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

puzzle_solver/puzzles/pearl/pearl.py

@@ -0,0 +1,151 @@
+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, set_char, in_bounds, Direction, get_next_pos, get_char, get_opposite_direction
+from puzzle_solver.core.utils_ortools import and_constraint, or_constraint, generic_solve_all, SingleSolution
+
+
+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]
+        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.reach_layers: list[dict[Pos, cp_model.IntVar]] = []  # R_t[p] booleans, t = 0..T
+
+        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})")
+        # Percolation layers R_t (monotone flood fill)
+        T = self.V * self.H  # large enough to cover whole board
+        for t in range(T + 1):
+            Rt: dict[Pos, cp_model.IntVar] = {}
+            for pos in get_all_pos(self.V, self.H):
+                Rt[pos] = self.model.NewBoolVar(f"R[{t}][{pos}]")
+            self.reach_layers.append(Rt)
+
+    def add_all_constraints(self):
+        self.force_direction_constraints()
+        self.force_wb_constraints()
+        self.connectivity_percolation()
+
+    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
+                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':
+                # 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
+                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 connectivity_percolation(self):
+        """
+        Layered percolation:
+            - root is exactly the first cell
+            - R_t is monotone nondecreasing in t (R_t+1 >= R_t)
+            - A cell can 'turn on' at layer t+1 iff has a neighbor on at layer t and the neighbor is pointing to it (or is root)
+            - Final layer is all connected
+        """
+        # Seed: R0 = root
+        for i, pos in enumerate(get_all_pos(self.V, self.H)):
+            if i == 0:
+                self.model.Add(self.reach_layers[0][pos] == 1)  # first cell is root
+            else:
+                self.model.Add(self.reach_layers[0][pos] == 0)
+
+        for t in range(1, len(self.reach_layers)):
+            Rt_prev = self.reach_layers[t - 1]
+            Rt = self.reach_layers[t]
+            for p in get_all_pos(self.V, self.H):
+                # Rt[p] = Rt_prev[p] | (white[p] & Rt_prev[neighbour #1]) | (white[p] & Rt_prev[neighbour #2]) | ...
+                # Create helper (white[p] & Rt_prev[neighbour #X]) for each neighbor q
+                neigh_helpers: list[cp_model.IntVar] = []
+                for direction in Direction:
+                    q = get_next_pos(p, direction)
+                    if not in_bounds(q, self.V, self.H):
+                        continue
+                    a = self.model.NewBoolVar(f"A[{t}][{p}]<-({q})")
+                    and_constraint(self.model, target=a, cs=[Rt_prev[q], self.cell_direction[(q, get_opposite_direction(direction))]])
+                    neigh_helpers.append(a)
+                or_constraint(self.model, target=Rt[p], cs=[Rt_prev[p]] + neigh_helpers)
+
+        # every pearl must be reached by the final layer
+        for p in get_all_pos(self.V, self.H):
+            self.model.Add(self.reach_layers[-1][p] == 1).OnlyEnforceIf(self.cell_active[p])
+
+
+    def solve_and_print(self):
+        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': '━┛', '  ': '  '}
+            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)
+        return generic_solve_all(self, board_to_solution, callback=callback, max_solutions=20)

puzzle_solver/puzzles/range/range.py

