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

puzzle_solver/puzzles/nonograms/nonograms_colored.py

@@ -0,0 +1,221 @@
+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_pos, set_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 combined_function
+
+
+def assert_input(lines: list[list[tuple[int, str]]]):
+    for line in lines:
+        for i,c in enumerate(line):
+            if c == -1:
+                continue
+            elif isinstance(c, str):
+                assert c[:-1].isdigit(), f'strings must begin with a digit, got {c}'
+                line[i] = (int(c[:-1]), c[-1])
+            elif isinstance(c, tuple):
+                assert len(c) == 2 and isinstance(c[0], int) and isinstance(c[1], str), f'tuples must be (int, str), got {c}'
+            else:
+                raise ValueError(f'invalid cell value: {c}')
+
+
+class Board:
+    def __init__(self, top: list[list[tuple[int, str]]], side: list[list[tuple[int, str]]]):
+        assert_input(top)
+        assert_input(side)
+        self.top = top
+        self.side = side
+        self.V = len(side)
+        self.H = len(top)
+        self.unique_colors = list(set([i[1] for line in top for i in line if i != -1] + [i[1] for line in side for i in line if i != -1]))
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, dict[str, cp_model.IntVar]] = defaultdict(dict)
+        self.extra_vars = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for color in self.unique_colors:
+                self.model_vars[pos][color] = self.model.NewBoolVar(f'{pos}:{color}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(lxp.sum(list(self.model_vars[pos].values())) <= 1)
+        for i in range(self.V):
+            ground_sequence = self.side[i]
+            if tuple(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}')
+        for i in range(self.H):
+            ground_sequence = self.top[i]
+            if tuple(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[tuple[int, str]], current_sequence: list[dict[str, cp_model.IntVar]], ns: str):
+        """
+        Constrain a colored sequence (current_sequence) to match the nonogram clues in clues.
+
+        clues: e.g., [(3, 'R'), (1, 'G')] means: a run of 3 red ones, then a run of 1 green one. If two clues are next to each other and have the same color, they must be separated by at least one blank.
+        current_sequence: list of dicts of IntVar in {0,1} for each color.
+
+        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)
+        R = len(clues)
+
+        # Early infeasibility check:
+        # Minimum required blanks equals number of adjacent pairs with same color.
+        same_color_separators = sum(1 for (len_i, col_i), (len_j, col_j) in zip(clues, clues[1:]) if col_i == col_j)
+        min_needed = sum(len_i for len_i, _ in clues) + same_color_separators
+        if min_needed > L:
+            print(f"Infeasible: clues {clues} need {min_needed} cells but line length is {L} for {ns}")
+            self.model.Add(0 == 1)
+            return
+
+        # Collect the color set present in clues and in the line vars
+        clue_colors = {c for _, c in clues}
+        seq_colors = set()
+        for j in range(L):
+            seq_colors.update(current_sequence[j].keys())
+        colors = sorted(clue_colors | seq_colors)
+
+        # Start vars per run
+        starts: list[cp_model.IntVar] = []
+        self.extra_vars[f"{ns}_starts"] = starts
+        for i in range(len(clues)):
+            # s_i in [0, L] but we will bound by containment constraint below
+            s = self.model.NewIntVar(0, L, f"{ns}_s[{i}]")
+            starts.append(s)
+
+        # Ordering + separation:
+        # If same color: s[i+1] >= s[i] + len[i] + 1
+        # If different color: s[i+1] >= s[i] + len[i]
+        for i in range(R - 1):
+            len_i, col_i = clues[i]
+            _, col_next = clues[i + 1]
+            gap = 1 if col_i == col_next else 0
+            self.model.Add(starts[i + 1] >= starts[i] + len_i + gap)
+
+        # Containment: s[i] + len[i] <= L
+        for i, (run_len, _) in enumerate(clues):
+            self.model.Add(starts[i] + run_len <= L)
+
+        # Coverage booleans: cover[i][j] <=> (starts[i] <= j) AND (j < starts[i] + run_len)
+        cover = [[None] * L for _ in range(R)]
+        list_b_le = [[None] * L for _ in range(R)]
+        list_b_lt_end = [[None] * L for _ in range(R)]
+        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, (run_len, _) in enumerate(clues):
+            s_i = starts[i]
+            for j in range(L):
+                b_le = self.model.NewBoolVar(f"{ns}_le[{i},{j}]")  # s_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 = self.model.NewBoolVar(f"{ns}_lt_end[{i},{j}]")  # j < s_i + run_len  <=>  s_i + run_len - 1 >= j
+                end_expr = s_i + run_len - 1
+                self.model.Add(end_expr >= j).OnlyEnforceIf(b_lt_end)
+                self.model.Add(end_expr <= j - 1).OnlyEnforceIf(b_lt_end.Not())
+
+                b_cov = self.model.NewBoolVar(f"{ns}_cov[{i},{j}]")
+                self.model.AddBoolAnd([b_le, b_lt_end]).OnlyEnforceIf(b_cov)
+                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
+
+        # Link coverage to per-cell, per-color variables.
+        # For each color k and cell j:
+        #   sum_{i: color_i == k} cover[i][j] == current_sequence[j][k]
+        # Also tie the total cover at j to the sum over all colors at j:
+        #   sum_i cover[i][j] == sum_k current_sequence[j][k]
+        # This enforces that at most one color is active per cell (since the LHS is in {0,1} due to non-overlap).
+        # If a color var is missing in current_sequence[j], assume it’s an implicit 0 by creating a fixed zero var.
+        # (Alternatively, require the caller to provide all colors per cell.)
+        zero_cache = {}
+        def get_zero(name: str):
+            if name not in zero_cache:
+                z = self.model.NewConstant(0)
+                zero_cache[name] = z
+            return zero_cache[name]
+
+        # Pre-index runs by color for efficiency
+        runs_by_color = {k: [] for k in colors}
+        for i, (_, k) in enumerate(clues):
+            runs_by_color[k].append(i)
+
+        for j in range(L):
+            # Total coverage at cell j
+            total_cov_j = sum(cover[i][j] for i in range(R)) if R > 0 else 0
+
+            # Sum of color vars at cell j
+            color_vars_j = []
+            for k in colors:
+                v = current_sequence[j].get(k, None)
+                if v is None:
+                    v = get_zero(f"{ns}_zero_{k}")
+                color_vars_j.append(v)
+
+                # Per-color coverage equality
+                if runs_by_color[k]:
+                    self.model.Add(sum(cover[i][j] for i in runs_by_color[k]) == v)
+                else:
+                    # No runs of this color -> force cell color var to 0
+                    self.model.Add(v == 0)
+
+            # Tie total coverage to sum of color vars (blank vs exactly-one color)
+            if R > 0:
+                self.model.Add(total_cov_j == sum(color_vars_j))
+            else:
+                # No runs at all: all cells must be blank across all colors
+                for v in color_vars_j:
+                    self.model.Add(v == 0)
+
+        # Optional but strong propagation: per-color totals must match total clue lengths of that color
+        total_len_by_color = {k: 0 for k in colors}
+        for length, k in clues:
+            total_len_by_color[k] += length
+
+        for k in colors:
+            total_cells_k = sum(current_sequence[j].get(k, get_zero(f"{ns}_zero_{k}")) for j in range(L))
+            self.model.Add(total_cells_k == total_len_by_color[k])
+
+    def solve_and_print(self, verbose: bool = True, visualize_colors: Optional[dict[str, str]] = None):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: color for pos, d in board.model_vars.items() for color, var in d.items() if solver.value(var) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), ' ')))
+            if visualize_colors is not None:
+                from matplotlib import pyplot as plt
+                from matplotlib.colors import ListedColormap
+                visualize_colors[' '] = 'black'
+                visualize_colors_keys = list(visualize_colors.keys())
+                char_to_int = {c: i for i, c in enumerate(visualize_colors_keys)}
+                nums = [[char_to_int[single_res.assignment.get(get_pos(x=c, y=r), ' ')] for c in range(self.H)] for r in range(self.V)]
+                plt.imshow(nums,
+                        aspect='equal',
+                        cmap=ListedColormap([visualize_colors[c] for c in visualize_colors_keys]),
+                        extent=[0, self.H, self.V, 0])
+                plt.colorbar()
+                # plt.grid(True)
+                plt.show()
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/norinori/norinori.py

@@ -3,8 +3,9 @@ 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, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils import Pos, Shape, get_all_pos, get_char, in_bounds, get_next_pos, Direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 @dataclass
@@ -89,13 +90,7 @@ 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 = 'X' if pos in single_res.assignment else ' '
-                set_char(res, pos, c)
-            print('[')
-            for row in res:
-                print("    [ '" + "', '".join(row.tolist()) + "' ],")
-            print(']')
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(self.board),
+                is_shaded=lambda r, c: Pos(x=c, y=r) in single_res.assignment))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/nurikabe/nurikabe.py

@@ -5,7 +5,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, in_bounds, get_char, polyominoes, Shape, Direction, get_next_pos
 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
 
 
 @dataclass
@@ -122,5 +122,9 @@ class Board:
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            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: str(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: 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/palisade/palisade.py

@@ -6,7 +6,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, set_char, in_bounds, get_next_pos, Direction, polyominoes
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
-from puzzle_solver.core.utils_visualizer import id_board_to_wall_board, render_grid
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 
@@ -100,6 +100,7 @@ class Board:
             for pos in get_all_pos(self.V, self.H):
                 region_idx = single_res.assignment[pos]
                 set_char(id_board, pos, region_idx)
-            board = np.where(self.board == ' ', '·', self.board)
-            print(render_grid(id_board_to_wall_board(id_board), center_char=board))
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(id_board),
+                center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else '·'))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/pearl/pearl.py

@@ -4,16 +4,16 @@ 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, in_bounds, Direction, get_next_pos, get_char, get_opposite_direction
+from puzzle_solver.core.utils import Pos, get_all_pos, in_bounds, Direction, get_next_pos, get_char, get_opposite_direction, get_pos, set_char
 from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
     def __init__(self, board: np.ndarray):
         assert board.ndim == 2 and board.shape[0] > 0 and board.shape[1] > 0, f'board must be 2d, got {board.ndim}'
-        assert all(i.item() in [' ', 'B', 'W'] for i in np.nditer(board)), f'board must be space, B, or W, got {list(np.nditer(board))}'
-        self.V = board.shape[0]
-        self.H = board.shape[1]
+        assert all(c.item().strip() in ['', 'B', 'W'] for c in np.nditer(board)), f'board must be space, B, or W, got {list(np.nditer(board))}'
+        self.V, self.H = board.shape
         self.board = board
         self.model = cp_model.CpModel()
         self.cell_active: dict[Pos, cp_model.IntVar] = {}
@@ -36,11 +36,10 @@ class Board:
     def force_wb_constraints(self):
         for pos in get_all_pos(self.V, self.H):
             c = get_char(self.board, pos)
-            if c == 'B':
-                # must be active
-                self.model.Add(self.cell_active[pos] == 1)
-                # black circle must be a corner not connected directly to another corner
-                # must be a corner
+            if not c.strip():
+                continue
+            self.model.Add(self.cell_active[pos] == 1)  # cell must be active
+            if c == 'B':  # black circle must be a corner not connected directly to another corner
                 self.model.Add(self.cell_direction[(pos, Direction.UP)] != self.cell_direction[(pos, Direction.DOWN)])
                 self.model.Add(self.cell_direction[(pos, Direction.LEFT)] != self.cell_direction[(pos, Direction.RIGHT)])
                 # must not be connected directly to another corner
@@ -49,11 +48,7 @@ class Board:
                     if not in_bounds(q, self.V, self.H):
                         continue
                     self.model.AddImplication(self.cell_direction[(pos, direction)], self.cell_direction[(q, direction)])
-            elif c == 'W':
-                # must be active
-                self.model.Add(self.cell_active[pos] == 1)
-                # white circle must be a straight which is connected to at least one corner
-                # must be straight
+            elif c == 'W':  # white circle must be a straight which is connected to at least one corner
                 self.model.Add(self.cell_direction[(pos, Direction.UP)] == self.cell_direction[(pos, Direction.DOWN)])
                 self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == self.cell_direction[(pos, Direction.RIGHT)])
                 # must be connected to at least one corner (i.e. UP-RIGHT or UP-LEFT or DOWN-RIGHT or DOWN-LEFT or RIGHT-UP or RIGHT-DOWN or LEFT-UP or LEFT-DOWN)
@@ -94,26 +89,19 @@ class Board:
             return False
         force_connected_component(self.model, self.cell_direction, is_neighbor=is_neighbor)
 
-
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, str] = defaultdict(str)
             for (pos, direction), var in board.cell_direction.items():
                 assignment[pos] += direction.name[0] if solver.BooleanValue(var) else ''
-            for pos in get_all_pos(self.V, self.H):
-                if len(assignment[pos]) == 0:
-                    assignment[pos] = '  '
-                else:
-                    assignment[pos] = ''.join(sorted(assignment[pos]))
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=object)
-            pretty_dict = {'DU': '┃ ', 'LR': '━━', 'DL': '━┒', 'DR': '┏━', 'RU': '┗━', 'LU': '━┛', '  ': '  '}
+            output_board = np.full((self.V, self.H), '', dtype=str)
             for pos in get_all_pos(self.V, self.H):
-                c = get_char(self.board, pos)
-                c = single_res.assignment[pos]
-                c = pretty_dict[c]
-                set_char(res, pos, c)
-            print(res)
+                if get_char(self.board, pos) in ['B', 'W']:  # if the main board has a white or black pearl, put it in the output
+                    set_char(output_board, pos, get_char(self.board, pos))
+                if not single_res.assignment[pos].strip():  # if the cell does not the line through it, put a dot
+                    set_char(output_board, pos, '.')
+            print(combined_function(self.V, self.H, show_grid=False, special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)], center_char=lambda r, c: output_board[r, c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=20)

puzzle_solver/puzzles/pipes/pipes.py

@@ -4,6 +4,7 @@ from ortools.sat.python.cp_model import LinearExpr as lxp
 
 from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char, Direction, get_next_pos, get_opposite_direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
@@ -77,5 +78,5 @@ class Board:
             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(res)
+            print(combined_function(self.V, self.H, show_grid=False, show_axes=True, special_content=lambda r, c: res[r, c], center_char=lambda r, c: 'O' if len(res[r, c]) == 1 else '')),
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/range/range.py

@@ -1,8 +1,9 @@
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_neighbors4, in_bounds, Direction, get_next_pos, get_char
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, get_neighbors4, in_bounds, Direction, get_next_pos, get_char
 from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
@@ -18,88 +19,51 @@ def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
 class Board:
     def __init__(self, clues: np.ndarray):
         assert clues.ndim == 2 and clues.shape[0] > 0 and clues.shape[1] > 0, f'clues must be 2d, got {clues.ndim}'
-        assert all(isinstance(i.item(), int) and i.item() >= -1 for i in np.nditer(clues)), f'clues must be -1 or >= 0, got {list(np.nditer(clues))}'
-        self.V = clues.shape[0]
-        self.H = clues.shape[1]
+        assert all(str(i.item()).strip() == '' or str(i.item()).strip().isdecimal() for i in np.nditer(clues)), f'clues must be empty or a decimal number, got {list(np.nditer(clues))}'
+        self.V, self.H = clues.shape
         self.clues = clues
-        self.model = cp_model.CpModel()
 
-        # Core vars
-        self.b: dict[Pos, cp_model.IntVar] = {}  # 1=black, 0=white
-        self.w: dict[Pos, cp_model.IntVar] = {}  # 1=white, 0=black
+        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):
-        # Cell color vars
         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]])
+            self.w[pos] = self.b[pos].Not()
 
     def add_all_constraints(self):
         self.no_adjacent_blacks()
-        self.white_connectivity_percolation()
         self.range_clues()
+        force_connected_component(self.model, self.w)
 
     def no_adjacent_blacks(self):
-        cache = set()
         for p in get_all_pos(self.V, self.H):
             for q in get_neighbors4(p, self.V, self.H):
-                if (p, q) in cache:
-                    continue
-                cache.add((p, q))
                 self.model.Add(self.b[p] + self.b[q] <= 1)
 
-
-    def white_connectivity_percolation(self):
-        force_connected_component(self.model, self.w)
-
     def range_clues(self):
-        # For each numbered cell c with value k:
-        #   - Force it white (cannot be black)
-        #   - Build visibility chains in four directions (excluding the cell itself)
-        #   - Sum of visible whites = 1 (itself) + sum(chains) == k
-        for pos in get_all_pos(self.V, self.H):
-            k = get_char(self.clues, pos)
-            if k == -1:
+        for pos in get_all_pos(self.V, self.H):  # For each numbered cell c with value k
+            k = str(get_char(self.clues, pos)).strip()
+            if not k:
                 continue
-            # Numbered cell must be white
-            self.model.Add(self.b[pos] == 0)
-
-            # Build visibility chains per direction (exclude self)
+            self.model.Add(self.w[pos] == 1)  # Force it white
             vis_vars: list[cp_model.IntVar] = []
-            for direction in Direction:
+            for direction in Direction:  # Build visibility chains in four direction
                 ray = get_ray(pos, self.V, self.H, direction)  # cells outward
-                if not ray:
-                    continue
-                # Chain: v0 = w[ray[0]]; vt = w[ray[t]] & vt-1
-                prev = None
-                for idx, cell in enumerate(ray):
+                for idx in range(len(ray)):
                     v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                    and_constraint(self.model, target=v, cs=[self.w[p] for p in ray[:idx+1]])
                     vis_vars.append(v)
-                    if idx == 0:
-                        # v0 == w[cell]
-                        self.model.Add(v == self.w[cell])
-                    else:
-                        and_constraint(self.model, target=v, cs=[self.w[cell], prev])
-                    prev = v
-
-            # 1 (self) + sum(vis_vars) == k
-            self.model.Add(1 + sum(vis_vars) == k)
+            self.model.Add(1 + sum(vis_vars) == int(k))  # Sum of visible whites = 1 (itself) + sum(chains) == k
 
     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] = solver.Value(var)
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.Value(board.b[pos]) for pos in get_all_pos(board.V, board.H)})
         def callback(single_res: SingleSolution):
             print("Solution:")
-            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)] == 1, center_char=lambda r, c: self.clues[r, c].strip(), text_on_shaded_cells=False))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -6,7 +6,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, in_bounds, set_char, get_char, Direction, get_next_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
-from puzzle_solver.core.utils_visualizer import render_grid
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 def factor_pairs(N: int, upper_limit_i: int, upper_limit_j: int):
@@ -121,6 +121,8 @@ class Board:
                     set_char(res, pos, get_char(res, pos) + 'U')
                 if bottom_pos not in single_res.assignment or single_res.assignment[bottom_pos] != cur:
                     set_char(res, pos, get_char(res, pos) + 'D')
-            print(render_grid(res, center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else ' '))
+            print(combined_function(self.V, self.H,
+                cell_flags=lambda r, c: res[r, c],
+                center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else ' '))
 
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/shingoki/shingoki.py

@@ -7,7 +7,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_neighbors4, get_next_pos, get_char, in_bounds
 from puzzle_solver.core.utils_ortools import generic_solve_all, force_connected_component, and_constraint
-from puzzle_solver.core.utils_visualizer import render_grid
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 @dataclass(frozen=True)
@@ -154,5 +154,5 @@ class Board:
                     res[min_y][min_x] += 'L'
                 else:
                     raise ValueError(f'Invalid position: {pos} and {neighbor}')
-            print(render_grid(res, center_char='.'))
+            print(combined_function(self.V - 1, self.H - 1, cell_flags=lambda r, c: res[r, c], center_char=lambda r, c: '.'))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/singles/singles.py

@@ -3,7 +3,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos, get_pos
 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
 
 
 class Board:
@@ -45,5 +45,9 @@ class Board:
             return SingleSolution(assignment={pos: 1 if solver.Value(val) == 1 else 0 for pos, val in board.B.items()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            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.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.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/slant/slant.py

@@ -4,8 +4,9 @@ from dataclasses import dataclass
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, set_char, in_bounds, get_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, in_bounds, get_pos
 from puzzle_solver.core.utils_ortools import force_no_loops, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 @dataclass(frozen=True)
@@ -13,10 +14,10 @@ class Node:
     """The grid is represented as a graph of cells connected to corners."""
     node_type: Union[Literal["Cell"], Literal["Corner"]]
     pos: Pos
-    slant: Union[Literal["//"], Literal["\\"], None]
+    slant: Union[Literal["/"], Literal["\\"], None]
 
     def get_neighbors(self, board_nodes: dict[tuple[str, Pos, Optional[str]], "Node"]) -> list["Node"]:
-        if self.node_type == "Cell" and self.slant == "//":
+        if self.node_type == "Cell" and self.slant == "/":
             n1 = board_nodes[("Corner", get_pos(self.pos.x+1, self.pos.y), None)]
             n2 = board_nodes[("Corner", get_pos(self.pos.x, self.pos.y+1), None)]
             return [n1, n2]
@@ -27,8 +28,8 @@ class Node:
         elif self.node_type == "Corner":
             # 4 cells, 2 cells per slant
             n1 = ("Cell", get_pos(self.pos.x-1, self.pos.y-1), "\\")
-            n2 = ("Cell", get_pos(self.pos.x, self.pos.y-1), "//")
-            n3 = ("Cell", get_pos(self.pos.x-1, self.pos.y), "//")
+            n2 = ("Cell", get_pos(self.pos.x, self.pos.y-1), "/")
+            n3 = ("Cell", get_pos(self.pos.x-1, self.pos.y), "/")
             n4 = ("Cell", get_pos(self.pos.x, self.pos.y), "\\")
             return {board_nodes[n] for n in [n1, n2, n3, n4] if n in board_nodes}
 
@@ -61,9 +62,9 @@ class Board:
 
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
-            self.model_vars[(pos, '//')] = self.model.NewBoolVar(f'{pos}://')
+            self.model_vars[(pos, '/')] = self.model.NewBoolVar(f'{pos}:/')
             self.model_vars[(pos, '\\')] = self.model.NewBoolVar(f'{pos}:\\')
-            self.model.AddExactlyOne([self.model_vars[(pos, '//')], self.model_vars[(pos, '\\')]])
+            self.model.AddExactlyOne([self.model_vars[(pos, '/')], self.model_vars[(pos, '\\')]])
         for (pos, slant), v in self.model_vars.items():
             self.nodes[Node(node_type="Cell", pos=pos, slant=slant)] = v
         for pos in get_all_pos(self.V + 1, self.H + 1):
@@ -76,8 +77,8 @@ class Board:
             # when pos is (xi, yi) then it gets a +1 contribution for each:
             # - cell (xi-1, yi-1) is a "\\"
             # - cell (xi, yi) is a "\\"
-            # - cell (xi, yi-1) is a "//"
-            # - cell (xi-1, yi) is a "//"
+            # - cell (xi, yi-1) is a "/"
+            # - cell (xi-1, yi) is a "/"
             xi, yi = pos.x, pos.y
             tl_pos = get_pos(xi-1, yi-1)
             br_pos = get_pos(xi, yi)
@@ -85,8 +86,8 @@ class Board:
             bl_pos = get_pos(xi-1, yi)
             tl_var = self.model_vars[(tl_pos, '\\')] if in_bounds(tl_pos, self.V, self.H) else 0
             br_var = self.model_vars[(br_pos, '\\')] if in_bounds(br_pos, self.V, self.H) else 0
-            tr_var = self.model_vars[(tr_pos, '//')] if in_bounds(tr_pos, self.V, self.H) else 0
-            bl_var = self.model_vars[(bl_pos, '//')] if in_bounds(bl_pos, self.V, self.H) else 0
+            tr_var = self.model_vars[(tr_pos, '/')] if in_bounds(tr_pos, self.V, self.H) else 0
+            bl_var = self.model_vars[(bl_pos, '/')] if in_bounds(bl_pos, self.V, self.H) else 0
             self.model.Add(sum([tl_var, tr_var, bl_var, br_var]) == number)
         board_nodes = {(node.node_type, node.pos, node.slant): node for node in self.nodes.keys()}
         self.neighbor_dict = {node: node.get_neighbors(board_nodes) for node in self.nodes.keys()}
@@ -106,12 +107,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):
-                set_char(res, pos, '/' if single_res.assignment[pos] == '//' else '\\')
-            print('[')
-            for row in range(self.V):
-                line = '    [ ' + ' '.join(res[row].tolist()) + ' ]'
-                print(line)
-            print(']')
+            print(combined_function(self.V, self.H, center_char=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)