multi-puzzle-solver 0.9.30__py3-none-any.whl → 1.0.2__py3-none-any.whl

multi_puzzle_solver-1.0.2.dist-info/RECORD

@@ -0,0 +1,69 @@
+puzzle_solver/__init__.py,sha256=Ll-qN1ElCTTILeun1u4t5dU0CdI3DkCX0ZNf0Q2UJtE,4886
+puzzle_solver/core/utils.py,sha256=XBW5j-IwtJMPMP-ycmY6SqRCM1NOVl5O6UeoGqNj618,8153
+puzzle_solver/core/utils_ortools.py,sha256=ACV3HgKWpEUTt1lpqsPryK1DeZpu7kdWQKEWTLJ2tfs,10384
+puzzle_solver/core/utils_visualizer.py,sha256=ymuhF75uwJbNhN8XVDYEPqw6sPKoqRaaxlhGeHtXpLs,20201
+puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
+puzzle_solver/puzzles/battleships/battleships.py,sha256=RuYCrs4j0vUjlU139NRYYP-uNPAgO0V7hAzbsHrRwD8,7446
+puzzle_solver/puzzles/binairo/binairo.py,sha256=NmVPIoyVCoMLaSFhsN0TcJQYvav9hi4hSwoAVirYhDU,6835
+puzzle_solver/puzzles/binairo/binairo_plus.py,sha256=TvLG3olwANtft3LuCF-y4OofpU9PNa4IXDqgZqsD-g0,267
+puzzle_solver/puzzles/black_box/black_box.py,sha256=EiCVkbhUP0x94otvQirv7MrggTu0ok8MIUPbxv6jkIU,15544
+puzzle_solver/puzzles/bridges/bridges.py,sha256=QwOhZyO5urbatkNyPmQxZ_lGM01ZejndMr_eoiBkr7g,5394
+puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=D-_Oi8OyxsVe1j3dIKYwRlxgeb3NWLmDWGcv-oclY0c,195
+puzzle_solver/puzzles/chess_range/chess_range.py,sha256=_VHlpUPnqeBstvSIt9RtTV-w2etSK7UrEHg6sErNqtU,21068
+puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=ByDfcRsk5FVmFicpU_DpLoLTJ99Kr___vX4y8ln8_EQ,400
+puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
+puzzle_solver/puzzles/dominosa/dominosa.py,sha256=Nmb7pn8U27QJwGy9F3wo8ylqo2_U51OAo3GN2soaNpc,7195
+puzzle_solver/puzzles/filling/filling.py,sha256=R8UIbztk3zNCeNbVClBJoKZHKeHwK_pesjGmMaEEQO0,5536
+puzzle_solver/puzzles/flip/flip.py,sha256=ZngJLUhRNc7qqo2wtNLdMPx4u9w9JTUge27PmdXyDCw,3985
+puzzle_solver/puzzles/flood_it/flood_it.py,sha256=jnCtH1sZIt6K4hbQDSsiM1Cd8FjQNP7cfw2ObUW5fEQ,7948
+puzzle_solver/puzzles/flood_it/parse_map/parse_map.py,sha256=0aw1TbiyxknY2hUAXaP3nXqT6I6mT9BIiERJSCj57xw,8245
+puzzle_solver/puzzles/galaxies/galaxies.py,sha256=36X9jaQfvLIWFkBY1VZH6I59eCDkc77U06NDtKRUECY,5571
+puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=XmFqVN_oRfq9AZFWy5ViUJ2Szjgx-srrRkFPJXEEyFo,9358
+puzzle_solver/puzzles/guess/guess.py,sha256=MpyrF6YVu0S1fzX-BllwxGKRGacWJpeLbNn5GetuEyo,10792
+puzzle_solver/puzzles/heyawake/heyawake.py,sha256=L_y44dHArOvO_tDyO35dwkvqdk9eEGItO7n4FDfzNDc,5586
+puzzle_solver/puzzles/inertia/inertia.py,sha256=-Y5fr7aK20zwmGHsZql7pYCq1kyMZglvkVZ6uIDf1HA,5658
+puzzle_solver/puzzles/inertia/tsp.py,sha256=mAhlSjCWespASeN8uLZ0JkYDw-ZqFEpal6NM-ubpCXw,15313
+puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=x0d64gTBd0HC2lO5uOpX2VKWfwj8rRiz0mQM_lqNmWs,8457
+puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGphTTUDMC0TkQvQ,2064
+puzzle_solver/puzzles/kakuro/kakuro.py,sha256=m22Ju-V2BdQl2Ng_pjVUSrxPCtIfqezdpebutURlhvg,4348
+puzzle_solver/puzzles/keen/keen.py,sha256=adSA_pc1m6F6jV7a-PpQxdci1bv4psCNRNt9hMIQdSY,5034
+puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
+puzzle_solver/puzzles/lits/lits.py,sha256=3fPIkhAIUz8JokcfaE_ZM3b0AFEnf5xPzGJ2qnm8SWY,7099
+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=gSdFsuZ-KrwVxgI1HF2q_pYleZ6vBm9jjRTFlboVnLY,5871
+puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
+puzzle_solver/puzzles/nonograms/nonograms.py,sha256=dTKfMwBL49hW3bNd34ETXW7lBRPuQeSPNSCHqHmfybg,6066
+puzzle_solver/puzzles/norinori/norinori.py,sha256=qR7V7NbZRN_ME90R2jL47AkGik1CY6JlAPhLBMXP2Gw,4714
+puzzle_solver/puzzles/nurikabe/nurikabe.py,sha256=3cbW7X4kAMQK8PkH_t65fzT5cI0O6tWWOqpQUVyuGT4,6501
+puzzle_solver/puzzles/palisade/palisade.py,sha256=T-LXlaLU5OwUQ24QWJWhBUFUktg0qDODTilNmBaXs4I,5014
+puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5omYLChM,6798
+puzzle_solver/puzzles/range/range.py,sha256=q0J3crlGfjYZSA6Dh4iMCwP_gRMWid-_8KPgggOrFKk,4410
+puzzle_solver/puzzles/rectangles/rectangles.py,sha256=MgOhZJGr9DVHb9bB8EAuwus0_8frBqRWqMwrOvMezHQ,6918
+puzzle_solver/puzzles/shakashaka/shakashaka.py,sha256=PRpg_qI7XA3ysAo_g1TRJsT3VwB5Vial2UcFyBOMwKQ,9571
+puzzle_solver/puzzles/shingoki/shingoki.py,sha256=heMuL9sm3jBegItjnqX05ttmDNiHSLB77BRljpeLLWk,7417
+puzzle_solver/puzzles/signpost/signpost.py,sha256=38LlMvP5Fx4qrTXmw4aNCt3yUbG3fhdSk6-YXmhAHFg,3861
+puzzle_solver/puzzles/singles/singles.py,sha256=KKn_Yl-eW874Bl1UmmcqoQ5vhNiO1JbM7fxKczOV5M4,2847
+puzzle_solver/puzzles/slant/slant.py,sha256=xF-N4PuXYfx638NP1f1mi6YncIZB4mLtXtdS79XyPbg,6122
+puzzle_solver/puzzles/slant/parse_map/parse_map.py,sha256=8thQxWbq0qjehKb2VzgUP22PGj-9n9djwbt3LGMVLJw,4811
+puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=JpyNQk8K4nUziwWKxSvWEkF1RRBGLnCppCWK1Yf5bt0,7052
+puzzle_solver/puzzles/star_battle/star_battle.py,sha256=IX6w4H3sifN01kPPtrAVRCK0Nl_xlXXSHvJKw8K1EuE,3718
+puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
+puzzle_solver/puzzles/stitches/stitches.py,sha256=bb5JXyclkbKq350MQ9d8AuGteQwSF8knaJ0DU9M92Uw,6515
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=b21SQvlnDM6wOl_1iUhZ7X6akpBZoOnj3kEzImBCh8Q,10497
+puzzle_solver/puzzles/sudoku/sudoku.py,sha256=rLq0N34v3Hb10CiptXtKxX-37OlQIyjIle9Es1FAtpM,13378
+puzzle_solver/puzzles/tapa/tapa.py,sha256=TsOQhnEvlC1JxaWiEjQg2KxRXJR49GrN71DsMvPpia8,5337
+puzzle_solver/puzzles/tents/tents.py,sha256=jccUXWA7KWAtPKpVJJYNI6masTYWQgx0eitcQw0-6Fc,6281
+puzzle_solver/puzzles/thermometers/thermometers.py,sha256=bGcVmpPeqL5AJtj8jkK8gYThzv9aGCd_QrWEiYBCA2s,4011
+puzzle_solver/puzzles/towers/towers.py,sha256=OLyTf9nTFR5L32-S_fhVyBmpz4i5YUNJotwOwbw_Fjg,6500
+puzzle_solver/puzzles/tracks/tracks.py,sha256=98xds9SKNqtOLFTRUX_KSMC7XYmZo567LOFeqotVQaM,7237
+puzzle_solver/puzzles/undead/undead.py,sha256=IGFQysgoaKZH8rKjqlrkoHsH28ve4_hKor2f0QOsWY0,6596
+puzzle_solver/puzzles/unequal/unequal.py,sha256=ExY2XDCrqROCDpRLfHo8uVr1zuli1QvbCdNCiDhlCac,6978
+puzzle_solver/puzzles/unruly/unruly.py,sha256=xwOUpC12uHbmlDj2guN60VaaHpLr1Y-WmMD5TKeHbZE,3826
+puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=5WixT_7K1HwfQ_dWbuBlQfpU8p69zB2KvOg32XJ8vno,5255
+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.2.dist-info/METADATA,sha256=LCKeSEhi50eG0kd-PUEbBBrpY7ZPuWau5Kz4csMTN84,347154
+multi_puzzle_solver-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-1.0.2.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-1.0.2.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -9,6 +9,7 @@ from puzzle_solver.puzzles.chess_range import chess_solo as chess_solo_solver
 from puzzle_solver.puzzles.chess_range import chess_melee as chess_melee_solver
 from puzzle_solver.puzzles.dominosa import dominosa as dominosa_solver
 from puzzle_solver.puzzles.filling import filling as filling_solver
