multi-puzzle-solver 1.0.4__py3-none-any.whl → 1.0.7__py3-none-any.whl

puzzle_solver/puzzles/norinori/norinori.py

@@ -3,9 +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 id_board_to_wall_board, render_grid
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 @dataclass
@@ -90,14 +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(render_grid(id_board_to_wall_board(self.board), center_char=lambda r, c: 'X' if (Pos(x=c, y=r) in single_res.assignment) else ' '))
+            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,12 +6,10 @@ 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
 
 
-
-# a shape on the 2d board is just a set of positions
-Shape = frozenset[Pos]
+Shape = frozenset[Pos]  # a shape on the 2d board is just a set of positions
 
 @dataclass(frozen=True)
 class ShapeOnBoard:
@@ -36,7 +34,6 @@ def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
     # min x/y is always 0
     max_x = max(p[0] for p in shape_list)
     max_y = max(p[1] for p in shape_list)
-
     for dy in range(0, board.shape[0] - max_y):
         for dx in range(0, board.shape[1] - max_x):
             body = tuple((p[0] + dx, p[1] + dy) for p in shape_list)
@@ -48,7 +45,6 @@ def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
                 yield frozenset(get_pos(x=p[0], y=p[1]) for p in body)
 
 
-
 class Board:
     def __init__(self, board: np.array, region_size: int):
         assert region_size >= 1 and isinstance(region_size, int), 'region_size must be an integer greater than or equal to 1'
@@ -59,7 +55,6 @@ class Board:
         self.region_size = region_size
         self.region_count = (self.V * self.H) // self.region_size
         assert self.region_count * self.region_size == self.V * self.H, f'region_size must be a factor of the board size, got {self.region_size} and {self.region_count}'
-
         self.polyominoes = polyominoes(self.region_size)
 
         self.model = cp_model.CpModel()
@@ -74,9 +69,7 @@ class Board:
                 uid = len(self.shapes_on_board)
                 shape_on_board = ShapeOnBoard(
                     is_active=self.model.NewBoolVar(f'{uid}:is_active'),
-                    shape=shape,
-                    shape_id=uid,
-                    body=body,
+                    shape=shape, shape_id=uid, body=body
                 )
                 self.shapes_on_board.append(shape_on_board)
                 for pos in body:
@@ -88,18 +81,11 @@ 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 shape in board.shapes_on_board:
-                if solver.Value(shape.is_active) == 1:
-                    for pos in shape.body:
-                        assignment[pos] = shape.shape_id
-            return SingleSolution(assignment=assignment)
+            active_shapes = [shape for shape in board.shapes_on_board if solver.Value(shape.is_active) == 1]
+            return SingleSolution(assignment={pos: shape.shape_id for shape in active_shapes for pos in shape.body})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            id_board = np.full((self.V, self.H), ' ', dtype=object)
-            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(np.array([[single_res.assignment[get_pos(x=c, y=r)] for c in range(self.H)] for r in range(self.V)])),
+                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

@@ -1,35 +1,20 @@
-import json
-from dataclasses import dataclass
-import time
+from collections import defaultdict
 
 import numpy as np
 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 import Direction, Pos, get_all_pos, get_next_pos, get_char, in_bounds, set_char, get_pos, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, force_connected_component, and_constraint, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
-@dataclass(frozen=True)
-class SingleSolution:
-    assignment: dict[tuple[Pos, Pos], int]
-
-    def get_hashable_solution(self) -> str:
-        result = []
-        for (pos, neighbor), v in self.assignment.items():
-            result.append((pos.x, pos.y, neighbor.x, neighbor.y, v))
-        return json.dumps(result, sort_keys=True)
-
-
-def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[tuple[Pos, Pos]]:
+def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
     out = []
-    prev_pos = pos
     while True:
+        out.append(pos)
         pos = get_next_pos(pos, direction)
         if not in_bounds(pos, V, H):
             break
-        out.append((prev_pos, pos))
-        prev_pos = pos
     return out
 
 
