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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.14
+Version: 0.9.18
 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
@@ -39,22 +39,35 @@ pip install multi-puzzle-solver
 Use:
 
 ```python
-from puzzle_solver import nonograms_solver
-solver = nonograms_solver.Board(top=[[2], [3], [1], [1, 1]], side=[[3], [1], [2, 1], [1]])
-solutions = solver.solve_and_print()
+from puzzle_solver import nonograms_solver as solver
+top_numbers = [[8, 2], [5, 4], [2, 1, 4], [2, 4], [2, 1, 4], [2, 5], [2, 8], [3, 2], [1, 6], [1, 9], [1, 6, 1], [1, 5, 3], [3, 2, 1], [4, 2], [1, 5]]
+side_numbers = [[7, 3], [7, 1, 1], [2, 3], [2, 3], [3, 2], [1, 1, 1, 1, 2], [1, 6, 1], [1, 9], [9], [2, 4], [8], [11], [7, 1, 1], [4, 3], [3, 2]]
+binst = solver.Board(top=top_numbers, side=side_numbers)
+solutions = binst.solve_and_print()
 ```
 
 Output:
 
 ```python
 Solution found
-[[' ' 'B' 'B' 'B']
- [' ' 'B' ' ' ' ']
- ['B' 'B' ' ' 'B']
- ['B' ' ' ' ' ' ']]
+[['B' 'B' 'B' 'B' 'B' 'B' 'B' ' ' 'B' 'B' 'B' ' ' ' ' ' ' ' ']
+ ['B' 'B' 'B' 'B' 'B' 'B' 'B' ' ' ' ' ' ' ' ' ' ' 'B' ' ' 'B']
+ ['B' 'B' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'B' 'B' 'B' ' ']
+ ['B' 'B' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'B' 'B' 'B']
+ ['B' 'B' 'B' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'B' 'B']
+ ['B' ' ' ' ' ' ' 'B' ' ' 'B' ' ' ' ' 'B' ' ' ' ' ' ' 'B' 'B']
+ ['B' ' ' ' ' ' ' ' ' ' ' 'B' 'B' 'B' 'B' 'B' 'B' ' ' ' ' 'B']
+ ['B' ' ' ' ' ' ' ' ' ' ' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B']
+ [' ' ' ' ' ' ' ' ' ' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' ' ']
+ [' ' ' ' ' ' ' ' ' ' 'B' 'B' ' ' 'B' 'B' 'B' 'B' ' ' ' ' ' ']
+ [' ' ' ' ' ' ' ' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' ' ' ' ' ' ']
+ ['B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' 'B' ' ' ' ' ' ' ' ']
+ ['B' 'B' 'B' 'B' 'B' 'B' 'B' ' ' ' ' 'B' ' ' 'B' ' ' ' ' ' ']
+ [' ' 'B' 'B' 'B' 'B' ' ' ' ' ' ' ' ' 'B' 'B' 'B' ' ' ' ' ' ']
+ [' ' 'B' 'B' 'B' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'B' 'B' ' ' ' ']]
 Solutions found: 1
 status: OPTIMAL
-Time taken: 0.00 seconds
+Time taken: 0.04 seconds
 ```
 (Note: Printing can be turned off by setting `verbose=False`)
 
