boggle_solver 0.0.1

data/README.markdown

@@ -0,0 +1,59 @@
+Ruby program that employs graph theory to solve a word matrix puzzle (Boggle).
+
+# Introduction
+Boggle Master consists of a 5x5 grid of letters. The goal of the game is to make as many words as possible from this grid by connecting neighboring letters. To generate a random puzzle the game uses 25 dice with letters on each side. The dice are shaken and each fall into a slot in the grid.
+
+# Example Grid
+
+Below is an example grid. One possible word in this graph is `wear`. Arrows are added for convenience.
+
+     J   O   X   T   Y
+
+     A   C   D   F   P
+
+     Y   K   B   E   O
+
+     A   M   G   P   W
+                     |
+     D   S   R<--A<--E
+
+The goal of this project is to find all possible words. Mostly to serve as a benchmark with which to compare my performance.
+
+
+# Coordinate System
+Below are the indicies used to represent the dice in the board:
+
+     0   1   2   3   4
+     5   6   7   8   9
+    10  11  12  13  14
+    15  16  17  18  19
+    20  21  22  23  24
+
+# Connection Matrix
+Adjacency matrix representing the connections in Boggle:
+
+    0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+    1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+    0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+    0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+    0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+    1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
+    1 1 1 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0
+    0 1 1 1 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0
+    0 0 1 1 1 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0
+    0 0 0 1 1 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0
+    0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0
+    0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0
+    0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0
+    0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0
+    0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0
+    0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0
+    0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 1 1 1 0 0
+    0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 1 1 1 0
+    0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 1 1 1
+    0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 1 1
+    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0
+    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0
+    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0
+    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1
+    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0

data/bin/boggle_solver

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'boggle_solver/runner'
+
+runner = BoggleSolver::Runner.new(ARGV)
+runner.run

data/boggle_solver.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name          = "boggle_solver"
+  s.summary       = "Find all words in a letter matrix"
+  s.description   = "File.read(File.join(File.dirname(__FILE__), 'README'))"
+  s.requirements  = "[ 'An installed dictionary (most Unix systems have one)']"
+  s.version       = "0.0.1"
+  s.author        = "Casey Robinson"
+  s.email         = "kc@rampantmonkey.com"
+  s.homepage      = "http://rampantmonkey.com"
+  s.platform      = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.9'
+  s.files         = Dir['**/**']
+  s.executables   = [ 'boggle_solver' ]
+  s.test_files    = Dir["test/test*.rb"]
+  s.has_rdoc      = false
+end

data/lib/boggle_solver/adjacency_matrix.rb

@@ -0,0 +1,52 @@
+module BoggleSolver
+
+  class AdjacencyMatrix
+
+    def initialize( n = 2 )
+      @m = Array.new(n, 0)
+      @m.map!{Array.new(n, 0)}
+      @n = n
+    end
+
+    def to_s
+      s = ""
+      @m.each do |row|
+        row.each {|e| s += e.to_s + " "}
+        s += "\n"
+      end
+      s.chop
+    end
+
+    def add_directed_edge(i, j, w=1)
+      @m[i][j] = w unless i == j
+    end
+
+    def add_edge(i, j, w=1)
+      add_directed_edge(i, j, w)
+      add_directed_edge(j, i, w)
+    end
+
+    def adjacent(u)
+      a = Array.new
+      @m[u].each_with_index {|v,i| a.push i unless v == 0 }
+      a
+    end
+
+    def depth_first_search
+      @visited  = Array.new(@n, nil)
+      @finished = Array.new(@n, nil)
+      @visited.each_with_index do |visit_status, u|
+        depth_first_search_visit(u) if visit_status.nil?
+      end
+    end
+
+    def depth_first_search_visit(u, *)
+      @visited[u] = 1
+      puts u
+      adjacent(u).each { |v| depth_first_search_visit(v) if @visited[v].nil?}
+      @finished[u] = 1
+    end
+
+  end
+
+end

data/lib/boggle_solver/board.rb