@@ -37,8 +22,8 @@ class Board:
     def __init__(self, board: np.array):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
         assert all((c.item().strip() == '') or (str(c.item())[:-1].isdecimal() and c.item()[-1].upper() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only space or digits and B/W'
-
         self.V, self.H = board.shape
+        self.board = board
         self.board_numbers: dict[Pos, int] = {}
         self.board_colors: dict[Pos, str] = {}
         for pos in get_all_pos(self.V, self.H):
@@ -47,112 +32,84 @@ class Board:
                 continue
             self.board_numbers[pos] = int(c[:-1])
             self.board_colors[pos] = c[-1].upper()
+
         self.model = cp_model.CpModel()
-        self.edge_vars: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.cell_active: dict[Pos, cp_model.IntVar] = {}
+        self.cell_direction: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
 
         self.create_vars()
         self.add_all_constraints()
 
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
-            for neighbor in get_neighbors4(pos, self.V, self.H):
-                if (neighbor, pos) in self.edge_vars:  # already added in opposite direction
-                    self.edge_vars[(pos, neighbor)] = self.edge_vars[(neighbor, pos)]
-                else:  # new edge
-                    self.edge_vars[(pos, neighbor)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
+            self.cell_active[pos] = self.model.NewBoolVar(f'{pos}')
+            for direction in Direction:
+                neighbor = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if not in_bounds(neighbor, self.V, self.H):
+                    self.cell_direction[(pos, direction)] = self.model.NewConstant(0)
+                    continue
+                if (neighbor, opposite_direction) in self.cell_direction:
+                    self.cell_direction[(pos, direction)] = self.cell_direction[(neighbor, opposite_direction)]
+                else:
+                    self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
 
     def add_all_constraints(self):
-        # each corners must have either 0 or 2 neighbors
-        for pos in get_all_pos(self.V, self.H):
-            corner_connections = [self.edge_vars[(pos, n)] for n in get_neighbors4(pos, self.V, self.H)]
-            if pos not in self.board_numbers:  # no color, either 0 or 2 edges
-                self.model.AddLinearExpressionInDomain(sum(corner_connections), cp_model.Domain.FromValues([0, 2]))
-            else:  # color, must have exactly 2 edges
-                self.model.Add(sum(corner_connections) == 2)
-
-        # enforce colors
         for pos in get_all_pos(self.V, self.H):
+            s = sum([self.cell_direction[(pos, direction)] for direction in Direction])
+            self.model.Add(s == 2).OnlyEnforceIf(self.cell_active[pos])
+            self.model.Add(s == 0).OnlyEnforceIf(self.cell_active[pos].Not())
             if pos not in self.board_numbers:
                 continue
-            self.enforce_corner_color(pos, self.board_colors[pos])
-            self.enforce_corner_number(pos, self.board_numbers[pos])
-
-        # enforce single connected component
-        def is_neighbor(edge1: tuple[Pos, Pos], edge2: tuple[Pos, Pos]) -> bool:
-            return any(c1 == c2 for c1 in edge1 for c2 in edge2)
-        force_connected_component(self.model, self.edge_vars, is_neighbor=is_neighbor)
+            self.enforce_corner_color_and_number(pos, self.board_colors[pos], self.board_numbers[pos])  # enforce colors and number
+        self.force_connected_component()  # enforce single connected component
 
-    def enforce_corner_color(self, pos: Pos, pos_color: str):
-        assert pos_color in ['W', 'B'], f'Invalid color: {pos_color}'
-        pos_r = get_next_pos(pos, Direction.RIGHT)
-        var_r = self.edge_vars[(pos, pos_r)] if (pos, pos_r) in self.edge_vars else False
-        pos_d = get_next_pos(pos, Direction.DOWN)
-        var_d = self.edge_vars[(pos, pos_d)] if (pos, pos_d) in self.edge_vars else False
-        pos_l = get_next_pos(pos, Direction.LEFT)
-        var_l = self.edge_vars[(pos, pos_l)] if (pos, pos_l) in self.edge_vars else False
-        pos_u = get_next_pos(pos, Direction.UP)
-        var_u = self.edge_vars[(pos, pos_u)] if (pos, pos_u) in self.edge_vars else False
+    def enforce_corner_color_and_number(self, pos: Pos, pos_color: str, pos_number: int):
+        assert pos_color in ['W', 'B'] and pos_number > 0, f'Invalid color or number: {pos_color}, {pos_number}'
+        self.model.Add(self.cell_active[pos] == 1)
         if pos_color == 'W':  # White circles must be passed through in a straight line
-            self.model.Add(var_r == var_l)
-            self.model.Add(var_u == var_d)
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == self.cell_direction[(pos, Direction.LEFT)])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == self.cell_direction[(pos, Direction.UP)])
         elif pos_color == 'B':  # Black circles must be turned upon
-            self.model.Add(var_r == 0).OnlyEnforceIf([var_l])
-            self.model.Add(var_l == 0).OnlyEnforceIf([var_r])
-            self.model.Add(var_u == 0).OnlyEnforceIf([var_d])
-            self.model.Add(var_d == 0).OnlyEnforceIf([var_u])
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.LEFT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.RIGHT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.UP)]])
+            self.model.Add(self.cell_direction[(pos, Direction.UP)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.DOWN)]])
         else:
             raise ValueError(f'Invalid color: {pos_color}')