+from puzzle_solver.puzzles.flood_it import flood_it as flood_it_solver
 from puzzle_solver.puzzles.flip import flip as flip_solver
 from puzzle_solver.puzzles.galaxies import galaxies as galaxies_solver
 from puzzle_solver.puzzles.guess import guess as guess_solver
@@ -52,4 +53,60 @@ from puzzle_solver.puzzles.yin_yang import yin_yang as yin_yang_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.30'
+__all__ = [
+    aquarium_solver,
+    battleships_solver,
+    binairo_solver,
+    binairo_plus_solver,
+    black_box_solver,
+    bridges_solver,
+    chess_range_solver,
+    chess_solo_solver,
+    chess_melee_solver,
+    dominosa_solver,
+    filling_solver,
+    flood_it_solver,
+    flip_solver,
+    galaxies_solver,
+    guess_solver,
+    heyawake_solver,
+    inertia_solver,
+    kakurasu_solver,
+    kakuro_solver,
+    keen_solver,
+    light_up_solver,
+    magnets_solver,
+    map_solver,
+    minesweeper_solver,
+    mosaic_solver,
+    nonograms_solver,
+    norinori_solver,
+    nurikabe_solver,
+    palisade_solver,
+    lits_solver,
+    pearl_solver,
+    range_solver,
+    rectangles_solver,
+    shakashaka_solver,
+    shingoki_solver,
+    signpost_solver,
+    singles_solver,
+    slant_solver,
+    slitherlink_solver,
+    star_battle_solver,
+    star_battle_shapeless_solver,
+    stitches_solver,
+    sudoku_solver,
+    tapa_solver,
+    tents_solver,
+    thermometers_solver,
+    towers_solver,
+    tracks_solver,
+    undead_solver,
+    unequal_solver,
+    unruly_solver,
+    yin_yang_solver,
+    inertia_image_parser,
+]
+
+__version__ = '1.0.2'

