multi-puzzle-solver 0.9.22__py3-none-any.whl → 0.9.25__py3-none-any.whl

puzzle_solver/core/utils.py

@@ -133,7 +133,7 @@ def get_deltas(direction: Union[Direction, Direction8]) -> Tuple[int, int]:
         raise ValueError(f'invalid direction: {direction}')
 
 
-def polyominoes(N):
+def polyominoes(N) -> set[Shape]:
     """Generate all polyominoes of size N. Every rotation and reflection is considered different and included in the result.
     Translation is not considered different and is removed from the result (otherwise the result would be infinite).
 
@@ -165,7 +165,7 @@ def polyominoes(N):
     shapes: set[FastShape] = {frozenset({(0, 0)})}
     for i in range(1, N):
         next_shapes: set[FastShape] = set()
-        directions = ((1,0),(-1,0),(0,1)) if i > 1 else (((1,0),(0,1)))  # cannot take left on first step, if confused read: https://louridas.github.io/rwa/assignments/polyominoes/
+        directions = ((1,0),(-1,0),(0,1),(0,-1)) if i > 1 else (((1,0),(0,1)))  # cannot take left on first step, if confused read: https://louridas.github.io/rwa/assignments/polyominoes/
         for s in shapes:
             # frontier of a single shape: all 4-neighbors of existing cells not already in the shape
             frontier = set()
@@ -188,6 +188,7 @@ def polyominoes(N):
     shapes = {frozenset(Pos(x, y) for x, y in s) for s in shapes}  # regular class, not the dirty-fast one
     return shapes
 
+
 def polyominoes_with_shape_id(N):
     """Refer to polyominoes() for more details. This function returns a set of all polyominoes of size N (rotated and reflected up to D4 symmetry) along with a unique ID for each polyomino that is unique up to D4 symmetry.
     Args:
@@ -226,3 +227,157 @@ def polyominoes_with_shape_id(N):
     result = {(s, canon_to_id[shape_to_canon[s]]) for s in shapes}
     result = {(frozenset(Pos(x, y) for x, y in s), _id) for s, _id in result}
     return result
