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

{multi_puzzle_solver-0.9.27.dist-info → multi_puzzle_solver-0.9.30.dist-info}/RECORD

@@ -1,10 +1,11 @@
-puzzle_solver/__init__.py,sha256=FzOcK5T5beTloncBQ-qo9hpqtxu4sbmR7m3fPUnnqec,3272
+puzzle_solver/__init__.py,sha256=f79JI0EQhfQi12yO6gvuzzLtxXQgojVrq-v8HZrzjS0,3693
 puzzle_solver/core/utils.py,sha256=XBW5j-IwtJMPMP-ycmY6SqRCM1NOVl5O6UeoGqNj618,8153
 puzzle_solver/core/utils_ortools.py,sha256=_i8cixHOB5XGqqcr-493bOiZgYJidnvxQMEfj--Trns,10278
-puzzle_solver/core/utils_visualizer.py,sha256=D1eNTZ3eJ76pBoznKRMwvlxXxQsz89K2fBfXP_dASwo,12868
+puzzle_solver/core/utils_visualizer.py,sha256=2jBnS2PeI4keFf-rneScSxX669zXu5F1lkClZ5EkMhE,21152
 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=sRtflnlGrN8xQ64beRZBGr74R8KptzxYDdFgXuW27pM,4595
+puzzle_solver/puzzles/binairo/binairo.py,sha256=4xgYd1ewYIQCqEzsHdgp6hWzyW_TF_2rt6PO8QLFKWU,6838
+puzzle_solver/puzzles/binairo/binairo_plus.py,sha256=TvLG3olwANtft3LuCF-y4OofpU9PNa4IXDqgZqsD-g0,267
 puzzle_solver/puzzles/black_box/black_box.py,sha256=ZnHDVt6PFS_r1kMNSsbz9hav1hxIrNDUvPyERGPjLjM,15635
 puzzle_solver/puzzles/bridges/bridges.py,sha256=15A9uV4xjoqPRo_9CTnoKeGRxS3z2aMF619T1n0dTOQ,5402
 puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=D-_Oi8OyxsVe1j3dIKYwRlxgeb3NWLmDWGcv-oclY0c,195
@@ -17,10 +18,12 @@ puzzle_solver/puzzles/flip/flip.py,sha256=ZngJLUhRNc7qqo2wtNLdMPx4u9w9JTUge27Pmd
 puzzle_solver/puzzles/galaxies/galaxies.py,sha256=p10lpmW0FjtneFCMEjG1FSiEpQuvD8zZG9FG8zYGoes,5582
 puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=v5TCrdREeOB69s9_QFgPHKA7flG69Im1HVzIdxH0qQc,9355
 puzzle_solver/puzzles/guess/guess.py,sha256=sH-NlYhxM3DNbhk4eGde09kgM0KaDvSbLrpHQiwcFGo,10791
+puzzle_solver/puzzles/heyawake/heyawake.py,sha256=qMnc_CuHn8K5Rw40tefjueI1pycpHQ7eN1R9Xg5WEuw,5601
 puzzle_solver/puzzles/inertia/inertia.py,sha256=gJBahkh69CrSWNscalKEoP1j4X-Q3XpbIBMiG9PUpU0,5657
 puzzle_solver/puzzles/inertia/tsp.py,sha256=gobiISHtARA4Elq0jr90p6Yhq11ULjGoqsS-rLFhYcc,15389
 puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=A9JQTNqamUdzlwqks0XQp3Hge3mzyTIVK6YtDJvqpL4,8422
 puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGphTTUDMC0TkQvQ,2064
+puzzle_solver/puzzles/kakuro/kakuro.py,sha256=Jf0Iilv32EPcaWikX92_vgBOVRp5MAE27aFRmnLotGQ,4374
 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/lits/lits.py,sha256=3fPIkhAIUz8JokcfaE_ZM3b0AFEnf5xPzGJ2qnm8SWY,7099
