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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.31
+Version: 1.0.3
 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,33 @@ 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>
+  <td align="center">
+    <a href="#pipes-puzzle-type-55"><b>Pipes</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/pipes_solved.png" alt="Pipes" width="140">
+    </a>
+  </td>
+</tr>
 </table>
 
 </div>
@@ -434,6 +461,10 @@ 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)
+  - [Pipes (Puzzle Type #55)](#pipes-puzzle-type-55)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -4823,6 +4854,305 @@ 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">
+
+---
+
+## Pipes (Puzzle Type #55)
+
+Also called "Net"
+
+* [**Play online 1**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/net.html)
+
+* [**Play online 2**](https://www.puzzle-pipes.com/)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/net.html#net)
+
+* [**Solver Code**][55]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You are given a grid of cells where each cell has 1, 2, 3, or 4 connections to its neighbors. Each cell can be freely rotated in multiple of 90 degrees, thus your can rotate the cells to be one of four possible states.
+
+The goal is to create a single fully connected graph where each cell's connection must be towards another cell's connection. No loose ends or loops are allowed.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/pipes_unsolved.png" alt="Pipes unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: cells with 1 or 3 active connections only have 1 unique orientation under rotational symmetry. However, cells with 2 active connections can be either a straight line (2I) or curved line (2L))
+
+```python
+import numpy as np
+from puzzle_solver import pipes_solver as solver
+board=np.array([
+    [ '1 ', '3 ', '3 ', '3 ', '1 ', '1 ', '2L', '2L', '2I', '1 ' ],
+    [ '1 ', '1 ', '1 ', '3 ', '2I', '1 ', '2I', '3 ', '2I', '1 ' ],
+    [ '2I', '1 ', '1 ', '3 ', '2L', '1 ', '3 ', '2I', '1 ', '1 ' ],
+    [ '2I', '2I', '1 ', '3 ', '3 ', '3 ', '2L', '3 ', '3 ', '2L' ],
+    [ '3 ', '3 ', '2I', '3 ', '1 ', '3 ', '2I', '2L', '1 ', '2L' ],
+    [ '1 ', '1 ', '3 ', '2I', '3 ', '2L', '1 ', '1 ', '2L', '2L' ],
+    [ '1 ', '1 ', '3 ', '1 ', '1 ', '1 ', '3 ', '3 ', '3 ', '2L' ],
+    [ '3 ', '2I', '3 ', '3 ', '2L', '3 ', '3 ', '2I', '2L', '1 ' ],
+    [ '1 ', '1 ', '3 ', '3 ', '3 ', '3 ', '1 ', '2L', '3 ', '2L' ],
+    [ '1 ', '2I', '3 ', '2I', '1 ', '1 ', '1 ', '3 ', '1 ', '1 ' ],
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+[['R' 'DLR' 'DLR' 'DLR' 'L' 'R' 'DL' 'DR' 'LR' 'L']
+ ['D' 'U' 'U' 'UDR' 'LR' 'L' 'UD' 'UDR' 'LR' 'L']
+ ['UD' 'D' 'R' 'ULR' 'DL' 'R' 'UDL' 'UD' 'D' 'D']
+ ['UD' 'UD' 'R' 'DLR' 'ULR' 'DLR' 'UL' 'UDR' 'ULR' 'UL']
+ ['UDR' 'ULR' 'LR' 'ULR' 'L' 'UDR' 'LR' 'UL' 'R' 'DL']
+ ['U' 'R' 'DLR' 'LR' 'DLR' 'UL' 'D' 'D' 'DR' 'UL']
+ ['D' 'R' 'UDL' 'D' 'U' 'D' 'UDR' 'ULR' 'ULR' 'DL']
+ ['UDR' 'LR' 'ULR' 'UDL' 'DR' 'ULR' 'ULR' 'LR' 'DL' 'U']
+ ['U' 'R' 'DLR' 'ULR' 'ULR' 'DLR' 'L' 'DR' 'ULR' 'DL']
+ ['R' 'LR' 'ULR' 'LR' 'L' 'U' 'R' 'ULR' 'L' 'U']]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 5.65 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/pipes_solved.png" alt="Pipes solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -4925,3 +5255,7 @@ 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"
+[55]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/pipes "puzzle_solver/src/puzzle_solver/puzzles/pipes at master · Ar-Kareem/puzzle_solver · GitHub"

multi_puzzle_solver-1.0.3.dist-info/RECORD

@@ -0,0 +1,70 @@
+puzzle_solver/__init__.py,sha256=g1rzu3qSDD7oz46Els59z3HCxigzjkkFmoG244ymWro,4966
+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/pipes/pipes.py,sha256=SPPgmYXeqjdzijLqdIb_TtlGmxzIad6MHQ31pyDcgUc,4448
+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.3.dist-info/METADATA,sha256=XxSydqNr_sbU-cmZcqvrI5ODi-vrpx7KuLWNmK9q4W4,350517
+multi_puzzle_solver-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-1.0.3.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-1.0.3.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
@@ -28,6 +29,7 @@ from puzzle_solver.puzzles.nurikabe import nurikabe as nurikabe_solver
 from puzzle_solver.puzzles.palisade import palisade as palisade_solver
 from puzzle_solver.puzzles.lits import lits as lits_solver
 from puzzle_solver.puzzles.pearl import pearl as pearl_solver
+from puzzle_solver.puzzles.pipes import pipes as pipes_solver
 from puzzle_solver.puzzles.range import range as range_solver
 from puzzle_solver.puzzles.rectangles import rectangles as rectangles_solver
 from puzzle_solver.puzzles.shakashaka import shakashaka as shakashaka_solver
@@ -52,4 +54,61 @@ 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,
+    pipes_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.3'

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```")