multi-puzzle-solver 1.0.3__py3-none-any.whl → 1.0.6__py3-none-any.whl

puzzle_solver/puzzles/galaxies/galaxies.py

@@ -1,110 +1,110 @@
-from collections import defaultdict
-from typing import Iterable, Union
-
-import numpy as np
-from ortools.sat.python import cp_model
-
-from puzzle_solver.core.utils import Pos, get_all_pos, set_char, Direction, get_next_pos, in_bounds, get_opposite_direction, get_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
-
-
-def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:
-    result = defaultdict(list)
-    for pos, arr_id in np.ndenumerate(galaxies):
-        if not arr_id.strip():
-            continue
-        result[arr_id].append(get_pos(x=pos[1], y=pos[0]))
-    return [positions for _, positions in sorted(result.items(), key=lambda x: x[0])]
-
-
-class Board:
-    def __init__(self, galaxies: Union[list[tuple[Pos, ...]], np.ndarray], V: int = None, H: int = None):
-        if isinstance(galaxies, np.ndarray):
-            V, H = galaxies.shape
-            galaxies = parse_numpy(galaxies)
-        else:
-            assert V is not None and H is not None, 'V and H must be provided if galaxies is not a numpy array'
-        assert V >= 1 and H >= 1, 'V and H must be at least 1'
-        assert all(isinstance(galaxy, Iterable) for galaxy in galaxies), 'galaxies must be a list of Iterables'
-        assert all(len(galaxy) in [1, 2, 4] for galaxy in galaxies), 'each galaxy must be exactly 1, 2, or 4 positions'
-        self.V = V
-        self.H = H
-        self.n_galaxies = len(galaxies)
-        self.galaxies = galaxies
-        self.prelocated_positions: set[Pos] = {pos: i for i, galaxy in enumerate(galaxies) for pos in galaxy}
-
-        self.model = cp_model.CpModel()
-        self.pos_to_galaxy: dict[Pos, dict[int, cp_model.IntVar]] = {p: {} for p in get_all_pos(V, H)}  # each position can be part of exactly one out of many possible galaxies
-        self.allocated_pairs: set[tuple[Pos, Pos]] = set()  # each pair is allocated to exactly one galaxy
-
-        self.create_vars()
-        self.add_all_constraints()
-
-    def create_vars(self):
-        for i in range(self.n_galaxies):
-            galaxy = self.galaxies[i]
-            if len(galaxy) == 1:
-                p1, p2 = galaxy[0], galaxy[0]
-            elif len(galaxy) == 2:
-                p1, p2 = galaxy[0], galaxy[1]
-            elif len(galaxy) == 4:
-                p1, p2 = galaxy[0], galaxy[3]  # [1] and [2] will be linked with symmetry
-            self.expand_galaxy(p1, p2, i)
-
-    def expand_galaxy(self, p1: Pos, p2: Pos, galaxy_idx: int):
-        if (p1, p2) in self.allocated_pairs or (p2, p1) in self.allocated_pairs:
-            return
-        if p1 in self.prelocated_positions and self.prelocated_positions[p1] != galaxy_idx:
-            return
-        if p2 in self.prelocated_positions and self.prelocated_positions[p2] != galaxy_idx:
-            return
-        if not in_bounds(p1, self.V, self.H) or not in_bounds(p2, self.V, self.H):
-            return
-        self.bind_pair(p1, p2, galaxy_idx)
-        # symmetrically expand the galaxy until illegal position is hit
-        for direction in [Direction.RIGHT, Direction.UP, Direction.DOWN, Direction.LEFT]:
-            symmetrical_direction = get_opposite_direction(direction)
-            new_p1 = get_next_pos(p1, direction)
-            new_p2 = get_next_pos(p2, symmetrical_direction)
-            self.expand_galaxy(new_p1, new_p2, galaxy_idx)
-
-    def bind_pair(self, p1: Pos, p2: Pos, galaxy_idx: int):
-        assert galaxy_idx not in self.pos_to_galaxy[p1], f'p1={p1} already has galaxy idx={galaxy_idx}'
-        assert galaxy_idx not in self.pos_to_galaxy[p2], f'p2={p2} already has galaxy idx={galaxy_idx}'
-        self.allocated_pairs.add((p1, p2))
-        v1 = self.model.NewBoolVar(f'{p1}:{galaxy_idx}')
-        v2 = self.model.NewBoolVar(f'{p2}:{galaxy_idx}')
-        self.model.Add(v1 == v2)
-        self.pos_to_galaxy[p1][galaxy_idx] = v1
-        self.pos_to_galaxy[p2][galaxy_idx] = v2
-
-    def add_all_constraints(self):
-        galaxy_vars = {}
-        for pos in get_all_pos(self.V, self.H):
-            pos_vars = list(self.pos_to_galaxy[pos].values())
-            self.model.AddExactlyOne(pos_vars)
-            for galaxy_idx, v in self.pos_to_galaxy[pos].items():
-                galaxy_vars.setdefault(galaxy_idx, {})[pos] = v
-        for pos_vars in galaxy_vars.values():
-            force_connected_component(self.model, pos_vars)
-
-
-    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, galaxy_vars in board.pos_to_galaxy.items():
-                for galaxy_idx, var in galaxy_vars.items():  # every pos is part of exactly one galaxy
-                    if solver.Value(var) == 1:
-                        assignment[pos] = galaxy_idx
-                        break
-            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):
-                set_char(res, pos, str(single_res.assignment[pos]).zfill(2))
-            print('[')
-            for row in range(self.V):
-                print('   ', res[row].tolist(), end=',\n')
-            print(']')
-        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
+from collections import defaultdict
+from typing import Iterable, Union
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, Direction, get_next_pos, in_bounds, get_opposite_direction, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:
+    result = defaultdict(list)
+    for pos, arr_id in np.ndenumerate(galaxies):
+        if not arr_id.strip():
+            continue
+        result[arr_id].append(get_pos(x=pos[1], y=pos[0]))
+    return [positions for _, positions in sorted(result.items(), key=lambda x: x[0])]
+
+
+class Board:
+    def __init__(self, galaxies: Union[list[tuple[Pos, ...]], np.ndarray], V: int = None, H: int = None):
+        if isinstance(galaxies, np.ndarray):
+            V, H = galaxies.shape
+            galaxies = parse_numpy(galaxies)
+        else:
+            assert V is not None and H is not None, 'V and H must be provided if galaxies is not a numpy array'
+        assert V >= 1 and H >= 1, 'V and H must be at least 1'
+        assert all(isinstance(galaxy, Iterable) for galaxy in galaxies), 'galaxies must be a list of Iterables'
+        assert all(len(galaxy) in [1, 2, 4] for galaxy in galaxies), 'each galaxy must be exactly 1, 2, or 4 positions'
+        self.V = V
+        self.H = H
+        self.n_galaxies = len(galaxies)
+        self.galaxies = galaxies
+        self.prelocated_positions: set[Pos] = {pos: i for i, galaxy in enumerate(galaxies) for pos in galaxy}
+
+        self.model = cp_model.CpModel()
+        self.pos_to_galaxy: dict[Pos, dict[int, cp_model.IntVar]] = {p: {} for p in get_all_pos(V, H)}  # each position can be part of exactly one out of many possible galaxies
+        self.allocated_pairs: set[tuple[Pos, Pos]] = set()  # each pair is allocated to exactly one galaxy
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for i in range(self.n_galaxies):
+            galaxy = self.galaxies[i]
+            if len(galaxy) == 1:
+                p1, p2 = galaxy[0], galaxy[0]
+            elif len(galaxy) == 2:
+                p1, p2 = galaxy[0], galaxy[1]
+            elif len(galaxy) == 4:
+                p1, p2 = galaxy[0], galaxy[3]  # [1] and [2] will be linked with symmetry
+            self.expand_galaxy(p1, p2, i)
+
+    def expand_galaxy(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        if (p1, p2) in self.allocated_pairs or (p2, p1) in self.allocated_pairs:
+            return
+        if p1 in self.prelocated_positions and self.prelocated_positions[p1] != galaxy_idx:
+            return
+        if p2 in self.prelocated_positions and self.prelocated_positions[p2] != galaxy_idx:
+            return
+        if not in_bounds(p1, self.V, self.H) or not in_bounds(p2, self.V, self.H):
+            return
+        self.bind_pair(p1, p2, galaxy_idx)
+        # symmetrically expand the galaxy until illegal position is hit
+        for direction in [Direction.RIGHT, Direction.UP, Direction.DOWN, Direction.LEFT]:
+            symmetrical_direction = get_opposite_direction(direction)
+            new_p1 = get_next_pos(p1, direction)
+            new_p2 = get_next_pos(p2, symmetrical_direction)
+            self.expand_galaxy(new_p1, new_p2, galaxy_idx)
+
+    def bind_pair(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        assert galaxy_idx not in self.pos_to_galaxy[p1], f'p1={p1} already has galaxy idx={galaxy_idx}'
+        assert galaxy_idx not in self.pos_to_galaxy[p2], f'p2={p2} already has galaxy idx={galaxy_idx}'
+        self.allocated_pairs.add((p1, p2))
+        v1 = self.model.NewBoolVar(f'{p1}:{galaxy_idx}')
+        v2 = self.model.NewBoolVar(f'{p2}:{galaxy_idx}')
+        self.model.Add(v1 == v2)
+        self.pos_to_galaxy[p1][galaxy_idx] = v1
+        self.pos_to_galaxy[p2][galaxy_idx] = v2
+
+    def add_all_constraints(self):
+        galaxy_vars = {}
+        for pos in get_all_pos(self.V, self.H):
+            pos_vars = list(self.pos_to_galaxy[pos].values())
+            self.model.AddExactlyOne(pos_vars)
+            for galaxy_idx, v in self.pos_to_galaxy[pos].items():
+                galaxy_vars.setdefault(galaxy_idx, {})[pos] = v
+        for pos_vars in galaxy_vars.values():
+            force_connected_component(self.model, pos_vars)
+
+
+    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, galaxy_vars in board.pos_to_galaxy.items():
+                for galaxy_idx, var in galaxy_vars.items():  # every pos is part of exactly one galaxy
+                    if solver.Value(var) == 1:
+                        assignment[pos] = galaxy_idx
+                        break
+            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):
+                set_char(res, pos, single_res.assignment[pos])
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(res),
+                center_char=lambda r, c: '.' if (Pos(x=c, y=r) in self.prelocated_positions) else ' '))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/heyawake/heyawake.py

