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

puzzle_solver/puzzles/sudoku/sudoku.py

@@ -0,0 +1,267 @@
+from typing import Union, Optional
+from collections import defaultdict
+
+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 and_constraint, generic_solve_all, or_constraint, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def get_value(board: np.array, pos: Pos) -> Union[int, str]:
+    c = get_char(board, pos).lower()
+    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, Bv: int, Bh: int) -> list[Pos]:
+    # Think: Bv=3 and Bh=4 while the board has 4 vertical blocks and 3 horizontal blocks
+    top_left_x = (i%Bv)*Bh
+    top_left_y = (i//Bv)*Bv
+    return [get_pos(x=top_left_x + x, y=top_left_y + y) for x in range(Bh) for y in range(Bv)]
+
+
+class Board:
+    def __init__(self,
+            board: np.array,
+            constrain_blocks: bool = True,
+            block_size: Optional[tuple[int, int]] = None,
+            sandwich: Optional[dict[str, list[int]]] = None,
+            unique_diagonal: bool = False,
+            jigsaw: Optional[np.array] = None,
+            killer: Optional[tuple[np.array, dict[str, int]]] = None,
+            ):
+        """
+        board: 2d array of characters
+        constrain_blocks: whether to constrain the blocks. If True, each block must contain all numbers from 1 to 9 exactly once.
+        block_size: tuple of block size (vertical, horizontal). If not provided, the block size is the square root of the board size.
+        sandwich: dictionary of sandwich clues (side, bottom). If provided, the sum of the values between 1 and 9 for each row and column is equal to the clue.
+        unique_diagonal: whether to constrain the 2 diagonals to be unique. If True, each diagonal must contain all numbers from 1 to 9 exactly once.
+        killer: tuple of (killer board, killer clues). If provided, the killer board must be a 2d array of ids of the killer blocks. The killer clues must be a dictionary of killer block ids to clues.
+            Each numbers in a killer block must be unique and sum to the clue.
+        """
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        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 space'
+        self.board = board
+        self.V, self.H = board.shape
+        self.L = max(self.V, self.H)
+        self.constrain_blocks = constrain_blocks
+        self.unique_diagonal = unique_diagonal
+        self.sandwich = None
+        self.jigsaw_id_to_pos = None
+        self.killer = None
+
+        if self.constrain_blocks:
+            if block_size is None:
+                B = np.sqrt(self.V)  # block size
+                assert B.is_integer(), 'board size must be a perfect square or provide block_size'
+                Bv, Bh = int(B), int(B)
+            else:
+                Bv, Bh = block_size
+                assert Bv * Bh == self.V, 'block size must be a factor of board size'
+            # can be different in 4x3 for example
+            self.Bv = Bv
+            self.Bh = Bh
+            self.B = Bv * Bh  # block count
+        else:
+            assert block_size is None, 'cannot set block size if blocks are not constrained'
+
+        if jigsaw is not None:
+            if self.constrain_blocks:
+                print('Warning: jigsaw and blocks are both constrained, are you sure you want to do this?')
+            assert jigsaw.ndim == 2, f'jigsaw must be 2d, got {jigsaw.ndim}'
+            assert jigsaw.shape[0] == self.V and jigsaw.shape[1] == self.H, 'jigsaw must be the same size as the board'
+            assert all(isinstance(i.item(), str) and i.item().isdecimal() for i in np.nditer(jigsaw)), 'jigsaw must contain only digits or space'
+            self.jigsaw_id_to_pos: dict[int, list[Pos]] = defaultdict(list)
+            for pos in get_all_pos(self.V, self.H):
+                v = get_char(jigsaw, pos)
+                if v.isdecimal():
+                    self.jigsaw_id_to_pos[int(v)].append(pos)
+            assert all(len(pos_list) <= self.L for pos_list in self.jigsaw_id_to_pos.values()), 'jigsaw areas cannot be larger than the number of digits'
+
+        if sandwich is not None:
+            assert set(sandwich.keys()) == set(['side', 'bottom']), 'sandwich must contain only side and bottom'
+            assert len(sandwich['side']) == self.H, 'side must be equal to board width'
+            assert len(sandwich['bottom']) == self.V, 'bottom must be equal to board height'
+            self.sandwich = sandwich
+
+        if killer is not None:
+            assert killer[0].ndim == 2, f'killer board must be 2d, got {killer[0].ndim}'
+            assert killer[0].shape[0] == self.V and killer[0].shape[1] == self.H, 'killer board must be the same size as the board'
+            assert all(isinstance(i.item(), str) and i.item().isdecimal() for i in np.nditer(killer[0])), 'killer board must contain only digits or space'
+            assert set(killer[1].keys()).issubset(set(killer[0].flatten())), f'killer clues must contain all killer block ids, {set(killer[0].flatten()) - set(killer[1].keys())}'
+            self.killer = killer
+
+        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.NewIntVar(1, self.L, f'{pos}')
+
+    def add_all_constraints(self):
+        # some squares are already filled
+        for pos in get_all_pos(self.V, self.H):
+            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.V):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, H=self.H)]
+            self.model.AddAllDifferent(row_vars)
+        # each column
+        for col in range(self.H):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, V=self.V)]
+            self.model.AddAllDifferent(col_vars)
+        if self.constrain_blocks:  # each block must contain all numbers from 1 to 9 exactly once
+            for block_i in range(self.B):
+                block_vars = [self.model_vars[p] for p in get_block_pos(block_i, Bv=self.Bv, Bh=self.Bh)]
+                self.model.AddAllDifferent(block_vars)
+        if self.sandwich is not None:
+            self.add_sandwich_constraints()
+        if self.unique_diagonal:
+            self.add_unique_diagonal_constraints()
+        if self.jigsaw_id_to_pos is not None:
+            self.add_jigsaw_constraints()
+        if self.killer is not None:
+            self.add_killer_constraints()
+
+    def add_sandwich_constraints(self):
+        """Sandwich constraints, enforce that the sum of the values between 1 and 9 for each row and column is equal to the clue."""
+        for c, clue in enumerate(self.sandwich['bottom']):
+            if clue is None or int(clue) < 0:
+                continue
+            col_vars = [self.model_vars[p] for p in get_col_pos(c, V=self.V)]
+            add_single_sandwich(col_vars, int(clue), self.model, name=f"sand_side_{c}")
+        for r, clue in enumerate(self.sandwich['side']):
+            if clue is None or int(clue) < 0:
+                continue
+            row_vars = [self.model_vars[p] for p in get_row_pos(r, H=self.H)]
+            add_single_sandwich(row_vars, int(clue), self.model, name=f"sand_bottom_{r}")
+
+    def add_unique_diagonal_constraints(self):
+        main_diagonal_vars = [self.model_vars[get_pos(x=i, y=i)] for i in range(min(self.V, self.H))]
+        self.model.AddAllDifferent(main_diagonal_vars)
+        anti_diagonal_vars = [self.model_vars[get_pos(x=i, y=self.V-i-1)] for i in range(min(self.V, self.H))]
+        self.model.AddAllDifferent(anti_diagonal_vars)
+
+    def add_jigsaw_constraints(self):
+        """All digits in one jigsaw area must be unique."""
+        for pos_list in self.jigsaw_id_to_pos.values():
+            self.model.AddAllDifferent([self.model_vars[p] for p in pos_list])
+
+    def add_killer_constraints(self):
+        """Killer constraints, enforce that the sum of the values in each killer block is equal to the clue and all numbers in a block are unique."""
+        killer_board, killer_clues = self.killer
+        # change clue keys to ints
+        killer_clues = {int(k): v for k, v in killer_clues.items()}
+        killer_id_to_pos = defaultdict(list)
+        for pos in get_all_pos(self.V, self.H):
+            v = get_char(killer_board, pos)
+            if v.isdecimal():
+                killer_id_to_pos[int(v)].append(pos)
+        for killer_id, pos_list in killer_id_to_pos.items():
+            self.model.AddAllDifferent([self.model_vars[p] for p in pos_list])
+            clue = killer_clues[killer_id]
+            self.model.Add(sum([self.model_vars[p] for p in pos_list]) == clue)
+
+    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")
+            val_arr = np.array([[single_res.assignment[get_pos(x=c, y=r)] for c in range(self.H)] for r in range(self.V)])
+            print(combined_function(self.V, self.H, center_char=lambda r, c: val_arr[r, c] if val_arr[r, c] < 10 else chr(val_arr[r, c] - 10 + ord('a'))))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
+
+
+
+def add_single_sandwich(vars_line: list[cp_model.IntVar], clue: int, model: cp_model.CpModel, name: str):
+    # VAR count:
+    # is_min: L
+    # is_max: L
+    # pos_min/max/lt: 1+1+1
+    # between: L
+    # a1/a2/case_a: L+L+L
+    # b1/b2/case_b: L+L+L
+    # take: L
+    # 10L+3 per 1 call of the function (i.e. per 1 line)
+    # entire board will have 2L lines (rows and columns)
+    # in total: 20L^2+6L
+
+    L = len(vars_line)
+    is_min = [model.NewBoolVar(f"{name}_ismin_{i}") for i in range(L)]
+    is_max = [model.NewBoolVar(f"{name}_ismax_{i}") for i in range(L)]
+    for i, v in enumerate(vars_line):
+        model.Add(v == 1).OnlyEnforceIf(is_min[i])
+        model.Add(v != 1).OnlyEnforceIf(is_min[i].Not())
+        model.Add(v == L).OnlyEnforceIf(is_max[i])
+        model.Add(v != L).OnlyEnforceIf(is_max[i].Not())
+
+    # index of the minimum and maximum values (sum of the values inbetween must = clue)
+    pos_min = model.NewIntVar(0, L - 1, f"{name}_pos_min")
+    pos_max = model.NewIntVar(0, L - 1, f"{name}_pos_max")
+    model.Add(pos_min == sum(i * is_min[i] for i in range(L)))
+    model.Add(pos_max == sum(i * is_max[i] for i in range(L)))
+
+    # used later to handle both cases (A. pos_min < pos_max and B. pos_max < pos_min)
+    lt = model.NewBoolVar(f"{name}_lt")  # pos_min < pos_max ?
+    model.Add(pos_min < pos_max).OnlyEnforceIf(lt)
+    model.Add(pos_min >= pos_max).OnlyEnforceIf(lt.Not())
+
+    between = [model.NewBoolVar(f"{name}_between_{i}") for i in range(L)]
+    for i in range(L):
+        # Case A: pos_min < i < pos_max (AND lt is true)
+        a1 = model.NewBoolVar(f"{name}_a1_{i}")  # pos_min < i
+        a2 = model.NewBoolVar(f"{name}_a2_{i}")  # i < pos_max
+
+        model.Add(pos_min < i).OnlyEnforceIf(a1)
+        model.Add(pos_min >= i).OnlyEnforceIf(a1.Not())
+        model.Add(i < pos_max).OnlyEnforceIf(a2)
+        model.Add(i >= pos_max).OnlyEnforceIf(a2.Not())
+
+        case_a = model.NewBoolVar(f"{name}_caseA_{i}")
+        and_constraint(model, case_a, [lt, a1, a2])
+
+        # Case B: pos_max < i < pos_min (AND lt is false)
+        b1 = model.NewBoolVar(f"{name}_b1_{i}")  # pos_max < i
+        b2 = model.NewBoolVar(f"{name}_b2_{i}")  # i < pos_min
+
+        model.Add(pos_max < i).OnlyEnforceIf(b1)
+        model.Add(pos_max >= i).OnlyEnforceIf(b1.Not())
+        model.Add(i < pos_min).OnlyEnforceIf(b2)
+        model.Add(i >= pos_min).OnlyEnforceIf(b2.Not())
+
+        case_b = model.NewBoolVar(f"{name}_caseB_{i}")
+        and_constraint(model, case_b, [lt.Not(), b1, b2])
+
+        # between[i] is true if we're in case A or case B
+        or_constraint(model, between[i], [case_a, case_b])
+
+    # sum values at indices that are "between"
+    take = [model.NewIntVar(0, L, f"{name}_take_{i}") for i in range(L)]
+    for i, v in enumerate(vars_line):
+        # take[i] = v if between[i] else 0
+        model.Add(take[i] == v).OnlyEnforceIf(between[i])
+        model.Add(take[i] == 0).OnlyEnforceIf(between[i].Not())
+
+    model.Add(sum(take) == clue)

