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

puzzle_solver/puzzles/sudoku/sudoku.py

@@ -1,14 +1,14 @@
-from typing import Union
+from typing import Union, Optional
 
 import numpy as np
 from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_pos, get_all_pos, get_char, set_char, get_row_pos, get_col_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, or_constraint, SingleSolution
 
 
 def get_value(board: np.array, pos: Pos) -> Union[int, str]:
-    c = get_char(board, pos)
+    c = get_char(board, pos).lower()
     if c == ' ':
         return c
     if str(c).isdecimal():
@@ -27,22 +27,40 @@ def set_value(board: np.array, pos: Pos, value: Union[int, str]):
     set_char(board, pos, value)
 
 
-def get_block_pos(i: int, B: int) -> list[Pos]:
-    top_left_x = (i%B)*B
-    top_left_y = (i//B)*B
-    return [get_pos(x=top_left_x + x, y=top_left_y + y) for x in range(B) for y in range(B)]
+def get_block_pos(i: int, Bv: int, Bh: int) -> list[Pos]:
+    # Think: Bv=3 and Bh=4 while the board has 4 vertical blocks and 3 horizontal blocks
+    top_left_x = (i%Bv)*Bh
+    top_left_y = (i//Bv)*Bv
+    return [get_pos(x=top_left_x + x, y=top_left_y + y) for x in range(Bh) for y in range(Bv)]
 
 
 class Board:
-    def __init__(self, board: np.array):
+    def __init__(self, board: np.array, block_size: Optional[tuple[int, int]] = None, sandwich: Optional[dict[str, list[int]]] = None, unique_diagonal: bool = False):
         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(isinstance(i.item(), str) and len(i.item()) == 1 and (i.item().isalnum() or i.item() == ' ') for i in np.nditer(board)), 'board must contain only alphanumeric characters or space'
         self.board = board
-        self.N = board.shape[0]
-        self.B = np.sqrt(self.N)  # block size
-        assert self.B.is_integer(), 'board size must be a perfect square'
-        self.B = int(self.B)
+        self.V, self.H = board.shape
+        if block_size is None:
+            B = np.sqrt(self.V)  # block size
+            assert B.is_integer(), 'board size must be a perfect square or provide block_size'
+            Bv, Bh = int(B), int(B)
+        else:
+            Bv, Bh = block_size
+            assert Bv * Bh == self.V, 'block size must be a factor of board size'
+        # can be different in 4x3 for example
+        self.Bv = Bv
+        self.Bh = Bh
+        self.B = Bv * Bh  # block count
+        if sandwich is not None:
+            assert set(sandwich.keys()) == set(['side', 'bottom']), 'sandwich must contain only side and bottom'
+            assert len(sandwich['side']) == self.H, 'side must be equal to board width'
+            assert len(sandwich['bottom']) == self.V, 'bottom must be equal to board height'
+            self.sandwich = sandwich
+        else:
+            self.sandwich = None
+        self.unique_diagonal = unique_diagonal
+    
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
 
@@ -50,28 +68,50 @@ class Board:
         self.add_all_constraints()
 
     def create_vars(self):
-        for pos in get_all_pos(self.N):
-            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewIntVar(1, self.B, f'{pos}')
 
     def add_all_constraints(self):
         # some squares are already filled
-        for pos in get_all_pos(self.N):
+        for pos in get_all_pos(self.V, self.H):
             c = get_value(self.board, pos)
             if c != ' ':
                 self.model.Add(self.model_vars[pos] == c)
         # every number appears exactly once in each row, each column and each block
         # each row
-        for row in range(self.N):
-            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.N)]
+        for row in range(self.V):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, H=self.H)]
             self.model.AddAllDifferent(row_vars)
         # each column
-        for col in range(self.N):
-            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.N)]
+        for col in range(self.H):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, V=self.V)]
             self.model.AddAllDifferent(col_vars)
         # each block
