multi-puzzle-solver 0.9.5__py3-none-any.whl → 0.9.7__py3-none-any.whl

{multi_puzzle_solver-0.9.5.dist-info → multi_puzzle_solver-0.9.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.5
+Version: 0.9.7
 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
@@ -242,6 +242,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/battleships_solved.png" alt="Battleships" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#kakurasu-puzzle-type-30"><b>Kakurasu</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/kakurasu_solved.png" alt="Kakurasu" width="140">
+    </a>
+  </td>
+</tr>
+<tr>
+  <td align="center">
+    <a href="#star-battle-puzzle-type-31"><b>Star Battle</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/star_battle_unsolved.png" alt="Star Battle" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -286,6 +298,8 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Aquarium (Puzzle Type #27)](#aquarium-puzzle-type-27)
   - [Stitches (Puzzle Type #28)](#stitches-puzzle-type-28)
   - [Battleships (Puzzle Type #29)](#battleships-puzzle-type-29)
+  - [Kakurasu (Puzzle Type #30)](#kakurasu-puzzle-type-30)
+  - [Star Battle (Puzzle Type #31)](#star-battle-puzzle-type-31)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -2439,6 +2453,165 @@ Time taken: 0.12 seconds
 
 ---
 
+## Kakurasu (Puzzle Type #30)
+
+* [**Play online**](https://www.puzzle-kakurasu.com/)
+
+* [**Solver Code**][30]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+The goal is to make some of the cells black in such a way that:
+
+1. The black cells on each row sum up to the number on the right.
+
+2. The black cells on each column sum up to the number on the bottom.
+
+3. If a black cell is first on its row/column its value is 1. If it is second its value is 2 etc. 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/kakurasu_unsolved.png" alt="Kakurasu unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+from puzzle_solver import kakurasu_solver as solver
+side = np.array([27, 6, 1, 12, 37, 37, 11, 4, 29, 23, 66, 55])
+bottom = np.array([22, 1, 25, 36, 10, 22, 25, 35, 32, 28, 45, 45])
+binst = solver.Board(side=side, bottom=bottom)
+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']]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.00 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/kakurasu_solved.png" alt="Kakurasu solved" width="500">
+
+---
+
+## Star Battle (Puzzle Type #31)
+
+* [**Play online**](https://www.puzzle-star-battle.com/)
+
+* [**Solver Code**][31]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+ You have to place stars on the grid according to the rules:
+- 2 stars cannot be adjacent horizontally, vertically or diagonally.
+- For 1★ puzzles, you have to place 1 star on each row, column and shape.
+- For 2★ puzzles, the stars per row, column and shape must be 2 etc.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/star_battle_unsolved.png" alt="Star Battle unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+Note that as usual the board is an id of the shape (id is meaningless, just used to identify one shape), and the star_count parameter depenends on the puzzle type.
+
+```python
+from puzzle_solver import star_battle_solver as solver
+  board = np.array([
+    ['00', '00', '00', '00', '00', '01', '01', '01', '01', '01', '01', '01', '01', '01', '02', '02', '02', '03', '03', '03', '03', '03', '03', '03', '03'],
+    ['00', '01', '00', '01', '01', '01', '01', '01', '01', '01', '04', '04', '01', '02', '02', '02', '02', '05', '05', '05', '05', '05', '05', '03', '03'],
+    ['00', '01', '01', '01', '01', '01', '01', '01', '01', '04', '04', '04', '04', '04', '02', '02', '05', '05', '05', '05', '05', '05', '03', '03', '03'],
+    ['00', '01', '06', '04', '04', '04', '04', '04', '04', '04', '04', '04', '04', '04', '02', '05', '05', '05', '05', '05', '05', '05', '03', '07', '03'],
+    ['00', '01', '06', '06', '06', '06', '06', '06', '06', '04', '04', '04', '04', '02', '02', '02', '02', '02', '05', '05', '05', '05', '05', '07', '03'],
+    ['00', '00', '08', '06', '09', '09', '09', '09', '06', '04', '04', '04', '04', '02', '02', '02', '02', '02', '05', '05', '05', '05', '07', '07', '07'],
+    ['00', '08', '08', '08', '08', '09', '09', '06', '06', '06', '04', '04', '04', '04', '02', '02', '02', '05', '05', '05', '07', '07', '07', '07', '07'],
+    ['00', '00', '08', '08', '08', '09', '09', '09', '09', '06', '10', '10', '10', '10', '02', '02', '02', '05', '11', '11', '11', '11', '07', '07', '07'],
+    ['08', '08', '08', '08', '09', '09', '09', '09', '09', '09', '10', '10', '10', '02', '02', '02', '02', '11', '11', '11', '11', '11', '11', '07', '11'],
+    ['08', '08', '08', '08', '09', '09', '09', '09', '09', '10', '10', '10', '10', '02', '02', '02', '11', '11', '11', '11', '11', '11', '11', '07', '11'],
+    ['08', '08', '08', '09', '09', '09', '09', '09', '10', '10', '10', '10', '10', '12', '12', '12', '12', '11', '11', '11', '11', '11', '11', '11', '11'],
+    ['08', '08', '09', '09', '09', '09', '09', '08', '10', '10', '10', '10', '10', '10', '10', '10', '12', '11', '11', '11', '11', '13', '11', '13', '11'],
+    ['14', '08', '08', '08', '08', '08', '08', '08', '10', '10', '10', '10', '10', '12', '12', '12', '12', '12', '11', '11', '11', '13', '11', '13', '15'],
+    ['14', '14', '14', '14', '16', '08', '16', '16', '17', '10', '10', '10', '10', '10', '10', '10', '10', '12', '13', '13', '13', '13', '13', '13', '15'],
+    ['14', '14', '14', '14', '16', '16', '16', '16', '17', '10', '10', '18', '18', '10', '19', '10', '12', '12', '13', '15', '15', '15', '15', '15', '15'],
+    ['14', '14', '14', '14', '14', '16', '16', '17', '17', '18', '18', '18', '19', '19', '19', '10', '10', '10', '13', '15', '15', '15', '15', '15', '15'],
+    ['14', '14', '14', '16', '16', '16', '16', '17', '18', '18', '20', '20', '19', '21', '19', '19', '19', '19', '13', '15', '15', '15', '15', '15', '15'],
+    ['14', '16', '16', '16', '16', '16', '16', '17', '18', '18', '20', '21', '21', '21', '21', '19', '21', '19', '15', '15', '21', '15', '15', '15', '15'],
+    ['14', '14', '14', '16', '16', '17', '17', '17', '18', '20', '20', '21', '20', '21', '21', '19', '21', '19', '15', '21', '21', '15', '15', '15', '15'],
+    ['14', '14', '14', '16', '16', '16', '17', '17', '18', '18', '20', '20', '20', '20', '21', '21', '21', '21', '21', '21', '15', '15', '22', '22', '15'],
+    ['14', '14', '14', '14', '23', '16', '17', '20', '18', '20', '20', '20', '20', '20', '20', '21', '24', '24', '24', '21', '15', '15', '22', '15', '15'],
+    ['14', '14', '14', '14', '23', '20', '17', '20', '18', '20', '20', '20', '20', '24', '24', '24', '24', '24', '24', '21', '15', '22', '22', '22', '15'],
+    ['14', '23', '23', '14', '23', '20', '20', '20', '18', '20', '20', '20', '20', '24', '24', '24', '24', '24', '24', '24', '24', '24', '24', '22', '15'],
+    ['14', '23', '14', '14', '23', '20', '23', '20', '18', '20', '20', '20', '20', '24', '24', '24', '24', '24', '24', '24', '22', '22', '22', '22', '22'],
+    ['14', '23', '23', '23', '23', '23', '23', '20', '20', '20', '20', '20', '20', '24', '24', '24', '24', '24', '24', '24', '24', '24', '24', '24', '24']
+  ])
+  binst = solver.Board(board=board, star_count=6)
+  solutions = binst.solve_and_print()
+```
+
+
+**Script Output**
+
+```python
+Solution found
+[' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' '],
+['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' '],
+[' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' '],
+['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'],
+[' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' '],
+[' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'],
+[' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' '],
+[' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'],
+[' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' '],
+[' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' '],
+[' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' '],
+['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' '],
+[' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' '],
+['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' '],
+[' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' '],
+[' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*'],
+[' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' '],
+[' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*'],
+[' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' '],
+[' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' '],
+[' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
+[' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*'],
+[' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.38 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/star_battle_solved.png" alt="Star Battle solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -2519,3 +2692,5 @@ Issues and PRs welcome!
 [27]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/aquarium "puzzle_solver/src/puzzle_solver/puzzles/aquarium at master · Ar-Kareem/puzzle_solver · GitHub"
 [28]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/stitches "puzzle_solver/src/puzzle_solver/puzzles/stitches at master · Ar-Kareem/puzzle_solver · GitHub"
 [29]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/battleships "puzzle_solver/src/puzzle_solver/puzzles/battleships at master · Ar-Kareem/puzzle_solver · GitHub"
+[30]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/kakurasu "puzzle_solver/src/puzzle_solver/puzzles/kakurasu at master · Ar-Kareem/puzzle_solver · GitHub"
+[31]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/star_battle "puzzle_solver/src/puzzle_solver/puzzles/star_battle at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.9.5.dist-info → multi_puzzle_solver-0.9.7.dist-info}/RECORD

@@ -1,41 +1,43 @@
-puzzle_solver/__init__.py,sha256=1PIodDzUT4ZJ0dIhb2cspUjjsun4qeycBueNkEC6ugA,2118
+puzzle_solver/__init__.py,sha256=u2RjFlPKYXFnsdHoh7Lo_0Gm99QAv_qv03fOF64Dsag,2269
 puzzle_solver/core/utils.py,sha256=3LlBDuie_G0uSlzibpQS2ULmEYSZmpJXh1kawj7rjkg,3396
 puzzle_solver/core/utils_ortools.py,sha256=qLTIzmITqmgGZvg8XpYAZ4c-lhD5sEDQfS8ECdQ_dkM,3005
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
-puzzle_solver/puzzles/battleships/battleships.py,sha256=0jwDR-bv6EHo8QTDZZ18WzShc7ohYtSSZw_DXh8y5lw,7483
-puzzle_solver/puzzles/bridges/bridges.py,sha256=zUT0TMIu8l982fqDMJfsTnTgqm48nG0iH8flsGT45_E,5489
-puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=KnfD_Sxd8bso46eQYpIemp4MIqOUNoonyRVe6soK8kc,231
-puzzle_solver/puzzles/chess_range/chess_range.py,sha256=IaldwJR4d0VAUxME2QyvtJdUNzGzDV0FGs1iq9KqsRU,21072
+puzzle_solver/puzzles/battleships/battleships.py,sha256=J1Y-zG2TOmJePCwQnUF8uE9cXL5v8GDVEGv30bQls6k,7467
+puzzle_solver/puzzles/bridges/bridges.py,sha256=15A9uV4xjoqPRo_9CTnoKeGRxS3z2aMF619T1n0dTOQ,5402
+puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=D-_Oi8OyxsVe1j3dIKYwRlxgeb3NWLmDWGcv-oclY0c,195
+puzzle_solver/puzzles/chess_range/chess_range.py,sha256=uMQGTIwzGskHIhI-tPYjT9a3wHUBIkZ18eXjV9IpUE4,21071
 puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=U3v766UsZHx_dC3gxqU90VbjAXn-OlYhtrnnvJYFvrQ,401
 puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
-puzzle_solver/puzzles/dominosa/dominosa.py,sha256=uh2vsba9HdSHGnYiYE8R_TZzQh5kge51Y1TMRyQlwek,7246
+puzzle_solver/puzzles/dominosa/dominosa.py,sha256=Nmb7pn8U27QJwGy9F3wo8ylqo2_U51OAo3GN2soaNpc,7195
 puzzle_solver/puzzles/filling/filling.py,sha256=UAkNYjlfxOrYGrRVmuElhWPeW10xD6kiWuB8oELzy3w,9141
-puzzle_solver/puzzles/guess/guess.py,sha256=w8ZE-0MswR1_e7_MX622OiCJ8fGTloRHblYFvSA4yHc,10812
-puzzle_solver/puzzles/inertia/inertia.py,sha256=xHtQ09sI7hqPcs20foz6YVMuYCsw59TZQxTumAKJuBs,5658
-puzzle_solver/puzzles/inertia/tsp.py,sha256=qMyT_W5vBmmaFUB7Cl9rC5xJNdAdQvIJEx6yxlbG9hw,15240
+puzzle_solver/puzzles/guess/guess.py,sha256=sH-NlYhxM3DNbhk4eGde09kgM0KaDvSbLrpHQiwcFGo,10791
+puzzle_solver/puzzles/inertia/inertia.py,sha256=gJBahkh69CrSWNscalKEoP1j4X-Q3XpbIBMiG9PUpU0,5657
+puzzle_solver/puzzles/inertia/tsp.py,sha256=6ZDxdg2f7GDsZeQpnSR2ay0-T4ZhTESJtkKMcm49OS0,15204
 puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=A9JQTNqamUdzlwqks0XQp3Hge3mzyTIVK6YtDJvqpL4,8422
+puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGphTTUDMC0TkQvQ,2064
 puzzle_solver/puzzles/keen/keen.py,sha256=tDb6C5S3Q0JAKPsdw-84WQ6PxRADELZHr_BK8FDH-NA,5039
 puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
 puzzle_solver/puzzles/magnets/magnets.py,sha256=-Wl49JD_PKeq735zQVMQ3XSQX6gdHiY-7PKw-Sh16jw,6474
 puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy3us,2582
-puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=TK2RSarbBpdhEmVjFydgvGPkLkjBM-a_JiOOmAA1OaU,5219
+puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=LiQVOGkWCsc1WtX8CdPgL_WwAcaeUFuoi5_eqH8U2Og,5876
 puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
 puzzle_solver/puzzles/nonograms/nonograms.py,sha256=1jmDTOCnmivmBlwtMDyyk3TVqH5IjapzLn7zLQ4qubk,6056
 puzzle_solver/puzzles/pearl/pearl.py,sha256=AP0whWwwZ-1zKingW14OwseYylNAr6NkXSrvdnPU6Rw,8566
 puzzle_solver/puzzles/range/range.py,sha256=g6ZuHuulYLpNFsqbnPoIB5KoGPllYppU10-Zzqfj5f8,6993
-puzzle_solver/puzzles/signpost/signpost.py,sha256=D19ua8rVwO6sgXq4nVLkZfEyz8hqc6qMOk3j-g44soU,3931
+puzzle_solver/puzzles/signpost/signpost.py,sha256=-0_S6ycwzwlUf9-ZhP127Rgo5gMBOHiTM6t08dLLDac,3869
 puzzle_solver/puzzles/singles/singles.py,sha256=kwMENfqQ-OP3YIz5baY6LRcvYCsNfhImEXN00lwazKM,5658
-puzzle_solver/puzzles/stitches/stitches.py,sha256=YvT9WXvUMPLcFGOYXWIPyifCi6caZqRqBTuCgNmcTPQ,6662
-puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=pUB9tG__u4Fq_RCFG_4NNq3LRKAa6FRrvuuL64cUIRM,8866
+puzzle_solver/puzzles/star_battle/star_battle.py,sha256=mNkxV68ejdjaGIZPC2LymfHk1i4T9XuAq1xUG7nnhMw,3192
+puzzle_solver/puzzles/stitches/stitches.py,sha256=iK8t02q43gH3FPbuIDn4dK0sbaOgZOnw8yHNRNvNuIU,6534
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=kbxTtJlfmE1IEA8Km3rALsfKXFl-0io1vd3d0Z-0OVo,8984
 puzzle_solver/puzzles/sudoku/sudoku.py,sha256=M_pry7XyKKzlfCF5rFi02lyOrj5GWZzXnDAxmD3NXvI,3588
 puzzle_solver/puzzles/tents/tents.py,sha256=iyVK2WXfIT5j_9qqlQg0WmwvixwXlZSsHGK3XA-KpII,6283
 puzzle_solver/puzzles/thermometers/thermometers.py,sha256=nsvJZkm7G8FALT27bpaB0lv5E_AWawqmvapQI8QcYXw,4015
 puzzle_solver/puzzles/towers/towers.py,sha256=QvL0Pp-Z2ewCeq9ZkNrh8MShKOh-Y52sFBSudve68wk,6496
-puzzle_solver/puzzles/tracks/tracks.py,sha256=VnAtxBkuUTHJYNXr1JGg0yYzJj3kRMBi8Nz7NHKS94A,9089
-puzzle_solver/puzzles/undead/undead.py,sha256=ygNugW5SOlYLy6d740gZ2IW9UJQ3SAr9vuMm0ZFr2nY,6630
+puzzle_solver/puzzles/tracks/tracks.py,sha256=0K1YZMHiRIMmFwoD_JxB2c_xB6GYV8spgNUCL-JwDJM,9073
+puzzle_solver/puzzles/undead/undead.py,sha256=IrCUfzQFBem658P5KKqldG7vd2TugTHehcwseCarerM,6604
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
 puzzle_solver/utils/visualizer.py,sha256=2LmNoxEqb9PGWmBmHW6jh6OqFgNYguavhHB-9Dv5EUw,6113
-multi_puzzle_solver-0.9.5.dist-info/METADATA,sha256=SZoYsEEiQ3rFfY54sI23v4X1BO86lJwOC6Wv2HIEakk,121887
-multi_puzzle_solver-0.9.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.5.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.5.dist-info/RECORD,,
+multi_puzzle_solver-0.9.7.dist-info/METADATA,sha256=7fMwUGqOwHaq_0hXWLuYPdPD0AYdwPDOVng23I2AwxI,133331
+multi_puzzle_solver-0.9.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.7.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.7.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -8,6 +8,7 @@ from puzzle_solver.puzzles.dominosa import dominosa as dominosa_solver
 from puzzle_solver.puzzles.filling import filling as filling_solver
 from puzzle_solver.puzzles.guess import guess as guess_solver
 from puzzle_solver.puzzles.inertia import inertia as inertia_solver
+from puzzle_solver.puzzles.kakurasu import kakurasu as kakurasu_solver
 from puzzle_solver.puzzles.keen import keen as keen_solver
 from puzzle_solver.puzzles.light_up import light_up as light_up_solver
 from puzzle_solver.puzzles.magnets import magnets as magnets_solver
@@ -19,6 +20,7 @@ from puzzle_solver.puzzles.pearl import pearl as pearl_solver
 from puzzle_solver.puzzles.range import range as range_solver
 from puzzle_solver.puzzles.signpost import signpost as signpost_solver
 from puzzle_solver.puzzles.singles import singles as singles_solver
+from puzzle_solver.puzzles.star_battle import star_battle as star_battle_solver
 from puzzle_solver.puzzles.stitches import stitches as stitches_solver
 from puzzle_solver.puzzles.sudoku import sudoku as sudoku_solver
 from puzzle_solver.puzzles.tents import tents as tents_solver
@@ -30,4 +32,4 @@ from puzzle_solver.puzzles.unruly import unruly as unruly_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.5'
+__version__ = '0.9.7'

puzzle_solver/puzzles/battleships/battleships.py

@@ -4,7 +4,7 @@ from typing import Optional
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors8, set_char, get_neighbors4, get_row_pos, get_col_pos, get_pos, in_bounds
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors8, set_char, get_row_pos, get_col_pos, get_pos, in_bounds
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, or_constraint
 
 @dataclass

puzzle_solver/puzzles/bridges/bridges.py

@@ -1,12 +1,10 @@
-import json
 from collections import defaultdict
-from dataclasses import dataclass
 
 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, set_char, get_neighbors8, get_next_pos, Direction, get_row_pos, get_col_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_row_pos, get_col_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 

puzzle_solver/puzzles/chess_range/chess_melee.py

@@ -1,5 +1,4 @@
 from .chess_range import Board as RangeBoard
-from .chess_range import PieceType
 
 class Board(RangeBoard):
     def __init__(self, pieces: list[str], colors: list[str]):

puzzle_solver/puzzles/chess_range/chess_range.py

@@ -9,7 +9,6 @@ from puzzle_solver.core.utils import Pos, get_pos
 from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, or_constraint
 
 
-
 class PieceType(Enum):
     KING   = 1
     QUEEN  = 2

puzzle_solver/puzzles/dominosa/dominosa.py

@@ -3,8 +3,8 @@ from collections import defaultdict
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_pos, get_all_pos, get_char, set_char, get_row_pos, get_col_pos, Direction, get_next_pos, in_bounds
-from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, or_constraint
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, Direction, get_next_pos, in_bounds
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, or_constraint
 
 
 def get_bool_var(model: cp_model.CpModel, var: cp_model.IntVar, eq_val: int, name: str) -> cp_model.IntVar:

puzzle_solver/puzzles/guess/guess.py

@@ -1,8 +1,9 @@
-from collections import defaultdict
-import numpy as np
-from collections import Counter
+from collections import Counter, defaultdict
 from itertools import product
 
+import numpy as np
+
+
 class Board:
     def __init__(self, num_pegs: int = 4, all_colors: list[str] = ['R', 'Y', 'G', 'B', 'O', 'P'], show_warnings: bool = True, show_progress: bool = False):
         assert num_pegs >= 1, 'num_pegs must be at least 1'

puzzle_solver/puzzles/inertia/inertia.py

@@ -3,7 +3,6 @@ from collections import defaultdict
 import numpy as np
 
 from puzzle_solver.core.utils import Direction8, Pos, get_all_pos, get_char, in_bounds, get_next_pos
-
 from . import tsp
 
 

puzzle_solver/puzzles/inertia/tsp.py

@@ -1,8 +1,10 @@
-from collections import deque, defaultdict
+from collections import defaultdict, deque
 from typing import Dict, List, Tuple, Set, Any, Optional
 import random
+
 from ortools.constraint_solver import pywrapcp, routing_enums_pb2
 
+
 Pos = Any  # Hashable node id
 
 def solve_optimal_walk(
@@ -81,7 +83,6 @@ def solve_optimal_walk(
         prev = {n: None for n in nodes}
         if src not in adj:
             return dist, prev
-        from collections import deque
         q = deque([src])
         dist[src] = 0
         while q:

puzzle_solver/puzzles/kakurasu/kakurasu.py

@@ -0,0 +1,46 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, side: np.array, bottom: np.array):
+        assert side.ndim == 1, f'side must be 1d, got {side.ndim}'
+        self.V = side.shape[0]
+        assert bottom.ndim == 1, f'bottom must be 1d, got {bottom.ndim}'
+        self.H = bottom.shape[0]
+        self.side = side
+        self.bottom = bottom
+
+        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):
+        for row in range(self.V):
+            self.model.Add(sum([self.model_vars[get_pos(x=col, y=row)] * (col + 1) for col in range(self.H)]) == self.side[row])
+        for col in range(self.H):
+            self.model.Add(sum([self.model_vars[get_pos(x=col, y=row)] * (row + 1) for row in range(self.V)]) == self.bottom[col])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                c = 'X' if single_res.assignment[pos] else ' '
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/minesweeper/minesweeper.py

@@ -1,5 +1,5 @@
 import time
-from typing import Union
+from typing import Union, Optional
 
 import numpy as np
 from ortools.sat.python import cp_model
@@ -10,7 +10,7 @@ from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 
 class Board:
-    def __init__(self, board: np.array, mine_count: int):
+    def __init__(self, board: np.array, mine_count: Optional[int] = None):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
         assert all(isinstance(i.item(), str) and (str(i.item()) in [' ', 'F', 'S', 'M', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']) for i in np.nditer(board)), 'board must be either F, S, M, 0-9 or space'
         self.board = board
@@ -28,7 +28,8 @@ class Board:
             self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
 
     def add_all_constraints(self):
-        self.model.Add(lxp.Sum(list(self.model_vars.values())) == self.mine_count)
+        if self.mine_count is not None:
+            self.model.Add(lxp.Sum(list(self.model_vars.values())) == self.mine_count)
         for pos in get_all_pos(self.V, self.H):
             c = get_char(self.board, pos)
             if c in ['F', ' ']:
@@ -55,7 +56,7 @@ def _is_feasible(board: np.array, pos: Pos = None, value: str = None, mine_count
         return SingleSolution(assignment={pos: solver.value(var) for pos, var in board.model_vars.items()})
     return len(generic_solve_all(board, board_to_solution, max_solutions=1, verbose=False)) >= 1
 
-def _is_safe(board: np.array, pos: Pos, mine_count: int) -> Union[bool, None]:
+def _is_safe(board: np.array, pos: Pos, mine_count: Optional[int] = None) -> Union[bool, None]:
     """Returns a True if the position is safe, False if it is a mine, otherwise None"""
     safe_feasible = _is_feasible(board, pos, 'S', mine_count=mine_count)
     mine_feasible = _is_feasible(board, pos, 'M', mine_count=mine_count)
@@ -67,7 +68,7 @@ def _is_safe(board: np.array, pos: Pos, mine_count: int) -> Union[bool, None]:
         return False
     raise ValueError(f"Position {pos} has both safe and mine infeasible")
 
-def give_next_guess(board: np.array, mine_count: int, verbose: bool = True):
+def give_next_guess(board: np.array, mine_count: Optional[int] = None, verbose: bool = True):
     tic = time.time()
     is_feasible = _is_feasible(board, mine_count=mine_count)
     if not is_feasible:
@@ -108,4 +109,16 @@ def give_next_guess(board: np.array, mine_count: int, verbose: bool = True):
             print('-'*10)
         toc = time.time()
         print(f"Time taken: {toc - tic:.2f} seconds")
-    return safe_positions, new_garuneed_mine_positions, wrong_flag_positions
+    return safe_positions, new_garuneed_mine_positions, wrong_flag_positions
+
+def print_board(board: np.array, safe_positions: set[Pos], new_garuneed_mine_positions: set[Pos], wrong_flag_positions: set[Pos]):
+    res = np.full((board.shape[0], board.shape[1]), ' ', dtype=object)
+    for pos in get_all_pos(board.shape[0], board.shape[1]):
+        if pos in safe_positions:
+            set_char(res, pos, 'S')
+        elif pos in new_garuneed_mine_positions:
+            set_char(res, pos, 'M')
+        elif get_char(board, pos) == 'F' and pos not in wrong_flag_positions:
+            set_char(res, pos, 'F')
+    
+    print(res)

puzzle_solver/puzzles/signpost/signpost.py

@@ -1,10 +1,8 @@
-from enum import Enum
-
 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, set_char, in_bounds, get_next_pos, Direction, get_row_pos, get_col_pos, Direction8
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, in_bounds, get_next_pos, Direction8
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 

puzzle_solver/puzzles/star_battle/star_battle.py

@@ -0,0 +1,63 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_neighbors8, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, board: np.array, star_count: int = 1):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] == board.shape[1], 'board must be square'
+        assert star_count >= 1 and isinstance(star_count, int), 'star_count must be an integer greater than or equal to 1'
+        assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
+        self.board = board
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.N = self.V * self.H
+        self.star_count = star_count
+        self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
+        self.blocks = {i: [pos for pos in get_all_pos(self.V, self.H) if int(get_char(self.board, pos)) == i] for i in self.block_numbers}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+
+        self.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):
+        # N stars per row / column / block
+        for row in range(self.V):
+            self.model.Add(sum(self.model_vars[pos] for pos in get_row_pos(row, H=self.H)) == self.star_count)
+        for col in range(self.H):
+            self.model.Add(sum(self.model_vars[pos] for pos in get_col_pos(col, V=self.V)) == self.star_count)
+        for block_i in self.block_numbers:
+            self.model.Add(sum(self.model_vars[pos] for pos in self.blocks[block_i]) == self.star_count)
+        # stars cant be adjacent
+        for pos in get_all_pos(self.V, self.H):
+            for neighbor in get_neighbors8(pos, V=self.V, H=self.H):
+                self.model.Add(self.model_vars[neighbor] == 0).OnlyEnforceIf(self.model_vars[pos])
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                c = '*' if single_res.assignment[pos] == 1 else ' '
+                set_char(res, pos, c)
+            for row in range(self.V):
+                print(res[row].tolist(), end='')
+                if row != self.V - 1:
+                    print(',', end='')
+                print()
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -207,4 +207,5 @@ if __name__ == '__main__':
     # to run this script and visualize the output, in the root run:
     #  python .\src\puzzle_solver\puzzles\stitches\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
     # main(Path(__file__).parent / 'input_output' / 'MTM6OSw4MjEsNDAx.png')
-    main(Path(__file__).parent / 'input_output' / 'weekly_oct_3rd_2025.png')
+    # main(Path(__file__).parent / 'input_output' / 'weekly_oct_3rd_2025.png')
+    main(Path(__file__).parent / 'input_output' / 'star_battle_67f73ff90cd8cdb4b3e30f56f5261f4968f5dac940bc6.png')

puzzle_solver/puzzles/stitches/stitches.py

@@ -1,11 +1,9 @@
-from collections import defaultdict
 from typing import Union
 
 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_neighbors4, set_char, get_neighbors8, get_next_pos, Direction, get_row_pos, get_col_pos, in_bounds, get_opposite_direction
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_next_pos, Direction, get_row_pos, get_col_pos, in_bounds, get_opposite_direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint
 
 

puzzle_solver/puzzles/tracks/tracks.py

@@ -2,7 +2,7 @@ from collections import defaultdict
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char, get_neighbors4, Direction, in_bounds, get_next_pos, get_row_pos, get_col_pos, get_opposite_direction
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char, Direction, in_bounds, get_next_pos, get_row_pos, get_col_pos, get_opposite_direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint, or_constraint
 
 

puzzle_solver/puzzles/undead/undead.py

@@ -6,7 +6,7 @@ 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, set_char, get_pos, get_next_pos, in_bounds, get_char, Direction, get_row_pos, get_col_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_pos, get_next_pos, in_bounds, get_char, Direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution