sudoku_solver 1.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Michel Belleville
+
+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.rdoc

@@ -0,0 +1,17 @@
+= sudoku_solver
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Michel Belleville. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sudoku_solver"
+    gem.summary = %Q{A pretty simple sudoku solver}
+    gem.description = %Q{A very simple sudoku problems solver}
+    gem.email = "michel.belleville@gmail.com"
+    gem.homepage = "http://github.com/Bastes/SudokuSolver"
+    gem.authors = ["Michel Belleville"]
+    gem.add_dependency "cellular_map", ">= 0.6.0"
+    gem.add_development_dependency "shoulda", ">= 0"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sudoku_solver #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Start an IRB session with all necessary files required.'
+task :shell do |t|
+  chdir File.dirname(__FILE__)
+  exec 'irb -I lib/ -I lib/sudoku_solver -r solver'
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/sudoku_solver.rb

@@ -0,0 +1 @@
+require "sudoku_solver/solver"

data/lib/sudoku_solver/grid.rb

@@ -0,0 +1,62 @@
+require 'cellular_map'
+
+module SudokuSolver
+  module Cell
+    attr_accessor :grid
+
+    def neighbours
+      sx = x - x % grid.dimension
+      sy = y - y % grid.dimension
+      neighbours_values = [
+        grid[grid.size, y],
+        grid[x, grid.size],
+        grid[sx..(sx + grid.dimension - 1), sy..(sy + grid.dimension - 1)] ].
+          inject([]) { |r, z| r + z.to_a }.flatten.uniq.reject { |d| d == self }
+    end
+  end
+
+  class Grid < CellularMap::Zone
+    attr_reader :dimension, :size, :possibilities
+
+    def initialize(dimension)
+      @dimension = dimension
+      @width = @dimension ** 2
+      @size = (0..(@width - 1))
+      @possibilities = (1..@width)
+      super(@size, @size, CellularMap::Map.new)
+    end
+
+    def [](x, y)
+      cell = super
+      if cell.is_a? CellularMap::Cell
+        cell.extend Cell
+        cell.grid = self
+      end
+      cell
+    end
+
+    def each # :nodoc:
+      super { |cell|
+        if cell.is_a? CellularMap::Cell
+          cell.extend Cell
+          cell.grid = self
+        end
+        yield cell
+      }
+    end
+
+    def solved?
+      ! self.detect { |c| c.content.nil? || c.content.length != 1 }
+    end
+
+    protected
+
+    def initialize_copy(other) # :nodoc:
+      @map = other.map.dup
+      @map.each { |c|
+        c.content = c.content.dup rescue nil
+        c.content = nil unless x === c.x && y === c.y
+      }
+    end
+  end
+end

data/lib/sudoku_solver/solver.rb

