boggler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86259e476a7f531b684261ce5062509d9500c37e
+  data.tar.gz: 7da27f1ea047c7fad9a7fa8690980435b2368b13
+SHA512:
+  metadata.gz: b1b71f7431211d276e4a96283ab96c674e363ccb1a37eb14a6670aaa9e95ef4cc0186a0f664b1c2d3d213da2a1b04cb55a3eafc9b64f19e38d06acf3cbd5cd9b
+  data.tar.gz: 5653dfac6b0ba0daec843046192aa99b8accaf37b8039766cd2495c03e5367e0d7a01883de09cd380e8e6aafc49ecf9a5341876db7fd3c09baa7785c66e557b5

checksums.yaml.gz.sig

@@ -0,0 +1,4 @@
+��Z�A���s9Q�`��ڸ�߳�vNU:2��CW���n�-�a/��>73���j�8��B��9�\��J+Rq����V<�dZ��
�Z_�%'NO�zk�m
+�(W��ΆƎ���m�oU��
+�;�*�4�tX���;lƠe��9�-
]A��.�V��v�H86��
+r��‘dd��7K�<�ӓ[iA��I_5MS�S��l�j

data.tar.gz.sig

@@ -0,0 +1,3 @@
+����V��
���L���غ�(�J�²��e��Û�I��W���H!A�I���ڠ��o�p�2�
+��g�4���յم1k�,g�ac=�-Q��(g|]�W�w�6s�f����wN��J�c�:�e㺄�K]���I*(焉�T�=Z_�N똥�h@5��E=|w{+Z���o��9
+��l�T��u�yZnRHr��Gt����݀x�D;�m��u���7/�`4��F[`H�,�>�n<

data/bin/boggler

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../lib/boggler', __FILE__)
+Boggler::Core.game

data/bin/boggler_solver

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../lib/boggler', __FILE__)
+Boggler::Core.run

data/lib/boggler.rb

@@ -0,0 +1,24 @@
+require 'set'
+
+module Boggler
+  extend self
+
+  def load
+    require File.join(load_path, 'core')
+    require File.join(load_path, 'die')
+    require File.join(load_path, 'dice')
+    require File.join(load_path, 'grid')
+    require File.join(load_path, 'cell')
+    require File.join(load_path, 'dictionary')
+    require File.join(load_path, 'benchmarking')
+    require File.join(load_path, 'solver')
+  end
+
+  private
+
+  def load_path
+    @load_path ||= File.expand_path('../boggler', __FILE__)
+  end
+end
+
+Boggler.load

data/lib/boggler/benchmarking.rb

@@ -0,0 +1,15 @@
+require 'benchmark'
+
+module Boggler
+  module Benchmarking
+    extend self
+
+    def measure(description, &block)
+      benchmark_format = "%n\t#{Benchmark::FORMAT}"
+
+      puts Benchmark.measure(description) {
+        yield if block_given?
+      }.format(benchmark_format)
+    end
+  end
+end

data/lib/boggler/cell.rb

@@ -0,0 +1,95 @@
+module Boggler
+  class Cell
+    attr_reader :row, :column, :letter, :word, :previous
+
+    MOVES = [
+      [-1, -1],
+      [-1,  0],
+      [-1,  1],
+      [ 0, -1],
+      [ 0,  1],
+      [ 1, -1],
+      [ 1,  0],
+      [ 1,  1],
+    ]
+
+    def initialize(
+        grid, row, column, dictionary = nil, used = nil, previous = nil)
+      @row    = row
+      @column = column
+      @letter = grid[row - 1][column - 1]
+      @grid   = grid
+      @previous = previous
+      @dictionary = dictionary || Dictionary.words
+
+      set_used used
+      @used[row][column] = true
+
+      @word = ((previous && previous.word) || '') + @letter
+      set_dictionary
+    end
+
+    def next_cell
+      begin
+        iterator.next
+      rescue StopIteration
+        nil
+      end
+    end
+
+    def valid_word?
+      !!@dictionary['']
+    end
+
+    def possible_word?
+      !!@dictionary
+    end
+
+    private
+
+    def set_dictionary
+      case word.length
+      when 1, 2
+        @dictionary = {}
+      when 3
+        @dictionary = Dictionary.words[@word]
+      else
+        @dictionary = @dictionary[@word[-1]]
+      end
+    end
+
+    def set_used(used)
+      @used = used && used.dup
+      @used ||= {}
+
+      @grid.size.times do |i|
+        row = used && used[i + 1] && used[i + 1].dup
+        @used[i + 1] = row || {}
+      end
+    end
+
+    def iterator
+      @iterator ||= neighbors.each
+    end
+
+    def neighbors
+      return @neighbors if @neighbors
+
+      @neighbors = []
+
+      MOVES.each do |move|
+        next_row    = row + move.first
+        next_column = column + move.last
+
+        if next_row > 0 && next_row <= @grid.size &&
+            next_column > 0 && next_column <= @grid.size &&
+            !@used[next_row][next_column]
+          @neighbors << Cell.new(
+            @grid, next_row, next_column, @dictionary, @used, self)
+        end
+      end
+
+      @neighbors
+    end
+  end
+end

data/lib/boggler/core.rb

@@ -0,0 +1,41 @@
+module Boggler
+  module Core
+    extend self
+
+    def run
+      start
+      Solver.solve @grid
+    end
+
+    def game
+      start
+
+      time = Time.now
+      Dictionary.words
+      while Time.now - time < 3 * 60 do
+      end
+
+      puts "\n" * 100
+
+      Solver.solve @grid
+    end
+
+    def seed
+      return @seed if defined?(@seed)
+      #@seed = 7567 # postdated appears
+      #@seed = 532183 # used for construction of grid word construction
+      @seed = rand(999_999)
+      srand @seed
+      @seed
+    end
+
+    private
+
+    def start
+      seed
+      puts "Randomized with seed #{seed}"
+      @grid = Grid.new
+      puts @grid.to_s
+    end
+  end
+end

data/lib/boggler/dice.rb

@@ -0,0 +1,83 @@
+module Boggler
+  module Dice
+    extend self
+
+    BOGGLE_DICE = [
+      Die.new(%W{a a c i o t}),
+      Die.new(%W{a h m o r s}),
+      Die.new(%W{e g k l u y}),
+      Die.new(%W{a b i l t y}),
+      Die.new(%W{a c d e m p}),
+      Die.new(%W{e g i n t v}),
+      Die.new(%W{g i l r u w}),
+      Die.new(%W{e l p s t u}),
+      Die.new(%W{d e n o s w}),
+      Die.new(%W{a c e l r s}),
+      Die.new(%W{a b j m o q}),
+      Die.new(%W{e e f h i y}),
+      Die.new(%W{e h i n p s}),
+      Die.new(%W{d k n o t u}),
+      Die.new(%W{a d e n v z}),
+      Die.new(%W{b i f o r x}),
+    ]
+
+    STATIC_BOGGLE = [
+      Die.new(%W{e g i n t v}),
+      Die.new(%W{e l p s t u}),
+      Die.new(%W{a b j m o q}),
+      Die.new(%W{e h i n p s}),
+      Die.new(%W{d k n o t u}),
+      Die.new(%W{a d e n v z}),
+      Die.new(%W{b i f o r x}),
+    ].shuffle
+
+    STATIC_DICE = [
+      Die.new(['h']),
+      Die.new(['e']),
+      Die.new(['a']),
+      Die.new(['r']),
+      STATIC_BOGGLE[0],
+      Die.new(['o']),
+      Die.new(['r']),
+      STATIC_BOGGLE[1],
+      STATIC_BOGGLE[2],
+      STATIC_BOGGLE[3],
+      Die.new(['m']),
+      STATIC_BOGGLE[4],
+      STATIC_BOGGLE[5],
+      STATIC_BOGGLE[6],
+      Die.new(['y']),
+      Die.new(['e']),
+    ]
+
+    def get(opts = {})
+      opts ||= {}
+
+      case opts[:method]
+      when :random
+        random_dice
+      when :boggle
+        BOGGLE_DICE.shuffle
+      when :big_boggle
+        [
+          BOGGLE_DICE.shuffle,
+          BOGGLE_DICE.shuffle,
+          BOGGLE_DICE.shuffle,
+          BOGGLE_DICE.shuffle,
+        ].flatten
+      when :static
+        STATIC_DICE
+      else
+        BOGGLE_DICE.shuffle
+      end
+    end
+
+    private
+
+    def random_dice
+      16.times.map do
+        Die.new
+      end
+    end
+  end
+end

data/lib/boggler/dictionary.rb

@@ -0,0 +1,76 @@
+module Boggler
+  module Dictionary
+    extend self
+
+    def words
+      return @words if defined?(@words)
+
+      content = nil
+
+      Benchmarking.measure('dictionary') do
+        path = File.expand_path('../../../vendor/dictionary.txt', __FILE__)
+        content = File.read(path)
+        content = content.split("\n")
+        @words = words_to_hash(content)
+      end
+
+      @words
+    end
+
+    def words_to_hash(words)
+      hash = {}
+
+      words.each do |word|
+        word = word.split('')
+
+        key = word[0..2].join
+        letters = word[3..-1]
+
+        merge_word hash, key, word_to_hash(letters)
+      end
+
+      hash
+    end
+
+    private
+
+    def merge_word(hash, key, word_hash)
+      if hash[key]
+        merge_word_hash hash[key], word_hash
+      else
+        hash[key] = word_hash
+      end
+    end
+
+    def merge_word_hash(hash, word_hash)
+      hash.merge!(word_hash) do |key, old_value, new_value|
+        if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+          merge_word_hash(old_value, new_value)
+        else
+          old_value || new_value
+        end
+      end
+    end
+
+    def word_to_hash(letters)
+      if letters.empty?
+        {'' => true}
+      else
+        letters_to_hash({}, letters)
+      end
+    end
+
+    def letters_to_hash(hash = {}, letters = [])
+      hash ||= {}
+      letters.each_with_index do |letter, i|
+        if letters.length > 1
+          hash[letter] = letters_to_hash(hash[letter], letters[(i + 1)..-1])
+          return hash
+        else
+          hash[letter] = {'' => true}
+          return hash
+        end
+      end
+    end
+  end
+end

data/lib/boggler/die.rb

@@ -0,0 +1,18 @@
+module Boggler
+  class Die
+    def initialize(sides = [])
+      @sides = sides || []
+      @sides << random_letter if sides.empty?
+    end
+
+    def roll
+      @sides.sample
+    end
+
+    private
+
+    def random_letter
+      rand(10...36).to_s 36
+    end
+  end
+end

data/lib/boggler/grid.rb

@@ -0,0 +1,94 @@
+module Boggler
+  class Grid
+    def initialize
+      @grid = []
+
+      @dice = Dice.get
+      @size = Math.sqrt(@dice.length).to_i
+
+      build_grid
+    end
+
+    def to_s
+      row_strings = []
+
+      @grid.each do |row|
+        row_strings << row_string_for(row)
+      end
+
+      grid_string = separator
+      row_strings.each do |row|
+        grid_string += row
+        grid_string += separator
+      end
+
+      grid_string
+    end
+
+    def words
+      return @words if defined?(@words)
+
+      @words = []
+
+      @size.times do |i|
+        @size.times do |j|
+          words_starting_at(i + 1, j + 1)
+        end
+      end
+
+      @words
+    end
+
+    private
+
+    def words_starting_at(row, column)
+      start_cell = Cell.new(@grid, row, column)
+      words_from_cell start_cell
+    end
+
+    def words_from_cell(cell)
+      @words << cell.word if cell.valid_word?
+      next_cell = next_possible_cell(cell)
+      words_from_cell(next_cell) if next_cell
+    end
+
+    def next_possible_cell(cell)
+      return unless cell
+      candidate = cell && cell.next_cell
+      while candidate && !candidate.possible_word?
+        candidate = cell.next_cell
+      end
+
+      return candidate if candidate
+
+      next_possible_cell cell.previous
+    end
+
+    def build_grid
+      letters = []
+
+      @dice.each_with_index do |die, i|
+        if i % @size == 0
+          @grid << letters unless letters.empty?
+          letters = []
+        end
+
+        letters << die.roll
+      end
+
+      @grid << letters
+    end
+
+    def row_string_for(row)
+      row_string = '|'
+      row.each do |cell|
+        row_string += " #{cell.upcase} |"
+      end
+      row_string + "\n"
+    end
+
+    def separator
+      @sep ||= '-' + ('-' * (4 * @size)) + "\n"
+    end
+  end
+end