multi-puzzle-solver 1.1.8__py3-none-any.whl

puzzle_solver/puzzles/numbermaze/numbermaze.py

@@ -0,0 +1,97 @@
+from collections import defaultdict
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_char, get_next_pos, get_opposite_direction, get_pos, in_bounds
+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:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() in [' ', '#']) or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        number_set = set(int(c.item()) for c in np.nditer(board) if str(c.item()).isdecimal())
+        self.N = max(number_set)
+        assert number_set == set(range(1, self.N + 1)), 'numbers must be consecutive integers starting from 1'
+        self.board = board
+        self.V, self.H = board.shape
+        self.fixed_pos: dict[Pos, int] = {pos: int(get_char(self.board, pos).strip()) for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos).strip() not in ['', '#']}
+        self.board_char: dict[Pos, str] = {pos: get_char(self.board, pos).strip() for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos).strip() != '#'}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, int], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in self.board_char:
+            for direction in Direction:
+                next_pos = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if not in_bounds(next_pos, self.V, self.H):
+                    continue
+                if get_char(self.board, next_pos).strip() == '#':
+                    continue
+                if (next_pos, opposite_direction) in self.model_vars:
+                    self.model_vars[(pos, direction)] = self.model_vars[(next_pos, opposite_direction)]
+                else:
+                    self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def is_neighbor(self, pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+        p1, d1 = pd1
+        p2, d2 = pd2
+        if p1 == p2:
+            return True
+        p1_pointing_to_p2 = get_next_pos(p1, d1) == p2
+        if not p1_pointing_to_p2:
+            return False
+        is_fixed = d2 == 'FIXED_NODE'  # pointing to a fixed node
+        return is_fixed or d2 == get_opposite_direction(d1)
+
+    def add_all_constraints(self):
+        for pos, c in self.fixed_pos.items():
+            target = 1 if (c == self.N) or (c == 1) else 2
+            self.model.Add(lxp.Sum([var for (p, _), var in self.model_vars.items() if p == pos]) == target)
+        for pos in self.board_char:
+            if pos in self.fixed_pos:
+                continue
+            self.model.Add(lxp.Sum([var for (p, _), var in self.model_vars.items() if p == pos]) == 2)
+        force_connected_component(self.model, self.model_vars, is_neighbor=self.is_neighbor)
+        self.implement_height_constraints()
+
+    def implement_height_constraints(self):
+        """Every node has a height equal to every other non-fixed node that is connected to it. or equal to (+0 or +1) of the height of a fixed node it is connected to"""
+        nodes = [(k, v) for k, v in self.model_vars.items() if k[0] not in self.fixed_pos]  # filter out fixed positions
+        fixed_nodes = [(pos, 'FIXED_NODE') for pos in self.fixed_pos]
+        node_heights = {(pos, 'FIXED_NODE'): self.model.NewConstant(c) for pos, c in self.fixed_pos.items()}
+        for k, v in nodes:
+            node_heights[k] = self.model.NewIntVar(0, self.N, f'node_height[{k}]')
+            self.model.Add(node_heights[k] == 0).OnlyEnforceIf(v.Not())
+        for (k, v) in nodes:
+            h = node_heights[k]
+            connected_nodes = [(k2, v2) for k2, v2 in nodes if self.is_neighbor(k, k2)]
+            for (k2, v2) in connected_nodes:  # all pairs of non-fixed nodes that are connected to each other must have the same height
+                self.model.Add(h == node_heights[k2]).OnlyEnforceIf([v, v2])
+            connected_fixed_nodes = [node_heights[k2] for k2 in fixed_nodes if self.is_neighbor(k, k2)]
+            for h2 in connected_fixed_nodes:  # connected to fixed node must have height of fixed node or 1 higher
+                zero_or_one = self.model.NewBoolVar(f'zero_or_one[{k}]')  # node with height h can be connected to fixed node with height h or h+1
+                self.model.Add(zero_or_one == 0).OnlyEnforceIf([v.Not()])
+                self.model.Add(h == h2 + zero_or_one).OnlyEnforceIf([v])
+
+    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 in get_all_pos(self.V, self.H):
+                for direction in Direction:
+                    if (pos, direction) in board.model_vars and solver.Value(board.model_vars[(pos, direction)]) == 1:
+                        assignment[pos] += direction.name[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, show_border_only=True, is_shaded=lambda r, c: get_char(self.board, get_pos(x=c, y=r)).strip() == '#',
+                special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] if get_pos(x=c, y=r) in single_res.assignment else None,
+                center_char=lambda r, c: get_char(self.board, get_pos(x=c, y=r)).strip().replace('#', '')))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/nurikabe/nurikabe.py

