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

{multi_puzzle_solver-0.9.15.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.15
+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
@@ -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,33 @@ 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>
+  <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>
 
@@ -318,6 +358,11 @@ 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)
+  - [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)
@@ -1772,8 +1817,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 +2937,454 @@ 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)
+
+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)
+
+* [**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
+from puzzle_solver import unequal_solver as solver
+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">
+
+---
+
+## 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?
@@ -2977,3 +3470,8 @@ 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"
+[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"