guava_sudoku_solver 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: daa34677a0e601753f2922ec82d28d7355a46b49
+  data.tar.gz: ea660522a2d3a427ce624a8cf90792ccf165bc2c
+SHA512:
+  metadata.gz: e646c9fd758f17419691c2ffd0e9e20ac876760c1607533456c8a8bc662ff6afd3cecc843fa1dde19e81a184bfdfbd82e656d6d939d5a06fcdb3364b9fc99ea2
+  data.tar.gz: cb44525638956ae2a9b2eb89be340a8c5462cdd7e17cc01a02a15640bd8f3157c511b32eb669c1951ba2d2381a6ced70ea86c21f98127793325bea90173d43aa

data/.gitignore

@@ -0,0 +1,64 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Vu Tran
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Victor Tran
+
+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,31 @@
+# SudokuSolver
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sudoku_solver'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sudoku_solver
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sudoku_solver/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*.rb"
+end
+
+desc "Run tests"
+task :default => :test
+

data/lib/sudoku_solver.rb

@@ -0,0 +1,40 @@
+require "sudoku_solver/version"
+require "sudoku_solver/brute_force/bruteforcable"
+require "sudoku_solver/table"
+require "sudoku_solver/variable"
+require "sudoku_solver/brute_force_corpus"
+require "sudoku_solver/brute_force_solver"
+
+# SudokuSolver provides convenient API to solve a sudoku puzzle:
+# `SudokuSolver.solve(rows)`
+#
+# Parameter:
+# `rows` should be 2D array like object which can be accessed via `each` to get
+# each row and `each` on the row to get individual sudoku elements.
+#
+# Each element should has value from 1 to 9 except elements that need to figure
+# out its value should be `nil` in order to be recognized by SudokuSolver.
+#
+# Example:
+#
+# ```ruby
+# require 'sudoku_solver'
+#
+# rows = []
+# (0..8).each
+#   rows << gets.split(' ').map do |element|
+#     element.to_i == 0 ? nil : element.to_i
+#   end
+# end
+#
+# solved_sudoku = SudokuSolver.solve(rows)
+#
+# solved_sudoku.each { |row| puts row.join(' ') }
+# ```
+#
+module SudokuSolver
+  def SudokuSolver.solve(rows)
+    final_table = BruteForceSolver.new(rows).solve
+    final_table.to_a
+  end
+end

data/lib/sudoku_solver/brute_force/bruteforcable.rb

@@ -0,0 +1,72 @@
+# Bruteforcable module provides conventional brute-force search mechanism
+# for any classes, objects that can handle message `build_brute_force_corpus`.
+#
+# By including Bruteforcable, the class is responsible for calling
+# `setup_for_brute_force(corpus, initial_state)` before issuing brute force
+# process by calling `brute_force`.
+#
+# Brute force basically try to assign available value to every variables and apply
+# to the state to see if it's a stop state.
+#
+# The process stops as soon as it reach a stop state.
+#
+# *Duck typing requirements:*
+#
+# `corpus` is supposed to handle these messages:
+#   1. `no_variables` which usually means number of variables
+#   2. `available_values(index)` which returns a set of available values for
+#       variable number index
+#   3. `variable_at(index)` returns variable instance number index
+#   4. `sort_variable(&comp_func)` (optional) sort all variables as compare
+#       function passed as a block
+#   5. `acquire(variable, value)`, strategy to handle value before assigning
+#       it to the variable
+#   6. `release(variable, value)`, strategy to handle value before assigning
+#       the variable to another value
+#
+# `initial_state` is supposed to handle these messages:
+#   1. `final_state?` which returns true if it's a stop state, false otherwise
+#   2. `apply(variable, value)` which apply a variable with specified value
+#       to itself
+#
+module Bruteforcable
+  attr_accessor :corpus
+  attr_accessor :state
+
+  def brute_force
+    if self.corpus.no_variables > 0
+      try(corpus, 0, self.state)
+    end
+    return (self.state.final_state? ? self.state : nil)
+  end
+
+  def try(corpus, index, state)
+    variable = corpus.variable_at(index)
+    corpus.available_values(variable).each do |value|
+      corpus.acquire(variable, value)
+      state.apply(corpus.variable_at(index), value)
+      if index == corpus.no_variables - 1
+        return true if state.final_state?
+      else
+        return true if try(corpus, index + 1, state)
+      end
+      corpus.release(variable, value)
+    end
+    return false
+  end
+
+  def setup_for_brute_force(corpus, initial_state)
+    self.corpus = corpus
+    self.state = initial_state
+  end
+
+  def sort_variables(&comp_func)
+    if comp_func
+      self.corpus.sort_variables do |a, b|
+        comp_func.call(a, b)
+      end
+    else
+      self.curpus.sort_variables
+    end
+  end
+end