@@ -0,0 +1,130 @@
+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, 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 combined_function
+
+
+@dataclass
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    N: int
+    body: set[Pos]
+    force_water: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() == ' ') or str(c.item()).isdecimal() or c.item() == '#' for c in np.nditer(board)), 'board must contain only space, #, or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.illegal_positions: set[Pos] = {pos for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos) == '#'}
+
+        unique_numbers: set[int] = {int(c) for c in np.nditer(board) if str(c).isdecimal()}
+        self.polyominoes: dict[int, set[Shape]] = {n: polyominoes(n) for n in unique_numbers}
+        self.hints = {pos: int(get_char(self.board, pos)) for pos in get_all_pos(self.V, self.H) if str(get_char(self.board, pos)).isdecimal()}
+        self.all_hint_pos: set[Pos] = set(self.hints.keys())
+
+        self.model = cp_model.CpModel()
+        self.W: dict[Pos, cp_model.IntVar] = {}
+        self.B: dict[Pos, cp_model.IntVar] = {}
+        self.shapes_on_board: list[ShapeOnBoard] = []
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in self.get_all_legal_pos():
+            self.W[pos] = self.model.NewBoolVar(f'W:{pos}')
+            self.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+            self.model.AddExactlyOne([self.W[pos], self.B[pos]])
+
+    def get_all_legal_pos(self) -> set[Pos]:
+        return {pos for pos in get_all_pos(self.V, self.H) if pos not in self.illegal_positions}
+
+    def in_bounds_and_legal(self, pos: Pos) -> bool:
+        return in_bounds(pos, self.V, self.H) and pos not in self.illegal_positions
+
+    def add_all_constraints(self):
+        for pos in self.W.keys():
+            self.model.AddExactlyOne([self.W[pos], self.B[pos]])
+
+        # init shapes on board for each hint
+        for hint_pos, hint_value in self.hints.items():
+            hint_shapes = []
+            for shape in self.polyominoes[hint_value]:
+                hint_single_shape = self.init_shape_on_board(shape, hint_pos, hint_value)  # a "single shape" is translated many times
+                hint_shapes.extend(hint_single_shape)
+            assert len(hint_shapes) > 0, f'no shapes found for hint {hint_pos} with value {hint_value}'
+            self.model.AddExactlyOne([s.is_active for s in hint_shapes])
+            self.shapes_on_board.extend(hint_shapes)
+
+        # if no shape is active on the spot then it must be black
+        for pos in self.get_all_legal_pos():
+            shapes_here = [s for s in self.shapes_on_board if pos in s.body]
+            self.model.AddExactlyOne([s.is_active for s in shapes_here] + [self.B[pos]])
+
+        # if a shape is active, then all its body must be white and force water must be black
+        for shape_on_board in self.shapes_on_board:
+            for pos in shape_on_board.body:
+                self.model.Add(self.W[pos] == 1).OnlyEnforceIf(shape_on_board.is_active)
+            for pos in shape_on_board.force_water:
+                self.model.Add(self.B[pos] == 1).OnlyEnforceIf(shape_on_board.is_active)
+
+        # disallow 2x2 blacks
+        for pos in get_all_pos(self.V, self.H):
+            tl = pos
+            tr = get_next_pos(pos, Direction.RIGHT)
+            bl = get_next_pos(pos, Direction.DOWN)
+            br = get_next_pos(bl, Direction.RIGHT)
+            if any(not in_bounds(p, self.V, self.H) for p in [tl, tr, bl, br]):
+                continue
+            self.model.AddBoolOr([self.B[tl].Not(), self.B[tr].Not(), self.B[bl].Not(), self.B[br].Not()])
+
+        # all black is single connected component
+        force_connected_component(self.model, self.B)
+
+    def init_shape_on_board(self, shape: Shape, hint_pos: Pos, hint_value: int):
+        other_hint_pos: set[Pos] = self.all_hint_pos - {hint_pos}
+        max_x = max(p.x for p in shape)
+        max_y = max(p.y for p in shape)
+        hint_shapes = []
+        for dx in range(0, max_x + 1):
+            for dy in range(0, max_y + 1):
+                body = {get_pos(x=p.x + hint_pos.x - dx, y=p.y + hint_pos.y - dy) for p in shape}  # translate shape by fixed hint position then dynamic moving dx and dy
+                if hint_pos not in body:  # the hint must still be in the body after translation
+                    continue
+                if any(not self.in_bounds_and_legal(p) for p in body):  # illegal shape
+                    continue
+                water = set(p for pos in body for p in get_neighbors4(pos, self.V, self.H))
+                water -= body
+                water -= self.illegal_positions
+                if any(p in other_hint_pos for p in body) or any(w in other_hint_pos for w in water):  # shape touches another hint or forces water on another hint, illegal
+                    continue
+                shape_on_board = ShapeOnBoard(
+                    is_active=self.model.NewBoolVar(f'{hint_pos}:{dx}:{dy}:is_active'),
+                    N=hint_value,
+                    body=body,
+                    force_water=water,
+                )
+                hint_shapes.append(shape_on_board)
+        return hint_shapes
+
+    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)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            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

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+from collections import defaultdict
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, 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 combined_function, id_board_to_wall_fn
+
+
+Shape = frozenset[Pos]  # a shape on the 2d board is just a set of positions
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    shape: Shape
+    shape_id: int
+    body: set[Pos]
+
+
+def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
+    # give a shape and a board, return all valid translations of the shape that are fully contained in the board AND consistent with the clues on the board
+    shape_list = list(shape)
+    shape_borders = []  # will contain the number of borders for each pos in the shape; this has to be consistent with the clues on the board
+    for pos in shape_list:
+        v = 0
+        for direction in Direction:
+            next_pos = get_next_pos(pos, direction)
+            if not in_bounds(next_pos, board.shape[0], board.shape[1]) or next_pos not in shape:
+                v += 1
+        shape_borders.append(v)
+    shape_list = [(p.x, p.y) for p in shape_list]
+    # 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)
+            for i, p in enumerate(body):
+                c = board[p[1], p[0]]
+                if c != ' ' and c != str(shape_borders[i]):  # there is a clue and it doesn't match my translated shape, skip
+                    break
+            else:
+                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'
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        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.V, self.H = board.shape
+        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()
+        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = defaultdict(set)
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for shape in self.polyominoes:
+            for body in get_valid_translations(shape, self.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
+                )
+                self.shapes_on_board.append(shape_on_board)
+                for pos in body:
+                    self.pos_to_shapes[pos].add(shape_on_board)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # each position has exactly one shape active
+            self.model.AddExactlyOne(shape.is_active for shape in self.pos_to_shapes[pos])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            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")
+            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