@@ -35,16 +38,19 @@ puzzle_solver/puzzles/palisade/palisade.py,sha256=T-LXlaLU5OwUQ24QWJWhBUFUktg0qD
 puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5omYLChM,6798
 puzzle_solver/puzzles/range/range.py,sha256=rruvD5ZSaOgvQuX6uGV_Dkr82nSiWZ5kDz03_j7Tt24,4425
 puzzle_solver/puzzles/rectangles/rectangles.py,sha256=zaPg3qI9TNxr2iXmNi2kOL8R2RsS9DyQPUTY3ukgYIA,7033
+puzzle_solver/puzzles/shakashaka/shakashaka.py,sha256=PRpg_qI7XA3ysAo_g1TRJsT3VwB5Vial2UcFyBOMwKQ,9571
+puzzle_solver/puzzles/shingoki/shingoki.py,sha256=uwX1ZIGGDlshMtsZedlgGYE8hDB1ou3h6aBnZEr_l8I,7425
 puzzle_solver/puzzles/signpost/signpost.py,sha256=-0_S6ycwzwlUf9-ZhP127Rgo5gMBOHiTM6t08dLLDac,3869
-puzzle_solver/puzzles/singles/singles.py,sha256=3wACiUa1Vmh2ce6szQ2hPjyBuH7aHiQ888p4R2jFkW4,3342
+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=dxnALSDXe9wU0uSD0QEXnzoh1q801mj1ePTNLtG0n60,4796
 puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=e1A_f_3J-QXN9fmt_Nf3FsYnp-TmE9TRKN06Wn4NnAU,7056
 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=iK8t02q43gH3FPbuIDn4dK0sbaOgZOnw8yHNRNvNuIU,6534
-puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=1LNJkIqpcz1LvY0H0uRedABQWm44dgNf9XeQuKm36WM,10275
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=f49ZGVBPXjAGgqZnqPab6PcO_DsFDFZnG3uA8b-1d7k,10441
 puzzle_solver/puzzles/sudoku/sudoku.py,sha256=SE4TM_gic6Jj0fkDR_NzUJdX2XKyQ8eeOnVAQ011Xbo,8870
+puzzle_solver/puzzles/tapa/tapa.py,sha256=TsOQhnEvlC1JxaWiEjQg2KxRXJR49GrN71DsMvPpia8,5337
 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
@@ -55,7 +61,7 @@ puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUy
 puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=WrRdNhmKhIARdGOt_36gpRxRzrfLGv3wl7igBpPFM64,5259
 puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=drjfoHqmFf6U-ZQUwrBbfGINRxDQpgbvy4U3D9QyMhM,6617
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.27.dist-info/METADATA,sha256=ZZDovGlLzsfNSjwsqHiYi91vCPJCA2-Na3jiaQ8JiRU,224813
-multi_puzzle_solver-0.9.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.27.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.27.dist-info/RECORD,,
+multi_puzzle_solver-0.9.30.dist-info/METADATA,sha256=yxPV6ZvkvGPOs1O2HpIob3e94uFQXjpm5JJKdCXyc2s,335384
+multi_puzzle_solver-0.9.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.30.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.30.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -1,6 +1,7 @@
 from puzzle_solver.puzzles.aquarium import aquarium as aquarium_solver
 from puzzle_solver.puzzles.battleships import battleships as battleships_solver
 from puzzle_solver.puzzles.binairo import binairo as binairo_solver
+from puzzle_solver.puzzles.binairo import binairo_plus as binairo_plus_solver
 from puzzle_solver.puzzles.black_box import black_box as black_box_solver
 from puzzle_solver.puzzles.bridges import bridges as bridges_solver
 from puzzle_solver.puzzles.chess_range import chess_range as chess_range_solver
@@ -11,8 +12,10 @@ from puzzle_solver.puzzles.filling import filling as filling_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
+from puzzle_solver.puzzles.heyawake import heyawake as heyawake_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.kakuro import kakuro as kakuro_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
@@ -27,6 +30,8 @@ from puzzle_solver.puzzles.lits import lits as lits_solver
 from puzzle_solver.puzzles.pearl import pearl as pearl_solver
 from puzzle_solver.puzzles.range import range as range_solver
 from puzzle_solver.puzzles.rectangles import rectangles as rectangles_solver