data/lib/sudoku_solver/brute_force_corpus.rb

@@ -0,0 +1,55 @@
+require 'set'
+
+module SudokuSolver
+  class BruteForceCorpus
+
+    def initialize
+      @variables = []
+      @available_in_row = Array.new(9) { Set.new 1..9 }
+      @available_in_col = Array.new(9) { Set.new 1..9 }
+      @available_in_sq = Array.new(3) do
+        Array.new(3) { Set.new 1..9 }
+      end
+    end
+
+    def no_variables
+      @variables.size
+    end
+
+    def add_variable(row, col)
+      @variables << Variable.new(row, col, self)
+    end
+
+    def variable_at(index)
+      @variables[index]
+    end
+
+    def acquire(variable, value)
+      @available_in_row[variable.row].delete(value)
+      @available_in_col[variable.col].delete(value)
+      @available_in_sq[variable.row/3][variable.col/3].delete(value)
+    end
+
+    def release(variable, value)
+      @available_in_row[variable.row].add(value)
+      @available_in_col[variable.col].add(value)
+      @available_in_sq[variable.row/3][variable.col/3].add(value)
+    end
+
+    def available_values(variable)
+      @available_in_row[variable.row] &
+        @available_in_col[variable.col] &
+        @available_in_sq[variable.row/3][variable.col/3]
+    end
+
+    def sort_variables(&comp_func)
+      if comp_func
+        @variables.sort! do |a, b|
+          comp_func.call(a, b)
+        end
+      else
+        @variables.sort!
+      end
+    end
+  end
+end

data/lib/sudoku_solver/brute_force_solver.rb

@@ -0,0 +1,18 @@
+module SudokuSolver
+  class BruteForceSolver
+    include Bruteforcable
+
+    def initialize(rows)
+      @rows = rows
+    end
+
+    def solve
+      table = Table.new(@rows)
+      setup_for_brute_force(table.build_brute_force_corpus, table)
+      sort_variables do |a, b|
+        a.available_values_size <=> b.available_values_size
+      end
+      brute_force
+    end
+  end
+end

data/lib/sudoku_solver/table.rb

@@ -0,0 +1,78 @@
+module SudokuSolver
+  class Table
+    def initialize(rows)
+      @data = Array.new(9) { Array.new(9, nil) }
+      rows.each_with_index do |row, row_index|
+        row.each_with_index do |element, col_index|
+          @data[row_index][col_index] = element
+        end
+      end
+    end
+
+    def build_brute_force_corpus
+      corpus = BruteForceCorpus.new
+      (0..8).each do |row|
+        (0..8).each do |col|
+          if @data[row][col] == nil
+            corpus.add_variable(row, col)
+          else
+            corpus.acquire(Variable.new(row, col, corpus), @data[row][col])
+          end
+        end
+      end
+      corpus
+    end
+
+    def apply(variable, value)
+      @data[variable.row][variable.col] = value
+    end
+
+    def final_state?
+      # check if every row is valid
+      (0..8).each do |row|
+        elements = []
+        (0..8).each do |col|
+          elements << @data[row][col]
+        end
+        return false unless valid?(elements)
+      end
+
+      # check if every column is valid
+      (0..8).each do |col|
+        elements = []
+        (0..8).each do |row|
+          elements << @data[row][col]
+        end
+        return false unless valid?(elements)
+      end
+
+      # check if every square is valid
+      (0..2).each do |sq_row|
+        (0..2).each do |sq_col|
+          elements = []
+          (0..2).each do |row|
+            (0..2).each do |col|
+              elements << @data[sq_row * 3 + row][sq_col * 3 + col]
+            end
+          end
+          return false unless valid?(elements)
+        end
+      end
+      return true
+    end
+
+    def to_a
+      @data
+    end
+
+    private
+    def valid?(elements)
+      masks = Array.new(9, nil)
+      elements.each do |element|
+        return false if element == nil || masks[element - 1] != nil
+        masks[element - 1] = 1
+      end
+      return true
+    end
+  end
+end

