binary_puzzle_solver 0.0.1 → 0.0.2

data/CREDITS.pod

@@ -0,0 +1,45 @@
+=encoding utf8
+
+=head1 The Binary Puzzle Solver credits and thanks file
+
+=head2 NOTE
+
+If you believe your name is missing here, please contact me at
+L<http://www.shlomifish.org/me/contact-me/>.
+
+=head2 List of Credits.
+
+=over 4
+
+=item * Shlomi Fish
+
+Doing the bulk of the work on the solver.
+
+=item * Meir Maor
+
+Giving a talk about the Scala programming language on August Penguin 2012,
+which prompted work on the solver.
+
+=item * Richard Klement (tybalt89)
+
+Writing an alternative solver in hacky perl and releasing it as open-source
+software under the MIT/X11 license.
+
+=item * Steve Klabnik
+
+Writing a
+L<tutorial for making ruby Gems|http://timelessrepo.com/making-ruby-gems> which
+proved to be useful. Also answered some questions on IRC
+
+=item * judyfor from #ruby-lang on Freenode
+
+Answering some questions, and recommending an rspec rakefile integration
+snippet.
+
+=item * Kizano_werk from #perl on Freenode
+
+Helping me diagnose a rubygems.org HTTP problem that prevented me from
+uploading this gem (and other gems in the future).
+
+=back 4
+

data/README.md

@@ -1,6 +1,8 @@
-# BinaryPuzzleSolver
+# Binary\_Puzzle\_Solver
 