@@ -0,0 +1,154 @@
+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_ortools import and_constraint, or_constraint, generic_solve_all, SingleSolution
+
+
+def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
+    out = []
+    while True:
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, V, H):
+            break
+        out.append(pos)
+    return out
+
+
+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]
+        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
+        # Connectivity helpers
+        self.root: dict[Pos, cp_model.IntVar] = {}       # exactly one root; root <= w
+        self.reach_layers: list[dict[Pos, cp_model.IntVar]] = []  # R_t[p] booleans, t = 0..T
+
+        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]])
+
+        # Root
+        for pos in get_all_pos(self.V, self.H):
+            self.root[pos] = self.model.NewBoolVar(f"root[{pos}]")
+
+        # Percolation layers R_t (monotone flood fill)
+        T = self.V * self.H  # large enough to cover whole board
+        for t in range(T + 1):
+            Rt: dict[Pos, cp_model.IntVar] = {}
+            for pos in get_all_pos(self.V, self.H):
+                Rt[pos] = self.model.NewBoolVar(f"R[{t}][{pos}]")
+            self.reach_layers.append(Rt)
+
+    def add_all_constraints(self):
+        self.no_adjacent_blacks()
+        self.white_connectivity_percolation()
+        self.range_clues()
+
+    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):
+        """
+        Layered percolation:
+          - root is exactly the first white cell
+          - R_t is monotone nondecreasing in t (R_t+1 >= R_t)
+          - A cell can 'turn on' at layer t+1 iff it's white and has a neighbor on at layer t (or is root)
+          - Final layer is equal to the white mask: R_T[p] == w[p]  => all whites are connected to the unique root
+        """
+        # to find unique solutions easily, we make only 1 possible root allowed; root is exactly the first white cell
+        prev_cells_black: list[cp_model.IntVar] = []
+        for pos in get_all_pos(self.V, self.H):
+            and_constraint(self.model, target=self.root[pos], cs=[self.w[pos]] + prev_cells_black)
+            prev_cells_black.append(self.b[pos])
+
+        # Seed: R0 = root
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(self.reach_layers[0][pos] == self.root[pos])
+
+        T = len(self.reach_layers)
+        for t in range(1, T):
+            Rt_prev = self.reach_layers[t - 1]
+            Rt = self.reach_layers[t]
+            for p in get_all_pos(self.V, self.H):
+                # Rt[p] = Rt_prev[p] | (white[p] & Rt_prev[neighbour #1]) | (white[p] & Rt_prev[neighbour #2]) | ...
+                # Create helper (white[p] & Rt_prev[neighbour #X]) for each neighbor q
+                neigh_helpers: list[cp_model.IntVar] = []
+                for q in get_neighbors4(p, self.V, self.H):
+                    a = self.model.NewBoolVar(f"A[{t}][{p}]<-({q})")
+                    and_constraint(self.model, target=a, cs=[self.w[p], Rt_prev[q]])
+                    neigh_helpers.append(a)
+                or_constraint(self.model, target=Rt[p], cs=[Rt_prev[p]] + neigh_helpers)
+
+        # All whites must be reached by the final layer
+        RT = self.reach_layers[T - 1]
+        for p in get_all_pos(self.V, self.H):
+            self.model.Add(RT[p] == self.w[p])
+
+    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:
+                continue
+            # Numbered cell must be white
+            self.model.Add(self.b[pos] == 0)
+
+            # Build visibility chains per direction (exclude self)
+            vis_vars: list[cp_model.IntVar] = []
+            for direction in 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):
+                    v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                    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)
+
+    def solve_and_print(self):
+        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:")
+            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)
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/signpost/signpost.py

@@ -0,0 +1,95 @@
+from enum import Enum
+
+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, set_char, in_bounds, get_next_pos, Direction, get_row_pos, get_col_pos, Direction8
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+CHAR_TO_DIRECTION8 = {
+    'Q': Direction8.UP_LEFT,
+    'W': Direction8.UP,
+    'E': Direction8.UP_RIGHT,
+    'A': Direction8.LEFT,
+    'D': Direction8.RIGHT,
+    'Z': Direction8.DOWN_LEFT,
+    'X': Direction8.DOWN,
+    'C': Direction8.DOWN_RIGHT,
+}
+
+
+def beam(pos: Pos, V: int, H: int, direction: Direction8) -> list[Pos]:
+    out = []
+    while True:
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, V, H):
+            break
+        out.append(pos)
+    return out
+
+class Board:
+    def __init__(self, board: np.array, values: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert values.ndim == 2, f'values must be 2d, got {values.ndim}'
+        assert board.shape == values.shape, f'board and values must have the same shape, got {board.shape} and {values.shape}'
+        self.board = board
+        self.values = values
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.N = self.V * self.H
+        assert all(int(c.item()) >= 0 and int(c.item()) <= self.N for c in np.nditer(values)), 'values must contain only integers between 0 and N'
+
+        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(V=self.V, H=self.H):
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        # constrain clues
+        for pos in get_all_pos(V=self.V, H=self.H):
+            c = int(get_char(self.values, pos))
+            if c == 0:
+                continue
+            self.model.Add(self.model_vars[pos] == c)
+        # all values are unique
+        self.model.AddAllDifferent(list(self.model_vars.values()))
+        # arrow for x points to x+1
+        for pos in get_all_pos(V=self.V, H=self.H):
+            c = get_char(self.board, pos)
+            if c == ' ':
+                continue
+            direction = CHAR_TO_DIRECTION8[c]
+            self.constrain_plus_one(pos, direction)
+    
+    def constrain_plus_one(self, pos: Pos, direction: Direction8):
+        beam_res = beam(pos, self.V, self.H, direction)
+        is_eq_list = []
+        for p in beam_res:
+            aux = self.model.NewBoolVar(f'{pos}:{p}')
+            self.model.Add(self.model_vars[p] == self.model_vars[pos] + 1).OnlyEnforceIf(aux)
+            self.model.Add(self.model_vars[p] != self.model_vars[pos] + 1).OnlyEnforceIf(aux.Not())
+            is_eq_list.append(aux)
+        self.model.Add(lxp.Sum(is_eq_list) == 1)
+    
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.Value(var)
+            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(V=self.V, H=self.H):
+                c = get_char(self.board, pos)
+                c = single_res.assignment[pos]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback, max_solutions=20)