data/lib/sudoku_solver/variable.rb

@@ -0,0 +1,15 @@
+module SudokuSolver
+  class Variable
+    attr_accessor :row, :col, :corpus
+
+    def initialize(row, col, corpus)
+      self.row = row
+      self.col = col
+      self.corpus = corpus
+    end
+
+    def available_values_size
+      corpus.available_values(self).size
+    end
+  end
+end

data/lib/sudoku_solver/version.rb

@@ -0,0 +1,3 @@
+module SudokuSolver
+  VERSION = "0.0.1"
+end

data/sudoku_solver.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sudoku_solver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "guava_sudoku_solver"
+  spec.version       = SudokuSolver::VERSION
+  spec.authors       = ["victor"]
+  spec.email         = ["vu.tran54@gmail.com"]
+  spec.summary       = %q{Solver for sudoku 9x9}
+  spec.description   = %q{Provide convenient way to solve a sudoku challenge}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 10.0"
+end

data/test/brute_force/test_broteforcable.rb

@@ -0,0 +1,67 @@
+require 'minitest/autorun'
+require 'sudoku_solver'
+
+# We are going to demonstrate using bruteforcable to solve an equation
+# of: x^3 + y^3 = 2000
+# where x, y are positive integer
+class DumpCorpus
+  def no_variables
+    2
+  end
+
+  def available_values(index)
+    1..10
+  end
+
+  def acquire(variable, value)
+  end
+
+  def release(variable, value)
+  end
+
+  def variable_at(index)
+    if index == 0
+      "x"
+    elsif index == 1
+      "y"
+    end
+  end
+end
+
+class DumpEquationState
+  attr_accessor :x, :y
+
+  def final_state?
+    self.x ** 3 + self.y ** 3 == 2000
+  end
+
+  def apply(variable, value)
+    if variable == "x"
+      self.x = value
+    elsif variable == "y"
+      self.y = value
+    end
+  end
+end
+
+class EquationSolver
+  include Bruteforcable
+
+  def initialize
+    corpus = DumpCorpus.new
+    initial_state = DumpEquationState.new
+    setup_for_brute_force(corpus, initial_state)
+  end
+
+  def solve
+    brute_force
+  end
+end
+
+class BruteforcableTest < Minitest::Test
+  def test_bruteforcable_provide_a_brute_force_process_to_any_problem
+    solver = EquationSolver.new
+    result = solver.solve
+    assert(result.x == 10 && result.y == 10)
+  end
+end

data/test/test_brute_force_corpus.rb