@@ -0,0 +1,124 @@
+require_relative 'adjacency_matrix'
+require 'thread'
+
+module BoggleSolver
+
+  class Board < AdjacencyMatrix
+    attr_reader :words
+
+    def initialize
+      super(25)
+      connect
+      @board = []
+#       @prng = Random.new
+      @words = []
+      generate_board
+      load_dictionary
+    end
+
+    def connect
+      j=0;
+      while j<25 do
+        add_edge(j, j-6) unless j < 6 or j % 5 == 0
+        add_edge(j, j-5) unless j < 5
+        add_edge(j, j-4) unless j < 4 or j % 5 == 4
+        add_edge(j, j-1) unless j % 5 == 0
+        add_edge(j, j+1) unless j % 5 == 4
+        add_edge(j, j+4) unless j > 19 or j % 5 == 0
+        add_edge(j, j+5) unless j > 19
+        add_edge(j, j+6) unless j > 18 or j % 5 == 4
+        j += 1
+      end
+    end
+
+    def generate_board
+  #     @board.map!{|item| (65.+rand(25)).chr}
+    @board = ["a", "r", "t", "a", "c", "c", "e", "a", "r", "d", "f", "e", "w", "o", "o", "n", "p", "l", "m", "i", "c", "r", "u", "b", "l"]
+    @board_hash = Hash.new(0)
+    @board.each {|letter| @board_hash[letter]  += 1}
+    end
+
+    def load_dictionary
+      dictionary_file = "/usr/share/dict/words"
+      @dictionary = Array.new
+
+      File.foreach(dictionary_file) do |line|
+        next_word = line.chomp
+        @dictionary.push next_word if possible? next_word
+      end
+    end
+
+    def possible? word
+      word_hash = Hash.new(0)
+      result = true
+      word.each_char {|letter| word_hash[letter] += 1}
+      word_hash.each do |letter, count|
+        result &&= count <= @board_hash[letter]
+      end
+      result
+    end
+
+    def to_s
+      s = ""
+      @board.each_with_index do |letter, index|
+        s += letter.to_s + " "
+        s += "\n" if index % 5 == 4
+      end
+      s.chomp
+    end
+
+    def in_dictionary? s
+      @dictionary.index s
+    end
+
+    def part_in_dictionary? s
+      s = "\\A" + s + "..*"
+      regex = Regexp.new(s)
+      !(@dictionary.grep regex).empty?
+    end
+
+    def find_words
+      threads = []
+      @board.each_with_index do |letter, index|
+        threads << Thread.new { depth_first_search(index) }
+      end
+
+      threads.each do |t|
+        t.join
+        @words.concat t[:words]
+      end
+
+      @words.uniq!
+      @words.sort_by!{|item| item.length}
+    end
+
+    def depth_first_search(offset=0)
+      Thread.current[:visited] = Array.new(@n, nil)
+      Thread.current[:finished] = Array.new(@n, nil)
+      Thread.current[:words] = []
+      Thread.current[:visited][offset..-1].each_with_index do |visit_status, u|
+        u += offset
+        search_string = @board[u]
+        depth_first_search_visit(u, search_string) if Thread.current[:finished][u].nil?
+      end
+    end
+
+    def depth_first_search_visit(u, search_string)
+      Thread.current[:visited][u] = 1
+      Thread.current[:words] << search_string if in_dictionary? search_string
+      adjacent(u).each do |v|
+        if Thread.current[:visited][v].nil?
+          s = search_string + @board[v]
+          Thread.current[:words].push s if in_dictionary? s
+          if part_in_dictionary? s
+            depth_first_search_visit(v, s)
+          end
+        end
+      end
+      Thread.current[:finished][u] = 1
+      Thread.current[:visited][u] = nil
+    end
+
+  end
+
+end

data/lib/boggle_solver/runner.rb

@@ -0,0 +1,17 @@
+require_relative 'board'
+
+module BoggleSolver
+
+  class Runner
+    def initialize(argv)
+      #Parse options here
+    end
+
+    def run
+      board = Board.new
+      board.find_words
+      p board.words
+    end
+
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: boggle_solver
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.1
+platform: ruby
+authors:
+- Casey Robinson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-05-15 00:00:00.000000000Z
+dependencies: []
+description: File.read(File.join(File.dirname(__FILE__), 'README'))
+email: kc@rampantmonkey.com
+executables:
+- boggle_solver
+extensions: []
+extra_rdoc_files: []
+files:
+- boggle_solver-0.0.1.gem
+- boggle_solver.gemspec
+- README.markdown
+- bin/boggle_solver
+- lib/boggle_solver/adjacency_matrix.rb
+- lib/boggle_solver/board.rb
+- lib/boggle_solver/runner.rb
+homepage: http://rampantmonkey.com
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements:
+- ! '[ ''An installed dictionary (most Unix systems have one)'']'
+rubyforge_project:
+rubygems_version: 1.8.15
+signing_key:
+specification_version: 3
+summary: Find all words in a letter matrix
+test_files: []
+...