puzzle_solver/puzzles/singles/singles.py

@@ -0,0 +1,116 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint, or_constraint
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] == board.shape[1], 'board must be square'
+        self.board = board
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.N = self.V * self.H
+        self.idx_of: dict[Pos, int] = get_all_pos_to_idx_dict(self.V, self.H)
+
+        self.model = cp_model.CpModel()
+        self.B = {} # black squares
+        self.Num = {} # value of squares (Num = N + idx if black, else board[pos])
+        # Connectivity helpers
+        self.root: dict[Pos, cp_model.IntVar] = {}       # exactly one root; root <= w
+        self.reach_layers: list[dict[Pos, cp_model.IntVar]] = []  # R_t[p] booleans, t = 0..T
+
+        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'{pos}')
+            self.Num[pos] = self.model.NewIntVar(0, 2*self.N, f'{pos}')
+            self.model.Add(self.Num[pos] == self.N + self.idx_of[pos]).OnlyEnforceIf(self.B[pos])
+            self.model.Add(self.Num[pos] == int(get_char(self.board, pos))).OnlyEnforceIf(self.B[pos].Not())
+        # Root
+        for pos in get_all_pos(self.V, self.H):
+            self.root[pos] = self.model.NewBoolVar(f"root[{pos}]")
+        # Percolation layers R_t (monotone flood fill)
+        for t in range(self.N + 1):
+            Rt: dict[Pos, cp_model.IntVar] = {}
+            for pos in get_all_pos(self.V, self.H):
+                Rt[pos] = self.model.NewBoolVar(f"R[{t}][{pos}]")
+            self.reach_layers.append(Rt)
+
+    def add_all_constraints(self):
+        self.no_adjacent_blacks()
+        self.no_number_appears_twice()
+        self.white_connectivity_percolation()
+
+    def no_adjacent_blacks(self):
+        # no two black squares are adjacent 
+        for pos in get_all_pos(self.V, self.H):
+            for neighbor in get_neighbors4(pos, self.V, self.H):
+                self.model.Add(self.B[pos] + self.B[neighbor] <= 1)
+
+    def no_number_appears_twice(self):
+        # no number appears twice in any row or column (numbers are ignored if black)
+        for row in range(self.V):
+            var_list = [self.Num[pos] for pos in get_row_pos(row, self.H)]
+            self.model.AddAllDifferent(var_list)
+        for col in range(self.H):
+            var_list = [self.Num[pos] for pos in get_col_pos(col, self.V)]
+            self.model.AddAllDifferent(var_list)
+
+    def white_connectivity_percolation(self):
+        """
+        Layered percolation:
+          - root is exactly the first white cell
+          - R_t is monotone nondecreasing in t (R_t+1 >= R_t)
+          - A cell can 'turn on' at layer t+1 iff it's white and has a neighbor on at layer t (or is root)
+          - Final layer is equal to the white mask: R_T[p] == w[p]  => all whites are connected to the unique root
+        """
+        # to find unique solutions easily, we make only 1 possible root allowed; root is exactly the first white cell
+        prev_cells_black: list[cp_model.IntVar] = []
+        for pos in get_all_pos(self.V, self.H):
+            and_constraint(self.model, target=self.root[pos], cs=[self.B[pos].Not()] + prev_cells_black)
+            prev_cells_black.append(self.B[pos])
+
+        # Seed: R0 = root
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(self.reach_layers[0][pos] == self.root[pos])
+
+        T = len(self.reach_layers)
+        for t in range(1, T):
+            Rt_prev = self.reach_layers[t - 1]
+            Rt = self.reach_layers[t]
+            for p in get_all_pos(self.V, self.H):
+                # Rt[p] = Rt_prev[p] | (white[p] & Rt_prev[neighbour #1]) | (white[p] & Rt_prev[neighbour #2]) | ...
+                # Create helper (white[p] & Rt_prev[neighbour #X]) for each neighbor q
+                neigh_helpers: list[cp_model.IntVar] = []
+                for q in get_neighbors4(p, self.V, self.H):
+                    a = self.model.NewBoolVar(f"A[{t}][{p}]<-({q})")
+                    and_constraint(self.model, target=a, cs=[self.B[p].Not(), Rt_prev[q]])
+                    neigh_helpers.append(a)
+                or_constraint(self.model, target=Rt[p], cs=[Rt_prev[p]] + neigh_helpers)
+
+        # All whites must be reached by the final layer
+        RT = self.reach_layers[T - 1]
+        for p in get_all_pos(self.V, self.H):
+            self.model.Add(RT[p] == self.B[p].Not())
+
+
+    def solve_and_print(self):
+        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")
+            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 = 'B' if single_res.assignment[pos] == 1 else ' '
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/sudoku/sudoku.py