@@ -0,0 +1,87 @@
+require 'minitest/autorun'
+require 'sudoku_solver'
+
+class BruteForceCorpusTest < Minitest::Test
+  def test_no_variables_is_0_at_initialization
+    corpus = SudokuSolver::BruteForceCorpus.new
+    assert(corpus.no_variables == 0)
+  end
+
+  def test_no_variables_is_increased_after_adding_variables
+    corpus = SudokuSolver::BruteForceCorpus.new
+    corpus.add_variable(1, 1)
+    assert(corpus.no_variables == 1)
+  end
+
+  def test_add_variable_adds_variable_instance_to_variable_list
+    corpus = SudokuSolver::BruteForceCorpus.new
+    corpus.add_variable(1, 1)
+    assert(corpus.variable_at(0).is_a?(SudokuSolver::Variable))
+  end
+
+  def test_variable_at_gets_variable_at_specified_index
+    corpus = SudokuSolver::BruteForceCorpus.new
+    corpus.add_variable(1, 1)
+    corpus.add_variable(1, 2)
+    corpus.add_variable(3, 4)
+    variable = corpus.variable_at(2)
+    assert(variable.row == 3 && variable.col == 4)
+  end
+
+  def test_acquire_remove_value_from_row_col_and_square_that_the_variable_belongs_to
+    corpus = SudokuSolver::BruteForceCorpus.new
+    corpus.acquire(SudokuSolver::Variable.new(1, 1, corpus), 1)
+    value_for_row_1 = corpus.available_values(
+      SudokuSolver::Variable.new(1, 2, corpus))
+    assert(!value_for_row_1.include?(1))
+    value_for_col_1 = corpus.available_values(
+      SudokuSolver::Variable.new(2, 1, corpus))
+    assert(!value_for_col_1.include?(1))
+    value_for_sq = corpus.available_values(
+      SudokuSolver::Variable.new(2, 2, corpus))
+    assert(!value_for_sq.include?(1))
+  end
+
+  def test_release_add_value_to_row_col_and_square_that_the_variable_belongs_to
+    corpus = SudokuSolver::BruteForceCorpus.new
+    corpus.acquire(SudokuSolver::Variable.new(1, 1, corpus), 1)
+    corpus.release(SudokuSolver::Variable.new(1, 1, corpus), 1)
+    value_for_row_1 = corpus.available_values(
+      SudokuSolver::Variable.new(1, 2, corpus))
+    assert(value_for_row_1.include?(1))
+    value_for_col_1 = corpus.available_values(
+      SudokuSolver::Variable.new(2, 1, corpus))
+    assert(value_for_col_1.include?(1))
+    value_for_sq = corpus.available_values(
+      SudokuSolver::Variable.new(2, 2, corpus))
+    assert(value_for_sq.include?(1))
+  end
+
+  def test_available_values_returns_values_that_the_variable_can_be_assigned
+    corpus = SudokuSolver::BruteForceCorpus.new
+    corpus.acquire(SudokuSolver::Variable.new(1, 1, corpus), 1)
+    corpus.acquire(SudokuSolver::Variable.new(1, 2, corpus), 2)
+    corpus.acquire(SudokuSolver::Variable.new(1, 3, corpus), 3)
+    corpus.acquire(SudokuSolver::Variable.new(1, 4, corpus), 4)
+    corpus.acquire(SudokuSolver::Variable.new(1, 5, corpus), 5)
+    corpus.acquire(SudokuSolver::Variable.new(1, 6, corpus), 6)
+    corpus.acquire(SudokuSolver::Variable.new(1, 7, corpus), 7)
+    corpus.acquire(SudokuSolver::Variable.new(1, 8, corpus), 8)
+
+    value_for_row = corpus.available_values(
+      SudokuSolver::Variable.new(1, 0, corpus))
+    assert(value_for_row.size == 1)
+    assert(value_for_row.to_a[0] == 9)
+  end
+
+  def test_sort_variables_sorts_variable_by_a_block
+    corpus = SudokuSolver::BruteForceCorpus.new
+    corpus.add_variable(1, 1)
+    corpus.add_variable(0, 1)
+    corpus.sort_variables do |v1, v2|
+      v1.row <=> v2.row
+    end
+    assert(corpus.variable_at(0).row == 0)
+    assert(corpus.variable_at(1).row == 1)
+  end
+end

data/test/test_sudoku_solver.rb