@@ -3,7 +3,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, 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
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
@@ -90,5 +90,9 @@ class Board:
             #     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]), ' ')))
+            print(combined_function(self.V, self.H,
+                is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1,
+                center_char=lambda r, c: self.region_to_clue.get(int(self.board[r, c]), ''),
+                text_on_shaded_cells=False
+            ))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=1)

puzzle_solver/puzzles/kakurasu/kakurasu.py

@@ -1,22 +1,21 @@
 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 import Pos, get_all_pos, get_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
     def __init__(self, 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.V = side.shape[0]
         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()
 
@@ -32,15 +31,8 @@ class Board:
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for pos, var in board.model_vars.items():
-                assignment[pos] = solver.value(var)
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=object)
-            for pos in get_all_pos(self.V, self.H):
-                c = 'X' if single_res.assignment[pos] else ' '
-                set_char(res, pos, c)
-            print(res)
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/kakuro/kakuro.py

@@ -6,7 +6,7 @@ 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, get_char
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
-from puzzle_solver.core.utils_visualizer import render_shaded_grid
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
@@ -73,5 +73,9 @@ class Board:
             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)])))
+            print(combined_function(self.V, self.H,
+                is_shaded=lambda r, c: self.board[r, c] == '#',
+                center_char=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)]),
+                text_on_shaded_cells=False
+            ))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/lits/lits.py