-        for block_i in range(self.N):
-            block_vars = [self.model_vars[p] for p in get_block_pos(block_i, self.B)]
+        for block_i in range(self.B):
+            block_vars = [self.model_vars[p] for p in get_block_pos(block_i, Bv=self.Bv, Bh=self.Bh)]
             self.model.AddAllDifferent(block_vars)
+        if self.sandwich is not None:
+            self.add_sandwich_constraints()
+        if self.unique_diagonal:
+            self.add_unique_diagonal_constraints()
+
+    def add_sandwich_constraints(self):
+        for c, clue in enumerate(self.sandwich['bottom']):
+            if clue is None or int(clue) < 0:
+                continue
+            col_vars = [self.model_vars[p] for p in get_col_pos(c, V=self.V)]
+            add_single_sandwich(col_vars, int(clue), self.model, name=f"sand_side_{c}")
+        for r, clue in enumerate(self.sandwich['side']):
+            if clue is None or int(clue) < 0:
+                continue
+            row_vars = [self.model_vars[p] for p in get_row_pos(r, H=self.H)]
+            add_single_sandwich(row_vars, int(clue), self.model, name=f"sand_bottom_{r}")
+
+    def add_unique_diagonal_constraints(self):
+        main_diagonal_vars = [self.model_vars[get_pos(x=i, y=i)] for i in range(min(self.V, self.H))]
+        self.model.AddAllDifferent(main_diagonal_vars)
+        anti_diagonal_vars = [self.model_vars[get_pos(x=i, y=self.V-i-1)] for i in range(min(self.V, self.H))]
+        self.model.AddAllDifferent(anti_diagonal_vars)
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
@@ -81,10 +121,83 @@ class Board:
             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):
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
                 c = get_value(self.board, pos)
                 c = single_res.assignment[pos]
                 set_value(res, pos, c)
             print(res)
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
+
+
+
+def add_single_sandwich(vars_line: list[cp_model.IntVar], clue: int, model: cp_model.CpModel, name: str):
+    # VAR count:
+    # is_min: L
+    # is_max: L
+    # pos_min/max/lt: 1+1+1
+    # between: L
+    # a1/a2/case_a: L+L+L
+    # b1/b2/case_b: L+L+L
+    # take: L
+    # 10L+3 per 1 call of the function (i.e. per 1 line)
+    # entire board will have 2L lines (rows and columns)
+    # in total: 20L^2+6L
+
+    L = len(vars_line)
+    is_min = [model.NewBoolVar(f"{name}_ismin_{i}") for i in range(L)]
+    is_max = [model.NewBoolVar(f"{name}_ismax_{i}") for i in range(L)]
+    for i, v in enumerate(vars_line):
+        model.Add(v == 1).OnlyEnforceIf(is_min[i])
+        model.Add(v != 1).OnlyEnforceIf(is_min[i].Not())
+        model.Add(v == L).OnlyEnforceIf(is_max[i])
+        model.Add(v != L).OnlyEnforceIf(is_max[i].Not())
+
+    # index of the minimum and maximum values (sum of the values inbetween must = clue)
+    pos_min = model.NewIntVar(0, L - 1, f"{name}_pos_min")
+    pos_max = model.NewIntVar(0, L - 1, f"{name}_pos_max")
+    model.Add(pos_min == sum(i * is_min[i] for i in range(L)))
+    model.Add(pos_max == sum(i * is_max[i] for i in range(L)))
+
+    # used later to handle both cases (A. pos_min < pos_max and B. pos_max < pos_min)
+    lt = model.NewBoolVar(f"{name}_lt")  # pos_min < pos_max ?
+    model.Add(pos_min < pos_max).OnlyEnforceIf(lt)
+    model.Add(pos_min >= pos_max).OnlyEnforceIf(lt.Not())
+
+    between = [model.NewBoolVar(f"{name}_between_{i}") for i in range(L)]
+    for i in range(L):
+        # Case A: pos_min < i < pos_max (AND lt is true)
+        a1 = model.NewBoolVar(f"{name}_a1_{i}")  # pos_min < i
+        a2 = model.NewBoolVar(f"{name}_a2_{i}")  # i < pos_max
+
+        model.Add(pos_min < i).OnlyEnforceIf(a1)
+        model.Add(pos_min >= i).OnlyEnforceIf(a1.Not())
+        model.Add(i < pos_max).OnlyEnforceIf(a2)
+        model.Add(i >= pos_max).OnlyEnforceIf(a2.Not())
+
+        case_a = model.NewBoolVar(f"{name}_caseA_{i}")
+        and_constraint(model, case_a, [lt, a1, a2])
+
+        # Case B: pos_max < i < pos_min (AND lt is false)
+        b1 = model.NewBoolVar(f"{name}_b1_{i}")  # pos_max < i
+        b2 = model.NewBoolVar(f"{name}_b2_{i}")  # i < pos_min
+
+        model.Add(pos_max < i).OnlyEnforceIf(b1)
+        model.Add(pos_max >= i).OnlyEnforceIf(b1.Not())
+        model.Add(i < pos_min).OnlyEnforceIf(b2)
+        model.Add(i >= pos_min).OnlyEnforceIf(b2.Not())
+
+        case_b = model.NewBoolVar(f"{name}_caseB_{i}")
+        and_constraint(model, case_b, [lt.Not(), b1, b2])
+
+        # between[i] is true if we're in case A or case B
+        or_constraint(model, between[i], [case_a, case_b])
+
+    # sum values at indices that are "between"
+    take = [model.NewIntVar(0, L, f"{name}_take_{i}") for i in range(L)]
+    for i, v in enumerate(vars_line):
+        # take[i] = v if between[i] else 0
+        model.Add(take[i] == v).OnlyEnforceIf(between[i])
+        model.Add(take[i] == 0).OnlyEnforceIf(between[i].Not())
+
+    model.Add(sum(take) == clue)

puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py

@@ -0,0 +1,169 @@
+
+def extract_lines(bw):
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = max(5, cols // 20)
+    h_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv2.erode(horizontal, h_kernel)
+    horizontal = cv2.dilate(horizontal, h_kernel)
+    h_means = np.mean(horizontal, axis=1)
+    h_idx = np.where(h_means > np.percentile(h_means, 70))[0]
+
+    rows = vertical.shape[0]
+    verticalsize = max(5, rows // 20)
+    v_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, verticalsize))
+    vertical = cv2.erode(vertical, v_kernel)
+    vertical = cv2.dilate(vertical, v_kernel)
+    v_means = np.mean(vertical, axis=0)
+    v_idx = np.where(v_means > np.percentile(v_means, 70))[0]
+    return h_idx, v_idx
+
+
+def _cluster_line_indices(indices, min_run=3):
+    """Group consecutive indices into line positions (take the mean of each run)."""
+    if len(indices) == 0:
+        return []
+    indices = np.sort(indices)
+    runs = []
+    run = [indices[0]]
+    for k in indices[1:]:
+        if k == run[-1] + 1:
+            run.append(k)
+        else:
+            if len(run) >= min_run:
+                runs.append(int(np.mean(run)))
+            run = [k]
+    if len(run) >= min_run:
+        runs.append(int(np.mean(run)))
+    # De-duplicate lines that are too close (rare)
+    dedup = []
+    for x in runs:
+        if not dedup or x - dedup[-1] > 2:
+            dedup.append(x)
+    return dedup
+
+
+def extract_yinyang_board(image_path, debug=False):
+    # Load and pre-process
+    img = cv2.imread(str(image_path))
+    assert img is not None, f"Failed to read image: {image_path}"
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    # Light grid lines → enhance lines using adaptive threshold
+    # (binary inverted so lines/dots become white)
+    bw = cv2.adaptiveThreshold(
+        gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY_INV, 35, 5
+    )
+
+    # Detect grid line indices (no guessing)
+    h_idx, v_idx = extract_lines(bw)
+    print(f"h_idx: {h_idx}")
+    print(f"v_idx: {v_idx}")
+    h_lines = h_idx
+    v_lines = v_idx
+    # h_lines = _cluster_line_indices(h_idx)
+    # v_lines = _cluster_line_indices(v_idx)
+    assert len(h_lines) >= 2 and len(v_lines) >= 2, "Could not detect grid lines"
+
+    # Cells are spans between successive grid lines
+    N_rows = len(h_lines) - 1
+    N_cols = len(v_lines) - 1
+    board = np.full((N_rows, N_cols), ' ', dtype='<U1')
+
+    # For robust per-cell analysis, also create a "dots" image with grid erased
+    # Remove thickened grid from bw
+    # Build masks for horizontal/vertical lines (reusing kernels sized by image dims)
+    cols = bw.shape[1]
+    rows = bw.shape[0]
+    h_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (max(5, cols // 20), 1))
+    v_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, max(5, rows // 20)))
+    horiz = cv2.morphologyEx(bw, cv2.MORPH_OPEN, h_kernel)
+    vert = cv2.morphologyEx(bw, cv2.MORPH_OPEN, v_kernel)
+    grid = cv2.bitwise_or(horiz, vert)
+    dots = cv2.bitwise_and(bw, cv2.bitwise_not(grid))  # mostly circles remain
+
+    # Iterate cells
+    print(f"N_rows: {N_rows}, N_cols: {N_cols}")
+    print(f"h_lines: {h_lines}")
+    print(f"v_lines: {v_lines}")
+    for r in range(N_rows):
+        y0, y1 = h_lines[r], h_lines[r + 1]
+        # shrink ROI to avoid line bleed
+        y0i = max(y0 + 2, 0)
+        y1i = max(min(y1 - 2, dots.shape[0]), y0i + 1)
+        for c in range(N_cols):
+            x0, x1 = v_lines[c], v_lines[c + 1]
+            x0i = max(x0 + 2, 0)
+            x1i = max(min(x1 - 2, dots.shape[1]), x0i + 1)
+
+            roi_gray = gray[y0i:y1i, x0i:x1i]
+            roi_dots = dots[y0i:y1i, x0i:x1i]
+            area = roi_dots.shape[0] * roi_dots.shape[1]
+            if area == 0:
+                continue
+
+            # If no meaningful foreground, it's empty
+            fg_area = int(np.count_nonzero(roi_dots))
+            if fg_area < 0.03 * area:
+                board[r, c] = ' '
+                continue
+
+            # Segment the largest blob (circle) inside the cell
+            contours, _ = cv2.findContours(roi_dots, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if not contours:
+                board[r, c] = ' '
+                continue
+
+            cnt = max(contours, key=cv2.contourArea)
+            if cv2.contourArea(cnt) < 0.02 * area:
+                board[r, c] = ' '
+                continue
+
+            mask = np.zeros_like(roi_dots)
+            cv2.drawContours(mask, [cnt], -1, 255, thickness=-1)
+
+            mean_inside = float(cv2.mean(roi_gray, mask=mask)[0])
+
+            # Heuristic: black stones have dark interior; white stones bright interior
+            # (grid background is white; outlines contribute little to mean)
+            board[r, c] = 'B' if mean_inside < 150 else 'W'
+    non_empty_rows = []
+    non_empty_cols = []
+    for r in range(N_rows):
+        if not all(board[r, :] == ' '):
+            non_empty_rows.append(r)
+    for c in range(N_cols):
+        if not all(board[:, c] == ' '):
+            non_empty_cols.append(c)
+    board = board[non_empty_rows, :][:, non_empty_cols]
+
+    if debug:
+        for row in board:
+            print(row.tolist())
+    output_path = Path(__file__).parent / "input_output" / (image_path.stem + ".json")
+    with open(output_path, 'w') as f:
+        f.write('[\n')
+        for i, row in enumerate(board):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(board) - 1:
+                f.write(',')
+            f.write('\n')
+        f.write(']')
+    print('output json: ', output_path)
+
+    return board
+
+if __name__ == "__main__":
+    #  python .\src\puzzle_solver\puzzles\yin_yang\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
+    import cv2
+    import numpy as np
+    from pathlib import Path
+    image_path = Path(__file__).parent / "input_output" / "MzoyLDcwMSw2NTY=.png"
+    # image_path = Path(__file__).parent / "input_output" / "Njo5MDcsNDk4.png"
+    # image_path = Path(__file__).parent / "input_output" / "MTE6Niw0NjEsMTIx.png"
+    assert image_path.exists(), f"Image file does not exist: {image_path}"
+    board = extract_yinyang_board(image_path, debug=True)
+    print(board)

puzzle_solver/puzzles/yin_yang/yin_yang.py

@@ -0,0 +1,110 @@
+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, in_bounds, Direction, get_next_pos, get_pos
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
+
+
+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, B, or W'
+        self.board = board
+        self.V, self.H = board.shape
+        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}')
+
+    def add_all_constraints(self):
+        self.force_clues()
+        self.disallow_2x2()
+        self.disallow_checkers()
+        self.force_connected_component()
+        self.force_border_transitions()
+
+    def force_clues(self):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos)
+            if c not in ['B', 'W']:
+                continue
+            self.model.Add(self.B[pos] == (c == 'B'))
+
+    def disallow_2x2(self):
+        for pos in get_all_pos(self.V, self.H):  # disallow 2x2 (WW/WW) and (BB/BB)
+            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], self.B[tr], self.B[bl], self.B[br]])
+            self.model.AddBoolOr([self.B[tl].Not(), self.B[tr].Not(), self.B[bl].Not(), self.B[br].Not()])
+    
+    def disallow_checkers(self):
+        # from https://ralphwaldo.github.io/yinyang_summary.html
+        for pos in get_all_pos(self.V, self.H):  # disallow (WB/BW) and (BW/WB)
+            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], self.B[tr].Not(), self.B[bl].Not(), self.B[br]])  # disallow (WB/BW)
+            self.model.AddBoolOr([self.B[tl].Not(), self.B[tr], self.B[bl], self.B[br].Not()])  # disallow (BW/WB)
+
+    def force_connected_component(self):
+        # force single connected component for both colors
+        force_connected_component(self.model, self.B)
+        force_connected_component(self.model, {k: v.Not() for k, v in self.B.items()})
+
+    def force_border_transitions(self):
+        # from https://ralphwaldo.github.io/yinyang_summary.html
+        # The border cells cannot be split into four (or more) separate blocks of colours
+        # It is therefore either split into two blocks (one of each colour), or is just a single block of one colour or the other
+        border_cells = []  # go in a ring clockwise from top left
+        for x in range(self.H):
+            border_cells.append(get_pos(x=x, y=0))
+        for y in range(1, self.V):
+            border_cells.append(get_pos(x=self.H-1, y=y))
+        for x in range(self.H-2, -1, -1):
+            border_cells.append(get_pos(x=x, y=self.V-1))
+        for y in range(self.V-2, 0, -1):
+            border_cells.append(get_pos(x=0, y=y))
+        # tie the knot
+        border_cells.append(border_cells[0])
+        # unequal sum is 0 or 2
+        deltas = []
+        for i in range(len(border_cells)-1):
+            aux = self.model.NewBoolVar(f'border_transition_{i}')  # i is black while i+1 is white
+            and_constraint(self.model, aux, [self.B[border_cells[i]], self.B[border_cells[i+1]].Not()])
+            deltas.append(aux)
+        self.model.Add(lxp.Sum(deltas) <= 1)
+
+
+    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] = 'B' if solver.BooleanValue(var) else 'W'
+            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 = single_res.assignment[pos]
+                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)