puzzle_solver/puzzles/suguru/suguru.py

@@ -0,0 +1,55 @@
+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_char, get_neighbors8, get_pos
+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
+
+
+class Board:
+    def __init__(self, id_board: np.array, num_board: np.array):
+        assert id_board.ndim == 2, f'id_board must be 2d, got {id_board.ndim}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(id_board)), 'id_board must contain only digits'
+        assert num_board.ndim == 2, f'num_board must be 2d, got {num_board.ndim}'
+        assert all(str(c.item()).strip() == '' or str(c.item()).isdecimal() for c in np.nditer(num_board)), 'num_board must contain only space or digits'
+        assert id_board.shape == num_board.shape, f'id_board and num_board must have the same shape, got {id_board.shape} and {num_board.shape}'
+        self.id_board = id_board
+        self.num_board = num_board
+        self.V, self.H = id_board.shape
+        self.ids = {int(c.item()) for c in np.nditer(id_board)}
+        self.id_to_pos: dict[int, set[Pos]] = defaultdict(set)
+        for pos in get_all_pos(self.V, self.H):
+            self.id_to_pos[int(get_char(self.id_board, pos))].add(pos)
+        self.N = max([len(v) for v in self.id_to_pos.values()])
+
+        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.NewIntVar(1, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        for cage in self.ids:
+            cage_vars = [self.model_vars[pos] for pos in self.id_to_pos[cage]]
+            self.model.AddAllDifferent(cage_vars)
+            for pos in self.id_to_pos[cage]:
+                self.model.Add(self.model_vars[pos] <= len(cage_vars))
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.num_board, pos).strip()
+            if c:  # force clues
+                self.model.Add(self.model_vars[pos] == int(c))
+            for n in get_neighbors8(pos, self.V, self.H):
+                self.model.Add(self.model_vars[pos] != self.model_vars[n])
+
+    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, center_char=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)]), cell_flags=id_board_to_wall_fn(self.id_board)))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/suko/suko.py