@@ -6,6 +6,7 @@ import numpy as np
 
 from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, in_bounds, Direction, get_next_pos, polyominoes_with_shape_id
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 # a shape on the 2d board is just a set of positions
@@ -128,9 +129,10 @@ class Board:
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=str)
+            res = np.full((self.V, self.H), ' ', dtype=object)
             for pos, val in single_res.assignment.items():
-                c = 'X' if val == 1 else ' '
-                set_char(res, pos, c)
-            print('[\n' + '\n'.join(['  ' + str(res[row].tolist()) + ',' for row in range(self.V)]) + '\n]')
+                set_char(res, pos, '▒▒▒' if val == 1 else ' ')
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(self.board),
+                center_char=lambda r, c: res[r][c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)

puzzle_solver/puzzles/mosaic/mosaic.py

@@ -2,47 +2,37 @@ 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_char, get_neighbors8
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors8, get_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
     def __init__(self, board: np.array):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
-        assert board.shape[0] == board.shape[1], 'board must be square'
         assert all((c.item() == ' ') or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
         self.board = board
-        self.N = board.shape[0]
+        self.V, self.H = board.shape
         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.N):
+        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 pos in get_all_pos(self.N):
+        for pos in get_all_pos(self.V, self.H):
             c = get_char(self.board, pos)
             if not str(c).isdecimal():
                 continue