@@ -0,0 +1,80 @@
+require 'sudoku_solver/grid'
+
+module SudokuSolver
+  class InvalidProblemError < Exception
+    attr_reader :problem
+    def initialize(problem)
+      @problem = problem
+    end
+  end
+
+  class Solver
+    def self.solve(problem)
+      self.new(problem).solve
+    end
+
+    def grid
+      Grid.new(@dimension).each { |c|
+        v = @problem[c.y][c.x]
+        unless v.nil? || @possibilities.to_a.include?(v)
+          raise InvalidProblemError.new(@problem) 
+        end
+        c.content = v ? [v] : @possibilities.to_a
+      }
+    end
+
+    def initialize(problem)
+      @problem = problem
+      @width = @problem.length
+      if problem.any? { |l| l.length != @width }
+        raise InvalidProblemError.new(problem)
+      end
+      @dimension = Math.sqrt(@width).to_i
+      @size = (0..(@width -1))
+      @possibilities = (1..@width)
+    rescue
+      raise InvalidProblemError.new(problem)
+    end
+
+    def solve
+      self.step(self.grid).to_a.collect { |l| l.collect { |c|
+        c.content.length == 1 ? c.content.first : nil } }
+    end
+
+    def step(grid)
+      grid = self.reduce(grid)
+      return grid if grid.solved?
+      cell = grid.detect { |c| c.content.length > 1 }
+      cell.content.each { |value|
+        begin
+          new_grid = grid.dup
+          new_grid[cell.x, cell.y] = [value]
+          solution = step(new_grid)
+          return solution if solution.solved?
+        rescue InvalidProblemError
+        end
+      }
+      raise InvalidProblemError.new(@problem)
+    end
+
+    def reduce(grid)
+      unsolved = grid.reject { |c| c.content.length == 1 }
+      until unsolved.empty? do
+        changed = unsolved.reject { |c| restrict(c) }
+        break unless changed.length > 0
+        unsolved.reject! { |c| c.content.length == 1 }
+      end
+      grid
+    end
+
+    def restrict(cell)
+      taken = cell.neighbours.collect { |c| c.content }.
+        reject { |r| r.length > 1 }.flatten
+      remaining = (cell.content - taken).sort
+      if remaining.length == 0
+        raise InvalidProblemError.new(@problem)
+      end
+      (cell.content == remaining) || ! (cell.content = remaining)
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'sudoku_solver'
+
+class Test::Unit::TestCase
+end

data/test/test_grid.rb

@@ -0,0 +1,108 @@
+require 'helper'
+
+class TestGrid < Test::Unit::TestCase
+  context('An empty 2x2 grid') {
+    setup { @grid = SudokuSolver::Grid.new(2) }
+    should('have the proper dimensions') {
+      assert_equal 2, @grid.dimension
+      assert_equal 4, @grid.width
+      assert_equal 4, @grid.height
+      assert_equal (0..3), @grid.size
+      assert_equal (1..4), @grid.possibilities
+    }
+  }
+
+  context('An empty 3x3 grid') {
+    setup { @grid = SudokuSolver::Grid.new(3) }
+    should('have the proper dimensions') {
+      assert_equal 3, @grid.dimension
+      assert_equal 9, @grid.width
+      assert_equal 9, @grid.height
+      assert_equal (0..8), @grid.size
+      assert_equal (1..9), @grid.possibilities
+    }
+
+    context('considering one of its cells') {
+      setup {
+        @cell1 = @grid[2, 5]
+        @cell2 = @grid.detect { |c|
+          [c.x, c.y] == [2, 5] }
+      }
+      should('find the neighbours') {
+        expected, obtained1, obtained2 = [
+          [
+            @grid[0, 5],
+            @grid[1, 5],
+            @grid[3, 5],
+            @grid[4, 5],
+            @grid[5, 5],
+            @grid[6, 5],
+            @grid[7, 5],
+            @grid[8, 5],
+            @grid[2, 0],
+            @grid[2, 1],
+            @grid[2, 2],
+            @grid[2, 3],
+            @grid[2, 4],
+            @grid[2, 6],
+            @grid[2, 7],
+            @grid[2, 8],
+            @grid[0, 3],
+            @grid[1, 3],
+            @grid[0, 4],
+            @grid[1, 4]
+          ],
+          @cell1.neighbours,
+          @cell2.neighbours
+        ].collect { |a| a.sort }
+        assert_equal expected, obtained1
+        assert_equal expected, obtained2
+      }
+    }
+
+    context('cloned') {
+      setup {
+        @grid[4, 4] = [1,2,3]
+        @clone = @grid.dup
+      }
+      should("be equal") { assert_equal @grid, @clone }
+      should("not be the same object") { assert_not_same @grid, @clone }
+      should("evolve their own separate way") {
+        @grid[1, 2] = [1, 2, 3]
+        @clone[1, 2] = [5, 6, 7]
+        @clone[4, 4].content.reject! { |v| v == 3 }
+        assert_equal [1, 2, 3], @grid[1, 2].content
+        assert_equal [1, 2, 3], @grid[4, 4].content
+        assert_equal [5, 6, 7], @clone[1, 2].content
+        assert_equal [1, 2], @clone[4, 4].content
+        assert_not_equal @grid, @clone
+      }
+    }
+  }
+
+  context('An empty 4x4 grid') {
+    setup { @grid = SudokuSolver::Grid.new(4) }
+    should('have the proper dimensions') {
+      assert_equal 4, @grid.dimension
+      assert_equal 16, @grid.width
+      assert_equal 16, @grid.height
+      assert_equal (0..15), @grid.size
+      assert_equal (1..16), @grid.possibilities
+    }
+    should('know it\'s not solved already') {
+      assert !@grid.solved? }
+  }
+
+  context('A 2x2 grid, solved') {
+    setup {
+      @grid = SudokuSolver::Grid.new(2)
+      problem = [ [ 1, 2, 3, 4 ],
+                  [ 3, 4, 1, 2 ],
+                  [ 2, 1, 4, 3 ],
+                  [ 4, 3, 2, 1 ] ]
+      @grid.each { |c| c.content = [problem[c.x][c.y]] }
+    }
+    should('know it\'s solved already') {
+      assert @grid.solved? }
+  }
+end

