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

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -0,0 +1,128 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, in_bounds, set_char, get_char, Direction, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def factor_pairs(N: int, upper_limit_i: int, upper_limit_j: int):
+    """Return all unique pairs (a, b) such that a * b == N, with a, b <= upper_limit."""
+    if N <= 0 or upper_limit_i <= 0 or upper_limit_j <= 0:
+        return []
+
+    pairs = []
+    i = 1
+    while i * i <= N:
+        if N % i == 0:
+            j = N // i
+            if i <= upper_limit_i and j <= upper_limit_j:
+                pairs.append((i, j))
+            if i != j and j <= upper_limit_i and i <= upper_limit_j:
+                pairs.append((j, i))
+        i += 1
+    return pairs
+
+
+@dataclass
+class Rectangle:
+    active: cp_model.IntVar
+    N: int
+    clue_id: int
+    width: int
+    height: int
+    body: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() == ' ') or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.clue_pos: list[Pos] = [pos for pos in get_all_pos(self.V, self.H) if str(get_char(self.board, pos)).isdecimal()]
+        self.clue_pos_to_id: dict[Pos, int] = {pos: i for i, pos in enumerate(self.clue_pos)}
+        self.clue_pos_to_value: dict[Pos, int] = {pos: int(get_char(self.board, pos)) for pos in self.clue_pos}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.rectangles: list[Rectangle] = []
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        self.init_rectangles()
+        # for each position it belongs to exactly 1 clue
+        # instead of iterating over all clues, we only look at the clues that are possible for this position (by looking at the rectangles that contain this position)
+        for pos in get_all_pos(self.V, self.H):
+            possible_clue_here = {rectangle.clue_id for rectangle in self.rectangles if pos in rectangle.body}  # get the clue position for any rectangle that contains this position
+            for possible_clue in possible_clue_here:
+                self.model_vars[(pos, possible_clue)] = self.model.NewBoolVar(f'{pos}:{possible_clue}')
+
+    def init_rectangles(self) -> list[Rectangle]:
+        self.fixed_pos: set[Pos] = set(self.clue_pos)
+        for pos in self.clue_pos:  # for each clue on the board
+            clue_id = self.clue_pos_to_id[pos]
+            clue_num = self.clue_pos_to_value[pos]
+            other_fixed_pos = self.fixed_pos - {pos}
+            for width, height in factor_pairs(clue_num, self.V, self.H):  # for each possible width x height rectangle that can fit the clue
+                # if the digit is at pos and we have a width x height rectangle then we can translate the rectangle "0 to width" to the left and "0 to height" to the top
+                for dx in range(width):
+                    for dy in range(height):
+                        body = {Pos(x=pos.x - dx + i, y=pos.y - dy + j) for i in range(width) for j in range(height)}
+                        if any(not in_bounds(p, self.V, self.H) for p in body):  # a rectangle cannot be out of bounds
+                            continue
+                        if any(p in other_fixed_pos for p in body):  # a rectangle cannot contain a different clue; each clue is 1 rectangle only
+                            continue
+                        rectangle = Rectangle(active=self.model.NewBoolVar(f'{clue_id}'), N=clue_num, clue_id=clue_id, width=width, height=height, body=body)
+                        self.rectangles.append(rectangle)
+
+    def add_all_constraints(self):
+        # each pos has only 1 rectangle active
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne(rectangle.active for rectangle in self.rectangles if pos in rectangle.body)
+        # each pos has only 1 clue active
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne(self.model_vars[(pos, clue_id)] for clue_id in self.clue_pos_to_id.values() if (pos, clue_id) in self.model_vars)
+        # a rectangle being active means all its body ponts to the clue
+        for rectangle in self.rectangles:
+            is_active = rectangle.active
+            for pos in rectangle.body:
+                self.model.Add(self.model_vars[(pos, rectangle.clue_id)] == 1).OnlyEnforceIf(is_active)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for rectangle in self.rectangles:
+                if solver.Value(rectangle.active) == 1:
+                    for pos in rectangle.body:
+                        assignment[pos] = f'id{rectangle.clue_id}:N={rectangle.N}:{rectangle.height}x{rectangle.width}'
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), '', dtype=object)
+            id_board = np.full((self.V, self.H), '', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                cur = single_res.assignment[pos]
+                set_char(id_board, pos, cur)
+                left_pos = get_next_pos(pos, Direction.LEFT)
+                right_pos = get_next_pos(pos, Direction.RIGHT)
+                top_pos = get_next_pos(pos, Direction.UP)
+                bottom_pos = get_next_pos(pos, Direction.DOWN)
+                if left_pos not in single_res.assignment or single_res.assignment[left_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'L')
+                if right_pos not in single_res.assignment or single_res.assignment[right_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'R')
+                if top_pos not in single_res.assignment or single_res.assignment[top_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'U')
+                if bottom_pos not in single_res.assignment or single_res.assignment[bottom_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'D')
+            print(combined_function(self.V, self.H,
+                cell_flags=lambda r, c: res[r, c],
+                center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else ' '))
+
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/ripple_effect/ripple_effect.py

@@ -0,0 +1,83 @@
+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_pos, Direction, get_next_pos, 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
+
+
+def get_orthogonals_with_dist(pos: Pos, V: int, H: int) -> list[tuple[Pos, int]]:
+    out = []
+    for direction in Direction:
+        current_pos = pos
+        current_dist = 0
+        while True:
+            current_pos = get_next_pos(current_pos, direction)
+            current_dist += 1
+            if not in_bounds(current_pos, V, H):
+                break
+            out.append((current_pos, current_dist))
+    return out
+
+
+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 id_board.shape == board.shape, f'id_board and board must have the same shape, got {id_board.shape} and {board.shape}'
+        assert all((c.item() == ' ') or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(id_board)), 'id_board must contain only digits'
+        self.board = board
+        self.id_board = id_board
+        self.V, self.H = board.shape
+        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.id_to_max_val: dict[int, int] = {id_: len(self.id_to_pos[id_]) for id_ in self.id_to_pos}
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, int], cp_model.IntVar] = {}
+        self.pos_vars: dict[Pos, set[cp_model.IntVar]] = defaultdict(set)
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            id_ = int(get_char(self.id_board, pos))
+            max_val = self.id_to_max_val[id_]
+            for n in range(1, max_val + 1):
+                self.model_vars[(pos, n)] = self.model.NewBoolVar(f'{pos}:{n}')
+                self.pos_vars[pos].add(self.model_vars[(pos, n)])
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne(self.pos_vars[pos])  # each position has exactly one number
+            c = get_char(self.board, pos).strip()  # force clues
+            if c != '':
+                self.model.Add(self.model_vars[(pos, int(c))] == 1)
+        for id_ in self.id_to_pos:  # each group has at most one number
+            max_val = self.id_to_max_val[id_]
+            for n in range(1, max_val + 1):
+                self.model.AddExactlyOne([self.model_vars[(pos, n)] for pos in self.id_to_pos[id_]])
+        for pos in get_all_pos(self.V, self.H):
+            # if pos is X then neighbors within X cant be X
+            orthogonals = get_orthogonals_with_dist(pos, self.V, self.H)
+            for neighbor, dist in orthogonals:
+                cur_n = dist
+                while True:
+                    if (pos, cur_n) not in self.model_vars:  # current position cant be as high as "cur_n"
+                        break
+                    if (neighbor, cur_n) not in self.model_vars:  # neighbor position cant be as high as "cur_n"
+                        break
+                    self.model.Add(self.model_vars[(neighbor, cur_n)] == 0).OnlyEnforceIf(self.model_vars[(pos, cur_n)])
+                    cur_n += 1
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: n for (pos, n), var in board.model_vars.items() if solver.Value(var) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                cell_flags=lambda r, c: id_board_to_wall_fn(self.id_board)(r, c),
+                center_char=lambda r, c: str(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/rooms/rooms.py

@@ -0,0 +1,75 @@
+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, Direction, get_next_pos, get_opposite_direction, get_pos, get_ray, in_bounds
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.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.V, self.H = board.shape
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in Direction:
+                next_pos = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if (next_pos, opposite_direction) in self.model_vars:
+                    self.model_vars[(pos, direction)] = self.model_vars[(next_pos, opposite_direction)]
+                elif not in_bounds(next_pos, self.V, self.H):
+                    self.model_vars[(pos, direction)] = self.model.NewConstant(1)
+                else:
+                    self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if not str(c).isdecimal():
+                continue
+            self.range_clue(pos, int(c))
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if d1 is None or d2 is None:  # cell center, only neighbor to its own walls
+                return p1 == p2
+            if p1 == p2 and d1 != d2:  # same position, different direction, is neighbor
+                return True
+            if get_next_pos(p1, d1) == p2 and d2 == get_opposite_direction(d1):
+                return True
+            return False
+        not_walls = {k: v.Not() for k, v in self.model_vars.items()}
+        cell_centers = {(k, None): self.model.NewConstant(1) for k in get_all_pos(self.V, self.H)}
+        force_connected_component(self.model, {**not_walls, **cell_centers}, is_neighbor=is_neighbor)
+
+    def range_clue(self, pos: Pos, k: int):
+        vis_vars: list[cp_model.IntVar] = []
+        for direction in Direction:  # Build visibility chains in four direction
+            ray = get_ray(pos, direction, self.V, self.H, include_self=True)  # cells outward
+            for idx in range(len(ray)):
+                v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                and_constraint(self.model, target=v, cs=[self.model_vars[(p, direction)].Not() for p in ray[:idx+1]])
+                vis_vars.append(v)
+        self.model.Add(sum(vis_vars) == int(k))  # Sum of visible whites = 1 (itself) + sum(chains) == k
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = defaultdict(str)
+            for pos in get_all_pos(self.V, self.H):
+                for direction in Direction:
+                    if (pos, direction) in board.model_vars and solver.Value(board.model_vars[(pos, direction)]) == 1:
+                        assignment[pos] += direction.name[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, cell_flags=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), ''), center_char=lambda r, c: str(self.board[r, c]).strip()))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=4)

puzzle_solver/puzzles/schurs_numbers/schurs_numbers.py

@@ -0,0 +1,73 @@
+from dataclasses import dataclass
+import json
+
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils_ortools import generic_solve_all
+
+
+@dataclass(frozen=True)
+class SingleSolution:
+    assignment: dict[int, str]
+
+    def get_hashable_solution(self) -> str:
+        return json.dumps(self.assignment, sort_keys=True)
+
+
+def all_pairs(lst: list[int]) -> list[tuple[int, int]]:
+    for i, ni in enumerate(lst):
+        for _j, nj in enumerate(lst[i:]):
+            yield ni, nj
+
+
+class SchurNumbers:
+    def __init__(self, colors: list[str], n: int):
+        self.N = n
+        self.num_colors = len(colors)
+        self.int_to_color: dict[int, str] = {i+1: c for i, c in enumerate(colors)}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[int, cp_model.IntVar] = {}
+        self.eq_vars: dict[tuple[int, int], cp_model.BoolVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for number in range(1, self.N + 1):
+            self.model_vars[number] = self.model.NewIntVar(1, self.num_colors, f'{number}:color')
+            for other_number in range(number + 1, self.N + 1):
+                self.eq_vars[(number, other_number)] = self.model.NewBoolVar(f'{number} == {other_number}')
+
+    def add_all_constraints(self):
+        numbers = list(self.model_vars.keys())
+        for (number, other_number) in self.eq_vars.keys():  # enforce auxiliary variables
+            v = self.eq_vars[(number, other_number)]
+            self.model.Add(self.model_vars[number] == self.model_vars[other_number]).OnlyEnforceIf(v)
+            self.model.Add(self.model_vars[number] != self.model_vars[other_number]).OnlyEnforceIf(v.Not())
+
+        for ni, nj in all_pairs(numbers):
+            if ni + nj not in numbers:
+                continue
+            nk = ni + nj
+            self.model.AddBoolOr([self.eq_vars[(ni, nk)].Not(), self.eq_vars[(nj, nk)].Not()])
+
+    def count_num_ways(self) -> int:
+        def board_to_solution(board: SchurNumbers, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={number: board.int_to_color[solver.Value(var)] for number, var in board.model_vars.items()})
+        solutions = generic_solve_all(self, board_to_solution, callback=None, verbose=False)
+        return len(solutions), solutions
+
+    def is_feasible(self) -> bool:
+        solver = cp_model.CpSolver()
+        solver.solve(self.model)
+        return solver.StatusName() in ['OPTIMAL', 'FEASIBLE']
+
+
+def find_max_n(colors: list[str], n=1) -> int:
+    while True:
+        print(f'checking n = {n}')
+        solver = SchurNumbers(colors=colors, n=n)
+        if not solver.is_feasible():
+            return n
+        n += 1
+    return n

puzzle_solver/puzzles/shakashaka/shakashaka.py

@@ -0,0 +1,201 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from enum import Enum
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char, get_neighbors4, in_bounds
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import render_bw_tiles_split
+
+
+TPos = tuple[int, int]
+
+class State(Enum):
+    WHITE = 'W'
+    BLACK = 'B'
+    TOP_LEFT = 'TL'
+    TOP_RIGHT = 'TR'
+    BOTTOM_LEFT = 'BL'
+    BOTTOM_RIGHT = 'BR'
+
+@dataclass
+class Rectangle:
+    is_rotated: bool
+    width: int
+    height: int
+    body: frozenset[tuple[TPos, State]]
+    disallow_white: frozenset[tuple[TPos]]
+    max_x: int
+    max_y: int
+
+@dataclass
+class RectangleOnBoard:
+    is_active: cp_model.IntVar
+    rectangle: Rectangle
+    body: frozenset[tuple[Pos, State]]
+    body_positions: frozenset[Pos]
+    disallow_white: frozenset[Pos]
+    translate: Pos
+    width: int
+    height: int
+
+
+def init_rectangles(V: int, H: int) -> list[Rectangle]:
+    """Returns all possible upright and 45 degree rotated rectangles on a VxH board that are NOT translated (i.e. both min_x and min_y are always 0)"""
+    rectangles = []
+    # up right rectangles
+    for height in range(1, V+1):
+        for width in range(1, H+1):
+            body = {(x, y) for x in range(width) for y in range(height)}
+            # disallow any orthogonal adjacent white positions
+            disallow_white = set((p[0] + dxdy[0], p[1] + dxdy[1]) for p in body for dxdy in ((1,0),(-1,0),(0,1),(0,-1)))
+            disallow_white -= body
+            rectangles.append(Rectangle(
+                is_rotated=False,
+                width=width,
+                height=height,
+                body={(p, State.WHITE) for p in body},
+                disallow_white=disallow_white,
+                max_x=width-1,
+                max_y=height-1,
+            ))
+    # now imagine rectangles rotated clockwise by 45 degrees
+    for height in range(1, V+1):
+        for width in range(1, H+1):
+            if width + height > V or width + height > H:  # this rotated rectangle won't fit
+                continue
+            body = {}
+            tl_body = {(i, height-1-i) for i in range(height)}  # top left edge
+            tr_body = {(height+i, i) for i in range(width)}  # top right edge
+            br_body = {(width+height-i-1, width+i) for i in range(height)}  # bottom right edge
+            bl_body = {(width-i-1, width+height-i-1) for i in range(width)}  # bottom left edge
+            inner_body = set()  # inner body is anything to the right of L and to the left of R
+            for y in range(width+height):
+                row_is_active = False
+                for x in range(width+height):
+                    if (x, y) in tl_body or (x, y) in bl_body:
+                        row_is_active = True
+                        continue
+                    if (x, y) in tr_body or (x, y) in br_body:
+                        break
+                    if row_is_active:
+                        inner_body.add((x, y))
+            tl_body = {(p, State.TOP_LEFT) for p in tl_body}
+            tr_body = {(p, State.TOP_RIGHT) for p in tr_body}
+            br_body = {(p, State.BOTTOM_RIGHT) for p in br_body}
+            bl_body = {(p, State.BOTTOM_LEFT) for p in bl_body}
+            inner_body = {(p, State.WHITE) for p in inner_body}
+            rectangles.append(Rectangle(
+                is_rotated=True, width=width, height=height, body=tl_body | tr_body | br_body | bl_body | inner_body, disallow_white=set(),
+                # clear from vizualization, both width and height contribute to both dimensions since it is rotated
+                max_x=width + height - 1,
+                max_y=width + height - 1,
+                ))
+    return rectangles
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() in [' ', 'B', '0', '1', '2', '3', '4']) for c in np.nditer(board)), 'board must contain only space, B, 0, 1, 2, 3, 4'
+        self.board = board
+        self.V, self.H = board.shape
+        self.black_positions: set[Pos] = {pos for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos).strip() != ''}
+        self.black_positions_tuple: set[TPos] = {(p.x, p.y) for p in self.black_positions}
+        self.pos_to_rectangle_on_board: dict[Pos, list[RectangleOnBoard]] = defaultdict(list)
+        self.model = cp_model.CpModel()
+        self.B: dict[Pos, cp_model.IntVar] = {}
+        self.W: dict[Pos, cp_model.IntVar] = {}
+        self.rectangles_on_board: list[RectangleOnBoard] = []
+        self.init_rectangles_on_board()
+        self.create_vars()
+        self.add_all_constraints()
+
+    def init_rectangles_on_board(self):
+        rectangles = init_rectangles(self.V, self.H)
+        for rectangle in rectangles:
+            # translate
+            for dx in range(self.H - rectangle.max_x):
+                for dy in range(self.V - rectangle.max_y):
+                    body: list[tuple[Pos, State]] = [None] * len(rectangle.body)
+                    for i, (p, s) in enumerate(rectangle.body):
+                        pp = (p[0] + dx, p[1] + dy)
+                        body[i] = (pp, s)
+                        if pp in self.black_positions_tuple:
+                            body = None
+                            break
+                    if body is None:
+                        continue
+                    disallow_white = {Pos(x=p[0] + dx, y=p[1] + dy) for p in rectangle.disallow_white}
+                    body_positions = set((Pos(x=p[0], y=p[1])) for p, _ in body)
+                    rectangle_on_board = RectangleOnBoard(
+                        is_active=self.model.NewBoolVar(f'{rectangle.is_rotated}:{rectangle.width}x{rectangle.height}:{dx}:{dy}:is_active'),
+                        rectangle=rectangle,
+                        body=set((Pos(x=p[0], y=p[1]), s) for p, s in body),
+                        body_positions=body_positions,
+                        disallow_white=disallow_white,
+                        translate=Pos(x=dx, y=dy),
+                        width=rectangle.width,
+                        height=rectangle.height,
+                    )
+                    self.rectangles_on_board.append(rectangle_on_board)
+                    for p in body_positions:
+                        self.pos_to_rectangle_on_board[p].append(rectangle_on_board)
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+            self.W[pos] = self.B[pos].Not()
+            if pos in self.black_positions:
+                self.model.Add(self.B[pos] == 1)
+
+    def add_all_constraints(self):
+        # every position not fixed must be part of exactly one rectangle
+        for pos in get_all_pos(self.V, self.H):
+            if pos in self.black_positions:
+                continue
+            self.model.AddExactlyOne([r.is_active for r in self.pos_to_rectangle_on_board[pos]])
+        # if a rectangle is active then all its body is black and all its disallow_white is white
+        for rectangle_on_board in self.rectangles_on_board:
+            for pos, state in rectangle_on_board.body:
+                if state == State.WHITE:
+                    self.model.Add(self.W[pos] == 1).OnlyEnforceIf(rectangle_on_board.is_active)
+                else:
+                    self.model.Add(self.B[pos] == 1).OnlyEnforceIf(rectangle_on_board.is_active)
+            for pos in rectangle_on_board.disallow_white:
+                if not in_bounds(pos, self.V, self.H):
+                    continue
+                self.model.Add(self.B[pos] == 1).OnlyEnforceIf(rectangle_on_board.is_active)
+        # if a position has a clue, enforce it
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c.strip() != '' and c.strip().isdecimal():
+                clue = int(c.strip())
+                neighbors = [self.B[p] for p in get_neighbors4(pos, self.V, self.H) if p not in self.black_positions]
+                self.model.Add(sum(neighbors) == clue)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for rectangle_on_board in board.rectangles_on_board:
+                if solver.Value(rectangle_on_board.is_active) == 1:
+                    for p, s in rectangle_on_board.body:
+                        assignment[p] = s.value
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), 'W', dtype=object)
+            text = np.full((self.V, self.H), '', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if pos in single_res.assignment:
+                    val = single_res.assignment[pos]
+                else:
+                    c = get_char(self.board, pos)
+                    if c.strip() != '':
+                        val = 'B'
+                        text[pos.y][pos.x] = c if c.strip() != 'B' else '.'
+                set_char(res, pos, val)
+            print(render_bw_tiles_split(res, cell_w=6, cell_h=3, borders=True, mode="text", cell_text=lambda r, c: text[r][c]))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)