@@ -0,0 +1,110 @@
+require 'minitest/autorun'
+
+class SudokuSolverTest < Minitest::Test
+  def test_outter_most_solve_method
+    input = [
+      [6, 2, nil, 8, 1, 3, 7, 5, 4],
+      [7, 8, 3, 9, 5, 4, 6, 2, 1],
+      [5, 1, 4, 6, 7, 2, 3, 9, 8],
+      [1, 7, 5, 2, 3, 8, 9, 4, 6],
+      [9, 3, 2, 4, 6, 1, 8, 7, 5],
+      [4, 6, 8, 7, 9, 5, 1, 3, 2],
+      [3, 9, 1, 5, 4, 6, 2, 8, 7],
+      [8, 4, 6, 3, 2, 7, 5, 1, 9],
+      [2, 5, 7, nil, 8, 9, 4, 6, 3]
+    ]
+
+    output = SudokuSolver.solve(input)
+    assert(SudokuSolver::Table.new(output).final_state?)
+  end
+
+  def test_solver
+    input = [
+      [6, 2, nil, 8, 1, 3, 7, 5, 4],
+      [7, 8, 3, 9, 5, 4, 6, 2, 1],
+      [5, 1, 4, 6, 7, 2, 3, 9, 8],
+      [1, 7, 5, 2, 3, 8, 9, 4, 6],
+      [9, 3, 2, 4, 6, 1, 8, 7, 5],
+      [4, 6, 8, 7, 9, 5, 1, 3, 2],
+      [3, 9, 1, 5, 4, 6, 2, 8, 7],
+      [8, 4, 6, 3, 2, 7, 5, 1, 9],
+      [2, 5, 7, nil, 8, 9, 4, 6, 3]
+    ]
+
+    solver = SudokuSolver::BruteForceSolver.new(input)
+    output = solver.solve
+    assert(output.final_state?, "Failed! The result is not valid")
+  end
+
+  def test_solver_many_slots
+    input = [
+      [nil, nil, nil, nil, 1, 3, nil, 5, nil],
+      [7, nil, nil, 9, 5, nil, 6, nil, nil],
+      [5, nil, nil, nil, nil, 2, nil, 9, 8],
+      [nil, nil, nil, 2, nil, 8, 9, nil, 6],
+      [nil, nil, nil, nil, 6, nil, nil, nil, nil],
+      [4, nil, 8, 7, nil, 5, nil, nil, nil],
+      [3, 9, nil, 5, nil, nil, nil, nil, 7],
+      [nil, nil, 6, nil, 2, 7, nil, nil, 9],
+      [nil, 5, nil, 1, 8, nil, nil, nil, nil],
+    ]
+
+    solver = SudokuSolver::BruteForceSolver.new(input)
+    output = solver.solve
+    assert(output.final_state?, "Failed! The result is not valid")
+  end
+
+  def test_solver_many_slots_2
+    input = [
+      [9, nil, nil, nil, nil, 7, nil, nil, nil],
+      [nil, 6, 2, nil, 3, nil, nil, nil, 7],
+      [nil, nil, nil, nil, nil, 8, 2, nil, nil],
+      [nil, 2, 5, nil, nil, nil, 4, nil, 1],
+      [nil, 7, 6, 3, nil, 5, 9, 2, nil],
+      [1, nil, 8, nil, nil, nil, 5, 7, nil],
+      [nil, nil, 9, 5, nil, nil, nil, nil, nil],
+      [2, nil, nil, nil, 9, nil, 8, 3, nil],
+      [nil, nil, nil, 7, nil, nil, nil, nil, 5],
+    ]
+
+    solver = SudokuSolver::BruteForceSolver.new(input)
+    output = solver.solve
+    assert(output.final_state?, "Failed! The result is not valid")
+  end
+
+  # def test_solver_many_slots_3
+  #   input = [
+  #     [nil, 8, nil, nil, nil, nil, nil, nil, 5],
+  #     [nil, nil, nil, nil, 4, nil, nil, nil, nil],
+  #     [5, nil, nil, nil, nil, nil, nil, nil, 6],
+  #     [nil, 4, 1, nil, nil, nil, 8, nil, nil],
+  #     [nil, nil, nil, 3, nil, 8, nil, nil, nil],
+  #     [nil, 9, nil, nil, nil, nil, nil, nil, nil],
+  #     [nil, nil, nil, nil, nil, 5, nil, nil, nil],
+  #     [3, nil, nil, 6, nil, 7, nil, nil, nil],
+  #     [nil, nil, nil, nil, nil, nil, 4, 1, nil],
+  #   ]
+
+  #   solver = SudokuSolver.new(input)
+  #   output = solver.solve
+  #   assert(output.final_state?, "Failed! The result is not valid")
+  # end
+
+  def test_solver_all_empty
+    input = [
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    ]
+
+    solver = SudokuSolver::BruteForceSolver.new(input)
+    output = solver.solve
+    assert(output.final_state?, "Failed! The result is not valid")
+  end
+end