data/test/test_solver.rb

@@ -0,0 +1,137 @@
+require 'helper'
+
+class TestSolver < Test::Unit::TestCase
+  [ :blah,
+    "truc",
+    1234,
+    [ [2] ],
+    [ [1], [2] ],
+    [ [1, nil, nil, nil],
+      [1, nil, nil, nil],
+      [nil, nil, nil, nil],
+      [nil, nil, nil, nil] ] ].each { |problem|
+    context("This absurd problem #{problem.inspect}") {
+      should('be impossible to solve') {
+        assert_raise(SudokuSolver::InvalidProblemError) {
+          SudokuSolver::Solver.solve(problem) }
+      }
+    }
+  } 
+
+  { [[nil]] => [[1]] }.each { |problem, solution|
+    context("The simplest problem in the world #{problem}") {
+      should('be easy to solve') {
+        assert_equal solution, SudokuSolver::Solver.solve(problem)
+      }
+    }
+  }
+
+  context('A 4x4 problem') {
+    setup {
+      @solution =
+        [ [ 1, 2, 3, 4],
+          [ 3, 4, 2, 1],
+          [ 2, 1, 4, 3],
+          [ 4, 3, 1, 2] ]
+      @problem = @solution.collect { |l| l.clone }
+    }
+    context('very simple') {
+      setup { @problem[0][0] = nil }
+      should('still be easy to solve') {
+        assert_equal @solution, SudokuSolver::Solver.solve(@problem)
+      }
+    }
+    context('simple') {
+      setup {
+        @problem[1][2] = nil
+        @problem[2][3] = nil
+      }
+      should('still be easy to solve') {
+        assert_equal @solution, SudokuSolver::Solver.solve(@problem)
+      }
+    }
+    context('less simple') {
+      setup {
+        @problem[0][2] = nil
+        @problem[1][2] = nil
+        @problem[2][3] = nil
+        @problem[3][3] = nil
+      }
+      should('still be easy to solve') {
+        assert_equal @solution, SudokuSolver::Solver.solve(@problem)
+      }
+    }
+    context('complex') {
+      setup {
+        @problem[0][2] = nil
+        @problem[2][2] = nil
+        @problem[0][3] = nil
+        @problem[3][2] = nil
+        @problem[3][1] = nil
+        @problem[2][3] = nil
+        @problem[2][0] = nil
+        @problem[2][3] = nil
+      }
+      should('still be easy to solve') {
+        assert_equal @solution, SudokuSolver::Solver.solve(@problem)
+      }
+    }
+  }
+
+  context("And now it's 3x3 time !") {
+    context("Easy for a start") {
+      setup {
+        @problem =
+          [ [   7, nil, nil,   3, nil, nil, nil,   2, nil ],
+            [   8,   4, nil,   2,   6, nil, nil, nil,   5 ],
+            [ nil,   5,   2, nil,   1,   9, nil,   8,   7 ],
+            [ nil, nil, nil,   9, nil, nil, nil,   3,   2 ],
+            [   4, nil,   1, nil, nil, nil,   7, nil,   6 ],
+            [   9,   2, nil, nil, nil,   6, nil, nil, nil ],
+            [   2,   9, nil,   6,   8, nil,   1,   7, nil ],
+            [   1, nil, nil, nil,   2,   4, nil,   6,   8 ],
+            [ nil,   7, nil, nil, nil,   3, nil, nil,   4 ] ]
+        @solution =
+          [ [   7,   1,   6,   3,   5,   8,   4,   2,   9 ],
+            [   8,   4,   9,   2,   6,   7,   3,   1,   5 ],
+            [   3,   5,   2,   4,   1,   9,   6,   8,   7 ],
+            [   5,   6,   7,   9,   4,   1,   8,   3,   2 ],
+            [   4,   8,   1,   5,   3,   2,   7,   9,   6 ],
+            [   9,   2,   3,   8,   7,   6,   5,   4,   1 ],
+            [   2,   9,   4,   6,   8,   5,   1,   7,   3 ],
+            [   1,   3,   5,   7,   2,   4,   9,   6,   8 ],
+            [   6,   7,   8,   1,   9,   3,   2,   5,   4 ] ]
+      }
+      should("be easy to solve") {
+        assert_equal @solution, SudokuSolver::Solver.solve(@problem)
+      }
+    }
+    context("And now a hard one") {
+      setup {
+        @problem =
+          [ [   9, nil, nil,   3, nil, nil, nil, nil,   6 ],
+            [ nil,   8, nil, nil, nil, nil, nil, nil,   7 ],
+            [ nil, nil,   5,   2, nil,   8,   9, nil, nil ],
+            [ nil, nil,   8, nil, nil,   4, nil,   7,   3 ],
+            [ nil,   9, nil, nil, nil, nil, nil,   4, nil ],
+            [   7,   6, nil,   1, nil, nil,   2, nil, nil ],
+            [ nil, nil,   7,   8, nil,   1,   4, nil, nil ],
+            [   1, nil, nil, nil, nil, nil, nil,   5, nil ],
+            [   8, nil, nil, nil, nil,   9, nil, nil,   1 ] ]
+        @solution =
+          [ [   9,   2,   1,   3,   4,   7,   5,   8,   6 ],
+            [   4,   8,   6,   9,   1,   5,   3,   2,   7 ],
+            [   3,   7,   5,   2,   6,   8,   9,   1,   4 ],
+            [   2,   1,   8,   5,   9,   4,   6,   7,   3 ],
+            [   5,   9,   3,   6,   7,   2,   1,   4,   8 ],
+            [   7,   6,   4,   1,   8,   3,   2,   9,   5 ],
+            [   6,   5,   7,   8,   2,   1,   4,   3,   9 ],
+            [   1,   4,   9,   7,   3,   6,   8,   5,   2 ],
+            [   8,   3,   2,   4,   5,   9,   7,   6,   1 ] ]
+      }
+      should("be easy to solve") {
+        assert_equal @solution, SudokuSolver::Solver.solve(@problem)
+      }
+    }
+  }
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: sudoku_solver
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Michel Belleville
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cellular_map
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A very simple sudoku problems solver
+email: michel.belleville@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/sudoku_solver.rb
+- lib/sudoku_solver/grid.rb
+- lib/sudoku_solver/solver.rb
+- test/helper.rb
+- test/test_grid.rb
+- test/test_solver.rb
+has_rdoc: true
+homepage: http://github.com/Bastes/SudokuSolver
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A pretty simple sudoku solver
+test_files: 
+- test/test_solver.rb
+- test/test_grid.rb
+- test/helper.rb