@@ -0,0 +1,90 @@
+from typing import Union
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_pos, get_all_pos, get_char, set_char, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def get_value(board: np.array, pos: Pos) -> Union[int, str]:
+    c = get_char(board, pos)
+    if c == '*':
+        return c
+    if str(c).isdecimal():
+        return int(c)
+    # a,b,... maps to 10,11,...
+    return ord(c) - ord('a') + 10
+
+
+def set_value(board: np.array, pos: Pos, value: Union[int, str]):
+    if value == '*':
+        value = '*'
+    elif value < 10:
+        value = str(value)
+    else:
+        value = chr(value - 10 + ord('a'))
+    set_char(board, pos, value)
+
+
+def get_block_pos(i: int, B: int) -> list[Pos]:
+    top_left_x = (i%B)*B
+    top_left_y = (i//B)*B
+    return [get_pos(x=top_left_x + x, y=top_left_y + y) for x in range(B) for y in range(B)]
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] == board.shape[1], 'board must be square'
+        assert all(isinstance(i.item(), str) and len(i.item()) == 1 and (i.item().isalnum() or i.item() == '*') for i in np.nditer(board)), 'board must contain only alphanumeric characters or *'
+        self.board = board
+        self.N = board.shape[0]
+        self.B = np.sqrt(self.N)  # block size
+        assert self.B.is_integer(), 'board size must be a perfect square'
+        self.B = int(self.B)
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.N):
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        # some squares are already filled
+        for pos in get_all_pos(self.N):
+            c = get_value(self.board, pos)
+            if c != '*':
+                self.model.Add(self.model_vars[pos] == c)
+        # every number appears exactly once in each row, each column and each block
+        # each row
+        for row in range(self.N):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.N)]
+            self.model.AddAllDifferent(row_vars)
+        # each column
+        for col in range(self.N):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.N)]
+            self.model.AddAllDifferent(col_vars)
+        # each block
+        for block_i in range(self.N):
+            block_vars = [self.model_vars[p] for p in get_block_pos(block_i, self.B)]
+            self.model.AddAllDifferent(block_vars)
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.N, self.N), ' ', dtype=object)
+            for pos in get_all_pos(self.N):
+                c = get_value(self.board, pos)
+                c = single_res.assignment[pos]
+                set_value(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)