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

puzzle_solver/puzzles/keen/keen.py

@@ -0,0 +1,99 @@
+from typing import Optional
+
+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_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def add_opcode_constraint(model: cp_model.CpModel, vlist: list[cp_model.IntVar], opcode: str, result: int):
+    assert opcode in ['+', '-', '*', '/'], "Invalid opcode"
+    if opcode in ['-', '/']:
+        assert len(vlist) == 2, f"Opcode '{opcode}' requires exactly 2 variables"
+
+    if opcode == '+':
+        model.Add(sum(vlist) == result)
+    elif opcode == '*':
+        model.AddMultiplicationEquality(result, vlist)
+
+    elif opcode == '-':
+        # either vlist[0] - vlist[1] == result OR vlist[1] - vlist[0] == result
+        b = model.NewBoolVar('sub_dir')
+        model.Add(vlist[0] - vlist[1] == result).OnlyEnforceIf(b)
+        model.Add(vlist[1] - vlist[0] == result).OnlyEnforceIf(b.Not())
+    elif opcode == '/':
+        # either v0 / v1 == result or v1 / v0 == result
+        b = model.NewBoolVar('div_dir')
+        # Ensure no division by zero
+        model.Add(vlist[0] != 0)
+        model.Add(vlist[1] != 0)
+        # case 1: v0 / v1 == result → v0 == v1 * result
+        model.Add(vlist[0] == vlist[1] * result).OnlyEnforceIf(b)
+        # case 2: v1 / v0 == result → v1 == v0 * result
+        model.Add(vlist[1] == vlist[0] * result).OnlyEnforceIf(b.Not())
+
+class Board:
+    def __init__(self, board: np.ndarray, block_results: dict[str, tuple[str, int]], clues: Optional[np.ndarray] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] == board.shape[1], 'board must be square'
+        assert clues is None or clues.ndim == 2 and clues.shape[0] == board.shape[0] and clues.shape[1] == board.shape[1], f'clues must be 2d, got {clues.ndim}'
+        assert all((c.item().startswith('d') and c.item()[1:].isdecimal()) for c in np.nditer(board)), "board must contain 'd' prefixed digits"
+        block_names = set(c.item() for c in np.nditer(board))
+        assert set(block_results.keys()).issubset(block_names), f'block results must contain all block names, {block_names - set(block_results.keys())}'
+        self.board = board
+        self.N = board.shape[0]
+        self.block_results = {block: (op, result) for block, (op, result) in block_results.items()}
+        self.clues = clues
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def get_block_pos(self, block: str):
+        return [p for p in get_all_pos(self.N) if get_char(self.board, p) == block]
+
+    def create_vars(self):
+        for pos in get_all_pos(self.N):
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+        if self.clues is not None:
+            for pos in get_all_pos(self.N):
+                c = get_char(self.clues, pos)
+                if int(c) >= 1:
+                    self.model.Add(self.model_vars[pos] == int(c))
+
+    def add_all_constraints(self):
+        self.unique_digits()
+        self.constrain_block_results()
+
+    def unique_digits(self):
+        # Each row contains only one occurrence of each digit
+        for row in range(self.N):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.N)]
+            self.model.AddAllDifferent(row_vars)
+        # Each column contains only one occurrence of each digit
+        for col in range(self.N):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.N)]
+            self.model.AddAllDifferent(col_vars)
+    
+    def constrain_block_results(self):
+        # The digits in each block can be combined to form the number stated in the clue, using the arithmetic operation given in the clue. That is: 
+        for block, (op, result) in self.block_results.items():
+            block_vars = [self.model_vars[p] for p in self.get_block_pos(block)]
+            add_opcode_constraint(self.model, block_vars, op, result)
+
+    def solve_and_print(self):
+        def board_to_solution(board: "Board", solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for p in get_all_pos(board.N):
+                assignment[p] = solver.Value(board.model_vars[p])
+            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 = single_res.assignment[pos]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback, max_solutions=10)

puzzle_solver/puzzles/light_up/light_up.py

