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

puzzle_solver/puzzles/unequal/unequal.py

@@ -0,0 +1,128 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_row_pos, get_col_pos, set_char, get_pos, get_char, Direction, in_bounds, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def parse_board(board: np.array) -> tuple[np.array, list[tuple[Pos, Pos, str]]]:
+    """Returns the internal board and a list for every pair of positions (p1, p2, comparison_type) where p1 < p2 if comparison_type is '<' otherwise abs(p1 - p2)==1 if comparison_type is '|'"""
+    V = int(np.ceil(board.shape[0] / 2))
+    H = int(np.ceil(board.shape[1] / 2))
+    internal_board = np.full((V, H), ' ', dtype=object)
+    pairs = []
+    for row_i in range(board.shape[0]):
+        for col_i in range(board.shape[1]):
+            cell = board[row_i, col_i]
+            if row_i % 2 == 0 and col_i % 2 == 0:  # number or empty cell
+                if cell == ' ':
+                    continue
+                # map A to 10, B to 11, etc.
+                if str(cell).isalpha() and len(str(cell)) == 1:
+                    cell = ord(cell.upper()) - ord('A') + 10
+                assert str(cell).isdecimal(), f'expected number at {row_i, col_i}, got {cell}'
+                internal_board[row_i // 2, col_i // 2] = int(cell)
+            elif row_i % 2 == 0 and col_i % 2 == 1:  # horizontal comparison
+                assert cell in ['<', '>', '|', ' '], f'expected <, >, |, or empty cell at {row_i, col_i}, got {cell}'
+                if cell == ' ':
+                    continue
+                p1 = get_pos(x=col_i // 2, y=row_i // 2)
+                p2 = get_pos(x=p1.x + 1, y=p1.y)
+                if cell == '<':
+                    pairs.append((p1, p2, '<'))
+                elif cell == '>':
+                    pairs.append((p2, p1, '<'))
+                elif cell == '|':
+                    pairs.append((p1, p2, '|'))
+                else:
+                    raise ValueError(f'unexpected cell {cell} at {row_i, col_i}')
+            elif row_i % 2 == 1 and col_i % 2 == 0:  # vertical comparison
+                assert cell in ['∧', '∨', 'U', 'D', 'V', 'n', '-', '|', ' '], f'expected ∧, ∨, U, D, V, n, -, |, or empty cell at {row_i, col_i}, got {cell}'
+                if cell == ' ':
+                    continue
+                p1 = get_pos(x=col_i // 2, y=row_i // 2)
+                p2 = get_pos(x=p1.x, y=p1.y + 1)
+                if cell in ['∨', 'U', 'V']:
+                    pairs.append((p2, p1, '<'))
+                elif cell in ['∧', 'D', 'n']:
+                    pairs.append((p1, p2, '<'))
+                elif cell in ['-', '|']:
+                    pairs.append((p1, p2, '|'))
+                else:
+                    raise ValueError(f'unexpected cell {cell} at {row_i, col_i}')
+            else:
+                assert cell in [' ', '.', 'X'], f'expected empty cell or dot or X at unused corner {row_i, col_i}, got {cell}'
+    return internal_board, pairs
+
+class Board:
+    def __init__(self, board: np.array, adjacent_mode: bool = False, include_zero_before_letter: bool = True):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] > 0 and board.shape[1] > 0, 'board must be non-empty'
+        self.board, self.pairs = parse_board(board)
+        self.adjacent_mode = adjacent_mode
+        self.V, self.H = self.board.shape
+        self.lb = 1
+        self.N = max(self.V, self.H)
+        if include_zero_before_letter and self.N > 9: # zero is introduced when board gets to 10, then we add 1 letter after that
+            self.lb = 0
+            self.N -= 1
+
+        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.NewIntVar(self.lb, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        for row_i in range(self.V):
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_row_pos(row_i, self.H)])
+        for col_i in range(self.H):
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_col_pos(col_i, self.V)])
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if str(c).isdecimal():
+                self.model.Add(self.model_vars[pos] == int(c))
+
+        for p1, p2, comparison_type in self.pairs:
+            assert comparison_type in ['<', '|'], f'SHOULD NEVER HAPPEN: invalid comparison type {comparison_type}, expected < or |'
+            if comparison_type == '<':
+                self.model.Add(self.model_vars[p1] < self.model_vars[p2])
+            elif comparison_type == '|':
+                aux = self.model.NewIntVar(0, 2*self.N, f'aux_{p1}_{p2}')
+                self.model.AddAbsEquality(aux, self.model_vars[p1] - self.model_vars[p2])
+                self.model.Add(aux == 1)
+        if self.adjacent_mode:
+            # in adjacent mode, there is strict NON adjacency if a | does not exist
+            all_pairs = {(p1, p2) for p1, p2, _ in self.pairs}
+            for pos in get_all_pos(self.V, self.H):
+                for direction in [Direction.RIGHT, Direction.DOWN]:
+                    neighbor = get_next_pos(pos, direction)
+                    if not in_bounds(neighbor, self.V, self.H):
+                        continue
+                    if (pos, neighbor) in all_pairs:
+                        continue
+                    assert (neighbor, pos) not in all_pairs, f'SHOULD NEVER HAPPEN: both {pos}->{neighbor} and {neighbor}->{pos} are in the same pair'
+                    aux = self.model.NewIntVar(0, 2*self.N, f'aux_{pos}_{neighbor}')
+                    self.model.AddAbsEquality(aux, self.model_vars[pos] - self.model_vars[neighbor])
+                    self.model.Add(aux != 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.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):
+                set_char(res, pos, str(single_res.assignment[pos]))
+            print('[')
+            for row in range(self.V):
+                line = '    [ ' + ' '.join(res[row].tolist()) + ' ]'
+                print(line)
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/unruly/unruly.py

