multi-puzzle-solver 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

{multi_puzzle_solver-1.0.8.dist-info → multi_puzzle_solver-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 1.0.8
+Version: 1.0.9
 Summary: Efficient solvers for countless (50+) types of puzzles (like Sudoku, Minesweeper, etc.) with a simple python API.
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver
@@ -610,7 +610,15 @@ Time taken: 0.04 seconds
 
 ## Sudoku (Puzzle Type #2)
 
-Also known as Number Place and Solo.
+Also known as Number Place and Solo. 
+
+The code can:
+
+1. Solve arbitrarily sized valid board sizes, thus can be used to solve:
+   - Hex Sudoku (a 16x16 variant) 
+   - Kidoku (a kid-friendly sudoku variant)
+2. Solve the ["Sandwich" sudoku variant](https://dkmgames.com/SandwichSudoku/) using the optional parameter `sandwich={'side': [...], 'bottom': [...]}`
+3. Solve the ["Sudoku-X" variant](https://www.sudopedia.org/wiki/Sudoku-X) using the optional parameter `unique_diagonal=True`
 
 * [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/solo.html)
 
@@ -635,12 +643,6 @@ You are given some of the numbers as clues; your aim is to place the rest of the
 
 Code to utilize this package and solve the puzzle:
 
-Note: 
-
-- The solver also supports solving the ["Sandwich" sudoku variant](https://dkmgames.com/SandwichSudoku/) through the optional parameter ``sandwich={'side': [...], 'bottom': [...] }``。
-
-- The solver also supports solving the ["Sudoku-X" variant](https://www.sudopedia.org/wiki/Sudoku-X) through the optional parameter ``unique_diagonal=True``。
-
 ```python
 import numpy as np
 from puzzle_solver import sudoku_solver as solver
@@ -1105,7 +1107,7 @@ Time taken: 0.15 seconds
 
 ## Keen (Puzzle Type #8)
 
-Also known as KenKen or CalcuDoku.
+Also known as KenKen, CalcuDoku, Inkies, or Inky.
 
 * [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/keen.html)
 
@@ -4043,6 +4045,8 @@ Applying the solution to the puzzle visually:
 
 ## Binairo (Puzzle Type #41)
 
+Also known as Takuzu, Binero, Tohu-Wa-Vohu (Formless and Empty), Eins und Zwei (One and Two), Binary Puzzles, Binoxxo, Binox, Zernero, Tic-Tac-Logic, and Sudoku Binary.
+
 * [**Play online**](https://www.puzzle-binairo.com)
 
 * [**Solver Code**][41]

{multi_puzzle_solver-1.0.8.dist-info → multi_puzzle_solver-1.0.9.dist-info}/RECORD

@@ -1,11 +1,11 @@
-puzzle_solver/__init__.py,sha256=0jnYSJY4kJBhX5PU4UMmMcbTg8PsyFjiX0y23r5sv5k,5502
+puzzle_solver/__init__.py,sha256=mCXXxGttWhDOTXSDFI2CrplOLmSFVF9r_XygisFqiAY,5502
 puzzle_solver/core/utils.py,sha256=FE0106dfQRsgCn2FRBvRq5zILLK7-Z3cPHkAlBWUX0w,8785
 puzzle_solver/core/utils_ortools.py,sha256=ACV3HgKWpEUTt1lpqsPryK1DeZpu7kdWQKEWTLJ2tfs,10384
 puzzle_solver/core/utils_visualizer.py,sha256=3EJ7V8rHyasj1peAzplDJfKkPy6Yj9j7BXqMBWQ3eNg,22834
 puzzle_solver/puzzles/abc_view/abc_view.py,sha256=Qr0rZKmKQ2teStHjQ5VPQ4k-XptsjJAlZ1WXWk5Aax4,4570
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=dGqYEWMoh4di5DN4sd-GtYb6QeTpVYFQJHBkrrmrudQ,5649
 puzzle_solver/puzzles/battleships/battleships.py,sha256=U4xJ_NJC2baHvfaAfJ01YEBjixq9gD0h8GP9L1V-_oM,7223
-puzzle_solver/puzzles/binairo/binairo.py,sha256=qKvpixLIBUcugAyJgpBGHV-9q_4nzA1ZOxeDFnltsXA,6843
+puzzle_solver/puzzles/binairo/binairo.py,sha256=EBpXYD9Mxuig4uJl3xkcQ6_tbnoG13mVV7RZpQEXm38,5790
 puzzle_solver/puzzles/binairo/binairo_plus.py,sha256=TvLG3olwANtft3LuCF-y4OofpU9PNa4IXDqgZqsD-g0,267
 puzzle_solver/puzzles/black_box/black_box.py,sha256=RXTXQhMAb_Oce9Mk1XpouniYIyy9k3kYGdey-SEeRMU,12559
 puzzle_solver/puzzles/bridges/bridges.py,sha256=QwOhZyO5urbatkNyPmQxZ_lGM01ZejndMr_eoiBkr7g,5394
@@ -69,7 +69,7 @@ puzzle_solver/puzzles/unruly/unruly.py,sha256=_C6FhYm9rqwhlQa6TMTxYr3rWcP_QS-E93
 puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=D0JacUdK5yPrfScmGqX-p8144VbwxfDgIaqF8hwLXlM,5039
 puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=drjfoHqmFf6U-ZQUwrBbfGINRxDQpgbvy4U3D9QyMhM,6617
 puzzle_solver/utils/visualizer.py,sha256=T2g5We9J3tkhyXWoN2OrIDIJDjt6w5sDd2ksOub0ZI8,6819
-multi_puzzle_solver-1.0.8.dist-info/METADATA,sha256=E6zK6c0vVluGrFEvS459AuNa33dET9IWNdmqtIbYJwA,456018
-multi_puzzle_solver-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-1.0.8.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-1.0.8.dist-info/RECORD,,
+multi_puzzle_solver-1.0.9.dist-info/METADATA,sha256=DsMyTWC0gI51MbgX6UecmA6jdP_pbGE-RLrHCK9Cyhk,456299
+multi_puzzle_solver-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-1.0.9.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-1.0.9.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -121,4 +121,4 @@ __all__ = [
     inertia_image_parser,
 ]
 
-__version__ = '1.0.8'
+__version__ = '1.0.9'

puzzle_solver/puzzles/binairo/binairo.py

@@ -10,26 +10,21 @@ from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
-    def __init__(self, board: np.array, arith_rows: Optional[np.array] = None, arith_cols: Optional[np.array] = None, force_unique: bool = True):
+    def __init__(self, board: np.array, arith_rows: Optional[np.array] = None, arith_cols: Optional[np.array] = None, force_unique: bool = True, disallow_three: bool = True):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] % 2 == 0 and board.shape[1] % 2 == 0, f'board must have even number of rows and columns, got {board.shape[0]}x{board.shape[1]}'
         assert all(c.item() in [' ', 'B', 'W'] for c in np.nditer(board)), 'board must contain only space or B'
+        assert arith_rows is None or all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_rows)), 'arith_rows must contain only space, x, or ='
+        assert arith_cols is None or all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_cols)), 'arith_cols must contain only space, x, or ='
         self.board = board
         self.V, self.H = board.shape
-        if arith_rows is not None:
-            assert arith_rows.ndim == 2, f'arith_rows must be 2d, got {arith_rows.ndim}'
-            assert arith_rows.shape == (self.V, self.H-1), f'arith_rows must be one column less than board, got {arith_rows.shape} for {board.shape}'
-            assert all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_rows)), 'arith_rows must contain only space, x, or ='
-        if arith_cols is not None:
-            assert arith_cols.ndim == 2, f'arith_cols must be 2d, got {arith_cols.ndim}'
-            assert arith_cols.shape == (self.V-1, self.H), f'arith_cols must be one column and row less than board, got {arith_cols.shape} for {board.shape}'
-            assert all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_cols)), 'arith_cols must contain only space, x, or ='
         self.arith_rows = arith_rows
         self.arith_cols = arith_cols
         self.force_unique = force_unique
+        self.disallow_three = disallow_three
 
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
-
         self.create_vars()
         self.add_all_constraints()
 
@@ -39,11 +34,9 @@ class Board:
 
     def add_all_constraints(self):
         for pos in get_all_pos(self.V, self.H):  # force clues
-            c = get_char(self.board, pos)
-            if c == 'B':
-                self.model.Add(self.model_vars[pos] == 1)
-            elif c == 'W':
-                self.model.Add(self.model_vars[pos] == 0)
+            c = get_char(self.board, pos).strip()
+            if c:
+                self.model.Add(self.model_vars[pos] == (c == 'B'))
         # 1. Each row and each column must contain an equal number of white and black circles.
         for row in range(self.V):
             row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.H)]
@@ -51,69 +44,48 @@ class Board:
         for col in range(self.H):
             col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.V)]
             self.model.Add(lxp.sum(col_vars) == len(col_vars) // 2)
-        # 2. More than two circles of the same color can't be adjacent.
-        for pos in get_all_pos(self.V, self.H):
-            self.disallow_three_in_a_row(pos, Direction.RIGHT)
-            self.disallow_three_in_a_row(pos, Direction.DOWN)
-
+        # 2. No three consecutive cells of the same color
+        if self.disallow_three:
+            for pos in get_all_pos(self.V, self.H):
+                self.disallow_three_in_a_row(pos, Direction.RIGHT)
+                self.disallow_three_in_a_row(pos, Direction.DOWN)
         # 3. Each row and column is unique.
         if self.force_unique:
-            # a list per row
             self.force_unique_double_list([[self.model_vars[pos] for pos in get_row_pos(row, self.H)] for row in range(self.V)])
-            # a list per column
             self.force_unique_double_list([[self.model_vars[pos] for pos in get_col_pos(col, self.V)] for col in range(self.H)])
-
         # if arithmetic is provided, add constraints for it
         if self.arith_rows is not None:
-            assert self.arith_rows.shape == (self.V, self.H-1), f'arith_rows must be one column less than board, got {self.arith_rows.shape} for {self.board.shape}'
-            for pos in get_all_pos(self.V, self.H-1):
-                c = get_char(self.arith_rows, pos)
-                if c == 'x':
-                    self.model.Add(self.model_vars[pos] != self.model_vars[get_next_pos(pos, Direction.RIGHT)])
-                elif c == '=':
-                    self.model.Add(self.model_vars[pos] == self.model_vars[get_next_pos(pos, Direction.RIGHT)])
+            self.force_arithmetic(self.arith_rows, Direction.RIGHT, self.V, self.H-1)
         if self.arith_cols is not None:
-            assert self.arith_cols.shape == (self.V-1, self.H), f'arith_cols must be one row less than board, got {self.arith_cols.shape} for {self.board.shape}'
-            for pos in get_all_pos(self.V-1, self.H):
-                c = get_char(self.arith_cols, pos)
-                if c == 'x':
-                    self.model.Add(self.model_vars[pos] != self.model_vars[get_next_pos(pos, Direction.DOWN)])
-                elif c == '=':
-                    self.model.Add(self.model_vars[pos] == self.model_vars[get_next_pos(pos, Direction.DOWN)])
-
+            self.force_arithmetic(self.arith_cols, Direction.DOWN, self.V-1, self.H)
 
     def disallow_three_in_a_row(self, p1: Pos, direction: Direction):
         p2 = get_next_pos(p1, direction)
         p3 = get_next_pos(p2, direction)
-        if any(not in_bounds(p, self.V, self.H) for p in [p1, p2, p3]):
-            return
-        self.model.AddBoolOr([
-            self.model_vars[p1],
-            self.model_vars[p2],
-            self.model_vars[p3],
-        ])
-        self.model.AddBoolOr([
-            self.model_vars[p1].Not(),
-            self.model_vars[p2].Not(),
-            self.model_vars[p3].Not(),
-        ])
+        if all(in_bounds(p, self.V, self.H) for p in [p1, p2, p3]):
+            self.model.AddBoolOr([self.model_vars[p1], self.model_vars[p2], self.model_vars[p3]])
+            self.model.AddBoolOr([self.model_vars[p1].Not(), self.model_vars[p2].Not(), self.model_vars[p3].Not()])
 
     def force_unique_double_list(self, model_vars: list[list[cp_model.IntVar]]):
-        if not model_vars or len(model_vars) < 2:
-            return
         m = len(model_vars[0])
-        assert m <= 61, f"Too many cells for binary encoding in int64: m={m}, model_vars={model_vars}"
-
+        assert m <= 61, f'Too many cells for binary encoding in int64: m={m}, model_vars={model_vars}'
         codes = []
-        pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
+        pow2 = [2**k for k in range(m)]
         for i, line in enumerate(model_vars):
-            code = self.model.NewIntVar(0, (1 << m) - 1, f"code_{i}")
-            # Sum 2^k * r[k] == code
-            self.model.Add(code == sum(pow2[k] * line[k] for k in range(m)))
+            code = self.model.NewIntVar(0, 2**m, f"code_{i}")
+            self.model.Add(code == lxp.weighted_sum(line, pow2))  # Sum 2^k * r[k] == code
             codes.append(code)
-
         self.model.AddAllDifferent(codes)
 
+    def force_arithmetic(self, arith_board: np.array, direction: Direction, V: int, H: int):
+        assert arith_board.shape == (V, H), f'arith_board going {direction} expected shape {V}x{H}, got {arith_board.shape}'
+        for pos in get_all_pos(V, H):
+            c = get_char(arith_board, pos).strip()
+            if c == 'x':
+                self.model.Add(self.model_vars[pos] != self.model_vars[get_next_pos(pos, direction)])
+            elif c == '=':
+                self.model.Add(self.model_vars[pos] == self.model_vars[get_next_pos(pos, direction)])
+
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, int] = {}