phg_sudoku_solver 0.0.2 → 0.0.3

data/README.md

@@ -1,13 +1,15 @@
 # PhgSudokuSolver
 
-Welcome to the PHG Sudoku Solver gem.
+##A simple little gem for solving sudoku puzzles.##
 
-Miles Porter
-Senior Software Consultant
-Painted Harmony Group, Inc.
-mporter(AT)paintedharmony(DOT)com
+**Miles Porter**<br>
+**Senior Software Consultant**<br>
+**Painted Harmony Group, Inc.**<br>
+**mporter@paintedharmony.com**<br>
 
-"I first started doing Sudoku puzzles a few years ago while on a 3 hour plane flight. I was hooked. Eventually, I came
+
+# Background:
+I first started doing Sudoku puzzles a few years ago while on a 3 hour plane flight. I was hooked. Eventually, I came
 across a Sudoku that I could not do. I was completely frustrated, and the puzzle that I was working on was printed in a
 weekly newspaper and I didn't want to wait an entire week to see the solution. So, I did what any good software engineer
 would do... I decided to write a program/algorithm to solve the puzzle. At first, I tried the brute-force method of
@@ -34,84 +36,84 @@ Or install it yourself as:
 
 The following snipit illustrates show to use this gem (taken from tests, mind you.)
 
-± irb
-1.9.3p194 :001 > require 'phg_sudoku_solver'
- => true
-1.9.3p194 :002 >
-1.9.3p194 :003 >   a = [ "5xx4x67xx", "xxx5xx9xx", "2xxx17x4x", "xxx72xx1x", "9xxxxxxx8", "x7xx68xxx", "x3x27xxx5", "xx4xx3xxx","xx26x4xx3"]
- => ["5xx4x67xx", "xxx5xx9xx", "2xxx17x4x", "xxx72xx1x", "9xxxxxxx8", "x7xx68xxx", "x3x27xxx5", "xx4xx3xxx", "xx26x4xx3"]
-1.9.3p194 :004 >
-1.9.3p194 :005 >   s = Sudoku.new(a)
 
-[blah blah blah]
+Create a new Sudoku instance by passing in an array of 9 strings.  Each string needs to be 9 characters.  Any non-
+numeric character (1-9) is considered to be an unsolved cell.  You can use spaces, Xs or whatever you like.
 
-1.9.3p194 :010 > x = s.solve
+Call the `.solve` method on the sudoku instance that you create.
 
-[blah blah blah]
+To get the results of the solved sudoku, you can
+1)  Call the '.dump_known_cells_str' method, which will return a formatted string that represents the solved puzzle.
+2)  Iterate over the '.get_fixed_value(r,c)' method, where r and c represent the row and column.  The data returned
+    will be the value found for that cell.
 
-x.dump_known_cells_str
- => "\\n  5   1   8 |   4   9   6 |   7   3   2 \\n
-          6   4   7 |   5   3   2 |   9   8   1 \\n
-          2   9   3 |   8   1   7 |   5   4   6 \\n
-          ----------------------------------------\\n
-          3   8   5 |   7   2   9 |   6   1   4 \\n
-          9   2   6 |   1   4   5 |   3   7   8 \\n
-          4   7   1 |   3   6   8 |   2   5   9 \\n
-          ----------------------------------------\\n
-          8   3   9 |   2   7   1 |   4   6   5 \\n
-          1   6   4 |   9   5   3 |   8   2   7 \\n
-          7   5   2 |   6   8   4 |   1   9   3 \\n"
 
-        (Note:  The display has been cleaned up a bit above.)
+Example from irb...
 
-Notes:
-  Create a new Sudoku instance by passing in an array of 9 strings.  Each string needs to be 9 characters.  Any non-
-  numeric character (1-9) is considered to be an unsolved cell.  You can use spaces, Xs or whatever you like.
+<pre>
+require 'phg_sudoku_solver'
+a = [  "5xx4x67xx",
+       "xxx5xx9xx",
+       "2xxx17x4x",
+       "xxx72xx1x",
+       "9xxxxxxx8",
+       "x7xx68xxx",
+       "x3x27xxx5",
+       "xx4xx3xxx",
+       "xx26x4xx3"]
 
-  Call the .solve method on the sudoku instance that you create.
+s = Sudoku.new(a)
 