@@ -0,0 +1,54 @@
+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, get_char, get_row_pos, get_col_pos, in_bounds, Direction, get_next_pos, get_pos
+from puzzle_solver.core.utils_visualizer import combined_function
+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] % 2 == 0 and board.shape[1] % 2 == 0, 'board must have even number of rows and columns'
+        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):
+            # enforce hints
+            c = get_char(self.board, pos)
+            if c.strip():
+                self.model.Add(self.model_vars[pos] == (c.strip() == 'B'))
+            # no three consecutive squares, horizontally or vertically, are the same colour
+            for direction in [Direction.RIGHT, Direction.DOWN]:
+                var_list = [pos]
+                for _ in range(2):
+                    var_list.append(get_next_pos(var_list[-1], direction))
+                if all(in_bounds(v, self.V, self.H) for v in var_list):
+                    self.model.Add(lxp.Sum([self.model_vars[v] for v in var_list]) != 0)
+                    self.model.Add(lxp.Sum([self.model_vars[v] for v in var_list]) != 3)
+        # each row and column contains the same number of black and white squares.
+        for col in range(self.H):
+            var_list = [self.model_vars[pos] for pos in get_col_pos(col, self.V)]
+            self.model.Add(lxp.Sum(var_list) == self.V // 2)
+        for row in range(self.V):
+            var_list = [self.model_vars[pos] for pos in get_row_pos(row, self.H)]
+            self.model.Add(lxp.Sum(var_list) == self.H // 2)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/vectors/vectors.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_char, get_next_pos, get_pos, Shape, in_bounds
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+Block = tuple[Pos, int]  # a block has a position and a number
+
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    uid: str
+    number: int
+    shape: Shape
+
+
+def get_unblocked_ray(block: Block, direction: Direction, board: np.array) -> tuple[Pos, ...]:
+    out = []
+    pos = block[0]
+    while True:
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, board.shape[0], board.shape[1]):
+            break
+        if get_char(board, pos).strip() != '':
+            break
+        out.append(pos)
+    return tuple(out)
+
+
+def find_quadruplets(target: int, limits: tuple[int, int, int, int]):
+    """
+    Find all quadruplets (a, b, c, d) such that a + b + c + d = target and a, b, c, d are in the given limits.
+    This is used to get all possible lengths for the four vectors coming out of a block and the limits are the maximum length of the vectors in each direction.
+    """
+    for a in range(limits[0] + 1):
+        for b in range(limits[1] + 1):
+            for c in range(limits[2] + 1):
+                d = target - (a + b + c)
+                if 0 <= d <= limits[3]:
+                    yield (a, b, c, d)
+
+
+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() in ['', '#']) or str(c.item()).strip().isdecimal() for c in np.nditer(board)), 'board must contain only space, #, or digits'
+        self.board = board
+        self.V, self.H = board.shape
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.blocks: list[Block] = [(pos, int(get_char(self.board, pos).strip())) for pos in get_all_pos(self.V, self.H) if str(get_char(self.board, pos).strip()).isdecimal()]
+        self.blocks_to_shapes: dict[Block, set[ShapeOnBoard]] = {b: set() for b in self.blocks}
+        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = {p: set() for p in get_all_pos(self.V, self.H)}
+        self.init_shapes()
+        self.add_all_constraints()
+
+    def init_shapes(self):
+        for block in self.blocks:
+            direction_rays = [get_unblocked_ray(block, direction, self.board) for direction in Direction]
+            num = block[1]
+            for quadruplet in find_quadruplets(num, tuple(len(ray) for ray in direction_rays)):
+                flat_pos_set = set(p for i in range(4) for p in direction_rays[i][:quadruplet[i]])
+                shape = frozenset(flat_pos_set | {block[0]})
+                uid = f'{block[0]}:{len(self.blocks_to_shapes[block])}'
+                shape_on_board = ShapeOnBoard(is_active=self.model.NewBoolVar(f'{uid}:is_active'), shape=shape, uid=uid, number=num)
+                self.blocks_to_shapes[block].add(shape_on_board)
+                for p in shape:
+                    self.pos_to_shapes[p].add(shape_on_board)
+
+    def add_all_constraints(self):
+        for block in self.blocks:  # every block has exactly one shape active
+            self.model.AddExactlyOne(shape.is_active for shape in self.blocks_to_shapes[block])
+        for pos in get_all_pos(self.V, self.H):  # every position has at most one shape active
+            self.model.AddAtMostOne(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:
+            return SingleSolution(assignment={pos: (s.uid, s.number) for pos in get_all_pos(board.V, board.H) for s in board.pos_to_shapes[pos] if solver.Value(s.is_active) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            arr = np.array([[single_res.assignment.get(get_pos(x=c, y=r), '') for c in range(self.H)] for r in range(self.V)])
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(arr),
+                # center_char=lambda r, c: str(single_res.assignment.get(get_pos(x=c, y=r), (None, '#'))[1]),  # display number on every filled position
+                center_char=lambda r, c: str(self.board[r, c]).strip(),  # only display the block number
+                text_on_shaded_cells=False
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/vermicelli/vermicelli.py

@@ -0,0 +1,74 @@
+from collections import defaultdict
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, Direction, get_next_pos, get_opposite_direction, get_pos, in_bounds
+from puzzle_solver.core.utils_ortools import force_connected_component, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, walls: np.array):
+        assert walls.ndim == 2, f'walls must be 2d, got {walls.ndim}'
+        assert all((len(c.item().strip()) <= 2) and all(ch in ['U', 'L', 'D', 'R'] for ch in c.item().strip()) for c in np.nditer(walls)), 'walls must contain only U, L, D, R'
+        self.walls = walls
+        self.V, self.H = walls.shape
+
+        self.model = cp_model.CpModel()
+        self.cell_active: dict[Pos, cp_model.IntVar] = {}
+        self.cell_direction: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in Direction:
+                next_pos = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if (next_pos, opposite_direction) in self.cell_direction:
+                    self.cell_direction[(pos, direction)] = self.cell_direction[(next_pos, opposite_direction)]
+                else:
+                    self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def add_all_constraints(self):
+        # force the already given walls
+        str_to_direction = {'U': Direction.UP, 'L': Direction.LEFT, 'D': Direction.DOWN, 'R': Direction.RIGHT}
+        for pos in get_all_pos(self.V, self.H):
+            for char in get_char(self.walls, pos).strip():
+                self.model.Add(self.cell_direction[(pos, str_to_direction[char])] == 0)
+
+        # all cells have exactly 2 directions
+        for pos in get_all_pos(self.V, self.H):
+            s = sum([self.cell_direction[(pos, direction)] for direction in Direction])
+            self.model.Add(s == 2)
+
+        # cant point to border
+        for pos in get_all_pos(self.V, self.H):
+            for direction in Direction:
+                next_pos = get_next_pos(pos, direction)
+                if not in_bounds(next_pos, self.V, self.H):
+                    self.model.Add(self.cell_direction[(pos, direction)] == 0)
+
+        # force single connected component
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if p1 == p2:  # same position, different direction, is neighbor
+                return True
+            if get_next_pos(p1, d1) == p2 and d2 == get_opposite_direction(d1):
+                return True
+            return False
+        force_connected_component(self.model, self.cell_direction, is_neighbor=is_neighbor)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = defaultdict(str)
+            for (pos, direction), var in board.cell_direction.items():
+                assignment[pos] += direction.name[0] if solver.BooleanValue(var) else ''
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, cell_flags=lambda r, c: self.walls[r, c],
+            special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)].strip()))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=20)

