multi-puzzle-solver 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

{multi_puzzle_solver-1.0.8.dist-info → multi_puzzle_solver-1.0.10.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 1.0.8
-Summary: Efficient solvers for countless (50+) types of puzzles (like Sudoku, Minesweeper, etc.) with a simple python API.
+Version: 1.0.10
+Summary: Efficient solvers for countless (60+) types of puzzles (like Sudoku, Minesweeper, etc.) with a simple python API.
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver
 Project-URL: Repository, https://github.com/Ar-Kareem/puzzle_solver
@@ -26,7 +26,7 @@ Requires-Dist: pytest-xdist; extra == "dev"
 
 # Python Puzzle Solver
 
-Solve countless (50+) classical logic puzzles automatically in Python. 
+Solve countless (60+) classical logic puzzles automatically in Python. 
 
 ## Quick Start
 
@@ -73,7 +73,7 @@ Time taken: 0.04 seconds
 
 ## Introduction
 
-The aim of this repo is to provide very efficient solvers (i.e. not brute force solvers) for countless (50+) popular pencil logic puzzles like Nonograms, Sudoku, Minesweeper, and many more lesser known ones.
+The aim of this repo is to provide very efficient solvers (i.e. not brute force solvers) for countless (60+) popular pencil logic puzzles like Nonograms, Sudoku, Minesweeper, and many more lesser known ones.
 
 If you happen to have a puzzle similar to the ones listed below and want to solve it (or see how many potential solutions a partially covered board has), then this repo is perfect for you.
 
@@ -417,6 +417,18 @@ 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/puzzles/mathema_grids_solved.png" alt="Mathema Grids" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#split-ends-puzzle-type-60"><b>N-Queens</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/puzzles/7_queens_solved.png" alt="N-Queens" width="140">
+    </a>
+  </td>
+</tr>
+<tr>
+  <td align="center">
+    <a href="#split-ends-puzzle-type-61"><b>Split Ends</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/puzzles/split_ends_solved.png" alt="Split Ends" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -491,6 +503,8 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Nonograms Colored (Puzzle Type #57)](#nonograms-colored-puzzle-type-57)
   - [ABC View (Puzzle Type #58)](#abc-view-puzzle-type-58)
   - [Mathema Grids (Puzzle Type #59)](#mathema-grids-puzzle-type-59)
+  - [Split Ends (Puzzle Type #61)](#split-ends-puzzle-type-61)
+  - [N-Queens (Puzzle Type #60)](#n-queens-puzzle-type-60)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -610,7 +624,15 @@ Time taken: 0.04 seconds
 
 ## Sudoku (Puzzle Type #2)
 
-Also known as Number Place and Solo.
+Also known as Number Place and Solo. 
+
+The code can:
+
+1. Solve arbitrarily sized valid board sizes, thus can be used to solve:
+   - Hex Sudoku (a 16x16 variant) 
+   - Kidoku (a kid-friendly sudoku variant)
+2. Solve the ["Sandwich" sudoku variant](https://dkmgames.com/SandwichSudoku/) using the optional parameter `sandwich={'side': [...], 'bottom': [...]}`
+3. Solve the ["Sudoku-X" variant](https://www.sudopedia.org/wiki/Sudoku-X) using the optional parameter `unique_diagonal=True`
 
 * [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/solo.html)
 
@@ -635,12 +657,6 @@ You are given some of the numbers as clues; your aim is to place the rest of the
 
 Code to utilize this package and solve the puzzle:
 
-Note: 
-
-- The solver also supports solving the ["Sandwich" sudoku variant](https://dkmgames.com/SandwichSudoku/) through the optional parameter ``sandwich={'side': [...], 'bottom': [...] }``。
-
-- The solver also supports solving the ["Sudoku-X" variant](https://www.sudopedia.org/wiki/Sudoku-X) through the optional parameter ``unique_diagonal=True``。
-
 ```python
 import numpy as np
 from puzzle_solver import sudoku_solver as solver
@@ -1105,7 +1121,7 @@ Time taken: 0.15 seconds
 
 ## Keen (Puzzle Type #8)
 
-Also known as KenKen or CalcuDoku.
+Also known as KenKen, CalcuDoku, Inkies, or Inky.
 
 * [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/keen.html)
 
@@ -4043,6 +4059,8 @@ Applying the solution to the puzzle visually:
 
 ## Binairo (Puzzle Type #41)
 
+Also known as Takuzu, Binero, Tohu-Wa-Vohu (Formless and Empty), Eins und Zwei (One and Two), Binary Puzzles, Binoxxo, Binox, Zernero, Tic-Tac-Logic, and Sudoku Binary.
+
 * [**Play online**](https://www.puzzle-binairo.com)
 
 * [**Solver Code**][41]
@@ -4395,19 +4413,30 @@ solutions = binst.solve_and_print()
 
 **Script Output**
 
-The output tells you which squares to tap to solve the puzzle.
+The output tells you which squares to tap to solve the puzzle, the shaded squares are the ones that need to be tapped.
 
 ```python
 Solution found
-[['T' ' ' 'T' 'T' 'T' ' ' ' ']
- [' ' ' ' ' ' 'T' ' ' 'T' ' ']
- [' ' 'T' ' ' ' ' 'T' ' ' ' ']
- ['T' ' ' 'T' ' ' ' ' 'T' ' ']
- [' ' ' ' ' ' 'T' ' ' ' ' 'T']
- ['T' ' ' 'T' ' ' 'T' 'T' 'T']
- [' ' ' ' ' ' ' ' ' ' 'T' 'T']]
+
+    0   1   2   3   4   5   6
+  ┌───┬───┬───┬───┬───┬───┬───┐
+ 0│▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│   │   │
+  ├───┼───┼───┼───┼───┼───┼───┤
+ 1│   │   │   │▒▒▒│   │▒▒▒│   │
+  ├───┼───┼───┼───┼───┼───┼───┤
+ 2│   │▒▒▒│   │   │▒▒▒│   │   │
+  ├───┼───┼───┼───┼───┼───┼───┤
+ 3│▒▒▒│   │▒▒▒│   │   │▒▒▒│   │
+  ├───┼───┼───┼───┼───┼───┼───┤
+ 4│   │   │   │▒▒▒│   │   │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┤
+ 5│▒▒▒│   │▒▒▒│   │▒▒▒│▒▒▒│▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┤
+ 6│   │   │   │   │   │▒▒▒│▒▒▒│
+  └───┴───┴───┴───┴───┴───┴───┘
 Solutions found: 1
 status: OPTIMAL
+Time taken: 0.01 seconds
 ```
 
 **Solved puzzle**
@@ -5942,6 +5971,142 @@ Time taken: 0.00 seconds
 
 ---
 
+## Split Ends (Puzzle Type #61)
+
+* [**Play online**](https://krazydad.com/play/splitends/)
+
+* [**Solver Code**](https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/split_ends)
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+Each row and column contains four unique Y shapes (four different orientations) and two Os. Ys should not form straight lines by touching other Ys.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/puzzles/split_ends_unsolved.png" alt="Split Ends unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+import numpy as np
+from puzzle_solver import split_ends_solver as solver
+board = np.array([
+    ['O', ' ', 'O', 'L', ' ', 'U'],
+    [' ', ' ', ' ', ' ', ' ', ' '],
+    [' ', 'R', ' ', ' ', 'O', ' '],
+    [' ', 'O', ' ', ' ', 'L', ' '],
+    [' ', ' ', ' ', ' ', ' ', ' '],
+    ['U', ' ', 'L', 'D', ' ', 'R'],
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+
+    0   1   2   3   4   5
+  ┌───┬───┬───┬───┬───┬───┐
+ 0│ O │ D │ O │ L │ R │ U │
+  ├───┼───┼───┼───┼───┼───┤
+ 1│ O │ L │ D │ R │ U │ O │
+  ├───┼───┼───┼───┼───┼───┤
+ 2│ D │ R │ O │ U │ O │ L │
+  ├───┼───┼───┼───┼───┼───┤
+ 3│ R │ O │ U │ O │ L │ D │
+  ├───┼───┼───┼───┼───┼───┤
+ 4│ L │ U │ R │ O │ D │ O │
+  ├───┼───┼───┼───┼───┼───┤
+ 5│ U │ O │ L │ D │ O │ R │
+  └───┴───┴───┴───┴───┴───┘
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.01 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/puzzles/split_ends_solved.png" alt="Split Ends solved" width="500">
+
+---
+
+## N-Queens (Puzzle Type #60)
+
+Can also solve puzzles such as 7-Queens.
+
+* [**Play online**](https://krazydad.com/play/queens/)
+
+* [**Solver Code**](https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/n_queens)
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+7-Queens Variant: Within each of the seven realms lives a lone queen. To maintain the peace, queens must not threaten each other: no row, column, diagonal, nor region may have more than one queen!
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/puzzles/7_queens_unsolved.png" alt="7 Queens unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+import numpy as np
+from puzzle_solver import n_queens_solver as solver
+board = np.array([
+  ['00', '00', '00', '00', '01', '01', '02', '02'],
+  ['00', '00', '03', '03', '01', '01', '02', '04'],
+  ['00', '00', '03', '03', '01', '01', '01', '04'],
+  ['03', '03', '03', '03', '01', '01', '01', '05'],
+  ['03', '03', '03', '03', '01', '01', '01', '05'],
+  ['03', '03', '06', '06', '06', '05', '05', '05'],
+  ['06', '06', '06', '06', '06', '06', '05', '05'],
+  ['06', '06', '06', '06', '06', '06', '05', '05']
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+
+    0   1   2   3   4   5   6   7
+  ┌───┬───┬───┬───┬───┬───┬───┬───┐
+ 0│   │   │   │   │   │   │▒▒▒│   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┤
+ 1│▒▒▒│   │   │   │   │   │   │   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┤
+ 2│   │   │   │   │   │   │   │▒▒▒│
+  ├───┼───┼───┼───┼───┼───┼───┼───┤
+ 3│   │   │   │   │▒▒▒│   │   │   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┤
+ 4│   │▒▒▒│   │   │   │   │   │   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┤
+ 5│   │   │   │   │   │▒▒▒│   │   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┤
+ 6│   │   │▒▒▒│   │   │   │   │   │
+  ├───┼───┼───┼───┼───┼───┼───┼───┤
+ 7│   │   │   │   │   │   │   │   │
+  └───┴───┴───┴───┴───┴───┴───┴───┘
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.00 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/puzzles/7_queens_solved.png" alt="7 Queens solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?

{multi_puzzle_solver-1.0.8.dist-info → multi_puzzle_solver-1.0.10.dist-info}/RECORD

@@ -1,11 +1,11 @@
-puzzle_solver/__init__.py,sha256=0jnYSJY4kJBhX5PU4UMmMcbTg8PsyFjiX0y23r5sv5k,5502
+puzzle_solver/__init__.py,sha256=TUXr71rkfWFDtF44XR1ophXB_U8dKFqrWbyLglbWI6c,5695
 puzzle_solver/core/utils.py,sha256=FE0106dfQRsgCn2FRBvRq5zILLK7-Z3cPHkAlBWUX0w,8785
 puzzle_solver/core/utils_ortools.py,sha256=ACV3HgKWpEUTt1lpqsPryK1DeZpu7kdWQKEWTLJ2tfs,10384
 puzzle_solver/core/utils_visualizer.py,sha256=3EJ7V8rHyasj1peAzplDJfKkPy6Yj9j7BXqMBWQ3eNg,22834
 puzzle_solver/puzzles/abc_view/abc_view.py,sha256=Qr0rZKmKQ2teStHjQ5VPQ4k-XptsjJAlZ1WXWk5Aax4,4570
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=dGqYEWMoh4di5DN4sd-GtYb6QeTpVYFQJHBkrrmrudQ,5649
 puzzle_solver/puzzles/battleships/battleships.py,sha256=U4xJ_NJC2baHvfaAfJ01YEBjixq9gD0h8GP9L1V-_oM,7223
-puzzle_solver/puzzles/binairo/binairo.py,sha256=qKvpixLIBUcugAyJgpBGHV-9q_4nzA1ZOxeDFnltsXA,6843
+puzzle_solver/puzzles/binairo/binairo.py,sha256=EBpXYD9Mxuig4uJl3xkcQ6_tbnoG13mVV7RZpQEXm38,5790
 puzzle_solver/puzzles/binairo/binairo_plus.py,sha256=TvLG3olwANtft3LuCF-y4OofpU9PNa4IXDqgZqsD-g0,267
 puzzle_solver/puzzles/black_box/black_box.py,sha256=RXTXQhMAb_Oce9Mk1XpouniYIyy9k3kYGdey-SEeRMU,12559
 puzzle_solver/puzzles/bridges/bridges.py,sha256=QwOhZyO5urbatkNyPmQxZ_lGM01ZejndMr_eoiBkr7g,5394
@@ -16,7 +16,7 @@ puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B
 puzzle_solver/puzzles/connect_the_dots/connect_the_dots.py,sha256=0axF_jtB34mUM6s3j4grjkIWTCjvaw4NZ4oVogZsNvs,2677
 puzzle_solver/puzzles/dominosa/dominosa.py,sha256=Nmb7pn8U27QJwGy9F3wo8ylqo2_U51OAo3GN2soaNpc,7195
 puzzle_solver/puzzles/filling/filling.py,sha256=ILgGJqVI7yd6HPvWeKEsr620qorxLtAQYKTq65PqarY,4952
-puzzle_solver/puzzles/flip/flip.py,sha256=ZngJLUhRNc7qqo2wtNLdMPx4u9w9JTUge27PmdXyDCw,3985
+puzzle_solver/puzzles/flip/flip.py,sha256=cei6irTfntqctaLS3-rdYu8M2tw7ibzlHHvTIHW18yo,3518
 puzzle_solver/puzzles/flood_it/flood_it.py,sha256=jnCtH1sZIt6K4hbQDSsiM1Cd8FjQNP7cfw2ObUW5fEQ,7948
 puzzle_solver/puzzles/flood_it/parse_map/parse_map.py,sha256=m7gcpvN3THZdYLowdR_Jwx3HyttaV4K2DqrX_U7uFqU,8209
 puzzle_solver/puzzles/galaxies/galaxies.py,sha256=IiKPU3fz5Aokhj5OjeT5jd_vdNuWnLzjZylGOTepsNU,5600
@@ -36,6 +36,7 @@ puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy
 puzzle_solver/puzzles/mathema_grids/mathema_grids.py,sha256=wXj3pfXUMh3deFA6XXndZXod6ZNyCVt9vX1akt9zz20,6380
 puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=gSdFsuZ-KrwVxgI1HF2q_pYleZ6vBm9jjRTFlboVnLY,5871
 puzzle_solver/puzzles/mosaic/mosaic.py,sha256=T89tkyTbob3LT20vwY3hkkEtNi8bxp2_CLaVi1gzhBc,1974
+puzzle_solver/puzzles/n_queens/n_queens.py,sha256=QTZwAwtqkijYKRQ4A6r1KUUOKkxPBcnzdSfMe-x8lc4,4425
 puzzle_solver/puzzles/nonograms/nonograms.py,sha256=Q-VHI0IPR2igccnE617HPThj5tnBgt27MiLWIZPtYcI,5587
 puzzle_solver/puzzles/nonograms/nonograms_colored.py,sha256=XpxzpJw0GA-tE7PiltlA-dfypaTvqNIDLnKl1LxIjD4,10500
 puzzle_solver/puzzles/norinori/norinori.py,sha256=ZEDWrD7zvEuqXOdXGOrELh1n_mWzhzZa3chs6Zqd3Pc,4570
@@ -52,10 +53,11 @@ puzzle_solver/puzzles/singles/singles.py,sha256=AugO2Gnd_OEyrxXUnqg3oPypdmeiFais
 puzzle_solver/puzzles/slant/slant.py,sha256=l4q9g0BfqQsA6zsySiemJC5iFsqsO6LoqTUqcTEqYEk,5897
 puzzle_solver/puzzles/slant/parse_map/parse_map.py,sha256=8thQxWbq0qjehKb2VzgUP22PGj-9n9djwbt3LGMVLJw,4811
 puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=AQsOMHB_vP4bDHbhq5hTRRblv01DecdEzy6F4k23OA0,7118
+puzzle_solver/puzzles/split_ends/split_ends.py,sha256=7z0u1CMsdLwBslVwm-cvq_8xJ31tBIvTSvENlMYgVUA,5764
 puzzle_solver/puzzles/star_battle/star_battle.py,sha256=GqrattaxVM7eHtPQYUWHAlLG8DQkDm7p1B3R8VeU9g8,4018
 puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
 puzzle_solver/puzzles/stitches/stitches.py,sha256=wj9z9979FaVtp2hcVu3YDTGlxtwljoQNBgMMM5U3icc,6109
-puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=b21SQvlnDM6wOl_1iUhZ7X6akpBZoOnj3kEzImBCh8Q,10497
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=TPpOR0QZHTtjqJ7MhjHJWlxCVVXLANyipIVWn2ZWzgA,11445
 puzzle_solver/puzzles/sudoku/sudoku.py,sha256=lj3DD98sdA9jNre8Nwe8s_OKpYe7K4iPCmXtJMKfIDs,13344
 puzzle_solver/puzzles/tapa/tapa.py,sha256=554Xun39M3oJ5kOUwrhLUtbUXbsAYj4DH-GBhtJbjoY,5439
 puzzle_solver/puzzles/tents/tents.py,sha256=81hAtmNNYIgzh0tEa0BuExmdzQfGVrlwjn_Dw8hEp3c,4943
@@ -69,7 +71,7 @@ puzzle_solver/puzzles/unruly/unruly.py,sha256=_C6FhYm9rqwhlQa6TMTxYr3rWcP_QS-E93
 puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=D0JacUdK5yPrfScmGqX-p8144VbwxfDgIaqF8hwLXlM,5039
 puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=drjfoHqmFf6U-ZQUwrBbfGINRxDQpgbvy4U3D9QyMhM,6617
 puzzle_solver/utils/visualizer.py,sha256=T2g5We9J3tkhyXWoN2OrIDIJDjt6w5sDd2ksOub0ZI8,6819
-multi_puzzle_solver-1.0.8.dist-info/METADATA,sha256=E6zK6c0vVluGrFEvS459AuNa33dET9IWNdmqtIbYJwA,456018
-multi_puzzle_solver-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-1.0.8.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-1.0.8.dist-info/RECORD,,
+multi_puzzle_solver-1.0.10.dist-info/METADATA,sha256=54KCpQTehbNVilhW5T1BcrbCCN6WPL0kntbPpTe6l7c,463353
+multi_puzzle_solver-1.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-1.0.10.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-1.0.10.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -26,6 +26,7 @@ from puzzle_solver.puzzles.map import map as map_solver
 from puzzle_solver.puzzles.mathema_grids import mathema_grids as mathema_grids_solver
 from puzzle_solver.puzzles.minesweeper import minesweeper as minesweeper_solver
 from puzzle_solver.puzzles.mosaic import mosaic as mosaic_solver
+from puzzle_solver.puzzles.n_queens import n_queens as n_queens_solver
 from puzzle_solver.puzzles.nonograms import nonograms as nonograms_solver
 from puzzle_solver.puzzles.nonograms import nonograms_colored as nonograms_colored_solver
 from puzzle_solver.puzzles.norinori import norinori as norinori_solver
@@ -42,6 +43,7 @@ from puzzle_solver.puzzles.signpost import signpost as signpost_solver
 from puzzle_solver.puzzles.singles import singles as singles_solver
 from puzzle_solver.puzzles.slant import slant as slant_solver
 from puzzle_solver.puzzles.slitherlink import slitherlink as slitherlink_solver
+from puzzle_solver.puzzles.split_ends import split_ends as split_ends_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
@@ -88,6 +90,7 @@ __all__ = [
     mathema_grids_solver,
     minesweeper_solver,
     mosaic_solver,
+    n_queens_solver,
     nonograms_solver,
     norinori_solver,
     nonograms_colored_solver,
@@ -104,6 +107,7 @@ __all__ = [
     singles_solver,
     slant_solver,
     slitherlink_solver,
+    split_ends_solver,
     star_battle_solver,
     star_battle_shapeless_solver,
     stitches_solver,
@@ -121,4 +125,4 @@ __all__ = [
     inertia_image_parser,
 ]
 
-__version__ = '1.0.8'
+__version__ = '1.0.10'

puzzle_solver/puzzles/binairo/binairo.py

@@ -10,26 +10,21 @@ from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
-    def __init__(self, board: np.array, arith_rows: Optional[np.array] = None, arith_cols: Optional[np.array] = None, force_unique: bool = True):
+    def __init__(self, board: np.array, arith_rows: Optional[np.array] = None, arith_cols: Optional[np.array] = None, force_unique: bool = True, disallow_three: bool = True):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] % 2 == 0 and board.shape[1] % 2 == 0, f'board must have even number of rows and columns, got {board.shape[0]}x{board.shape[1]}'
         assert all(c.item() in [' ', 'B', 'W'] for c in np.nditer(board)), 'board must contain only space or B'
+        assert arith_rows is None or all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_rows)), 'arith_rows must contain only space, x, or ='
+        assert arith_cols is None or all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_cols)), 'arith_cols must contain only space, x, or ='
         self.board = board
         self.V, self.H = board.shape
-        if arith_rows is not None:
-            assert arith_rows.ndim == 2, f'arith_rows must be 2d, got {arith_rows.ndim}'
-            assert arith_rows.shape == (self.V, self.H-1), f'arith_rows must be one column less than board, got {arith_rows.shape} for {board.shape}'
-            assert all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_rows)), 'arith_rows must contain only space, x, or ='
-        if arith_cols is not None:
-            assert arith_cols.ndim == 2, f'arith_cols must be 2d, got {arith_cols.ndim}'
-            assert arith_cols.shape == (self.V-1, self.H), f'arith_cols must be one column and row less than board, got {arith_cols.shape} for {board.shape}'
-            assert all(isinstance(c.item(), str) and c.item() in [' ', 'x', '='] for c in np.nditer(arith_cols)), 'arith_cols must contain only space, x, or ='
         self.arith_rows = arith_rows
         self.arith_cols = arith_cols
         self.force_unique = force_unique
+        self.disallow_three = disallow_three
 
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
-
         self.create_vars()
         self.add_all_constraints()
 
@@ -39,11 +34,9 @@ class Board:
 
     def add_all_constraints(self):
         for pos in get_all_pos(self.V, self.H):  # force clues
-            c = get_char(self.board, pos)
-            if c == 'B':
-                self.model.Add(self.model_vars[pos] == 1)
-            elif c == 'W':
-                self.model.Add(self.model_vars[pos] == 0)
+            c = get_char(self.board, pos).strip()
+            if c:
+                self.model.Add(self.model_vars[pos] == (c == 'B'))
         # 1. Each row and each column must contain an equal number of white and black circles.
         for row in range(self.V):
             row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.H)]
@@ -51,69 +44,48 @@ class Board:
         for col in range(self.H):
             col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.V)]
             self.model.Add(lxp.sum(col_vars) == len(col_vars) // 2)
-        # 2. More than two circles of the same color can't be adjacent.
-        for pos in get_all_pos(self.V, self.H):
-            self.disallow_three_in_a_row(pos, Direction.RIGHT)
-            self.disallow_three_in_a_row(pos, Direction.DOWN)
-
+        # 2. No three consecutive cells of the same color
+        if self.disallow_three:
+            for pos in get_all_pos(self.V, self.H):
+                self.disallow_three_in_a_row(pos, Direction.RIGHT)
+                self.disallow_three_in_a_row(pos, Direction.DOWN)
         # 3. Each row and column is unique.
         if self.force_unique:
-            # a list per row
             self.force_unique_double_list([[self.model_vars[pos] for pos in get_row_pos(row, self.H)] for row in range(self.V)])
-            # a list per column
             self.force_unique_double_list([[self.model_vars[pos] for pos in get_col_pos(col, self.V)] for col in range(self.H)])
-
         # if arithmetic is provided, add constraints for it
         if self.arith_rows is not None:
-            assert self.arith_rows.shape == (self.V, self.H-1), f'arith_rows must be one column less than board, got {self.arith_rows.shape} for {self.board.shape}'
-            for pos in get_all_pos(self.V, self.H-1):
-                c = get_char(self.arith_rows, pos)
-                if c == 'x':
-                    self.model.Add(self.model_vars[pos] != self.model_vars[get_next_pos(pos, Direction.RIGHT)])
-                elif c == '=':
-                    self.model.Add(self.model_vars[pos] == self.model_vars[get_next_pos(pos, Direction.RIGHT)])
+            self.force_arithmetic(self.arith_rows, Direction.RIGHT, self.V, self.H-1)
         if self.arith_cols is not None:
-            assert self.arith_cols.shape == (self.V-1, self.H), f'arith_cols must be one row less than board, got {self.arith_cols.shape} for {self.board.shape}'
-            for pos in get_all_pos(self.V-1, self.H):
-                c = get_char(self.arith_cols, pos)
-                if c == 'x':
-                    self.model.Add(self.model_vars[pos] != self.model_vars[get_next_pos(pos, Direction.DOWN)])
-                elif c == '=':
-                    self.model.Add(self.model_vars[pos] == self.model_vars[get_next_pos(pos, Direction.DOWN)])
-
+            self.force_arithmetic(self.arith_cols, Direction.DOWN, self.V-1, self.H)
 
     def disallow_three_in_a_row(self, p1: Pos, direction: Direction):
         p2 = get_next_pos(p1, direction)
         p3 = get_next_pos(p2, direction)
-        if any(not in_bounds(p, self.V, self.H) for p in [p1, p2, p3]):
-            return
-        self.model.AddBoolOr([
-            self.model_vars[p1],
-            self.model_vars[p2],
-            self.model_vars[p3],
-        ])
-        self.model.AddBoolOr([
-            self.model_vars[p1].Not(),
-            self.model_vars[p2].Not(),
-            self.model_vars[p3].Not(),
-        ])
+        if all(in_bounds(p, self.V, self.H) for p in [p1, p2, p3]):
+            self.model.AddBoolOr([self.model_vars[p1], self.model_vars[p2], self.model_vars[p3]])
+            self.model.AddBoolOr([self.model_vars[p1].Not(), self.model_vars[p2].Not(), self.model_vars[p3].Not()])
 
     def force_unique_double_list(self, model_vars: list[list[cp_model.IntVar]]):
-        if not model_vars or len(model_vars) < 2:
-            return
         m = len(model_vars[0])
-        assert m <= 61, f"Too many cells for binary encoding in int64: m={m}, model_vars={model_vars}"
-
+        assert m <= 61, f'Too many cells for binary encoding in int64: m={m}, model_vars={model_vars}'
         codes = []
-        pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
+        pow2 = [2**k for k in range(m)]
         for i, line in enumerate(model_vars):
-            code = self.model.NewIntVar(0, (1 << m) - 1, f"code_{i}")
-            # Sum 2^k * r[k] == code
-            self.model.Add(code == sum(pow2[k] * line[k] for k in range(m)))
+            code = self.model.NewIntVar(0, 2**m, f"code_{i}")
+            self.model.Add(code == lxp.weighted_sum(line, pow2))  # Sum 2^k * r[k] == code
             codes.append(code)
-
         self.model.AddAllDifferent(codes)
 
+    def force_arithmetic(self, arith_board: np.array, direction: Direction, V: int, H: int):
+        assert arith_board.shape == (V, H), f'arith_board going {direction} expected shape {V}x{H}, got {arith_board.shape}'
+        for pos in get_all_pos(V, H):
+            c = get_char(arith_board, pos).strip()
+            if c == 'x':
+                self.model.Add(self.model_vars[pos] != self.model_vars[get_next_pos(pos, direction)])
+            elif c == '=':
+                self.model.Add(self.model_vars[pos] == self.model_vars[get_next_pos(pos, direction)])
+
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, int] = {}

puzzle_solver/puzzles/flip/flip.py

@@ -3,8 +3,18 @@ from typing import Any, Optional
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, set_char, get_char, Direction, get_next_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_char, Direction, get_next_pos, get_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def _to_pos(pos: Pos, s: str) -> Pos:
+    d = {'L': Direction.LEFT, 'R': Direction.RIGHT, 'U': Direction.UP, 'D': Direction.DOWN}[s[0]]
+    r = get_next_pos(pos, d)
+    if len(s) == 1:
+        return r
+    else:
+        return _to_pos(r, s[1:])
 
 
 class Board:
@@ -13,7 +23,6 @@ class Board:
         assert all((c.item() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only B or W'
         self.board = board
         self.V, self.H = board.shape
-
         if random_mapping is None:
             self.tap_mapping: dict[Pos, set[Pos]] = {pos: list(get_neighbors4(pos, self.V, self.H, include_self=True)) for pos in get_all_pos(self.V, self.H)}
         else:
@@ -21,13 +30,6 @@ class Board:
             if isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], Pos):
                 self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
             elif isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], str):  # strings like "L", "UR", etc.
-                def _to_pos(pos: Pos, s: str) -> Pos:
-                    d = {'L': Direction.LEFT, 'R': Direction.RIGHT, 'U': Direction.UP, 'D': Direction.DOWN}[s[0]]
-                    r = get_next_pos(pos, d)
-                    if len(s) == 1:
-                        return r
-                    else:
-                        return _to_pos(r, s[1:])
                 self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(_to_pos(pos, s) for s in random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
             else:
                 raise ValueError(f'invalid random_mapping: {random_mapping}')
@@ -35,10 +37,8 @@ class Board:
                 if k not in v:
                     v.add(k)
 
-
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
-
         self.create_vars()
         self.add_all_constraints()
 
@@ -49,29 +49,16 @@ class Board:
     def add_all_constraints(self):
         for pos in get_all_pos(self.V, self.H):
             # the state of a position is its starting state + if it is tapped + if any pos pointing to it is tapped
-            c = get_char(self.board, pos)
             pos_that_will_turn_me = [k for k,v in self.tap_mapping.items() if pos in v]
             literals = [self.model_vars[p] for p in pos_that_will_turn_me]
-            if c == 'W':  # if started as white then needs an even number of taps while xor checks for odd number
+            if get_char(self.board, pos) == 'W':  # if started as white then needs an even number of taps while xor checks for odd number
                 literals.append(self.model.NewConstant(True))
-            elif c == 'B':
-                pass
-            else:
-                raise ValueError(f'invalid character: {c}')
             self.model.AddBoolXOr(literals)
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for pos, var in board.model_vars.items():
-                assignment[pos] = solver.Value(var)
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
         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):
-                c = get_char(self.board, pos)
-                c = 'T' if single_res.assignment[pos] == 1 else ' '
-                set_char(res, pos, c)
-            print(res)
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/n_queens/n_queens.py

@@ -0,0 +1,81 @@
+from collections import defaultdict
+from typing import Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_pos, get_row_pos, get_col_pos, Direction8, in_bounds, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def get_ray(pos: Pos, direction: Direction8, V: int, H: int) -> list[Pos]:
+    out = []
+    while True:
+        out.append(pos)
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, V, H):
+            break
+    return out
+
+
+class Board:
+    def __init__(self, board: np.array, id_to_count: Optional[dict[int, int]] = None):
+        """
+        board is a 2d array of location ids
+        id_to_count is a dict of int to int, where the key is the id of the location and the value is the count of the queens on that location
+        """
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only digits'
+        assert id_to_count is None or (isinstance(id_to_count, dict) and all(isinstance(k, int) and isinstance(v, int) for k, v in id_to_count.items())), 'id_to_count must be a dict of int to int'
+        self.board = board
+        self.V, self.H = board.shape
+        self.location_ids = set([int(c.item()) for c in np.nditer(board)])
+        self.location_ids_to_pos: dict[int, set[Pos]] = defaultdict(set)
+        for pos in get_all_pos(self.V, self.H):
+            self.location_ids_to_pos[int(get_char(self.board, pos))].add(pos)
+        self.id_to_count = id_to_count
+        if self.id_to_count is None:
+            self.id_to_count = {id_: 1 for id_ in self.location_ids}
+
+        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.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        # every row has at most one queen
+        for row in range(self.V):
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in get_row_pos(row, self.H)]) <= 1)
+        # every column has at most one queen
+        for col in range(self.H):
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in get_col_pos(col, self.V)]) <= 1)
+        # every diagonal has at most one queen
+        for pos in get_col_pos(0, self.V):  # down-right diagonal on left border
+            ray = get_ray(pos, Direction8.DOWN_RIGHT, self.V, self.H)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        for pos in get_row_pos(0, self.H):  # down-right diagonal on top border
+            ray = get_ray(pos, Direction8.DOWN_RIGHT, self.V, self.H)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        for pos in get_row_pos(0, self.H):  # down-left diagonal on top
+            ray = get_ray(pos, Direction8.DOWN_LEFT, self.V, self.H)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        for pos in get_col_pos(self.H - 1, self.V):  # down-left diagonal on right border
+            ray = get_ray(pos, Direction8.DOWN_LEFT, self.V, self.H)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        # every id has at most count queens
+        for id_ in self.location_ids:
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in self.location_ids_to_pos[id_]]) == self.id_to_count[id_])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/split_ends/split_ends.py

@@ -0,0 +1,94 @@
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Direction8, Pos, get_all_pos, get_char, get_neighbors8, get_pos, get_row_pos, get_col_pos, Direction, get_opposite_direction, get_next_pos, in_bounds
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item() in ['L', 'R', 'U', 'D', 'O', ' '] for c in np.nditer(board)), 'board must contain only L, R, U, D, O, or space'
+        self.STATES = list(Direction) + ['O']
+        self.board = board
+        self.V, self.H = board.shape
+        assert self.V == 6 and self.H == 6, f'board must be 6x6, got {self.V}x{self.H}'
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in self.STATES:
+                self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+            self.model.AddExactlyOne([self.model_vars[(pos, direction)] for direction in self.STATES])
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos)
+            c = {'L': Direction.LEFT, 'R': Direction.RIGHT, 'U': Direction.UP, 'D': Direction.DOWN, 'O': 'O'}.get(c, None)
+            if c is not None:
+                self.model.Add(self.model_vars[(pos, c)] == 1)
+        for row in range(self.V):  # each row, 1 of each direction and 2 O's
+            for direction in Direction:
+                self.model.AddExactlyOne([self.model_vars[(pos, direction)] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):  # each column, 1 of each direction and 2 O's
+            for direction in Direction:
+                self.model.AddExactlyOne([self.model_vars[(pos, direction)] for pos in get_col_pos(col, self.V)])
+        for pos in get_all_pos(self.V, self.H):
+            for direction in Direction:
+                self.apply_orientation_rule(pos, direction)
+
+    def apply_orientation_rule(self, pos: Pos, direction: Direction):
+        # if cell is direction (for example L), then the cell to its left must not be R, and the cell to its up-right and down-right must also not be R
+        # and the cell to its up-right cant be U and the cell to its down-right cant be D. You have to see the triangles visually for it to make sense.
+        assert direction in Direction, f'direction must be in Direction, got {direction}'
+        if direction == Direction.LEFT:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.LEFT), Direction.RIGHT),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.RIGHT),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.RIGHT),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.UP),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.DOWN),
+            ]
+        elif direction == Direction.RIGHT:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.RIGHT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.UP),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.DOWN),
+            ]
+        elif direction == Direction.UP:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.UP), Direction.DOWN),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.DOWN),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.DOWN),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.RIGHT),
+            ]
+        elif direction == Direction.DOWN:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.DOWN), Direction.UP),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.UP),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.UP),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.RIGHT),
+            ]
+        else:
+            raise ValueError(f'invalid direction: {direction}')
+        disallow_pairs = [d_pair for d_pair in disallow_pairs if in_bounds(d_pair[0], self.V, self.H)]
+        for d_pos, d_direction in disallow_pairs:
+            self.model.Add(self.model_vars[(d_pos, d_direction)] == 0).OnlyEnforceIf(self.model_vars[(pos, direction)])
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: 'O' if direction == 'O' else direction.name[0] for (pos, direction), var in board.model_vars.items() if solver.Value(var) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), ' ')))
+        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

@@ -119,15 +119,19 @@ def main(image):
     horizontal_idx, vertical_idx = extract_lines(bw)
     horizontal_idx = mean_consecutives(horizontal_idx)
     vertical_idx = mean_consecutives(vertical_idx)
+    mean_vertical_dist = np.mean(np.diff(vertical_idx))
+    mean_horizontal_dist = np.mean(np.diff(horizontal_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 = {'top': arr.copy(), 'left': arr.copy(), 'right': arr.copy(), 'bottom': arr.copy()}
     hists = {'top': {}, 'left': {}, 'right': {}, 'bottom': {}}
+    j_idx = 0
+    i_len = 0
+    j_len = 0
     for j in range(height - 1):
+        i_idx = 0
         for i in range(width - 1):
             hidx1, hidx2 = horizontal_idx[j], horizontal_idx[j+1]
             vidx1, vidx2 = vertical_idx[i], vertical_idx[i+1]
@@ -135,7 +139,11 @@ def main(image):
             hidx2 = min(src.shape[0], hidx2 + 4)
             vidx1 = max(0, vidx1 - 2)
             vidx2 = min(src.shape[1], vidx2 + 4)
+            if (hidx2 - hidx1) < mean_horizontal_dist * 0.5 or (vidx2 - vidx1) < mean_vertical_dist * 0.5:
+                continue
+            print(f"j_idx: {j_idx}, i_idx: {i_idx}")
             cell = src[hidx1:hidx2, vidx1:vidx2]
+            # print(f"cell_shape: {cell.shape}, mean_horizontal_dist: {mean_horizontal_dist}, mean_vertical_dist: {mean_vertical_dist}")
             mid_x = cell.shape[1] // 2
             mid_y = cell.shape[0] // 2
             # if j > height - 4 and i > width - 6:
@@ -143,13 +151,18 @@ def main(image):
             # show_wait_destroy(f"cell_{i}_{j}", cell)
             cell = cv.bitwise_not(cell)  # invert colors
             top = cell[0:10, mid_y-5:mid_y+5]
-            hists['top'][j, i] = np.sum(top)
+            hists['top'][j_idx, i_idx] = np.sum(top)
             left = cell[mid_x-5:mid_x+5, 0:10]
-            hists['left'][j, i] = np.sum(left)
+            hists['left'][j_idx, i_idx] = np.sum(left)
             right = cell[mid_x-5:mid_x+5, -10:]
-            hists['right'][j, i] = np.sum(right)
+            hists['right'][j_idx, i_idx] = np.sum(right)
             bottom = cell[-10:, mid_y-5:mid_y+5]
-            hists['bottom'][j, i] = np.sum(bottom)
+            hists['bottom'][j_idx, i_idx] = np.sum(bottom)
+            i_idx += 1
+            i_len = max(i_len, i_idx)
+        if i_idx > 0:
+            j_idx += 1
+        j_len = max(j_len, j_idx)
 
     fig, axs = plt.subplots(2, 2)
     axs[0, 0].hist(list(hists['top'].values()), bins=100)
@@ -178,9 +191,11 @@ def main(image):
     axs[1, 1].axvline(target_bottom, color='red')
     # plt.show()
     # 1/0
-    print(f"target_top: {target_top}, target_left: {target_left}, target_right: {target_right}, target_bottom: {target_bottom}")
-    for j in range(height - 1):
-        for i in range(width - 1):
+    arr = np.zeros((j_len, i_len), dtype=object)
+    output = {'top': arr.copy(), 'left': arr.copy(), 'right': arr.copy(), 'bottom': arr.copy()}
+    print(f"target_top: {target_top}, target_left: {target_left}, target_right: {target_right}, target_bottom: {target_bottom}, j_len: {j_len}, i_len: {i_len}")
+    for j in range(j_len):
+        for i in range(i_len):
             if hists['top'][j, i] > target_top:
                 output['top'][j, i] = 1
             if hists['left'][j, i] > target_left:
@@ -244,5 +259,8 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')
     # main(Path(__file__).parent / 'input_output' / 'heyawake_MDoxNiwxNDQ=.png')
     # main(Path(__file__).parent / 'input_output' / 'heyawake_MTQ6ODQ4LDEzOQ==.png')
-    main(Path(__file__).parent / 'input_output' / 'sudoku_jigsaw.png')
+    # main(Path(__file__).parent / 'input_output' / 'sudoku_jigsaw.png')
+    # main(Path(__file__).parent / 'input_output' / 'Screenshot 2025-11-01 025846.png')
+    # main(Path(__file__).parent / 'input_output' / 'Screenshot 2025-11-01 035658.png')
+    main(Path(__file__).parent / 'input_output' / 'Screenshot 2025-11-01 044110.png')