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

puzzle_solver/puzzles/n_queens/n_queens.py

@@ -0,0 +1,71 @@
+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_char, get_pos, get_row_pos, get_col_pos, Direction8, get_ray
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array, id_to_count: Optional[dict[int, int]] = None):
+        """
+        board is a 2d array of location ids
+        id_to_count is a dict of int to int, where the key is the id of the location and the value is the count of the queens on that location
+        """
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only digits'
+        assert id_to_count is None or (isinstance(id_to_count, dict) and all(isinstance(k, int) and isinstance(v, int) for k, v in id_to_count.items())), 'id_to_count must be a dict of int to int'
+        self.board = board
+        self.V, self.H = board.shape
+        self.location_ids = set([int(c.item()) for c in np.nditer(board)])
+        self.location_ids_to_pos: dict[int, set[Pos]] = defaultdict(set)
+        for pos in get_all_pos(self.V, self.H):
+            self.location_ids_to_pos[int(get_char(self.board, pos))].add(pos)
+        self.id_to_count = id_to_count
+        if self.id_to_count is None:
+            self.id_to_count = {id_: 1 for id_ in self.location_ids}
+
+        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):
+            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        # every row has at most one queen
+        for row in range(self.V):
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in get_row_pos(row, self.H)]) <= 1)
+        # every column has at most one queen
+        for col in range(self.H):
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in get_col_pos(col, self.V)]) <= 1)
+        # every diagonal has at most one queen
+        for pos in get_col_pos(0, self.V):  # down-right diagonal on left border
+            ray = get_ray(pos, Direction8.DOWN_RIGHT, self.V, self.H, include_self=True)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        for pos in get_row_pos(0, self.H):  # down-right diagonal on top border
+            ray = get_ray(pos, Direction8.DOWN_RIGHT, self.V, self.H, include_self=True)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        for pos in get_row_pos(0, self.H):  # down-left diagonal on top
+            ray = get_ray(pos, Direction8.DOWN_LEFT, self.V, self.H, include_self=True)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        for pos in get_col_pos(self.H - 1, self.V):  # down-left diagonal on right border
+            ray = get_ray(pos, Direction8.DOWN_LEFT, self.V, self.H, include_self=True)
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in ray]) <= 1)
+        # every id has at most count queens
+        for id_ in self.location_ids:
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in self.location_ids_to_pos[id_]]) == self.id_to_count[id_])
+
+    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(var) for pos, var in board.model_vars.items()})
+        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))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/nonograms/nonograms.py

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

puzzle_solver/puzzles/nonograms/nonograms_colored.py

@@ -0,0 +1,220 @@
+from collections import defaultdict
+from typing import Optional
+
+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, 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

@@ -0,0 +1,96 @@
+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, 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
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    orientation: str
+    body: set[Pos]
+    disallow: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.ndarray):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.board = board
+        self.V, self.H = board.shape
+        assert all((c == ' ') or str(c).isdecimal() for c in np.nditer(board)), "board must contain space or digits"
+        self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
+        self.blocks = {i: [pos for pos in get_all_pos(self.V, self.H) if int(get_char(self.board, pos)) == i] for i in self.block_numbers}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.shapes_on_board: list[ShapeOnBoard] = []
+
+        self.create_vars()
+        self.init_shapes_on_board()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def init_shapes_on_board(self):
+        for pos in get_all_pos(self.V, self.H):
+            shape = self.get_shape(pos, 'horizontal')
+            if shape is not None:
+                self.shapes_on_board.append(shape)
+            shape = self.get_shape(pos, 'vertical')
+            if shape is not None:
+                self.shapes_on_board.append(shape)
+
+    def add_all_constraints(self):
+        # if a piece is active then all its body is active and the disallow is inactive
+        for shape in self.shapes_on_board:
+            for pos in shape.body:
+                self.model.Add(self.model_vars[pos] == 1).OnlyEnforceIf(shape.is_active)
+            for pos in shape.disallow:
+                self.model.Add(self.model_vars[pos] == 0).OnlyEnforceIf(shape.is_active)
+        # if a spot is active then exactly one piece (with a body there) is active
+        for pos in get_all_pos(self.V, self.H):
+            pieces_on_pos = [shape for shape in self.shapes_on_board if pos in shape.body]
+            # if pos is on then exactly one shape is active. if pos is off then 0 shapes are active.
+            self.model.Add(sum(shape.is_active for shape in pieces_on_pos) == self.model_vars[pos])
+        # every region must have exactly 2 spots active.
+        for block in self.blocks.values():
+            self.model.Add(sum(self.model_vars[pos] for pos in block) == 2)
+
+    def get_shape(self, pos: Pos, orientation: str) -> Shape:
+        assert orientation in ['horizontal', 'vertical'], 'orientation must be horizontal or vertical'
+        if orientation == 'horizontal':
+            body = {pos, get_next_pos(pos, Direction.RIGHT)}
+        else:
+            body = {pos, get_next_pos(pos, Direction.DOWN)}
+        if any(not in_bounds(p, self.V, self.H) for p in body):
+            return None
+        disallow = set(get_next_pos(p, direction) for p in body for direction in Direction)
+        disallow = {p for p in disallow if p not in body and in_bounds(p, self.V, self.H)}
+        shape_on_board = ShapeOnBoard(
+            is_active=self.model.NewBoolVar(f'horizontal:{pos}'),
+            orientation='horizontal',
+            body=body,
+            disallow=disallow,
+        )
+        return shape_on_board
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: "Board", solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos in get_all_pos(self.V, self.H):
+                if solver.Value(self.model_vars[pos]) == 1:
+                    assignment[pos] = get_char(self.board, pos)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            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/number_path/number_path.py