+
+
+def render_grid(cell_flags: np.ndarray,
+                center_char: Union[np.ndarray, str, None] = None,
+                show_axes: bool = True,
+                scale_x: int = 2) -> str:
+    """
+    most of this function was AI generated then modified by me, I don't currently care about the details of rendering to the terminal this looked good enough during my testing.
+    cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
+    center_char: np.ndarray of shape (N, N) with the center of the cells, or a string to use for all cells, or None to not show centers.
+    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
+    """
+    assert cell_flags is not None and cell_flags.ndim == 2
+    R, C = cell_flags.shape
+
+    # Edge presence arrays (note the rectangular shapes)
+    H = np.zeros((R+1, C), dtype=bool)  # horizontal edges between rows
+    V = np.zeros((R, C+1), dtype=bool)  # vertical edges between cols
+    for r in range(R):
+        for c in range(C):
+            s = cell_flags[r, c]
+            if 'U' in s: H[r,   c] = True
+            if 'D' in s: H[r+1, c] = True
+            if 'L' in s: V[r,   c] = True
+            if 'R' in s: V[r, c+1] = True
+
+    # Bitmask for corner connections
+    U, Rb, D, Lb = 1, 2, 4, 8
+    JUNCTION = {
+        0: ' ',
+        U: '│', D: '│', U|D: '│',
+        Lb: '─', Rb: '─', Lb|Rb: '─',
+        U|Rb: '└', Rb|D: '┌', D|Lb: '┐', Lb|U: '┘',
+        U|D|Lb: '┤', U|D|Rb: '├', Lb|Rb|U: '┴', Lb|Rb|D: '┬',
+        U|Rb|D|Lb: '┼',
+    }
+
+    assert scale_x >= 1
+    assert H.shape == (R+1, C) and V.shape == (R, C+1)
+
+    rows = 2*R + 1
+    cols = 2*C*scale_x + 1
+    canvas = [[' ']*cols for _ in range(rows)]
+
+    def x_corner(c):     # x of corner column c  (0..C)
+        return (2*c) * scale_x
+    def x_between(c,k):  # kth in-between col (1..2*scale_x-1) between corners c and c+1
+        return (2*c) * scale_x + k
+
+    # horizontal edges: fill the stretched band between corners with '─'
+    for r in range(R+1):
+        rr = 2*r
+        for c in range(C):
+            if H[r, c]:
+                for k in range(1, scale_x*2):  # 1..(2*scale_x-1)
+                    canvas[rr][x_between(c, k)] = '─'
+
+    # vertical edges: at the corner columns
+    for r in range(R):
+        rr = 2*r + 1
+        for c in range(C+1):
+            if V[r, c]:
+                canvas[rr][x_corner(c)] = '│'
+
+    # junctions at every corner grid point
+    for r in range(R+1):
+        rr = 2*r
+        for c in range(C+1):
+            m = 0
+            if r > 0   and V[r-1, c]: m |= U
+            if c < C   and H[r, c]:   m |= Rb
+            if r < R   and V[r, c]:   m |= D
+            if c > 0   and H[r, c-1]: m |= Lb
+            canvas[rr][x_corner(c)] = JUNCTION[m]
+
+    # centers (safe for multi-character strings)
+    def put_center_text(rr: int, c: int, text: str):
+        left  = x_corner(c) + 1
+        right = x_corner(c+1) - 1
+        if right < left:
+            return
+        span_width = right - left + 1
+        s = str(text)
+        if len(s) > span_width:
+            s = s[:span_width]  # truncate to protect borders
+        start = left + (span_width - len(s)) // 2
+        for i, ch in enumerate(s):
+            canvas[rr][start + i] = ch
+
+    if center_char is not None:
+        for r in range(R):
+            rr = 2*r + 1
+            for c in range(C):
+                val = center_char if isinstance(center_char, str) else center_char[r, c]
+                put_center_text(rr, c, '' if val is None else str(val))
+
+    # rows -> strings
+    art_rows = [''.join(row) for row in canvas]
+    if not show_axes:
+        return '\n'.join(art_rows)
+
+    # Axes labels: row indices on the left, column indices on top (handle C, not R)
+    gut = max(2, len(str(R-1)))  # gutter width based on row index width
+    gutter = ' ' * gut
+    top_tens = list(gutter + ' ' * cols)
+    top_ones = list(gutter + ' ' * cols)
+
+    for c in range(C):
+        xc_center = x_corner(c) + scale_x
+        if C >= 10:
+            top_tens[gut + xc_center] = str((c // 10) % 10)
+        top_ones[gut + xc_center] = str(c % 10)
+
+    if gut >= 2:
+        top_tens[gut-2:gut] = list('  ')
+        top_ones[gut-2:gut] = list('  ')
+
+    labeled = []
+    for r, line in enumerate(art_rows):
+        if r % 2 == 1:  # cell-center row
+            label = str(r//2).rjust(gut)
+        else:
+            label = ' ' * gut
+        labeled.append(label + line)
+
+    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
+
+def id_board_to_wall_board(id_board: np.array, border_is_wall = True) -> np.array:
+    """In many instances, we have a 2d array where cell values are arbitrary ids
+    and we want to convert it to a 2d array where cell values are walls "U", "D", "L", "R" to represent the edges that separate me from my neighbors that have different ids.
+    Args:
+        id_board: np.array of shape (N, N) with arbitrary ids.
+        border_is_wall: if True, the edges of the board are considered to be walls.
+    Returns:
+        np.array of shape (N, N) with walls "U", "D", "L", "R".
+    """
+    res = np.full((id_board.shape[0], id_board.shape[1]), '', dtype=object)
+    V, H = id_board.shape
+    def append_char(pos: Pos, s: str):
+        set_char(res, pos, get_char(res, pos) + s)
+    def handle_pos_direction(pos: Pos, direction: Direction, s: str):
+        pos2 = get_next_pos(pos, direction)
+        if in_bounds(pos2, V, H):
+            if get_char(id_board, pos2) != get_char(id_board, pos):
+                append_char(pos, s)
+        else:
+            if border_is_wall:
+                append_char(pos, s)
+    for pos in get_all_pos(V, H):
+        handle_pos_direction(pos, Direction.LEFT, 'L')
+        handle_pos_direction(pos, Direction.RIGHT, 'R')
+        handle_pos_direction(pos, Direction.UP, 'U')
+        handle_pos_direction(pos, Direction.DOWN, 'D')
+    return res

puzzle_solver/core/utils_ortools.py

@@ -146,16 +146,12 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
     for p in keys_in_order:
         model.Add(node_height[p] > 0).OnlyEnforceIf(vs[p])
 
-    all_new_vars: dict[str, cp_model.IntVar] = {}
-    for k, v in is_root.items():
-        all_new_vars[f"{prefix_name}is_root[{k}]"] = v
-    for k, v in prefix_zero.items():
-        all_new_vars[f"{prefix_name}prefix_zero[{k}]"] = v
-    for k, v in node_height.items():
-        all_new_vars[f"{prefix_name}node_height[{k}]"] = v
-    for k, v in max_neighbor_height.items():
-        all_new_vars[f"{prefix_name}max_neighbor_height[{k}]"] = v
-
+    all_new_vars = {
+        "is_root": is_root,
+        "prefix_zero": prefix_zero,
+        "node_height": node_height,
+        "max_neighbor_height": max_neighbor_height,
+    }
     return all_new_vars
 
 

puzzle_solver/puzzles/binairo/binairo.py

@@ -0,0 +1,98 @@
+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, in_bounds, set_char, get_char, get_neighbors8, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+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', 'W'] for c in np.nditer(board)), 'board must contain only space or B'
+        self.board = board
+        self.V, self.H = board.shape
+        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):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos)
+            if c == 'B':
+                self.model.Add(self.model_vars[pos] == 1)
+            elif c == 'W':
+                self.model.Add(self.model_vars[pos] == 0)
+        # 1. Each row and each column must contain an equal number of white and black circles.
+        for row in range(self.V):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.H)]
+            self.model.Add(lxp.sum(row_vars) == len(row_vars) // 2)
+        for col in range(self.H):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.V)]
+            self.model.Add(lxp.sum(col_vars) == len(col_vars) // 2)
+        # 2. More than two circles of the same color can't be adjacent.
+        for pos in get_all_pos(self.V, self.H):
+            self.disallow_three_in_a_row(pos, Direction.RIGHT)
+            self.disallow_three_in_a_row(pos, Direction.DOWN)
+        # 3. Each row and column is unique. 
+        # a list per row
+        self.force_unique([[self.model_vars[pos] for pos in get_row_pos(row, self.H)] for row in range(self.V)])
+        # a list per column
+        self.force_unique([[self.model_vars[pos] for pos in get_col_pos(col, self.V)] for col in range(self.H)])
+
+    def disallow_three_in_a_row(self, p1: Pos, direction: Direction):
+        p2 = get_next_pos(p1, direction)
+        p3 = get_next_pos(p2, direction)
+        if any(not in_bounds(p, self.V, self.H) for p in [p1, p2, p3]):
+            return
+        self.model.AddBoolOr([
+            self.model_vars[p1],
+            self.model_vars[p2],
+            self.model_vars[p3],
+        ])
+        self.model.AddBoolOr([
+            self.model_vars[p1].Not(),
+            self.model_vars[p2].Not(),
+            self.model_vars[p3].Not(),
+        ])
+
+    def force_unique(self, model_vars: list[list[cp_model.IntVar]]):
+        if not model_vars or len(model_vars) < 2:
+            return
+        m = len(model_vars[0])
+        assert m <= 61, f"Too many cells for binary encoding in int64: m={m}, model_vars={model_vars}"
+
+        codes = []
+        pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
+        for i, l in enumerate(model_vars):
+            code = self.model.NewIntVar(0, (1 << m) - 1, f"code_{i}")
+            # Sum 2^k * r[k] == code
+            self.model.Add(code == sum(pow2[k] * l[k] for k in range(m)))
+            codes.append(code)
+
+        self.model.AddAllDifferent(codes)
+
+    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")
+            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 'W'
+                set_char(res, pos, c)
+            print('[')
+            for row in res:
+                print("    [ '" + "', '".join(row.tolist()) + "' ],")
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/flip/flip.py

@@ -0,0 +1,48 @@
+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, get_char, get_neighbors8
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+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((c.item() == ' ') or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        self.board = board
+        self.N = board.shape[0]
+        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.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.N):
+            c = get_char(self.board, pos)
+            if not str(c).isdecimal():
+                continue
+            neighbour_vars = [self.model_vars[p] for p in get_neighbors8(pos, self.N, include_self=True)]
+            self.model.Add(lxp.sum(neighbour_vars) == int(c))
+
+    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")
+            res = np.full((self.N, self.N), ' ', dtype=object)
+            for pos in get_all_pos(self.N):
+                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 if verbose else None, verbose=verbose)