puzzle_solver/core/utils_ortools.py

@@ -14,6 +14,8 @@ class SingleSolution:
     assignment: dict[Pos, Union[str, int]]
 
     def get_hashable_solution(self) -> str:
+        if isinstance(self.assignment, list):
+            return json.dumps(self.assignment)
         result = []
         for pos, v in self.assignment.items():
             result.append((pos.x, pos.y, v))
@@ -93,14 +95,14 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
     Total new variables: =4V [for N by M 2D grid total is 4NM]
     """
     if is_neighbor is None:
-        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1
+        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1  # noqa: E731
 
     vs = vars_to_force
     v_count = len(vs)
     if v_count <= 2:  # graph must have at least 3 nodes to possibly be disconnected
         return {}
     # =V model variables, one for each variable
-    is_root: dict[Pos, cp_model.IntVar] = {}  # =V, defines the unique root 
+    is_root: dict[Pos, cp_model.IntVar] = {}  # =V, defines the unique
     prefix_zero: dict[Pos, cp_model.IntVar] = {}  # =V, used for picking the unique root
     node_height: dict[Pos, cp_model.IntVar] = {}  # =V, trickles down from the root
     max_neighbor_height: dict[Pos, cp_model.IntVar] = {}  # =V, the height of the tallest neighbor
@@ -141,7 +143,7 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
         model.Add(node_height[pi] == max_neighbor_height[pi] - 1).OnlyEnforceIf([vs[pi], is_root[pi].Not()])
         model.Add(node_height[pi] == v_count).OnlyEnforceIf(is_root[pi])
         model.Add(node_height[pi] == 0).OnlyEnforceIf(vs[pi].Not())
-    
+
     # final check: all active nodes have height > 0
     for p in keys_in_order:
         model.Add(node_height[p] > 0).OnlyEnforceIf(vs[p])
@@ -161,7 +163,7 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
     Returns a dictionary of new variables that can be used to enforce the no component constraint.
     """
     if is_neighbor is None:
-        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1
+        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1  # noqa: E731
 
     vs = vars_to_force
     v_count = len(vs)
@@ -220,8 +222,8 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
             model.Add(tree_edge[(p_parent, p)] == 0).OnlyEnforceIf([is_root[p]])
         # every active node has exactly 1 parent except root has none
         model.AddExactlyOne([tree_edge[(p_parent, p)] for p_parent in parent_of[p]] + [vs[p].Not(), is_root[p]])
-    
-    # now each subgraph has directions where each non-root points to a single parent (and its value is parent+1). 
+
+    # now each subgraph has directions where each non-root points to a single parent (and its value is parent+1).
     # to break cycles, every non-root active node must be > all neighbors that arent children
 
     all_new_vars: dict[str, cp_model.IntVar] = {}

puzzle_solver/core/utils_visualizer.py

@@ -94,7 +94,7 @@ def render_grid(cell_flags: np.ndarray,
         for r in range(R):
             rr = 2*r + 1
             for c in range(C):
-                val = center_char if isinstance(center_char, str) else center_char[r, c]
+                val = center_char if isinstance(center_char, str) else (center_char(r, c) if callable(center_char) else center_char[r, c])
                 put_center_text(rr, c, '' if val is None else str(val))
 
     # rows -> strings
@@ -159,13 +159,7 @@ def id_board_to_wall_board(id_board: np.array, border_is_wall = True) -> np.arra
 def render_shaded_grid(V: int,
                        H: int,
                        is_shaded: Callable[[int, int], bool],
-                       *,
-                       scale_x: int = 2,
-                       scale_y: int = 1,
-                       fill_char: str = '▒',
-                       empty_char: str = ' ',
-                       empty_text: Optional[Union[str, Callable[[int, int], Optional[str]]]] = None,
-                       show_axes: bool = True) -> str:
+                       empty_text: Optional[Union[str, Callable[[int, int], Optional[str]]]] = None,) -> str:
     """
     Most of this function was AI generated then modified by me, I don't currently care about the details of rendering to the terminal this looked good enough during my testing.
     Visualize a V x H grid where each cell is shaded if is_shaded(r, c) is True.
@@ -179,6 +173,11 @@ def render_shaded_grid(V: int,
                 cells. If a callable (r, c) -> str|None, used per cell. Text is
                 centered within the interior row and truncated to fit.
     """
+    scale_x: int = 2
+    scale_y: int = 1
+    fill_char: str = '▒'
+    empty_char: str = ' '
+    show_axes: bool = True
     assert V >= 1 and H >= 1
     assert scale_x >= 1 and scale_y >= 1
     assert len(fill_char) == 1 and len(empty_char) == 1
