multi-puzzle-solver 0.9.20__py3-none-any.whl → 0.9.22__py3-none-any.whl

{multi_puzzle_solver-0.9.20.dist-info → multi_puzzle_solver-0.9.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.20
+Version: 0.9.22
 Summary: Efficient solvers for numerous popular and esoteric logic puzzles using CP-SAT
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver
@@ -309,6 +309,11 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
       <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/slitherlink_solved.png" alt="Slitherlink" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#yin-yang-puzzle-type-40"><b>Yin-Yang</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/yin_yang_solved.png" alt="Yin-Yang" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -363,6 +368,7 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Unequal (Puzzle Type #37)](#unequal-puzzle-type-37)
   - [Norinori (Puzzle Type #38)](#norinori-puzzle-type-38)
   - [Slitherlink (Puzzle Type #39)](#slitherlink-puzzle-type-39)
+  - [Yin-Yang (Puzzle Type #40)](#yin-yang-puzzle-type-40)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -488,6 +494,13 @@ You are given some of the numbers as clues; your aim is to place the rest of the
 <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/sudoku_unsolved.png" alt="Sudoku unsolved" width="500">
 
 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
@@ -2220,6 +2233,7 @@ The numbers outside the grid show the number of filled cells horizontally and ve
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
 from puzzle_solver import thermometers_solver as solver
 board = np.array([
   ['R', 'R', 'D', 'R', 'D', 'R', 'X', 'D', 'L', 'X', 'L', 'L', 'L', 'L', 'L'],
@@ -2299,6 +2313,7 @@ The numbers outside the grid show the number of filled cells horizontally and ve
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
 from puzzle_solver import aquarium_solver as solver
 board = np.array([
   ['01', '01', '01', '01', '02', '02', '02', '03', '03', '03', '03', '04', '05', '05', '05'],
@@ -2376,6 +2391,7 @@ Time taken: 0.02 seconds
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
 from puzzle_solver import stitches_solver as solver
 board = np.array([
   ["00", "00", "00", "00", "00", "01", "01", "01", "01", "01", "01", "01", "01", "02", "02"],
@@ -2456,6 +2472,7 @@ Time taken: 0.01 seconds
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
 from puzzle_solver import battleships_solver as solver
 board = np.array([
   [' ', ' ', ' ', ' ', ' ', 'S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
@@ -2538,6 +2555,7 @@ The goal is to make some of the cells black in such a way that:
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
 from puzzle_solver import kakurasu_solver as solver
 side = np.array([27, 6, 1, 12, 37, 37, 11, 4, 29, 23, 66, 55])
 bottom = np.array([22, 1, 25, 36, 10, 22, 25, 35, 32, 28, 45, 45])
@@ -2598,6 +2616,7 @@ Code to utilize this package and solve the puzzle:
 Note that as usual the board is an id of the shape (id is meaningless, just used to identify one shape), and the `star_count` parameter depenends on the puzzle type.
 
 ```python
+import numpy as np
 from puzzle_solver import star_battle_solver as solver
 board = np.array([
   ['00', '00', '00', '00', '00', '01', '01', '01', '01', '01', '01', '01', '01', '01', '02', '02', '02', '03', '03', '03', '03', '03', '03', '03', '03'],
@@ -2697,7 +2716,8 @@ Code to utilize this package and solve the puzzle:
 The `star_count` parameter depenends on the puzzle type.
 
 ```python
-from puzzle_solver import star_battle_shapeless_solver as shapeless_solver
+import numpy as np
+from puzzle_solver import star_battle_shapeless as solver
 board = np.array([
   [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], 
   ['B', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], 
@@ -2710,7 +2730,7 @@ board = np.array([
   ['B', 'B', ' ', ' ', ' ', ' ', 'B', 'B', 'B', ' '], 
   ['B', ' ', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' '], 
 ])
-binst = shapeless_solver.Board(board=board, star_count=2)
+binst = solver.Board(board=board, star_count=2)
 solutions = binst.solve_and_print()
 ```
 
@@ -2767,6 +2787,8 @@ Note: The solver is capable of solving variations where the puzzle pieces the ma
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
+from puzzle_solver import lits_solver as solver
 board = np.array([
   ['00', '00', '00', '01', '01', '02', '02', '02', '03', '03', '03', '04', '04', '05', '06', '07', '07', '08', '08', '09'],
   ['00', '00', '00', '00', '01', '02', '03', '03', '03', '10', '04', '04', '05', '05', '06', '07', '08', '08', '09', '09'],
@@ -2963,6 +2985,7 @@ Code to utilize this package and solve the puzzle:
 Note: The number are arbitrary and simply number each galaxy as an integer.
 
 ```python
+import numpy as np
 from puzzle_solver import galaxies_solver as solver
 galaxies = np.array([
     ['  ', '  ', '00', '  ', '  ', '01', '01', '02', '02', '03', '03', '  ', '04', '04', '  '],
@@ -3047,6 +3070,7 @@ Code to utilize this package and solve the puzzle:
 Note: For an NxM board you need an (N+1)x(M+1) array because the puzzle is to solve for the cells while the input is the values at the corners (there's always one more corner than cells in each dimension).
 
 ```python
+import numpy as np
 from puzzle_solver import slant_solver as solver
 board = np.array([
     [' ', ' ', '1', ' ', '1', ' ', '1', ' ', '1', ' ', ' ', ' ', ' '],
@@ -3131,6 +3155,7 @@ Code to utilize this package and solve the puzzle:
 Note: For an NxM board you need an (2N-1)x(2M-1) array because the puzzle involves input in between the cells. Each numbered cell has neighbors horizontally to represent ">", "<", and "|" (where "|" represents adjacency) and vertically to represent "∧", "∨" and "-" (where "-" represents adjacency). The "X" in the input are unused corners that shouldnt contain anything (just a corner). The numbers should never appear orthogonal to an "X", only diagonally to it. vice-versa for the comparison operators.
 
 ```python
+import numpy as np
 from puzzle_solver import unequal_solver as solver
 board = np.array([
     [' ', ' ', ' ', ' ', '9', ' ', '1', ' ', '7', '>', ' ', '>', ' ', ' ', ' ', ' ', ' ', '>', ' '],
@@ -3210,6 +3235,7 @@ You have to shade some of the cells in such a way that:
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
 from puzzle_solver import norinori_solver as solver
 board = np.array([
     ['00', '01', '01', '01', '01', '02', '03', '03', '04', '04', '04', '05', '05', '05', '06', '07', '08', '08', '09', '09'],
@@ -3299,6 +3325,7 @@ A line forming a single loop without crossings or branches means that every corn
 Code to utilize this package and solve the puzzle:
 
 ```python
+import numpy as np
 from puzzle_solver import slitherlink_solver as solver
 board = np.array([
     ['3', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', '1', ' '],
@@ -3385,6 +3412,97 @@ Applying the solution to the puzzle visually:
 
 ---
 
+
+## Yin-Yang (Puzzle Type #40)
+
+* [**Play online**](https://www.puzzle-yin-yang.com)
+
+* [**Solver Code**][40]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+Yin-Yang is played on a rectangular grid with no standard size. Some cells start out filled with black or white. The rest of the cells are empty. The goal is to color all cells in such a way that:
+1. All black cells should be connected orthogonally in a single group.
+2. All white cells should be connected orthogonally in a single group.
+3. 2x2 areas of the same color are not allowed.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/yin_yang_unsolved.png" alt="Yin-Yang unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+import numpy as np
+from puzzle_solver import yin_yang_solver as solver
+board = np.array([
+  [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+  [' ', ' ', ' ', ' ', ' ', 'W', ' ', ' ', ' ', 'B', ' ', ' ', 'W', ' ', 'W', ' ', ' ', 'W', ' ', ' '],
+  [' ', ' ', 'B', ' ', 'B', ' ', 'W', ' ', ' ', 'W', 'B', ' ', ' ', ' ', ' ', 'W', ' ', 'W', ' ', ' '],
+  [' ', ' ', ' ', ' ', ' ', 'W', ' ', 'W', ' ', 'B', ' ', ' ', ' ', ' ', 'W', ' ', ' ', 'W', ' ', ' '],
+  [' ', 'W', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'W', 'W', ' ', ' ', ' ', ' ', ' ', ' ', 'W', ' ', ' '],
+  [' ', ' ', ' ', ' ', 'W', ' ', ' ', ' ', 'W', 'B', ' ', ' ', ' ', ' ', ' ', 'W', ' ', 'W', ' ', ' '],
+  [' ', ' ', ' ', ' ', ' ', 'W', ' ', ' ', ' ', ' ', 'B', ' ', 'B', ' ', 'B', 'W', ' ', 'W', ' ', ' '],
+  [' ', ' ', 'B', 'W', 'W', ' ', 'W', ' ', ' ', ' ', 'B', ' ', 'B', ' ', 'B', ' ', ' ', ' ', ' ', ' '],
+  [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', 'B', ' ', 'B', ' ', 'B', ' ', 'B', ' ', 'B', ' '],
+  [' ', 'W', ' ', 'W', ' ', ' ', 'W', ' ', ' ', ' ', 'B', ' ', 'B', ' ', 'B', ' ', 'B', ' ', 'B', ' '],
+  [' ', ' ', ' ', ' ', 'W', 'B', ' ', ' ', ' ', 'B', ' ', ' ', 'B', ' ', 'B', ' ', 'B', ' ', 'B', ' '],
+  [' ', ' ', 'B', ' ', ' ', ' ', 'B', 'B', ' ', 'W', 'B', ' ', 'B', ' ', 'B', ' ', ' ', 'B', ' ', ' '],
+  [' ', 'W', 'W', 'W', ' ', 'B', ' ', 'W', ' ', ' ', 'B', ' ', 'B', ' ', 'B', ' ', ' ', ' ', 'B', ' '],
+  [' ', ' ', ' ', ' ', ' ', ' ', 'W', ' ', ' ', 'B', ' ', 'B', ' ', ' ', 'B', ' ', 'B', ' ', 'B', ' '],
+  [' ', 'W', ' ', 'B', 'W', 'B', ' ', 'W', ' ', ' ', ' ', ' ', 'B', 'B', ' ', ' ', 'B', ' ', 'B', ' '],
+  [' ', ' ', ' ', ' ', 'W', ' ', ' ', 'B', 'B', 'B', 'B', 'B', ' ', ' ', ' ', 'B', ' ', ' ', 'B', ' '],
+  [' ', 'W', ' ', ' ', ' ', 'W', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', 'B', ' '],
+  ['W', ' ', ' ', 'W', ' ', ' ', 'B', ' ', ' ', 'B', 'B', 'B', 'B', 'B', ' ', ' ', 'B', ' ', 'B', ' '],
+  [' ', 'W', 'W', ' ', 'W', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', 'B', ' ', 'B', ' '],
+  ['B', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', 'W']
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+[
+    [ 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W' ],
+    [ 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'B', 'B', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'B', 'W', 'B', 'W', 'W', 'W', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'B', 'B', 'B', 'B', 'B', 'W', 'B', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'W', 'W', 'W', 'W', 'B', 'W', 'W', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'W', 'B', 'W', 'B', 'B', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'B', 'W', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'B', 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'W', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'B', 'B', 'W' ],
+    [ 'W', 'W', 'W', 'W', 'W', 'B', 'W', 'W', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'W', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'B', 'B', 'B', 'W', 'B', 'B', 'B', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'W', 'B', 'W', 'B', 'W', 'W', 'W', 'W', 'W', 'W', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'B', 'B', 'B', 'B', 'B', 'W', 'B', 'B', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'B', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'W', 'B', 'B', 'B', 'B', 'W', 'B', 'B', 'B', 'B', 'B', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'B', 'W', 'W', 'W', 'W', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'W' ],
+]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 3.10 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/yin_yang_solved.png" alt="Yin-Yang solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -3475,3 +3593,4 @@ Issues and PRs welcome!
 [37]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/unequal "puzzle_solver/src/puzzle_solver/puzzles/unequal at master · Ar-Kareem/puzzle_solver · GitHub"
 [38]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/norinori "puzzle_solver/src/puzzle_solver/puzzles/norinori at master · Ar-Kareem/puzzle_solver · GitHub"
 [39]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/slitherlink "puzzle_solver/src/puzzle_solver/puzzles/slitherlink at master · Ar-Kareem/puzzle_solver · GitHub"
+[40]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/yin_yang "puzzle_solver/src/puzzle_solver/puzzles/yin_yang at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.9.20.dist-info → multi_puzzle_solver-0.9.22.dist-info}/RECORD

@@ -1,4 +1,4 @@
-puzzle_solver/__init__.py,sha256=EuBuJfRIA3IGQExkQ5h4BNYXWHLzdZh3j65ocCMy_64,2855
+puzzle_solver/__init__.py,sha256=H7Tpw9yF9TDqwck6bXv1jiS9TGtO5nsVwcDd0Fp1Xyg,2926
 puzzle_solver/core/utils.py,sha256=_LA81kHrsgvqPvq7RISBeaurXmYMKAU9N6qmV8n0G7s,8063
 puzzle_solver/core/utils_ortools.py,sha256=2xEL9cMEKmNhRD9lhr2nGdZ3Lbmc9cnHY8xv6iLhUr0,10542
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
@@ -38,7 +38,7 @@ puzzle_solver/puzzles/star_battle/star_battle.py,sha256=IX6w4H3sifN01kPPtrAVRCK0
 puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
 puzzle_solver/puzzles/stitches/stitches.py,sha256=iK8t02q43gH3FPbuIDn4dK0sbaOgZOnw8yHNRNvNuIU,6534
 puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=1LNJkIqpcz1LvY0H0uRedABQWm44dgNf9XeQuKm36WM,10275
-puzzle_solver/puzzles/sudoku/sudoku.py,sha256=M_pry7XyKKzlfCF5rFi02lyOrj5GWZzXnDAxmD3NXvI,3588
+puzzle_solver/puzzles/sudoku/sudoku.py,sha256=SE4TM_gic6Jj0fkDR_NzUJdX2XKyQ8eeOnVAQ011Xbo,8870
 puzzle_solver/puzzles/tents/tents.py,sha256=iyVK2WXfIT5j_9qqlQg0WmwvixwXlZSsHGK3XA-KpII,6283
 puzzle_solver/puzzles/thermometers/thermometers.py,sha256=nsvJZkm7G8FALT27bpaB0lv5E_AWawqmvapQI8QcYXw,4015
 puzzle_solver/puzzles/towers/towers.py,sha256=QvL0Pp-Z2ewCeq9ZkNrh8MShKOh-Y52sFBSudve68wk,6496
@@ -46,8 +46,10 @@ puzzle_solver/puzzles/tracks/tracks.py,sha256=98xds9SKNqtOLFTRUX_KSMC7XYmZo567LO
 puzzle_solver/puzzles/undead/undead.py,sha256=IrCUfzQFBem658P5KKqldG7vd2TugTHehcwseCarerM,6604
 puzzle_solver/puzzles/unequal/unequal.py,sha256=ExY2XDCrqROCDpRLfHo8uVr1zuli1QvbCdNCiDhlCac,6978
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
+puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=WrRdNhmKhIARdGOt_36gpRxRzrfLGv3wl7igBpPFM64,5259
+puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=l4b6eO30kspmiP20b60WbvxEEKNKgLQU1SgwDNhhLOA,6459
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.20.dist-info/METADATA,sha256=R36gUfx8jHLCnOMt4QEYf-wtBYskwk46IxxPJGMapjI,180363
-multi_puzzle_solver-0.9.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.20.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.20.dist-info/RECORD,,
+multi_puzzle_solver-0.9.22.dist-info/METADATA,sha256=X8hwi1PYI_Yka0rUuxUy5vck0_lSHt-Gwy0m1w8tS_k,187121
+multi_puzzle_solver-0.9.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.22.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.22.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -37,7 +37,8 @@ from puzzle_solver.puzzles.tracks import tracks as tracks_solver
 from puzzle_solver.puzzles.undead import undead as undead_solver
 from puzzle_solver.puzzles.unequal import unequal as unequal_solver
 from puzzle_solver.puzzles.unruly import unruly as unruly_solver
+from puzzle_solver.puzzles.yin_yang import yin_yang as yin_yang_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.20'
+__version__ = '0.9.22'

puzzle_solver/puzzles/sudoku/sudoku.py

@@ -1,14 +1,14 @@
-from typing import Union
+from typing import Union, Optional
 
 import numpy as np
 from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_pos, get_all_pos, get_char, set_char, get_row_pos, get_col_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, or_constraint, SingleSolution
 
 
 def get_value(board: np.array, pos: Pos) -> Union[int, str]:
-    c = get_char(board, pos)
+    c = get_char(board, pos).lower()
     if c == ' ':
         return c
     if str(c).isdecimal():
@@ -27,22 +27,40 @@ def set_value(board: np.array, pos: Pos, value: Union[int, str]):
     set_char(board, pos, value)
 
 
-def get_block_pos(i: int, B: int) -> list[Pos]:
-    top_left_x = (i%B)*B
-    top_left_y = (i//B)*B
-    return [get_pos(x=top_left_x + x, y=top_left_y + y) for x in range(B) for y in range(B)]
+def get_block_pos(i: int, Bv: int, Bh: int) -> list[Pos]:
+    # Think: Bv=3 and Bh=4 while the board has 4 vertical blocks and 3 horizontal blocks
+    top_left_x = (i%Bv)*Bh
+    top_left_y = (i//Bv)*Bv
+    return [get_pos(x=top_left_x + x, y=top_left_y + y) for x in range(Bh) for y in range(Bv)]
 
 
 class Board:
-    def __init__(self, board: np.array):
+    def __init__(self, board: np.array, block_size: Optional[tuple[int, int]] = None, sandwich: Optional[dict[str, list[int]]] = None, unique_diagonal: bool = False):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
         assert board.shape[0] == board.shape[1], 'board must be square'
         assert all(isinstance(i.item(), str) and len(i.item()) == 1 and (i.item().isalnum() or i.item() == ' ') for i in np.nditer(board)), 'board must contain only alphanumeric characters or space'
         self.board = board
-        self.N = board.shape[0]
-        self.B = np.sqrt(self.N)  # block size
-        assert self.B.is_integer(), 'board size must be a perfect square'
-        self.B = int(self.B)
+        self.V, self.H = board.shape
+        if block_size is None:
+            B = np.sqrt(self.V)  # block size
+            assert B.is_integer(), 'board size must be a perfect square or provide block_size'
+            Bv, Bh = int(B), int(B)
+        else:
+            Bv, Bh = block_size
+            assert Bv * Bh == self.V, 'block size must be a factor of board size'
+        # can be different in 4x3 for example
+        self.Bv = Bv
+        self.Bh = Bh
+        self.B = Bv * Bh  # block count
+        if sandwich is not None:
+            assert set(sandwich.keys()) == set(['side', 'bottom']), 'sandwich must contain only side and bottom'
+            assert len(sandwich['side']) == self.H, 'side must be equal to board width'
+            assert len(sandwich['bottom']) == self.V, 'bottom must be equal to board height'
+            self.sandwich = sandwich
+        else:
+            self.sandwich = None
+        self.unique_diagonal = unique_diagonal
+    
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
 
@@ -50,28 +68,50 @@ class Board:
         self.add_all_constraints()
 
     def create_vars(self):
-        for pos in get_all_pos(self.N):
-            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewIntVar(1, self.B, f'{pos}')
 
     def add_all_constraints(self):
         # some squares are already filled
-        for pos in get_all_pos(self.N):
+        for pos in get_all_pos(self.V, self.H):
             c = get_value(self.board, pos)
             if c != ' ':
                 self.model.Add(self.model_vars[pos] == c)
         # every number appears exactly once in each row, each column and each block
         # each row
-        for row in range(self.N):
-            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.N)]
+        for row in range(self.V):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, H=self.H)]
             self.model.AddAllDifferent(row_vars)
         # each column
-        for col in range(self.N):
-            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.N)]
+        for col in range(self.H):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, V=self.V)]
             self.model.AddAllDifferent(col_vars)
         # each block
-        for block_i in range(self.N):
-            block_vars = [self.model_vars[p] for p in get_block_pos(block_i, self.B)]
+        for block_i in range(self.B):
+            block_vars = [self.model_vars[p] for p in get_block_pos(block_i, Bv=self.Bv, Bh=self.Bh)]
             self.model.AddAllDifferent(block_vars)
+        if self.sandwich is not None:
+            self.add_sandwich_constraints()
+        if self.unique_diagonal:
+            self.add_unique_diagonal_constraints()
+
+    def add_sandwich_constraints(self):
+        for c, clue in enumerate(self.sandwich['bottom']):
+            if clue is None or int(clue) < 0:
+                continue
+            col_vars = [self.model_vars[p] for p in get_col_pos(c, V=self.V)]
+            add_single_sandwich(col_vars, int(clue), self.model, name=f"sand_side_{c}")
+        for r, clue in enumerate(self.sandwich['side']):
+            if clue is None or int(clue) < 0:
+                continue
+            row_vars = [self.model_vars[p] for p in get_row_pos(r, H=self.H)]
+            add_single_sandwich(row_vars, int(clue), self.model, name=f"sand_bottom_{r}")
+
+    def add_unique_diagonal_constraints(self):
+        main_diagonal_vars = [self.model_vars[get_pos(x=i, y=i)] for i in range(min(self.V, self.H))]
+        self.model.AddAllDifferent(main_diagonal_vars)
+        anti_diagonal_vars = [self.model_vars[get_pos(x=i, y=self.V-i-1)] for i in range(min(self.V, self.H))]
+        self.model.AddAllDifferent(anti_diagonal_vars)
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
@@ -81,10 +121,83 @@ class Board:
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.N, self.N), ' ', dtype=object)
-            for pos in get_all_pos(self.N):
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
                 c = get_value(self.board, pos)
                 c = single_res.assignment[pos]
                 set_value(res, pos, c)
             print(res)
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
+
+
+
+def add_single_sandwich(vars_line: list[cp_model.IntVar], clue: int, model: cp_model.CpModel, name: str):
+    # VAR count:
+    # is_min: L
+    # is_max: L
+    # pos_min/max/lt: 1+1+1
+    # between: L
+    # a1/a2/case_a: L+L+L
+    # b1/b2/case_b: L+L+L
+    # take: L
+    # 10L+3 per 1 call of the function (i.e. per 1 line)
+    # entire board will have 2L lines (rows and columns)
+    # in total: 20L^2+6L
+
+    L = len(vars_line)
+    is_min = [model.NewBoolVar(f"{name}_ismin_{i}") for i in range(L)]
+    is_max = [model.NewBoolVar(f"{name}_ismax_{i}") for i in range(L)]
+    for i, v in enumerate(vars_line):
+        model.Add(v == 1).OnlyEnforceIf(is_min[i])
+        model.Add(v != 1).OnlyEnforceIf(is_min[i].Not())
+        model.Add(v == L).OnlyEnforceIf(is_max[i])
+        model.Add(v != L).OnlyEnforceIf(is_max[i].Not())
+
+    # index of the minimum and maximum values (sum of the values inbetween must = clue)
+    pos_min = model.NewIntVar(0, L - 1, f"{name}_pos_min")
+    pos_max = model.NewIntVar(0, L - 1, f"{name}_pos_max")
+    model.Add(pos_min == sum(i * is_min[i] for i in range(L)))
+    model.Add(pos_max == sum(i * is_max[i] for i in range(L)))
+
+    # used later to handle both cases (A. pos_min < pos_max and B. pos_max < pos_min)
+    lt = model.NewBoolVar(f"{name}_lt")  # pos_min < pos_max ?
+    model.Add(pos_min < pos_max).OnlyEnforceIf(lt)
+    model.Add(pos_min >= pos_max).OnlyEnforceIf(lt.Not())
+
+    between = [model.NewBoolVar(f"{name}_between_{i}") for i in range(L)]
+    for i in range(L):
+        # Case A: pos_min < i < pos_max (AND lt is true)
+        a1 = model.NewBoolVar(f"{name}_a1_{i}")  # pos_min < i
+        a2 = model.NewBoolVar(f"{name}_a2_{i}")  # i < pos_max
+
+        model.Add(pos_min < i).OnlyEnforceIf(a1)
+        model.Add(pos_min >= i).OnlyEnforceIf(a1.Not())
+        model.Add(i < pos_max).OnlyEnforceIf(a2)
+        model.Add(i >= pos_max).OnlyEnforceIf(a2.Not())
+
+        case_a = model.NewBoolVar(f"{name}_caseA_{i}")
+        and_constraint(model, case_a, [lt, a1, a2])
+
+        # Case B: pos_max < i < pos_min (AND lt is false)
+        b1 = model.NewBoolVar(f"{name}_b1_{i}")  # pos_max < i
+        b2 = model.NewBoolVar(f"{name}_b2_{i}")  # i < pos_min
+
+        model.Add(pos_max < i).OnlyEnforceIf(b1)
+        model.Add(pos_max >= i).OnlyEnforceIf(b1.Not())
+        model.Add(i < pos_min).OnlyEnforceIf(b2)
+        model.Add(i >= pos_min).OnlyEnforceIf(b2.Not())
+
+        case_b = model.NewBoolVar(f"{name}_caseB_{i}")
+        and_constraint(model, case_b, [lt.Not(), b1, b2])
+
+        # between[i] is true if we're in case A or case B
+        or_constraint(model, between[i], [case_a, case_b])
+
+    # sum values at indices that are "between"
+    take = [model.NewIntVar(0, L, f"{name}_take_{i}") for i in range(L)]
+    for i, v in enumerate(vars_line):
+        # take[i] = v if between[i] else 0
+        model.Add(take[i] == v).OnlyEnforceIf(between[i])
+        model.Add(take[i] == 0).OnlyEnforceIf(between[i].Not())
+
+    model.Add(sum(take) == clue)

puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py

@@ -0,0 +1,169 @@
+
+def extract_lines(bw):
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = max(5, cols // 20)
+    h_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv2.erode(horizontal, h_kernel)
+    horizontal = cv2.dilate(horizontal, h_kernel)
+    h_means = np.mean(horizontal, axis=1)
+    h_idx = np.where(h_means > np.percentile(h_means, 70))[0]
+
+    rows = vertical.shape[0]
+    verticalsize = max(5, rows // 20)
+    v_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, verticalsize))
+    vertical = cv2.erode(vertical, v_kernel)
+    vertical = cv2.dilate(vertical, v_kernel)
+    v_means = np.mean(vertical, axis=0)
+    v_idx = np.where(v_means > np.percentile(v_means, 70))[0]
+    return h_idx, v_idx
+
+
+def _cluster_line_indices(indices, min_run=3):
+    """Group consecutive indices into line positions (take the mean of each run)."""
+    if len(indices) == 0:
+        return []
+    indices = np.sort(indices)
+    runs = []
+    run = [indices[0]]
+    for k in indices[1:]:
+        if k == run[-1] + 1:
+            run.append(k)
+        else:
+            if len(run) >= min_run:
+                runs.append(int(np.mean(run)))
+            run = [k]
+    if len(run) >= min_run:
+        runs.append(int(np.mean(run)))
+    # De-duplicate lines that are too close (rare)
+    dedup = []
+    for x in runs:
+        if not dedup or x - dedup[-1] > 2:
+            dedup.append(x)
+    return dedup
+
+
+def extract_yinyang_board(image_path, debug=False):
+    # Load and pre-process
+    img = cv2.imread(str(image_path))
+    assert img is not None, f"Failed to read image: {image_path}"
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    # Light grid lines → enhance lines using adaptive threshold
+    # (binary inverted so lines/dots become white)
+    bw = cv2.adaptiveThreshold(
+        gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY_INV, 35, 5
+    )
+
+    # Detect grid line indices (no guessing)
+    h_idx, v_idx = extract_lines(bw)
+    print(f"h_idx: {h_idx}")
+    print(f"v_idx: {v_idx}")
+    h_lines = h_idx
+    v_lines = v_idx
+    # h_lines = _cluster_line_indices(h_idx)
+    # v_lines = _cluster_line_indices(v_idx)
+    assert len(h_lines) >= 2 and len(v_lines) >= 2, "Could not detect grid lines"
+
+    # Cells are spans between successive grid lines
+    N_rows = len(h_lines) - 1
+    N_cols = len(v_lines) - 1
+    board = np.full((N_rows, N_cols), ' ', dtype='<U1')
+
+    # For robust per-cell analysis, also create a "dots" image with grid erased
+    # Remove thickened grid from bw
+    # Build masks for horizontal/vertical lines (reusing kernels sized by image dims)
+    cols = bw.shape[1]
+    rows = bw.shape[0]
+    h_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (max(5, cols // 20), 1))
+    v_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, max(5, rows // 20)))
+    horiz = cv2.morphologyEx(bw, cv2.MORPH_OPEN, h_kernel)
+    vert = cv2.morphologyEx(bw, cv2.MORPH_OPEN, v_kernel)
+    grid = cv2.bitwise_or(horiz, vert)
+    dots = cv2.bitwise_and(bw, cv2.bitwise_not(grid))  # mostly circles remain
+
+    # Iterate cells
+    print(f"N_rows: {N_rows}, N_cols: {N_cols}")
+    print(f"h_lines: {h_lines}")
+    print(f"v_lines: {v_lines}")
+    for r in range(N_rows):
+        y0, y1 = h_lines[r], h_lines[r + 1]
+        # shrink ROI to avoid line bleed
+        y0i = max(y0 + 2, 0)
+        y1i = max(min(y1 - 2, dots.shape[0]), y0i + 1)
+        for c in range(N_cols):
+            x0, x1 = v_lines[c], v_lines[c + 1]
+            x0i = max(x0 + 2, 0)
+            x1i = max(min(x1 - 2, dots.shape[1]), x0i + 1)
+
+            roi_gray = gray[y0i:y1i, x0i:x1i]
+            roi_dots = dots[y0i:y1i, x0i:x1i]
+            area = roi_dots.shape[0] * roi_dots.shape[1]
+            if area == 0:
+                continue
+
+            # If no meaningful foreground, it's empty
+            fg_area = int(np.count_nonzero(roi_dots))
+            if fg_area < 0.03 * area:
+                board[r, c] = ' '
+                continue
+
+            # Segment the largest blob (circle) inside the cell
+            contours, _ = cv2.findContours(roi_dots, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if not contours:
+                board[r, c] = ' '
+                continue
+
+            cnt = max(contours, key=cv2.contourArea)
+            if cv2.contourArea(cnt) < 0.02 * area:
+                board[r, c] = ' '
+                continue
+
+            mask = np.zeros_like(roi_dots)
+            cv2.drawContours(mask, [cnt], -1, 255, thickness=-1)
+
+            mean_inside = float(cv2.mean(roi_gray, mask=mask)[0])
+
+            # Heuristic: black stones have dark interior; white stones bright interior
+            # (grid background is white; outlines contribute little to mean)
+            board[r, c] = 'B' if mean_inside < 150 else 'W'
+    non_empty_rows = []
+    non_empty_cols = []
+    for r in range(N_rows):
+        if not all(board[r, :] == ' '):
+            non_empty_rows.append(r)
+    for c in range(N_cols):
+        if not all(board[:, c] == ' '):
+            non_empty_cols.append(c)
+    board = board[non_empty_rows, :][:, non_empty_cols]
+
+    if debug:
+        for row in board:
+            print(row.tolist())
+    output_path = Path(__file__).parent / "input_output" / (image_path.stem + ".json")
+    with open(output_path, 'w') as f:
+        f.write('[\n')
+        for i, row in enumerate(board):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(board) - 1:
+                f.write(',')
+            f.write('\n')
+        f.write(']')
+    print('output json: ', output_path)
+
+    return board
+
+if __name__ == "__main__":
+    #  python .\src\puzzle_solver\puzzles\yin_yang\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
+    import cv2
+    import numpy as np
+    from pathlib import Path
+    image_path = Path(__file__).parent / "input_output" / "MzoyLDcwMSw2NTY=.png"
+    # image_path = Path(__file__).parent / "input_output" / "Njo5MDcsNDk4.png"
+    # image_path = Path(__file__).parent / "input_output" / "MTE6Niw0NjEsMTIx.png"
+    assert image_path.exists(), f"Image file does not exist: {image_path}"
+    board = extract_yinyang_board(image_path, debug=True)
+    print(board)

puzzle_solver/puzzles/yin_yang/yin_yang.py

@@ -0,0 +1,110 @@
+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 Pos, get_all_pos, set_char, get_char, in_bounds, Direction, get_next_pos, get_pos
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
+
+
+class Board:
+    def __init__(self, board: np.array):
+        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, B, or W'
+        self.board = board
+        self.V, self.H = board.shape
+        self.model = cp_model.CpModel()
+        self.B: dict[Pos, cp_model.IntVar] = {}
+        self.W: 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.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+
+    def add_all_constraints(self):
+        self.force_clues()
+        self.disallow_2x2()
+        self.disallow_checkers()
+        self.force_connected_component()
+        self.force_border_transitions()
+
+    def force_clues(self):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos)
+            if c not in ['B', 'W']:
+                continue
+            self.model.Add(self.B[pos] == (c == 'B'))
+
+    def disallow_2x2(self):
+        for pos in get_all_pos(self.V, self.H):  # disallow 2x2 (WW/WW) and (BB/BB)
+            tl = pos
+            tr = get_next_pos(pos, Direction.RIGHT)
+            bl = get_next_pos(pos, Direction.DOWN)
+            br = get_next_pos(bl, Direction.RIGHT)
+            if any(not in_bounds(p, self.V, self.H) for p in [tl, tr, bl, br]):
+                continue
+            self.model.AddBoolOr([self.B[tl], self.B[tr], self.B[bl], self.B[br]])
+            self.model.AddBoolOr([self.B[tl].Not(), self.B[tr].Not(), self.B[bl].Not(), self.B[br].Not()])
+    
+    def disallow_checkers(self):
+        # from https://ralphwaldo.github.io/yinyang_summary.html
+        for pos in get_all_pos(self.V, self.H):  # disallow (WB/BW) and (BW/WB)
+            tl = pos
+            tr = get_next_pos(pos, Direction.RIGHT)
+            bl = get_next_pos(pos, Direction.DOWN)
+            br = get_next_pos(bl, Direction.RIGHT)
+            if any(not in_bounds(p, self.V, self.H) for p in [tl, tr, bl, br]):
+                continue
+            self.model.AddBoolOr([self.B[tl], self.B[tr].Not(), self.B[bl].Not(), self.B[br]])  # disallow (WB/BW)
+            self.model.AddBoolOr([self.B[tl].Not(), self.B[tr], self.B[bl], self.B[br].Not()])  # disallow (BW/WB)
+
+    def force_connected_component(self):
+        # force single connected component for both colors
+        force_connected_component(self.model, self.B)
+        force_connected_component(self.model, {k: v.Not() for k, v in self.B.items()})
+
+    def force_border_transitions(self):
+        # from https://ralphwaldo.github.io/yinyang_summary.html
+        # The border cells cannot be split into four (or more) separate blocks of colours
+        # It is therefore either split into two blocks (one of each colour), or is just a single block of one colour or the other
+        border_cells = []  # go in a ring clockwise from top left
+        for x in range(self.H):
+            border_cells.append(get_pos(x=x, y=0))
+        for y in range(1, self.V):
+            border_cells.append(get_pos(x=self.H-1, y=y))
+        for x in range(self.H-2, -1, -1):
+            border_cells.append(get_pos(x=x, y=self.V-1))
+        for y in range(self.V-2, 0, -1):
+            border_cells.append(get_pos(x=0, y=y))
+        # tie the knot
+        border_cells.append(border_cells[0])
+        # unequal sum is 0 or 2
+        deltas = []
+        for i in range(len(border_cells)-1):
+            aux = self.model.NewBoolVar(f'border_transition_{i}')  # i is black while i+1 is white
+            and_constraint(self.model, aux, [self.B[border_cells[i]], self.B[border_cells[i+1]].Not()])
+            deltas.append(aux)
+        self.model.Add(lxp.Sum(deltas) <= 1)
+
+
+    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.B.items():
+                assignment[pos] = 'B' if solver.BooleanValue(var) else 'W'
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos)
+                c = single_res.assignment[pos]
+                set_char(res, pos, c)
+            print('[')
+            for row in res:
+                print("    [ '" + "', '".join(row.tolist()) + "' ],")
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)