@@ -0,0 +1,76 @@
+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_char, get_next_pos, get_pos, in_bounds, Direction8, 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, start: Pos, end: Pos):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        assert in_bounds(start, self.V, self.H) and in_bounds(end, self.V, self.H), 'start and end must be within the board'
+        self.numbers = sorted(set(int(c.item()) for c in np.nditer(board)))
+        self.numbers_to_next: dict[int, int] = {}
+        for i in range(len(self.numbers) - 1):
+            self.numbers_to_next[self.numbers[i]] = self.numbers[i + 1]
+        self.numbers_to_next[self.numbers[-1]] = self.numbers[0]
+        self.start = start
+        self.end = end
+
+        self.model = cp_model.CpModel()
+        self.from_to: dict[tuple[Pos, Direction8], cp_model.IntVar] = {}
+        self.to_from: dict[tuple[Pos, Direction8], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            if pos == self.end:  # end shouldn't point
+                continue
+            target = self.numbers_to_next[int(get_char(self.board, pos))]
+            for direction in Direction8:
+                next_pos = get_next_pos(pos, direction)
+                if not in_bounds(next_pos, self.V, self.H):
+                    continue
+                if next_pos == self.start:  # nothing should point at the start
+                    continue
+                if int(get_char(self.board, next_pos)) != target:
+                    continue
+                self.from_to[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+                self.to_from[(next_pos, get_opposite_direction(direction))] = self.from_to[(pos, direction)]
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            if pos == self.end:  # end shouldn't point
+                continue
+            all_dirs = [self.from_to[(pos, direction)] for direction in Direction8 if (pos, direction) in self.from_to]
+            assert len(all_dirs) > 0, f'no directions found for pos {pos}'
+            self.model.Add(lxp.Sum(all_dirs) == 1)
+        for pos in get_all_pos(self.V, self.H):
+            if pos == self.start:  # start shouldn't be pointed at
+                continue
+            all_dirs = [self.to_from[(pos, direction)] for direction in Direction8 if (pos, direction) in self.to_from]
+            assert len(all_dirs) > 0, f'no directions found for pos {pos}'
+            self.model.Add(lxp.Sum(all_dirs) == 1)
+
+        def is_neighbor(pd1: tuple[Pos, Direction8], pd2: tuple[Pos, Direction8]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if get_next_pos(p1, d1) == p2 or p1 == p2 or get_next_pos(p2, d2) == p1:
+                return True
+            return False
+        force_connected_component(self.model, self.from_to, is_neighbor=is_neighbor)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: direction.name for (pos, direction), var in board.from_to.items() if solver.Value(var) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            arrows = {Direction8.UP.name: '↑', Direction8.DOWN.name: '↓', Direction8.LEFT.name: '←', Direction8.RIGHT.name: '→', Direction8.UP_LEFT.name: '↖', Direction8.UP_RIGHT.name: '↗', Direction8.DOWN_LEFT.name: '↙', Direction8.DOWN_RIGHT.name: '↘', ' ': ' '}
+            print(combined_function(self.V, self.H, center_char=lambda r, c: arrows[single_res.assignment.get(get_pos(x=c, y=r), ' ')]))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)