puzzle_solver/puzzles/lits/lits.py

@@ -1,7 +1,5 @@
-import json
-import time
 from dataclasses import dataclass
-from typing import Optional, Union
+from typing import Optional
 
 from ortools.sat.python import cp_model
 import numpy as np
@@ -14,19 +12,6 @@ from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution,
 Shape = frozenset[Pos]
 
 
-@dataclass(frozen=True)
-class SingleSolution:
-    assignment: dict[Pos, Union[str, int]]
-    all_other_variables: dict
-
-    def get_hashable_solution(self) -> str:
-        result = []
-        for pos, v in self.assignment.items():
-            result.append((pos.x, pos.y, v))
-        return json.dumps(result, sort_keys=True)
-
-
-
 @dataclass
 class ShapeOnBoard:
     is_active: cp_model.IntVar
@@ -63,7 +48,6 @@ class Board:
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
             self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
-        # print('base vars:', len(self.model_vars))
 
     def init_shapes_on_board(self):
         for idx, (shape, shape_id) in enumerate(self.polyominoes):
@@ -84,7 +68,6 @@ class Board:
                     body=body,
                     disallow_same_shape=disallow_same_shape,
                 ))
-        # print('shapes on board:', len(self.shapes_on_board))
 
     def add_all_constraints(self):
         # RULES:
@@ -99,11 +82,9 @@ class Board:
         self.force_one_shape_per_block()  # Rule #1
         self.disallow_same_shape_touching()  # Rule #2
         self.fc = force_connected_component(self.model, self.model_vars)  # Rule #3
-        # print('force connected vars:', len(fc))
         shape_2_by_2 = frozenset({Pos(0, 0), Pos(0, 1), Pos(1, 0), Pos(1, 1)})
         self.disallow_shape(shape_2_by_2)  # Rule #4
 
-
     def only_allow_shapes_on_board(self):
         for shape_on_board in self.shapes_on_board:
             # if shape is active then all its body cells must be active
@@ -118,7 +99,6 @@ class Board:
         for block_i in self.block_numbers:
             shapes_on_block = [s for s in self.shapes_on_board if s.body & self.blocks[block_i]]
             assert all(s.body.issubset(self.blocks[block_i]) for s in shapes_on_block), 'expected all shapes on block to be fully contained in the block'
-            # print(f'shapes on block {block_i} has {len(shapes_on_block)} shapes')
             self.model.Add(sum(s.is_active for s in shapes_on_block) == 1)
 
     def disallow_same_shape_touching(self):
@@ -138,8 +118,6 @@ class Board:
             self.model.Add(sum(self.model_vars[p] for p in cur_body) < len(cur_body))
 
 
-
-
     def solve_and_print(self, verbose: bool = True, max_solutions: Optional[int] = None, verbose_callback: Optional[bool] = None):
         if verbose_callback is None:
             verbose_callback = verbose
@@ -147,10 +125,7 @@ class Board:
             assignment: dict[Pos, int] = {}
             for pos, var in board.model_vars.items():
                 assignment[pos] = solver.Value(var)