puzzle_solver/puzzles/walls/walls.py

@@ -0,0 +1,52 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, Direction, get_pos, get_ray
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() == ' ') or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.model = cp_model.CpModel()
+        self.horiz_vars: dict[Pos, cp_model.IntVar] = {}
+        self.vert_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.horiz_vars[pos] = self.model.NewBoolVar(f'{pos}:horiz')
+            self.vert_vars[pos] = self.model.NewBoolVar(f'{pos}:vert')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if not str(c).isdecimal():
+                self.model.AddExactlyOne([self.horiz_vars[pos], self.vert_vars[pos]])
+                continue
+            self.model.Add(self.horiz_vars[pos] + self.vert_vars[pos] == 0)  # spot with number has to be blank
+            self.range_clue(pos, int(c))
+
+    def range_clue(self, pos: Pos, k: int):
+        vis_vars: list[cp_model.IntVar] = []
+        d_to_var = {Direction.UP: self.vert_vars, Direction.DOWN: self.vert_vars, Direction.LEFT: self.horiz_vars, Direction.RIGHT: self.horiz_vars}
+        for direction in Direction:  # Build visibility chains in four direction
+            ray = get_ray(pos, direction, self.V, self.H)  # cells outward
+            for idx in range(len(ray)):
+                v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                and_constraint(self.model, target=v, cs=[d_to_var[direction][p] for p in ray[:idx+1]])
+                vis_vars.append(v)
+        self.model.Add(sum(vis_vars) == int(k))  # Sum of visible whites = 1 (itself) + sum(chains) == k
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: 'LR'*solver.Value(board.horiz_vars[pos]) + 'UD'*solver.Value(board.vert_vars[pos]) for pos in get_all_pos(board.V, board.H)})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: str(self.board[r, c]).strip(), special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)].strip()))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/yajilin/yajilin.py