data/test/test_table.rb

@@ -0,0 +1,56 @@
+require 'minitest/autorun'
+require 'sudoku_solver'
+
+class TableTest < Minitest::Test
+  def test_final_state_true
+    table = SudokuSolver::Table.new([
+      [6, 2, 9, 8, 1, 3, 7, 5, 4],
+      [7, 8, 3, 9, 5, 4, 6, 2, 1],
+      [5, 1, 4, 6, 7, 2, 3, 9, 8],
+      [1, 7, 5, 2, 3, 8, 9, 4, 6],
+      [9, 3, 2, 4, 6, 1, 8, 7, 5],
+      [4, 6, 8, 7, 9, 5, 1, 3, 2],
+      [3, 9, 1, 5, 4, 6, 2, 8, 7],
+      [8, 4, 6, 3, 2, 7, 5, 1, 9],
+      [2, 5, 7, 1, 8, 9, 4, 6, 3]]
+    )
+
+    assert(table.final_state?, "Failed! Expected the final_state? returns true")
+  end
+
+  def test_final_state_false_because_of_missing_slots
+    table = SudokuSolver::Table.new([
+      [6, 2, nil, 8, 1, 3, 7, 5, 4],
+      [7, 8, 3, 9, 5, 4, 6, 2, 1],
+      [5, 1, 4, 6, 7, 2, 3, 9, 8],
+      [1, 7, 5, 2, 3, 8, 9, 4, 6],
+      [9, 3, 2, 4, 6, 1, 8, 7, 5],
+      [4, 6, 8, 7, 9, 5, 1, 3, 2],
+      [3, 9, 1, 5, 4, 6, 2, 8, 7],
+      [8, 4, 6, 3, 2, 7, 5, 1, 9],
+      [2, 5, 7, nil, 8, 9, 4, 6, 3]]
+    )
+
+    assert(
+      !table.final_state?,
+      "Failed! Expected the final_state? returns false if any slots are missing")
+  end
+
+  def test_final_state_false_because_of_dup_value
+    table = SudokuSolver::Table.new([
+      [6, 2, 9, 8, 1, 3, 7, 5, 4],
+      [7, 8, 3, 9, 5, 4, 6, 2, 1],
+      [5, 1, 4, 6, 7, 2, 3, 9, 8],
+      [1, 7, 5, 2, 3, 8, 9, 4, 6],
+      [9, 3, 2, 4, 6, 1, 8, 7, 5],
+      [4, 6, 8, 7, 9, 5, 1, 3, 2],
+      [3, 9, 1, 5, 4, 6, 2, 8, 7],
+      [8, 4, 6, 3, 2, 7, 5, 2, 9],
+      [2, 5, 7, 1, 8, 9, 4, 6, 3]]
+    )
+
+    assert(
+      !table.final_state?,
+      "Failed! Expected the final_state? returns false if any slots are duplicated")
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: guava_sudoku_solver
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- victor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Provide convenient way to solve a sudoku challenge
+email:
+- vu.tran54@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sudoku_solver.rb
+- lib/sudoku_solver/brute_force/bruteforcable.rb
+- lib/sudoku_solver/brute_force_corpus.rb
+- lib/sudoku_solver/brute_force_solver.rb
+- lib/sudoku_solver/table.rb
+- lib/sudoku_solver/variable.rb
+- lib/sudoku_solver/version.rb
+- sudoku_solver.gemspec
+- test/brute_force/test_broteforcable.rb
+- test/test_brute_force_corpus.rb
+- test/test_sudoku_solver.rb
+- test/test_table.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.6.7
+signing_key: 
+specification_version: 4
+summary: Solver for sudoku 9x9
+test_files:
+- test/brute_force/test_broteforcable.rb
+- test/test_brute_force_corpus.rb
+- test/test_sudoku_solver.rb
+- test/test_table.rb
+has_rdoc: