boggle_solver 0.0.5 → 0.1.0

data/boggle_solver.gemspec

@@ -1,12 +1,9 @@
 Gem::Specification.new do |s|
   s.name          = "boggle_solver"
   s.summary       = "Find all words in a letter matrix"
-  s.description   = "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."
+  s.description   = "Ruby program that employs graph theory to solve a word matrix puzzle (Boggle)."
   s.requirements  = "[ 'An installed dictionary (most Unix systems have one)']"
-  s.version       = "0.0.5"
+  s.version       = "0.1.0"
   s.author        = "Casey Robinson"
   s.email         = "kc@rampantmonkey.com"
   s.homepage      = "http://rampantmonkey.com"

data/lib/boggle_solver/board.rb

@@ -143,6 +143,10 @@ module BoggleSolver
       Thread.current[:visited][u] = nil
     end
 
+    def score
+      @words.inject(0) { |points, w| points + w.length}
+    end
+
   end
 
 end

data/lib/boggle_solver/runner.rb

@@ -12,6 +12,7 @@ module BoggleSolver
       board = Board.new(@options.mode,@options.input,@options.dictionary)
       board.find_words
       p board.words
+      p board.score
     end
 
   end

data/pkg/boggle_solver-0.0.5/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/pkg/boggle_solver-0.0.5/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rubygems/package_task'
+spec = eval(File.read('boggle_solver.gemspec'))
+Gem::PackageTask.new(spec) do |pkg| end

data/pkg/boggle_solver-0.0.5/bin/boggle_solver

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

data/pkg/boggle_solver-0.0.5/boggle_solver.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name          = "boggle_solver"
+  s.summary       = "Find all words in a letter matrix"
+  s.description   = "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."
+  s.requirements  = "[ 'An installed dictionary (most Unix systems have one)']"
+  s.version       = "0.0.5"
+  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/pkg/boggle_solver-0.0.5/lib/boggle_solver/adjacency_matrix.rb

@@ -0,0 +1,52 @@
+module BoggleSolver
+
+  class AdjacencyMatrix
+    attr_reader :visited, :finished
+
+    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
+      adjacent(u).each { |v| depth_first_search_visit(v) if @visited[v].nil?}
+      @finished[u] = 1
+    end
+
+  end
+
+end

data/pkg/boggle_solver-0.0.5/lib/boggle_solver/board.rb