-
-    def enforce_corner_number(self, pos: Pos, pos_number: int):
-        # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
-        # Build visibility chains per direction (exclude self)
-        vis_vars: list[cp_model.IntVar] = []
-        for direction in Direction:
-            rays = get_ray(pos, self.V, self.H, direction)  # cells outward
-            if not rays:
-                continue
-            # Chain: v0 = w[ray[0]]; vt = w[ray[t]] & vt-1
-            prev = None
-            for idx, (pos1, pos2) in enumerate(rays):
-                v = self.model.NewBoolVar(f"vis[{pos1}-{pos2}]->({direction.name})[{idx}]")
+        vis_vars: list[cp_model.IntVar] = []  # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
+        for direction in Direction:  # Build visibility chains in four direction
+            ray = get_ray(pos, self.V, self.H, direction)  # cells outward
+            for idx in range(len(ray)):
+                v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                and_constraint(self.model, target=v, cs=[self.cell_direction[(p, direction)] for p in ray[:idx+1]])
                 vis_vars.append(v)
-                if idx == 0:
-                    # v0 == w[cell]
-                    self.model.Add(v == self.edge_vars[(pos1, pos2)])
-                else:
-                    and_constraint(self.model, target=v, cs=[self.edge_vars[(pos1, pos2)], prev])
-                prev = v
         self.model.Add(sum(vis_vars) == pos_number)
 
+    def force_connected_component(self):
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if p1 == p2 and d1 != d2:  # same position, different direction, is neighbor
+                return True
+            if get_next_pos(p1, d1) == p2 and d2 == get_opposite_direction(d1):
+                return True
+            return False
+        force_connected_component(self.model, self.cell_direction, is_neighbor=is_neighbor)
 
     def solve_and_print(self, verbose: bool = True):
-        tic = time.time()
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[tuple[Pos, Pos], int] = {}
-            for (pos, neighbor), var in board.edge_vars.items():
-                assignment[(pos, neighbor)] = solver.Value(var)
+            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 ''
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
-            nonlocal tic
-            print(f"Solution found in {time.time() - tic:.2f} seconds")
-            tic = time.time()
-            res = np.full((self.V - 1, self.H - 1), ' ', dtype=object)
-            for (pos, neighbor), v in single_res.assignment.items():
-                if v == 0:
-                    continue
-                min_x = min(pos.x, neighbor.x)
-                min_y = min(pos.y, neighbor.y)
-                dx = abs(pos.x - neighbor.x)
-                dy = abs(pos.y - neighbor.y)
-                if min_x == self.H - 1:  # only way to get right
-                    res[min_y][min_x - 1] += 'R'
-                elif min_y == self.V - 1:  # only way to get down
-                    res[min_y - 1][min_x] += 'D'
-                elif dx == 1:
-                    res[min_y][min_x] += 'U'
-                elif dy == 1:
-                    res[min_y][min_x] += 'L'
-                else:
-                    raise ValueError(f'Invalid position: {pos} and {neighbor}')
-            print(render_grid(res, center_char='.'))
+            print("Solution found")
+            output_board = np.full((self.V, self.H), '', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if get_char(self.board, pos)[-1] 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)

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)