@@ -0,0 +1,95 @@
+from enum import Enum
+
+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, set_char, in_bounds, get_next_pos, get_neighbors4, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class State(Enum):
+    BLACK = ('BLACK', 'B')
+    SHINE = ('SHINE', 'S')
+    LIGHT = ('LIGHT', 'L')
+
+
+def laser_out(board: np.array, init_pos: Pos) -> list[Pos]:
+    'laser out in all 4 directions until we hit a wall or out of bounds'
+    N = board.shape[0]
+    result = []
+    for direction in Direction:
+        cur_pos = init_pos
+        while True:
+            cur_pos = get_next_pos(cur_pos, direction)
+            if not in_bounds(cur_pos, N) or get_char(board, cur_pos) != '*':
+                break
+            result.append(cur_pos)
+    return result
+
+
+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 in ['*', 'W']) or str(c).isdecimal() for c in np.nditer(board)), 'board must contain only * or W or numbers'
+        self.board = board
+        self.N = board.shape[0]
+        self.star_positions: set[Pos] = {pos for pos in get_all_pos(self.N) if get_char(self.board, pos) == '*'}
+        self.number_position: set[Pos] = {pos for pos in get_all_pos(self.N) if str(get_char(self.board, pos)).isdecimal()}
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, State], cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in self.star_positions:
+            var_list = []
+            for state in State:
+                v = self.model.NewBoolVar(f'{pos}:{state.value[0]}')
+                self.model_vars[(pos, state)] = v
+                var_list.append(v)
+            self.model.AddExactlyOne(var_list)
+
+    def add_all_constraints(self):
+        # goal: no black squares
+        for pos in self.star_positions:
+            self.model.Add(self.model_vars[(pos, State.BLACK)] == 0)
+        # number of lights touching a decimal is = decimal
+        for pos in self.number_position:
+            ground = int(get_char(self.board, pos))
+            neighbour_list = get_neighbors4(pos, self.N, self.N)
+            neighbour_list = [p for p in neighbour_list if p in self.star_positions]
+            neighbour_light_count = lxp.Sum([self.model_vars[(p, State.LIGHT)] for p in neighbour_list])
+            self.model.Add(neighbour_light_count == ground)
+        # if a square is a light then everything it touches shines
+        for pos in self.star_positions:
+            orthoginals = laser_out(self.board, pos)
+            for ortho in orthoginals:
+                self.model.Add(self.model_vars[(ortho, State.SHINE)] == 1).OnlyEnforceIf([self.model_vars[(pos, State.LIGHT)]])
+        # a square is black if all of it's laser_out is not light AND itself isnot a light
+        for pos in self.star_positions:
+            orthoginals = laser_out(self.board, pos)
+            i_am_not_light = [self.model_vars[(pos, State.LIGHT)].Not()]
+            no_light_in_laser = [self.model_vars[(p, State.LIGHT)].Not() for p in orthoginals]
+            self.model.Add(self.model_vars[(pos, State.BLACK)] == 1).OnlyEnforceIf(i_am_not_light + no_light_in_laser)
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for (pos, state), var in board.model_vars.items():
+                if solver.BooleanValue(var):
+                    assignment[pos] = state.value[1]
+            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)
+                if c == '*':
+                    c = single_res.assignment[pos]
+                    c = 'L' if c == 'L' else ' '
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/magnets/magnets.py