@@ -0,0 +1,107 @@
+from collections import defaultdict
+
+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, 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(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] = {}
+        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):
+            self.cell_active[pos] = self.model.NewBoolVar(f"a[{pos}]")
+            for direction in Direction:
+                self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f"b[{pos}]->({direction.name})")
+
+    def add_all_constraints(self):
+        self.force_direction_constraints()
+        self.force_wb_constraints()
+        self.force_connected_component()
+
+    def force_wb_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            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
+                for direction in Direction:
+                    q = get_next_pos(pos, direction)
+                    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':  # 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)
+                aux_list: list[cp_model.IntVar] = []
+                for direction in Direction:
+                    q = get_next_pos(pos, direction)
+                    if not in_bounds(q, self.V, self.H):
+                        continue
+                    ortho_directions = {Direction.UP, Direction.DOWN, Direction.LEFT, Direction.RIGHT} - {direction, get_opposite_direction(direction)}
+                    for ortho_direction in ortho_directions:
+                        aux = self.model.NewBoolVar(f"A[{pos}]<-({q})")
+                        and_constraint(self.model, target=aux, cs=[self.cell_direction[(q, ortho_direction)], self.cell_direction[(pos, direction)]])
+                        aux_list.append(aux)
+                self.model.Add(lxp.Sum(aux_list) >= 1)
+
+    def force_direction_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            # cell active means exactly 2 directions are active, cell not active means no directions are active
+            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())
+            # X having right means the cell to its right has left and so on for all directions
+            for direction in Direction:
+                q = get_next_pos(pos, direction)
+                if in_bounds(q, self.V, self.H):
+                    self.model.Add(self.cell_direction[(pos, direction)] == self.cell_direction[(q, get_opposite_direction(direction))])
+                else:
+                    self.model.Add(self.cell_direction[(pos, direction)] == 0)
+
+    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):
+        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 ''
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            output_board = np.full((self.V, self.H), '', dtype=str)
+            for pos in get_all_pos(self.V, self.H):
+                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

