phg_sudoku_solver 0.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in phg_sudoku_solver.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Miles Porter
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# PhgSudokuSolver
+
+Welcome to the PHG Sudoku Solver gem.
+
+Miles Porter
+Senior Software Consultant
+Painted Harmony Group, Inc.
+mporter(AT)paintedharmony(DOT)com
+
+"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
+plugging in random numbers. I quickly discovered that would never work because there are just too many combinations...
+I continued to think about how to write code to solve Sudoku puzzles. There are, of course, countless sites and free
+software that provide solutions to the problem. I wanted, however, to see if I could do it myself. The result of that
+effort is what you see in front fo you. The code uses a number of different techniques to try and deduce what values
+can be inferred by the puzzle. After all the inferred cells are set, the program uses recursion to complete the puzzle.
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'phg_sudoku_solver'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install phg_sudoku_solver
+
+## Usage
+
+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]
+
+1.9.3p194 :010 > x = s.solve
+
+[blah blah blah]
+
+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.)
+
+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.
+
+  Call the .solve method on the sudoku instance that you create.
+
+  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.
+
+  WHEN SOMETHING GOES WRONG...  AND SOMETHING ALWAYS GOES WRONG...
+
+  1.  If the sudoku entered is invalid, the solve method will return an error.
+
+ 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 >
+
+  2.  Some sudoku are just to complex for the engine to compute a solution in the given maximum iterations
+
+  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)
+
+  [blah blah blah]
+
+  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.
+
+  Oh...  and you can set the max iterations:
+
+  s.set_max_iterations(500)
+
+  for example.
+
+  More features will be released at some point.  Enjoy!
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/phg_sudoku_solver/cell.rb

@@ -0,0 +1,65 @@
+#
+# Cell.rb
+#
+# Created on September 23, 2013
+#
+# A class that contains the logic for a single cell in a sudoku puzzle.
+#
+
+class Cell
+
+  def initialize *args
+    @fixed_value = -1
+    @possible_values = []
+    if args.size==1
+      case args[0].class.to_s
+        when "Array"
+          @possible_values = args[0]
+        when "Fixnum"
+          @fixed_value = args[0]
+      end
+    end
+  end
+
+
+  def reset_possible_values()
+    @possible_values = []
+  end
+
+  def add_possible_value(val)
+    @possible_values.push(val)
+    if @possible_values.count > 1
+      @fixed_value = -1
+    end
+  end
+
+  def set_possible_values(val)
+    @possible_values = val
+  end
+
+  def set_fixed_value(val)
+    @fixed_value = val
+    if val>0
+      @possible_values = []
+    end
+  end
+
+  def get_fixed_value()
+    @fixed_value
+  end
+
+  def get_possible_values()
+    @possible_values
+  end
+
+  def contains_possible_value(x)
+    @possible_values.include?(x)
+  end
+
+  def copy()
+    c = Cell.new()
+    c.set_fixed_value(@fixed_value)
+    c.set_possible_values(@possible_values)
+    c
+  end
+end

data/lib/phg_sudoku_solver/version.rb

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

data/lib/phg_sudoku_solver.rb