-            all_other_variables = {
-                'fc': {k: solver.Value(v) for k, v in board.fc.items()}
-            }
-            return SingleSolution(assignment=assignment, all_other_variables=all_other_variables)
+            return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
             res = np.full((self.V, self.H), ' ', dtype=str)
@@ -158,5 +133,4 @@ class Board:
                 c = 'X' if val == 1 else ' '
                 set_char(res, pos, c)
             print('[\n' + '\n'.join(['  ' + str(res[row].tolist()) + ',' for row in range(self.V)]) + '\n]')
-            pass
         return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)

puzzle_solver/puzzles/palisade/palisade.py

@@ -0,0 +1,104 @@
+from dataclasses import dataclass
+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_ortools import generic_solve_all, SingleSolution
+
+
+
+# a shape on the 2d board is just a set of positions
+Shape = frozenset[Pos]
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    shape: Shape
+    shape_id: int
+    body: set[Pos]
+
+
+def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
+    # give a shape and a board, return all valid translations of the shape that are fully contained in the board AND consistent with the clues on the board
+    shape_list = list(shape)
+    shape_borders = []  # will contain the number of borders for each pos in the shape; this has to be consistent with the clues on the board
+    for pos in shape_list:
+        v = 0
+        for direction in Direction:
+            next_pos = get_next_pos(pos, direction)
+            if not in_bounds(next_pos, board.shape[0], board.shape[1]) or next_pos not in shape:
+                v += 1
+        shape_borders.append(v)
+    shape_list = [(p.x, p.y) for p in shape_list]
+    # min x/y is always 0
+    max_x = max(p[0] for p in shape_list)
+    max_y = max(p[1] for p in shape_list)
+
+    for dy in range(0, board.shape[0] - max_y):
+        for dx in range(0, board.shape[1] - max_x):
+            body = tuple((p[0] + dx, p[1] + dy) for p in shape_list)
+            for i, p in enumerate(body):
+                c = board[p[1], p[0]]
+                if c != ' ' and c != str(shape_borders[i]):  # there is a clue and it doesn't match my translated shape, skip
+                    break
+            else:
+                yield tuple(get_pos(x=p[0], y=p[1]) for p in body)
+
+
+
+class Board:
+    def __init__(self, board: np.array, region_size: int):
+        assert region_size >= 1 and isinstance(region_size, int), 'region_size must be an integer greater than or equal to 1'
+        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.region_size = region_size
+        self.region_count = (self.V * self.H) // self.region_size
+        assert self.region_count * self.region_size == self.V * self.H, f'region_size must be a factor of the board size, got {self.region_size} and {self.region_count}'
+
+        self.polyominoes = polyominoes(self.region_size)
+
+        self.model = cp_model.CpModel()
+        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = defaultdict(set)
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for shape in self.polyominoes:
+            for body in get_valid_translations(shape, self.board):
+                uid = len(self.shapes_on_board)
+                shape_on_board = ShapeOnBoard(
+                    is_active=self.model.NewBoolVar(f'{uid}:is_active'),
+                    shape=shape,
+                    shape_id=uid,
+                    body=body,
+                )
+                self.shapes_on_board.append(shape_on_board)
+                for pos in body:
+                    self.pos_to_shapes[pos].add(shape_on_board)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # each position has exactly one shape active
+            self.model.AddExactlyOne(shape.is_active for shape in self.pos_to_shapes[pos])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for shape in board.shapes_on_board:
+                if solver.Value(shape.is_active) == 1:
+                    for pos in shape.body:
+                        assignment[pos] = shape.shape_id
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            id_board = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                region_idx = single_res.assignment[pos]
+                set_char(id_board, pos, region_idx)
+            board = np.where(self.board == ' ', '·', self.board)
+            print(render_grid(id_board_to_wall_board(id_board), center_char=board))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -0,0 +1,130 @@
+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_ortools import generic_solve_all, SingleSolution
+
+
+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 (i, rectangle) in enumerate(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('[')
+            # for row in id_board:
+            #     print('       ', row.tolist(), end=',\n')
+            # print('    ])')
+            print(render_grid(res, center_char=self.board))
+
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)