@@ -0,0 +1,82 @@
+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, 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:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item().strip() in ['1', '2L', '2I', '3', '4'] for c in np.nditer(board)), 'board must contain only 1, 2L, 2I, 3, 4. Found:' + str(set(c.item().strip() for c in np.nditer(board)) - set(['1', '2L', '2I', '3', '4']))
+        self.board = board
+        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.V, self.H):
+            for direction in Direction:
+                mirrored = (get_next_pos(pos, direction), get_opposite_direction(direction))
+                if mirrored in self.model_vars:
+                    self.model_vars[(pos, direction)] = self.model_vars[mirrored]
+                else:
+                    self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.force_position(pos, get_char(self.board, pos).strip())
+        # single connected component
+        self.force_connected_component()
+
+    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.model_vars, is_neighbor=is_neighbor)
+
+    def force_position(self, pos: Pos, value: str):
+        # cells with 1 or 3 or 4 neighbors each only have 1 unique state under rotational symmetry
+        # cells with 2 neighbors can either be a straight line (2I) or curved line (2L)
+        if value == '1':
+            self.model.Add(lxp.sum([self.model_vars[(pos, direction)] for direction in Direction]) == 1)
+        elif value == '2L':
+            self.model.Add(self.model_vars[(pos, Direction.LEFT)] != self.model_vars[(pos, Direction.RIGHT)])
+            self.model.Add(self.model_vars[(pos, Direction.UP)] != self.model_vars[(pos, Direction.DOWN)])
+        elif value == '2I':
+            self.model.Add(self.model_vars[(pos, Direction.LEFT)] == self.model_vars[(pos, Direction.RIGHT)])
+            self.model.Add(self.model_vars[(pos, Direction.UP)] == self.model_vars[(pos, Direction.DOWN)])
+            self.model.Add(self.model_vars[(pos, Direction.UP)] != self.model_vars[(pos, Direction.RIGHT)])
+        elif value == '3':
+            self.model.Add(lxp.sum([self.model_vars[(pos, direction)] for direction in Direction]) == 3)
+        elif value == '4':
+            self.model.Add(lxp.sum([self.model_vars[(pos, direction)] for direction in Direction]) == 4)
+        else:
+            raise ValueError(f'invalid value: {value}')
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment = {}
+            for pos in get_all_pos(self.V, self.H):
+                assignment[pos] = ''
+                for direction in Direction:
+                    if solver.Value(board.model_vars[(pos, direction)]) == 1:
+                        assignment[pos] += direction.name[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                set_char(res, pos, single_res.assignment[pos])
+            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

@@ -0,0 +1,59 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, get_neighbors4, Direction, get_char, get_ray
+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, 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(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()
+        self.b: dict[Pos, cp_model.IntVar] = {}
+        self.w: dict[Pos, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.b[pos] = self.model.NewBoolVar(f"b[{pos}]")
+            self.w[pos] = self.b[pos].Not()
+
+    def add_all_constraints(self):
+        self.no_adjacent_blacks()
+        self.range_clues()
+        force_connected_component(self.model, self.w)
+
+    def no_adjacent_blacks(self):
+        for p in get_all_pos(self.V, self.H):
+            for q in get_neighbors4(p, self.V, self.H):
+                self.model.Add(self.b[p] + self.b[q] <= 1)
+
+    def range_clues(self):
+        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
+            self.model.Add(self.w[pos] == 1)  # Force it white
+            vis_vars: list[cp_model.IntVar] = []
+            for direction in Direction:  # Build visibility chains in four direction
+                ray = get_ray(pos, direction, self.V, self.H)  # 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.w[p] for p in ray[:idx+1]])
+                    vis_vars.append(v)
+            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:
+            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:")
+            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)