multi-puzzle-solver 0.9.31__py3-none-any.whl → 1.0.2__py3-none-any.whl

{multi_puzzle_solver-0.9.31.dist-info → multi_puzzle_solver-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.31
+Version: 1.0.2
 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
@@ -369,6 +369,28 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
     </a>
   </td>
 </tr>
+<tr>
+  <td align="center">
+    <a href="#kakuro-puzzle-type-51"><b>Kakuro</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/kakuro_solved.png" alt="Kakuro" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#sudoku-jigsaw-puzzle-type-52"><b>Sudoku Jigsaw</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/sudoku_jigsaw_solved.png" alt="Sudoku Jigsaw" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#sudoku-killer-puzzle-type-53"><b>Sudoku Killer</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/sudoku_killer_solved.png" alt="Sudoku Killer" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#flood-it-puzzle-type-54"><b>Flood It</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flood_it_unsolved.png" alt="Flood It" width="140">
+    </a>
+  </td>
+</tr>
 </table>
 
 </div>
@@ -434,6 +456,9 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Binairo Plus (Puzzle Type #49)](#binairo-plus-puzzle-type-49)
   - [Shakashaka (Puzzle Type #50)](#shakashaka-puzzle-type-50)
   - [Kakuro (Puzzle Type #51)](#kakuro-puzzle-type-51)
+  - [Sudoku Jigsaw (Puzzle Type #52)](#sudoku-jigsaw-puzzle-type-52)
+  - [Sudoku Killer (Puzzle Type #53)](#sudoku-killer-puzzle-type-53)
+  - [Flood It (Puzzle Type #54)](#flood-it-puzzle-type-54)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -4823,6 +4848,232 @@ Time taken: 0.00 seconds
 
 ---
 
+## Sudoku Jigsaw (Puzzle Type #52)
+
+* [**Play online**](https://www.puzzle-jigsaw-sudoku.com/)
+
+* [**Solver Code**][52]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+   1. The basic Sudoku rules apply.
+   2. The difference is that instead of having 3x3 rectangular blocks these blocks have irregular shapes
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/sudoku_jigsaw_unsolved.png" alt="Sudoku Jigsaw unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: the ids are arbitrary and simply represent cells that share a block)
+
+```python
+import numpy as np
+from puzzle_solver import sudoku_solver as solver
+board = np.array([
+  [ '1', ' ', ' ', '2', ' ', ' ', '8', '5', ' ' ],
+  [ '2', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+  [ ' ', ' ', '8', ' ', ' ', ' ', ' ', ' ', ' ' ],
+  [ '7', ' ', ' ', '5', ' ', '1', ' ', ' ', ' ' ],
+  [ ' ', ' ', ' ', '1', ' ', '3', ' ', ' ', ' ' ],
+  [ ' ', ' ', ' ', '8', ' ', '4', ' ', ' ', '6' ],
+  [ ' ', ' ', ' ', ' ', ' ', ' ', '5', ' ', ' ' ],
+  [ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '5' ],
+  [ ' ', '2', '6', ' ', ' ', '9', ' ', ' ', '1' ],
+])
+jigsaw_ids = np.array([
+  ['00', '00', '01', '01', '01', '01', '02', '02', '02'],
+  ['00', '00', '01', '01', '03', '01', '01', '02', '02'],
+  ['00', '00', '01', '04', '03', '03', '02', '02', '02'],
+  ['00', '04', '04', '04', '03', '03', '03', '03', '02'],
+  ['00', '00', '04', '04', '03', '03', '05', '05', '05'],
+  ['06', '04', '04', '04', '05', '05', '05', '07', '05'],
+  ['06', '08', '08', '08', '08', '05', '05', '07', '07'],
+  ['06', '06', '06', '06', '08', '07', '07', '07', '07'],
+  ['06', '06', '06', '08', '08', '08', '08', '07', '07'],
+])
+binst = solver.Board(board=board, jigsaw=jigsaw_ids, constrain_blocks=False)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+[['1' '9' '4' '2' '3' '6' '8' '5' '7']
+ ['2' '8' '5' '9' '4' '7' '1' '6' '3']
+ ['6' '3' '8' '4' '7' '5' '9' '1' '2']
+ ['7' '6' '3' '5' '9' '1' '2' '8' '4']
+ ['4' '5' '2' '1' '6' '3' '7' '9' '8']
+ ['5' '7' '9' '8' '1' '4' '3' '2' '6']
+ ['3' '1' '7' '6' '8' '2' '5' '4' '9']
+ ['9' '4' '1' '7' '2' '8' '6' '3' '5']
+ ['8' '2' '6' '3' '5' '9' '4' '7' '1']]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.01 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/sudoku_jigsaw_solved.png" alt="Sudoku Jigsaw solved" width="500">
+
+---
+
+## Sudoku Killer (Puzzle Type #53)
+
+* [**Play online**](https://www.puzzle-killer-sudoku.com/)
+
+* [**Solver Code**][53]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+   1. The basic Sudoku rules apply.
+   2. The sum of all numbers in a cage must match the small number printed in its corner.
+   3. No number appears more than once in a cage.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/sudoku_killer_unsolved.png" alt="Sudoku Killer unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: the ids are arbitrary and simply represent cells that share a cage)
+
+```python
+import numpy as np
+from puzzle_solver import sudoku_solver as solver
+board = np.full((9, 9), ' ')
+killer_board = np.array([
+  ['01', '01', '03', '03', '03', '12', '12', '13', '14'],
+  ['02', '01', '04', '16', '16', '17', '17', '13', '14'],
+  ['02', '02', '04', '18', '19', '19', '15', '15', '14'],
+  ['11', '11', '05', '18', '19', '19', '20', '15', '23'],
+  ['10', '10', '05', '30', '31', '32', '20', '22', '23'],
+  ['08', '07', '06', '30', '31', '32', '21', '22', '24'],
+  ['08', '07', '06', '29', '31', '33', '21', '24', '24'],
+  ['09', '34', '34', '29', '28', '33', '26', '26', '25'],
+  ['09', '34', '34', '28', '28', '27', '27', '25', '25'],
+])
+killer_clues = {
+  '01': 16, '02': 11, '03': 24, '04': 10, '05': 11, '06': 7, '07': 10, '08': 10, '09': 16,
+  '10': 11, '11': 10, '12': 7, '13': 11, '14': 16, '15': 16, '16': 8, '17': 12, '18': 8, '19': 15,
+  '20': 7, '21': 10, '22': 5, '23': 13, '24': 16, '25': 9, '26': 14, '27': 15, '28': 13, '29': 11,
+  '30': 9, '31': 15, '32': 13, '33': 11, '34': 15,
+}
+binst = solver.Board(board=board, block_size=(3, 3), killer=(killer_board, killer_clues))
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+[['5' '4' '8' '7' '9' '1' '6' '2' '3']
+ ['3' '7' '1' '6' '2' '8' '4' '9' '5']
+ ['2' '6' '9' '5' '4' '3' '1' '7' '8']
+ ['1' '9' '4' '3' '6' '2' '5' '8' '7']
+ ['8' '3' '7' '1' '5' '9' '2' '4' '6']
+ ['6' '2' '5' '8' '7' '4' '3' '1' '9']
+ ['4' '8' '2' '9' '3' '5' '7' '6' '1']
+ ['7' '1' '3' '2' '8' '6' '9' '5' '4']
+ ['9' '5' '6' '4' '1' '7' '8' '3' '2']]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.01 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/sudoku_killer_solved.png" alt="Sudoku Killer solved" width="500">
+
+---
+
+## Flood It (Puzzle Type #54)
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/flood.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/flood.html#flood)
+
+* [**Solver Code**][54]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+The game is a combinatorial puzzle played on a colored N by N grid where the goal is to make the entire grid a single color using the minimum number of moves.
+
+A move consists of picking a new color, which then floods the connected component of the player's current area that has that chosen color.
+
+The player's current area is the top-leftmost corner of the grid along with any similarly colored orthogonal cells connected to the current area.
+
+</details>
+
+This game has a lot of interesting mathematical properties related to Graph Theory (for example many details are referenced in this [2022 Graph Theory paper](https://arxiv.org/pdf/1101.5876))
+
+Finding an optimal solution for any graph is NP-hard. 
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flood_it_unsolved.png" alt="Flood It unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: the ids are arbitrary and simply represent cells that share a cage)
+
+```python
+import numpy as np
+from puzzle_solver import flood_it_solver as solver
+board = np.array([
+    ['B', 'Y', 'G', 'Y', 'R', 'B', 'Y', 'Y', 'G', 'B', 'R', 'P'],
+    ['P', 'G', 'G', 'Y', 'B', 'O', 'Y', 'O', 'B', 'Y', 'R', 'O'],
+    ['B', 'R', 'P', 'Y', 'O', 'R', 'G', 'G', 'G', 'R', 'R', 'Y'],
+    ['O', 'G', 'P', 'G', 'Y', 'Y', 'P', 'P', 'O', 'Y', 'B', 'B'],
+    ['G', 'Y', 'G', 'O', 'R', 'G', 'R', 'P', 'G', 'O', 'B', 'R'],
+    ['R', 'G', 'B', 'G', 'O', 'B', 'O', 'G', 'B', 'O', 'O', 'B'],
+    ['G', 'B', 'P', 'R', 'Y', 'P', 'R', 'B', 'Y', 'B', 'Y', 'P'],
+    ['G', 'B', 'G', 'P', 'O', 'Y', 'R', 'Y', 'P', 'P', 'O', 'G'],
+    ['R', 'P', 'B', 'O', 'B', 'G', 'Y', 'O', 'Y', 'R', 'P', 'O'],
+    ['G', 'P', 'P', 'P', 'P', 'Y', 'G', 'P', 'O', 'G', 'O', 'R'],
+    ['Y', 'Y', 'B', 'B', 'R', 'B', 'O', 'R', 'O', 'O', 'R', 'O'],
+    ['B', 'G', 'B', 'G', 'R', 'B', 'P', 'Y', 'P', 'B', 'R', 'G']
+])
+solution = solver.solve_minimum_steps(board=board)
+```
+
+**Script Output**
+
+```python
+Trying with exactly 16 moves... Not possible!
+Trying with exactly 32 moves... Possible!
+Solution: ['Y', 'G', 'B', 'Y', 'B', 'R', 'B', 'Y', 'G', 'Y', 'G', 'B', 'B', 'G', 'Y', 'Y', 'R', 'B', 'Y', 'G', 'Y', 'B', 'Y', 'B', 'Y', 'B', 'G', 'Y', 'B', 'G', 'R', 'Y']
+Trying with exactly 24 moves... Possible!
+Solution: ['Y', 'G', 'B', 'Y', 'B', 'R', 'B', 'R', 'Y', 'G', 'R', 'Y', 'R', 'B', 'G', 'B', 'G', 'Y', 'G', 'B', 'Y', 'G', 'R', 'Y']
+Trying with exactly 20 moves... Possible!
+Solution: ['Y', 'G', 'B', 'Y', 'B', 'R', 'B', 'G', 'Y', 'G', 'B', 'G', 'Y', 'B', 'Y', 'R', 'B', 'G', 'R', 'Y']
+Trying with exactly 18 moves... Possible!
+Solution: ['Y', 'G', 'B', 'Y', 'R', 'B', 'R', 'Y', 'B', 'G', 'R', 'Y', 'R', 'B', 'G', 'R', 'Y', 'B']
+Trying with exactly 17 moves... Not possible!
+Best Horizon is: T=18
+Best solution is: ['Y', 'G', 'B', 'Y', 'R', 'B', 'R', 'Y', 'B', 'G', 'R', 'Y', 'R', 'B', 'G', 'R', 'Y', 'B']
+Time taken: 3.10 seconds
+```
+
+**Solved puzzle**
+
+This picture won't mean much as the game is about the sequence and number of moves not the final frame as shown here. 
+
+Note that the solved solution on the bottom left says that only 18 moves were used (based on the above output) despite the website saying 20 total moves are permitted (and the puzzle settings specified 0 extra moves permitted). Thus the solver managed to find a more optimal solution than the website.
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flood_it_solved.png" alt="Flood It solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -4925,3 +5176,6 @@ Issues and PRs welcome!
 [49]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/binairo_plus "puzzle_solver/src/puzzle_solver/puzzles/binairo_plus at master · Ar-Kareem/puzzle_solver · GitHub"
 [50]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/shakashaka "puzzle_solver/src/puzzle_solver/puzzles/shakashaka at master · Ar-Kareem/puzzle_solver · GitHub"
 [51]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/kakuro "puzzle_solver/src/puzzle_solver/puzzles/kakuro at master · Ar-Kareem/puzzle_solver · GitHub"
+[52]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/sudoku "puzzle_solver/src/puzzle_solver/puzzles/sudoku at master · Ar-Kareem/puzzle_solver · GitHub"
+[53]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/sudoku "puzzle_solver/src/puzzle_solver/puzzles/sudoku at master · Ar-Kareem/puzzle_solver · GitHub"
+[54]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/flood_it "puzzle_solver/src/puzzle_solver/puzzles/flood_it at master · Ar-Kareem/puzzle_solver · GitHub"

multi_puzzle_solver-1.0.2.dist-info/RECORD

@@ -0,0 +1,69 @@
+puzzle_solver/__init__.py,sha256=Ll-qN1ElCTTILeun1u4t5dU0CdI3DkCX0ZNf0Q2UJtE,4886
+puzzle_solver/core/utils.py,sha256=XBW5j-IwtJMPMP-ycmY6SqRCM1NOVl5O6UeoGqNj618,8153
+puzzle_solver/core/utils_ortools.py,sha256=ACV3HgKWpEUTt1lpqsPryK1DeZpu7kdWQKEWTLJ2tfs,10384
+puzzle_solver/core/utils_visualizer.py,sha256=ymuhF75uwJbNhN8XVDYEPqw6sPKoqRaaxlhGeHtXpLs,20201
+puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
+puzzle_solver/puzzles/battleships/battleships.py,sha256=RuYCrs4j0vUjlU139NRYYP-uNPAgO0V7hAzbsHrRwD8,7446
+puzzle_solver/puzzles/binairo/binairo.py,sha256=NmVPIoyVCoMLaSFhsN0TcJQYvav9hi4hSwoAVirYhDU,6835
+puzzle_solver/puzzles/binairo/binairo_plus.py,sha256=TvLG3olwANtft3LuCF-y4OofpU9PNa4IXDqgZqsD-g0,267
+puzzle_solver/puzzles/black_box/black_box.py,sha256=EiCVkbhUP0x94otvQirv7MrggTu0ok8MIUPbxv6jkIU,15544
+puzzle_solver/puzzles/bridges/bridges.py,sha256=QwOhZyO5urbatkNyPmQxZ_lGM01ZejndMr_eoiBkr7g,5394
+puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=D-_Oi8OyxsVe1j3dIKYwRlxgeb3NWLmDWGcv-oclY0c,195
+puzzle_solver/puzzles/chess_range/chess_range.py,sha256=_VHlpUPnqeBstvSIt9RtTV-w2etSK7UrEHg6sErNqtU,21068
+puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=ByDfcRsk5FVmFicpU_DpLoLTJ99Kr___vX4y8ln8_EQ,400
+puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
+puzzle_solver/puzzles/dominosa/dominosa.py,sha256=Nmb7pn8U27QJwGy9F3wo8ylqo2_U51OAo3GN2soaNpc,7195
+puzzle_solver/puzzles/filling/filling.py,sha256=R8UIbztk3zNCeNbVClBJoKZHKeHwK_pesjGmMaEEQO0,5536
+puzzle_solver/puzzles/flip/flip.py,sha256=ZngJLUhRNc7qqo2wtNLdMPx4u9w9JTUge27PmdXyDCw,3985
+puzzle_solver/puzzles/flood_it/flood_it.py,sha256=jnCtH1sZIt6K4hbQDSsiM1Cd8FjQNP7cfw2ObUW5fEQ,7948
+puzzle_solver/puzzles/flood_it/parse_map/parse_map.py,sha256=0aw1TbiyxknY2hUAXaP3nXqT6I6mT9BIiERJSCj57xw,8245
+puzzle_solver/puzzles/galaxies/galaxies.py,sha256=36X9jaQfvLIWFkBY1VZH6I59eCDkc77U06NDtKRUECY,5571
+puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=XmFqVN_oRfq9AZFWy5ViUJ2Szjgx-srrRkFPJXEEyFo,9358
+puzzle_solver/puzzles/guess/guess.py,sha256=MpyrF6YVu0S1fzX-BllwxGKRGacWJpeLbNn5GetuEyo,10792
+puzzle_solver/puzzles/heyawake/heyawake.py,sha256=L_y44dHArOvO_tDyO35dwkvqdk9eEGItO7n4FDfzNDc,5586
+puzzle_solver/puzzles/inertia/inertia.py,sha256=-Y5fr7aK20zwmGHsZql7pYCq1kyMZglvkVZ6uIDf1HA,5658
+puzzle_solver/puzzles/inertia/tsp.py,sha256=mAhlSjCWespASeN8uLZ0JkYDw-ZqFEpal6NM-ubpCXw,15313
+puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=x0d64gTBd0HC2lO5uOpX2VKWfwj8rRiz0mQM_lqNmWs,8457
+puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGphTTUDMC0TkQvQ,2064
+puzzle_solver/puzzles/kakuro/kakuro.py,sha256=m22Ju-V2BdQl2Ng_pjVUSrxPCtIfqezdpebutURlhvg,4348
+puzzle_solver/puzzles/keen/keen.py,sha256=adSA_pc1m6F6jV7a-PpQxdci1bv4psCNRNt9hMIQdSY,5034
+puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
+puzzle_solver/puzzles/lits/lits.py,sha256=3fPIkhAIUz8JokcfaE_ZM3b0AFEnf5xPzGJ2qnm8SWY,7099
+puzzle_solver/puzzles/magnets/magnets.py,sha256=-Wl49JD_PKeq735zQVMQ3XSQX6gdHiY-7PKw-Sh16jw,6474
+puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy3us,2582
+puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=gSdFsuZ-KrwVxgI1HF2q_pYleZ6vBm9jjRTFlboVnLY,5871
+puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
+puzzle_solver/puzzles/nonograms/nonograms.py,sha256=dTKfMwBL49hW3bNd34ETXW7lBRPuQeSPNSCHqHmfybg,6066
+puzzle_solver/puzzles/norinori/norinori.py,sha256=qR7V7NbZRN_ME90R2jL47AkGik1CY6JlAPhLBMXP2Gw,4714
+puzzle_solver/puzzles/nurikabe/nurikabe.py,sha256=3cbW7X4kAMQK8PkH_t65fzT5cI0O6tWWOqpQUVyuGT4,6501
+puzzle_solver/puzzles/palisade/palisade.py,sha256=T-LXlaLU5OwUQ24QWJWhBUFUktg0qDODTilNmBaXs4I,5014
+puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5omYLChM,6798
+puzzle_solver/puzzles/range/range.py,sha256=q0J3crlGfjYZSA6Dh4iMCwP_gRMWid-_8KPgggOrFKk,4410
+puzzle_solver/puzzles/rectangles/rectangles.py,sha256=MgOhZJGr9DVHb9bB8EAuwus0_8frBqRWqMwrOvMezHQ,6918
+puzzle_solver/puzzles/shakashaka/shakashaka.py,sha256=PRpg_qI7XA3ysAo_g1TRJsT3VwB5Vial2UcFyBOMwKQ,9571
+puzzle_solver/puzzles/shingoki/shingoki.py,sha256=heMuL9sm3jBegItjnqX05ttmDNiHSLB77BRljpeLLWk,7417
+puzzle_solver/puzzles/signpost/signpost.py,sha256=38LlMvP5Fx4qrTXmw4aNCt3yUbG3fhdSk6-YXmhAHFg,3861
+puzzle_solver/puzzles/singles/singles.py,sha256=KKn_Yl-eW874Bl1UmmcqoQ5vhNiO1JbM7fxKczOV5M4,2847
+puzzle_solver/puzzles/slant/slant.py,sha256=xF-N4PuXYfx638NP1f1mi6YncIZB4mLtXtdS79XyPbg,6122
+puzzle_solver/puzzles/slant/parse_map/parse_map.py,sha256=8thQxWbq0qjehKb2VzgUP22PGj-9n9djwbt3LGMVLJw,4811
+puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=JpyNQk8K4nUziwWKxSvWEkF1RRBGLnCppCWK1Yf5bt0,7052
+puzzle_solver/puzzles/star_battle/star_battle.py,sha256=IX6w4H3sifN01kPPtrAVRCK0Nl_xlXXSHvJKw8K1EuE,3718
+puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
+puzzle_solver/puzzles/stitches/stitches.py,sha256=bb5JXyclkbKq350MQ9d8AuGteQwSF8knaJ0DU9M92Uw,6515
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=b21SQvlnDM6wOl_1iUhZ7X6akpBZoOnj3kEzImBCh8Q,10497
+puzzle_solver/puzzles/sudoku/sudoku.py,sha256=rLq0N34v3Hb10CiptXtKxX-37OlQIyjIle9Es1FAtpM,13378
+puzzle_solver/puzzles/tapa/tapa.py,sha256=TsOQhnEvlC1JxaWiEjQg2KxRXJR49GrN71DsMvPpia8,5337
+puzzle_solver/puzzles/tents/tents.py,sha256=jccUXWA7KWAtPKpVJJYNI6masTYWQgx0eitcQw0-6Fc,6281
+puzzle_solver/puzzles/thermometers/thermometers.py,sha256=bGcVmpPeqL5AJtj8jkK8gYThzv9aGCd_QrWEiYBCA2s,4011
+puzzle_solver/puzzles/towers/towers.py,sha256=OLyTf9nTFR5L32-S_fhVyBmpz4i5YUNJotwOwbw_Fjg,6500
+puzzle_solver/puzzles/tracks/tracks.py,sha256=98xds9SKNqtOLFTRUX_KSMC7XYmZo567LOFeqotVQaM,7237
+puzzle_solver/puzzles/undead/undead.py,sha256=IGFQysgoaKZH8rKjqlrkoHsH28ve4_hKor2f0QOsWY0,6596
+puzzle_solver/puzzles/unequal/unequal.py,sha256=ExY2XDCrqROCDpRLfHo8uVr1zuli1QvbCdNCiDhlCac,6978
+puzzle_solver/puzzles/unruly/unruly.py,sha256=xwOUpC12uHbmlDj2guN60VaaHpLr1Y-WmMD5TKeHbZE,3826
+puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=5WixT_7K1HwfQ_dWbuBlQfpU8p69zB2KvOg32XJ8vno,5255
+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.2.dist-info/METADATA,sha256=LCKeSEhi50eG0kd-PUEbBBrpY7ZPuWau5Kz4csMTN84,347154
+multi_puzzle_solver-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-1.0.2.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-1.0.2.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -9,6 +9,7 @@ from puzzle_solver.puzzles.chess_range import chess_solo as chess_solo_solver
 from puzzle_solver.puzzles.chess_range import chess_melee as chess_melee_solver
 from puzzle_solver.puzzles.dominosa import dominosa as dominosa_solver
 from puzzle_solver.puzzles.filling import filling as filling_solver
+from puzzle_solver.puzzles.flood_it import flood_it as flood_it_solver
 from puzzle_solver.puzzles.flip import flip as flip_solver
 from puzzle_solver.puzzles.galaxies import galaxies as galaxies_solver
 from puzzle_solver.puzzles.guess import guess as guess_solver
@@ -52,4 +53,60 @@ 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.31'
+__all__ = [
+    aquarium_solver,
+    battleships_solver,
+    binairo_solver,
+    binairo_plus_solver,
+    black_box_solver,
+    bridges_solver,
+    chess_range_solver,
+    chess_solo_solver,
+    chess_melee_solver,
+    dominosa_solver,
+    filling_solver,
+    flood_it_solver,
+    flip_solver,
+    galaxies_solver,
+    guess_solver,
+    heyawake_solver,
+    inertia_solver,
+    kakurasu_solver,
+    kakuro_solver,
+    keen_solver,
+    light_up_solver,
+    magnets_solver,
+    map_solver,
+    minesweeper_solver,
+    mosaic_solver,
+    nonograms_solver,
+    norinori_solver,
+    nurikabe_solver,
+    palisade_solver,
+    lits_solver,
+    pearl_solver,
+    range_solver,
+    rectangles_solver,
+    shakashaka_solver,
+    shingoki_solver,
+    signpost_solver,
+    singles_solver,
+    slant_solver,
+    slitherlink_solver,
+    star_battle_solver,
+    star_battle_shapeless_solver,
+    stitches_solver,
+    sudoku_solver,
+    tapa_solver,
+    tents_solver,
+    thermometers_solver,
+    towers_solver,
+    tracks_solver,
+    undead_solver,
+    unequal_solver,
+    unruly_solver,
+    yin_yang_solver,
+    inertia_image_parser,
+]
+
+__version__ = '1.0.2'

puzzle_solver/core/utils_ortools.py

@@ -14,6 +14,8 @@ class SingleSolution:
     assignment: dict[Pos, Union[str, int]]
 
     def get_hashable_solution(self) -> str:
+        if isinstance(self.assignment, list):
+            return json.dumps(self.assignment)
         result = []
         for pos, v in self.assignment.items():
             result.append((pos.x, pos.y, v))
@@ -93,14 +95,14 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
     Total new variables: =4V [for N by M 2D grid total is 4NM]
     """
     if is_neighbor is None:
-        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1
+        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1  # noqa: E731
 
     vs = vars_to_force
     v_count = len(vs)
     if v_count <= 2:  # graph must have at least 3 nodes to possibly be disconnected
         return {}
     # =V model variables, one for each variable
-    is_root: dict[Pos, cp_model.IntVar] = {}  # =V, defines the unique root 
+    is_root: dict[Pos, cp_model.IntVar] = {}  # =V, defines the unique
     prefix_zero: dict[Pos, cp_model.IntVar] = {}  # =V, used for picking the unique root
     node_height: dict[Pos, cp_model.IntVar] = {}  # =V, trickles down from the root
     max_neighbor_height: dict[Pos, cp_model.IntVar] = {}  # =V, the height of the tallest neighbor
@@ -141,7 +143,7 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
         model.Add(node_height[pi] == max_neighbor_height[pi] - 1).OnlyEnforceIf([vs[pi], is_root[pi].Not()])
         model.Add(node_height[pi] == v_count).OnlyEnforceIf(is_root[pi])
         model.Add(node_height[pi] == 0).OnlyEnforceIf(vs[pi].Not())
-    
+
     # final check: all active nodes have height > 0
     for p in keys_in_order:
         model.Add(node_height[p] > 0).OnlyEnforceIf(vs[p])
@@ -161,7 +163,7 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
     Returns a dictionary of new variables that can be used to enforce the no component constraint.
     """
     if is_neighbor is None:
-        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1
+        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1  # noqa: E731
 
     vs = vars_to_force
     v_count = len(vs)
@@ -220,8 +222,8 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
             model.Add(tree_edge[(p_parent, p)] == 0).OnlyEnforceIf([is_root[p]])
         # every active node has exactly 1 parent except root has none
         model.AddExactlyOne([tree_edge[(p_parent, p)] for p_parent in parent_of[p]] + [vs[p].Not(), is_root[p]])
-    
-    # now each subgraph has directions where each non-root points to a single parent (and its value is parent+1). 
+
+    # now each subgraph has directions where each non-root points to a single parent (and its value is parent+1).
     # to break cycles, every non-root active node must be > all neighbors that arent children
 
     all_new_vars: dict[str, cp_model.IntVar] = {}

puzzle_solver/core/utils_visualizer.py

@@ -94,7 +94,7 @@ def render_grid(cell_flags: np.ndarray,
         for r in range(R):
             rr = 2*r + 1
             for c in range(C):
-                val = center_char if isinstance(center_char, str) else center_char[r, c]
+                val = center_char if isinstance(center_char, str) else (center_char(r, c) if callable(center_char) else center_char[r, c])
                 put_center_text(rr, c, '' if val is None else str(val))
 
     # rows -> strings
@@ -159,13 +159,7 @@ def id_board_to_wall_board(id_board: np.array, border_is_wall = True) -> np.arra
 def render_shaded_grid(V: int,
                        H: int,
                        is_shaded: Callable[[int, int], bool],
-                       *,
-                       scale_x: int = 2,
-                       scale_y: int = 1,
-                       fill_char: str = '▒',
-                       empty_char: str = ' ',
-                       empty_text: Optional[Union[str, Callable[[int, int], Optional[str]]]] = None,
-                       show_axes: bool = True) -> str:
+                       empty_text: Optional[Union[str, Callable[[int, int], Optional[str]]]] = None,) -> str:
     """
     Most of this function was AI generated then modified by me, I don't currently care about the details of rendering to the terminal this looked good enough during my testing.
     Visualize a V x H grid where each cell is shaded if is_shaded(r, c) is True.
@@ -179,6 +173,11 @@ def render_shaded_grid(V: int,
                 cells. If a callable (r, c) -> str|None, used per cell. Text is
                 centered within the interior row and truncated to fit.
     """
+    scale_x: int = 2
+    scale_y: int = 1
+    fill_char: str = '▒'
+    empty_char: str = ' '
+    show_axes: bool = True
     assert V >= 1 and H >= 1
     assert scale_x >= 1 and scale_y >= 1
     assert len(fill_char) == 1 and len(empty_char) == 1
@@ -349,8 +348,10 @@ def render_bw_tiles_split(
         if not use_color:
             return ""
         parts = []
-        if fg is not None: parts.append(str(fg))
-        if bg is not None: parts.append(str(bg))
+        if fg is not None:
+            parts.append(str(fg))
+        if bg is not None:
+            parts.append(str(bg))
         return ("\x1b[" + ";".join(parts) + "m") if parts else ""
 
     RESET = "\x1b[0m" if use_color else ""
@@ -501,4 +502,4 @@ def render_bw_tiles_split(
 #     mode="text",        # ← key change
 #     text_palette="solid"  # try "solid" for stark black/white
 # )
-# print("```text\n" + art + "\n```")
+# print("```text\n" + art + "\n```")

puzzle_solver/puzzles/binairo/binairo.py

@@ -56,13 +56,13 @@ class Board:
             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. 
+        # 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}'
@@ -106,10 +106,10 @@ class Board:
 
         codes = []
         pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
-        for i, l in enumerate(model_vars):
+        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] * l[k] for k in range(m)))
+            self.model.Add(code == sum(pow2[k] * line[k] for k in range(m)))
             codes.append(code)
 
         self.model.AddAllDifferent(codes)

puzzle_solver/puzzles/black_box/black_box.py

@@ -50,7 +50,7 @@ class Board:
         self.right_values = right
         self.bottom_values = bottom
         self.left_values = left
-        
+
         self.model = cp_model.CpModel()
         self.ball_states: dict[Pos, cp_model.IntVar] = {}
         # (entry_pos, T, cell_pos, direction) -> True if the beam that entered from the board at "entry_pos" is present in "cell_pos" and is going in the direction "direction" at time T
@@ -86,7 +86,7 @@ class Board:
                 for cell in self.get_all_pos_extended():
                     for direction in Direction:
                         self.beam_states[(entry_pos, t, cell, direction)] = self.model.NewBoolVar(f'beam:{entry_pos}:{t}:{cell}:{direction}')
-        
+
         for (entry_pos, t, cell, direction) in self.beam_states.keys():
             if t not in self.beam_states_at_t:
                 self.beam_states_at_t[t] = {}
@@ -110,7 +110,7 @@ class Board:
         beam_ids.extend((beam_id, Direction.LEFT) for beam_id in self.right_cells)
         beam_ids.extend((beam_id, Direction.UP) for beam_id in self.bottom_cells)
         beam_ids.extend((beam_id, Direction.RIGHT) for beam_id in self.left_cells)
-        
+
         for (beam_id, direction) in beam_ids:
             # beam at t=0 is present at beam_id and facing direction
             self.model.Add(self.beam_states[(beam_id, 0, beam_id, direction)] == 1)
@@ -189,7 +189,7 @@ class Board:
         else:
             ball_right = False
             ball_right_not = True
-        
+
         pos_left = get_next_pos(cur_pos, direction_left)
         pos_right = get_next_pos(cur_pos, direction_right)
         pos_reflected = get_next_pos(cur_pos, reflected)
@@ -304,10 +304,4 @@ class Board:
                 ball_state = 'O' if single_res.assignment[pos] else ' '
                 res[pos.y][pos.x] = ball_state
             print(res)
-        r = generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
-        # print('non unique count:', count)
-
-
-
-
-
+        generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/bridges/bridges.py

@@ -73,7 +73,7 @@ class Board:
         xhoriz_min = min(horiz_bridge[0].x, horiz_bridge[1].x)
         xhoriz_max = max(horiz_bridge[0].x, horiz_bridge[1].x)
         yhoriz = horiz_bridge[0].y
-        
+
         # no equals because thats what the puzzle says
         x_contained = xhoriz_min < xvert < xhoriz_max
         y_contained = yvert_min < yhoriz < yvert_max

puzzle_solver/puzzles/chess_range/chess_range.py

@@ -173,11 +173,11 @@ class Board:
         self.H = 8  # board size
         # the puzzle rules mean the only legal positions are the starting positions of the pieces
         self.all_legal_positions: set[Pos] = {pos for _, pos in self.pieces.values()}
-        assert len(self.all_legal_positions) == len(self.pieces), f'positions are not unique'
+        assert len(self.all_legal_positions) == len(self.pieces), 'positions are not unique'
 
         self.model = cp_model.CpModel()
         # Input numbers: N is number of piece, T is number of time steps (=N here), B is board size (=N here because the only legal positions are the starting positions of the pieces):
-        # Number of variables 
+        # Number of variables
         # piece_positions: O(NTB)
         # is_dead: O(NT)
         # mover: O(NT)
@@ -341,7 +341,7 @@ class Board:
         for t in range(self.T - 1):
             self.model.AddExactlyOne([self.victim[(p, t)] for p in range(self.N)])
 
-        # optional parameter to force 
+        # optional parameter to force
         if self.max_moves_per_piece is not None:
             for p in range(self.N):
                 self.model.Add(sum([self.mover[(p, t)] for t in range(self.T - 1)]) <= self.max_moves_per_piece)