@@ -349,8 +348,10 @@ def render_bw_tiles_split(
         if not use_color:
             return ""
         parts = []
-        if fg is not None: parts.append(str(fg))
-        if bg is not None: parts.append(str(bg))
+        if fg is not None:
+            parts.append(str(fg))
+        if bg is not None:
+            parts.append(str(bg))
         return ("\x1b[" + ";".join(parts) + "m") if parts else ""
 
     RESET = "\x1b[0m" if use_color else ""
@@ -383,26 +384,17 @@ def render_bw_tiles_split(
         else:                      # y = 1 - x
             return (fy < 1 - fx) if val == "TL" else (fy > 1 - fx)
 
-    def on_boundary(val: CellVal, fx: float, fy: float) -> bool:
-        if val in ("B","W"):
-            return False
-        kind, _ = diag_kind_and_slash(val)
-        eps = 0.5 / max(cell_w, cell_h)   # thin boundary
-        if kind == "main":
-            return abs(fy - fx) <= eps
-        else:
-            return abs(fy - (1 - fx)) <= eps
-
     # Build one tile as a matrix of 1-char tokens (already colorized if ANSI)
     def make_tile(val: CellVal) -> List[List[str]]:
         rows: List[List[str]] = []
-        kind, slash_ch = diag_kind_and_slash(val)
-
+        _, slash_ch = diag_kind_and_slash(val)
         for y in range(cell_h):
             fy = (y + 0.5) / cell_h
             line: List[str] = []
+            prev = None
             for x in range(cell_w):
                 fx = (x + 0.5) / cell_w
+                fx_next = (x + 1.5) / cell_w
 
                 if val == "B":
                     line.append(sgr(bg=BG_BLACK) + " " + RESET if use_color else TXT_BLACK)
@@ -412,7 +404,12 @@ def render_bw_tiles_split(
                     continue
 
                 black_side = is_black(val, fx, fy)
-                boundary   = on_boundary(val, fx, fy)
+                next_black_side = is_black(val, fx_next, fy)
+                boundary = False  # if true places a "/" or "\" at the current position
+                if prev is not None and not prev and black_side:  # prev white and cur black => boundary now
+                    boundary = True
+                if black_side and not next_black_side:  # cur black and next white => boundary now
+                    boundary = True
 
                 if use_color:
                     bg = BG_BLACK if black_side else BG_WHITE
@@ -426,6 +423,7 @@ def render_bw_tiles_split(
                         line.append(slash_ch)
                     else:
                         line.append(TXT_BLACK if black_side else TXT_WHITE)
+                prev = black_side
             rows.append(line)
         return rows
 
@@ -435,23 +433,7 @@ def render_bw_tiles_split(
             return
         ch = ch[0]  # keep one character (user said single number)
         cx, cy = cell_w // 2, cell_h // 2
-        fx = (cx + 0.5) / cell_w
-        fy = (cy + 0.5) / cell_h
-
-        # If center is boundary or not black, nudge horizontally toward black side
-        if val in ("TL","TR","BL","BR"):
-            kind, _ = diag_kind_and_slash(val)
-            # Determine which side is black relative to x at this y
-            if kind == "main":  # boundary y=x → compare fx vs fy
-                want_right = (val == "TR")  # black is to the right of boundary
-                if on_boundary(val, fx, fy) or (is_black(val, fx, fy) is False):
-                    if want_right and cx + 1 < cell_w:  cx += 1
-                    elif not want_right and cx - 1 >= 0: cx -= 1
-            else:               # boundary y=1-x → compare fx vs 1-fy
-                want_left = (val == "TL")  # black is to the left of boundary
-                if on_boundary(val, fx, fy) or (is_black(val, fx, fy) is False):
-                    if want_left and cx - 1 >= 0:        cx -= 1
-                    elif not want_left and cx + 1 < cell_w: cx += 1
+        cx -= 1
 
         # Compose the glyph for that spot
         if use_color:
@@ -520,4 +502,4 @@ def render_bw_tiles_split(
 #     mode="text",        # ← key change
 #     text_palette="solid"  # try "solid" for stark black/white
 # )
-# print("```text\n" + art + "\n```")
+# print("```text\n" + art + "\n```")

puzzle_solver/puzzles/binairo/binairo.py

@@ -56,13 +56,13 @@ class Board:
             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. 
+        # 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}'
@@ -106,10 +106,10 @@ class Board:
 
         codes = []
         pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
-        for i, l in enumerate(model_vars):
+        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] * l[k] for k in range(m)))
+            self.model.Add(code == sum(pow2[k] * line[k] for k in range(m)))
             codes.append(code)
 
         self.model.AddAllDifferent(codes)

puzzle_solver/puzzles/black_box/black_box.py

@@ -50,7 +50,7 @@ class Board:
         self.right_values = right
         self.bottom_values = bottom
         self.left_values = left
-        
+
         self.model = cp_model.CpModel()
         self.ball_states: dict[Pos, cp_model.IntVar] = {}
         # (entry_pos, T, cell_pos, direction) -> True if the beam that entered from the board at "entry_pos" is present in "cell_pos" and is going in the direction "direction" at time T
@@ -86,7 +86,7 @@ class Board:
                 for cell in self.get_all_pos_extended():
                     for direction in Direction:
                         self.beam_states[(entry_pos, t, cell, direction)] = self.model.NewBoolVar(f'beam:{entry_pos}:{t}:{cell}:{direction}')
-        
+
         for (entry_pos, t, cell, direction) in self.beam_states.keys():
             if t not in self.beam_states_at_t:
                 self.beam_states_at_t[t] = {}
@@ -110,7 +110,7 @@ class Board:
         beam_ids.extend((beam_id, Direction.LEFT) for beam_id in self.right_cells)
         beam_ids.extend((beam_id, Direction.UP) for beam_id in self.bottom_cells)
         beam_ids.extend((beam_id, Direction.RIGHT) for beam_id in self.left_cells)
-        
+
         for (beam_id, direction) in beam_ids:
             # beam at t=0 is present at beam_id and facing direction
             self.model.Add(self.beam_states[(beam_id, 0, beam_id, direction)] == 1)
@@ -189,7 +189,7 @@ class Board:
         else:
             ball_right = False
             ball_right_not = True
-        
+
         pos_left = get_next_pos(cur_pos, direction_left)
         pos_right = get_next_pos(cur_pos, direction_right)
         pos_reflected = get_next_pos(cur_pos, reflected)
@@ -304,10 +304,4 @@ class Board:
                 ball_state = 'O' if single_res.assignment[pos] else ' '
                 res[pos.y][pos.x] = ball_state
             print(res)
-        r = generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
-        # print('non unique count:', count)
-
-
-
-
-
+        generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/bridges/bridges.py

@@ -73,7 +73,7 @@ class Board:
         xhoriz_min = min(horiz_bridge[0].x, horiz_bridge[1].x)
         xhoriz_max = max(horiz_bridge[0].x, horiz_bridge[1].x)
         yhoriz = horiz_bridge[0].y
-        
+
         # no equals because thats what the puzzle says
         x_contained = xhoriz_min < xvert < xhoriz_max
         y_contained = yvert_min < yhoriz < yvert_max

puzzle_solver/puzzles/chess_range/chess_range.py

@@ -173,11 +173,11 @@ class Board:
         self.H = 8  # board size
         # the puzzle rules mean the only legal positions are the starting positions of the pieces
         self.all_legal_positions: set[Pos] = {pos for _, pos in self.pieces.values()}
-        assert len(self.all_legal_positions) == len(self.pieces), f'positions are not unique'
+        assert len(self.all_legal_positions) == len(self.pieces), 'positions are not unique'
 
         self.model = cp_model.CpModel()
         # Input numbers: N is number of piece, T is number of time steps (=N here), B is board size (=N here because the only legal positions are the starting positions of the pieces):
-        # Number of variables 
+        # Number of variables
         # piece_positions: O(NTB)
         # is_dead: O(NT)
         # mover: O(NT)
@@ -341,7 +341,7 @@ class Board:
         for t in range(self.T - 1):
             self.model.AddExactlyOne([self.victim[(p, t)] for p in range(self.N)])
 
-        # optional parameter to force 
+        # optional parameter to force
         if self.max_moves_per_piece is not None:
             for p in range(self.N):
                 self.model.Add(sum([self.mover[(p, t)] for t in range(self.T - 1)]) <= self.max_moves_per_piece)

puzzle_solver/puzzles/chess_range/chess_solo.py

@@ -4,6 +4,6 @@ from .chess_range import PieceType
 class Board(RangeBoard):
     def __init__(self, pieces: list[str]):
         king_pieces = [p for p in range(len(pieces)) if pieces[p][0] == 'K']
-        assert len(king_pieces) == 1, f'exactly one king piece is required'
+        assert len(king_pieces) == 1, 'exactly one king piece is required'
         super().__init__(pieces, max_moves_per_piece=2, last_piece_alive=PieceType.KING)
 

puzzle_solver/puzzles/filling/filling.py

@@ -3,8 +3,8 @@ from dataclasses import dataclass
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, Shape, get_all_pos, get_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 
 @dataclass
@@ -85,7 +85,7 @@ class Board:
             # exactly one shape is active at that position
             self.model.AddExactlyOne(s.is_active for d in self.digits for s in self.body_loc_to_shape[(d,pos)])
         # if a shape is active then all its body is active
-        
+
         for s_list in self.body_loc_to_shape.values():
             for s in s_list:
                 for p in s.body:

puzzle_solver/puzzles/flood_it/flood_it.py

@@ -0,0 +1,174 @@
+import sys
+import time
+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_neighbors4, get_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, nodes: dict[int, int], edges: dict[int, set[int]], horizon: int, start_node_id: int):
+        self.T = horizon
+        self.nodes = nodes
+        self.edges = edges
+        self.start_node_id = start_node_id
+        self.K = len(set(nodes.values()))
+
+        self.model = cp_model.CpModel()
+        self.decision: dict[tuple[int, int], cp_model.IntVar] = {}  # (t, k)
+        self.connected: dict[tuple[int, int], cp_model.IntVar] = {}  # (t, cluster_id)
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for t in range(self.T - 1):  # (N-1) actions (we dont need to decide at time N)
+            for k in range(self.K):
+                self.decision[t, k] = self.model.NewBoolVar(f'decision:{t}:{k}')
+        for t in range(self.T):
+            for cluster_id in self.nodes:
+                self.connected[t, cluster_id] = self.model.NewBoolVar(f'connected:{t}:{cluster_id}')
+
+    def add_all_constraints(self):
+        # init time t=0, all clusters are not connected except start_node
+        for cluster_id in self.nodes:
+            if cluster_id == self.start_node_id:
+                self.model.Add(self.connected[0, cluster_id] == 1)
+            else:
+                self.model.Add(self.connected[0, cluster_id] == 0)
+        # each timestep I will pick either one or zero colors
+        for t in range(self.T - 1):
+            # print('fixing decision at time t=', t, 'to single action with colors', self.K)
+            self.model.Add(lxp.sum([self.decision[t, k] for k in range(self.K)]) <= 1)
+        # at the end of the game, all clusters must be connected
+        for cluster_id in self.nodes:
+            self.model.Add(self.connected[self.T-1, cluster_id] == 1)
+
+        for t in range(1, self.T):
+            for cluster_id in self.nodes:
+                # connected[t, i] must be 0 if all connencted clusters at t-1 are 0 (thus connected[t, i] <= sum(connected[t-1, j] for j in touching)
+                sum_neighbors = lxp.sum([self.connected[t-1, j] for j in self.edges[cluster_id]]) + self.connected[t-1, cluster_id]
+                self.model.Add(self.connected[t, cluster_id] <= sum_neighbors)
+                # connected[t, i] must be 0 if color chosen at time t does not match color of cluster i and not connected at t-1
+                cluster_color = self.nodes[cluster_id]
+                self.model.Add(self.connected[t, cluster_id] == 0).OnlyEnforceIf([self.decision[t-1, cluster_color].Not(), self.connected[t-1, cluster_id].Not()])
+                self.model.Add(self.connected[t, cluster_id] == 1).OnlyEnforceIf([self.connected[t-1, cluster_id]])
+
+        pairs = [(self.decision[t, k], t+1) for t in range(self.T - 1) for k in range(self.K)]
+        self.model.Minimize(lxp.weighted_sum([p[0] for p in pairs], [p[1] for p in pairs]))
+
+    def solve(self) -> list[SingleSolution]:
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: list[str] = [None for _ in range(self.T - 1)]
+            for t in range(self.T - 1):
+                for k in range(self.K):
+                    if solver.Value(self.decision[t, k]) == 1:
+                        assignment[t] = k
+                        break
+            return SingleSolution(assignment=assignment)
+        return generic_solve_all(self, board_to_solution, verbose=False, max_solutions=1)
+
+
+def solve_minimum_steps(board: np.array, start_pos: Optional[Pos] = None, verbose: bool = True) -> int:
+    tic = time.time()
+    all_colors: set[str] = {c.item().strip() for c in np.nditer(board) if c.item().strip()}
+    color_to_int: dict[str, int] = {c: i for i, c in enumerate(sorted(all_colors))}  # colors string to color id
+    int_to_color: dict[int, str] = {i: c for c, i in color_to_int.items()}
+
+    graph: dict[Pos, int] = _board_to_graph(board)  # position to cluster id
+    nodes: dict[int, int] = {cluster_id: color_to_int[get_char(board, pos)] for pos, cluster_id in graph.items()}
+    edges = _graph_to_edges(board, graph)  # cluster id to touching cluster ids
+    if start_pos is None:
+        start_pos = Pos(0,0)
+
+    def solution_int_to_str(solution: SingleSolution):
+        return [int_to_color.get(color_id, '?') for color_id in solution.assignment]
+
+    def print_solution(solution: SingleSolution):
+        solution = solution_int_to_str(solution)
+        print("Solution:", solution)
+    solution = _binary_search_solution(nodes, edges, graph[start_pos], callback=print_solution if verbose else None, verbose=verbose)
+    if verbose:
+        if solution is None:
+            print("No solution found")
+        else:
+            solution = solution_int_to_str(solution)
+            print(f"Best Horizon is: T={len(solution)}")
+            print("Best solution is:", solution)
+        toc = time.time()
+        print(f"Time taken: {toc - tic:.2f} seconds")
+    return solution
+
+
+def _board_to_graph(board: np.array) -> dict[int, set[int]]:
+    def dfs_flood(board: np.array, pos: Pos, cluster_id: int, graph: dict[Pos, int]):
+        if pos in graph:
+            return
+        graph[pos] = cluster_id
+        for neighbor in get_neighbors4(pos, board.shape[0], board.shape[1]):
+            if get_char(board, neighbor) == get_char(board, pos):
+                dfs_flood(board, neighbor, cluster_id, graph)
+    graph: dict[Pos, int] = {}
+    cluster_id = 0
+    V, H = board.shape
+    for pos in get_all_pos(V, H):
+        if pos in graph:
+            continue
+        dfs_flood(board, pos, cluster_id, graph)
+        cluster_id += 1
+    return graph
+
+
+def _graph_to_edges(board: np.array, graph: dict[Pos, int]) -> dict[int, set[int]]:
+    cluster_edges: dict[int, set[int]] = defaultdict(set)
+    V, H = board.shape
+    for pos in get_all_pos(V, H):
+        for neighbor in get_neighbors4(pos, V, H):
+            n1, n2 = graph[pos], graph[neighbor]
+            if n1 != n2:
+                cluster_edges[n1].add(n2)
+                cluster_edges[n2].add(n1)
+    return cluster_edges
+
+
+def _binary_search_solution(nodes, edges, start_node_id, callback, verbose: bool = True):
+    if len(nodes) <= 1:
+        return SingleSolution(assignment=[])
+    min_T = 2
+    max_T = len(nodes)
+    hist = {}  # record historical T and best solution
+    while min_T <= max_T:
+        if max_T - min_T <= 20:  # small gap, just take the middle
+            T = min_T + (max_T - min_T) // 2
+        else:  # large gap, just +5 the min to not go too far
+            T = min_T + 15
+        # main check for binary search
+        if T in hist:  # already done and found solution
+            solutions = hist[T]
+        else:
+            if verbose:
+                print(f"Trying with exactly {T-1} moves...", end='')
+                sys.stdout.flush()
+            binst = Board(nodes=nodes, edges=edges, horizon=T, start_node_id=start_node_id)
+            solutions = binst.solve()
+            if verbose:
+                print(' Possible!' if len(solutions) > 0 else ' Not possible!')
+                if len(solutions) > 0:
+                    callback(solutions[0])
+        if min_T == max_T:
+            hist[T] = solutions
+            break
+        if len(solutions) > 0:
+            hist[T] = solutions
+            max_T = T
+        else:
+            min_T = T + 1
+    best_solution = min(hist.items(), key=lambda x: x[0])[1][0]
+    return best_solution
+
+