-  To get the results of the solved sudoku, you can
-  1)  Call the .dump_known_cells_str method, which will return a formatted string that represents the solved puzzle.
-  2)  Iterate over the .get_fixed_value(r,c) method, where r and c represent the row and column.  The data returned
-      will be the value found for that cell.
+x = s.solve
+
+x.dump_known_cells_str
 
-  WHEN SOMETHING GOES WRONG...  AND SOMETHING ALWAYS GOES WRONG...
+  5   1   8 |   4   9   6 |   7   3   2
+  6   4   7 |   5   3   2 |   9   8   1
+  2   9   3 |   8   1   7 |   5   4   6
+ ----------------------------------------
+  3   8   5 |   7   2   9 |   6   1   4
+  9   2   6 |   1   4   5 |   3   7   8
+  4   7   1 |   3   6   8 |   2   5   9
+ ----------------------------------------
+  8   3   9 |   2   7   1 |   4   6   5
+  1   6   4 |   9   5   3 |   8   2   7
+  7   5   2 |   6   8   4 |   1   9   3
+</pre>
+Note:  The display has been cleaned up a bit above.
 
-  1.  If the sudoku entered is invalid, the solve method will return an error.
+## WHEN SOMETHING GOES WRONG...  AND SOMETHING ALWAYS GOES WRONG...
 