@@ -0,0 +1,54 @@
+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_pos
+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, quadrant: np.array, color_sums: dict[str, int]):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item().strip() != '' for c in np.nditer(board)), 'board must contain only non-empty strings'
+        self.V, self.H = board.shape
+        self.colors = {c.item().strip() for c in np.nditer(board)}
+        assert quadrant.shape == (self.V-1, self.H-1), f'quadrant must be {(self.V-1, self.H-1)}, got {quadrant.shape}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(quadrant)), 'quadrant must contain only digits'
+        assert set(color_sums.keys()) == self.colors, f'color_sums must contain all colors, missing {self.colors - set(color_sums.keys())} and extra {set(color_sums.keys()) - self.colors}'
+        self.N = self.V * self.H
+        self.board = board
+        self.quadrant = quadrant
+        self.color_sums = color_sums
+        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.NewIntVar(1, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        self.model.AddAllDifferent(list(self.model_vars.values()))  # all numbers are unique
+        for color in self.colors:  # enforce color sums
+            color_sum = self.color_sums[color]
+            color_vars = [self.model_vars[pos] for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos) == color]
+            self.model.Add(lxp.Sum(color_vars) == color_sum)
+        for pos in get_all_pos(self.V - 1, self.H - 1):  # enforce the 2x2 sums
+            quadrant_sum = int(get_char(self.quadrant, pos))
+            tl = pos
+            tr = get_next_pos(tl, Direction.RIGHT)
+            bl = get_next_pos(tl, Direction.DOWN)
+            br = get_next_pos(bl, Direction.RIGHT)
+            quadrant = np.array([self.model_vars[tl], self.model_vars[tr], self.model_vars[bl], self.model_vars[br]])
+            self.model.Add(lxp.Sum(quadrant) == quadrant_sum)
+
+    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, center_char=lambda r, c: single_res.assignment[get_pos(x=c, y=r)]))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/tapa/tapa.py

