binary_puzzle_solver 0.0.3 → 0.0.4

data/bin/binary-puzzle-solve

@@ -3,6 +3,10 @@
 require 'binary_puzzle_solver'
 
 filename = ARGV.shift
+if (not filename)
+    raise "Missing path to the file containing a layout."
+end
+
 board = Binary_Puzzle_Solver.gen_board_from_string_v1(IO.read(filename))
 
 board.add_to_iters_quota(1_000_000_000);
@@ -13,6 +17,7 @@ board.try_to_solve_using(
         :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,
+        :check_try_placing_last_of_certain_digit_in_row_to_avoid_dups,
     ]
 );
 

data/lib/binary_puzzle_solver/base.rb

@@ -80,15 +80,19 @@ module Binary_Puzzle_Solver
             return
         end
 
-        def get_char()
-            if state == ZERO
+        def self.get_state_char(val)
+            if val == ZERO
                 return '0'
-            elsif state == ONE
+            elsif val == ONE
                 return '1'
             else
-                raise RuntimeError, "get_char() called on Unset state"
+                raise RuntimeError, "get_state_char() called on Unset state"
             end
         end
+
+        def get_char()
+            return Cell.get_state_char(state)
+        end
     end
 
     # A summary for a row or column.
@@ -165,6 +169,7 @@ module Binary_Puzzle_Solver
     class Board
 
         attr_reader :iters_quota, :num_iters_done
+
         def initialize (params)
             @dim_limits = {:x => params[:x], :y => params[:y]}
             @cells = dim_range(:y).map {
@@ -174,6 +179,10 @@ module Binary_Puzzle_Solver
                 :x => dim_range(:x).map { RowSummary.new(limit(:y)); },
                 :y => dim_range(:y).map { RowSummary.new(limit(:x)); }
             }
+            @complete_rows_map = {
+                :x => Hash.new,
+                :y => Hash.new
+            }
             @old_moves = []
             @new_moves = []
 
@@ -258,10 +267,37 @@ module Binary_Puzzle_Solver
             return @cells[y][x]
         end
 
+        def list_views
+            return [false, true].map { |v| get_view(:rotate => v) }
+        end
+
+        def get_complete_map(dir)
+            return @complete_rows_map[dir]
+        end
+
         def set_cell_state(coord, state)
             _get_cell(coord).set_state(state)
-            get_row_summary(:dim => :x, :idx => coord.x).inc_count(state)
-            get_row_summary(:dim => :y, :idx => coord.y).inc_count(state)
+
+            mymap = @complete_rows_map
+            list_views().each do |v|
+                row_dim = v.row_dim()
+                real_row_dim = v.mapped_row_dim()
+                row_idx = coord.method(real_row_dim).call()
+                summary = v.get_row_summary(:dim => row_dim, :idx => row_idx)
+
+                # puts "Coord = (x=#{coord.x},y=#{coord.y}) row_dim = #{row_dim} RowIdx = #{row_idx} mapped_row_dim = #{v.mapped_row_dim}"
+                summary.inc_count(state)
+
+                if summary.are_both_full() then
+                    str = v.get_row_handle(row_idx).get_string()
+                    mymap[real_row_dim][str] ||= []
+                    arr = mymap[real_row_dim][str]
+                    arr << row_idx
+                    if (arr.length > 1) then
+                        raise GameIntegrityException, "Duplicate rows at dim #{row_dim} #{arr.join(',')}"
+                    end
+                end
+            end
             return
         end
 
@@ -300,7 +336,7 @@ module Binary_Puzzle_Solver
 
         def try_to_solve_using (params)
             methods_list = params[:methods]
-            views = [get_view(:rotate => false), get_view(:rotate => true), ]
+            views = list_views()
 
             catch :out_of_iters do
                 first_iter = true
@@ -349,11 +385,9 @@ module Binary_Puzzle_Solver
         end
 
         def validate()
-            views = [get_view(:rotate => false), get_view(:rotate => true), ]
-
             is_final = true
 
-            views.each do |v|
+            list_views().each do |v|
                 view_final = v.validate_rows()
                 is_final &&= view_final
             end
@@ -423,6 +457,14 @@ module Binary_Puzzle_Solver
             return :x
         end
 
+        def mapped_row_dim()
+            return _calc_mapped_dir(row_dim())
+        end
+
+        def get_complete_row_map()
+            return @board.get_complete_map(mapped_row_dim())
+        end
+
         def get_row_handle(idx)
             return RowHandle.new(self, idx)
         end
@@ -444,8 +486,14 @@ module Binary_Puzzle_Solver
             return
         end
 
+        def set_cell_state(coord, state)
+            @board.set_cell_state(
+                _calc_mapped_coord(coord), state
+            )
+        end
+
         def perform_and_append_move(params)