+from puzzle_solver.puzzles.shakashaka import shakashaka as shakashaka_solver
+from puzzle_solver.puzzles.shingoki import shingoki as shingoki_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.slant import slant as slant_solver
@@ -35,6 +40,7 @@ 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
 from puzzle_solver.puzzles.sudoku import sudoku as sudoku_solver
+from puzzle_solver.puzzles.tapa import tapa as tapa_solver
 from puzzle_solver.puzzles.tents import tents as tents_solver
 from puzzle_solver.puzzles.thermometers import thermometers as thermometers_solver
 from puzzle_solver.puzzles.towers import towers as towers_solver
@@ -46,4 +52,4 @@ 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.27'
+__version__ = '0.9.30'

puzzle_solver/core/utils_visualizer.py

@@ -1,5 +1,5 @@
 import numpy as np
-from typing import Union, Callable, Optional
+from typing import Union, Callable, Optional, List, Sequence, Literal
 from puzzle_solver.core.utils import Pos, get_all_pos, get_next_pos, in_bounds, set_char, get_char, Direction
 
 
@@ -308,3 +308,216 @@ def render_shaded_grid(V: int,
         labeled.append(label + line)
 
     return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
+
+CellVal = Literal["B", "W", "TL", "TR", "BL", "BR"]
+GridLike = Sequence[Sequence[CellVal]]
+
+def render_bw_tiles_split(
+    grid: GridLike,
+    cell_w: int = 6,
+    cell_h: int = 3,
+    borders: bool = False,
+    mode: Literal["ansi", "text"] = "ansi",
+    text_palette: Literal["solid", "hatch"] = "solid",
+    cell_text: Optional[Callable[[int, int], str]] = None) -> str:
+    """
+    Render a VxH grid with '/' or '\\' splits and optional per-cell centered text.
+
+    `cell_text(r, c) -> str`: if returns non-empty, its first character is drawn
+    near the geometric center of cell (r,c), nudged to the black side for halves.
+    """
+
+    V = len(grid)
+    if V == 0:
+        return ""
+    H = len(grid[0])
+    if any(len(row) != H for row in grid):
+        raise ValueError("All rows must have the same length")
+    if cell_w < 1 or cell_h < 1:
+        raise ValueError("cell_w and cell_h must be >= 1")
+
+    allowed = {"B","W","TL","TR","BL","BR"}
+    for r in range(V):
+        for c in range(H):
+            if grid[r][c] not in allowed:
+                raise ValueError(f"Invalid cell value at ({r},{c}): {grid[r][c]}")
+
+    # ── Mode setup ─────────────────────────────────────────────────────────
+    use_color = (mode == "ansi")
+
+    def sgr(bg: int | None = None, fg: int | None = None) -> str:
+        if not use_color:
+            return ""
+        parts = []
+        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 ""
+
+    BG_BLACK, BG_WHITE = 40, 47
+    FG_BLACK, FG_WHITE = 30, 37
+
+    if text_palette == "solid":
+        TXT_BLACK, TXT_WHITE = " ", "█"
+    elif text_palette == "hatch":
+        TXT_BLACK, TXT_WHITE = "░", "▓"
+    else:
+        raise ValueError("text_palette must be 'solid' or 'hatch'")
+
+    def diag_kind_and_slash(val: CellVal):
+        if val in ("TR", "BL"):
+            return "main", "\\"
+        elif val in ("TL", "BR"):
+            return "anti", "/"
+        return None, "?"
+
+    def is_black(val: CellVal, fx: float, fy: float) -> bool:
+        if val == "B":
+            return True
+        if val == "W":
+            return False
+        kind, _ = diag_kind_and_slash(val)
+        if kind == "main":         # y = x
+            return (fy < fx) if val == "TR" else (fy > fx)
+        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)
+
+        for y in range(cell_h):
+            fy = (y + 0.5) / cell_h
+            line: List[str] = []
+            for x in range(cell_w):
+                fx = (x + 0.5) / cell_w
+
+                if val == "B":
+                    line.append(sgr(bg=BG_BLACK) + " " + RESET if use_color else TXT_BLACK)
+                    continue
+                if val == "W":
+                    line.append(sgr(bg=BG_WHITE) + " " + RESET if use_color else TXT_WHITE)
+                    continue
+
+                black_side = is_black(val, fx, fy)
+                boundary   = on_boundary(val, fx, fy)
+
+                if use_color:
+                    bg = BG_BLACK if black_side else BG_WHITE
+                    if boundary:
+                        fg = FG_WHITE if bg == BG_BLACK else FG_BLACK
+                        line.append(sgr(bg=bg, fg=fg) + slash_ch + RESET)
+                    else:
+                        line.append(sgr(bg=bg) + " " + RESET)
+                else:
+                    if boundary:
+                        line.append(slash_ch)
+                    else:
+                        line.append(TXT_BLACK if black_side else TXT_WHITE)
+            rows.append(line)
+        return rows
+
+    # Overlay a single character centered (nudged into black side if needed)
+    def overlay_center_char(tile: List[List[str]], val: CellVal, ch: str):
+        if not ch:
+            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
+
+        # Compose the glyph for that spot
+        if use_color:
+            # Force black bg + white fg so it pops
+            token = sgr(bg=BG_BLACK, fg=FG_WHITE) + ch + RESET
+        else:
+            # In text mode, just put the raw character
+            token = ch
+        tile[cy][cx] = token
+
+    # Optional borders
+    if borders:
+        horiz = "─" * cell_w
+        top = "┌" + "┬".join(horiz for _ in range(H)) + "┐"
+        mid = "├" + "┼".join(horiz for _ in range(H)) + "┤"
+        bot = "└" + "┴".join(horiz for _ in range(H)) + "┘"
+
+    out_lines: List[str] = []
+    if borders:
+        out_lines.append(top)
+
+    for r in range(V):
+        # Build tiles for this row (so we can overlay per-cell text)
+        row_tiles: List[List[List[str]]] = []
+        for c in range(H):
+            t = make_tile(grid[r][c])
+            if cell_text is not None:
+                label = cell_text(r, c)
+                if label:
+                    overlay_center_char(t, grid[r][c], label)
+            row_tiles.append(t)
+
+        # Emit tile rows
+        for y in range(cell_h):
+            if borders:
+                parts = ["│"]
+                for c in range(H):
+                    parts.append("".join(row_tiles[c][y]))
+                    parts.append("│")
+                out_lines.append("".join(parts))
+            else:
+                out_lines.append("".join("".join(row_tiles[c][y]) for c in range(H)))
+
+        if borders and r < V - 1:
+            out_lines.append(mid)
+
+    if borders:
+        out_lines.append(bot)
+
+    return "\n".join(out_lines) + (RESET if use_color else "")
+
+
+
+
+# demo = [
+#     ["TL","TR","BL","BR","B","W","BL","BR","B","W","TL","TR","BL","BR","B","W","BL","BR","B","W","W","BL","BR","B","W"],
+#     ["W","BL","TR","BL","TL","BR","BL","BR","W","W","W","B","TR","BL","TL","BR","BL","BR","B","W","BR","BL","BR","B","W"],
+#     ["BR","BL","TR","TL","W","B","BL","BR","B","W","BR","BL","TR","TL","W","B","BL","BR","B","W","B","BL","BR","B","W"],
+# ]
+# print(render_bw_tiles_split(demo, cell_w=8, cell_h=4, borders=True, mode="ansi"))
+# art = render_bw_tiles_split(
+#     demo,
+#     cell_w=8,
+#     cell_h=4,
+#     borders=True,
+#     mode="text",        # ← key change
+#     text_palette="solid"  # try "solid" for stark black/white
+# )
+# print("```text\n" + art + "\n```")

