multi-puzzle-solver 0.9.26__py3-none-any.whl → 0.9.30__py3-none-any.whl

puzzle_solver/puzzles/heyawake/heyawake.py

@@ -0,0 +1,94 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, set_char, get_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
+
+def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
+    """Given a list of integers (mostly with duplicates), return every consecutive sequence of 3 integer changes. 
+    i.e. return a list of (begin_idx, end_idx) tuples where for each r=int_list[begin_idx:end_idx] we have r[0]!=r[1] and r[-2]!=r[-1] and len(r)>=3"""
+    out = []
+    change_indices = [i for i in range(len(int_list) - 1) if int_list[i] != int_list[i+1]]
+    # notice how for every subsequence r, the subsequence begining index is in change_indices and the ending index - 1 is in change_indices
+    for i in range(len(change_indices) - 1):
+        begin_idx = change_indices[i]
+        end_idx = change_indices[i+1] + 1  # we want to include the first number in the third sequence
+        if end_idx > len(int_list):
+            continue
+        out.append((begin_idx, end_idx))
+    return out
+    
+
+class Board:
+    def __init__(self, board: np.array, region_to_clue: dict[str, int]):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.all_regions: set[int] = {int(c.item()) for c in np.nditer(board)}
+        self.region_to_clue = {int(k): v for k, v in region_to_clue.items()}
+        assert set(self.region_to_clue.keys()).issubset(self.all_regions), f'extra regions in region_to_clue: {set(self.region_to_clue.keys()) - self.all_regions}'
+        self.region_to_pos: dict[int, set[Pos]] = {r: set() for r in self.all_regions}
+        for pos in get_all_pos(self.V, self.H):
+            rid = int(get_char(self.board, pos))
+            self.region_to_pos[rid].add(pos)
+
+        self.model = cp_model.CpModel()
+        self.B: dict[Pos, cp_model.IntVar] = {}
+        self.W: dict[Pos, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+            self.W[pos] = self.model.NewBoolVar(f'W:{pos}')
+            self.model.AddExactlyOne([self.B[pos], self.W[pos]])
+
+    def add_all_constraints(self):
+        # Regions with a number should contain black cells matching the number.
+        for rid, clue in self.region_to_clue.items():
+            self.model.Add(sum([self.B[p] for p in self.region_to_pos[rid]]) == clue)
+        # 2 black cells cannot be adjacent horizontally or vertically.
+        for pos in get_all_pos(self.V, self.H):
+            for neighbor in get_neighbors4(pos, self.V, self.H):
+                self.model.AddBoolOr([self.W[pos], self.W[neighbor]])
+        # All white cells should be connected in a single group.
+        force_connected_component(self.model, self.W)
+        # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
+        self.disallow_white_lines_spanning_3_regions()
+
+    def disallow_white_lines_spanning_3_regions(self):
+        # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
+        row_to_region: dict[int, list[int]] = {row: [] for row in range(self.V)}
+        col_to_region: dict[int, list[int]] = {col: [] for col in range(self.H)}
+        for pos in get_all_pos(self.V, self.H):  # must traverse from least to most (both row and col)
+            rid = int(get_char(self.board, pos))
+            row_to_region[pos.y].append(rid)
+            col_to_region[pos.x].append(rid)
+        for row_num, row in row_to_region.items():
+            for begin_idx, end_idx in return_3_consecutives(row):
+                pos_list = [get_pos(x=x, y=row_num) for x in range(begin_idx, end_idx+1)]
+                self.model.AddBoolOr([self.B[p] for p in pos_list])
+        for col_num, col in col_to_region.items():
+            for begin_idx, end_idx in return_3_consecutives(col):
+                pos_list = [get_pos(x=col_num, y=y) for y in range(begin_idx, end_idx+1)]
+                self.model.AddBoolOr([self.B[p] for p in pos_list])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.B.items():
+                assignment[pos] = 1 if solver.Value(var) == 1 else 0
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            # res = np.full((self.V, self.H), ' ', dtype=object)
+            # for pos in get_all_pos(self.V, self.H):
+            #     c = 'B' if single_res.assignment[pos] == 1 else ' '
+            #     set_char(res, pos, c)
+            # print(res)
+            print(render_shaded_grid(self.V, self.H, lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1, empty_text=lambda r, c: self.region_to_clue.get(int(self.board[r, c]), ' ')))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=1)

