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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.18
+Version: 0.9.20
 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
@@ -299,6 +299,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/unequal_solved.png" alt="Unequal" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#norinori-puzzle-type-38"><b>Norinori</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/norinori_solved.png" alt="Norinori" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#slitherlink-puzzle-type-39"><b>Slitherlink</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/slitherlink_solved.png" alt="Slitherlink" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -351,6 +361,8 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Galaxies (Puzzle Type #35)](#galaxies-puzzle-type-35)
   - [Slant (Puzzle Type #36)](#slant-puzzle-type-36)
   - [Unequal (Puzzle Type #37)](#unequal-puzzle-type-37)
+  - [Norinori (Puzzle Type #38)](#norinori-puzzle-type-38)
+  - [Slitherlink (Puzzle Type #39)](#slitherlink-puzzle-type-39)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -3083,6 +3095,8 @@ Applying the solution to the puzzle visually:
 
 ## Unequal (Puzzle Type #37)
 
+Also called "Futoshiki" or Renzoku"
+
 * [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/unequal.html)
 
 * [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/unequal.html#unequal)
@@ -3117,6 +3131,7 @@ Code to utilize this package and solve the puzzle:
 Note: For an NxM board you need an (2N-1)x(2M-1) array because the puzzle involves input in between the cells. Each numbered cell has neighbors horizontally to represent ">", "<", and "|" (where "|" represents adjacency) and vertically to represent "∧", "∨" and "-" (where "-" represents adjacency). The "X" in the input are unused corners that shouldnt contain anything (just a corner). The numbers should never appear orthogonal to an "X", only diagonally to it. vice-versa for the comparison operators.
 
 ```python
+from puzzle_solver import unequal_solver as solver
 board = np.array([
     [' ', ' ', ' ', ' ', '9', ' ', '1', ' ', '7', '>', ' ', '>', ' ', ' ', ' ', ' ', ' ', '>', ' '],
     [' ', 'X', 'V', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', '∧', 'X', ' ', 'X', ' ', 'X', ' '],
@@ -3170,6 +3185,206 @@ Applying the solution to the puzzle visually:
 
 ---
 
+## Norinori (Puzzle Type #38)
+
+* [**Play online**](https://www.puzzle-norinori.com)
+
+* [**Solver Code**][38]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You have to shade some of the cells in such a way that:
+- Exactly 2 cells are shaded in each region.
+- Each shaded cell should be a part of a domino*. Dominoes can cross the region borders.
+- The dominoes cannot touch each other except diagonally.
+
+* A domino is a shape made of 2 shaded cells next to each other (1x2 or 2x1).
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/norinori_unsolved.png" alt="Norinori unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+from puzzle_solver import norinori_solver as solver
+board = np.array([
+    ['00', '01', '01', '01', '01', '02', '03', '03', '04', '04', '04', '05', '05', '05', '06', '07', '08', '08', '09', '09'],
+    ['00', '00', '01', '01', '01', '02', '03', '04', '04', '10', '11', '11', '05', '06', '06', '07', '08', '08', '12', '12'],
+    ['13', '13', '13', '01', '01', '03', '03', '10', '10', '10', '11', '14', '05', '14', '07', '07', '07', '12', '12', '12'],
+    ['13', '15', '13', '16', '16', '16', '17', '17', '17', '18', '18', '14', '14', '14', '07', '07', '07', '07', '07', '12'],
+    ['13', '15', '15', '16', '19', '19', '17', '17', '17', '18', '18', '18', '14', '20', '07', '07', '21', '21', '21', '21'],
+    ['13', '19', '19', '19', '19', '19', '17', '22', '22', '22', '22', '18', '14', '20', '20', '07', '21', '23', '23', '21'],
+    ['24', '24', '25', '25', '25', '25', '26', '27', '27', '27', '28', '28', '20', '20', '29', '29', '30', '30', '31', '31'],
+    ['24', '24', '25', '32', '33', '33', '26', '27', '27', '34', '28', '35', '35', '36', '36', '29', '37', '30', '31', '31'],
+    ['38', '32', '32', '32', '33', '27', '27', '27', '27', '34', '28', '28', '35', '35', '29', '29', '37', '37', '31', '37'],
+    ['38', '38', '32', '39', '33', '40', '34', '34', '34', '34', '28', '35', '35', '35', '41', '37', '37', '37', '37', '37'],
+    ['42', '38', '39', '39', '40', '40', '43', '43', '34', '44', '28', '35', '45', '45', '41', '41', '41', '41', '46', '46'],
+    ['42', '42', '39', '47', '47', '40', '40', '44', '44', '44', '48', '48', '48', '48', '48', '41', '49', '49', '49', '46'],
+    ['50', '50', '39', '39', '40', '40', '40', '40', '51', '51', '51', '52', '48', '48', '53', '41', '54', '54', '49', '46'],
+    ['50', '39', '39', '55', '55', '40', '40', '40', '56', '51', '51', '52', '53', '48', '53', '41', '41', '54', '49', '46'],
+    ['39', '39', '39', '57', '56', '56', '56', '56', '56', '56', '53', '53', '53', '53', '53', '58', '58', '58', '59', '59'],
+    ['60', '39', '39', '57', '57', '61', '61', '61', '62', '56', '56', '63', '63', '63', '63', '63', '59', '59', '59', '59'],
+    ['60', '64', '65', '65', '61', '61', '66', '66', '62', '62', '62', '67', '63', '63', '68', '69', '69', '69', '69', '69'],
+    ['60', '64', '65', '65', '65', '65', '66', '70', '70', '70', '70', '67', '67', '71', '68', '69', '72', '73', '73', '69'],
+    ['60', '60', '60', '65', '66', '66', '66', '66', '74', '75', '75', '75', '67', '71', '68', '68', '72', '73', '73', '73'],
+    ['76', '76', '76', '76', '76', '77', '77', '74', '74', '74', '74', '67', '67', '71', '71', '71', '72', '73', '78', '78']
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+**Script Output**
+
+```python
+Solution found
+[
+    [ 'X', ' ', ' ', ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', 'X' ],
+    [ 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', ' ' ],
+    [ ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', 'X', ' ', ' ', ' ', 'X', ' ', ' ' ],
+    [ 'X', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X' ],
+    [ ' ', ' ', 'X', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', 'X', ' ', ' ', 'X', 'X', ' ', ' ', 'X' ],
+    [ ' ', 'X', ' ', ' ', 'X', ' ', ' ', 'X', 'X', ' ', ' ', ' ', ' ', 'X', 'X', ' ', ' ', 'X', 'X', ' ' ],
+    [ ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', ' ', 'X', 'X', ' ', ' ', 'X' ],
+    [ 'X', ' ', 'X', 'X', ' ', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', 'X', ' ', ' ', 'X', ' ', 'X' ],
+    [ 'X', ' ', ' ', ' ', 'X', ' ', ' ', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', ' ', ' ' ],
+    [ ' ', 'X', 'X', ' ', 'X', ' ', ' ', ' ', 'X', ' ', 'X', 'X', ' ', ' ', ' ', 'X', ' ', ' ', ' ', ' ' ],
+    [ 'X', ' ', ' ', ' ', ' ', ' ', 'X', 'X', ' ', 'X', ' ', ' ', 'X', 'X', ' ', ' ', ' ', 'X', 'X', ' ' ],
+    [ 'X', ' ', ' ', 'X', 'X', ' ', ' ', ' ', ' ', 'X', ' ', ' ', ' ', ' ', 'X', ' ', 'X', ' ', ' ', ' ' ],
+    [ ' ', 'X', 'X', ' ', ' ', ' ', ' ', 'X', 'X', ' ', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', 'X' ],
+    [ 'X', ' ', ' ', 'X', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ' ],
+    [ 'X', ' ', ' ', ' ', ' ', ' ', 'X', ' ', ' ', 'X', ' ', ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ' ],
+    [ ' ', ' ', ' ', 'X', 'X', ' ', ' ', 'X', 'X', ' ', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', 'X' ],
+    [ ' ', 'X', ' ', ' ', ' ', 'X', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', 'X' ],
+    [ ' ', 'X', ' ', 'X', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', 'X', 'X', ' ', ' ', ' ', 'X', 'X', ' ' ],
+    [ 'X', ' ', 'X', ' ', ' ', ' ', ' ', 'X', ' ', ' ', 'X', 'X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', ' ' ],
+    [ 'X', ' ', 'X', ' ', ' ', 'X', 'X', ' ', 'X', 'X', ' ', ' ', ' ', ' ', 'X', ' ', 'X', ' ', 'X', 'X' ],
+]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.04 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/norinori_solved.png" alt="Norinori solved" width="500">
+
+---
+
+## Slitherlink (Puzzle Type #39)
+
+Also known as Fences and Loop the Loop
+
+* [**Play online**](https://www.puzzle-loop.com)
+
+* [**Solver Code**][39]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You have to draw lines between the dots to form a single loop without crossings or branches. The numbers indicate how many lines surround it.
+
+A line forming a single loop without crossings or branches means that every corner has either 2 or 0 lines touching it.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/slitherlink_unsolved.png" alt="Slitherlink unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+from puzzle_solver import slitherlink_solver as solver
+board = np.array([
+    ['3', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', '1', ' '],
+    [' ', ' ', '3', ' ', '3', ' ', ' ', ' ', '3', ' ', '2', '2', ' ', '2', ' ', '2', '2', ' ', '2', '3'],
+    ['2', '2', ' ', ' ', ' ', '2', '1', ' ', '1', '1', ' ', ' ', '3', '1', ' ', '2', ' ', ' ', ' ', '2'],
+    [' ', ' ', '2', ' ', ' ', '2', '2', ' ', ' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', '2', '2', '3', ' '],
+    ['1', '2', '1', ' ', ' ', ' ', '2', '1', ' ', '3', '2', ' ', '3', '2', '2', '3', ' ', '3', '2', '2'],
+    [' ', '3', '2', '2', '1', '2', ' ', '3', ' ', ' ', ' ', ' ', '2', '2', '3', ' ', '1', '1', ' ', '2'],
+    ['1', ' ', ' ', ' ', ' ', ' ', '2', ' ', ' ', '2', ' ', '1', '3', ' ', ' ', ' ', ' ', '2', '2', '2'],
+    [' ', '3', ' ', '2', '0', '1', '2', '1', ' ', '1', '3', ' ', '2', ' ', ' ', '2', ' ', '2', '1', ' '],
+    ['2', ' ', ' ', ' ', '2', ' ', '3', ' ', ' ', ' ', ' ', '2', ' ', ' ', '1', '2', ' ', ' ', '1', '3'],
+    [' ', ' ', '1', ' ', ' ', ' ', ' ', '2', '0', ' ', '1', ' ', '2', ' ', '0', ' ', '2', ' ', '3', '2'],
+    [' ', '3', ' ', '3', ' ', '1', '3', ' ', '3', ' ', '2', ' ', ' ', '2', '2', '2', '3', ' ', ' ', ' '],
+    ['3', ' ', ' ', ' ', ' ', ' ', ' ', '0', '2', '1', ' ', ' ', '2', ' ', ' ', '1', ' ', '0', '2', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', '3', ' ', '3', '2', '3', ' ', ' ', '2', ' ', '1', ' ', ' ', ' ', ' '],
+    ['2', '2', ' ', '3', '0', ' ', ' ', '3', ' ', ' ', '2', ' ', ' ', ' ', ' ', '2', '2', ' ', '3', ' '],
+    [' ', '2', '0', ' ', ' ', '3', ' ', '1', ' ', ' ', '2', ' ', '2', '2', ' ', ' ', ' ', '2', ' ', '2'],
+    [' ', ' ', '1', '3', '1', ' ', ' ', ' ', ' ', ' ', '2', ' ', '2', '1', ' ', '1', '2', '2', ' ', ' '],
+    ['2', ' ', '2', '2', ' ', '1', '3', ' ', '2', ' ', '3', '1', '2', ' ', '3', '2', ' ', '1', '1', ' '],
+    [' ', ' ', '2', ' ', '1', ' ', ' ', ' ', '2', ' ', ' ', ' ', '2', ' ', '1', '0', ' ', ' ', ' ', '3'],
+    [' ', '2', ' ', ' ', '2', ' ', '2', '3', '2', ' ', '2', '2', ' ', '3', '2', '2', '3', '3', '1', ' '],
+    ['0', '0', ' ', '3', '2', ' ', ' ', ' ', ' ', ' ', '2', '1', '2', '1', ' ', ' ', ' ', '2', '1', ' '],
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+**Script Output**
+
+```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│ 3 │ · │ ·   2 │ · │ ·   ·   ·   ·   3 │ ·   · │ ·   · │ · │ 3 │ · │ ·   1   · │
+  │   │   └───┐   │   │   ┌───────┐   ┌───┘   ┌───┘   ┌───┘   │   │   └───┐   ┌───┘
+ 1│ · │ ·   3 │ · │ 3 │ · │ ·   · │ 3 │ ·   2 │ 2   · │ 2   · │ 2 │ 2   · │ 2 │ 3
+  │   │   ┌───┘   └───┘   │       └───┘   ┌───┘   ┌───┘       │   └───────┘   └───┐
+ 2│ 2 │ 2 │ ·   ·   ·   2 │ 1   ·   1   1 │ ·   · │ 3   1   · │ 2   ·   ·   ·   2 │
+  │   │   │   ┌───────────┘   ┌───┐       └───┐   └───────┐   └───────┐   ┌───┐   │
+ 3│ · │ · │ 2 │ ·   ·   2   2 │ · │ ·   ·   3 │ ·   ·   · │ ·   ·   2 │ 2 │ 3 │ · │
+  │   └───┘   └───────────────┘   └───┐   ┌───┘   ┌───┐   │   ┌───┐   │   │   │   │
+ 4│ 1   2   1   ·   ·   ·   2   1   · │ 3 │ 2   · │ 3 │ 2 │ 2 │ 3 │ · │ 3 │ 2 │ 2 │
+  │   ┌───────────────────────────┐   └───┘   ┌───┘   │   │   │   │   └───┘   │   │
+ 5│ · │ 3   2   2   1   2   ·   3 │ ·   ·   · │ ·   2 │ 2 │ 3 │ · │ 1   1   · │ 2 │
+  │   └───────────┐   ┌───────────┘   ┌───────┘   ┌───┘   └───┘   │       ┌───┘   │
+ 6│ 1   ·   ·   · │ · │ ·   2   ·   · │ 2   ·   1 │ 3   ·   ·   · │ ·   2 │ 2   2 │
+  │   ┌───────────┘   └───────────────┘   ┌───┐   └───────────┐   └───────┘   ┌───┘
+ 7│ · │ 3   ·   2   0   1   2   1   ·   1 │ 3 │ ·   2   ·   · │ 2   ·   2   1 │ ·
+  │   └───┐   ┌───┐       ┌───┐   ┌───┐   │   └───────────┐   └───┐   ┌───┐   └───┐
+ 8│ 2   · │ · │ · │ 2   · │ 3 │ · │ · │ · │ ·   2   ·   · │ 1   2 │ · │ · │ 1   3 │
+  └───┐   └───┘   └───┐   │   └───┘   └───┘   ┌───┐   ┌───┘       └───┘   │   ┌───┘
+ 9  · │ ·   1   ·   · │ · │ ·   2   0   ·   1 │ · │ 2 │ ·   0   ·   2   · │ 3 │ 2
+      └───┐   ┌───────┘   │   ┌───┐   ┌───┐   │   │   │       ┌───────┐   └───┘
+10  ·   3 │ · │ 3   ·   1 │ 3 │ · │ 3 │ · │ 2 │ · │ · │ 2   2 │ 2   3 │ ·   ·   ·
+  ┌───────┘   └───────┐   └───┘   └───┘   │   │   │   └───────┘   ┌───┘       ┌───┐
+11│ 3   ·   ·   ·   · │ ·   ·   0   2   1 │ · │ · │ 2   ·   ·   1 │ ·   0   2 │ · │
+  └───┐   ┌───────┐   │   ┌───┐   ┌───┐   │   │   └───┐   ┌───┐   └───┐   ┌───┘   │
+12  · │ · │ ·   · │ · │ · │ 3 │ · │ 3 │ 2 │ 3 │ ·   · │ 2 │ · │ 1   · │ · │ ·   · │
+  ┌───┘   │   ┌───┘   └───┘   │   │   │   └───┘   ┌───┘   │   │   ┌───┘   └───┐   │
+13│ 2   2 │ · │ 3   0   ·   · │ 3 │ · │ ·   2   · │ ·   · │ · │ 2 │ 2   ·   3 │ · │
+  │   ┌───┘   └───┐   ┌───┐   └───┘   └───────────┘   ┌───┘   │   │   ┌───────┘   │
+14│ · │ 2   0   · │ · │ 3 │ ·   1   ·   ·   2   ·   2 │ 2   · │ · │ · │ 2   ·   2 │
+  │   │       ┌───┘   │   │       ┌───────────────────┘       └───┘   │   ┌───────┘
+15│ · │ ·   1 │ 3   1 │ · │ ·   · │ ·   ·   2   ·   2   1   ·   1   2 │ 2 │ ·   ·
+  │   └───┐   └───┐   │   └───┐   │       ┌───────────────────┐   ┌───┘   └───────┐
+16│ 2   · │ 2   2 │ · │ 1   3 │ · │ 2   · │ 3   1   2   ·   3 │ 2 │ ·   1   1   · │
+  └───┐   └───┐   └───┘   ┌───┘   └───┐   └───┐   ┌───────────┘   └───────┐   ┌───┘
+17  · │ ·   2 │ ·   1   · │ ·   ·   2 │ ·   · │ · │ 2   ·   1   0   ·   · │ · │ 3
+      └───┐   └───┐   ┌───┘   ┌───┐   │       │   │   ┌───┐       ┌───┐   │   └───┐
+18  ·   2 │ ·   · │ 2 │ ·   2 │ 3 │ 2 │ ·   2 │ 2 │ · │ 3 │ 2   2 │ 3 │ 3 │ 1   · │
+          └───┐   │   │   ┌───┘   │   └───────┘   └───┘   └───────┘   └───┘       │
+19  0   0   · │ 3 │ 2 │ · │ ·   · │ ·   ·   2   1   2   1   ·   ·   ·   2   1   · │
+              └───┘   └───┘       └───────────────────────────────────────────────┘
+Solutions found: 1
+status: OPTIMAL
+Time taken: 2.39 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/slitherlink_solved.png" alt="Slitherlink solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -3258,3 +3473,5 @@ Issues and PRs welcome!
 [35]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/galaxies "puzzle_solver/src/puzzle_solver/puzzles/galaxies at master · Ar-Kareem/puzzle_solver · GitHub"
 [36]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/slant "puzzle_solver/src/puzzle_solver/puzzles/slant at master · Ar-Kareem/puzzle_solver · GitHub"
 [37]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/unequal "puzzle_solver/src/puzzle_solver/puzzles/unequal at master · Ar-Kareem/puzzle_solver · GitHub"
+[38]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/norinori "puzzle_solver/src/puzzle_solver/puzzles/norinori at master · Ar-Kareem/puzzle_solver · GitHub"
+[39]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/slitherlink "puzzle_solver/src/puzzle_solver/puzzles/slitherlink at master · Ar-Kareem/puzzle_solver · GitHub"

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

@@ -1,4 +1,4 @@
-puzzle_solver/__init__.py,sha256=nqXtO2JuY0r7gNM1HwP_5apXmLX7OeriApzXNaJZjDA,2704
+puzzle_solver/__init__.py,sha256=EuBuJfRIA3IGQExkQ5h4BNYXWHLzdZh3j65ocCMy_64,2855
 puzzle_solver/core/utils.py,sha256=_LA81kHrsgvqPvq7RISBeaurXmYMKAU9N6qmV8n0G7s,8063
 puzzle_solver/core/utils_ortools.py,sha256=2xEL9cMEKmNhRD9lhr2nGdZ3Lbmc9cnHY8xv6iLhUr0,10542
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
@@ -26,17 +26,18 @@ puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy
 puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=LiQVOGkWCsc1WtX8CdPgL_WwAcaeUFuoi5_eqH8U2Og,5876
 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=Z2c0iEn7a6S6gaaJlvNMNNbAQwpztNLB0LTH_XVgu74,12269
+puzzle_solver/puzzles/norinori/norinori.py,sha256=uC8vXAw35xsTmpmTeKqYW7tbcssms9LCcXFBONtV2Ng,4743
 puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5omYLChM,6798
 puzzle_solver/puzzles/range/range.py,sha256=rruvD5ZSaOgvQuX6uGV_Dkr82nSiWZ5kDz03_j7Tt24,4425
 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=jw-Buwzo_eZADL45zD5-Hs8HaT3AU4dZn6eifCUPnhA,11701
 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
-puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=dbd7DoqjR4qkMQAeD_lPpuLB_KCFCIHfDauTbjB3W80,8880
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=1LNJkIqpcz1LvY0H0uRedABQWm44dgNf9XeQuKm36WM,10275
 puzzle_solver/puzzles/sudoku/sudoku.py,sha256=M_pry7XyKKzlfCF5rFi02lyOrj5GWZzXnDAxmD3NXvI,3588
 puzzle_solver/puzzles/tents/tents.py,sha256=iyVK2WXfIT5j_9qqlQg0WmwvixwXlZSsHGK3XA-KpII,6283
 puzzle_solver/puzzles/thermometers/thermometers.py,sha256=nsvJZkm7G8FALT27bpaB0lv5E_AWawqmvapQI8QcYXw,4015
@@ -46,7 +47,7 @@ puzzle_solver/puzzles/undead/undead.py,sha256=IrCUfzQFBem658P5KKqldG7vd2TugTHehc
 puzzle_solver/puzzles/unequal/unequal.py,sha256=ExY2XDCrqROCDpRLfHo8uVr1zuli1QvbCdNCiDhlCac,6978
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.18.dist-info/METADATA,sha256=q9i19rwenN_tEUfhsP8ayNEVfeKcRTm4xK4AmWyzw9M,163560
-multi_puzzle_solver-0.9.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.18.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.18.dist-info/RECORD,,
+multi_puzzle_solver-0.9.20.dist-info/METADATA,sha256=R36gUfx8jHLCnOMt4QEYf-wtBYskwk46IxxPJGMapjI,180363
+multi_puzzle_solver-0.9.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.20.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.20.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -18,12 +18,14 @@ from puzzle_solver.puzzles.map import map as map_solver
 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.lits import lits as lits_solver
 from puzzle_solver.puzzles.pearl import pearl as pearl_solver
 from puzzle_solver.puzzles.range import range as range_solver
 from puzzle_solver.puzzles.signpost import signpost as signpost_solver
 from puzzle_solver.puzzles.singles import singles as singles_solver
 from puzzle_solver.puzzles.slant import slant as slant_solver
+from puzzle_solver.puzzles.slitherlink import slitherlink as slitherlink_solver
 from puzzle_solver.puzzles.star_battle import star_battle as star_battle_solver
 from puzzle_solver.puzzles.star_battle import star_battle_shapeless as star_battle_shapeless_solver
 from puzzle_solver.puzzles.stitches import stitches as stitches_solver
@@ -38,4 +40,4 @@ from puzzle_solver.puzzles.unruly import unruly as unruly_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.18'
+__version__ = '0.9.20'

puzzle_solver/puzzles/norinori/norinori.py

@@ -1,133 +1,32 @@
-import json
-import time
 from dataclasses import dataclass
-from typing import Optional, Union
 
-from ortools.sat.python import cp_model
 import numpy as np
+from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, in_bounds, Direction, get_next_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
-
-
-# a shape on the 2d board is just a set of positions
-Shape = frozenset[Pos]
-
-
-def polyominoes(N):
-    """Generate all polyominoes of size N. Every rotation and reflection is considered different and included in the result.
-    Translation is not considered different and is removed from the result (otherwise the result would be infinite).
-
-    Below is the number of unique polyominoes of size N (not including rotations and reflections) and the lenth of the returned result (which includes all rotations and reflections)
-    N	name		#shapes		#results
-    1	monomino	1			1
-    2	domino		1			2
-    3	tromino		2			6
-    4	tetromino	5			19
-    5	pentomino	12			63
-    6	hexomino	35			216
-    7	heptomino	108			760
-    8	octomino	369			2,725
-    9	nonomino	1,285		9,910
-    10	decomino	4,655		36,446
-    11	undecomino	17,073		135,268
-    12	dodecomino	63,600		505,861
-    Source: https://en.wikipedia.org/wiki/Polyomino
-
-    Args:
-        N (int): The size of the polyominoes to generate.
-
-    Returns:
-        set[(frozenset[Pos], int)]: A set of all polyominoes of size N (rotated and reflected up to D4 symmetry) along with a unique ID for each polyomino.
-    """
-    assert N >= 1, 'N cannot be less than 1'
-    # need a frozenset because regular sets are not hashable
-    shapes: set[Shape] = {frozenset({Pos(0, 0)})}
-    for i in range(1, N):
-        next_shapes: set[Shape] = set()
-        for s in shapes:
-            # frontier: all 4-neighbors of existing cells not already in the shape
-            frontier = {get_next_pos(pos, direction)
-                        for pos in s
-                        for direction in Direction
-                        if get_next_pos(pos, direction) not in s}
-            for cell in frontier:
-                t = s | {cell}
-                # normalize by translation only: shift so min x,y is (0,0). This removes translational symmetries.
-                minx = min(pos.x for pos in t)
-                miny = min(pos.y for pos in t)
-                t0 = frozenset(Pos(x=pos.x - minx, y=pos.y - miny) for pos in t)
-                next_shapes.add(t0)
-        shapes = next_shapes
-    # shapes is now complete, now classify up to D4 symmetry (rotations/reflections), translations ignored
-    mats = (
-        ( 1, 0,  0, 1),  # regular
-        (-1, 0,  0, 1),  # reflect about x
-        ( 1, 0,  0,-1),  # reflect about y
-        (-1, 0,  0,-1),  # reflect about x and y
-        # trnaspose then all 4 above
-        ( 0, 1,  1, 0), ( 0, 1, -1, 0), ( 0,-1,  1, 0), ( 0,-1, -1, 0),
-    )
-    # compute canonical representative for each shape (lexicographically smallest normalized transform)
-    shape_to_canon: dict[Shape, tuple[Pos, ...]] = {}
-    for s in shapes:
-        reps: list[tuple[Pos, ...]] = []
-        for a, b, c, d in mats:
-            pts = {Pos(x=a*p.x + b*p.y, y=c*p.x + d*p.y) for p in s}
-            minx = min(p.x for p in pts)
-            miny = min(p.y for p in pts)
-            rep = tuple(sorted(Pos(x=p.x - minx, y=p.y - miny) for p in pts))
-            reps.append(rep)
-        canon = min(reps)
-        shape_to_canon[s] = canon
-
-    canon_set = set(shape_to_canon.values())
-    canon_to_id = {canon: i for i, canon in enumerate(sorted(canon_set))}
-    result = {(s, canon_to_id[shape_to_canon[s]]) for s in shapes}
-    return result
-
-
-@dataclass(frozen=True)
-class SingleSolution:
-    assignment: dict[Pos, Union[str, int]]
-    all_other_variables: dict
-
-    def get_hashable_solution(self) -> str:
-        result = []
-        for pos, v in self.assignment.items():
-            result.append((pos.x, pos.y, v))
-        return json.dumps(result, sort_keys=True)
-
+from puzzle_solver.core.utils import Pos, Shape, get_all_pos, get_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint
 
 
 @dataclass
 class ShapeOnBoard:
     is_active: cp_model.IntVar
-    shape: Shape
-    shape_id: int
+    orientation: str
     body: set[Pos]
-    disallow_same_shape: set[Pos]
+    disallow: set[Pos]
 
 
 class Board:
-    def __init__(self, board: np.array, polyomino_degrees: int = 4):
+    def __init__(self, board: np.ndarray):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
-        self.V = board.shape[0]
-        self.H = board.shape[1]
-        assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
         self.board = board
-        self.polyomino_degrees = polyomino_degrees
-        self.polyominoes = polyominoes(self.polyomino_degrees)
-
+        self.V, self.H = board.shape
+        assert all((c == ' ') or str(c).isdecimal() for c in np.nditer(board)), "board must contain space or digits"
         self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
-        self.blocks = {i: set() for i in self.block_numbers}
-        for cell in get_all_pos(self.V, self.H):
-            self.blocks[int(get_char(self.board, cell))].add(cell)
+        self.blocks = {i: [pos for pos in get_all_pos(self.V, self.H) if int(get_char(self.board, pos)) == i] for i in self.block_numbers}
 
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
-        self.connected_components: dict[Pos, cp_model.IntVar] = {}
-        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+        self.shapes_on_board: list[ShapeOnBoard] = []
 
         self.create_vars()
         self.init_shapes_on_board()
@@ -136,120 +35,67 @@ class Board:
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
             self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
-        # print('base vars:', len(self.model_vars))
 
     def init_shapes_on_board(self):
-        for idx, (shape, shape_id) in enumerate(self.polyominoes):
-            for translate in get_all_pos(self.V, self.H):  # body of shape is translated to be at pos
-                body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape}
-                if any(not in_bounds(p, self.V, self.H) for p in body):
-                    continue
-                # shape must be fully contained in one block
-                if len(set(get_char(self.board, p) for p in body)) > 1:
-                    continue
-                # 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
-                disallow_same_shape = set(get_next_pos(p, direction) for p in body for direction in Direction)
-                disallow_same_shape -= body
-                self.shapes_on_board.append(ShapeOnBoard(
-                    is_active=self.model.NewBoolVar(f'{idx}:{translate}:is_active'),
-                    shape=shape,
-                    shape_id=shape_id,
-                    body=body,
-                    disallow_same_shape=disallow_same_shape,
-                ))
-        # print('shapes on board:', len(self.shapes_on_board))
+        for pos in get_all_pos(self.V, self.H):
+            shape = self.get_shape(pos, 'horizontal')
+            if shape is not None:
+                self.shapes_on_board.append(shape)
+            shape = self.get_shape(pos, 'vertical')
+            if shape is not None:
+                self.shapes_on_board.append(shape)
 
     def add_all_constraints(self):
-        # RULES:
-        # 1- You have to place one tetromino in each region in such a way that:
-        # 2- 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
-        # 3- The shaded cells should form a single connected area.
-        # 4- 2x2 shaded areas are not allowed
-
-        # each cell must be part of a shape, every shape must be fully on the board. Core constraint, otherwise shapes on the board make no sense.
-        self.only_allow_shapes_on_board()
-
-        self.force_one_shape_per_block()  # Rule #1
-        self.disallow_same_shape_touching()  # Rule #2
-        self.fc = force_connected_component(self.model, self.model_vars)  # Rule #3
-        # print('force connected vars:', len(fc))
-        shape_2_by_2 = frozenset({Pos(0, 0), Pos(0, 1), Pos(1, 0), Pos(1, 1)})
-        self.disallow_shape(shape_2_by_2)  # Rule #4
-
-
-    def only_allow_shapes_on_board(self):
-        for shape_on_board in self.shapes_on_board:
-            # if shape is active then all its body cells must be active
-            self.model.Add(sum(self.model_vars[p] for p in shape_on_board.body) == len(shape_on_board.body)).OnlyEnforceIf(shape_on_board.is_active)
-        # each cell must be part of a shape
-        for p in get_all_pos(self.V, self.H):
-            shapes_on_p = [s for s in self.shapes_on_board if p in s.body]
-            self.model.Add(sum(s.is_active for s in shapes_on_p) == 1).OnlyEnforceIf(self.model_vars[p])
-
-    def force_one_shape_per_block(self):
-        # You have to place exactly one tetromino in each region
-        for block_i in self.block_numbers:
-            shapes_on_block = [s for s in self.shapes_on_board if s.body & self.blocks[block_i]]
-            assert all(s.body.issubset(self.blocks[block_i]) for s in shapes_on_block), 'expected all shapes on block to be fully contained in the block'
-            # print(f'shapes on block {block_i} has {len(shapes_on_block)} shapes')
-            self.model.Add(sum(s.is_active for s in shapes_on_block) == 1)
-
-    def disallow_same_shape_touching(self):
-        # if shape is active then it must not touch any other shape of the same type
-        for shape_on_board in self.shapes_on_board:
-            similar_shapes = [s for s in self.shapes_on_board if s.shape_id == shape_on_board.shape_id]
-            for s in similar_shapes:
-                if shape_on_board.disallow_same_shape & s.body:  # this shape disallows having s be on the board
-                    self.model.Add(s.is_active == 0).OnlyEnforceIf(shape_on_board.is_active)
-
-    def disallow_shape(self, shape_to_disallow: Shape):
-        # for every position in the board, force sum of body < len(body)
-        for translate in get_all_pos(self.V, self.H):
-            cur_body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape_to_disallow}
-            if any(not in_bounds(p, self.V, self.H) for p in cur_body):
-                continue
-            self.model.Add(sum(self.model_vars[p] for p in cur_body) < len(cur_body))
-
-
-
-
-    def solve_and_print(self, verbose: bool = True, max_solutions: Optional[int] = None, verbose_callback: Optional[bool] = None):
-        if verbose_callback is None:
-            verbose_callback = verbose
-        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+        # if a piece is active then all its body is active and the disallow is inactive
+        for shape in self.shapes_on_board:
+            for pos in shape.body:
+                self.model.Add(self.model_vars[pos] == 1).OnlyEnforceIf(shape.is_active)
+            for pos in shape.disallow:
+                self.model.Add(self.model_vars[pos] == 0).OnlyEnforceIf(shape.is_active)
+        # if a spot is active then exactly one piece (with a body there) is active
+        for pos in get_all_pos(self.V, self.H):
+            pieces_on_pos = [shape for shape in self.shapes_on_board if pos in shape.body]
+            # if pos is on then exactly one shape is active. if pos is off then 0 shapes are active.
+            self.model.Add(sum(shape.is_active for shape in pieces_on_pos) == self.model_vars[pos])
+        # every region must have exactly 2 spots active.
+        for block in self.blocks.values():
+            self.model.Add(sum(self.model_vars[pos] for pos in block) == 2)
+
+    def get_shape(self, pos: Pos, orientation: str) -> Shape:
+        assert orientation in ['horizontal', 'vertical'], 'orientation must be horizontal or vertical'
+        if orientation == 'horizontal':
+            body = {pos, get_next_pos(pos, Direction.RIGHT)}
+        else:
+            body = {pos, get_next_pos(pos, Direction.DOWN)}
+        if any(not in_bounds(p, self.V, self.H) for p in body):
+            return None
+        disallow = set(get_next_pos(p, direction) for p in body for direction in Direction)
+        disallow = {p for p in disallow if p not in body and in_bounds(p, self.V, self.H)}
+        shape_on_board = ShapeOnBoard(
+            is_active=self.model.NewBoolVar(f'horizontal:{pos}'),
+            orientation='horizontal',
+            body=body,
+            disallow=disallow,
+        )
+        return shape_on_board
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: "Board", solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, int] = {}
-            for pos, var in board.model_vars.items():
-                assignment[pos] = solver.Value(var)
-            all_other_variables = {
-                'fc': {k: solver.Value(v) for k, v in board.fc.items()}
-            }
-            return SingleSolution(assignment=assignment, all_other_variables=all_other_variables)
+            for pos in get_all_pos(self.V, self.H):
+                if solver.Value(self.model_vars[pos]) == 1:
+                    assignment[pos] = get_char(self.board, pos)
+            return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=str)
-            for pos, val in single_res.assignment.items():
-                c = 'X' if val == 1 else ' '
+            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 = 'X' if pos in single_res.assignment else ' '
                 set_char(res, pos, c)
-            print('[\n' + '\n'.join(['  ' + str(res[row].tolist()) + ',' for row in range(self.V)]) + '\n]')
-            pass
-        return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)
-
-    def solve_then_constrain(self, verbose: bool = True):
-        tic = time.time()
-        all_solutions = []
-        while True:
-            solutions = self.solve_and_print(verbose=False, verbose_callback=verbose, max_solutions=1)
-            if len(solutions) == 0:
-                break
-            all_solutions.extend(solutions)
-            assignment = solutions[0].assignment
-            # constrain the board to not return the same solution again
-            lits = [self.model_vars[p].Not() if assignment[p] == 1 else self.model_vars[p] for p in assignment.keys()]
-            self.model.AddBoolOr(lits)
-            self.model.ClearHints()
-            for k, v in solutions[0].all_other_variables['fc'].items():
-                self.model.AddHint(self.fc[k], v)
-        print(f'Solutions found: {len(all_solutions)}')
-        toc = time.time()
-        print(f'Time taken: {toc - tic:.2f} seconds')
-        return all_solutions
+            print('[')
+            for row in res:
+                print("    [ '" + "', '".join(row.tolist()) + "' ],")
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -0,0 +1,248 @@
+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
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+
+
+CellBorder = tuple[Pos, Direction]
+Corner = 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() for c in np.nditer(board)), 'board must contain only spaces or digits'
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.board = board
+        self.cell_borders_to_corners: dict[CellBorder, set[Corner]] = defaultdict(set)  # for every cell border, a set of all corners it is connected to
+        self.corners_to_cell_borders: dict[Corner, set[CellBorder]] = defaultdict(set)  # opposite direction
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[CellBorder, cp_model.IntVar] = {}  # one entry for every unique variable in the model
+        self.cell_borders: dict[CellBorder, cp_model.IntVar] = {}  # for every position and direction, one entry for that edge (thus the same edge variables are used in opposite directions of neighboring cells)
+        self.corner_vars: dict[Corner, set[cp_model.IntVar]] = defaultdict(set)  # for every corner, one entry for each edge that touches the corner (i.e. 4 per corner unless on the border)
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in [Direction.RIGHT, Direction.DOWN]:
+                self.add_var(pos, direction)
+        for pos in get_row_pos(0, self.H):
+            self.add_var(pos, Direction.UP)
+        for pos in get_col_pos(0, self.V):
+            self.add_var(pos, Direction.LEFT)
+
+    def add_var(self, pos: Pos, direction: Direction):
+        cell_border = (pos, direction)
+        v = self.model.NewBoolVar(f'main:{cell_border}')
+        self.model_vars[cell_border] = v
+        self.add_cell_border_var(cell_border, v)
+        self.add_corner_vars(cell_border, v)
+
+    def add_cell_border_var(self, cell_border: CellBorder, var: cp_model.IntVar):
+        """An edge belongs to two cells unless its on the border in which case it only belongs to one."""
+        pos, direction = cell_border
+        self.cell_borders[cell_border] = var
+        next_pos = get_next_pos(pos, direction)
+        if in_bounds(next_pos, self.V, self.H):
+            self.cell_borders[(next_pos, get_opposite_direction(direction))] = var
+    
+    def add_corner_vars(self, cell_border: CellBorder, var: cp_model.IntVar):
+        """
+        An edge always belongs to two corners. Note that the cell xi,yi has the 4 corners (xi,yi), (xi+1,yi), (xi,yi+1), (xi+1,yi+1). (memorize these 4 coordinates or the function wont make sense)
+        Thus corner index is +1 of board coordinates.
+        Never check for bounds here because an edge ALWAYS touches two corners AND because the +1 will make in_bounds return False when its still in bounds.
+        """
+        pos, direction = cell_border
+        if direction == Direction.LEFT:  # it touches me and (xi,yi+1)
+            corner1 = pos
+            corner2 = get_next_pos(pos, Direction.DOWN)
+        elif direction == Direction.UP:  # it touches me and (xi+1,yi)
+            corner1 = pos
+            corner2 = get_next_pos(pos, Direction.RIGHT)
+        elif direction == Direction.RIGHT:  # it touches (xi+1,yi) and (xi+1,yi+1)
+            corner1 = get_next_pos(pos, Direction.RIGHT)
+            corner2 = get_next_pos(corner1, Direction.DOWN)
+        elif direction == Direction.DOWN:  # it touches (xi,yi+1) and (xi+1,yi+1)
+            corner1 = get_next_pos(pos, Direction.DOWN)
+            corner2 = get_next_pos(corner1, Direction.RIGHT)
+        else:
+            raise ValueError(f'Invalid direction: {direction}')
+        self.corner_vars[corner1].add(var)
+        self.corner_vars[corner2].add(var)
+        self.cell_borders_to_corners[cell_border].add(corner1)
+        self.cell_borders_to_corners[cell_border].add(corner2)
+        self.corners_to_cell_borders[corner1].add(cell_border)
+        self.corners_to_cell_borders[corner2].add(cell_border)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # enforce cells with numbers
+            variables = [self.cell_borders[(pos, direction)] for direction in Direction if (pos, direction) in self.cell_borders]
+            val = get_char(self.board, pos)
+            if not val.isdecimal():
+                continue
+            self.model.Add(sum(variables) == int(val))
+        for corner in self.corner_vars:  # a corder always has 0 or 2 active edges
+            g = self.model.NewBoolVar(f'corner_gate_{corner}')
+            self.model.Add(sum(self.corner_vars[corner]) == 0).OnlyEnforceIf(g.Not())
+            self.model.Add(sum(self.corner_vars[corner]) == 2).OnlyEnforceIf(g)
+        # single connected component
+        def is_neighbor(cb1: CellBorder, cb2: CellBorder) -> bool:
+            cb1_corners = self.cell_borders_to_corners[cb1]
+            cb2_corners = self.cell_borders_to_corners[cb2]
+            return len(cb1_corners & cb2_corners) > 0
+        force_connected_component(self.model, self.model_vars, is_neighbor=is_neighbor)
+
+
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for (pos, direction), var in board.model_vars.items():
+                if solver.value(var) == 1:
+                    if pos not in assignment:
+                        assignment[pos] = ''
+                    assignment[pos] += direction.name[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if pos not in single_res.assignment:
+                    continue
+                c = ''.join(sorted(single_res.assignment[pos]))
+                set_char(res, pos, c)
+            print(render_grid(cell_flags=res, center_char=lambda c, r: self.board[r, c] if self.board[r, c] != ' ' else '·'))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=999)
+
+
+
+
+
+def render_grid(cell_flags: np.ndarray = None,
+                H: np.ndarray = None,
+                V: np.ndarray = None,
+                mark_centers: bool = True,
+                center_char: str = '·',
+                show_axes: bool = True,
+                scale_x: int = 2) -> str:
+    """
+    AI generated this because I don't currently care about the details of rendering to the terminal and I did it in a quick and dirty way while the AI made it in a pretty way, and this looks good during my development.
+        cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
+    OR:
+        H: (N+1, N) horizontal edges between corners
+        V: (N,   N+1) vertical edges between corners
+    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
+    """
+    if cell_flags is not None:
+        N = cell_flags.shape[0]
+        H = np.zeros((N+1, N), dtype=bool)
+        V = np.zeros((N, N+1), dtype=bool)
+        for r in range(N):
+            for c in range(N):
+                s = cell_flags[r, c]
+                if 'U' in s: H[r, c]   = True          # edge between (r,c) and (r, c+1) above the cell
+                if 'D' in s: H[r+1, c] = True          # edge below the cell
+                if 'L' in s: V[r, c]   = True          # edge left of the cell
+                if 'R' in s: V[r, c+1] = True          # edge right of the cell
+    assert H is not None and V is not None, 'H and V must be provided'
+    # Bitmask for corner connections
+    U, R, D, L = 1, 2, 4, 8
+    JUNCTION = {
+        0: ' ',
+        U: '│', D: '│', U|D: '│',
+        L: '─', R: '─', L|R: '─',
+        U|R: '└', R|D: '┌', D|L: '┐', L|U: '┘',
+        U|D|L: '┤', U|D|R: '├', L|R|U: '┴', L|R|D: '┬',
+        U|R|D|L: '┼',
+    }
+
+    assert scale_x >= 1
+    N = V.shape[0]
+    assert H.shape == (N+1, N) and V.shape == (N, N+1)
+
+    rows = 2*N + 1
+    cols = 2*N*scale_x + 1                 # stretched width
+    canvas = [[' ']*cols for _ in range(rows)]
+
+    def x_corner(c):     # x of corner column c
+        return (2*c) * scale_x
+    def x_between(c,k):  # kth in-between column (1..scale_x) between c and c+1 corners
+        return (2*c) * scale_x + k
+
+    # horizontal edges: fill the stretched band between corners with '─'
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N):
+            if H[r, c]:
+                # previously: for k in range(1, scale_x*2, 2):
+                for k in range(1, scale_x*2):          # 1..(2*scale_x-1), no gaps
+                    canvas[rr][x_between(c, k)] = '─'
+
+    # vertical edges: draw at the corner columns (no horizontal stretching needed)
+    for r in range(N):
+        rr = 2*r + 1
+        for c in range(N+1):
+            if V[r, c]:
+                canvas[rr][x_corner(c)] = '│'
+
+    # junctions at corners
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N+1):
+            m = 0
+            if r > 0   and V[r-1, c]: m |= U
+            if c < N   and H[r, c]:   m |= R
+            if r < N   and V[r, c]:   m |= D
+            if c > 0   and H[r, c-1]: m |= L
+            canvas[rr][x_corner(c)] = JUNCTION[m]
+
+    # centers (help count exact widths/heights)
+    if mark_centers:
+        for r in range(N):
+            rr = 2*r + 1
+            for c in range(N):
+                # center lies midway across the stretched span
+                xc = x_corner(c) + scale_x          # middle-ish; works for any integer scale_x
+                canvas[rr][xc] = center_char if isinstance(center_char, str) else center_char(c, r)
+
+    # turn canvas rows into strings
+    art_rows = [''.join(row) for row in canvas]
+
+    if not show_axes:
+        return '\n'.join(art_rows)
+
+    # ── Axes ────────────────────────────────────────────────────────────────
+    gut = max(2, len(str(N-1)))       # left gutter width
+    gutter = ' ' * gut
+    top_tens = list(gutter + ' ' * cols)
+    top_ones = list(gutter + ' ' * cols)
+
+    for c in range(N):
+        xc_center = x_corner(c) + scale_x
+        if N >= 10:
+            top_tens[gut + xc_center] = str((c // 10) % 10)
+        top_ones[gut + xc_center] = str(c % 10)
+
+    # tiny corner labels
+    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)
+
+

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -3,6 +3,7 @@
     Look at the ./input_output/ directory for examples of input images and output json files.
     The output json is used in the test_solve.py file to test the solver.
 """
+# import json
 from pathlib import Path
 import numpy as np
 cv = None
@@ -72,6 +73,8 @@ def mean_consecutives(arr: np.ndarray) -> np.ndarray:
     return np.array(sums) // np.array(counts)
 
 def dfs(x, y, out, output, current_num):
+    # if current_num == '48':
+    #     print('dfs', x, y, current_num)
     if x < 0 or x >= out.shape[1] or y < 0 or y >= out.shape[0]:
         return
     if out[y, x] != '  ':
@@ -136,6 +139,8 @@ def main(image):
             cell = src[hidx1:hidx2, vidx1:vidx2]
             mid_x = cell.shape[1] // 2
             mid_y = cell.shape[0] // 2
+            # if j > height - 4 and i > width - 6:
+            #     show_wait_destroy(f"cell_{i}_{j}", cell)
             # show_wait_destroy(f"cell_{i}_{j}", cell)
             cell = cv.bitwise_not(cell)  # invert colors
             top = cell[0:10, mid_y-5:mid_y+5]
@@ -156,10 +161,18 @@ def main(image):
     axs[1, 0].set_title('Right')
     axs[1, 1].hist(list(hists['bottom'].values()), bins=100)
     axs[1, 1].set_title('Bottom')
+    global_target = None
+    # global_target = 28_000
     target_top = np.mean(list(hists['top'].values()))
     target_left = np.mean(list(hists['left'].values()))
     target_right = np.mean(list(hists['right'].values()))
     target_bottom = np.mean(list(hists['bottom'].values()))
+    if global_target is not None:
+        target_top = global_target
+        target_left = global_target
+        target_right = global_target
+        target_bottom = global_target
+
     axs[0, 0].axvline(target_top, color='red')
     axs[0, 1].axvline(target_left, color='red')
     axs[1, 0].axvline(target_right, color='red')
@@ -185,12 +198,18 @@ def main(image):
             print('   Sums: ', hists['top'][j, i], hists['left'][j, i], hists['right'][j, i], hists['bottom'][j, i])
 
     current_count = 0
-    out = np.full_like(output['top'], '  ', dtype='U2')
+    z_fill = 2
+    out = np.full_like(output['top'], '  ', dtype='U32')
     for j in range(out.shape[0]):
+        if current_count > 99:
+            z_fill = 3
         for i in range(out.shape[1]):
             if out[j, i] == '  ':
-                dfs(i, j, out, output, str(current_count).zfill(2))
+                if current_count == 48:
+                    print(f"current_count: {current_count}, x: {i}, y: {j}")
+                dfs(i, j, out, output, str(current_count).zfill(z_fill))
                 current_count += 1
+    print(out)
 
     with open(output_path, 'w') as f:
         f.write('[\n')
@@ -202,6 +221,18 @@ def main(image):
         f.write(']')
     print('output json: ', output_path)
 
+    # with open(output_path.parent / 'debug.json', 'w') as f:
+    #     debug_pos = {}
+    #     for j in range(out.shape[0]):
+    #         for i in range(out.shape[1]):
+    #             out_str = ''
+    #             out_str += 'T' if output['top'][j, i] else ''
+    #             out_str += 'L' if output['left'][j, i] else ''
+    #             out_str += 'R' if output['right'][j, i] else ''
+    #             out_str += 'B' if output['bottom'][j, i] else ''
+    #             debug_pos[f'{j}_{i}'] = out_str
+    #     json.dump(debug_pos, f, indent=2)
+
 if __name__ == '__main__':
     # to run this script and visualize the output, in the root run:
     #  python .\src\puzzle_solver\puzzles\stitches\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
@@ -209,4 +240,6 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'weekly_oct_3rd_2025.png')
     # main(Path(__file__).parent / 'input_output' / 'star_battle_67f73ff90cd8cdb4b3e30f56f5261f4968f5dac940bc6.png')
     # main(Path(__file__).parent / 'input_output' / 'LITS_MDoxNzksNzY3.png')
-    main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
+    # main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
+    # main(Path(__file__).parent / 'input_output' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.png')
+    main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')