@@ -0,0 +1,87 @@
+from collections import defaultdict
+
+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, get_char, Direction, in_bounds, get_next_pos, get_opposite_direction, get_pos, get_neighbors4, get_ray
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.board = board
+        self.V, self.H = board.shape
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[(pos, 'FILLED')] = self.model.NewBoolVar(f'{pos}:FILLED')
+            self.model_vars[(pos, 'NUMBER')] = self.model.NewBoolVar(f'{pos}:NUMBER')
+            for direction in Direction:
+                next_pos = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if (next_pos, opposite_direction) in self.model_vars:
+                    self.model_vars[(pos, direction)] = self.model_vars[(next_pos, opposite_direction)]
+                elif not in_bounds(next_pos, self.V, self.H):
+                    self.model_vars[(pos, direction)] = self.model.NewConstant(0)
+                else:
+                    self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def add_all_constraints(self):
+        pos_in_ray = set()  # keep track of all positions that are hit by rays; if a position has no ray then it cannot be filled
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos).strip()
+            if c:
+                d, num = c[0], int(c[1:])
+                d = {'U': Direction.UP, 'D': Direction.DOWN, 'L': Direction.LEFT, 'R': Direction.RIGHT}[d]
+                ray = get_ray(pos, d, self.V, self.H)
+                pos_in_ray.update(ray)
+                self.model.Add(self.model_vars[(pos, 'NUMBER')] == 1)
+                self.model.Add(lxp.Sum([self.model_vars[(p, 'FILLED')] for p in ray]) == num)
+            else:
+                self.model.Add(self.model_vars[(pos, 'NUMBER')] == 0)
+            lxp_sum = lxp.Sum([self.model_vars[(pos, direction)] for direction in Direction])
+            self.model.Add(lxp_sum == 0).OnlyEnforceIf(self.model_vars[(pos, 'NUMBER')])
+            self.model.Add(lxp_sum == 0).OnlyEnforceIf(self.model_vars[(pos, 'FILLED')])
+            self.model.Add(lxp_sum == 2).OnlyEnforceIf([self.model_vars[(pos, 'NUMBER')].Not(), self.model_vars[(pos, 'FILLED')].Not()])
+            for n in get_neighbors4(pos, self.V, self.H):  # filled cannot be adjacent to another filled cell
+                self.model.Add(self.model_vars[(n, 'FILLED')] == 0).OnlyEnforceIf(self.model_vars[(pos, 'FILLED')])
+                self.model.Add(self.model_vars[(pos, 'FILLED')] == 0).OnlyEnforceIf(self.model_vars[(n, 'FILLED')])
+
+        for pos in get_all_pos(self.V, self.H):  # if a position has not been hit by any ray then it cannot be filled
+            if pos not in pos_in_ray:
+                self.model.Add(self.model_vars[(pos, 'FILLED')] == 0)
+
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            return (p1 == p2) or (get_next_pos(p1, d1) == p2 and d2 == get_opposite_direction(d1))
+        direction_vars = {k: v for k, v in self.model_vars.items() if isinstance(k[1], Direction)}
+        force_connected_component(self.model, direction_vars, is_neighbor=is_neighbor)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = defaultdict(str)
+            for (pos, aux), var in board.model_vars.items():
+                if solver.BooleanValue(var):
+                    assignment[pos] += aux.name[0] if isinstance(aux, Direction) else aux[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            answer = np.array([[single_res.assignment.get(get_pos(c, r), '') for c in range(self.H)] for r in range(self.V)])
+            d = {'U': '↑', 'D': '↓', 'L': '←', 'R': '→'}
+            num_arrow = np.array([[self.board[r, c][1:].strip() + d.get(self.board[r, c][0], '') for c in range(self.H)] for r in range(self.V)])
+            print(combined_function(self.V, self.H,
+                show_border_only=True,
+                is_shaded=lambda r, c: answer[r, c] == 'F',
+                special_content=lambda r, c: answer[r, c] if answer[r, c] not in ['N', 'F'] else None,
+                center_char=lambda r, c: num_arrow[r, c],
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py

@@ -0,0 +1,172 @@
+# THIS PARSER IS STILL VERY BUGGY
+
+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__":
+    # THIS PARSER IS STILL VERY BUGGY
+    #  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" / "OTozLDY2MSw3MjE=.png"
+    # 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)