-            neighbour_vars = [self.model_vars[p] for p in get_neighbors8(pos, self.N, include_self=True)]
-            self.model.Add(lxp.sum(neighbour_vars) == int(c))
+            self.model.Add(lxp.Sum([self.model_vars[n] for n in get_neighbors8(pos, self.V, self.H, include_self=True)]) == int(c))
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for pos, var in board.model_vars.items():
-                assignment[pos] = solver.Value(var)
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.N, self.N), ' ', dtype=object)
-            for pos in get_all_pos(self.N):
-                c = get_char(self.board, pos)
-                c = 'B' if single_res.assignment[pos] == 1 else ' '
-                set_char(res, pos, c)
-            print(res)
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1, center_char=lambda r, c: str(self.board[r, c]), text_on_shaded_cells=False))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/nonograms/nonograms.py

@@ -1,8 +1,82 @@
-import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_row_pos, get_col_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, get_row_pos, get_col_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def constrain_nonogram_sequence(model: cp_model.CpModel, clues: list[int], current_sequence: list[cp_model.IntVar], ns: str):
+    """
+    Constrain a binary sequence (current_sequence) to match the nonogram clues in clues.
+
+    clues: e.g., [3,1] means: a run of 3 ones, >=1 zero, then a run of 1 one.
+    current_sequence: list of IntVar in {0,1}.
+    extra_vars: dict for storing helper vars safely across multiple calls.
+
+    steps:
+    - Create start position s_i for each run i.
+    - Enforce order and >=1 separation between runs.
+    - Link each cell j to exactly one run interval (or none) via coverage booleans.
+    - Force sum of ones to equal sum(clues).
+    """
+    L = len(current_sequence)
+
+    # not needed but useful for debugging: any clue longer than the line ⇒ unsat.
+    if sum(clues) + len(clues) - 1 > L:
+        print(f"Infeasible: clue {clues} longer than line length {L} for {ns}")
+        model.Add(0 == 1)
+        return
+
+    result = {}
+    # Start variables for each run. This is the most critical variable for the problem.
+    starts = []
+    result[f"{ns}_starts"] = starts
+    for i in range(len(clues)):
+        s = model.NewIntVar(0, L, f"{ns}_s[{i}]")
+        starts.append(s)
+    # Enforce order and >=1 blank between consecutive runs.
+    for i in range(len(clues) - 1):
+        model.Add(starts[i + 1] >= starts[i] + clues[i] + 1)
+    # enforce that every run is fully contained in the board
+    for i in range(len(clues)):
+        model.Add(starts[i] + clues[i] <= L)
+
+    # For each cell j, create booleans cover[i][j] that indicate
+    # whether run i covers cell j:  (starts[i] <= j) AND (j < starts[i] + clues[i])
+    cover = [[None] * L for _ in range(len(clues))]
+    list_b_le = [[None] * L for _ in range(len(clues))]
+    list_b_lt_end = [[None] * L for _ in range(len(clues))]
+    result[f"{ns}_cover"] = cover
+    result[f"{ns}_list_b_le"] = list_b_le
+    result[f"{ns}_list_b_lt_end"] = list_b_lt_end
+
+    for i, c in enumerate(clues):
+        s_i = starts[i]
+        for j in range(L):
+            # b_le: s_i <= j [is start[i] <= j]
+            b_le = model.NewBoolVar(f"{ns}_le[{i},{j}]")
+            model.Add(s_i <= j).OnlyEnforceIf(b_le)
+            model.Add(s_i >= j + 1).OnlyEnforceIf(b_le.Not())
+
+            # b_lt_end: j < s_i + c  ⇔  s_i + c - 1 >= j [is start[i] + clues[i] - 1 (aka end[i]) >= j]
+            b_lt_end = model.NewBoolVar(f"{ns}_lt_end[{i},{j}]")
+            end_expr = s_i + c - 1
+            model.Add(end_expr >= j).OnlyEnforceIf(b_lt_end)
+            model.Add(end_expr <= j - 1).OnlyEnforceIf(b_lt_end.Not())  # (s_i + c - 1) < j
+
+            b_cov = model.NewBoolVar(f"{ns}_cov[{i},{j}]")
+            # If covered ⇒ both comparisons true
+            model.AddBoolAnd([b_le, b_lt_end]).OnlyEnforceIf(b_cov)
+            # If both comparisons true ⇒ covered
+            model.AddBoolOr([b_cov, b_le.Not(), b_lt_end.Not()])
+            cover[i][j] = b_cov
+            list_b_le[i][j] = b_le
+            list_b_lt_end[i][j] = b_lt_end
+
+    # Each cell j is 1 iff it is covered by exactly one run.
+    # (Because runs are separated by >=1 zero, these coverage intervals cannot overlap,
+    for j in range(L):
+        model.Add(sum(cover[i][j] for i in range(len(clues))) == current_sequence[j])
 
 
 class Board:
@@ -30,97 +104,18 @@ class Board:
             if ground_sequence == -1:
                 continue
             current_sequence = [self.model_vars[pos] for pos in get_row_pos(i, self.H)]
-            self.constrain_nonogram_sequence(ground_sequence, current_sequence, f'ngm_side_{i}')
+            constrain_nonogram_sequence(self.model, ground_sequence, current_sequence, f'ngm_side_{i}')
         for i in range(self.H):
             ground_sequence = self.top[i]
             if ground_sequence == -1:
                 continue
             current_sequence = [self.model_vars[pos] for pos in get_col_pos(i, self.V)]
-            self.constrain_nonogram_sequence(ground_sequence, current_sequence, f'ngm_top_{i}')
-
-    def constrain_nonogram_sequence(self, clues: list[int], current_sequence: list[cp_model.IntVar], ns: str):
-        """
-        Constrain a binary sequence (current_sequence) to match the nonogram clues in clues.
-
-        clues: e.g., [3,1] means: a run of 3 ones, >=1 zero, then a run of 1 one.
-        current_sequence: list of IntVar in {0,1}.
-        extra_vars: dict for storing helper vars safely across multiple calls.
-
-        steps:
-        - Create start position s_i for each run i.
-        - Enforce order and >=1 separation between runs.
-        - Link each cell j to exactly one run interval (or none) via coverage booleans.
-        - Force sum of ones to equal sum(clues).
-        """
-        L = len(current_sequence)
-
-        # not needed but useful for debugging: any clue longer than the line ⇒ unsat.
-        if sum(clues) + len(clues) - 1 > L:
-            print(f"Infeasible: clue {clues} longer than line length {L} for {ns}")
-            self.model.Add(0 == 1)
-            return
-
-        # Start variables for each run. This is the most critical variable for the problem.
-        starts = []
-        self.extra_vars[f"{ns}_starts"] = starts
-        for i in range(len(clues)):
-            s = self.model.NewIntVar(0, L, f"{ns}_s[{i}]")
-            starts.append(s)
-        # Enforce order and >=1 blank between consecutive runs.
-        for i in range(len(clues) - 1):
-            self.model.Add(starts[i + 1] >= starts[i] + clues[i] + 1)
-        # enforce that every run is fully contained in the board
-        for i in range(len(clues)):
-            self.model.Add(starts[i] + clues[i] <= L)
-
-        # For each cell j, create booleans cover[i][j] that indicate
-        # whether run i covers cell j:  (starts[i] <= j) AND (j < starts[i] + clues[i])
-        cover = [[None] * L for _ in range(len(clues))]
-        list_b_le = [[None] * L for _ in range(len(clues))]
-        list_b_lt_end = [[None] * L for _ in range(len(clues))]
-        self.extra_vars[f"{ns}_cover"] = cover
-        self.extra_vars[f"{ns}_list_b_le"] = list_b_le
-        self.extra_vars[f"{ns}_list_b_lt_end"] = list_b_lt_end
-
-        for i, c in enumerate(clues):
-            s_i = starts[i]
-            for j in range(L):
-                # b_le: s_i <= j [is start[i] <= j]
-                b_le = self.model.NewBoolVar(f"{ns}_le[{i},{j}]")
-                self.model.Add(s_i <= j).OnlyEnforceIf(b_le)
-                self.model.Add(s_i >= j + 1).OnlyEnforceIf(b_le.Not())
-
-                # b_lt_end: j < s_i + c  ⇔  s_i + c - 1 >= j [is start[i] + clues[i] - 1 (aka end[i]) >= j]
-                b_lt_end = self.model.NewBoolVar(f"{ns}_lt_end[{i},{j}]")
-                end_expr = s_i + c - 1
-                self.model.Add(end_expr >= j).OnlyEnforceIf(b_lt_end)
-                self.model.Add(end_expr <= j - 1).OnlyEnforceIf(b_lt_end.Not())  # (s_i + c - 1) < j
-
-                b_cov = self.model.NewBoolVar(f"{ns}_cov[{i},{j}]")
-                # If covered ⇒ both comparisons true
-                self.model.AddBoolAnd([b_le, b_lt_end]).OnlyEnforceIf(b_cov)
-                # If both comparisons true ⇒ covered
-                self.model.AddBoolOr([b_cov, b_le.Not(), b_lt_end.Not()])
-                cover[i][j] = b_cov
-                list_b_le[i][j] = b_le
-                list_b_lt_end[i][j] = b_lt_end
-
-        # Each cell j is 1 iff it is covered by exactly one run.
-        # (Because runs are separated by >=1 zero, these coverage intervals cannot overlap,
-        for j in range(L):
-            self.model.Add(sum(cover[i][j] for i in range(len(clues))) == current_sequence[j])
+            constrain_nonogram_sequence(self.model, ground_sequence, current_sequence, f'ngm_top_{i}')
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for pos, var in board.model_vars.items():
-                assignment[pos] = solver.value(var)
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.value(var) for pos, var in board.model_vars.items()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=object)
-            for pos in get_all_pos(self.V, self.H):
-                c = 'B' if single_res.assignment[pos] == 1 else ' '
-                set_char(res, pos, c)
-            print(res)
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)