@@ -0,0 +1,117 @@
+from enum import Enum
+
+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, set_char, in_bounds, get_next_pos, Direction, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class State(Enum):
+    BLANK = ('BLANK', ' ')
+    POSITIVE = ('POSITIVE', '+')
+    NEGATIVE = ('NEGATIVE', '-')
+
+
+class Board:
+    def __init__(self, board: np.array, sides: dict[str, np.array]):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert len(sides) == 4, '4 sides must be provided'
+        assert all(s.ndim == 1 for s in sides.values()), 'all sides must be 1d'
+        assert set(sides.keys()) == set(['pos_v', 'neg_v', 'pos_h', 'neg_h'])
+        assert sides['pos_h'].shape[0] == board.shape[0], 'pos_h dim must equal vertical board size'
+        assert sides['neg_h'].shape[0] == board.shape[0], 'neg_h dim must equal vertical board size'
+        assert sides['pos_v'].shape[0] == board.shape[1], 'pos_v dim must equal horizontal board size'
+        assert sides['neg_v'].shape[0] == board.shape[1], 'neg_v dim must equal horizontal board size'
+        self.board = board
+        self.sides = sides
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.model = cp_model.CpModel()
+        self.pairs: set[tuple[Pos, Pos]] = set()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        # init vars
+        for pos in get_all_pos(V=self.V, H=self.H):
+            var_list = []
+            for state in State:
+                v = self.model.NewBoolVar(f'{pos}:{state.value[0]}')
+                self.model_vars[(pos, state)] = v
+                var_list.append(v)
+            self.model.AddExactlyOne(var_list)
+        # init pairs. traverse from top left and V indicates vertical domino (2x1) while H is horizontal (1x2)
+        seen_pos = set()
+        for pos in get_all_pos(V=self.V, H=self.H):
+            if pos in seen_pos:
+                continue
+            seen_pos.add(pos)
+            c = get_char(self.board, pos)
+            direction = {'V': Direction.DOWN, 'H': Direction.RIGHT}[c]
+            other_pos = get_next_pos(pos, direction)
+            seen_pos.add(other_pos)
+            self.pairs.add((pos, other_pos))
+        assert len(self.pairs)*2 == self.V*self.H
+
+    def add_all_constraints(self):
+        # pairs must be matching
+        for pair in self.pairs:
+            a, b = pair
+            self.model.add(self.model_vars[(a, State.BLANK)] == self.model_vars[(b, State.BLANK)])
+            self.model.add(self.model_vars[(a, State.POSITIVE)] == self.model_vars[(b, State.NEGATIVE)])
+            self.model.add(self.model_vars[(a, State.NEGATIVE)] == self.model_vars[(b, State.POSITIVE)])
+        # no orthoginal matching poles
+        for pos in get_all_pos(V=self.V, H=self.H):
+            right_pos = get_next_pos(pos, Direction.RIGHT)
+            down_pos = get_next_pos(pos, Direction.DOWN)
+            if in_bounds(right_pos, H=self.H, V=self.V):
+                self.model.add(self.model_vars[(pos, State.POSITIVE)] == 0).OnlyEnforceIf(self.model_vars[(right_pos, State.POSITIVE)])
+                self.model.add(self.model_vars[(right_pos, State.POSITIVE)] == 0).OnlyEnforceIf(self.model_vars[(pos, State.POSITIVE)])
+                self.model.add(self.model_vars[(pos, State.NEGATIVE)] == 0).OnlyEnforceIf(self.model_vars[(right_pos, State.NEGATIVE)])
+                self.model.add(self.model_vars[(right_pos, State.NEGATIVE)] == 0).OnlyEnforceIf(self.model_vars[(pos, State.NEGATIVE)])
+            if in_bounds(down_pos, H=self.H, V=self.V):
+                self.model.add(self.model_vars[(pos, State.POSITIVE)] == 0).OnlyEnforceIf(self.model_vars[(down_pos, State.POSITIVE)])
+                self.model.add(self.model_vars[(down_pos, State.POSITIVE)] == 0).OnlyEnforceIf(self.model_vars[(pos, State.POSITIVE)])
+                self.model.add(self.model_vars[(pos, State.NEGATIVE)] == 0).OnlyEnforceIf(self.model_vars[(down_pos, State.NEGATIVE)])
+                self.model.add(self.model_vars[(down_pos, State.NEGATIVE)] == 0).OnlyEnforceIf(self.model_vars[(pos, State.NEGATIVE)])
+
+        # sides counts must equal actual count
+        for row_i in range(self.V):
+            sum_pos = lxp.sum([self.model_vars[(pos, State.POSITIVE)] for pos in get_row_pos(row_i, self.H)])
+            sum_neg = lxp.sum([self.model_vars[(pos, State.NEGATIVE)] for pos in get_row_pos(row_i, self.H)])
+            ground_pos = self.sides['pos_h'][row_i]
+            ground_neg = self.sides['neg_h'][row_i]
+            if ground_pos != -1:
+                self.model.Add(sum_pos == ground_pos)
+            if ground_neg != -1:
+                self.model.Add(sum_neg == ground_neg)
+        for col_i in range(self.H):
+            sum_pos = lxp.sum([self.model_vars[(pos, State.POSITIVE)] for pos in get_col_pos(col_i, self.V)])
+            sum_neg = lxp.sum([self.model_vars[(pos, State.NEGATIVE)] for pos in get_col_pos(col_i, self.V)])
+            ground_pos = self.sides['pos_v'][col_i]
+            ground_neg = self.sides['neg_v'][col_i]
+            if ground_pos != -1:
+                self.model.Add(sum_pos == ground_pos)
+            if ground_neg != -1:
+                self.model.Add(sum_neg == ground_neg)
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for (pos, state), var in board.model_vars.items():
+                if solver.BooleanValue(var):
+                    assignment[pos] = state.value[1]
+            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(V=self.V, H=self.H):
+                c = get_char(self.board, pos)
+                c = single_res.assignment[pos]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/map/map.py