-TODO: Write a gem description
+This gem provides an API for solving the Binary Puzzles from
+[BinaryPuzzle.com](http://www.binarypuzzle.com/) . In the future
+it will also provide a command-line interface.
 
 ## Installation
 

data/binary_puzzle_solver.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
     s.authors     = ["Shlomi Fish"]
     s.email       = ["shlomif@cpan.org"]
     # TODO : add a better home page on http://www.shlomifish.org/ .
-    s.homepage    = "http://github.com/shlomif/binary-puzzle-garden"
+    s.homepage    = "http://www.shlomifish.org/open-source/projects/japanese-puzzle-games/binary-puzzle/"
     s.summary     = %q{A solver for http://www.binarypuzzle.com/ instances}
     s.description = %q{This is a solver for instances of the so-called Binary
       Puzzle from http://www.binarypuzzle.com/ . It is incomplete, but

data/lib/binary_puzzle_solver/base.rb

@@ -481,8 +481,9 @@ module Binary_Puzzle_Solver
                 return
             }
 
-            row.iter().each do |x, cell|
-                 cell_state = cell.state
+            row.iter_of_handles().each do |h|
+                 x = h.x
+                 cell_state = h.get_cell.state
 
                  if cell_state == Cell::UNKNOWN
                      handle_prev_cell_states.call(x)
@@ -542,7 +543,10 @@ module Binary_Puzzle_Solver
             if (full_val)
                 opposite_val = opposite_value(full_val)
 
-                row.iter().each do |x, cell|
+                row.iter_of_handles().each do |cell_h|
+                    x = cell_h.x
+                    cell = cell_h.get_cell
+
                     cell_state = cell.state
 
                     if cell_state == Cell::UNKNOWN
@@ -559,6 +563,131 @@ module Binary_Puzzle_Solver
             return
         end
 
+        def check_exceeded_numbers_while_accounting_for_two_unknown_gaps(params)
+            row_idx = params[:idx]
+
+            row = get_row_handle(row_idx)
+
+            gaps = {}
+
+            next_gap = []
+
+            add_gap = lambda {
+                l = next_gap.length
+                if (l > 0)
+                    if not gaps[l]
+                        gaps[l] = []
+                    end
+                    gaps[l] << next_gap
+                    next_gap = []
+                end
+            }
+
+            row.iter_of_handles().each do |cell_h|
+                if (cell_h.get_state == Cell::UNKNOWN)
+                    next_gap << cell_h.x
+                else
+                    add_gap.call()
+                end
+            end
+
+            add_gap.call()
+
+            if (gaps.has_key?(2)) then
+                implicit_counts = {Cell::ZERO => 0, Cell::ONE => 0,}
+                gaps[2].each do |gap|
+                    x_s = []
+                    if (gap[0] > 0)
+                        x_s << gap[0]-1
+                    end
+                    if (gap[-1] < row.max_idx)
+                        x_s << gap[-1]+1
+                    end
+
+                    bordering_values = {Cell::ZERO => 0, Cell::ONE => 0,}
+                    x_s.each do |x|
+                        bordering_values[row.get_state(x)] += 1
+                    end
+
+                    for v in [Cell::ZERO, Cell::ONE] do
+                       if bordering_values[opposite_value(v)] > 0
+                           implicit_counts[v] += 1
+                       end
+                    end
+                end
+
+                summ = row.get_summary()
+
+                v = [Cell::ZERO, Cell::ONE].find {
+                    |v| summ.get_count(v) + implicit_counts[v] \
+                        == summ.half_limit()
+                }
+
+                if v then
+                    gap_keys = gaps.keys.select { |x| x != 2 }
+                    opposite_val = opposite_value(v)
+                    gap_keys.each do |k|
+                        gaps[k].each do |gap|
+                            gap.each do |x|
+                                perform_and_append_move(
+                                    :coord => row.get_coord(x),
+                                    :val => opposite_val,
+                                    :reason => \
+                                    "Analysis of gaps and their neighboring values",
+                                    :dir => row.col_dim()
+                                )
+                            end
+                        end
+                    end
+                end
+            end
+        end
+
+        def check_try_placing_last_of_certain_digit_in_row(params)
+            row_idx = params[:idx]
+
+            row = get_row_handle(row_idx)
+
+            summary = row.get_summary()
+
+            v = [Cell::ZERO, Cell::ONE].find {
+                |v| summary.get_count(v) == summary.half_limit() - 1
+            }
+
+            if not(v) then
+                return
+            end
+
+            oppose_v = opposite_value(v)
+
+            values = row.iter_of_states().to_a
+            coords = row.where_values_are(Cell::UNKNOWN)
+
+            coords_copy = Array.new(coords)
+
+            for x in coords do
+                v_s = Array.new(values)
+                for x_to_fill in coords_copy do
+                    v_s[x_to_fill] = ((x_to_fill == x) ? v : oppose_v)
+                end
+
+                # Is there a three in a row?
+                if ((0 .. (v_s.length - 3)).to_a.index { |i|
+                    (1 .. 2).all? { |offset| v_s[i] == v_s[i+offset] }
+                }) then
+                perform_and_append_move(
+                    :coord => row.get_coord(x),
+                    :val => oppose_v,
+                    :reason => "Trying opposite value that is the last remaining results in three-in-a-row",
+                    :dir => col_dim()
+                )
+                return
+                end
+            end
+
+            return
+        end
+
         def validate_rows()
             # TODO
             complete_rows_map = Hash.new
@@ -587,7 +716,7 @@ module Binary_Puzzle_Solver
         end
 
         def get_string()
-            return iter().map { |x, cell| cell.get_char() }.join('')
+            return iter_of_handles().map { |cell_h| cell_h.get_char() }.join('')
         end
 
         def col_dim()
@@ -610,12 +739,33 @@ module Binary_Puzzle_Solver
             return view.get_cell_state(get_coord(x))
         end
 
+        def get_cell(x)
+            return view._get_cell(get_coord(x))
+        end
+
         def iter
             return view.dim_range(col_dim()).map { |x|
-                [x, view._get_cell(get_coord(x))]
+                [x, get_cell(x)]
             }
         end
 
+        def get_cell_handle(x)
+            return CellHandle.new(self, x)
+        end
+
+        def iter_of_handles
+            return view.dim_range(col_dim()).map { |x| get_cell_handle(x) }
+        end
+
+        def iter_of_states
+            return iter_of_handles.map { |x| x.get_state() }
+        end
+
+        def where_values_are(v)
+            return iter_of_handles.select { |x|
+                x.get_state() == v }.map { |h| h.x }
+        end
+
         def check_for_duplicated(complete_rows_map)
             summary = get_summary()
 
@@ -652,8 +802,8 @@ module Binary_Puzzle_Solver
                 end
             }
 
-            iter().each do |x, cell|
-                cell_state = cell.state
+            iter_of_handles().each do |cell_h|
+                cell_state = cell_h.get_state
                 if cell_state == prev_cell_state then
                     count += 1
                 else
@@ -677,6 +827,34 @@ module Binary_Puzzle_Solver
         end
     end
 
+    class CellHandle
+
+        attr_reader :row_handle, :x
+
+        def initialize (row_handle, x)
+            @row_handle = row_handle
+            @x = x
+
+            return
+        end
+
+        def get_coord()
+            return row_handle.get_coord(x)
+        end
+
+        def get_state()
+            return row_handle.get_state(x)
+        end
+
+        def get_cell()
+            return row_handle.get_cell(x)
+        end
+
+        def get_char()
+            return get_cell().get_char()
+        end
+    end
+
     def Binary_Puzzle_Solver.gen_board_from_string_v1(string)
         lines = string.lines.map { |l| l.chomp }
         line_lens = lines.map { |l| l.length }

data/lib/binary_puzzle_solver/version.rb

@@ -1,3 +1,3 @@
 module Binary_Puzzle_Solver
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
 end

data/test/{parse-board.rb → deduction.rb}

@@ -53,8 +53,8 @@ def compare_boards(got, expected)
             got.get_cell_state(coord).should == expected.get_cell_state(coord)
             rescue
                 puts "Wrong coord in x=#{x} y=#{y}"
-                puts "Got == #{got.as_string()}"
-                puts "Expected == #{expected.as_string()}"
+                puts "Got ==\n#{got.as_string()}\n"
+                puts "Expected ==\n#{expected.as_string()}\n"
                 raise
             end
         end
@@ -215,6 +215,235 @@ EOF
     return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
 end
 
+def get_6x6_hard_board_1__initial()
+    input_str = <<'EOF'
+|   1  |
+|  0  1|
+|0   0 |
+| 11   |
+|      |
+|1   0 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_hard_board_1__intermediate()
+    input_str = <<'EOF'
+|0  1  |
+|1 0  1|
+|0   0 |
+|0110  |
+|1     |
+|1   0 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_hard_board_1__final()
+    input_str = <<'EOF'
+|010110|
+|100101|
+|011001|
+|011010|
+|100110|
+|101001|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_hard_board_2__initial()
+    input_str = <<'EOF'
+| 11  1|
+|00    |
+|      |
+|  1  0|
+|      |
+|   0  |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_hard_board_2__intermediate()
+    input_str = <<'EOF'
+|011001|
+|001   |
+|1 0   |
+|  1  0|
+|  0   |
+| 1001 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_hard_board_2__intermediate_2()
+    input_str = <<'EOF'
+|011001|
+|001101|
+|100110|
+|011010|
+|100101|
+|110010|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_hard_board_3__initial()
+    input_str = <<'EOF'
+|1 0  0|
+|      |
+| 11   |
+| 1  1 |
+|     0|
+|  01  |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_hard_board_3__intermediate()
+    input_str = <<'EOF'
+|100110|
+|101001|
+|011001|
+|010110|
+|101010|
+|010101|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_10x10_easy_board_1__initial()
+    input_str = <<'EOF'
+|       1  |
+| 00  0  1 |
+| 0  1  0 0|
+|  1   1   |
+|1 1      1|
+|       1  |
+| 0  1   0 |
+|    11   0|
+| 0 0  1  0|
+|0   0   1 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_10x10_easy_board_1__final()
+    input_str = <<'EOF'
+|0110010101|
+|1001100110|
+|1001101010|
+|0110011001|
+|1010100101|
+|0101010110|
+|1001101001|
+|0110110100|
+|1010011010|
+|0101001011|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+
+def get_10x10_hard_board_1__initial()
+    input_str = <<'EOF'
+|  0       |
+|0 0  1    |
+|        1 |
+|      0  0|
+|1 00 1    |
+|          |
+|  0  1 1  |
+|1       11|
+|   0      |
+|1   1 1 1 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_10x10_hard_board_1__final()
+    input_str = <<'EOF'
+|1101100100|
+|0101011001|
+|0010101011|
+|1011010100|
+|1100110010|
+|0011001101|
+|0100110110|
+|1001001011|
+|0110010101|
+|1010101010|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_10x10_hard_board_2__initial()
+    input_str = <<'EOF'
+|   0  1  0|
+|  1 1   0 |
+| 0     10 |
+| 0        |
+|    0     |
+|  1      0|
+|   1  0   |
+| 0      0 |
+| 00    0 0|
+|   0  1 0 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_10x10_hard_board_2__final()
+    input_str = <<'EOF'
+|0110011010|
+|0110100101|
+|1001010101|
+|1001101010|
+|0110010101|
+|1011001010|
+|0101100110|
+|0010110101|
+|1001011010|
+|1100101001|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_12x12_hard_board_1__initial()
+    input_str = <<'EOF'
+|      1 1  0|
+|    0 1   1 |
+|  1 0    0 0|
+|00      1   |
+|    00   0  |
+|  0 0   1   |
+|      00 0 0|
+| 00  1      |
+|  0    1    |
+|00       0  |
+|       00   |
+|00   0      |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_12x12_hard_board_1__final()
+    input_str = <<'EOF'
+|011010101100|
+|010100110011|
+|101101010010|
+|001011001101|
+|110100110010|
+|100100101101|
+|011011001010|
+|100101010101|
+|110010110100|
+|001011001011|
+|110101100100|
+|001010011011|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
 describe "construct_board" do
     it "6*6 Easy board No. 1 should" do
 
@@ -579,4 +808,191 @@ describe "rudimentary_deduction" do
         # binding.pry
         compare_boards(board, final_board)
     end
+
+    it "Solving 6*6 Hard board No. 1 should" do
+
+        board = get_6x6_hard_board_1__initial()
+
+        board.add_to_iters_quota(1_000_000_000);
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+            ]
+        );
+
+        intermediate_board = get_6x6_hard_board_1__intermediate();
+
+        # binding.pry
+        compare_boards(board, intermediate_board)
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+            ]
+        );
+
+        intermediate_board_2 = get_6x6_hard_board_1__final();
+
+        # binding.pry
+        compare_boards(board, intermediate_board_2)
+    end
+
+    it "Solving 6*6 Hard board No. 2 should" do
+
+        board = get_6x6_hard_board_2__initial()
+
+        board.add_to_iters_quota(1_000_000_000);
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+            ]
+        );
+
+        intermediate_board = get_6x6_hard_board_2__intermediate();
+
+        # binding.pry
+        compare_boards(board, intermediate_board)
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+                :check_try_placing_last_of_certain_digit_in_row,
+            ]
+        )
+
+        final_board = get_6x6_hard_board_2__intermediate_2();
+
+        # binding.pry
+        compare_boards(board, final_board)
+    end
+
+    it "Solving 6*6 Hard board No. 3 should" do
+
+        board = get_6x6_hard_board_3__initial()
+
+        board.add_to_iters_quota(1_000_000_000);
+
+        # binding.pry
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+                :check_try_placing_last_of_certain_digit_in_row,
+            ]
+        )
+
+        intermediate_board = get_6x6_hard_board_3__intermediate()
+        # binding.pry
+
+        compare_boards(board, intermediate_board)
+    end
+
+    it "Solving 10*10 Easy board No. 1 should" do
+
+        board = get_10x10_easy_board_1__initial()
+
+        board.add_to_iters_quota(1_000_000_000);
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+                :check_try_placing_last_of_certain_digit_in_row,
+            ]
+        );
+
+        final_board = get_10x10_easy_board_1__final()
+
+        compare_boards(board, final_board)
+    end
+
+    it "Solving 10*10 Hard board No. 1 should" do
+
+        board = get_10x10_hard_board_1__initial()
+
+        board.add_to_iters_quota(1_000_000_000);
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+                :check_try_placing_last_of_certain_digit_in_row,
+            ]
+        );
+
+        board.get_cell_state(
+            Binary_Puzzle_Solver::Coord.new(:x => 9, :y => 1)
+        ).should == ONE
+
+        final_board = get_10x10_hard_board_1__final()
+
+        # binding.pry
+
+        compare_boards(board, final_board)
+    end
+
+    it "Solving 10*10 Hard board No. 2 should" do
+
+        board = get_10x10_hard_board_2__initial()
+
+        board.add_to_iters_quota(1_000_000_000);
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+                :check_try_placing_last_of_certain_digit_in_row,
+            ]
+        );
+
+        final_board = get_10x10_hard_board_2__final()
+
+        # binding.pry
+
+        compare_boards(board, final_board)
+    end
+
+    it "Solving 12*12 Hard board No. 1 should" do
+
+        board = get_12x12_hard_board_1__initial()
+
+        board.add_to_iters_quota(1_000_000_000);
+
+        board.try_to_solve_using(
+            :methods => [
+                :check_and_handle_sequences_in_row,
+                :check_and_handle_known_unknown_sameknown_in_row,
+                :check_and_handle_cells_of_one_value_in_row_were_all_found,
+                :check_exceeded_numbers_while_accounting_for_two_unknown_gaps,
+                :check_try_placing_last_of_certain_digit_in_row,
+            ]
+        );
+
+        final_board = get_12x12_hard_board_1__final()
+
+        # binding.pry
+
+        compare_boards(board, final_board)
+    end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: binary_puzzle_solver
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-06 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: launchy
@@ -52,6 +52,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CREDITS.pod
 - Gemfile
 - LICENSE.txt
 - Makefile
@@ -61,8 +62,8 @@ files:
 - lib/binary_puzzle_solver.rb
 - lib/binary_puzzle_solver/base.rb
 - lib/binary_puzzle_solver/version.rb
-- test/parse-board.rb
-homepage: http://github.com/shlomif/binary-puzzle-garden
+- test/deduction.rb
+homepage: http://www.shlomifish.org/open-source/projects/japanese-puzzle-games/binary-puzzle/
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -87,4 +88,4 @@ signing_key:
 specification_version: 3
 summary: A solver for http://www.binarypuzzle.com/ instances
 test_files:
-- test/parse-board.rb
+- test/deduction.rb