puzzle_solver/puzzles/binairo/binairo.py

@@ -1,17 +1,32 @@
+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 Direction, Pos, get_all_pos, get_next_pos, in_bounds, set_char, get_char, get_neighbors8, get_row_pos, get_col_pos
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, get_char, get_row_pos, get_col_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
 
 
 class Board:
-    def __init__(self, board: np.array):
+    def __init__(self, board: np.array, arith_rows: Optional[np.array] = None, arith_cols: Optional[np.array] = None, force_unique: bool = True):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
         assert all(c.item() in [' ', 'B', 'W'] for c in np.nditer(board)), 'board must contain only space or B'
         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.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
 
@@ -40,11 +55,32 @@ class Board:
         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. 
-        # a list per row
-        self.force_unique([[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([[self.model_vars[pos] for pos in get_col_pos(col, self.V)] for col in range(self.H)])
+        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)])
+        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)])
+
 
     def disallow_three_in_a_row(self, p1: Pos, direction: Direction):
         p2 = get_next_pos(p1, direction)
@@ -62,7 +98,7 @@ class Board:
             self.model_vars[p3].Not(),
         ])
 
-    def force_unique(self, model_vars: list[list[cp_model.IntVar]]):
+    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])
@@ -86,13 +122,5 @@ class Board:
             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 = get_char(self.board, pos)
