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

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)

puzzle_solver/puzzles/shingoki/shingoki.py

@@ -0,0 +1,158 @@
+import json
+from dataclasses import dataclass
+import time
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_neighbors4, get_next_pos, get_char, in_bounds
+from puzzle_solver.core.utils_ortools import generic_solve_all, force_connected_component, and_constraint
+from puzzle_solver.core.utils_visualizer import render_grid
+
+
+@dataclass(frozen=True)
+class SingleSolution:
+    assignment: dict[tuple[Pos, Pos], int]
+
+    def get_hashable_solution(self) -> str:
+        result = []
+        for (pos, neighbor), v in self.assignment.items():
+            result.append((pos.x, pos.y, neighbor.x, neighbor.y, v))
+        return json.dumps(result, sort_keys=True)
+
+
+def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[tuple[Pos, Pos]]:
+    out = []
+    prev_pos = pos
+    while True:
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, V, H):
+            break
+        out.append((prev_pos, pos))
+        prev_pos = pos
+    return out
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item().strip() == '') or (str(c.item())[:-1].isdecimal() and c.item()[-1].upper() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only space or digits and B/W'
+
+        self.V, self.H = board.shape
+        self.board_numbers: dict[Pos, int] = {}
+        self.board_colors: dict[Pos, str] = {}
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(board, pos)
+            if c.strip() == '':
+                continue
+            self.board_numbers[pos] = int(c[:-1])
+            self.board_colors[pos] = c[-1].upper()
+        self.model = cp_model.CpModel()
+        self.edge_vars: dict[tuple[Pos, 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):
+            for neighbor in get_neighbors4(pos, self.V, self.H):
+                if (neighbor, pos) in self.edge_vars:  # already added in opposite direction
+                    self.edge_vars[(pos, neighbor)] = self.edge_vars[(neighbor, pos)]
+                else:  # new edge
+                    self.edge_vars[(pos, neighbor)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
+
+    def add_all_constraints(self):
+        # each corners must have either 0 or 2 neighbors
+        for pos in get_all_pos(self.V, self.H):
+            corner_connections = [self.edge_vars[(pos, n)] for n in get_neighbors4(pos, self.V, self.H)]
+            if pos not in self.board_numbers:  # no color, either 0 or 2 edges
+                self.model.AddLinearExpressionInDomain(sum(corner_connections), cp_model.Domain.FromValues([0, 2]))
+            else:  # color, must have exactly 2 edges
+                self.model.Add(sum(corner_connections) == 2)
+
+        # enforce colors
+        for pos in get_all_pos(self.V, self.H):
+            if pos not in self.board_numbers:
+                continue
+            self.enforce_corner_color(pos, self.board_colors[pos])
+            self.enforce_corner_number(pos, self.board_numbers[pos])
+        
+        # enforce single connected component
+        def is_neighbor(edge1: tuple[Pos, Pos], edge2: tuple[Pos, Pos]) -> bool:
+            return any(c1 == c2 for c1 in edge1 for c2 in edge2)
+        force_connected_component(self.model, self.edge_vars, is_neighbor=is_neighbor)
+
+    def enforce_corner_color(self, pos: Pos, pos_color: str):
+        assert pos_color in ['W', 'B'], f'Invalid color: {pos_color}'
+        pos_r = get_next_pos(pos, Direction.RIGHT)
+        var_r = self.edge_vars[(pos, pos_r)] if (pos, pos_r) in self.edge_vars else False
+        pos_d = get_next_pos(pos, Direction.DOWN)
+        var_d = self.edge_vars[(pos, pos_d)] if (pos, pos_d) in self.edge_vars else False
+        pos_l = get_next_pos(pos, Direction.LEFT)
+        var_l = self.edge_vars[(pos, pos_l)] if (pos, pos_l) in self.edge_vars else False
+        pos_u = get_next_pos(pos, Direction.UP)
+        var_u = self.edge_vars[(pos, pos_u)] if (pos, pos_u) in self.edge_vars else False
+        if pos_color == 'W':  # White circles must be passed through in a straight line
+            self.model.Add(var_r == var_l)
+            self.model.Add(var_u == var_d)
+        elif pos_color == 'B':  # Black circles must be turned upon
+            self.model.Add(var_r == 0).OnlyEnforceIf([var_l])
+            self.model.Add(var_l == 0).OnlyEnforceIf([var_r])
+            self.model.Add(var_u == 0).OnlyEnforceIf([var_d])
+            self.model.Add(var_d == 0).OnlyEnforceIf([var_u])
+        else:
+            raise ValueError(f'Invalid color: {pos_color}')
+
+    def enforce_corner_number(self, pos: Pos, pos_number: int):
+        # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
+        # Build visibility chains per direction (exclude self)
+        vis_vars: list[cp_model.IntVar] = []
+        for direction in Direction:
+            rays = get_ray(pos, self.V, self.H, direction)  # cells outward
+            if not rays:
+                continue
+            # Chain: v0 = w[ray[0]]; vt = w[ray[t]] & vt-1
+            prev = None
+            for idx, (pos1, pos2) in enumerate(rays):
+                v = self.model.NewBoolVar(f"vis[{pos1}-{pos2}]->({direction.name})[{idx}]")
+                vis_vars.append(v)
+                if idx == 0:
+                    # v0 == w[cell]
+                    self.model.Add(v == self.edge_vars[(pos1, pos2)])
+                else:
+                    and_constraint(self.model, target=v, cs=[self.edge_vars[(pos1, pos2)], prev])
+                prev = v
+        self.model.Add(sum(vis_vars) == pos_number)
+
+
+    def solve_and_print(self, verbose: bool = True):
+        tic = time.time()
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[tuple[Pos, Pos], int] = {}
+            for (pos, neighbor), var in board.edge_vars.items():
+                assignment[(pos, neighbor)] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            nonlocal tic
+            print(f"Solution found in {time.time() - tic:.2f} seconds")
+            tic = time.time()
+            res = np.full((self.V - 1, self.H - 1), ' ', dtype=object)
+            for (pos, neighbor), v in single_res.assignment.items():
+                if v == 0:
+                    continue
+                min_x = min(pos.x, neighbor.x)
+                min_y = min(pos.y, neighbor.y)
+                dx = abs(pos.x - neighbor.x)
+                dy = abs(pos.y - neighbor.y)
+                if min_x == self.H - 1:  # only way to get right
+                    res[min_y][min_x - 1] += 'R'
+                elif min_y == self.V - 1:  # only way to get down
+                    res[min_y - 1][min_x] += 'D'
+                elif dx == 1:
+                    res[min_y][min_x] += 'U'
+                elif dy == 1:
+                    res[min_y][min_x] += 'L'
+                else:
+                    raise ValueError(f'Invalid position: {pos} and {neighbor}')
+            print(render_grid(res, center_char='.'))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/singles/singles.py

@@ -1,8 +1,9 @@
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos, get_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
 
 
 class Board:
@@ -14,62 +15,35 @@ class Board:
         self.H = board.shape[1]
         self.N = self.V * self.H
         self.idx_of: dict[Pos, int] = get_all_pos_to_idx_dict(self.V, self.H)
-
         self.model = cp_model.CpModel()
-        self.B = {} # black squares
-        self.W = {} # white squares
+        self.B = {}
+        self.W = {}
         self.Num = {} # value of squares (Num = N + idx if black, else board[pos])
-
         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}')
-            # either black or white
-            self.model.AddExactlyOne([self.B[pos], self.W[pos]])
+            self.W[pos] = self.B[pos].Not()
             self.Num[pos] = self.model.NewIntVar(0, 2*self.N, f'{pos}')
             self.model.Add(self.Num[pos] == self.N + self.idx_of[pos]).OnlyEnforceIf(self.B[pos])
-            self.model.Add(self.Num[pos] == int(get_char(self.board, pos))).OnlyEnforceIf(self.B[pos].Not())
+            self.model.Add(self.Num[pos] == int(get_char(self.board, pos))).OnlyEnforceIf(self.W[pos])
 
     def add_all_constraints(self):
-        self.no_adjacent_blacks()
-        self.no_number_appears_twice()
-        self.force_connected_component()
-
-    def no_adjacent_blacks(self):
-        # no two black squares are adjacent 
-        for pos in get_all_pos(self.V, self.H):
+        for pos in get_all_pos(self.V, self.H):  # no two black squares are adjacent
             for neighbor in get_neighbors4(pos, self.V, self.H):
                 self.model.Add(self.B[pos] + self.B[neighbor] <= 1)
-
-    def no_number_appears_twice(self):
-        # no number appears twice in any row or column (numbers are ignored if black)
-        for row in range(self.V):
-            var_list = [self.Num[pos] for pos in get_row_pos(row, self.H)]
-            self.model.AddAllDifferent(var_list)
-        for col in range(self.H):
-            var_list = [self.Num[pos] for pos in get_col_pos(col, self.V)]
-            self.model.AddAllDifferent(var_list)
-
-    def force_connected_component(self):
-        force_connected_component(self.model, self.W)
-
-
+        for row in range(self.V):  # no number appears twice in any row (numbers are ignored if black)
+            self.model.AddAllDifferent([self.Num[pos] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):  # no number appears twice in any column (numbers are ignored if black)
+            self.model.AddAllDifferent([self.Num[pos] for pos in get_col_pos(col, self.V)])
+        force_connected_component(self.model, self.W)  # all white squares must be a single connected component
 
     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)
+            return SingleSolution(assignment={pos: 1 if solver.Value(val) == 1 else 0 for pos, val in board.B.items()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=object)
-            for pos in get_all_pos(self.V, self.H):
-                c = get_char(self.board, pos)
-                c = 'B' if single_res.assignment[pos] == 1 else ' '
-                set_char(res, pos, c)
-            print(res)
+            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.board[r, c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -242,4 +242,6 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'LITS_MDoxNzksNzY3.png')
     # main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
     # main(Path(__file__).parent / 'input_output' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.png')
-    main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')
+    # main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')
+    # main(Path(__file__).parent / 'input_output' / 'heyawake_MDoxNiwxNDQ=.png')
+    main(Path(__file__).parent / 'input_output' / 'heyawake_MTQ6ODQ4LDEzOQ==.png')

puzzle_solver/puzzles/tapa/tapa.py

@@ -0,0 +1,98 @@
+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, set_char, get_char, in_bounds, Direction, get_next_pos, get_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
+
+
+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, "Xs must have at least one block length."
+    assert all(x >= 1 for x in Xs), "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(self.model, self.model_vars)
+
+    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:
+            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")
+            board_justified = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos).strip()
+                if len(c) > 3:
+                    c = '...'
+                set_char(board_justified, pos, ' ' * (2 - len(c)) + c)
+            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(board_justified[r, c])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=5)