@@ -0,0 +1,97 @@
+from typing import Union
+from itertools import combinations
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Direction8, Pos, get_all_pos, get_char, in_bounds, Direction, get_next_pos, get_pos, get_neighbors4
+from puzzle_solver.core.utils_ortools import SingleSolution, force_connected_component_using_demand, generic_unique_projections
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def rotated_assignments_N_nums(Xs: tuple[int, ...], target_length: int = 8) -> set[tuple[bool, ...]]:
+    """ Given Xs = [X1, X2, ..., Xm] (each Xi >= 1), build all unique length-`target_length`
+        boolean lists of the form: [ True*X1, False*N1, True*X2, False*N2, ..., True*Xm, False*Nm ]
+        where each Ni >= 1 and sum(Xs) + sum(Ni) = target_length,
+        including all `target_length` wrap-around rotations, de-duplicated.
+    """
+    assert len(Xs) >= 1 and all(x >= 1 for x in Xs), "Xs must have at least one block length and all Xi must be >= 1."
+    assert sum(Xs) + len(Xs) <= target_length, f"sum(Xs) + len(Xs) <= target_length required; got {sum(Xs)} + {len(Xs)} > {target_length}"
+    num_zero_blocks = len(Xs)
+    total_zeros = target_length - sum(Xs)
+    seen: set[tuple[bool, ...]] = set()
+    for cut_positions in combinations(range(1, total_zeros), num_zero_blocks - 1):
+        cut_positions = (*cut_positions, total_zeros)
+        Ns = [cut_positions[0]]  # length of zero blocks
+        for i in range(1, len(cut_positions)):
+            Ns.append(cut_positions[i] - cut_positions[i - 1])
+        base: list[bool] = []
+        for x, n in zip(Xs, Ns):
+            base.extend([True] * x)
+            base.extend([False] * n)
+        for dx in range(target_length):  # all rotations (wrap-around)
+            rot = tuple(base[dx:] + base[:dx])
+            seen.add(rot)
+    return seen
+
+
+class Board:
+    def __init__(self, board: np.array, separator: str = '/'):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(all(str(c).strip().isdecimal() or str(c).strip() == '' for c in cell.item().split(separator)) for cell in np.nditer(board)), 'board must contain only digits and separator'
+        self.V, self.H = board.shape
+        self.board = board
+        self.separator = separator
+        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):
+        # 2x2 blacks are not allowed
+        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.model_vars[tl].Not(), self.model_vars[tr].Not(), self.model_vars[bl].Not(), self.model_vars[br].Not()])
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c.strip() == '':
+                continue
+            clue = tuple(int(x.strip()) for x in c.split(self.separator))
+            self.model.Add(self.model_vars[pos] == 0)  # clue cannot be black
+            self.enforce_clue(pos, clue)  # each clue must be satisfied
+        # all blacks are connected
+        force_connected_component_using_demand(self.model, self.model_vars)
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(sum([self.model_vars[n] for n in get_neighbors4(pos, self.V, self.H)]) > 0).OnlyEnforceIf(self.model_vars[pos])
+
+    def enforce_clue(self, pos: Pos, clue: Union[int, tuple[int, int]]):
+        neighbors = []
+        for direction in [Direction8.UP, Direction8.UP_RIGHT, Direction8.RIGHT, Direction8.DOWN_RIGHT, Direction8.DOWN, Direction8.DOWN_LEFT, Direction8.LEFT, Direction8.UP_LEFT]:
+            n = get_next_pos(pos, direction)
+            neighbors.append(self.model_vars[n] if in_bounds(n, self.V, self.H) else self.model.NewConstant(False))
+        valid_assignments = rotated_assignments_N_nums(Xs=clue)
+        self.model.AddAllowedAssignments(neighbors, valid_assignments)
+
+    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")
+            def get_c(c: str) -> str:
+                return (' ' * (2 - len(c)) + c) if len(c) <= 3 else '...'
+            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: get_c(self.board[r, c]),
+                text_on_shaded_cells=False
+            ))
+        project_vars = list(self.model_vars.values())
+        return generic_unique_projections(self, project_vars, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/tatami/tatami.py

@@ -0,0 +1,64 @@
+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, get_char, get_pos, get_row_pos, get_col_pos, get_next_pos, Direction, in_bounds
+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
+
+
+class Board:
+    def __init__(self, board: np.array, id_board: np.array):
+        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.id_board = id_board
+        self.V, self.H = board.shape
+        self.pos_to_id: dict[Pos, int] = {pos: int(get_char(id_board, pos)) for pos in get_all_pos(self.V, self.H)}
+        self.id_to_pos: dict[int, set[Pos]] = defaultdict(set)
+        for pos in get_all_pos(self.V, self.H):
+            self.id_to_pos[self.pos_to_id[pos]].add(pos)
+        id_lens = set([len(v) for v in self.id_to_pos.values()])
+        assert len(id_lens) == 1, f'all tatamis must have the same size, got {id_lens}'
+        self.N = list(id_lens)[0]
+
+        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 get_all_pos(self.V, self.H):
+            for n in range(1, self.N + 1):
+                self.model_vars[(pos, n)] = self.model.NewBoolVar(f'{pos}:{n}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # every pos has exactly one number
+            self.model.AddExactlyOne([self.model_vars[(pos, n)] for n in range(1, self.N + 1)])
+            c = get_char(self.board, pos).strip()
+            if c:  # force clues
+                self.model.Add(self.model_vars[(pos, int(c))] == 1)
+        for v in range(1, self.N + 1):
+            for (_, pos_set) in self.id_to_pos.items():  # a tatami cannot have a repeating number
+                self.model.AddExactlyOne([self.model_vars[(pos, v)] for pos in pos_set])
+            for row in range(self.V):  # numbers repeat X times horizontally
+                self.model.Add(lxp.Sum([self.model_vars[(pos, v)] for pos in get_row_pos(row, self.H)]) == int(np.ceil(self.V / self.N)))
+            for col in range(self.H):  # numbers repeat X times vertically
+                self.model.Add(lxp.Sum([self.model_vars[(pos, v)] for pos in get_col_pos(col, self.V)]) == int(np.ceil(self.H / self.N)))
+            for pos in get_all_pos(self.V, self.H):  # numbers cannot touch horizontally or vertically
+                right_pos = get_next_pos(pos, Direction.RIGHT)
+                down_pos = get_next_pos(pos, Direction.DOWN)
+                if in_bounds(right_pos, self.V, self.H):
+                    self.model.Add(self.model_vars[(right_pos, v)] == 0).OnlyEnforceIf(self.model_vars[(pos, v)])
+                if in_bounds(down_pos, self.V, self.H):
+                    self.model.Add(self.model_vars[(down_pos, v)] == 0).OnlyEnforceIf(self.model_vars[(pos, v)])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: v for (pos, v), var in board.model_vars.items() if solver.Value(var)})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, cell_flags=id_board_to_wall_fn(self.id_board), center_char=lambda r, c: str(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)