@@ -269,6 +282,23 @@ 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/black_box_solved.png" alt="Black Box" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#galaxies-puzzle-type-35"><b>Galaxies</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/galaxies_solved.png" alt="Galaxies" width="140">
+    </a>
+  </td>
+</tr>
+<tr>
+  <td align="center">
+    <a href="#slant-puzzle-type-36"><b>Slant</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/slant_solved.png" alt="Slant" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#unequal-puzzle-type-37"><b>Unequal</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/unequal_solved.png" alt="Unequal" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -318,6 +348,9 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Star Battle Shapeless (Puzzle Type #32)](#star-battle-shapeless-puzzle-type-32)
   - [Lits (Puzzle Type #33)](#lits-puzzle-type-33)
   - [Black Box (Puzzle Type #34)](#black-box-puzzle-type-34)
+  - [Galaxies (Puzzle Type #35)](#galaxies-puzzle-type-35)
+  - [Slant (Puzzle Type #36)](#slant-puzzle-type-36)
+  - [Unequal (Puzzle Type #37)](#unequal-puzzle-type-37)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -1772,8 +1805,8 @@ Thus the solver was developed with the additional much harder goal of collecting
 It does so using the following high level steps:
 
 1. Model the board as a directed graph where the cells are nodes and legal moves as directed edges with unit cost. Each gem has to a group of edges where traversing any one of them collects that gem.
-2. Model step (1) as a [Generalized Traveling Salesman Problem (GTSP)](https://en.wikipedia.org/wiki/Set_TSP_problem), where each gem’s edge group forms a cluster.
-3. Apply the [Noon–Bean transformation](https://deepblue.lib.umich.edu/bitstream/handle/2027.42/6834/ban3102.0001.001.pdf?sequence=5) **(Noon & Bean, 1991)** to convert the GTSP from step (2) into an equivalent Asymmetric TSP (ATSP) that can be solved with OR-Tools’ routing solver. (Noon-Bean transformation is mentioned but not described in the [TSP wikipedia page](https://en.wikipedia.org/wiki/Travelling_salesman_problem).)
+2. Model step (1) as a [Generalized Traveling Salesman Problem (GTSP)](https://en.wikipedia.org/wiki/Set_TSP_problem), where each gem's edge group forms a cluster.
+3. Apply the [Noon–Bean transformation](https://deepblue.lib.umich.edu/bitstream/handle/2027.42/6834/ban3102.0001.001.pdf?sequence=5) **(Noon & Bean, 1991)** to convert the GTSP from step (2) into an equivalent Asymmetric TSP (ATSP) that can be solved with OR-Tools' routing solver. (Noon-Bean transformation is mentioned but not described in the [TSP wikipedia page](https://en.wikipedia.org/wiki/Travelling_salesman_problem).)
 4. Use a [Vehicle Routing Problem (VRP)](https://en.wikipedia.org/wiki/Vehicle_routing_problem) solver using the [OR-Tools VRP solver](https://developers.google.com/optimization/routing/routing_tasks) to solve the ATSP.
 
 This achieves a final sequence of moves that is empirically always faster than the website's solution.
@@ -2892,6 +2925,251 @@ Time taken: 30.33 seconds
 
 ---
 
+## Galaxies (Puzzle Type #35)
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/galaxies.html#galaxies)
+
+* [**Solver Code**][35]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You have a rectangular grid containing a number of dots. Your aim is to partition the rectangle into connected regions of squares, in such a way that every region is 180° rotationally symmetric, and contains exactly one dot which is located at its centre of symmetry.
+
+To enter your solution, you draw lines along the grid edges to mark the boundaries of the regions. The puzzle is complete when the marked lines on the grid are precisely those that separate two squares belonging to different regions.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/galaxies_unsolved.png" alt="Galaxies unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+Note: The number are arbitrary and simply number each galaxy as an integer.
+
+```python
+from puzzle_solver import galaxies_solver as solver
+galaxies = np.array([
+    ['  ', '  ', '00', '  ', '  ', '01', '01', '02', '02', '03', '03', '  ', '04', '04', '  '],
+    ['05', '05', '  ', '  ', '06', '01', '01', '02', '02', '  ', '  ', '  ', '07', '  ', '  '],
+    ['08', '  ', '  ', '  ', '06', '  ', '09', '09', '  ', '  ', '10', '  ', '  ', '  ', '  '],
+    ['  ', '  ', '  ', '  ', '  ', '  ', '11', '11', '12', '  ', '  ', '  ', '  ', '13', '13'],
+    ['14', '  ', '  ', '  ', '15', '  ', '11', '11', '  ', '  ', '  ', '  ', '16', '  ', '  '],
+    ['  ', '17', '  ', '  ', '15', '  ', '  ', '  ', '  ', '  ', '  ', '  ', '16', '  ', '18'],
+    ['  ', '17', '19', '  ', '  ', '  ', '  ', '  ', '  ', '20', '  ', '  ', '  ', '21', '18'],
+    ['  ', '22', '  ', '  ', '23', '  ', '  ', '  ', '  ', '20', '  ', '24', '24', '21', '25'],
+    ['26', '27', '27', '28', '28', '29', '  ', '  ', '  ', '  ', '  ', '  ', '  ', '30', '30'],
+    ['  ', '27', '27', '28', '28', '31', '31', '  ', '  ', '  ', '  ', '32', '  ', '30', '30'],
+    ['  ', '  ', '  ', '33', '33', '31', '31', '34', '  ', '  ', '35', '  ', '  ', '  ', '  '],
+    ['36', '  ', '  ', '33', '33', '  ', '  ', '34', '  ', '  ', '  ', '  ', '  ', '37', '  '],
+    ['  ', '  ', '38', '38', '  ', '39', '  ', '40', '40', '41', '41', '42', '  ', '37', '  '],
+    ['43', '44', '38', '38', '45', '45', '46', '40', '40', '41', '41', '42', '  ', '  ', '  '],
+    ['43', '  ', '  ', '  ', '  ', '  ', '  ', '47', '  ', '  ', '  ', '  ', '48', '48', '  ']
+])
+binst = solver.Board(galaxies=galaxies)
+solutions = binst.solve_and_print()
+```
+**Script Output**
+
+As the instructions say, the solution to this puzzle is not garunteed to be unique.
+
+```python
+Solution found
+[
+    ['00', '00', '00', '00', '00', '01', '01', '02', '02', '03', '03', '04', '04', '04', '04'],
+    ['05', '05', '15', '06', '06', '01', '01', '02', '02', '10', '10', '07', '07', '07', '13'],
+    ['08', '15', '15', '15', '06', '06', '09', '09', '10', '10', '10', '10', '10', '13', '13'],
+    ['14', '15', '15', '15', '15', '15', '11', '11', '12', '20', '10', '10', '16', '13', '13'],
+    ['14', '15', '15', '15', '15', '15', '11', '11', '20', '20', '20', '20', '16', '13', '13'],
+    ['14', '17', '17', '15', '15', '15', '15', '15', '20', '20', '20', '20', '16', '13', '18'],
+    ['17', '17', '19', '15', '15', '15', '15', '15', '20', '20', '20', '24', '16', '21', '18'],
+    ['26', '22', '27', '27', '23', '15', '15', '15', '20', '20', '20', '24', '24', '21', '25'],
+    ['26', '27', '27', '28', '28', '29', '15', '20', '20', '20', '20', '32', '24', '30', '30'],
+    ['26', '27', '27', '28', '28', '31', '31', '20', '20', '20', '20', '32', '37', '30', '30'],
+    ['27', '27', '33', '33', '33', '31', '31', '34', '34', '20', '35', '32', '37', '37', '37'],
+    ['36', '38', '38', '33', '33', '33', '34', '34', '41', '41', '41', '41', '37', '37', '37'],
+    ['44', '44', '38', '38', '45', '39', '46', '40', '40', '41', '41', '42', '37', '37', '37'],
+    ['43', '44', '38', '38', '45', '45', '46', '40', '40', '41', '41', '42', '37', '37', '37'],
+    ['43', '44', '44', '38', '38', '45', '46', '47', '41', '41', '41', '41', '48', '48', '37'],
+]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.07 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/galaxies_solved.png" alt="Galaxies solved" width="500">
+
+---
+
+## Slant (Puzzle Type #36)
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/slant.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/slant.html#slant)
+
+* [**Solver Code**][36]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You have a grid of squares. Your aim is to draw a diagonal line through each square, and choose which way each line slants so that the following conditions are met:
+
+   - The diagonal lines never form a loop.
+   - Any point with a circled number has precisely that many lines meeting at it. (Thus, a 4 is the centre of a cross shape, whereas a zero is the centre of a diamond shape – or rather, a partial diamond shape, because a zero can never appear in the middle of the grid because that would immediately cause a loop.)
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/slant_unsolved.png" alt="Slant unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+Note: For an NxM board you need an (N+1)x(M+1) array because the puzzle is to solve for the cells while the input is the values at the corners (there's always one more corner than cells in each dimension).
+
+```python
+from puzzle_solver import slant_solver as solver
+board = np.array([
+    [' ', ' ', '1', ' ', '1', ' ', '1', ' ', '1', ' ', ' ', ' ', ' '],
+    [' ', '1', '2', ' ', ' ', '2', ' ', '2', ' ', '2', ' ', '1', '1'],
+    [' ', '2', '2', ' ', '2', '3', '2', ' ', '3', ' ', ' ', '1', ' '],
+    ['1', '1', ' ', '3', '1', '2', ' ', '1', ' ', ' ', '3', ' ', ' '],
+    [' ', ' ', '1', '1', ' ', ' ', ' ', '1', '1', '3', ' ', '3', ' '],
+    ['1', '2', ' ', '2', '2', ' ', '2', ' ', ' ', '1', '2', ' ', ' '],
+    [' ', '2', '2', '2', ' ', ' ', '2', '3', '2', ' ', ' ', ' ', ' '],
+    [' ', '1', '2', ' ', ' ', '2', ' ', '2', ' ', ' ', ' ', '1', ' '],
+    [' ', ' ', ' ', '3', '2', '2', ' ', '3', '1', ' ', ' ', ' ', '1'],
+    [' ', '2', '1', '1', '2', ' ', '1', ' ', '1', ' ', '1', '1', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', ' '],
+])
+binst = solver.Board(numbers=board)
+solutions = binst.solve_and_print()
+```
+**Script Output**
+
+```python
+Solution found
+[
+    [ / \ \ / / / / \ \ \ / \ ]
+    [ \ \ \ \ \ \ / \ / / \ \ ]
+    [ \ \ \ / / \ / \ \ \ \ / ]
+    [ \ / \ \ / \ / / \ / \ / ]
+    [ / \ \ / \ \ \ / / / \ \ ]
+    [ / \ \ / \ \ \ / \ / \ \ ]
+    [ / \ \ / \ / / / \ / / \ ]
+    [ \ \ \ \ \ / / / \ / \ \ ]
+    [ / / / \ \ / / \ \ / \ \ ]
+    [ \ \ / / / \ / \ / \ \ / ]
+]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.06 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/slant_solved.png" alt="Slant solved" width="500">
+
+---
+
+## Unequal (Puzzle Type #37)
+
+* [**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)
+
+* [**Solver Code**][37]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+ You have a square grid; each square may contain a digit from 1 to the size of the grid, and some squares have clue signs between them. Your aim is to fully populate the grid with numbers such that:
+
+  - Each row contains only one occurrence of each digit
+  - Each column contains only one occurrence of each digit
+  - All the clue signs are satisfied.
+
+There are two modes for this game, 'Unequal' and 'Adjacent'.
+
+In 'Unequal' mode, the clue signs are greater-than symbols indicating one square's value is greater than its neighbour's. In this mode not all clues may be visible, particularly at higher difficulty levels.
+
+In 'Adjacent' mode, the clue signs are bars indicating one square's value is numerically adjacent (i.e. one higher or one lower) than its neighbour. In this mode all clues are always visible: absence of a bar thus means that a square's value is definitely not numerically adjacent to that neighbour's.
+
+In 'Trivial' difficulty level (available via the 'Custom' game type selector), there are no greater-than signs in 'Unequal' mode; the puzzle is to solve the Latin square only. 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/unequal_unsolved.png" alt="Unequal unsolved" width="500">
+
+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
+board = np.array([
+    [' ', ' ', ' ', ' ', '9', ' ', '1', ' ', '7', '>', ' ', '>', ' ', ' ', ' ', ' ', ' ', '>', ' '],
+    [' ', 'X', 'V', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', '∧', 'X', ' ', 'X', ' ', 'X', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', '6', ' ', ' ', ' ', '9', ' ', ' ', ' ', '5', ' ', '3', ' ', ' '],
+    [' ', 'X', ' ', 'X', '∧', 'X', ' ', 'X', '∧', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' '],
+    [' ', ' ', ' ', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '6', ' ', '9', ' ', ' ', ' ', ' '],
+    [' ', 'X', ' ', 'X', 'V', 'X', 'V', 'X', 'V', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', 'V'],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '<', ' ', '<', ' ', '>', ' ', ' ', ' ', ' ', ' '],
+    [' ', 'X', ' ', 'X', '∧', 'X', 'V', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' '],
+    [' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '<', ' ', ' ', ' '],
+    [' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', '∧', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' '],
+    [' ', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '5', ' ', ' ', '>', ' ', '<', ' ', ' ', '4'],
+    ['V', 'X', '∧', 'X', 'V', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', 'V', 'X', ' ', 'X', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', ' ', ' ', ' ', ' ', ' '],
+    [' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', '∧', 'X', ' ', 'X', ' ', 'X', 'V'],
+    [' ', ' ', ' ', '<', ' ', ' ', ' ', '<', ' ', ' ', ' ', '<', ' ', '<', ' ', ' ', ' ', '<', ' '],
+    [' ', 'X', ' ', 'X', ' ', 'X', 'V', 'X', ' ', 'X', 'V', 'X', '∧', 'X', ' ', 'X', ' ', 'X', ' '],
+    [' ', ' ', ' ', ' ', ' ', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', ' ', ' ', '9', ' ', ' '],
+    ['V', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', 'V'],
+    [' ', '>', ' ', ' ', ' ', '>', ' ', ' ', ' ', ' ', '4', '<', ' ', '<', ' ', '<', '7', ' ', '2'],
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+**Script Output**
+
+```python
+Solution found
+[
+    [ 6 5 9 1 7 2 0 8 4 3 ]
+    [ 7 1 0 6 4 9 2 5 3 8 ]
+    [ 3 4 2 8 5 0 6 9 1 7 ]
+    [ 5 9 1 7 3 6 8 4 2 0 ]
+    [ 8 3 5 4 0 7 1 2 6 9 ]
+    [ 2 6 7 0 1 5 9 3 8 4 ]
+    [ 0 7 4 9 2 8 3 1 5 6 ]
+    [ 9 2 6 5 8 3 4 7 0 1 ]
+    [ 4 8 3 2 6 1 7 0 9 5 ]
+    [ 1 0 8 3 9 4 5 6 7 2 ]
+]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.05 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/unequal_solved.png" alt="Unequal solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -2977,3 +3255,6 @@ Issues and PRs welcome!
 [32]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/star_battle_shapeless "puzzle_solver/src/puzzle_solver/puzzles/star_battle_shapeless at master · Ar-Kareem/puzzle_solver · GitHub"
 [33]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/lits "puzzle_solver/src/puzzle_solver/puzzles/lits at master · Ar-Kareem/puzzle_solver · GitHub"
 [34]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/black_box "puzzle_solver/src/puzzle_solver/puzzles/black_box at master · Ar-Kareem/puzzle_solver · GitHub"
+[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"

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

@@ -1,6 +1,6 @@
-puzzle_solver/__init__.py,sha256=-7Mdi0aljanRFso8IlRMDx_TxX1x8joDABRaBpC69fc,2503
+puzzle_solver/__init__.py,sha256=nqXtO2JuY0r7gNM1HwP_5apXmLX7OeriApzXNaJZjDA,2704
 puzzle_solver/core/utils.py,sha256=_LA81kHrsgvqPvq7RISBeaurXmYMKAU9N6qmV8n0G7s,8063
-puzzle_solver/core/utils_ortools.py,sha256=USUl23e6AyE_FGTIN1oYkmMJOuwmKXNges9K2G4ccNM,10360
+puzzle_solver/core/utils_ortools.py,sha256=2xEL9cMEKmNhRD9lhr2nGdZ3Lbmc9cnHY8xv6iLhUr0,10542
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
 puzzle_solver/puzzles/battleships/battleships.py,sha256=RuYCrs4j0vUjlU139NRYYP-uNPAgO0V7hAzbsHrRwD8,7446
 puzzle_solver/puzzles/black_box/black_box.py,sha256=ZnHDVt6PFS_r1kMNSsbz9hav1hxIrNDUvPyERGPjLjM,15635
@@ -11,6 +11,8 @@ 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/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
 puzzle_solver/puzzles/inertia/inertia.py,sha256=gJBahkh69CrSWNscalKEoP1j4X-Q3XpbIBMiG9PUpU0,5657
 puzzle_solver/puzzles/inertia/tsp.py,sha256=gobiISHtARA4Elq0jr90p6Yhq11ULjGoqsS-rLFhYcc,15389
@@ -29,19 +31,22 @@ puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5
 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/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=VWHT-iYDaFsd37h9DE07EkeZ_dJMEfatXSByqC2vh04,8916
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=dbd7DoqjR4qkMQAeD_lPpuLB_KCFCIHfDauTbjB3W80,8880
 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
 puzzle_solver/puzzles/towers/towers.py,sha256=QvL0Pp-Z2ewCeq9ZkNrh8MShKOh-Y52sFBSudve68wk,6496
 puzzle_solver/puzzles/tracks/tracks.py,sha256=98xds9SKNqtOLFTRUX_KSMC7XYmZo567LOFeqotVQaM,7237
 puzzle_solver/puzzles/undead/undead.py,sha256=IrCUfzQFBem658P5KKqldG7vd2TugTHehcwseCarerM,6604
+puzzle_solver/puzzles/unequal/unequal.py,sha256=ExY2XDCrqROCDpRLfHo8uVr1zuli1QvbCdNCiDhlCac,6978
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.14.dist-info/METADATA,sha256=HYspx5V6VWQi6fmAy1I6WaNrDlGumsChUCY2mjZQArI,148507
-multi_puzzle_solver-0.9.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.14.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.14.dist-info/RECORD,,
+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,,

puzzle_solver/__init__.py

@@ -7,6 +7,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.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
 from puzzle_solver.puzzles.kakurasu import kakurasu as kakurasu_solver
@@ -22,6 +23,7 @@ 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.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
@@ -31,8 +33,9 @@ from puzzle_solver.puzzles.thermometers import thermometers as thermometers_solv
 from puzzle_solver.puzzles.towers import towers as towers_solver
 from puzzle_solver.puzzles.tracks import tracks as tracks_solver
 from puzzle_solver.puzzles.undead import undead as undead_solver
+from puzzle_solver.puzzles.unequal import unequal as unequal_solver
 from puzzle_solver.puzzles.unruly import unruly as unruly_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.14'
+__version__ = '0.9.18'

puzzle_solver/core/utils_ortools.py

@@ -97,6 +97,8 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
 
     vs = vars_to_force
     v_count = len(vs)
+    if v_count <= 2:  # graph must have at least 3 nodes to possibly be disconnected
+        return {}
     # =V model variables, one for each variable
     is_root: dict[Pos, cp_model.IntVar] = {}  # =V, defines the unique root 
     prefix_zero: dict[Pos, cp_model.IntVar] = {}  # =V, used for picking the unique root
@@ -128,7 +130,7 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
     for p in keys_in_order:
         and_constraint(model, is_root[p], [vs[p], prefix_zero[p]])
     # Exactly one root:
-    model.Add(sum(is_root.values()) == 1)
+    model.Add(sum(is_root.values()) <= 1)
 
     # For each node i, consider only neighbors
     for i, pi in enumerate(keys_in_order):
@@ -173,10 +175,15 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
     tree_edge: dict[tuple[Pos, Pos], cp_model.IntVar] = {}  # tree_edge[p, q] means p is parent of q
     prefix_name = "no_loops_"
 
-    def parent_of(p: Pos) -> list[Pos]:
-        return [q for q in keys_in_order if (q, p) in tree_edge]
-    def children_of(p: Pos) -> list[Pos]:
-        return [q for q in keys_in_order if (p, q) in tree_edge]
+    parent_of = {p: [] for p in vs.keys()}
+    children_of = {p: [] for p in vs.keys()}
+    for p in vs.keys():
+        for q in vs.keys():
+            if p == q:
+                continue
+            if is_neighbor(p, q):
+                parent_of[q].append(p)
+                children_of[p].append(q)
 
     keys_in_order = list(vs.keys())  # must enforce some ordering
     node_to_idx: dict[Pos, int] = {p: i+1 for i, p in enumerate(keys_in_order)}
@@ -195,16 +202,13 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
         model.Add(block_root[p] == node_to_idx[p]).OnlyEnforceIf([is_root[p]])
 
     for p in keys_in_order:
-        for q in keys_in_order:
-            if p == q:
-                continue
-            if is_neighbor(p, q):
-                tree_edge[(p, q)] = model.NewBoolVar(f"{prefix_name}tree_edge[{p} is parent of {q}]")
-                model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[p].Not()])
-                model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[q].Not()])
-                # a tree_edge[p, q] means p is parent of q thus h[q] = h[p] + 1
-                model.Add(node_height[q] == node_height[p] + 1).OnlyEnforceIf([tree_edge[(p, q)]])
-                model.Add(block_root[q] == block_root[p]).OnlyEnforceIf([tree_edge[(p, q)]])
+        for q in children_of[p]:
+            tree_edge[(p, q)] = model.NewBoolVar(f"{prefix_name}tree_edge[{p} is parent of {q}]")
+            model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[p].Not()])
+            model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[q].Not()])
+            # a tree_edge[p, q] means p is parent of q thus h[q] = h[p] + 1
+            model.Add(node_height[q] == node_height[p] + 1).OnlyEnforceIf([tree_edge[(p, q)]])
+            model.Add(block_root[q] == block_root[p]).OnlyEnforceIf([tree_edge[(p, q)]])
 
     for (p, q) in tree_edge:
         if (q, p) in tree_edge:
@@ -212,14 +216,14 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
             model.Add(tree_edge[(p, q)] == 1).OnlyEnforceIf([tree_edge[(q, p)].Not(), vs[p], vs[q]])
 
     for p in keys_in_order:
-        for p_child in children_of(p):
+        for p_child in children_of[p]:
             # i am root thus I point to all my children
             model.Add(tree_edge[(p, p_child)] == 1).OnlyEnforceIf([is_root[p], vs[p_child]])
-        for p_parent in parent_of(p):
+        for p_parent in parent_of[p]:
             # i am root thus I have no parent
             model.Add(tree_edge[(p_parent, p)] == 0).OnlyEnforceIf([is_root[p]])
         # every active node has exactly 1 parent except root has none
-        model.AddExactlyOne([tree_edge[(p_parent, p)] for p_parent in parent_of(p)] + [vs[p].Not(), is_root[p]])
+        model.AddExactlyOne([tree_edge[(p_parent, p)] for p_parent in parent_of[p]] + [vs[p].Not(), is_root[p]])
     
     # now each subgraph has directions where each non-root points to a single parent (and its value is parent+1). 
     # to break cycles, every non-root active node must be > all neighbors that arent children
@@ -231,5 +235,7 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
         all_new_vars[f"{prefix_name}tree_edge[{k[0]} is parent of {k[1]}]"] = v
     for k, v in node_height.items():
         all_new_vars[f"{prefix_name}node_height[{k}]"] = v
+    for k, v in block_root.items():
+        all_new_vars[f"{prefix_name}block_root[{k}]"] = v
 
     return all_new_vars

puzzle_solver/puzzles/galaxies/galaxies.py

@@ -0,0 +1,110 @@
+from collections import defaultdict
+from typing import Iterable, Union
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, Direction, get_next_pos, in_bounds, get_opposite_direction, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+
+
+def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:
+    result = defaultdict(list)
+    for pos, arr_id in np.ndenumerate(galaxies):
+        if not arr_id.strip():
+            continue
+        result[arr_id].append(get_pos(x=pos[1], y=pos[0]))
+    return [positions for _, positions in sorted(result.items(), key=lambda x: x[0])]
+
+
+class Board:
+    def __init__(self, galaxies: Union[list[tuple[Pos, ...]], np.ndarray], V: int = None, H: int = None):
+        if isinstance(galaxies, np.ndarray):
+            V, H = galaxies.shape
+            galaxies = parse_numpy(galaxies)
+        else:
+            assert V is not None and H is not None, 'V and H must be provided if galaxies is not a numpy array'
+        assert V >= 1 and H >= 1, 'V and H must be at least 1'
+        assert all(isinstance(galaxy, Iterable) for galaxy in galaxies), 'galaxies must be a list of Iterables'
+        assert all(len(galaxy) in [1, 2, 4] for galaxy in galaxies), 'each galaxy must be exactly 1, 2, or 4 positions'
+        self.V = V
+        self.H = H
+        self.n_galaxies = len(galaxies)
+        self.galaxies = galaxies
+        self.prelocated_positions: set[Pos] = {pos: i for i, galaxy in enumerate(galaxies) for pos in galaxy}
+
+        self.model = cp_model.CpModel()
+        self.pos_to_galaxy: dict[Pos, dict[int, cp_model.IntVar]] = {p: {} for p in get_all_pos(V, H)}  # each position can be part of exactly one out of many possible galaxies
+        self.allocated_pairs: set[tuple[Pos, Pos]] = set()  # each pair is allocated to exactly one galaxy
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for i in range(self.n_galaxies):
+            galaxy = self.galaxies[i]
+            if len(galaxy) == 1:
+                p1, p2 = galaxy[0], galaxy[0]
+            elif len(galaxy) == 2:
+                p1, p2 = galaxy[0], galaxy[1]
+            elif len(galaxy) == 4:
+                p1, p2 = galaxy[0], galaxy[3]  # [1] and [2] will be linked with symmetry
+            self.expand_galaxy(p1, p2, i)
+
+    def expand_galaxy(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        if (p1, p2) in self.allocated_pairs or (p2, p1) in self.allocated_pairs:
+            return
+        if p1 in self.prelocated_positions and self.prelocated_positions[p1] != galaxy_idx:
+            return
+        if p2 in self.prelocated_positions and self.prelocated_positions[p2] != galaxy_idx:
+            return
+        if not in_bounds(p1, self.V, self.H) or not in_bounds(p2, self.V, self.H):
+            return
+        self.bind_pair(p1, p2, galaxy_idx)
+        # symmetrically expand the galaxy until illegal position is hit
+        for direction in [Direction.RIGHT, Direction.UP, Direction.DOWN, Direction.LEFT]:
+            symmetrical_direction = get_opposite_direction(direction)
+            new_p1 = get_next_pos(p1, direction)
+            new_p2 = get_next_pos(p2, symmetrical_direction)
+            self.expand_galaxy(new_p1, new_p2, galaxy_idx)
+
+    def bind_pair(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        assert galaxy_idx not in self.pos_to_galaxy[p1], f'p1={p1} already has galaxy idx={galaxy_idx}'
+        assert galaxy_idx not in self.pos_to_galaxy[p2], f'p2={p2} already has galaxy idx={galaxy_idx}'
+        self.allocated_pairs.add((p1, p2))
+        v1 = self.model.NewBoolVar(f'{p1}:{galaxy_idx}')
+        v2 = self.model.NewBoolVar(f'{p2}:{galaxy_idx}')
+        self.model.Add(v1 == v2)
+        self.pos_to_galaxy[p1][galaxy_idx] = v1
+        self.pos_to_galaxy[p2][galaxy_idx] = v2
+
+    def add_all_constraints(self):
+        galaxy_vars = {}
+        for pos in get_all_pos(self.V, self.H):
+            pos_vars = list(self.pos_to_galaxy[pos].values())
+            self.model.AddExactlyOne(pos_vars)
+            for galaxy_idx, v in self.pos_to_galaxy[pos].items():
+                galaxy_vars.setdefault(galaxy_idx, {})[pos] = v
+        for galaxy_idx, pos_vars in galaxy_vars.items():
+            force_connected_component(self.model, pos_vars)
+
+
+    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, galaxy_vars in board.pos_to_galaxy.items():
+                for galaxy_idx, var in galaxy_vars.items():  # every pos is part of exactly one galaxy
+                    if solver.Value(var) == 1:
+                        assignment[pos] = galaxy_idx
+                        break
+            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):
+                set_char(res, pos, str(single_res.assignment[pos]).zfill(2))
+            print('[')
+            for row in range(self.V):
+                print('   ', res[row].tolist(), end=',\n')
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/galaxies/parse_map/parse_map.py

@@ -0,0 +1,216 @@
+"""
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.html and converts them to a json file. 
+    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.
+"""
+from pathlib import Path
+import numpy as np
+cv = None
+Image = None
+
+
+def extract_lines(bw):
+    # Create the images that will use to extract the horizontal and vertical lines
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = cols // 5
+    # Create structure element for extracting horizontal lines through morphology operations
+    horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv.erode(horizontal, horizontalStructure)
+    horizontal = cv.dilate(horizontal, horizontalStructure)
+    horizontal_means = np.mean(horizontal, axis=1)
+    horizontal_cutoff = np.percentile(horizontal_means, 50)
+    # location where the horizontal lines are
+    horizontal_idx = np.where(horizontal_means > horizontal_cutoff)[0]
+    # print(f"horizontal_idx: {horizontal_idx}")
+    height = len(horizontal_idx)
+    # show_wait_destroy("horizontal", horizontal)  # this has the horizontal lines
+
+    rows = vertical.shape[0]
+    verticalsize = rows // 5
+    # Create structure element for extracting vertical lines through morphology operations
+    verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+    vertical = cv.erode(vertical, verticalStructure)
+    vertical = cv.dilate(vertical, verticalStructure)
+    vertical_means = np.mean(vertical, axis=0)
+    vertical_cutoff = np.percentile(vertical_means, 50)
+    vertical_idx = np.where(vertical_means > vertical_cutoff)[0]
+    # print(f"vertical_idx: {vertical_idx}")
+    width = len(vertical_idx)
+    # print(f"height: {height}, width: {width}")
+    # print(f"vertical_means: {vertical_means}")
+    # show_wait_destroy("vertical", vertical)  # this has the vertical lines
+
+    vertical = cv.bitwise_not(vertical)
+    # show_wait_destroy("vertical_bit", vertical)
+
+    return horizontal_idx, vertical_idx
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+def mean_consecutives(arr: np.ndarray) -> np.ndarray:
+    """if a sequence of values is consecutive, then average the values"""
+    sums = []
+    counts = []
+    for i in range(len(arr)):
+        if i == 0:
+            sums.append(arr[i])
+            counts.append(1)
+        elif arr[i] == arr[i-1] + 1:
+            sums[-1] += arr[i]
+            counts[-1] += 1
+        else:
+            sums.append(arr[i])
+            counts.append(1)
+    return np.array(sums) // np.array(counts)
+
+def main(image):
+    global Image
+    global cv
+    import matplotlib.pyplot as plt
+    from PIL import Image as Image_module
+    import cv2 as cv_module
+    Image = Image_module
+    cv = cv_module
+
+
+    image_path = Path(image)
+    output_path = image_path.parent / (image_path.stem + '.json')
+    src = cv.imread(image, cv.IMREAD_COLOR)
+    assert src is not None, f'Error opening image: {image}'
+    if len(src.shape) != 2:
+        gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    else:
+        gray = src
+    # now the image is in grayscale
+
+    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
+    gray = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(gray.copy(), 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 15, -2)
+    # show_wait_destroy("binary", bw)
+
+    # show_wait_destroy("src", src)
+    horizontal_idx, vertical_idx = extract_lines(bw)
+    horizontal_idx = mean_consecutives(horizontal_idx)
+    vertical_idx = mean_consecutives(vertical_idx)
+    height = len(horizontal_idx)
+    width = len(vertical_idx)
+    print(f"height: {height}, width: {width}")
+    print(f"horizontal_idx: {horizontal_idx}")
+    print(f"vertical_idx: {vertical_idx}")
+    arr = np.zeros((height - 1, width - 1), dtype=object)
+    output = {(dx, dy): arr.copy() for dx in [-1, 0, 1] for dy in [-1, 0, 1]}
+    hists = {(dx, dy): {} for dx in [-1, 0, 1] for dy in [-1, 0, 1]}
+    for j in range(height - 1):
+        for i in range(width - 1):
+            hidx1, hidx2 = horizontal_idx[j], horizontal_idx[j+1]
+            vidx1, vidx2 = vertical_idx[i], vertical_idx[i+1]
+            hidx1 = max(0, hidx1 - 2)
+            hidx2 = min(src.shape[0], hidx2 + 4)
+            vidx1 = max(0, vidx1 - 2)
+            vidx2 = min(src.shape[1], vidx2 + 4)
+            cell = src[hidx1:hidx2, vidx1:vidx2]
+            mid_x = cell.shape[1] // 2
+            mid_y = cell.shape[0] // 2
+            cell = cv.bitwise_not(cell)  # invert colors
+            for dx in [-1, 0, 1]:
+                for dy in [-1, 0, 1]:
+                    mx = mid_x + dx*mid_x
+                    my = mid_y + dy*mid_y
+                    mx0 = max(0, mx - 5)
+                    mx1 = min(cell.shape[1], mx + 5)
+                    my0 = max(0, my - 5)
+                    my1 = min(cell.shape[0], my + 5)
+                    cell_part = cell[my0:my1, mx0:mx1]
+                    hists[(dx, dy)][j, i] = np.sum(cell_part)
+            # top = cell[0:10, mid_y-5:mid_y+5]
+            # hists['top'][j, i] = np.sum(top)
+            # left = cell[mid_x-5:mid_x+5, 0:10]
+            # hists['left'][j, i] = np.sum(left)
+            # right = cell[mid_x-5:mid_x+5, -10:]
+            # hists['right'][j, i] = np.sum(right)
+            # bottom = cell[-10:, mid_y-5:mid_y+5]
+            # hists['bottom'][j, i] = np.sum(bottom)
+            # print(f"cell_{i}_{j}, ", [hists[(dx, dy)][j, i] for dx in [-1, 0, 1] for dy in [-1, 0, 1]])
+            # show_wait_destroy(f"cell_{i}_{j}", cell)
+
+    fig, axs = plt.subplots(3, 3)
+    target = 100
+    for dx in [-1, 0, 1]:
+        for dy in [-1, 0, 1]:
+            axs[dx+1, dy+1].hist(list(hists[(dx, dy)].values()), bins=100)
+            axs[dx+1, dy+1].set_title(f'{dx},{dy}')
+            # target = np.mean(list(hists[(dx, dy)].values()))
+            axs[dx+1, dy+1].axvline(target, color='red')
+    # plt.show()
+    # 1/0
+    for j in range(height - 1):
+        for i in range(width - 1):
+            sums_str = ''
+            out_str = ''
+            for dx in [-1, 0, 1]:
+                out_xpart = 'L' if dx == -1 else 'C' if dx == 0 else 'R'
+                for dy in [-1, 0, 1]:
+                    out_ypart = 'T' if dy == -1 else 'C' if dy == 0 else 'B'
+                    sums_str += str(hists[(dx, dy)][j, i]) + ' '
+                    if hists[(dx, dy)][j, i] < target:
+                        out_str += (out_xpart + out_ypart + ' ')
+                        output[(dx, dy)][j, i] = 1
+            print(f"cell_{j}_{i}", end=': ')
+            print(out_str)
+            print('   Sums: ', sums_str)
+
+    out = np.full_like(output[(0, 0)], '  ', dtype='U2')
+    counter = 0
+    for j in range(out.shape[0]):
+        for i in range(out.shape[1]):
+            for dx in [-1, 0, 1]:
+                for dy in [-1, 0, 1]:
+                    if output[(dx, dy)][j, i] == 1:
+                        # out[j, i] = dxdy_to_char[(dx, dy)]
+                        if dx == 0 and dy == 0:  # single point
+                            out[j, i] = str(counter).zfill(2)
+                            counter += 1
+                        elif dx == 0 and dy == 1:  # vertical
+                            out[j, i] = str(counter).zfill(2)
+                            out[j+1, i] = str(counter).zfill(2)
+                            counter += 1
+                        elif dx == 1 and dy == 0:  # horizontal
+                            out[j, i] = str(counter).zfill(2)
+                            out[j, i+1] = str(counter).zfill(2)
+                            counter += 1
+                        elif dx == 1 and dy == 1:  # 2 by 2
+                            out[j, i] = str(counter).zfill(2)
+                            out[j+1, i] = str(counter).zfill(2)
+                            out[j, i+1] = str(counter).zfill(2)
+                            out[j+1, i+1] = str(counter).zfill(2)
+                            counter += 1
+
+    # print(out)
+    with open(output_path, 'w') as f:
+        f.write('[\n')
+        for i, row in enumerate(out):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(out) - 1:
+                f.write(',')
+            f.write('\n')
+        f.write(']')
+    print('output json: ', output_path)
+
+if __name__ == '__main__':
+    # to run this script and visualize the output, in the root run:
+    #  python .\src\puzzle_solver\puzzles\galaxies\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
+    # main(Path(__file__).parent / 'input_output' / 'MTM6OSw4MjEsNDAx.png')
+    # 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' / 'eofodowmumgzzdkopzlpzkzaezrhefoezejvdtxrzmpgozzemxjdcigcqzrk.png')

puzzle_solver/puzzles/slant/parse_map/parse_map.py

@@ -0,0 +1,133 @@
+"""
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html and converts them to a json file. 
+    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, itertools
+from pathlib import Path
+import numpy as np
+cv = None
+
+
+def extract_lines(bw):
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = max(5, cols // 20)
+    h_kernel = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv.erode(horizontal, h_kernel)
+    horizontal = cv.dilate(horizontal, h_kernel)
+    h_means = np.mean(horizontal, axis=1)
+    h_idx = np.where(h_means > np.percentile(h_means, 70))[0]
+
+    rows = vertical.shape[0]
+    verticalsize = max(5, rows // 20)
+    v_kernel = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+    vertical = cv.erode(vertical, v_kernel)
+    vertical = cv.dilate(vertical, v_kernel)
+    v_means = np.mean(vertical, axis=0)
+    v_idx = np.where(v_means > np.percentile(v_means, 70))[0]
+    return h_idx, v_idx
+
+def mean_consecutives(arr):
+    if len(arr) == 0:
+        return arr
+    sums, counts = [arr[0]], [1]
+    for k in arr[1:]:
+        if k == sums[-1] + counts[-1]:
+            sums[-1] += k; counts[-1] += 1
+        else:
+            sums.append(k); counts.append(1)
+    return np.array(sums)//np.array(counts)
+
+def main(img_path):
+    global cv
+    import cv2 as cv_module
+    cv = cv_module
+    image_path = Path(img_path)
+    output_path = image_path.parent / (image_path.stem + '.json')
+    src = cv.imread(img_path, cv.IMREAD_COLOR)
+    gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    inv = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(inv, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY, 15, -2)
+    h_idx, v_idx = extract_lines(bw)
+    h_idx = mean_consecutives(h_idx)
+    v_idx = mean_consecutives(v_idx)
+
+    # Estimate grid cell and circle radii
+    cell = int(np.median(np.diff(h_idx))) if len(h_idx) > 3 else 40
+    r_min = max(6, int(cell*0.18))
+    r_max = int(cell*0.52)
+
+    # Global Hough detection with parameter sweep
+    blur = cv.medianBlur(gray, 5)
+    detected = []  # x, y, r
+
+    for dp, p2 in itertools.product([1.2, 1.0], [20, 18, 16, 14, 12]):
+        circles = cv.HoughCircles(
+            blur, cv.HOUGH_GRADIENT, dp=dp, minDist=max(12, int(cell*0.75)),
+            param1=120, param2=p2, minRadius=r_min, maxRadius=r_max
+        )
+        if circles is not None:
+            for (x, y, r) in np.round(circles[0, :]).astype(int):
+                detected.append((x, y, r))
+
+    # Non-maximum suppression to remove duplicates
+    def nms(circles, dist_thr=10):
+        kept = []
+        for x,y,r in sorted(circles, key=lambda c: -c[2]):
+            if all((x-kx)**2+(y-ky)**2 > dist_thr**2 for kx,ky,kr in kept):
+                kept.append((x,y,r))
+        return kept
+
+    detected = nms(detected, dist_thr=max(10,int(cell*0.4)))
+
+    # Map circle centers to nearest intersection
+    H, W = len(h_idx), len(v_idx)
+    presence = np.zeros((H, W), dtype=int)
+
+    # Build KD-like search by grid proximity
+    tol = int(cell*0.5)  # max distance from an intersection to accept a circle
+    for (cx, cy, r) in detected:
+        # find nearest indices
+        j = int(np.argmin(np.abs(h_idx - cy)))
+        i = int(np.argmin(np.abs(v_idx - cx)))
+        if abs(h_idx[j]-cy) <= tol and abs(v_idx[i]-cx) <= tol:
+            presence[j, i] = 1
+
+    with open(output_path, 'w') as f:
+        f.write('[\n')
+        for i, row in enumerate(presence):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(presence) - 1:
+                f.write(',')
+            f.write('\n')
+        f.write(']')
+    print('output json: ', output_path)
+    print('output json: ', output_path)
+    print('output json: ', output_path)
+
+    overlay = src.copy()
+    for (cx, cy, r) in detected:
+        cv.circle(overlay, (cx, cy), r, (255,0,0), 2)
+    for j, y in enumerate(h_idx):
+        for i, x in enumerate(v_idx):
+            color = (0,0,255) if presence[j,i]==1 else (0,255,0)
+            cv.circle(overlay, (int(x), int(y)), 4, color, 2)
+    show_wait_destroy("overlay", overlay)
+
+
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+if __name__ == '__main__':
+    # to run this script and visualize the output, in the root run:
+    #  python .\src\puzzle_solver\puzzles\slant\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
+    main(Path(__file__).parent / 'input_output' / '23131379850022376.png')

puzzle_solver/puzzles/slant/slant.py

@@ -0,0 +1,117 @@
+from typing import Literal, Optional, Union
+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, set_char, in_bounds, get_pos
+from puzzle_solver.core.utils_ortools import force_no_loops, generic_solve_all, SingleSolution
+
+
+@dataclass(frozen=True)
+class Node:
+    """The grid is represented as a graph of cells connected to corners."""
+    node_type: Union[Literal["Cell"], Literal["Corner"]]
+    pos: Pos
+    slant: Union[Literal["//"], Literal["\\"], None]
+
+    def get_neighbors(self, board_nodes: dict[tuple[str, Pos, Optional[str]], "Node"]) -> list["Node"]:
+        if self.node_type == "Cell" and self.slant == "//":
+            n1 = board_nodes[("Corner", get_pos(self.pos.x+1, self.pos.y), None)]
+            n2 = board_nodes[("Corner", get_pos(self.pos.x, self.pos.y+1), None)]
+            return [n1, n2]
+        elif self.node_type == "Cell" and self.slant == "\\":
+            n1 = board_nodes[("Corner", get_pos(self.pos.x, self.pos.y), None)]
+            n2 = board_nodes[("Corner", get_pos(self.pos.x+1, self.pos.y+1), None)]
+            return [n1, n2]
+        elif self.node_type == "Corner":
+            # 4 cells, 2 cells per slant
+            n1 = ("Cell", get_pos(self.pos.x-1, self.pos.y-1), "\\")
+            n2 = ("Cell", get_pos(self.pos.x, self.pos.y-1), "//")
+            n3 = ("Cell", get_pos(self.pos.x-1, self.pos.y), "//")
+            n4 = ("Cell", get_pos(self.pos.x, self.pos.y), "\\")
+            return {board_nodes[n] for n in [n1, n2, n3, n4] if n in board_nodes}
+
+
+class Board:
+    def __init__(self, numbers: Union[list[tuple[Pos, int]], np.array], V: int = None, H: int = None):
+        if isinstance(numbers, np.ndarray):
+            V, H = numbers.shape
+            V = V - 1
+            H = H - 1
+            numbers = [(get_pos(x=pos[1], y=pos[0]), int(d)) for pos, d in np.ndenumerate(numbers) if str(d).isdecimal()]
+            numbers = [(p, n) for p, n in numbers if n >= 0]
+        else:
+            assert V is not None and H is not None, 'V and H must be provided if numbers is not a numpy array'
+        assert V >= 1 and H >= 1, 'V and H must be at least 1'
+        assert all(isinstance(number, int) and number >= 0 for (pos, number) in numbers), 'numbers must be a list of integers'
+        self.V = V
+        self.H = H
+        self.numbers = numbers
+        self.pos_to_number: dict[Pos, int] = {pos: number for pos, number in numbers}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], cp_model.IntVar] = {}
+        self.nodes: dict[Node, cp_model.IntVar] = {}
+        self.neighbor_dict: dict[Node, set[Node]] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[(pos, '//')] = self.model.NewBoolVar(f'{pos}://')
+            self.model_vars[(pos, '\\')] = self.model.NewBoolVar(f'{pos}:\\')
+            self.model.AddExactlyOne([self.model_vars[(pos, '//')], self.model_vars[(pos, '\\')]])
+        for (pos, slant), v in self.model_vars.items():
+            self.nodes[Node(node_type="Cell", pos=pos, slant=slant)] = v
+        for pos in get_all_pos(self.V + 1, self.H + 1):
+            self.nodes[Node(node_type="Corner", pos=pos, slant=None)] = self.model.NewConstant(1)
+
+
+    def add_all_constraints(self):
+        for pos, number in self.pos_to_number.items():
+            # pos is a position on the intersection of 4 cells
+            # when pos is (xi, yi) then it gets a +1 contribution for each:
+            # - cell (xi-1, yi-1) is a "\\"
+            # - cell (xi, yi) is a "\\"
+            # - cell (xi, yi-1) is a "//"
+            # - cell (xi-1, yi) is a "//"
+            xi, yi = pos.x, pos.y
+            tl_pos = get_pos(xi-1, yi-1)
+            br_pos = get_pos(xi, yi)
+            tr_pos = get_pos(xi, yi-1)
+            bl_pos = get_pos(xi-1, yi)
+            tl_var = self.model_vars[(tl_pos, '\\')] if in_bounds(tl_pos, self.V, self.H) else 0
+            br_var = self.model_vars[(br_pos, '\\')] if in_bounds(br_pos, self.V, self.H) else 0
+            tr_var = self.model_vars[(tr_pos, '//')] if in_bounds(tr_pos, self.V, self.H) else 0
+            bl_var = self.model_vars[(bl_pos, '//')] if in_bounds(bl_pos, self.V, self.H) else 0
+            self.model.Add(sum([tl_var, tr_var, bl_var, br_var]) == number)
+        board_nodes = {(node.node_type, node.pos, node.slant): node for node in self.nodes.keys()}
+        self.neighbor_dict = {node: node.get_neighbors(board_nodes) for node in self.nodes.keys()}
+        no_loops_vars = force_no_loops(self.model, self.nodes, is_neighbor=lambda n1, n2: n1 in self.neighbor_dict[n2])
+        self.no_loops_vars = no_loops_vars
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            # graph = {node: solver.Value(var) for node, var in board.nodes.items()}
+            for (pos, s), var in board.model_vars.items():
+                if solver.Value(var) == 1:
+                    assignment[pos] = s
+            for p in get_all_pos(self.V, self.H):
+                assert p in assignment, f'position {p} is not assigned a number'
+            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):
+                set_char(res, pos, '/' if single_res.assignment[pos] == '//' else '\\')
+            print('[')
+            for row in range(self.V):
+                line = '    [ ' + ' '.join(res[row].tolist()) + ' ]'
+                print(line)
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -1,5 +1,5 @@
 """
-    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html and converts them to a json file. 
+    This file is a simple helper that parses the images from https://www.puzzle-stitches.com/ and converts them to a json file. 
     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.
 """

puzzle_solver/puzzles/unequal/unequal.py

@@ -0,0 +1,128 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_row_pos, get_col_pos, set_char, get_pos, get_char, Direction, in_bounds, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def parse_board(board: np.array) -> tuple[np.array, list[tuple[Pos, Pos, str]]]:
+    """Returns the internal board and a list for every pair of positions (p1, p2, comparison_type) where p1 < p2 if comparison_type is '<' otherwise abs(p1 - p2)==1 if comparison_type is '|'"""
+    V = int(np.ceil(board.shape[0] / 2))
+    H = int(np.ceil(board.shape[1] / 2))
+    internal_board = np.full((V, H), ' ', dtype=object)
+    pairs = []
+    for row_i in range(board.shape[0]):
+        for col_i in range(board.shape[1]):
+            cell = board[row_i, col_i]
+            if row_i % 2 == 0 and col_i % 2 == 0:  # number or empty cell
+                if cell == ' ':
+                    continue
+                # map A to 10, B to 11, etc.
+                if str(cell).isalpha() and len(str(cell)) == 1:
+                    cell = ord(cell.upper()) - ord('A') + 10
+                assert str(cell).isdecimal(), f'expected number at {row_i, col_i}, got {cell}'
+                internal_board[row_i // 2, col_i // 2] = int(cell)
+            elif row_i % 2 == 0 and col_i % 2 == 1:  # horizontal comparison
+                assert cell in ['<', '>', '|', ' '], f'expected <, >, |, or empty cell at {row_i, col_i}, got {cell}'
+                if cell == ' ':
+                    continue
+                p1 = get_pos(x=col_i // 2, y=row_i // 2)
+                p2 = get_pos(x=p1.x + 1, y=p1.y)
+                if cell == '<':
+                    pairs.append((p1, p2, '<'))
+                elif cell == '>':
+                    pairs.append((p2, p1, '<'))
+                elif cell == '|':
+                    pairs.append((p1, p2, '|'))
+                else:
+                    raise ValueError(f'unexpected cell {cell} at {row_i, col_i}')
+            elif row_i % 2 == 1 and col_i % 2 == 0:  # vertical comparison
+                assert cell in ['∧', '∨', 'U', 'D', 'V', 'n', '-', '|', ' '], f'expected ∧, ∨, U, D, V, n, -, |, or empty cell at {row_i, col_i}, got {cell}'
+                if cell == ' ':
+                    continue
+                p1 = get_pos(x=col_i // 2, y=row_i // 2)
+                p2 = get_pos(x=p1.x, y=p1.y + 1)
+                if cell in ['∨', 'U', 'V']:
+                    pairs.append((p2, p1, '<'))
+                elif cell in ['∧', 'D', 'n']:
+                    pairs.append((p1, p2, '<'))
+                elif cell in ['-', '|']:
+                    pairs.append((p1, p2, '|'))
+                else:
+                    raise ValueError(f'unexpected cell {cell} at {row_i, col_i}')
+            else:
+                assert cell in [' ', '.', 'X'], f'expected empty cell or dot or X at unused corner {row_i, col_i}, got {cell}'
+    return internal_board, pairs
+
+class Board:
+    def __init__(self, board: np.array, adjacent_mode: bool = False, include_zero_before_letter: bool = True):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] > 0 and board.shape[1] > 0, 'board must be non-empty'
+        self.board, self.pairs = parse_board(board)
+        self.adjacent_mode = adjacent_mode
+        self.V, self.H = self.board.shape
+        self.lb = 1
+        self.N = max(self.V, self.H)
+        if include_zero_before_letter and self.N > 9: # zero is introduced when board gets to 10, then we add 1 letter after that
+            self.lb = 0
+            self.N -= 1
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewIntVar(self.lb, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        for row_i in range(self.V):
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_row_pos(row_i, self.H)])
+        for col_i in range(self.H):
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_col_pos(col_i, self.V)])
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if str(c).isdecimal():
+                self.model.Add(self.model_vars[pos] == int(c))
+
+        for p1, p2, comparison_type in self.pairs:
+            assert comparison_type in ['<', '|'], f'SHOULD NEVER HAPPEN: invalid comparison type {comparison_type}, expected < or |'
+            if comparison_type == '<':
+                self.model.Add(self.model_vars[p1] < self.model_vars[p2])
+            elif comparison_type == '|':
+                aux = self.model.NewIntVar(0, 2*self.N, f'aux_{p1}_{p2}')
+                self.model.AddAbsEquality(aux, self.model_vars[p1] - self.model_vars[p2])
+                self.model.Add(aux == 1)
+        if self.adjacent_mode:
+            # in adjacent mode, there is strict NON adjacency if a | does not exist
+            all_pairs = {(p1, p2) for p1, p2, _ in self.pairs}
+            for pos in get_all_pos(self.V, self.H):
+                for direction in [Direction.RIGHT, Direction.DOWN]:
+                    neighbor = get_next_pos(pos, direction)
+                    if not in_bounds(neighbor, self.V, self.H):
+                        continue
+                    if (pos, neighbor) in all_pairs:
+                        continue
+                    assert (neighbor, pos) not in all_pairs, f'SHOULD NEVER HAPPEN: both {pos}->{neighbor} and {neighbor}->{pos} are in the same pair'
+                    aux = self.model.NewIntVar(0, 2*self.N, f'aux_{pos}_{neighbor}')
+                    self.model.AddAbsEquality(aux, self.model_vars[pos] - self.model_vars[neighbor])
+                    self.model.Add(aux != 1)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.Value(var)
+            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):
+                set_char(res, pos, str(single_res.assignment[pos]))
+            print('[')
+            for row in range(self.V):
+                line = '    [ ' + ' '.join(res[row].tolist()) + ' ]'
+                print(line)
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)