@@ -0,0 +1,56 @@
+import json
+from dataclasses import dataclass
+
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils_ortools import generic_solve_all
+
+
+@dataclass(frozen=True)
+class SingleSolution:
+    assignment: dict[int, int]
+
+    def get_hashable_solution(self) -> str:
+        return json.dumps(self.assignment, sort_keys=True)
+
+
+class Board:
+    def __init__(self, regions: dict[int, set[int]], fixed_colors: dict[int, str]):
+        self.regions = regions
+        self.fixed_colors = fixed_colors
+        self.N = len(regions)
+        assert max(max(region) for region in regions.values() if region) == self.N - 1, 'region indices must be 0..N-1'
+        assert set(fixed_colors.keys()).issubset(set(range(self.N))), 'fixed colors must be a subset of region indices'
+        assert all(color in ['Y', 'R', 'G', 'B'] for color in fixed_colors.values()), 'fixed colors must be Y, R, G, or B'
+        self.color_to_int = {c: i for i, c in enumerate(set(fixed_colors.values()))}
+        self.int_to_color = {i: c for c, i in self.color_to_int.items()}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[int, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for region_idx in self.regions.keys():
+            self.model_vars[region_idx] = self.model.NewIntVar(0, 3, f'{region_idx}')
+
+    def add_all_constraints(self):
+        # fix given colors
+        for region_idx, color in self.fixed_colors.items():
+            self.model.Add(self.model_vars[region_idx] == self.color_to_int[color])
+        # neighboring regions must have different colors
+        for region_idx, region_connections in self.regions.items():
+            for other_region_idx in region_connections:  # neighboring regions must have different colors
+                self.model.Add(self.model_vars[region_idx] != self.model_vars[other_region_idx])
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[int, int] = {}
+            for region_idx, var in board.model_vars.items():
+                assignment[region_idx] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print({k: self.int_to_color[v] for k, v in single_res.assignment.items()})
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/minesweeper/minesweeper.py

@@ -0,0 +1,110 @@
+import time
+from typing import Union
+
+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, set_char, get_neighbors8
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, board: np.array, mine_count: int):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(isinstance(i.item(), str) and (str(i.item()) in [' ', 'F', 'S', 'M', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']) for i in np.nditer(board)), 'board must be either F, S, M, 0-9 or space'
+        self.board = board
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.mine_count = mine_count
+        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):
+        self.model.Add(lxp.Sum(list(self.model_vars.values())) == self.mine_count)
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c in ['F', ' ']:
+                continue
+            if c == 'S':  # safe position but neighbours are unknown
+                self.model.Add(self.model_vars[pos] == 0)
+                continue
+            if c == 'M':  # mine position but neighbours are unknown
+                self.model.Add(self.model_vars[pos] == 1)
+                continue
+            # clue indicates safe position AND neighbours are known
+            c = int(c)
+            self.model.Add(lxp.Sum([self.model_vars[n] for n in get_neighbors8(pos, self.V, self.H, include_self=False)]) == c)
+            self.model.Add(self.model_vars[pos] == 0)
+
+
+def _is_feasible(board: np.array, pos: Pos = None, value: str = None, mine_count: int = None) -> bool:
+    """Returns True if the board is feasible after setting the value at the position"""
+    board = board.copy()
+    if pos is not None and value is not None:
+        set_char(board, pos, str(value))
+    board = Board(board, mine_count=mine_count)
+    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()})
+    return len(generic_solve_all(board, board_to_solution, max_solutions=1, verbose=False)) >= 1
+
+def _is_safe(board: np.array, pos: Pos, mine_count: int) -> Union[bool, None]:
+    """Returns a True if the position is safe, False if it is a mine, otherwise None"""
+    safe_feasible = _is_feasible(board, pos, 'S', mine_count=mine_count)
+    mine_feasible = _is_feasible(board, pos, 'M', mine_count=mine_count)
+    if safe_feasible and mine_feasible:
+        return None
+    if safe_feasible:
+        return True
+    if mine_feasible:
+        return False
+    raise ValueError(f"Position {pos} has both safe and mine infeasible")
+
+def give_next_guess(board: np.array, mine_count: int):
+    tic = time.time()
+    is_feasible = _is_feasible(board, mine_count=mine_count)
+    if not is_feasible:
+        raise ValueError("Board is not feasible")
+    V = board.shape[0]
+    H = board.shape[1]
+    check_positions = set()  # any position that is unknown and has a neighbour with a clue or flag
+    flag_positions = set()
+    for pos in get_all_pos(V, H):
+        neighbours8 = get_neighbors8(pos, V, H, include_self=False)
+        if get_char(board, pos) not in [' ', 'F']:
+            continue
+        if get_char(board, pos) == 'F' or any(get_char(board, n) != ' ' for n in neighbours8):
+            check_positions.add(pos)
+        if get_char(board, pos) == 'F':
+            flag_positions.add(pos)
+    pos_dict = {pos: _is_safe(board, pos, mine_count) for pos in check_positions}
+    safe_positions = {pos for pos, is_safe in pos_dict.items() if is_safe is True}
+    mine_positions = {pos for pos, is_safe in pos_dict.items() if is_safe is False}
+    new_garuneed_mine_positions = mine_positions - flag_positions
+    wrong_flag_positions = flag_positions - mine_positions
+    if len(safe_positions) > 0:
+        print(f"Found {len(safe_positions)} new guaranteed safe positions")
+        print(safe_positions)
+        print('-'*10)
+    if len(mine_positions) == 0:
+        print("No guaranteed mine positions")
+        print('-'*10)
+    if len(new_garuneed_mine_positions) > 0:
+        print(f"Found {len(new_garuneed_mine_positions)} new guaranteed mine positions")
+        print(new_garuneed_mine_positions)
+        print('-'*10)
+    if len(wrong_flag_positions) > 0:
+        print(f"WARNING | "*4 + "WARNING")
+        print(f"Found {len(wrong_flag_positions)} wrong flag positions")
+        print(wrong_flag_positions)
+        print('-'*10)
+    toc = time.time()
+    print(f"Time taken: {toc - tic:.2f} seconds")
+    return safe_positions, new_garuneed_mine_positions, wrong_flag_positions