puzzle_solver/puzzles/tents/tents.py

@@ -0,0 +1,80 @@
+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_neighbors8, get_next_pos, get_row_pos, get_col_pos, get_opposite_direction, get_pos
+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, side: np.array, top: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert side.ndim == 1 and side.shape[0] == board.shape[0], 'side must be 1d and equal to board size'
+        assert top.ndim == 1 and top.shape[0] == board.shape[1], 'top must be 1d and equal to board size'
+        assert all(c.item() in [' ', 'T'] for c in np.nditer(board)), 'board must contain only space or T'
+        self.board = board
+        self.V, self.H = board.shape
+        self.side = side
+        self.top = top
+        self.non_tree_positions: set[Pos] = {pos for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos) == ' '}
+        self.tree_positions: set[Pos] = {pos for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos) == 'T'}
+
+        self.model = cp_model.CpModel()
+        self.is_tent: dict[Pos, cp_model.IntVar] = defaultdict(int)
+        self.tent_direction: dict[tuple[Pos, Direction], cp_model.IntVar] = defaultdict(int)
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in self.non_tree_positions:
+            self.is_tent[pos] = self.model.NewBoolVar(f'{pos}:is_tent')
+        for pos in self.tree_positions:
+            for direction in Direction:
+                tent_pos = get_next_pos(pos, direction)
+                if tent_pos not in self.is_tent:
+                    continue
+                opposite_direction = get_opposite_direction(direction)
+                tent_direction = self.model.NewBoolVar(f'{pos}:{direction}')
+                self.model.Add(tent_direction == 0).OnlyEnforceIf(self.is_tent[tent_pos].Not())
+                self.tent_direction[(pos, direction)] = tent_direction
+                self.tent_direction[(tent_pos, opposite_direction)] = tent_direction
+
+    def add_all_constraints(self):
+        # - There are exactly as many tents as trees.
+        self.model.Add(lxp.sum([self.is_tent[pos] for pos in self.non_tree_positions]) == len(self.tree_positions))
+        # - no two tents are adjacent horizontally, vertically or diagonally
+        for pos in self.non_tree_positions:
+            for neighbor in get_neighbors8(pos, V=self.V, H=self.H, include_self=False):
+                self.model.Add(self.is_tent[neighbor] == 0).OnlyEnforceIf(self.is_tent[pos])
+        # - the number of tents in each row and column matches the numbers around the edge of the grid
+        for row in range(self.V):
+            if self.side[row] == -1:
+                continue
+            row_vars = [self.is_tent[pos] for pos in get_row_pos(row, H=self.H)]
+            self.model.Add(lxp.sum(row_vars) == self.side[row])
+        for col in range(self.H):
+            if self.top[col] == -1:
+                continue
+            col_vars = [self.is_tent[pos] for pos in get_col_pos(col, V=self.V)]
+            self.model.Add(lxp.sum(col_vars) == self.top[col])
+        # - it is possible to match tents to trees so that each tree is orthogonally adjacent to its own tent (but may also be adjacent to other tents).
+        # each tent is pointing exactly once at a tree
+        for pos in self.non_tree_positions:
+            var_list = [self.tent_direction[(pos, direction)] for direction in Direction]
+            self.model.Add(lxp.sum(var_list) == 1).OnlyEnforceIf(self.is_tent[pos])
+            self.model.Add(lxp.sum(var_list) == 0).OnlyEnforceIf(self.is_tent[pos].Not())
+        # each tree is pointed at by exactly one tent
+        for pos in self.tree_positions:
+            var_list = [self.tent_direction[(pos, direction)] for direction in Direction]
+            self.model.Add(lxp.sum(var_list) == 1)
+
+    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.is_tent.items() if not isinstance(var, int)})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: ('|' if self.board[r][c].strip() else ('▲' if single_res.assignment[get_pos(c, r)] == 1 else ' '))))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=5)