multi-puzzle-solver 1.0.8__tar.gz → 1.0.9__tar.gz

{multi_puzzle_solver-1.0.8 → multi_puzzle_solver-1.0.9}/PKG-INFO

@@ -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 → multi_puzzle_solver-1.0.9}/README.md

@@ -584,7 +584,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)
 
@@ -609,12 +617,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
@@ -1079,7 +1081,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)
 
@@ -4017,6 +4019,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 → multi_puzzle_solver-1.0.9}/src/multi_puzzle_solver.egg-info/PKG-INFO

@@ -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 → multi_puzzle_solver-1.0.9}/src/puzzle_solver/__init__.py

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

multi_puzzle_solver-1.0.9/src/puzzle_solver/puzzles/binairo/binairo.py

@@ -0,0 +1,98 @@
+from typing import Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, get_char, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+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, 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
+        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()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            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)]
+            self.model.Add(lxp.sum(row_vars) == len(row_vars) // 2)
+        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. 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:
+            self.force_unique_double_list([[self.model_vars[pos] for pos in get_row_pos(row, self.H)] for row in range(self.V)])
+            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:
+            self.force_arithmetic(self.arith_rows, Direction.RIGHT, self.V, self.H-1)
+        if self.arith_cols is not None:
+            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 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]]):
+        m = len(model_vars[0])
+        assert m <= 61, f'Too many cells for binary encoding in int64: m={m}, model_vars={model_vars}'
+        codes = []
+        pow2 = [2**k for k in range(m)]
+        for i, line in enumerate(model_vars):
+            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] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

{multi_puzzle_solver-1.0.8 → multi_puzzle_solver-1.0.9}/tests/test_binairo.py

@@ -4,6 +4,30 @@ from puzzle_solver import binairo_solver as solver
 from puzzle_solver.core.utils import get_pos
 
 
+def test_toy():
+  # tests that each row is actually unique
+  board = np.array([
+    ['B', ' ', 'B', ' '],
+    [' ', ' ', 'B', ' '],
+    ['W', ' ', ' ', ' '],
+    [' ', 'B', ' ', ' '],
+  ])
+  binst = solver.Board(board=board)
+  solutions = binst.solve_and_print()
+  assert len(solutions) == 1, f'unique solutions != 1, == {len(solutions)}'
+  solution = solutions[0].assignment
+  ground = np.array([
+    ['B', 'W', 'B', 'W'],
+    ['W', 'W', 'B', 'B'],
+    ['W', 'B', 'W', 'B'],
+    ['B', 'B', 'W', 'W'],
+  ])
+  ground_assignment = {get_pos(x=x, y=y): 1 if ground[y][x] == 'B' else 0 for x in range(ground.shape[1]) for y in range(ground.shape[0])}
+  assert set(solution.keys()) == set(ground_assignment.keys()), f'solution keys != ground assignment keys, {set(solution.keys()) ^ set(ground_assignment.keys())} \n\n\n{solution} \n\n\n{ground_assignment}'
+  for pos in solution.keys():
+    assert solution[pos] == ground_assignment[pos], f'solution[{pos}] != ground_assignment[{pos}], {solution[pos]} != {ground_assignment[pos]}'
+
+
 def test_easy():
   # 6x6 easy
   # https://www.puzzle-binairo.com/binairo-6x6-easy/?e=MDoxLDkxMSwwMzg=
@@ -121,6 +145,7 @@ def test_ground():
 
 
 if __name__ == '__main__':
+  test_toy()
   test_easy()
   test_easy_2()
   test_ground()

multi_puzzle_solver-1.0.8/src/puzzle_solver/puzzles/binairo/binairo.py

@@ -1,126 +0,0 @@
-from typing import Optional
-
-import numpy as np
-from ortools.sat.python import cp_model
-from ortools.sat.python.cp_model import LinearExpr as lxp
-
-from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, get_char, get_row_pos, get_col_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
-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):
-        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
-        assert all(c.item() in [' ', 'B', 'W'] for c in np.nditer(board)), 'board must contain only space or B'
-        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.model = cp_model.CpModel()
-        self.model_vars: dict[Pos, cp_model.IntVar] = {}
-
-        self.create_vars()
-        self.add_all_constraints()
-
-    def create_vars(self):
-        for pos in get_all_pos(self.V, self.H):
-            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
-
-    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)
-        # 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)]
-            self.model.Add(lxp.sum(row_vars) == len(row_vars) // 2)
-        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)
-
-        # 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)])
-        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)])
-
-
-    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(),
-        ])
-
-    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}"
-
-        codes = []
-        pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
-        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)))
-            codes.append(code)
-
-        self.model.AddAllDifferent(codes)
-
-    def solve_and_print(self, verbose: bool = True):
-        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for pos, var in board.model_vars.items():
-                assignment[pos] = solver.Value(var)
-            return SingleSolution(assignment=assignment)
-        def callback(single_res: SingleSolution):
-            print("Solution found")
-            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
-        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)