-            set_cell_state(params[:coord], params[:val])
+            set_cell_state( params[:coord], params[:val] )
             _append_move(params)
         end
 
@@ -647,9 +695,55 @@ module Binary_Puzzle_Solver
             end
         end
 
+        def _do_values_have_a_three_in_a_row(params)
+            row_idx = params[:idx]
+            v_s = params[:v_s]
+
+            return {
+                :verdict => ((0 .. (v_s.length - 3)).to_a.index { |i|
+                    (1 .. 2).all? { |offset| v_s[i] == v_s[i+offset] }
+                }),
+                :reason => "Trying opposite value that is the last remaining results in three-in-a-row",
+            }
+        end
+
+        def _are_values_duplicates(params)
+            row_idx = params[:idx]
+            v_s = params[:v_s]
+
+            str = RowHandle.calc_iter_of_states_str(v_s)
+            mymap = get_complete_row_map()
+
+            verdict = (mymap.has_key?(str) and (mymap[str].length > 0));
+
+            return {
+                :verdict => verdict,
+                :reason => "Trying opposite value that is the last remaining results in a duplicate row",
+            }
+        end
+
+        def check_try_placing_last_of_certain_digit_in_row_to_avoid_dups(params)
+            row_idx = params[:idx]
+
+            return _generic_check_try_placing_last_digit(
+                :idx => row_idx,
+                :callback_method => :_are_values_duplicates,
+            )
+        end
+
         def check_try_placing_last_of_certain_digit_in_row(params)
             row_idx = params[:idx]
 
+            return _generic_check_try_placing_last_digit(
+                :idx => row_idx,
+                :callback_method => :_do_values_have_a_three_in_a_row,
+            )
+        end
+
+        def _generic_check_try_placing_last_digit(params)
+            row_idx = params[:idx]
+            callback_method = params[:callback_method]
+
             row = get_row_handle(row_idx)
 
             summary = row.get_summary()
@@ -676,16 +770,18 @@ module Binary_Puzzle_Solver
                 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()
+                result = method(callback_method).call(
+                    :idx => row_idx, :v_s => v_s
                 )
-                return
+
+                if (result[:verdict])
+                    perform_and_append_move(
+                        :coord => row.get_coord(x),
+                        :val => oppose_v,
+                        :reason => result[:reason],
+                        :dir => col_dim()
+                    )
+                    return
                 end
             end
 
@@ -693,19 +789,18 @@ module Binary_Puzzle_Solver
         end
 
         def validate_rows()
-            # TODO
-            complete_rows_map = Hash.new
-
             is_final = true
 
             dim_range(row_dim()).each do |row_idx|
                 row = get_row_handle(row_idx)
-                ret = row.validate( :complete_rows_map => complete_rows_map )
+                ret = row.validate(:foo => false)
                 is_final &&= ret[:is_final]
             end
 
             return is_final
         end
+
+        private :_do_values_have_a_three_in_a_row, :_generic_check_try_placing_last_digit, :_are_values_duplicates
     end
 
     class RowHandle
@@ -719,8 +814,14 @@ module Binary_Puzzle_Solver
             return view.get_row_summary(:idx => idx, :dim => row_dim());
         end
 
+        def self.calc_iter_of_states_str(iter)
+            return iter.map { |v| Cell.get_state_char(v) }.join('')
+        end
+
         def get_string()
-            return iter_of_handles().map { |cell_h| cell_h.get_char() }.join('')
+            return RowHandle.calc_iter_of_states_str(
+                iter_of_handles().map { |cell_h| cell_h.get_state() }
+            )
         end
 
         def col_dim()
@@ -770,21 +871,12 @@ module Binary_Puzzle_Solver
                 x.get_state() == v }.map { |h| h.x }
         end
 
-        def check_for_duplicated(complete_rows_map)
+        def check_for_duplicated()
             summary = get_summary()
 
             if not summary.are_both_not_exceeded() then
                 raise GameIntegrityException, "Value exceeded"
             elsif summary.are_both_full() then
-                s = get_string()
-                complete_rows_map[s] ||= []
-                dups = complete_rows_map[s]
-                dups << idx
-                if (dups.length > 1)
-                    i, j = dups[0], dups[1]
-                    raise GameIntegrityException, \
-                        "Duplicate Rows - #{i} and #{j}"
-                end
                 return true
             else
                 return false
@@ -823,11 +915,9 @@ module Binary_Puzzle_Solver
         end
 
         def validate(params)
-            complete_rows_map = params[:complete_rows_map]
-
             check_for_too_many_consecutive()
 
-            return { :is_final => check_for_duplicated(complete_rows_map), };
+            return { :is_final => check_for_duplicated(), };
         end
     end
 

data/lib/binary_puzzle_solver/version.rb

@@ -1,3 +1,3 @@
 module Binary_Puzzle_Solver
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
 end