puzzle_solver/puzzles/mosaic/mosaic.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 * 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):
+        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)

puzzle_solver/puzzles/nonograms/nonograms.py

@@ -0,0 +1,126 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, top: list[list[int]], side: list[list[int]]):
+        assert all(isinstance(i, int) for l in top for i in l), 'top must be a list of lists of integers'
+        assert all(isinstance(i, int) for l in side for i in l), 'side must be a list of lists of integers'
+        self.top = top
+        self.side = side
+        self.V = len(side)
+        self.H = len(top)
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.extra_vars = {}
+
+        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 i in range(self.V):
+            ground_sequence = self.side[i]
+            if ground_sequence == -1:
+                continue
+            current_sequence = [self.model_vars[pos] for pos in get_row_pos(i, self.H)]
+            self.constrain_nonogram_sequence(ground_sequence, current_sequence, f'ngm_side_{i}')
+        for i in range(self.H):
+            ground_sequence = self.top[i]
+            if ground_sequence == -1:
+                continue
+            current_sequence = [self.model_vars[pos] for pos in get_col_pos(i, self.V)]
+            self.constrain_nonogram_sequence(ground_sequence, current_sequence, f'ngm_top_{i}')
+
+    def constrain_nonogram_sequence(self, clues: list[int], current_sequence: list[cp_model.IntVar], ns: str):
+        """
+        Constrain a binary sequence (current_sequence) to match the nonogram clues in clues.
+
+        clues: e.g., [3,1] means: a run of 3 ones, >=1 zero, then a run of 1 one.
+        current_sequence: list of IntVar in {0,1}.
+        extra_vars: dict for storing helper vars safely across multiple calls.
+
+        steps:
+        - Create start position s_i for each run i.
+        - Enforce order and >=1 separation between runs.
+        - Link each cell j to exactly one run interval (or none) via coverage booleans.
+        - Force sum of ones to equal sum(clues).
+        """
+        L = len(current_sequence)
+
+        # not needed but useful for debugging: any clue longer than the line ⇒ unsat.
+        if sum(clues) + len(clues) - 1 > L:
+            print(f"Infeasible: clue {clues} longer than line length {L} for {ns}")
+            self.model.Add(0 == 1)
+            return
+
+        # Start variables for each run. This is the most critical variable for the problem.
+        starts = []
+        self.extra_vars[f"{ns}_starts"] = starts
+        for i, c in enumerate(clues):
+            s = self.model.NewIntVar(0, L, f"{ns}_s[{i}]")
+            starts.append(s)
+        # Enforce order and >=1 blank between consecutive runs.
+        for i in range(len(clues) - 1):
+            self.model.Add(starts[i + 1] >= starts[i] + clues[i] + 1)
+        # enforce that every run is fully contained in the board
+        for i in range(len(clues)):
+            self.model.Add(starts[i] + clues[i] <= L)
+
+        # For each cell j, create booleans cover[i][j] that indicate
+        # whether run i covers cell j:  (starts[i] <= j) AND (j < starts[i] + clues[i])
+        cover = [[None] * L for _ in range(len(clues))]
+        list_b_le = [[None] * L for _ in range(len(clues))]
+        list_b_lt_end = [[None] * L for _ in range(len(clues))]
+        self.extra_vars[f"{ns}_cover"] = cover
+        self.extra_vars[f"{ns}_list_b_le"] = list_b_le
+        self.extra_vars[f"{ns}_list_b_lt_end"] = list_b_lt_end
+
+        for i, c in enumerate(clues):
+            s_i = starts[i]
+            for j in range(L):
+                # b_le: s_i <= j [is start[i] <= j]
+                b_le = self.model.NewBoolVar(f"{ns}_le[{i},{j}]")
+                self.model.Add(s_i <= j).OnlyEnforceIf(b_le)
+                self.model.Add(s_i >= j + 1).OnlyEnforceIf(b_le.Not())
+
+                # b_lt_end: j < s_i + c  ⇔  s_i + c - 1 >= j [is start[i] + clues[i] - 1 (aka end[i]) >= j]
+                b_lt_end = self.model.NewBoolVar(f"{ns}_lt_end[{i},{j}]")
+                end_expr = s_i + c - 1
+                self.model.Add(end_expr >= j).OnlyEnforceIf(b_lt_end)
+                self.model.Add(end_expr <= j - 1).OnlyEnforceIf(b_lt_end.Not())  # (s_i + c - 1) < j
+
+                b_cov = self.model.NewBoolVar(f"{ns}_cov[{i},{j}]")
+                # If covered ⇒ both comparisons true
+                self.model.AddBoolAnd([b_le, b_lt_end]).OnlyEnforceIf(b_cov)
+                # If both comparisons true ⇒ covered
+                self.model.AddBoolOr([b_cov, b_le.Not(), b_lt_end.Not()])
+                cover[i][j] = b_cov
+                list_b_le[i][j] = b_le
+                list_b_lt_end[i][j] = b_lt_end
+
+        # Each cell j is 1 iff it is covered by exactly one run.
+        # (Because runs are separated by >=1 zero, these coverage intervals cannot overlap,
+        for j in range(L):
+            self.model.Add(sum(cover[i][j] for i in range(len(clues))) == current_sequence[j])
+
+    def solve_and_print(self):
+        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 = '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)