-                c = 'B' if single_res.assignment[pos] == 1 else 'W'
-                set_char(res, pos, c)
-            print('[')
-            for row in res:
-                print("    [ '" + "', '".join(row.tolist()) + "' ],")
-            print(']')
+            print(render_shaded_grid(self.V, self.H, 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/binairo/binairo_plus.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+from . import binairo
+
+class Board(binairo.Board):
+    def __init__(self, board: np.array, arith_rows: np.array, arith_cols: np.array):
+        super().__init__(board=board, arith_rows=arith_rows, arith_cols=arith_cols, force_unique=False)

puzzle_solver/puzzles/heyawake/heyawake.py

@@ -0,0 +1,94 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, set_char, get_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
+
+def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
+    """Given a list of integers (mostly with duplicates), return every consecutive sequence of 3 integer changes. 
+    i.e. return a list of (begin_idx, end_idx) tuples where for each r=int_list[begin_idx:end_idx] we have r[0]!=r[1] and r[-2]!=r[-1] and len(r)>=3"""
+    out = []
+    change_indices = [i for i in range(len(int_list) - 1) if int_list[i] != int_list[i+1]]
+    # notice how for every subsequence r, the subsequence begining index is in change_indices and the ending index - 1 is in change_indices
+    for i in range(len(change_indices) - 1):
+        begin_idx = change_indices[i]
+        end_idx = change_indices[i+1] + 1  # we want to include the first number in the third sequence
+        if end_idx > len(int_list):
+            continue
+        out.append((begin_idx, end_idx))
+    return out
+    
+
+class Board:
+    def __init__(self, board: np.array, region_to_clue: dict[str, int]):
+        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 space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.all_regions: set[int] = {int(c.item()) for c in np.nditer(board)}
+        self.region_to_clue = {int(k): v for k, v in region_to_clue.items()}
+        assert set(self.region_to_clue.keys()).issubset(self.all_regions), f'extra regions in region_to_clue: {set(self.region_to_clue.keys()) - self.all_regions}'
+        self.region_to_pos: dict[int, set[Pos]] = {r: set() for r in self.all_regions}
+        for pos in get_all_pos(self.V, self.H):
+            rid = int(get_char(self.board, pos))
+            self.region_to_pos[rid].add(pos)
+
+        self.model = cp_model.CpModel()
+        self.B: dict[Pos, cp_model.IntVar] = {}
+        self.W: 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.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+            self.W[pos] = self.model.NewBoolVar(f'W:{pos}')
+            self.model.AddExactlyOne([self.B[pos], self.W[pos]])
+
+    def add_all_constraints(self):
+        # Regions with a number should contain black cells matching the number.
+        for rid, clue in self.region_to_clue.items():
+            self.model.Add(sum([self.B[p] for p in self.region_to_pos[rid]]) == clue)
+        # 2 black cells cannot be adjacent horizontally or vertically.
+        for pos in get_all_pos(self.V, self.H):
+            for neighbor in get_neighbors4(pos, self.V, self.H):
+                self.model.AddBoolOr([self.W[pos], self.W[neighbor]])
+        # All white cells should be connected in a single group.
+        force_connected_component(self.model, self.W)
+        # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
+        self.disallow_white_lines_spanning_3_regions()
+
+    def disallow_white_lines_spanning_3_regions(self):
+        # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
+        row_to_region: dict[int, list[int]] = {row: [] for row in range(self.V)}
+        col_to_region: dict[int, list[int]] = {col: [] for col in range(self.H)}
+        for pos in get_all_pos(self.V, self.H):  # must traverse from least to most (both row and col)
+            rid = int(get_char(self.board, pos))
+            row_to_region[pos.y].append(rid)
+            col_to_region[pos.x].append(rid)
+        for row_num, row in row_to_region.items():
+            for begin_idx, end_idx in return_3_consecutives(row):
+                pos_list = [get_pos(x=x, y=row_num) for x in range(begin_idx, end_idx+1)]
+                self.model.AddBoolOr([self.B[p] for p in pos_list])
+        for col_num, col in col_to_region.items():
+            for begin_idx, end_idx in return_3_consecutives(col):
+                pos_list = [get_pos(x=col_num, y=y) for y in range(begin_idx, end_idx+1)]
+                self.model.AddBoolOr([self.B[p] for p in pos_list])
+
+    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.B.items():
+                assignment[pos] = 1 if solver.Value(var) == 1 else 0
+            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 = 'B' if single_res.assignment[pos] == 1 else ' '
+            #     set_char(res, pos, c)
+            # print(res)
+            print(render_shaded_grid(self.V, self.H, lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1, empty_text=lambda r, c: self.region_to_clue.get(int(self.board[r, c]), ' ')))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=1)

puzzle_solver/puzzles/kakuro/kakuro.py

@@ -0,0 +1,77 @@
+from typing import Iterator
+
+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 Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, set_char, get_char, get_neighbors8
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
+
+
+class Board:
+    def __init__(self, board: np.array, row_sums: list[list[int]], col_sums: list[list[int]], N: int = 9):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() in ['#', ' ', '1', '2', '3', '4', '5', '6', '7', '8', '9']) for c in np.nditer(board)), 'board must contain only #, space, or digits'
+        assert len(row_sums) == board.shape[0] and all(isinstance(i, list) and all(isinstance(j, int) or j == '#' for j in i) for i in row_sums), 'row_sums must be a list of lists of integers or #'
+        assert len(col_sums) == board.shape[1] and all(isinstance(i, list) and all(isinstance(j, int) or j == '#' for j in i) for i in col_sums), 'col_sums must be a list of lists of integers or #'
+        self.board = board
+        self.row_sums = row_sums
+        self.col_sums = col_sums
+        self.V, self.H = board.shape
+        self.N = N
+        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):
+            if get_char(self.board, pos) == '#':
+                continue
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+
+    def get_consecutives(self, pos: Pos, direction: Direction) -> Iterator[list[Pos]]:
+        consecutive = []
+        while in_bounds(pos, self.V, self.H):
+            if get_char(self.board, pos) == '#':
+                if len(consecutive) > 0:
+                    yield consecutive
+                    consecutive = []
+            else:
+                consecutive.append(pos)
+            pos = get_next_pos(pos, direction)
+        if len(consecutive) > 0:
+            yield consecutive
+
+    def add_all_constraints(self):
+        for row in range(self.V):
+            row_consecutives = self.get_consecutives(get_pos(x=0, y=row), Direction.RIGHT)
+            for i, consecutive in enumerate(row_consecutives):
+                # print('row', row, 'i', i, 'consecutive', consecutive)
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.row_sums[row][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == clue)
+            assert len(self.row_sums[row]) == i + 1, f'row_sums[{row}] has {len(self.row_sums[row])} clues, but {i + 1} consecutive cells'
+        for col in range(self.H):
+            col_consecutives = self.get_consecutives(get_pos(x=col, y=0), Direction.DOWN)
+            for i, consecutive in enumerate(col_consecutives):
+                # print('col', col, 'i', i, 'consecutive', consecutive)
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.col_sums[col][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == clue)
+            assert len(self.col_sums[col]) == i + 1, f'col_sums[{col}] has {len(self.col_sums[col])} clues, but {i + 1} consecutive cells'
+
+    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")
+            print(render_shaded_grid(self.V, self.H, is_shaded=lambda r, c: self.board[r, c] == '#', empty_text=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)