@@ -0,0 +1,148 @@
+require_relative 'adjacency_matrix'
+require 'thread'
+
+module BoggleSolver
+
+  class Board < AdjacencyMatrix
+    attr_reader :words
+
+    def initialize(mode=:default, input, dictionary_file)
+      super(25)
+      connect
+      @board = []
+      if mode == :random
+        @prng = Random.new
+        generate_random_board
+      elsif mode == :given
+        @board = input.split(//)
+      else
+        generate_board
+      end
+      calculate_board_hash
+      puts self
+      @words = []
+      set_dictionary dictionary_file
+      load_dictionary
+    end
+
+    def set_dictionary file
+      @dictionary_file = file
+    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 = ["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"]
+    end
+
+    def load_board_from_string s
+      @board = s.split(//) if s.length == 25
+    end
+
+    def generate_random_board
+      @board = Array.new(25)
+      @board.map!{|item| (65.+rand(25)).chr.downcase!}
+    end
+
+    def calculate_board_hash
+      @board_hash = Hash.new(0)
+      @board.each {|letter| @board_hash[letter]  += 1}
+    end
+
+    def load_dictionary
+      @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}
+      @words = @words.drop_while{|w| w.length < 3}
+    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/pkg/boggle_solver-0.0.5/lib/boggle_solver/options.rb

@@ -0,0 +1,42 @@
+require 'optparse'
+
+module BoggleSolver
+  class Options
+
+    DEFAULT_DICTIONARY = "/usr/share/dict/words"
+
+    attr_reader :dictionary, :mode, :input
+
+    def initialize(argv)
+      @dictionary = DEFAULT_DICTIONARY
+      @mode = :default
+      parse(argv)
+      @input = argv[0]
+      @mode = :given unless argv.empty?
+    end
+
+    def parse(argv)
+      OptionParser.new do |opts|
+        opts.banner = "Usage:   boggle_solver [ options ] "
+        opts.on("-d", "--dict path",  String, "Path to dictionary") do |dict|
+          @dictionary = dict
+        end
+        opts.on("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+        opts.on("-r", "--random", "Use a random board") do
+          @mode = :random
+        end
+
+        begin
+          argv = ["-r"] if argv.empty?
+          opts.parse!(argv)
+        rescue OptionParser::ParseError => e
+          STDERR.puts e.message, "\n", opts
+          exit(-1)
+        end
+      end
+    end
+  end
+end

data/pkg/boggle_solver-0.0.5/lib/boggle_solver/runner.rb

@@ -0,0 +1,19 @@
+require_relative 'board'
+require_relative 'options'
+
+module BoggleSolver
+
+  class Runner
+    def initialize(argv)
+      @options = Options.new(argv)
+    end
+
+    def run
+      board = Board.new(@options.mode,@options.input,@options.dictionary)
+      board.find_words
+      p board.words
+      p board.score
+    end
+
+  end
+end

data/pkg/boggle_solver-0.0.5/test/test_adjacency_matrix.rb

@@ -0,0 +1,93 @@
+require 'test/unit'
+require 'shoulda'
+require_relative '../lib/boggle_solver/adjacency_matrix'
+
+class TestAdjacencyMatrix < Test::Unit::TestCase
+
+  context "basics" do
+    setup do
+      @matrix = BoggleSolver::AdjacencyMatrix.new(4)
+    end
+
+    should "print matrix as square" do
+      assert_equal "0 0 0 0 \n0 0 0 0 \n0 0 0 0 \n0 0 0 0 ", @matrix.to_s
+    end
+  end
+
+  context "directed edges" do
+    setup do
+      @matrix = BoggleSolver::AdjacencyMatrix.new(4)
+    end
+
+    should "add one directed edge from v1 to v3" do
+      @matrix.add_directed_edge(1,3)
+      assert_equal "0 0 0 0 \n0 0 0 1 \n0 0 0 0 \n0 0 0 0 ", @matrix.to_s
+    end
+
+    should "add weighted directed edge from v3 to v1" do
+      @matrix.add_directed_edge(3,1, 7)
+      assert_equal "0 0 0 0 \n0 0 0 0 \n0 0 0 0 \n0 7 0 0 ", @matrix.to_s
+    end
+
+    should "store multiple directed edges" do
+      @matrix.add_directed_edge(2,1)
+      @matrix.add_directed_edge(3,1)
+      @matrix.add_directed_edge(0,3)
+      assert_equal "0 0 0 1 \n0 0 0 0 \n0 1 0 0 \n0 1 0 0 ", @matrix.to_s
+    end
+  end
+
+  context "undirected edges" do
+    setup do
+      @matrix = BoggleSolver::AdjacencyMatrix.new(4)
+    end
+
+    should "add undirected edge between v0 and v2" do
+      @matrix.add_edge(0,2)
+      assert_equal "0 0 1 0 \n0 0 0 0 \n1 0 0 0 \n0 0 0 0 ", @matrix.to_s
+    end
+
+    should "add weighted undirected edge between v0 and v2" do
+      @matrix.add_edge(0,2,8)
+      assert_equal "0 0 8 0 \n0 0 0 0 \n8 0 0 0 \n0 0 0 0 ", @matrix.to_s
+    end
+  end
+
+  context "adjacent" do
+    setup do
+      @n = 5
+      @matrix = BoggleSolver::AdjacencyMatrix.new(@n)
+    end
+
+    should "return empty array since no edges have been added" do
+      (0...@n).each { |i| assert_equal [], @matrix.adjacent(i)}
+    end
+
+    should "add 3 edges" do
+      @matrix.add_edge(0,1)
+      @matrix.add_edge(0,2)
+      @matrix.add_edge(0,4)
+      assert_equal [1,2,4], @matrix.adjacent(0)
+      assert_equal [0], @matrix.adjacent(1)
+      assert_equal [0], @matrix.adjacent(2)
+      assert_equal [], @matrix.adjacent(3)
+      assert_equal [0], @matrix.adjacent(4)
+    end
+  end
+
+  context "depth first search" do
+    setup do
+      @n = 5
+      @matrix = BoggleSolver::AdjacencyMatrix.new(@n)
+      @matrix.depth_first_search
+    end
+
+    should "visit all verticies" do
+      (0...@n).each { |i| assert_not_nil @matrix.visited[i] }
+    end
+
+    should "finish all verticies" do
+      (0...@n).each { |i| assert_not_nil @matrix.finished[i] }
+    end
+  end
+end

data/pkg/boggle_solver-0.0.5/test/test_board.rb

@@ -0,0 +1 @@
+

data/pkg/boggle_solver-0.0.5/test/test_options.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'shoulda'
+require_relative '../lib/boggle_solver/options'
+
+class TestOptions < Test::Unit::TestCase
+
+  context "specifying nothing" do
+    setup do
+      @opts = BoggleSolver::Options.new([])
+    end
+
+    should "return default dictionary" do
+      assert_equal BoggleSolver::Options::DEFAULT_DICTIONARY, @opts.dictionary
+    end
+
+    should "set mode to random" do
+      assert_equal @opts.mode, :random
+    end
+  end
+
+  context "specifying a dictionary" do
+    should "return it" do
+      opts = BoggleSolver::Options.new(["-d", "mydict"])
+      assert_equal "mydict", opts.dictionary
+    end
+  end
+
+  context "specifying the board with a string and nothing else" do
+    should "return the board" do
+      opts = BoggleSolver::Options.new(["abcdefghijklmnopqrstuvwxy"])
+      assert_equal "abcdefghijklmnopqrstuvwxy", opts.input
+      assert_equal opts.mode, :given
+    end
+  end
+
+  context "specifying the board with a string and an extra word" do
+    should "return only the board" do
+      opts = BoggleSolver::Options.new(["abcdefghijklmnopqrstuvwxy", "extra stuff"])
+      assert_equal "abcdefghijklmnopqrstuvwxy", opts.input
+      assert_equal opts.mode, :given
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: boggle_solver
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Casey Robinson
@@ -11,16 +11,7 @@ bindir: bin
 cert_chain: []
 date: 2012-05-26 00:00:00.000000000Z
 dependencies: []
-description: ! '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.'
+description: Ruby program that employs graph theory to solve a word matrix puzzle (Boggle).
 email: kc@rampantmonkey.com
 executables:
 - boggle_solver
@@ -35,6 +26,18 @@ files:
 - lib/boggle_solver/board.rb
 - lib/boggle_solver/options.rb
 - lib/boggle_solver/runner.rb
+- pkg/boggle_solver-0.0.5.gem
+- pkg/boggle_solver-0.0.5/boggle_solver.gemspec
+- pkg/boggle_solver-0.0.5/Rakefile
+- pkg/boggle_solver-0.0.5/README.markdown
+- pkg/boggle_solver-0.0.5/bin/boggle_solver
+- pkg/boggle_solver-0.0.5/lib/boggle_solver/adjacency_matrix.rb
+- pkg/boggle_solver-0.0.5/lib/boggle_solver/board.rb
+- pkg/boggle_solver-0.0.5/lib/boggle_solver/options.rb
+- pkg/boggle_solver-0.0.5/lib/boggle_solver/runner.rb
+- pkg/boggle_solver-0.0.5/test/test_adjacency_matrix.rb
+- pkg/boggle_solver-0.0.5/test/test_board.rb
+- pkg/boggle_solver-0.0.5/test/test_options.rb
 - test/test_adjacency_matrix.rb
 - test/test_board.rb
 - test/test_options.rb