data/test/data/boards/12x12_hard_no_1.binpuz.board

@@ -0,0 +1,12 @@
+|      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      |

data/test/data/boards/2013-06-07-12x12_very_hard.binpuz.board

@@ -0,0 +1,12 @@
+|0   0  1 1  |
+|       1  0 |
+|   11    0  |
+|0  1 01    0|
+|        0  0|
+| 1          |
+|  0    11  1|
+|1  1     0  |
+| 00 0  0   0|
+|            |
+| 1 1  0 0   |
+|    0     10|

data/test/deduction.rb

@@ -444,6 +444,102 @@ EOF
     return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
 end
 
+def get_6x6_very_hard_board_1__initial()
+    input_str = <<'EOF'
+|  1   |
+|00 1  |
+|0     |
+|      |
+|   1  |
+|    0 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_very_hard_board_1__intermediate_1()
+    input_str = <<'EOF'
+|101010|
+|001101|
+|010011|
+|1  010|
+|   10 |
+| 1010 |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_very_hard_board_1__final()
+    input_str = <<'EOF'
+|101010|
+|001101|
+|010011|
+|110010|
+|101100|
+|010101|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_very_hard_board_2__initial()
+    input_str = <<'EOF'
+| 0    |
+|      |
+|1     |
+| 0  0 |
+|1  0  |
+| 0   0|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_6x6_very_hard_board_2__final()
+    input_str = <<'EOF'
+|001011|
+|010011|
+|110100|
+|001101|
+|110010|
+|101100|
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_12x12_very_hard_board_1__initial()
+    input_str = <<'EOF'
+|       00 1 |
+|  1       1 |
+|   0 0  0  0|
+|     0      |
+| 11 1  1 0  |
+| 11 0 00    |
+|          1 |
+|1  00   0   |
+|            |
+|  1     1   |
+|   0  0  0 0|
+|  10   0    |
+EOF
+    return Binary_Puzzle_Solver.gen_board_from_string_v1(input_str)
+end
+
+def get_12x12_very_hard_board_1__intermediate_1()
+    input_str = <<'EOF'
+|110100100110|
+|001101001011|
+|110010110100|
+|100100101101|
+|011011010010|
+|011001001101|
+|100110110010|
+|101001010011|
+|010110101100|
+|001101011001|
+|110011010010|
+|001010101101|
+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
 
@@ -995,4 +1091,97 @@ describe "rudimentary_deduction" do
 
         compare_boards(board, final_board)
     end
+
+    it "Solving 6*6 Very Hard board No. 1 should" do
+
+        board = get_6x6_very_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,
+            ]
+        );
+
+        intermediate_board = get_6x6_very_hard_board_1__intermediate_1()
+
+        # 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,
+                :check_try_placing_last_of_certain_digit_in_row_to_avoid_dups,
+            ]
+        );
+
+        board.get_cell_state(
+            Binary_Puzzle_Solver::Coord.new(:x => 1, :y => 3)
+        ).should == ONE
+        board.get_cell_state(
+            Binary_Puzzle_Solver::Coord.new(:x => 2, :y => 3)
+        ).should == ZERO
+
+        final_board = get_6x6_very_hard_board_1__final()
+
+        compare_boards(board, final_board)
+    end
+
+    it "Solving 6*6 Very Hard board No. 2 should" do
+
+        board = get_6x6_very_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,
+                :check_try_placing_last_of_certain_digit_in_row_to_avoid_dups,
+            ]
+        );
+
+        final_board = get_6x6_very_hard_board_2__final()
+
+        # binding.pry
+
+        compare_boards(board, final_board)
+    end
+
+    it "Solving 12*12 Very Hard board No. 1 should" do
+
+        board = get_12x12_very_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,
+                :check_try_placing_last_of_certain_digit_in_row_to_avoid_dups,
+            ]
+        );
+
+        final_board = get_12x12_very_hard_board_1__intermediate_1()
+
+        # 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.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-28 00:00:00.000000000 Z
+date: 2013-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: launchy
@@ -64,6 +64,8 @@ files:
 - lib/binary_puzzle_solver.rb
 - lib/binary_puzzle_solver/base.rb
 - lib/binary_puzzle_solver/version.rb
+- test/data/boards/12x12_hard_no_1.binpuz.board
+- test/data/boards/2013-06-07-12x12_very_hard.binpuz.board
 - test/deduction.rb
 homepage: http://www.shlomifish.org/open-source/projects/japanese-puzzle-games/binary-puzzle/
 licenses: []
@@ -90,4 +92,6 @@ signing_key:
 specification_version: 3
 summary: A solver for http://www.binarypuzzle.com/ instances
 test_files:
+- test/data/boards/12x12_hard_no_1.binpuz.board
+- test/data/boards/2013-06-07-12x12_very_hard.binpuz.board
 - test/deduction.rb