multi-puzzle-solver 0.9.22__tar.gz → 0.9.25__tar.gz

{multi_puzzle_solver-0.9.22 → multi_puzzle_solver-0.9.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.22
+Version: 0.9.25
 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
@@ -315,6 +315,23 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
     </a>
   </td>
 </tr>
+<tr>
+  <td align="center">
+    <a href="#binairo-puzzle-type-41"><b>Binairo</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/binairo_solved.png" alt="Binairo" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#rectangles-puzzle-type-42"><b>Rectangles</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/rectangles_solved.png" alt="Rectangles" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#palisade-puzzle-type-43"><b>Palisade</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/palisade_solved.png" alt="Palisade" width="140">
+    </a>
+  </td>
+</tr>
 </table>
 
 </div>
@@ -369,6 +386,9 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Norinori (Puzzle Type #38)](#norinori-puzzle-type-38)
   - [Slitherlink (Puzzle Type #39)](#slitherlink-puzzle-type-39)
   - [Yin-Yang (Puzzle Type #40)](#yin-yang-puzzle-type-40)
+  - [Binairo (Puzzle Type #41)](#binairo-puzzle-type-41)
+  - [Rectangles (Puzzle Type #42)](#rectangles-puzzle-type-42)
+  - [Palisade (Puzzle Type #43)](#palisade-puzzle-type-43)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -3303,9 +3323,13 @@ Applying the solution to the puzzle visually:
 
 ## Slitherlink (Puzzle Type #39)
 
-Also known as Fences and Loop the Loop
+Also known as Fences, Loop the Loop, and Loopy
+
+* [**Play online 1**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/loopy.html)
+
+* [**Play online 2**](https://www.puzzle-loop.com)
 
-* [**Play online**](https://www.puzzle-loop.com)
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/loopy.html#loopy)
 
 * [**Solver Code**][39]
 
@@ -3412,7 +3436,6 @@ Applying the solution to the puzzle visually:
 
 ---
 
-
 ## Yin-Yang (Puzzle Type #40)
 
 * [**Play online**](https://www.puzzle-yin-yang.com)
@@ -3503,6 +3526,299 @@ Applying the solution to the puzzle visually:
 
 ---
 
+## Binairo (Puzzle Type #41)
+
+* [**Play online**](https://www.puzzle-binairo.com)
+
+* [**Solver Code**][41]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+Binairo is played on a rectangular grid with no standard size. Some cells start out filled with black or white circles. The rest of the cells are empty. The goal is to place circles in all cells in such a way that:
+
+1. Each row and each column must contain an equal number of white and black circles.
+2. More than two circles of the same color can't be adjacent.
+3. Each row and column is unique. 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/binairo_unsolved.png" alt="Binairo unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+import numpy as np
+from puzzle_solver import binairo_solver as solver
+board = np.array([
+    [' ', ' ', ' ', ' ', 'W', ' ', ' ', ' ', 'W', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' ', 'W'],
+    [' ', 'W', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', ' ', 'W', ' ', ' ', 'B', ' ', ' ', ' ', 'B', ' '],
+    [' ', 'W', ' ', ' ', ' ', 'W', ' ', 'W', 'W', ' ', ' ', ' ', 'B', ' ', ' ', 'W', ' ', ' ', ' ', ' '],
+    ['B', ' ', ' ', 'W', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    ['B', ' ', ' ', ' ', 'W', ' ', ' ', ' ', ' ', 'B', ' ', 'W', ' ', ' ', ' ', 'B', ' ', ' ', ' ', 'W'],
+    [' ', ' ', 'W', ' ', ' ', 'W', ' ', ' ', ' ', ' ', 'W', ' ', ' ', ' ', ' ', ' ', ' ', 'W', ' ', ' '],
+    ['W', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' ', 'B', ' ', ' ', 'B', 'B', ' ', ' ', 'W', ' ', 'B', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', 'W', ' ', ' ', ' '],
+    [' ', ' ', ' ', ' ', 'W', ' ', 'B', ' ', 'W', ' ', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    [' ', 'W', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'W', ' ', ' ', ' ', 'W', 'W', ' ', ' ', ' '],
+    [' ', ' ', 'B', ' ', ' ', ' ', 'B', ' ', 'B', ' ', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    [' ', 'W', 'B', ' ', 'W', ' ', 'B', ' ', ' ', ' ', ' ', ' ', 'W', 'W', ' ', 'B', ' ', ' ', 'B', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' ', ' ', 'B', 'B'],
+    [' ', 'B', ' ', ' ', ' ', ' ', 'W', ' ', 'W', 'W', ' ', ' ', 'W', ' ', ' ', ' ', 'W', ' ', ' ', ' '],
+    [' ', ' ', 'W', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'W', 'W', ' ', ' ', 'W', 'W', ' '],
+    [' ', 'B', ' ', 'B', 'W', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+    [' ', 'B', ' ', ' ', ' ', 'W', ' ', ' ', ' ', 'W', ' ', ' ', 'B', ' ', 'B', ' ', ' ', ' ', ' ', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ', ' ', 'W', ' ', ' ', ' ', 'W'],
+    [' ', ' ', ' ', 'B', 'B', ' ', ' ', 'W', ' ', 'W', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B', ' ', ' '],
+    ['B', ' ', 'B', 'B', ' ', ' ', ' ', ' ', ' ', 'W', ' ', 'B', ' ', ' ', 'B', ' ', ' ', ' ', ' ', ' ']
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+[
+    [ 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'B', 'W' ],
+    [ 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'B', 'W', 'B' ],
+    [ 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'W', 'B', 'B' ],
+    [ 'B', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'B', 'W' ],
+    [ 'W', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'W', 'B' ],
+    [ 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'B', 'W' ],
+    [ 'B', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'B' ],
+    [ 'W', 'B', 'W', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'B', 'W', 'B', 'W' ],
+    [ 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'B' ],
+    [ 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'B', 'W', 'W' ],
+    [ 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W' ],
+    [ 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'B' ],
+    [ 'W', 'B', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'W' ],
+    [ 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B' ],
+    [ 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'B', 'W', 'B', 'W', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B' ],
+    [ 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'B', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'W' ],
+    [ 'W', 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B' ],
+    [ 'B', 'W', 'B', 'B', 'W', 'B', 'W', 'B', 'W', 'W', 'B', 'B', 'W', 'W', 'B', 'W', 'B', 'W', 'W', 'B' ],
+]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.03 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/binairo_solved.png" alt="Binairo solved" width="500">
+
+---
+
+## Rectangles (Puzzle Type #42)
+
+Also called "Shikaku".
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/rect.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/rect.html#rect)
+
+* [**Solver Code**][42]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You have a grid of squares, with numbers written in some (but not all) of the squares. Your task is to subdivide the grid into rectangles of various sizes, such that both:
+
+- (a) every rectangle contains exactly one numbered square
+- (b) the area of each rectangle is equal to the number written in its numbered square. 
+
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/rectangles_unsolved.png" alt="Rectangles unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+import numpy as np
+from puzzle_solver import rectangles_solver as solver
+board = np.array([
+    ['3', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '15',' ', ' ', ' ', ' ' ],
+    [' ', ' ', '2', '2', ' ', ' ', ' ', ' ', ' ', ' ', '11',' ', ' ', ' ', ' ', ' ', ' ', '3', '2' ],
+    [' ', ' ', ' ', ' ', '2', ' ', ' ', ' ', '11',' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' ' ],
+    [' ', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', ' ', '6', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '28','4', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '10',' ', '10',' ', ' ', ' ', ' ', '45',' ' ],
+    [' ', ' ', '3', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', '22',' ', ' ', ' ', ' ', ' ', '28',' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '17'],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', '8', '3', ' ', ' ', '2', '2', ' ', ' ', ' ', '5', ' ', ' ', '4', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', ' ', ' ', ' ', '4', ' ', ' ', '8', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', ' ', ' ', ' ' ],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '3', ' ' ],
+    [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    ['2', ' ', ' ', ' ', '12',' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    ['2', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' ],
+    [' ', ' ', '3', '2', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '60',' ', ' ', ' ', ' ', ' ', '4', ' ' ],
+])
+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  
+    0   1   2   3   4   5   6   7   8   9   0   1   2   3   4   5   6   7   8
+  ┌───────────┬───────────────────────────────────────────────────────────┬───┐
+ 0│ 3         │                                            15             │   │
+  ├───────┬───┼───┬───────────────────────────────────────────┬───────────┤   │
+ 1│       │ 2 │ 2 │                        11                 │         3 │ 2 │
+  │       │   │   ├───┬───────────────────────────────────────┴───┬───────┼───┤
+ 2│       │   │   │ 2 │            11                             │     2 │   │
+  │       ├───┴───┤   ├───────────────────────┬───┬───┬───────────┴───────┤   │
+ 3│       │     2 │   │                     6 │   │   │                   │   │
+  │       ├───────┴───┴───────────────┬───┬───┤   │   │                   │   │
+ 4│       │                           │   │   │ 3 │   │                   │   │
+  │       │                           │   │   │   │   │                   │   │
+ 5│       │                           │   │ 2 │   │   │                   │   │
+  │       │                           │   ├───┴───┤   │                   │   │
+ 6│       │                           │   │     2 │   │                   │   │
+  │       │                           │   ├───────┤   │                   │   │
+ 7│       │                        28 │ 4 │       │   │                   │   │
+  │       ├───┬───────────────────────┴───┤       │   │                   │   │
+ 8│       │   │                           │10     │10 │                45 │   │
+  │       │   │                           │       │   │                   │   │
+ 9│       │ 3 │                           │       │   │                   │   │
+  │       │   │                           │       │   │                   │   │
+10│    22 │   │                28         │       │   │                   │17 │
+  │       ├───┤                           │       │   │                   │   │
+11│       │   │                           │       │   │                   │   │
+  ├───────┤   ├───────┬───┬───┬───────────┴───────┤   ├───────────────┬───┤   │
+12│     8 │ 3 │       │ 2 │ 2 │             5     │   │ 4             │   │   │
+  │       │   │       │   │   ├───────────────────┴───┴───────┬───────┤   │   │
+13│       │   │     4 │   │   │ 8                             │ 2     │   │   │
+  │       ├───┴───────┼───┴───┴───────────────────────────────┴───────┤   │   │
+14│       │           │                                               │ 3 │   │
+  │       │           │                                               ├───┤   │
+15│       │           │                                               │   │   │
+  ├───────┤           │                                               │   │   │
+16│ 2     │        12 │                                               │   │   │
+  ├───────┤           │                                               │   │   │
+17│ 2     │           │                                               │   │   │
+  ├───────┴───┬───────┤                                               │   │   │
+18│         3 │ 2     │                        60                     │ 4 │   │
+  └───────────┴───────┴───────────────────────────────────────────────┴───┴───┘
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.01 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/rectangles_solved.png" alt="Rectangles solved" width="500">
+
+---
+
+
+## Palisade (Puzzle Type #43)
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/palisade.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/palisade.html#palisade)
+
+* [**Solver Code**][42]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You're given a grid of N squares and a region size M, some of which contain numbers. Your goal is to subdivide the grid into (N/M) contiguous regions, where every region is of size M, such that each square containing a number is adjacent to exactly that many edges (including those between the inside and the outside of the grid). 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/palisade_unsolved.png" alt="Palisade unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: it takes a few seconds for the model to be built if the region size is larger than 8 and around 10 seconds for a region size of 10)
+
+```python
+import numpy as np
+from puzzle_solver import palisade_solver as solver
+board = np.array([
+    ['2', ' ', ' ', ' ', ' ', '3', ' ', ' ', '1', '1', '3', ' ', ' ', ' ', ' '],
+    ['3', '2', '1', ' ', '2', '3', ' ', ' ', ' ', ' ', ' ', '2', ' ', '0', ' '],
+    [' ', ' ', ' ', '1', '1', ' ', ' ', '1', ' ', ' ', ' ', '1', ' ', ' ', ' '],
+    [' ', '3', '2', ' ', ' ', ' ', ' ', '2', '3', ' ', ' ', ' ', '1', ' ', ' '],
+    [' ', '0', '1', ' ', '2', ' ', ' ', '0', ' ', ' ', ' ', '1', ' ', '3', '2'],
+    ['1', '0', ' ', ' ', ' ', '2', '2', ' ', '2', ' ', '3', ' ', '0', '2', ' '],
+    [' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' '],
+    [' ', '1', ' ', ' ', ' ', '3', '1', ' ', '1', ' ', ' ', ' ', ' ', '1', ' '],
+    [' ', ' ', ' ', '0', ' ', ' ', '0', ' ', ' ', '1', '2', ' ', ' ', ' ', '3'],
+    [' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', ' ', '2', ' ', ' ', '1', '2', '1'],
+    [' ', ' ', ' ', ' ', '1', ' ', '2', '3', '1', ' ', ' ', ' ', '2', ' ', '1'],
+    ['2', ' ', '1', ' ', '2', '2', '1', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' '],
+])
+binst = solver.Board(board, region_size=10)
+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  
+    0   1   2   3   4   5   6   7   8   9   0   1   2   3   4
+  ┌───────────────────┬───────────────────────┬───────────────┐
+ 0│ 2   ·   ·   ·   · │ 3   ·   ·   1   1   3 │ ·   ·   ·   · │
+  │   ┌───────────┐   ├───────┬───┐       ┌───┴───┐           │
+ 1│ 3 │ 2   1   · │ 2 │ 3   · │ · │ ·   · │ ·   2 │ ·   0   · │
+  ├───┘           │   └───┐   │   └───┐   └───┐   └───┐       │
+ 2│ ·   ·   ·   1 │ 1   · │ · │ 1   · │ ·   · │ 1   · │ ·   · │
+  │   ┌───┐       │   ┌───┘   │   ┌───┴───────┘       └───┐   │
+ 3│ · │ 3 │ 2   · │ · │ ·   · │ 2 │ 3   ·   ·   ·   1   · │ · │
+  ├───┘   └───────┼───┘   ┌───┘   └───┬───────────────┬───┴───┤
+ 4│ ·   0   1   · │ 2   · │ ·   0   · │ ·   ·   1   · │ 3   2 │
+  │           ┌───┘       │           │   ┌───┐       └───┐   │
+ 5│ 1   0   · │ ·   ·   2 │ 2   ·   2 │ · │ 3 │ ·   0   2 │ · │
+  │       ┌───┴───────────┼───┬───────┴───┤   ├───┐       │   │
+ 6│ ·   · │ ·   ·   ·   3 │ · │ ·   ·   2 │ · │ · │ ·   · │ · │
+  ├───────┘   ┌───────────┤   └───┐       │   │   └───────┘   │
+ 7│ ·   1   · │ ·   ·   3 │ 1   · │ 1   · │ · │ ·   ·   1   · │
+  │       ┌───┘       ┌───┘       │       │   └───────┐   ┌───┤
+ 8│ ·   · │ ·   0   · │ ·   0   · │ ·   1 │ 2   ·   · │ · │ 3 │
+  │   ┌───┘       ┌───┤           ├───┐   └───┐       ├───┘   │
+ 9│ · │ ·   ·   · │ · │ ·   1   · │ · │ 2   · │ ·   1 │ 2   1 │
+  ├───┤   ┌───────┘   ├───────┐   │   └───┐   │       │       │
+10│ · │ · │ ·   ·   1 │ ·   2 │ 3 │ 1   · │ · │ ·   2 │ ·   1 │
+  │   └───┘           │       └───┘       ├───┴───────┘       │
+11│ 2   ·   1   ·   2 │ 2   1   ·   ·   2 │ ·   ·   ·   ·   · │
+  └───────────────────┴───────────────────┴───────────────────┘
+Solutions found: 1
+status: OPTIMAL
+Time taken: 11.94 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/palisade_solved.png" alt="Palisade solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -3594,3 +3910,6 @@ Issues and PRs welcome!
 [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"
 [40]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/yin_yang "puzzle_solver/src/puzzle_solver/puzzles/yin_yang at master · Ar-Kareem/puzzle_solver · GitHub"
+[41]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/binairo "puzzle_solver/src/puzzle_solver/puzzles/binairo at master · Ar-Kareem/puzzle_solver · GitHub"
+[42]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/rectangles "puzzle_solver/src/puzzle_solver/puzzles/rectangles at master · Ar-Kareem/puzzle_solver · GitHub"
+[43]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/palisade "puzzle_solver/src/puzzle_solver/puzzles/palisade at master · Ar-Kareem/puzzle_solver · GitHub"