@@ -0,0 +1,491 @@
+require 'phg_sudoku_solver/version'
+require 'phg_sudoku_solver/cell'
+#
+# Sudoku.rb
+#
+# Created on September 23, 2013
+#
+#
+
+class Sudoku
+
+  def set_max_iterations(iterations)
+    @max_iterations=iterations
+  end
+
+  def set_total_iterations(iterations)
+    @total_iterations = iterations
+  end
+
+  def initialize (*args)
+    @total_iterations = 0
+    @max_iterations = 100000
+    @debug = false
+    @cells = Array.new(9) { Array.new(9) }
+
+    if args.size==1
+      (0..8).each { |row|
+        if args[0][row].is_a?(String)
+          (0..8).each { |col|
+            val = args[0][row][col]
+            if /[0-9]/.match(val)
+              @cells[row][col] = Cell.new(val.to_i)
+            else
+              @cells[row][col] = Cell.new()
+            end
+          }
+        end
+      }
+    elsif args.size==0
+      (0..8).each { |row|
+        (0..8).each { |col|
+          @cells[row][col] = Cell.new()
+        }
+      }
+    end
+    unless self.validate_sudoku
+      raise Exception.new('Sudoku entered appears to be invalid.')
+    end
+  end
+
+  def get_cells
+    @cells
+  end
+
+  def set_cells(row, col, cell)
+    @cells[row][col]=cell
+  end
+
+  def get_fixed_value(row, col)
+    @cells[row][col].get_fixed_value()
+  end
+
+  def set_fixed_value(row, col, val)
+    @cells[row][col].set_fixed_value(val)
+  end
+
+  def set_possible_values(row, col, vals)
+    @cells[row][col].set_possible_values(vals)
+  end
+
+  def add_possible_value(row, col, val)
+    @cells[row][col].add_possible_value(val)
+  end
+
+  def get_possible_values(row, col)
+    @cells[row][col].get_possible_values
+  end
+
+  def get_total_iterations
+    @total_iterations
+  end
+
+  def solve
+    iteration=0
+    no_progress_count = 0
+
+    while @solved_cell_count!=81
+      iteration+=1
+      @total_iterations+=1
+      print_debug 'Iteration: %s   SolvedCells: %s\n' % [iteration, @solved_cell_count]
+      compute_possible_values()
+
+      begin
+        if validate_sudoku()
+          find_row_implied_values()
+          find_col_implied_values()
+          find_matrix_implied_values()
+        else
+          return nil, @total_iterations
+        end
+      rescue Exception => error
+        print_debug '\nValidation Error: %s\n' % error
+        @solved_cell_count=count_fixed_cells()
+        return nil, @total_iterations
+      end
+
+      if @total_iterations > @max_iterations
+        print_debug 'Total Iterations... %s\n' % @total_iterations
+        print_debug 'This is just taking too long\n'
+        raise Exception.new('Solution taking too long!\n\n')
+      end
+
+      if @solved_cell_count==count_fixed_cells()
+        no_progress_count+=1
+        if no_progress_count>9
+          print_debug ('We''re not making progress here!')
+          solution = recurse()
+          return solution, @total_iterations
+        end
+      else
+        no_progress_count=0
+        @solved_cell_count=count_fixed_cells()
+      end
+    end
+    return self, @total_iterations
+  end
+
+  def count_fixed_cells
+    fixed_cell_count=0
+
+    @cells.each() do |row|
+      row.each() do |cell|
+        fixed_cell_count = fixed_cell_count + 1 if cell.get_fixed_value != -1
+      end
+    end
+    fixed_cell_count
+  end
+
+  def find_row_implied_values
+
+    (1..9).each { |i|
+      (0..8).each { |r|
+        fixed_count = 0
+        variable_count = 0
+        temp_row = -1
+        temp_col = -1
+        (0..8).each { |c|
+          # Start by counting up fixed values for the given number i.  (e.g. How many of i do we have?)
+          if @cells[r][c].get_fixed_value()==i
+            fixed_count+=1
+          end
+
+          #  We are checking to see if there is only one i in the possible values for this row.
+          #  If so, then we will set the fixed value in the cell contains it.
+          (0..@cells[r][c].get_possible_values().count).each { |j|
+            if @cells[r][c].get_possible_values()[j]==i
+              variable_count+=1
+              temp_row = r
+              temp_col = c
+            end
+          }
+
+        }
+        if (fixed_count==0) and (variable_count==1)
+          @cells[temp_row][temp_col].set_fixed_value(i)
+        end
+
+        if fixed_count>1
+          raise('Duplicate fixed values in row check.  Make sure you entered correct values.')
+        end
+      }
+    }
+  end
+
+  def find_col_implied_values
+    (1..9).each { |i|
+      (0..8).each { |c|
+        fixed_count = 0
+        variable_count = 0
+        temp_row = -1
+        temp_col = -1
+        (0..8).each { |r|
+          if @cells[r][c].get_fixed_value()==i
+            fixed_count+=1
+          end
+
+          (0..@cells[r][c].get_possible_values().count).each { |j|
+            if @cells[r][c].get_possible_values()[j]==i
+              variable_count+=1
+              temp_row = r
+              temp_col = c
+            end
+          }
+
+        }
+        if (fixed_count==0) and (variable_count==1)
+          @cells[temp_row][temp_col].set_fixed_value(i)
+        end
+
+        if fixed_count>1
+          raise('Duplicate fixed value in column check.  Make sure you entered correct values.')
+        end
+      }
+    }
+  end
+
+  def find_matrix_implied_values
+    # In each sub-matrix we check for implied values (i) one at a time...
+    [0, 3, 6].each { |row_start|
+      [0, 3, 6].each { |col_start|
+        (1..9).each { |i|
+          temp_row = 0
+          temp_col = 0
+          fixed_count = 0
+          variable_count = 0
+          (row_start..row_start+2).each { |r|
+            (col_start..col_start+2).each { |c|
+
+              if @cells[r][c].get_fixed_value()==i
+                fixed_count+=1
+              end
+
+              (0..@cells[r][c].get_possible_values().count).each { |j|
+                if @cells[r][c].get_possible_values()[j]==i
+                  variable_count+=1
+                  temp_row = r
+                  temp_col = c
+                end
+              }
+            }
+          }
+
+          if (fixed_count==0) and (variable_count==1)
+            @cells[temp_row][temp_col].set_fixed_value(i)
+          end
+
+          if fixed_count>1
+            raise('Duplicate fixed value in matrix check.  Make sure you entered correct values.')
+          end
+        }
+      }
+    }
+  end
+
+
+  def compute_possible_values
+
+    (0..8).each { |r|
+      (0..8).each { |c|
+        if @cells[r][c].get_fixed_value()<=0
+          @cells[r][c].reset_possible_values()
+
+          (1..9).each { |possible_value|
+            if check_row_value(r, c, possible_value) and check_col_value(r, c, possible_value) and check_matrix_value(r, c, possible_value)
+              add_possible_value(r, c, possible_value)
+            end
+
+          }
+          if @cells[r][c].get_possible_values().count==1
+            fixed_val = @cells[r][c].get_possible_values()[0]
+            @cells[r][c].set_fixed_value(fixed_val)
+            print_debug 'Resetting possible values...'
+            @cells[r][c].reset_possible_values()
+          elsif @cells[r][c].get_possible_values().count>1
+            @cells[r][c].set_fixed_value(-1)
+          end
+        end
+      }
+    }
+  end
+
+  def check_row_value(row, col, val)
+    result = true
+    (0..8).each { |current_column|
+      if current_column!=col
+        if @cells[row][current_column].get_fixed_value()==val
+          result = false
+        end
+      end
+    }
+    result
+  end
+
+  def check_col_value(row, col, val)
+    result = true
+    (0..8).each { |r|
+      if r!=row
+        if @cells[r][col].get_fixed_value()==val
+          result = false
+        end
+      end
+    }
+    result
+  end
+
+  def check_matrix_value(row, col, val)
+    result = true
+    row_start = (row/3).floor * 3
+    col_start = (col/3).floor * 3
+    (row_start..row_start+2).each { |y|
+      (col_start..col_start+2).each { |x|
+        unless row==y and col==x
+          if @cells[y][x].get_fixed_value()==val
+            result = false
+          end
+        end
+      }
+    }
+    result
+  end
+
+  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()
+              end
+            end
+          }
+        end
+      }
+    }
+    print_debug('Dead end found.\n')
+    nil
+  end
+
+  def copy
+    s = Sudoku.new()
+    (0..8).each { |r|
+      (0..8).each { |c|
+        copied_cell = @cells[r][c].copy
+        s.set_cells(r, c, copied_cell)
+      }
+    }
+    s.set_max_iterations(@max_iterations)
+    s.set_total_iterations(@total_iterations)
+    s.set_debug(@debug)
+    s
+  end
+
+  def validate_sudoku
+    results = true
+    begin
+      (0..8).each { |r|
+        validate_row(r)
+      }
+
+      (0..8).each { |c|
+        validate_column(c)
+      }
+
+      [0, 3, 6].each { |r|
+        [0, 3, 6].each { |c|
+          validate_matrix(r, c)
+        }
+      }
+    rescue Exception => error
+      results = false
+    end
+    results
+  end
+
+  def validate_row(r)
+    
+    (1..9).each { |i|
+      found_count=0
+      (0..8).each { |c|
+        if @cells[r][c].get_fixed_value()==i
+          found_count+=1
+        end
+      }
+      if found_count>1
+        raise Exception.new('Row invalid %s.  Canceling' % r)
+      end
+    }
+    true
+  end
+
+
+  def validate_column(c)
+
+    (1..9).each { |i|
+      found_count = 0
+      (0..8).each { |r|
+        if @cells[r][c].get_fixed_value()==i
+          found_count+=1
+        end
+      }
+      if found_count>1
+        raise Exception.new('Row invalid.  Canceling')
+      end
+    }
+    true
+  end
+
+
+  def validate_matrix(r, c)
+    (1..9).each { |i|
+      found_count=0
+      row_start = (r/3).floor * 3
+      col_start = (c/3).floor * 3
+      (row_start..row_start+2).each { |y|
+        (col_start..col_start+2).each { |x|
+          if @cells[y][x].get_fixed_value()==i
+            found_count+=1
+          end
+
+        }
+      }
+      if found_count>1
+        raise Exception.new('Matrix invalid! Canceling.')
+      end
+    }
+    true
+  end
+
+
+  def set_debug(b)
+    @debug = b
+  end
+
+  def dump_to_str
+    if @debug
+      print '\n'
+      (0..8).each { |row|
+        (0..8).each { |col|
+          printf('   %3s     | ' % @cells[row][col].get_fixed_value())
+          if col == 2 or col == 5
+            print '| '
+          end
+
+        }
+        print '\n'
+        (0..8).each { |col|
+          array = @cells[row][col].get_possible_values()
+          if array==[]
+            array = '--'
+          end
+          printf(' %10s  ' % array)
+          if col == 2 or col == 5
+            print '| '
+          end
+        }
+        print '\n\n'
+      }
+    end
+  end
+
+  def dump_known_cells_str
+
+    result = '\n'
+    for row in (0..8)
+      (0..8).each do |col|
+        if @cells[row][col].get_fixed_value() > 0
+          val = @cells[row][col].get_fixed_value()
+        else
+          val = ' '
+        end
+        result+='%3s ' % val
+        if col == 2 or col == 5
+          result+= '| '
+        end
+      end
+      if row==2 or row==5
+        result+= '\n----------------------------------------\n'
+      else
+        result+= '\n'
+      end
+    end
+    result
+  end
+
+  def print_debug(message)
+    if @debug
+      print message
+    end
+  end
+
+end
+