puzzle_solver/puzzles/kakuro/kakuro.py

@@ -0,0 +1,77 @@
+from typing import Iterator
+
+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_next_pos, get_pos, in_bounds, set_char, get_char, get_neighbors8
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
+
+
+class Board:
+    def __init__(self, board: np.array, row_sums: list[list[int]], col_sums: list[list[int]], N: int = 9):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() in ['#', ' ', '1', '2', '3', '4', '5', '6', '7', '8', '9']) for c in np.nditer(board)), 'board must contain only #, space, or digits'
+        assert len(row_sums) == board.shape[0] and all(isinstance(i, list) and all(isinstance(j, int) or j == '#' for j in i) for i in row_sums), 'row_sums must be a list of lists of integers or #'
+        assert len(col_sums) == board.shape[1] and all(isinstance(i, list) and all(isinstance(j, int) or j == '#' for j in i) for i in col_sums), 'col_sums must be a list of lists of integers or #'
+        self.board = board
+        self.row_sums = row_sums
+        self.col_sums = col_sums
+        self.V, self.H = board.shape
+        self.N = 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(self.V, self.H):
+            if get_char(self.board, pos) == '#':
+                continue
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+
+    def get_consecutives(self, pos: Pos, direction: Direction) -> Iterator[list[Pos]]:
+        consecutive = []
+        while in_bounds(pos, self.V, self.H):
+            if get_char(self.board, pos) == '#':
+                if len(consecutive) > 0:
+                    yield consecutive
+                    consecutive = []
+            else:
+                consecutive.append(pos)
+            pos = get_next_pos(pos, direction)
+        if len(consecutive) > 0:
+            yield consecutive
+
+    def add_all_constraints(self):
+        for row in range(self.V):
+            row_consecutives = self.get_consecutives(get_pos(x=0, y=row), Direction.RIGHT)
+            for i, consecutive in enumerate(row_consecutives):
+                # print('row', row, 'i', i, 'consecutive', consecutive)
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.row_sums[row][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == clue)
+            assert len(self.row_sums[row]) == i + 1, f'row_sums[{row}] has {len(self.row_sums[row])} clues, but {i + 1} consecutive cells'
+        for col in range(self.H):
+            col_consecutives = self.get_consecutives(get_pos(x=col, y=0), Direction.DOWN)
+            for i, consecutive in enumerate(col_consecutives):
+                # print('col', col, 'i', i, 'consecutive', consecutive)
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.col_sums[col][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == clue)
+            assert len(self.col_sums[col]) == i + 1, f'col_sums[{col}] has {len(self.col_sums[col])} clues, but {i + 1} consecutive cells'
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(render_shaded_grid(self.V, self.H, is_shaded=lambda r, c: self.board[r, c] == '#', empty_text=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/nurikabe/nurikabe.py

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

puzzle_solver/puzzles/palisade/palisade.py

@@ -4,8 +4,9 @@ from collections import defaultdict
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, id_board_to_wall_board, render_grid, set_char, in_bounds, get_next_pos, Direction, polyominoes
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, set_char, in_bounds, get_next_pos, Direction, polyominoes
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import id_board_to_wall_board, render_grid
 
 
 

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -3,10 +3,10 @@ from dataclasses import dataclass
 import numpy as np
 
 from ortools.sat.python import cp_model
-from ortools.sat.python.cp_model import LinearExpr as lxp
 
-from puzzle_solver.core.utils import Pos, get_all_pos, in_bounds, set_char, get_char, get_neighbors8, Direction, get_next_pos, render_grid
+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 render_grid
 
 
 def factor_pairs(N: int, upper_limit_i: int, upper_limit_j: int):

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 wont 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)