- 1.9.3p194 :015 > a = ['123123123']
-  => ["123123123"]
- 1.9.3p194 :016 > s = Sudoku.new(a)
- Exception: Sudoku entered appears to be invalid.
- 	from /Users/miles_r_porter/.rvm/gems/ruby-1.9.3-p194/gems/phg_sudoku_solver-0.0.2/lib/phg_sudoku_solver.rb:47:in `initialize'
- 	from (irb):16:in `new'
- 	from (irb):16
- 	from /Users/miles_r_porter/.rvm/rubies/ruby-1.9.3-p194/bin/irb:16:in `<main>'
- 1.9.3p194 :017 >
+1.  If the sudoku entered is invalid, the solve method will return an error.
 
-  2.  Some sudoku are just to complex for the engine to compute a solution in the given maximum iterations
+<pre>
+a = ['123123123']
+s = Sudoku.new(a)
+Exception: Sudoku entered appears to be invalid.
+...
+</pre>
 
-  1.9.3p194 :018 >   a = ["123456789","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx"]
-   => ["123456789", "xxxxxxxxx", "xxxxxxxxx", "xxxxxxxxx", "xxxxxxxxx", "xxxxxxxxx", "xxxxxxxxx", "xxxxxxxxx", "xxxxxxxxx"]
-  1.9.3p194 :019 > s = Sudoku.new(a)
+2.  Some sudoku are just to complex for the engine to compute a solution in the given maximum iterations
 
-  [blah blah blah]
+<pre>
+a = ["123456789","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx","xxxxxxxxx"]
+s = Sudoku.new(a)
+x = s.solve
+Exception: Solution taking too long!
+</pre>
 
-  1.9.3p194 :020 > x = s.solve()
 
-  1.9.3p194 :012 > x = s.solve
-  Exception: Solution taking too long!\n\n
 
-  Note:  The number of iterations are checked after each recursion, so there total iterations may exceed the max
-  iterations set.
+Note:  The number of iterations are checked after each recursion, so there total iterations may exceed the max
+iterations set.  You can set the max iterations like this:
 
-  Oh...  and you can set the max iterations:
+`s.set_max_iterations(500)`
 
-  s.set_max_iterations(500)
+I have created a sample app running on Heroku (that includes a link to source code) that uses the gem...
 
-  for example.
+[Sample App Running On Heroku](https://sudoku-solver-2.herokuapp.com/)
 
-  More features will be released at some point.  Enjoy!
+More features will be released at some point.  Enjoy!
 
 
 ## Contributing

data/lib/phg_sudoku_solver.rb

@@ -83,11 +83,13 @@ class Sudoku
   def solve
     iteration=0
     no_progress_count = 0
+    print_debug 'Max Iterations = %s' %  @max_iterations
 
     while @solved_cell_count!=81
       iteration+=1
       @total_iterations+=1
       print_debug 'Iteration: %s   SolvedCells: %s\n' % [iteration, @solved_cell_count]
+      puts dump_known_cells_str
       compute_possible_values()
 
       begin
@@ -311,24 +313,26 @@ class Sudoku
 
   def recurse
     recurse = copy()
-    (0..8).each { |r|
-      (0..8).each { |c|
-        if (recurse.get_fixed_value(r, c)<=0) and (recurse.get_possible_values(r, c).count>0)
-          (0..recurse.get_possible_values(r, c).count).each { |j|
-            unless recurse.get_possible_values(r, c)[j].nil?
-              print_debug '\nStarting recursion with (%s,%s) set to %s\n' % [r, c, recurse.get_possible_values(r, c)[j]]
-              recurse.set_fixed_value(r, c, recurse.get_possible_values(r, c)[j])
-              print_debug('Recursion starting...')
-              recurse, iterations = recurse.solve
-              @total_iterations = @total_iterations + iterations
-              if recurse!=nil
-                return recurse
-              else
-                recurse = copy()
+    (2..8).each { |guesses|
+      (0..8).each { |r|
+        (0..8).each { |c|
+          if (recurse.get_possible_values(r, c).count==guesses)  #Staring with cells that have the fewest to solve.
+            (0..recurse.get_possible_values(r, c).count).each { |j|
+              unless recurse.get_possible_values(r, c)[j].nil?
+                print_debug '\nStarting recursion with (%s,%s) set to %s\n' % [r, c, recurse.get_possible_values(r, c)[j]]
+                recurse.set_fixed_value(r, c, recurse.get_possible_values(r, c)[j])
+                print_debug('Recursion starting...')
+                recurse, iterations = recurse.solve
+                @total_iterations = @total_iterations + iterations
+                if recurse!=nil
+                  return recurse
+                else
+                  recurse = copy()
+                end
               end
-            end
-          }
-        end
+            }
+          end
+        }
       }
     }
     print_debug('Dead end found.\n')
@@ -483,7 +487,7 @@ class Sudoku
 
   def print_debug(message)
     if @debug
-      print message
+      puts message + '\n'
     end
   end
 

data/lib/phg_sudoku_solver/version.rb

@@ -1,3 +1,3 @@
 module PhgSudokuSolver
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/test/sudoku_test.rb

@@ -19,7 +19,7 @@ class PhgSudokuSolverTest < Test::Unit::TestCase
 
   # Cell initialize
   def test_initialize_sudoku
-    a = ["5xx4x67xx",
+    a =  ["5xx4x67xx",
           "xxx5xx9xx",
           "2xxx17x4x",
           "xxx72xx1x",
@@ -386,22 +386,41 @@ class PhgSudokuSolverTest < Test::Unit::TestCase
   end
 
   def test_too_long_solve
-    a = [ "123 789 456",
-          "456 123 789",
-          "789 456 123",
+    a = [ "123789456",
+          "456123789",
+          "789456123",
 
-          "xxx xxx xxx",
-          "xxx xxx xxx",
-          "xxx xxx 231",
+          "xxxxxxxxx",
+          "xxxxxxxxx",
+          "xxxxxx231",
 
-          "xxx xxx xxx",
-          "xxx xxx xxx",
-          "xxx xxx xxx"]
+          "xxxxxxxxx",
+          "xxxxxxxxx",
+          "xxxxxxxxx"]
     s1 = Sudoku.new(a)
-    s1.set_max_iterations(100)
+    s1.set_max_iterations(10)
     self.assert_raise(Exception) {
       s1.solve() }
   end
 
+  def test_solve_super_hard
+    a = [ "xx8xx3xx5",
+          "xxxx4x9xx",
+          "x4x8xx7xx",
+          "xx3x5xx68",
+          "xxx462xxx",
+          "27xx3x4xx",
+          "xx4xx6x2x",
+          "xx1x9xxxx",
+          "8xx3xx6xx"]
+
+    s = Sudoku.new(a)
+    s.set_max_iterations(10000)
+    s.set_debug(true)
+    solved, total_iterations = s.solve()
+    puts "Got to here."
+    puts solved.dump_to_str
+    self.assert(solved.validate_sudoku, "Solved sudoku is invalid!!!")
+  end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phg_sudoku_solver
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Miles Porter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-10 00:00:00.000000000 Z
+date: 2015-03-17 00:00:00.000000000 Z
 dependencies: []
 description: A simple sudoku solving utility that uses two dimensional arrays and
   recursion.
@@ -51,17 +51,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.7
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A simple sudoku solving utility