multi-puzzle-solver 0.9.25__py3-none-any.whl → 0.9.27__py3-none-any.whl

{multi_puzzle_solver-0.9.25.dist-info → multi_puzzle_solver-0.9.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.25
+Version: 0.9.27
 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
@@ -331,6 +331,16 @@ 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/palisade_solved.png" alt="Palisade" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#flip-puzzle-type-44"><b>Flip</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flip_unsolved.png" alt="Flip" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#nurikabe-puzzle-type-45"><b>Nurikabe</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/nurikabe_unsolved.png" alt="Nurikabe" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -389,6 +399,8 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Binairo (Puzzle Type #41)](#binairo-puzzle-type-41)
   - [Rectangles (Puzzle Type #42)](#rectangles-puzzle-type-42)
   - [Palisade (Puzzle Type #43)](#palisade-puzzle-type-43)
+  - [Flip (Puzzle Type #44)](#flip-puzzle-type-44)
+  - [Nurikabe (Puzzle Type #45)](#nurikabe-puzzle-type-45)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -3730,14 +3742,13 @@ Applying the solution to the puzzle visually:
 
 ---
 
-
 ## Palisade (Puzzle Type #43)
 
 * [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/palisade.html)
 
 * [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/palisade.html#palisade)
 
-* [**Solver Code**][42]
+* [**Solver Code**][43]
 
 <details>
   <summary><strong>Rules</strong></summary>
@@ -3819,6 +3830,189 @@ Applying the solution to the puzzle visually:
 
 ---
 
+## Flip (Puzzle Type #44)
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/flip.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/flip.html#flip)
+
+* [**Solver Code**][44]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You have a grid of squares, some light and some dark. Your aim is to light all the squares up at the same time. You can choose any square and flip its state from light to dark or dark to light, but when you do so, other squares around it change state as well. 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flip_unsolved.png" alt="Flip unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: the solver also supports random mapping of squares to the neighbors they flip, see the test cases in `tests/test_flip.py` for usage examples)
+
+```python
+import numpy as np
+from puzzle_solver import flip_solver as solver
+board = np.array([
+    ['B', 'W', 'W', 'W', 'W', 'W', 'W'],
+    ['B', 'B', 'W', 'W', 'W', 'B', 'B'],
+    ['W', 'B', 'W', 'W', 'B', 'B', 'W'],
+    ['B', 'B', 'B', 'W', 'W', 'B', 'W'],
+    ['W', 'W', 'B', 'B', 'W', 'B', 'W'],
+    ['B', 'W', 'B', 'B', 'W', 'W', 'W'],
+    ['B', 'W', 'B', 'W', 'W', 'B', 'B'],
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+The output tells you which squares to tap to solve the puzzle.
+
+```python
+Solution found
+[['T' ' ' 'T' 'T' 'T' ' ' ' ']
+ [' ' ' ' ' ' 'T' ' ' 'T' ' ']
+ [' ' 'T' ' ' ' ' 'T' ' ' ' ']
+ ['T' ' ' 'T' ' ' ' ' 'T' ' ']
+ [' ' ' ' ' ' 'T' ' ' ' ' 'T']
+ ['T' ' ' 'T' ' ' 'T' 'T' 'T']
+ [' ' ' ' ' ' ' ' ' ' 'T' 'T']]
+Solutions found: 1
+status: OPTIMAL
+```
+
+**Solved puzzle**
+
+This picture won't mean much as the game is about the sequence of moves not the final frame as shown here.
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flip_solved.png" alt="Flip solved" width="500">
+
+---
+## Nurikabe (Puzzle Type #45)
+
+* [**Play online**](https://www.puzzle-nurikabe.com/)
+
+* [**Instructions**](https://www.logicgamesonline.com/nurikabe/)
+
+* [**Solver Code**][45]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+Nurikabe is a binary determination puzzle. You must decide for each cell if it is white or black according to the following rules:
+
+   - All of the black cells must be connected.
+   - Each numbered cell must be part of a white island of connected white cells.
+   - Each island must have the same number of white cells as the number it contains (including the numbered cell).
+   - Two islands may not be connected.
+   - There cannot be any 2x2 blocks of black cells.
+
+Read more about the history and methods behind nurikabe in the [Wikipedia nurikabe article](https://en.wikipedia.org/wiki/Nurikabe).
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/nurikabe_unsolved.png" alt="Nurikabe unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: the solver also supports random mapping of squares to the neighbors they flip, see the test cases in `tests/test_flip.py` for usage examples)
+
+```python
+import numpy as np
+from puzzle_solver import nurikabe_solver as solver
+board = np.array([
+    ['2', ' ', '3', ' ', '3', ' ', ' ', ' ', '3', ' ', ' ', '3', ' ', ' ', ' ', '2', ' ', '2', ' ', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    [' ', ' ', ' ', ' ', '2', ' ', ' ', '1', ' ', ' ', '1', ' ', '3', ' ', ' ', ' ', '3', ' ', ' ', ' '],
+    ['2', ' ', ' ', '1', ' ', ' ', '3', ' ', ' ', '2', ' ', '2', ' ', ' ', ' ', '1', ' ', ' ', ' ', ' '],
+    [' ', ' ', '2', ' ', '2', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    ['1', ' ', ' ', ' ', ' ', '1', ' ', '2', ' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', '2'],
+    [' ', '2', ' ', '2', ' ', ' ', '1', ' ', ' ', ' ', ' ', ' ', ' ', '6', ' ', ' ', '2', ' ', ' ', ' '],
+    [' ', ' ', ' ', ' ', ' ', '2', ' ', '7', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '3', ' '],
+    [' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' ', '2', ' ', '2', ' ', ' ', ' ', ' ', ' '],
+    ['4', ' ', ' ', ' ', ' ', ' ', '7', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    [' ', ' ', ' ', ' ', '7', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', ' ', ' '],
+    [' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', '1', ' ', ' ', ' ', ' ', ' ', '3'],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' ', '4', ' ', ' ', '7', ' ', ' ', ' ', ' '],
+    [' ', '1', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    [' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', ' '],
+    ['2', ' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', '3', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' '],
+    [' ', ' ', ' ', '4', ' ', ' ', ' ', ' ', '1', ' ', ' ', ' ', '2', ' ', '1', ' ', '3', ' ', ' ', ' '],
+    [' ', '1', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', '1', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2'],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', ' ', ' ', ' ', ' '],
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+The output tells you which squares to tap to solve the puzzle.
+
+```python
+Solution found
+    0   0   0   0   0   0   0   0   0   0   1   1   1   1   1   1   1   1   1   1  
+    0   1   2   3   4   5   6   7   8   9   0   1   2   3   4   5   6   7   8   9
+  ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
+ 0│ 2 │▒▒▒│ 3 │▒▒▒│ 3 │   │   │▒▒▒│ 3 │   │▒▒▒│ 3 │   │   │▒▒▒│ 2 │▒▒▒│ 2 │   │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 1│   │▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 2│▒▒▒│▒▒▒│   │▒▒▒│ 2 │   │▒▒▒│ 1 │▒▒▒│▒▒▒│ 1 │▒▒▒│ 3 │   │▒▒▒│▒▒▒│ 3 │   │   │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 3│ 2 │▒▒▒│▒▒▒│ 1 │▒▒▒│▒▒▒│ 3 │▒▒▒│▒▒▒│ 2 │▒▒▒│ 2 │▒▒▒│   │▒▒▒│ 1 │▒▒▒│▒▒▒│▒▒▒│▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 4│   │▒▒▒│ 2 │▒▒▒│ 2 │▒▒▒│   │   │▒▒▒│   │▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│ 3 │   │   │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 5│▒▒▒│▒▒▒│   │▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│ 2 │▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 6│ 1 │▒▒▒│▒▒▒│▒▒▒│▒▒▒│ 1 │▒▒▒│ 2 │   │▒▒▒│ 3 │▒▒▒│   │▒▒▒│   │   │▒▒▒│ 1 │▒▒▒│ 2 │
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 7│▒▒▒│ 2 │▒▒▒│ 2 │▒▒▒│▒▒▒│ 1 │▒▒▒│▒▒▒│▒▒▒│   │   │▒▒▒│ 6 │   │▒▒▒│ 2 │▒▒▒│▒▒▒│   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 8│▒▒▒│   │▒▒▒│   │▒▒▒│ 2 │▒▒▒│ 7 │   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│   │▒▒▒│▒▒▒│   │▒▒▒│ 3 │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ 9│▒▒▒│▒▒▒│ 3 │▒▒▒│▒▒▒│   │▒▒▒│▒▒▒│   │▒▒▒│ 2 │▒▒▒│ 2 │▒▒▒│ 2 │▒▒▒│▒▒▒│▒▒▒│   │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+10│ 4 │▒▒▒│   │   │▒▒▒│▒▒▒│ 7 │▒▒▒│   │▒▒▒│   │▒▒▒│   │▒▒▒│   │▒▒▒│   │▒▒▒│   │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+11│   │▒▒▒│▒▒▒│▒▒▒│ 7 │▒▒▒│   │▒▒▒│   │   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│ 3 │   │▒▒▒│▒▒▒│▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+12│   │▒▒▒│ 2 │▒▒▒│   │▒▒▒│   │▒▒▒│▒▒▒│   │▒▒▒│ 1 │▒▒▒│ 1 │▒▒▒│▒▒▒│▒▒▒│   │▒▒▒│ 3 │
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+13│   │▒▒▒│   │▒▒▒│   │▒▒▒│   │   │▒▒▒│▒▒▒│ 2 │▒▒▒│ 4 │▒▒▒│▒▒▒│ 7 │   │   │▒▒▒│   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+14│▒▒▒│ 1 │▒▒▒│▒▒▒│   │▒▒▒│▒▒▒│   │   │▒▒▒│   │▒▒▒│   │   │▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+15│▒▒▒│▒▒▒│ 2 │▒▒▒│   │   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│   │▒▒▒│   │▒▒▒│ 1 │▒▒▒│▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+16│ 2 │▒▒▒│   │▒▒▒│▒▒▒│   │▒▒▒│ 1 │▒▒▒│ 3 │   │   │▒▒▒│▒▒▒│▒▒▒│   │▒▒▒│▒▒▒│ 2 │   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+17│   │▒▒▒│▒▒▒│ 4 │▒▒▒│▒▒▒│▒▒▒│▒▒▒│ 1 │▒▒▒│▒▒▒│▒▒▒│ 2 │▒▒▒│ 1 │▒▒▒│ 3 │▒▒▒│▒▒▒│▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+18│▒▒▒│ 1 │▒▒▒│   │   │   │▒▒▒│ 3 │▒▒▒│▒▒▒│ 1 │▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│   │   │▒▒▒│ 2 │
+  ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
+19│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│   │   │▒▒▒│▒▒▒│▒▒▒│▒▒▒│▒▒▒│ 1 │▒▒▒│▒▒▒│▒▒▒│▒▒▒│   │
+  └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
+Solutions found: 1
+status: OPTIMAL
+Time taken: 1.62 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/nurikabe_solved.png" alt="Nurikabe solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -3913,3 +4107,5 @@ Issues and PRs welcome!
 [41]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/binairo "puzzle_solver/src/puzzle_solver/puzzles/binairo at master · Ar-Kareem/puzzle_solver · GitHub"
 [42]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/rectangles "puzzle_solver/src/puzzle_solver/puzzles/rectangles at master · Ar-Kareem/puzzle_solver · GitHub"
 [43]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/palisade "puzzle_solver/src/puzzle_solver/puzzles/palisade at master · Ar-Kareem/puzzle_solver · GitHub"
+[44]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/flip "puzzle_solver/src/puzzle_solver/puzzles/flip at master · Ar-Kareem/puzzle_solver · GitHub"
+[45]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/nurikabe "puzzle_solver/src/puzzle_solver/puzzles/nurikabe at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.9.25.dist-info → multi_puzzle_solver-0.9.27.dist-info}/RECORD

@@ -1,6 +1,7 @@
-puzzle_solver/__init__.py,sha256=DsQVO-Eo1odFFFvQB1IpbJw-Yr2MTtON6zMnLUi05P8,3203
-puzzle_solver/core/utils.py,sha256=7Wo8_LHLEv8bY5-HsuCuLIjttZMMW09DoL1CcFDiu1Q,14046
+puzzle_solver/__init__.py,sha256=FzOcK5T5beTloncBQ-qo9hpqtxu4sbmR7m3fPUnnqec,3272
+puzzle_solver/core/utils.py,sha256=XBW5j-IwtJMPMP-ycmY6SqRCM1NOVl5O6UeoGqNj618,8153
 puzzle_solver/core/utils_ortools.py,sha256=_i8cixHOB5XGqqcr-493bOiZgYJidnvxQMEfj--Trns,10278
+puzzle_solver/core/utils_visualizer.py,sha256=D1eNTZ3eJ76pBoznKRMwvlxXxQsz89K2fBfXP_dASwo,12868
 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=sRtflnlGrN8xQ64beRZBGr74R8KptzxYDdFgXuW27pM,4595
@@ -12,7 +13,7 @@ puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=U3v766UsZHx_dC3gxqU90VbjA
 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=vrOIil285_r3IQ0F4c9mUBWMRVlPH4vowog_z1tCGdI,5567
-puzzle_solver/puzzles/flip/flip.py,sha256=4rQ-JsC_f33YKDM7aueKVlcVdDwzeBkTJL51K-Vy0gA,2223
+puzzle_solver/puzzles/flip/flip.py,sha256=ZngJLUhRNc7qqo2wtNLdMPx4u9w9JTUge27PmdXyDCw,3985
 puzzle_solver/puzzles/galaxies/galaxies.py,sha256=p10lpmW0FjtneFCMEjG1FSiEpQuvD8zZG9FG8zYGoes,5582
 puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=v5TCrdREeOB69s9_QFgPHKA7flG69Im1HVzIdxH0qQc,9355
 puzzle_solver/puzzles/guess/guess.py,sha256=sH-NlYhxM3DNbhk4eGde09kgM0KaDvSbLrpHQiwcFGo,10791
@@ -29,15 +30,16 @@ puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=LiQVOGkWCsc1WtX8CdPgL_Ww
 puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
 puzzle_solver/puzzles/nonograms/nonograms.py,sha256=1jmDTOCnmivmBlwtMDyyk3TVqH5IjapzLn7zLQ4qubk,6056
 puzzle_solver/puzzles/norinori/norinori.py,sha256=uC8vXAw35xsTmpmTeKqYW7tbcssms9LCcXFBONtV2Ng,4743
-puzzle_solver/puzzles/palisade/palisade.py,sha256=ZFvBnBVbR0iIcQ5Vm3PtHPjdSDvrO5OUbM91YoTKpHI,4962
+puzzle_solver/puzzles/nurikabe/nurikabe.py,sha256=VMJjB9KAKmfBkG1mDT3Jf2I1PZJb--Qx0BicN8xL4eg,6519
+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=rruvD5ZSaOgvQuX6uGV_Dkr82nSiWZ5kDz03_j7Tt24,4425
-puzzle_solver/puzzles/rectangles/rectangles.py,sha256=V7p6GSCwYrFfILDWiLLUbX08WlnPbQKdhQm8bMa2Mgw,7060
+puzzle_solver/puzzles/rectangles/rectangles.py,sha256=zaPg3qI9TNxr2iXmNi2kOL8R2RsS9DyQPUTY3ukgYIA,7033
 puzzle_solver/puzzles/signpost/signpost.py,sha256=-0_S6ycwzwlUf9-ZhP127Rgo5gMBOHiTM6t08dLLDac,3869
 puzzle_solver/puzzles/singles/singles.py,sha256=3wACiUa1Vmh2ce6szQ2hPjyBuH7aHiQ888p4R2jFkW4,3342
 puzzle_solver/puzzles/slant/slant.py,sha256=xF-N4PuXYfx638NP1f1mi6YncIZB4mLtXtdS79XyPbg,6122
 puzzle_solver/puzzles/slant/parse_map/parse_map.py,sha256=dxnALSDXe9wU0uSD0QEXnzoh1q801mj1ePTNLtG0n60,4796
-puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=N3jv1Z-yYFlQDinii-DZfuJvLUsn9fT0h5Kyruxjn94,7017
+puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=e1A_f_3J-QXN9fmt_Nf3FsYnp-TmE9TRKN06Wn4NnAU,7056
 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=iK8t02q43gH3FPbuIDn4dK0sbaOgZOnw8yHNRNvNuIU,6534
@@ -53,7 +55,7 @@ puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUy
 puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=WrRdNhmKhIARdGOt_36gpRxRzrfLGv3wl7igBpPFM64,5259
 puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=drjfoHqmFf6U-ZQUwrBbfGINRxDQpgbvy4U3D9QyMhM,6617
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.25.dist-info/METADATA,sha256=DcVaQpmwyhYN0y0XxOcvomrpoerVjgYdylE8VUFml04,208538
-multi_puzzle_solver-0.9.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.25.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.25.dist-info/RECORD,,
+multi_puzzle_solver-0.9.27.dist-info/METADATA,sha256=ZZDovGlLzsfNSjwsqHiYi91vCPJCA2-Na3jiaQ8JiRU,224813
+multi_puzzle_solver-0.9.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.27.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.27.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -8,7 +8,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.flip import flip as flip_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
 from puzzle_solver.puzzles.inertia import inertia as inertia_solver
@@ -21,6 +21,7 @@ from puzzle_solver.puzzles.minesweeper import minesweeper as minesweeper_solver
 from puzzle_solver.puzzles.mosaic import mosaic as mosaic_solver
 from puzzle_solver.puzzles.nonograms import nonograms as nonograms_solver
 from puzzle_solver.puzzles.norinori import norinori as norinori_solver
+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
@@ -45,4 +46,4 @@ 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.25'
+__version__ = '0.9.27'

puzzle_solver/core/utils.py

@@ -42,7 +42,9 @@ def get_next_pos(cur_pos: Pos, direction: Union[Direction, Direction8]) -> Pos:
     return get_pos(cur_pos.x+delta_x, cur_pos.y+delta_y)
 
 
-def get_neighbors4(pos: Pos, V: int, H: int) -> Iterable[Pos]:
+def get_neighbors4(pos: Pos, V: int, H: int, include_self: bool = False) -> Iterable[Pos]:
+    if include_self:
+        yield pos
     for dx, dy in ((1,0),(-1,0),(0,1),(0,-1)):
         p2 = get_pos(x=pos.x+dx, y=pos.y+dy)
         if in_bounds(p2, V, H):
@@ -228,156 +230,3 @@ def polyominoes_with_shape_id(N):
     result = {(frozenset(Pos(x, y) for x, y in s), _id) for s, _id in result}
     return result
 
-
-def render_grid(cell_flags: np.ndarray,
-                center_char: Union[np.ndarray, str, None] = None,
-                show_axes: bool = True,
-                scale_x: int = 2) -> 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.
-    cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
-    center_char: np.ndarray of shape (N, N) with the center of the cells, or a string to use for all cells, or None to not show centers.
-    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
-    """
-    assert cell_flags is not None and cell_flags.ndim == 2
-    R, C = cell_flags.shape
-
-    # Edge presence arrays (note the rectangular shapes)
-    H = np.zeros((R+1, C), dtype=bool)  # horizontal edges between rows
-    V = np.zeros((R, C+1), dtype=bool)  # vertical edges between cols
-    for r in range(R):
-        for c in range(C):
-            s = cell_flags[r, c]
-            if 'U' in s: H[r,   c] = True
-            if 'D' in s: H[r+1, c] = True
-            if 'L' in s: V[r,   c] = True
-            if 'R' in s: V[r, c+1] = True
-
-    # Bitmask for corner connections
-    U, Rb, D, Lb = 1, 2, 4, 8
-    JUNCTION = {
-        0: ' ',
-        U: '│', D: '│', U|D: '│',
-        Lb: '─', Rb: '─', Lb|Rb: '─',
-        U|Rb: '└', Rb|D: '┌', D|Lb: '┐', Lb|U: '┘',
-        U|D|Lb: '┤', U|D|Rb: '├', Lb|Rb|U: '┴', Lb|Rb|D: '┬',
-        U|Rb|D|Lb: '┼',
-    }
-
-    assert scale_x >= 1
-    assert H.shape == (R+1, C) and V.shape == (R, C+1)
-
-    rows = 2*R + 1
-    cols = 2*C*scale_x + 1
-    canvas = [[' ']*cols for _ in range(rows)]
-
-    def x_corner(c):     # x of corner column c  (0..C)
-        return (2*c) * scale_x
-    def x_between(c,k):  # kth in-between col (1..2*scale_x-1) between corners c and c+1
-        return (2*c) * scale_x + k
-
-    # horizontal edges: fill the stretched band between corners with '─'
-    for r in range(R+1):
-        rr = 2*r
-        for c in range(C):
-            if H[r, c]:
-                for k in range(1, scale_x*2):  # 1..(2*scale_x-1)
-                    canvas[rr][x_between(c, k)] = '─'
-
-    # vertical edges: at the corner columns
-    for r in range(R):
-        rr = 2*r + 1
-        for c in range(C+1):
-            if V[r, c]:
-                canvas[rr][x_corner(c)] = '│'
-
-    # junctions at every corner grid point
-    for r in range(R+1):
-        rr = 2*r
-        for c in range(C+1):
-            m = 0
-            if r > 0   and V[r-1, c]: m |= U
-            if c < C   and H[r, c]:   m |= Rb
-            if r < R   and V[r, c]:   m |= D
-            if c > 0   and H[r, c-1]: m |= Lb
-            canvas[rr][x_corner(c)] = JUNCTION[m]
-
-    # centers (safe for multi-character strings)
-    def put_center_text(rr: int, c: int, text: str):
-        left  = x_corner(c) + 1
-        right = x_corner(c+1) - 1
-        if right < left:
-            return
-        span_width = right - left + 1
-        s = str(text)
-        if len(s) > span_width:
-            s = s[:span_width]  # truncate to protect borders
-        start = left + (span_width - len(s)) // 2
-        for i, ch in enumerate(s):
-            canvas[rr][start + i] = ch
-
-    if center_char is not None:
-        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]
-                put_center_text(rr, c, '' if val is None else str(val))
-
-    # rows -> strings
-    art_rows = [''.join(row) for row in canvas]
-    if not show_axes:
-        return '\n'.join(art_rows)
-
-    # Axes labels: row indices on the left, column indices on top (handle C, not R)
-    gut = max(2, len(str(R-1)))  # gutter width based on row index width
-    gutter = ' ' * gut
-    top_tens = list(gutter + ' ' * cols)
-    top_ones = list(gutter + ' ' * cols)
-
-    for c in range(C):
-        xc_center = x_corner(c) + scale_x
-        if C >= 10:
-            top_tens[gut + xc_center] = str((c // 10) % 10)
-        top_ones[gut + xc_center] = str(c % 10)
-
-    if gut >= 2:
-        top_tens[gut-2:gut] = list('  ')
-        top_ones[gut-2:gut] = list('  ')
-
-    labeled = []
-    for r, line in enumerate(art_rows):
-        if r % 2 == 1:  # cell-center row
-            label = str(r//2).rjust(gut)
-        else:
-            label = ' ' * gut
-        labeled.append(label + line)
-
-    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
-
-def id_board_to_wall_board(id_board: np.array, border_is_wall = True) -> np.array:
-    """In many instances, we have a 2d array where cell values are arbitrary ids
-    and we want to convert it to a 2d array where cell values are walls "U", "D", "L", "R" to represent the edges that separate me from my neighbors that have different ids.
-    Args:
-        id_board: np.array of shape (N, N) with arbitrary ids.
-        border_is_wall: if True, the edges of the board are considered to be walls.
-    Returns:
-        np.array of shape (N, N) with walls "U", "D", "L", "R".
-    """
-    res = np.full((id_board.shape[0], id_board.shape[1]), '', dtype=object)
-    V, H = id_board.shape
-    def append_char(pos: Pos, s: str):
-        set_char(res, pos, get_char(res, pos) + s)
-    def handle_pos_direction(pos: Pos, direction: Direction, s: str):
-        pos2 = get_next_pos(pos, direction)
-        if in_bounds(pos2, V, H):
-            if get_char(id_board, pos2) != get_char(id_board, pos):
-                append_char(pos, s)
-        else:
-            if border_is_wall:
-                append_char(pos, s)
-    for pos in get_all_pos(V, H):
-        handle_pos_direction(pos, Direction.LEFT, 'L')
-        handle_pos_direction(pos, Direction.RIGHT, 'R')
-        handle_pos_direction(pos, Direction.UP, 'U')
-        handle_pos_direction(pos, Direction.DOWN, 'D')
-    return res

puzzle_solver/core/utils_visualizer.py

@@ -0,0 +1,310 @@
+import numpy as np
+from typing import Union, Callable, Optional
+from puzzle_solver.core.utils import Pos, get_all_pos, get_next_pos, in_bounds, set_char, get_char, Direction
+
+
+def render_grid(cell_flags: np.ndarray,
+                center_char: Union[np.ndarray, str, None] = None,
+                show_axes: bool = True,
+                scale_x: int = 2) -> 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.
+    cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
+    center_char: np.ndarray of shape (N, N) with the center of the cells, or a string to use for all cells, or None to not show centers.
+    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
+    """
+    assert cell_flags is not None and cell_flags.ndim == 2
+    R, C = cell_flags.shape
+
+    # Edge presence arrays (note the rectangular shapes)
+    H = np.zeros((R+1, C), dtype=bool)  # horizontal edges between rows
+    V = np.zeros((R, C+1), dtype=bool)  # vertical edges between cols
+    for r in range(R):
+        for c in range(C):
+            s = cell_flags[r, c]
+            if 'U' in s: H[r,   c] = True
+            if 'D' in s: H[r+1, c] = True
+            if 'L' in s: V[r,   c] = True
+            if 'R' in s: V[r, c+1] = True
+
+    # Bitmask for corner connections
+    U, Rb, D, Lb = 1, 2, 4, 8
+    JUNCTION = {
+        0: ' ',
+        U: '│', D: '│', U|D: '│',
+        Lb: '─', Rb: '─', Lb|Rb: '─',
+        U|Rb: '└', Rb|D: '┌', D|Lb: '┐', Lb|U: '┘',
+        U|D|Lb: '┤', U|D|Rb: '├', Lb|Rb|U: '┴', Lb|Rb|D: '┬',
+        U|Rb|D|Lb: '┼',
+    }
+
+    assert scale_x >= 1
+    assert H.shape == (R+1, C) and V.shape == (R, C+1)
+
+    rows = 2*R + 1
+    cols = 2*C*scale_x + 1
+    canvas = [[' ']*cols for _ in range(rows)]
+
+    def x_corner(c):     # x of corner column c  (0..C)
+        return (2*c) * scale_x
+    def x_between(c,k):  # kth in-between col (1..2*scale_x-1) between corners c and c+1
+        return (2*c) * scale_x + k
+
+    # horizontal edges: fill the stretched band between corners with '─'
+    for r in range(R+1):
+        rr = 2*r
+        for c in range(C):
+            if H[r, c]:
+                for k in range(1, scale_x*2):  # 1..(2*scale_x-1)
+                    canvas[rr][x_between(c, k)] = '─'
+
+    # vertical edges: at the corner columns
+    for r in range(R):
+        rr = 2*r + 1
+        for c in range(C+1):
+            if V[r, c]:
+                canvas[rr][x_corner(c)] = '│'
+
+    # junctions at every corner grid point
+    for r in range(R+1):
+        rr = 2*r
+        for c in range(C+1):
+            m = 0
+            if r > 0   and V[r-1, c]: m |= U
+            if c < C   and H[r, c]:   m |= Rb
+            if r < R   and V[r, c]:   m |= D
+            if c > 0   and H[r, c-1]: m |= Lb
+            canvas[rr][x_corner(c)] = JUNCTION[m]
+
+    # centers (safe for multi-character strings)
+    def put_center_text(rr: int, c: int, text: str):
+        left  = x_corner(c) + 1
+        right = x_corner(c+1) - 1
+        if right < left:
+            return
+        span_width = right - left + 1
+        s = str(text)
+        if len(s) > span_width:
+            s = s[:span_width]  # truncate to protect borders
+        start = left + (span_width - len(s)) // 2
+        for i, ch in enumerate(s):
+            canvas[rr][start + i] = ch
+
+    if center_char is not None:
+        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]
+                put_center_text(rr, c, '' if val is None else str(val))
+
+    # rows -> strings
+    art_rows = [''.join(row) for row in canvas]
+    if not show_axes:
+        return '\n'.join(art_rows)
+
+    # Axes labels: row indices on the left, column indices on top (handle C, not R)
+    gut = max(2, len(str(R-1)))  # gutter width based on row index width
+    gutter = ' ' * gut
+    top_tens = list(gutter + ' ' * cols)
+    top_ones = list(gutter + ' ' * cols)
+
+    for c in range(C):
+        xc_center = x_corner(c) + scale_x
+        if C >= 10:
+            top_tens[gut + xc_center] = str((c // 10) % 10)
+        top_ones[gut + xc_center] = str(c % 10)
+
+    if gut >= 2:
+        top_tens[gut-2:gut] = list('  ')
+        top_ones[gut-2:gut] = list('  ')
+
+    labeled = []
+    for r, line in enumerate(art_rows):
+        if r % 2 == 1:  # cell-center row
+            label = str(r//2).rjust(gut)
+        else:
+            label = ' ' * gut
+        labeled.append(label + line)
+
+    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
+
+def id_board_to_wall_board(id_board: np.array, border_is_wall = True) -> np.array:
+    """In many instances, we have a 2d array where cell values are arbitrary ids
+    and we want to convert it to a 2d array where cell values are walls "U", "D", "L", "R" to represent the edges that separate me from my neighbors that have different ids.
+    Args:
+        id_board: np.array of shape (N, N) with arbitrary ids.
+        border_is_wall: if True, the edges of the board are considered to be walls.
+    Returns:
+        np.array of shape (N, N) with walls "U", "D", "L", "R".
+    """
+    res = np.full((id_board.shape[0], id_board.shape[1]), '', dtype=object)
+    V, H = id_board.shape
+    def append_char(pos: Pos, s: str):
+        set_char(res, pos, get_char(res, pos) + s)
+    def handle_pos_direction(pos: Pos, direction: Direction, s: str):
+        pos2 = get_next_pos(pos, direction)
+        if in_bounds(pos2, V, H):
+            if get_char(id_board, pos2) != get_char(id_board, pos):
+                append_char(pos, s)
+        else:
+            if border_is_wall:
+                append_char(pos, s)
+    for pos in get_all_pos(V, H):
+        handle_pos_direction(pos, Direction.LEFT, 'L')
+        handle_pos_direction(pos, Direction.RIGHT, 'R')
+        handle_pos_direction(pos, Direction.UP, 'U')
+        handle_pos_direction(pos, Direction.DOWN, 'D')
+    return res
+
+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:
+    """
+    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.
+    The grid lines are always present.
+
+    scale_x: horizontal stretch (>=1). Interior width per cell = 2*scale_x - 1.
+    scale_y: vertical stretch (>=1). Interior height per cell = scale_y.
+    fill_char: character to fill shaded cell interiors (single char).
+    empty_char: background character for unshaded interiors (single char).
+    empty_text: Optional text for unshaded cells. If a string, used for all unshaded
+                cells. If a callable (r, c) -> str|None, used per cell. Text is
+                centered within the interior row and truncated to fit.
+    """
+    assert V >= 1 and H >= 1
+    assert scale_x >= 1 and scale_y >= 1
+    assert len(fill_char) == 1 and len(empty_char) == 1
+
+    # ── Layout helpers ─────────────────────────────────────────────────────
+    def x_corner(c: int) -> int:                 # column of vertical border at grid column c (0..H)
+        return (2 * c) * scale_x
+    def y_border(r: int) -> int:                 # row of horizontal border at grid row r (0..V)
+        return (scale_y + 1) * r
+
+    rows = y_border(V) + 1
+    cols = x_corner(H) + 1
+    canvas = [[empty_char] * cols for _ in range(rows)]
+
+    # ── Shading first (borders will overwrite as needed) ───────────────────
+    shaded_map = [[False]*H for _ in range(V)]
+    for r in range(V):
+        top = y_border(r) + 1
+        bottom = y_border(r + 1) - 1             # inclusive
+        if top > bottom:
+            continue
+        for c in range(H):
+            left  = x_corner(c) + 1
+            right = x_corner(c + 1) - 1          # inclusive
+            if left > right:
+                continue
+            shaded = bool(is_shaded(r, c))
+            shaded_map[r][c] = shaded
+            ch = fill_char if shaded else empty_char
+            for yy in range(top, bottom + 1):
+                for xx in range(left, right + 1):
+                    canvas[yy][xx] = ch
+
+    # ── Grid lines ─────────────────────────────────────────────────────────
+    U, Rb, D, Lb = 1, 2, 4, 8
+    JUNCTION = {
+        0: ' ',
+        U: '│', D: '│', U | D: '│',
+        Lb: '─', Rb: '─', Lb | Rb: '─',
+        U | Rb: '└', Rb | D: '┌', D | Lb: '┐', Lb | U: '┘',
+        U | D | Lb: '┤', U | D | Rb: '├', Lb | Rb | U: '┴', Lb | Rb | D: '┬',
+        U | Rb | D | Lb: '┼',
+    }
+
+    # Horizontal borders (every y_border row)
+    for r in range(V + 1):
+        yy = y_border(r)
+        for c in range(H):
+            base = x_corner(c)
+            for k in range(1, 2 * scale_x):      # 1..(2*scale_x-1)
+                canvas[yy][base + k] = '─'
+
+    # Vertical borders (every x_corner col)
+    for c in range(H + 1):
+        xx = x_corner(c)
+        for r in range(V):
+            for ky in range(1, scale_y + 1):
+                canvas[y_border(r) + ky][xx] = '│'
+
+    # Junctions at intersections
+    for r in range(V + 1):
+        yy = y_border(r)
+        for c in range(H + 1):
+            xx = x_corner(c)
+            m = 0
+            if r > 0: m |= U
+            if r < V: m |= D
+            if c > 0: m |= Lb
+            if c < H: m |= Rb
+            canvas[yy][xx] = JUNCTION[m]
+
+    # ── Optional per-cell text for UNshaded cells ──────────────────────────
+    def put_center_text(r_cell: int, c_cell: int, s: str):
+        # interior box
+        left  = x_corner(c_cell) + 1
+        right = x_corner(c_cell + 1) - 1
+        top   = y_border(r_cell) + 1
+        bottom= y_border(r_cell + 1) - 1
+        if left > right or top > bottom:
+            return
+        span_w = right - left + 1
+        # choose middle interior row for text
+        yy = top + (bottom - top) // 2
+        s = '' if s is None else str(s)
+        if len(s) > span_w:
+            s = s[:span_w]
+        start = left + (span_w - len(s)) // 2
+        for i, ch in enumerate(s):
+            canvas[yy][start + i] = ch
+
+    if empty_text is not None:
+        for r in range(V):
+            for c in range(H):
+                if not shaded_map[r][c]:
+                    s = empty_text(r, c) if callable(empty_text) else empty_text
+                    if s:
+                        put_center_text(r, c, s)
+
+    # ── Stringify ──────────────────────────────────────────────────────────
+    art_rows = [''.join(row) for row in canvas]
+    if not show_axes:
+        return '\n'.join(art_rows)
+
+    # Axes labels: columns on top; rows on left
+    gut = max(2, len(str(V - 1)))
+    gutter = ' ' * gut
+    top_tens = list(gutter + ' ' * cols)
+    top_ones = list(gutter + ' ' * cols)
+    for c in range(H):
+        xc_center = x_corner(c) + scale_x
+        if H >= 10:
+            top_tens[gut + xc_center] = str((c // 10) % 10)
+        top_ones[gut + xc_center] = str(c % 10)
+    if gut >= 2:
+        top_tens[gut - 2:gut] = list('  ')
+        top_ones[gut - 2:gut] = list('  ')
+
+    labeled = []
+    for y, line in enumerate(art_rows):
+        mod = y % (scale_y + 1)
+        if 1 <= mod <= scale_y:
+            r = y // (scale_y + 1)
+            mid = (scale_y + 1) // 2
+            label = (str(r).rjust(gut) if mod == mid else ' ' * gut)
+        else:
+            label = ' ' * gut
+        labeled.append(label + line)
+
+    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)

puzzle_solver/puzzles/flip/flip.py

@@ -1,18 +1,41 @@
+from typing import Any, Optional
+
 import numpy as np
 from ortools.sat.python import cp_model
-from ortools.sat.python.cp_model import LinearExpr as lxp
 
-from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char, get_neighbors8
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, set_char, get_char, Direction, get_next_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 
 class Board:
-    def __init__(self, board: np.array):
+    def __init__(self, board: np.array, random_mapping: Optional[dict[Pos, Any]] = None):
         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((c.item() == ' ') or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        assert all((c.item() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only B or W'
         self.board = board
-        self.N = board.shape[0]
+        self.V, self.H = board.shape
+
+        if random_mapping is None:
+            self.tap_mapping: dict[Pos, set[Pos]] = {pos: list(get_neighbors4(pos, self.V, self.H, include_self=True)) for pos in get_all_pos(self.V, self.H)}
+        else:
+            mapping_value = list(random_mapping.values())[0]
+            if isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], Pos):
+                self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
+            elif isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], str):  # strings like "L", "UR", etc.
+                def _to_pos(pos: Pos, s: str) -> Pos:
+                    d = {'L': Direction.LEFT, 'R': Direction.RIGHT, 'U': Direction.UP, 'D': Direction.DOWN}[s[0]]
+                    r = get_next_pos(pos, d)
+                    if len(s) == 1:
+                        return r
+                    else:
+                        return _to_pos(r, s[1:])
+                self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(_to_pos(pos, s) for s in random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
+            else:
+                raise ValueError(f'invalid random_mapping: {random_mapping}')
+            for k, v in self.tap_mapping.items():
+                if k not in v:
+                    v.add(k)
+
+
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
 
@@ -20,16 +43,22 @@ class Board:
         self.add_all_constraints()
 
     def create_vars(self):
-        for pos in get_all_pos(self.N):
-            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'tap:{pos}')
 
     def add_all_constraints(self):
-        for pos in get_all_pos(self.N):
+        for pos in get_all_pos(self.V, self.H):
+            # the state of a position is its starting state + if it is tapped + if any pos pointing to it is tapped
             c = get_char(self.board, pos)
-            if not str(c).isdecimal():
-                continue
-            neighbour_vars = [self.model_vars[p] for p in get_neighbors8(pos, self.N, include_self=True)]
-            self.model.Add(lxp.sum(neighbour_vars) == int(c))
+            pos_that_will_turn_me = [k for k,v in self.tap_mapping.items() if pos in v]
+            literals = [self.model_vars[p] for p in pos_that_will_turn_me]
+            if c == 'W':  # if started as white then needs an even number of taps while xor checks for odd number
+                literals.append(self.model.NewConstant(True))
+            elif c == 'B':
+                pass
+            else:
+                raise ValueError(f'invalid character: {c}')
+            self.model.AddBoolXOr(literals)
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
@@ -39,10 +68,10 @@ 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_char(self.board, pos)
-                c = 'B' if single_res.assignment[pos] == 1 else ' '
+                c = 'T' if single_res.assignment[pos] == 1 else ' '
                 set_char(res, pos, c)
             print(res)
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/nurikabe/nurikabe.py

@@ -0,0 +1,126 @@
+from dataclasses import dataclass
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, in_bounds, set_char, get_char, polyominoes, Shape, Direction, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
+
+
+@dataclass
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    N: int
+    body: set[Pos]
+    force_water: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() == ' ') or str(c.item()).isdecimal() or c.item() == '#' for c in np.nditer(board)), 'board must contain only space, #, or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.illegal_positions: set[Pos] = {pos for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos) == '#'}
+
+        unique_numbers: set[int] = {int(c) for c in np.nditer(board) if str(c).isdecimal()}
+        self.polyominoes: dict[int, set[Shape]] = {n: polyominoes(n) for n in unique_numbers}
+        self.hints = {pos: int(get_char(self.board, pos)) for pos in get_all_pos(self.V, self.H) if str(get_char(self.board, pos)).isdecimal()}
+        self.all_hint_pos: set[Pos] = set(self.hints.keys())
+
+        self.model = cp_model.CpModel()
+        self.W: dict[Pos, cp_model.IntVar] = {}
+        self.B: dict[Pos, cp_model.IntVar] = {}
+        self.shapes_on_board: list[ShapeOnBoard] = []
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in self.get_all_legal_pos():
+            self.W[pos] = self.model.NewBoolVar(f'W:{pos}')
+            self.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+            self.model.AddExactlyOne([self.W[pos], self.B[pos]])
+
+    def get_all_legal_pos(self) -> set[Pos]:
+        return {pos for pos in get_all_pos(self.V, self.H) if pos not in self.illegal_positions}
+
+    def in_bounds_and_legal(self, pos: Pos) -> bool:
+        return in_bounds(pos, self.V, self.H) and pos not in self.illegal_positions
+
+    def add_all_constraints(self):
+        for pos in self.W.keys():
+            self.model.AddExactlyOne([self.W[pos], self.B[pos]])
+
+        # init shapes on board for each hint
+        for hint_pos, hint_value in self.hints.items():
+            hint_shapes = []
+            for shape in self.polyominoes[hint_value]:
+                hint_single_shape = self.init_shape_on_board(shape, hint_pos, hint_value)  # a "single shape" is translated many times
+                hint_shapes.extend(hint_single_shape)
+            assert len(hint_shapes) > 0, f'no shapes found for hint {hint_pos} with value {hint_value}'
+            self.model.AddExactlyOne([s.is_active for s in hint_shapes])
+            self.shapes_on_board.extend(hint_shapes)
+        
+        # if no shape is active on the spot then it must be black
+        for pos in self.get_all_legal_pos():
+            shapes_here = [s for s in self.shapes_on_board if pos in s.body]
+            self.model.AddExactlyOne([s.is_active for s in shapes_here] + [self.B[pos]])
+
+        # if a shape is active, then all its body must be white and force water must be black
+        for shape_on_board in self.shapes_on_board:
+            for pos in shape_on_board.body:
+                self.model.Add(self.W[pos] == 1).OnlyEnforceIf(shape_on_board.is_active)
+            for pos in shape_on_board.force_water:
+                self.model.Add(self.B[pos] == 1).OnlyEnforceIf(shape_on_board.is_active)
+
+        # disallow 2x2 blacks
+        for pos in get_all_pos(self.V, self.H):
+            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].Not(), self.B[tr].Not(), self.B[bl].Not(), self.B[br].Not()])
+
+        # all black is single connected component
+        force_connected_component(self.model, self.B)
+
+    def init_shape_on_board(self, shape: Shape, hint_pos: Pos, hint_value: int):
+        other_hint_pos: set[Pos] = self.all_hint_pos - {hint_pos}
+        max_x = max(p.x for p in shape)
+        max_y = max(p.y for p in shape)
+        hint_shapes = []
+        for dx in range(0, max_x + 1):
+            for dy in range(0, max_y + 1):
+                body = {get_pos(x=p.x + hint_pos.x - dx, y=p.y + hint_pos.y - dy) for p in shape}  # translate shape by fixed hint position then dynamic moving dx and dy
+                if hint_pos not in body:  # the hint must still be in the body after translation
+                    continue
+                if any(not self.in_bounds_and_legal(p) for p in body):  # illegal shape
+                    continue
+                water = set(p for pos in body for p in get_neighbors4(pos, self.V, self.H))
+                water -= body
+                water -= self.illegal_positions
+                if any(p in other_hint_pos for p in body) or any(w in other_hint_pos for w in water):  # shape touches another hint or forces water on another hint, illegal
+                    continue
+                shape_on_board = ShapeOnBoard(
+                    is_active=self.model.NewBoolVar(f'{hint_pos}:{dx}:{dy}:is_active'),
+                    N=hint_value,
+                    body=body,
+                    force_water=water,
+                )
+                hint_shapes.append(shape_on_board)
+        return hint_shapes
+
+    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] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(render_shaded_grid(self.V, self.H, lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1, empty_text=lambda r, c: str(self.board[r, c])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/palisade/palisade.py

@@ -4,8 +4,9 @@ from collections import defaultdict
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, id_board_to_wall_board, render_grid, set_char, in_bounds, get_next_pos, Direction, polyominoes
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, set_char, in_bounds, get_next_pos, Direction, polyominoes
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import id_board_to_wall_board, render_grid
 
 
 
@@ -44,7 +45,7 @@ def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
                 if c != ' ' and c != str(shape_borders[i]):  # there is a clue and it doesn't match my translated shape, skip
                     break
             else:
-                yield tuple(get_pos(x=p[0], y=p[1]) for p in body)
+                yield frozenset(get_pos(x=p[0], y=p[1]) for p in body)
 
 
 

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -3,10 +3,10 @@ from dataclasses import dataclass
 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, in_bounds, set_char, get_char, get_neighbors8, Direction, get_next_pos, render_grid
+from puzzle_solver.core.utils import Pos, get_all_pos, in_bounds, set_char, get_char, Direction, get_next_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import render_grid
 
 
 def factor_pairs(N: int, upper_limit_i: int, upper_limit_j: int):

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -2,8 +2,9 @@ import numpy as np
 from collections import defaultdict
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, Direction, get_row_pos, get_col_pos, get_next_pos, in_bounds, get_opposite_direction, render_grid
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, Direction, get_row_pos, get_col_pos, get_next_pos, in_bounds, get_opposite_direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import render_grid
 
 
 CellBorder = tuple[Pos, Direction]