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

puzzle_solver/puzzles/kakuro/kakuro.py

@@ -0,0 +1,81 @@
+from typing import Iterator
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, get_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array, row_sums: list[list[int]], col_sums: list[list[int]], N: int = 9):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() in ['#', ' ', '1', '2', '3', '4', '5', '6', '7', '8', '9']) for c in np.nditer(board)), 'board must contain only #, space, or digits'
+        assert len(row_sums) == board.shape[0] and all(isinstance(i, list) and all(isinstance(j, int) or j == '#' for j in i) for i in row_sums), 'row_sums must be a list of lists of integers or #'
+        assert len(col_sums) == board.shape[1] and all(isinstance(i, list) and all(isinstance(j, int) or j == '#' for j in i) for i in col_sums), 'col_sums must be a list of lists of integers or #'
+        self.board = board
+        self.row_sums = row_sums
+        self.col_sums = col_sums
+        self.V, self.H = board.shape
+        self.N = N
+        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):
+            if get_char(self.board, pos) == '#':
+                continue
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+
+    def get_consecutives(self, pos: Pos, direction: Direction) -> Iterator[list[Pos]]:
+        consecutive = []
+        while in_bounds(pos, self.V, self.H):
+            if get_char(self.board, pos) == '#':
+                if len(consecutive) > 0:
+                    yield consecutive
+                    consecutive = []
+            else:
+                consecutive.append(pos)
+            pos = get_next_pos(pos, direction)
+        if len(consecutive) > 0:
+            yield consecutive
+
+    def add_all_constraints(self):
+        for row in range(self.V):
+            row_consecutives = self.get_consecutives(get_pos(x=0, y=row), Direction.RIGHT)
+            for i, consecutive in enumerate(row_consecutives):
+                # print('row', row, 'i', i, 'consecutive', consecutive)
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.row_sums[row][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == clue)
+            assert len(self.row_sums[row]) == i + 1, f'row_sums[{row}] has {len(self.row_sums[row])} clues, but {i + 1} consecutive cells'
+        for col in range(self.H):
+            col_consecutives = self.get_consecutives(get_pos(x=col, y=0), Direction.DOWN)
+            for i, consecutive in enumerate(col_consecutives):
+                # print('col', col, 'i', i, 'consecutive', consecutive)
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.col_sums[col][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == clue)
+            assert len(self.col_sums[col]) == i + 1, f'col_sums[{col}] has {len(self.col_sums[col])} clues, but {i + 1} consecutive cells'
+
+    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")
+            print(combined_function(self.V, self.H,
+                is_shaded=lambda r, c: self.board[r, c] == '#',
+                center_char=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)]),
+                text_on_shaded_cells=False
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/kakuro/krypto_kakuro.py

@@ -0,0 +1,95 @@
+from typing import Iterator
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, get_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array, row_sums: list[list[str]], col_sums: list[list[str]], characters: list[str], min_value: int = 0, max_value: int = 9):
+        legal_chars = characters + ['#'] + [str(i) for i in range(min_value, max_value + 1)]
+        assert (len(row_sums), len(col_sums)) == board.shape, f'row_sums and col_sums must be the same shape as board, got {len(row_sums)}x{len(col_sums)} and {board.shape}'
+        assert all(all(cc in legal_chars for cc in c.item().strip()) for c in np.nditer(board)), 'board must contain only #, space, or characters'
+        assert all(all(all(cc in legal_chars for cc in c) for c in s) for s in row_sums), 'row_sums must be a list of lists of strings containing only # or characters'
+        assert all(all(all(cc in legal_chars for cc in c) for c in s) for s in col_sums), 'col_sums must be a list of lists of strings containing only # or characters'
+        self.board = board
+        self.row_sums, self.col_sums = row_sums, col_sums
+        self.characters = characters
+        self.min_value, self.max_value = min_value, max_value
+        assert (self.max_value - self.min_value + 1) == len(self.characters), f'max_value - min_value + 1 must be equal to the number of characters, got {self.max_value - self.min_value + 1} != {len(self.characters)}'
+        self.V, self.H = board.shape
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.dictionary: dict[str, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for char in self.characters:
+            self.dictionary[char] = self.model.NewIntVar(self.min_value, self.max_value, f'{char}')
+        for pos in get_all_pos(self.V, self.H):
+            if get_char(self.board, pos) == '#':
+                continue
+            self.model_vars[pos] = self.model.NewIntVar(self.min_value, self.max_value, f'{pos}')
+
+    def get_consecutives(self, pos: Pos, direction: Direction) -> Iterator[list[Pos]]:
+        consecutive = []
+        while in_bounds(pos, self.V, self.H):
+            if get_char(self.board, pos) == '#':
+                if len(consecutive) > 0:
+                    yield consecutive
+                    consecutive = []
+            else:
+                consecutive.append(pos)
+            pos = get_next_pos(pos, direction)
+        if len(consecutive) > 0:
+            yield consecutive
+
+    def clue_to_var(self, clue: str) -> cp_model.IntVar:
+        res = []
+        for i,c in enumerate(clue[::-1]):
+            res.append(self.dictionary[c] * 10**i)
+        return lxp.sum(res)
+
+    def add_all_constraints(self):
+        self.model.AddAllDifferent(list(self.dictionary.values()))  # dictionary must be unique
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos).strip()
+            if c not in ['', '#']:
+                self.model.Add(self.model_vars[pos] == (self.dictionary[c] if c in self.dictionary else int(c)))
+        for row in range(self.V):  # for row clues
+            row_consecutives = self.get_consecutives(get_pos(x=0, y=row), Direction.RIGHT)
+            for i, consecutive in enumerate(row_consecutives):
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.row_sums[row][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == self.clue_to_var(clue))
+            assert len(self.row_sums[row]) == i + 1, f'row_sums[{row}] has {len(self.row_sums[row])} clues, but {i + 1} consecutive cells'
+        for col in range(self.H):  # for column clues
+            col_consecutives = self.get_consecutives(get_pos(x=col, y=0), Direction.DOWN)
+            for i, consecutive in enumerate(col_consecutives):
+                self.model.AddAllDifferent([self.model_vars[p] for p in consecutive])
+                clue = self.col_sums[col][i]
+                if clue != '#':
+                    self.model.Add(lxp.sum([self.model_vars[p] for p in consecutive]) == self.clue_to_var(clue))
+            assert len(self.col_sums[col]) == i + 1, f'col_sums[{col}] has {len(self.col_sums[col])} clues, but {i + 1} consecutive cells'
+
+    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")
+            print(combined_function(self.V, self.H,
+                is_shaded=lambda r, c: self.board[r, c] == '#',
+                center_char=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)]),
+                text_on_shaded_cells=False
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/keen/keen.py

@@ -0,0 +1,76 @@
+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, get_pos, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def add_opcode_constraint(model: cp_model.CpModel, vlist: list[cp_model.IntVar], opcode: str, result: int):
+    assert opcode in ['+', '-', '*', '/'], "Invalid opcode"
+    assert opcode not in ['-', '/'] or 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_gate')
+        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_gate')
+        # 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 clues is None or clues.shape == board.shape, f'clues must be 2d, got {clues.shape}'
+        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.clues = clues
+        self.V, self.H = board.shape
+        self.block_results = {block: (op, result) for block, (op, result) in block_results.items()}
+
+        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(1, max(self.V, self.H), f'{pos}')
+        if self.clues is not None:
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.clues, pos).strip()
+                if int(c) >= 1:
+                    self.model.Add(self.model_vars[pos] == int(c))
+
+    def add_all_constraints(self):
+        for row in range(self.V):  # 1 number per row
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):  # 1 number per column
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_col_pos(col, self.V)])
+        for block, (op, result) in self.block_results.items():  # cage op code
+            block_vars = [self.model_vars[p] for p in get_all_pos(self.V, self.H) if get_char(self.board, p) == block]
+            add_opcode_constraint(self.model, vlist=block_vars, opcode=op, result=result)
+
+    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(board.model_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: single_res.assignment[get_pos(x=c, y=r)]))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=10)

puzzle_solver/puzzles/kropki/kropki.py

@@ -0,0 +1,94 @@
+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, get_pos, Direction, in_bounds, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, or_constraint
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def get_eq_var(model: cp_model.CpModel, a: cp_model.IntVar, b: cp_model.IntVar) -> cp_model.IntVar:
+    eq_var = model.NewBoolVar(f'{a}:{b}:eq')
+    model.Add(a == b).OnlyEnforceIf(eq_var)
+    model.Add(a != b).OnlyEnforceIf(eq_var.Not())
+    return eq_var
+
+
+class Board:
+    def __init__(self, board: np.array, horiz_board: np.array, vert_board: np.array, digits: Optional[list[int]] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((str(c.item()).strip() == '') 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
+        assert horiz_board.shape == (self.V, self.H - 1), f'horiz_board must be {(self.V, self.H - 1)}, got {horiz_board.shape}'
+        assert all((str(c.item()).strip() == '') or str(c.item()).strip() in ['B', 'W'] for c in np.nditer(horiz_board)), 'horiz_board must contain only space or digits'
+        assert vert_board.shape == (self.V - 1, self.H), f'vert_board must be {(self.V - 1, self.H)}, got {vert_board.shape}'
+        assert all((str(c.item()).strip() == '') or str(c.item()).strip() in ['B', 'W'] for c in np.nditer(vert_board)), 'vert_board must contain only space or digits'
+        self.horiz_board = horiz_board
+        self.vert_board = vert_board
+        if digits is None:
+            digits = list(range(1, max(self.V, self.H) + 1))
+        assert len(digits) >= max(self.V, self.H), 'digits must be at least as long as the board'
+        self.digits = digits
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.digits_2_1_ratio: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.digits_consecutive: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        allowed_values = cp_model.Domain.FromValues(self.digits)
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            self.model_vars[pos] = self.model.NewIntVarFromDomain(allowed_values, f'{pos}')
+            for direction in [Direction.RIGHT, Direction.DOWN]:
+                neighbor = get_next_pos(pos, direction)
+                if not in_bounds(neighbor, self.V, self.H):
+                    continue
+                self.digits_2_1_ratio[(pos, neighbor)] = self.model.NewBoolVar(f'{pos}:{neighbor}:2_1')
+                self.digits_consecutive[(pos, neighbor)] = self.model.NewBoolVar(f'{pos}:{neighbor}:consecutive')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos)
+            if not str(c).isdecimal():
+                continue
+            self.model.Add(self.model_vars[pos] == int(c))
+        # all columns and rows are unique
+        for row in range(self.V):
+            self.model.AddAllDifferent([self.model_vars[get_pos(x=c, y=row)] for c in range(self.H)])
+        for col in range(self.H):
+            self.model.AddAllDifferent([self.model_vars[get_pos(x=col, y=r)] for r in range(self.V)])
+        for p in get_all_pos(self.V, self.H):  # force horiz and vert relationships between digits
+            for direction in [Direction.RIGHT, Direction.DOWN]:
+                neighbor = get_next_pos(p, direction)
+                if not in_bounds(neighbor, self.V, self.H):
+                    continue
+                self.setup_aux(p, direction)
+                c = get_char(self.horiz_board if direction == Direction.RIGHT else self.vert_board, p)
+                if c == 'B':  # 2:1 ratio
+                    self.model.Add(self.digits_2_1_ratio[(p, neighbor)] == 1)
+                elif c == 'W':  # consecutive
+                    self.model.Add(self.digits_consecutive[(p, neighbor)] == 1)
+                else:  # neither
+                    self.model.Add(self.digits_2_1_ratio[(p, neighbor)] == 0)
+                    self.model.Add(self.digits_consecutive[(p, neighbor)] == 0)
+
+    def setup_aux(self, pos: Pos, direction: Direction):
+        neighbor = get_next_pos(pos, direction)
+        a_plus_one_b = get_eq_var(self.model, self.model_vars[pos] + 1, self.model_vars[neighbor])
+        b_plus_one_a = get_eq_var(self.model, self.model_vars[neighbor] + 1, self.model_vars[pos])
+        or_constraint(self.model, self.digits_consecutive[(pos, neighbor)], [a_plus_one_b, b_plus_one_a])  # consecutive aux
+        a_twice_b = get_eq_var(self.model, self.model_vars[pos], 2 * self.model_vars[neighbor])
+        b_twice_a = get_eq_var(self.model, self.model_vars[neighbor], 2 * self.model_vars[pos])
+        or_constraint(self.model, self.digits_2_1_ratio[(pos, neighbor)], [a_twice_b, b_twice_a])  # 2:1 ratio aux
+
+    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, center_char=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=1)

puzzle_solver/puzzles/light_up/light_up.py

@@ -0,0 +1,58 @@
+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, in_bounds, get_next_pos, get_neighbors4, Direction, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+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'
+    V, H = board.shape
+    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, V, H) or get_char(board, cur_pos).strip() != '':
+                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 all((c.item().strip() in ['', 'W']) or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or W or numbers'
+        self.board = board
+        self.V, self.H = board.shape
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force N lights touching the number N
+            c = get_char(self.board, pos).strip()
+            if c not in ['', 'W']:
+                self.model.Add(self.model_vars[pos] == 0)
+                self.model.Add(lxp.Sum([self.model_vars[p] for p in get_neighbors4(pos, self.V, self.H)]) == int(c))
+            else:  # not numbered, must be lit
+                orthoginals = laser_out(self.board, pos)
+                self.model.AddAtLeastOne([self.model_vars[p] for p in orthoginals] + [self.model_vars[pos]])
+                for ortho in orthoginals:
+                    self.model.Add(self.model_vars[ortho] == 0).OnlyEnforceIf(self.model_vars[pos])
+
+    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, center_char=lambda r, c: str(self.board[r, c]).strip()))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/linesweeper/linesweeper.py

@@ -0,0 +1,71 @@
+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, get_neighbors8, get_pos, Direction, get_next_pos, get_opposite_direction, 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, 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.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):
+            self.cell_active[pos] = self.model.NewBoolVar(f'{pos}')
+            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)]
+                elif not in_bounds(next_pos, self.V, self.H):
+                    self.cell_direction[(pos, direction)] = self.model.NewConstant(0)
+                else:
+                    self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force state
+            sum_directions = lxp.Sum([self.cell_direction[(pos, direction)] for direction in Direction])
+            self.model.Add(sum_directions == 2).OnlyEnforceIf(self.cell_active[pos])
+            self.model.Add(sum_directions == 0).OnlyEnforceIf(self.cell_active[pos].Not())
+            c = get_char(self.board, pos).strip()  # force clues
+            if c:
+                self.model.Add(self.cell_active[pos] == 0)
+                self.model.Add(lxp.Sum([self.cell_active[n] for n in get_neighbors8(pos, self.V, self.H, include_self=False)]) == int(c))
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if p1 == p2 and d1 != d2:  # 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 in get_all_pos(self.V, self.H):
+                for direction in Direction:
+                    if (pos, direction) in board.cell_direction and solver.Value(board.cell_direction[(pos, direction)]) == 1:
+                        assignment[pos] += direction.name[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, show_grid=False,
+                special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)],
+                center_char=lambda r, c: str(self.board[r, c]).strip())
+            )
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/link_a_pix/link_a_pix.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+from collections import defaultdict
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_pos, shapes_between, Shape
+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
+
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    uid: int
+    is_active: cp_model.IntVar
+    size: int
+    shape: Shape
+
+
+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.pos_to_char: dict[Pos, str] = {p: get_char(board, p).strip() for p in get_all_pos(self.V, self.H) if get_char(board, p).strip() != ''}
+
+        self.model = cp_model.CpModel()
+        self.all_shapes: list[ShapeOnBoard] = []
+        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = defaultdict(set)
+        self.create_shapes()
+        self.add_all_constraints()
+
+    def create_shapes(self):
+        num_to_pos: dict[tuple[str, int], list[Pos]] = defaultdict(list)
+        single_to_pos: list[tuple[str, Pos]] = []
+        for p, s in self.pos_to_char.items():  # all cells that arent empty
+            if s.isdecimal():  # black cell
+                color = 'black'
+                N = int(s)
+            else:  # colored cell
+                color = s.split('_')[0]
+                N = int(s.split('_')[1])
+            if N == 1:  # cell with a 1
+                single_to_pos.append((color, p))
+            else:  # cell with a number >= 2
+                num_to_pos[(color, N)].append(p)
+
+        for color, p in single_to_pos:  # all cells with a 1
+            s = ShapeOnBoard(uid=len(self.all_shapes), is_active=self.model.NewBoolVar(f'{color}_{p}'), size=1, shape=frozenset([p]))
+            self.all_shapes.append(s)
+            self.pos_to_shapes[p].add(s)
+
+        for (_, N), plist in num_to_pos.items():  # all cells with a number >= 2
+            assert len(plist) % 2 == 0, f'{s} has {len(plist)} positions, must be even'
+            for i, pi in enumerate(plist):
+                for _j, pj in enumerate(plist[i+1:]):  # don't double count
+                    self.populate_pair(pi, pj, N)
+
+    def populate_pair(self, pos1: Pos, pos2: Pos, N: int):
+        for shape in shapes_between(pos1, pos2, N):
+            number_cells_hit = {p for p in shape if p in self.pos_to_char}
+            assert number_cells_hit.issuperset({pos1, pos2}), f'Not possible! shape {shape} should always hit pos1 and pos2; this error means there\'s a bug in shapes_between'
+            if number_cells_hit != {pos1, pos2}:  # shape hit some numbered cells other than pos1 and pos2
+                continue
+            s = ShapeOnBoard(uid=len(self.all_shapes), is_active=self.model.NewBoolVar(f'{shape}'), size=N, shape=shape)
+            self.all_shapes.append(s)
+            self.pos_to_shapes[pos1].add(s)
+            self.pos_to_shapes[pos2].add(s)
+
+    def add_all_constraints(self):
+        for pos in self.pos_to_char.keys():  # every numbered cell must have exactly one shape active touch it
+            shapes_on_pos = [s.is_active for s in self.pos_to_shapes[pos]]
+            assert len(shapes_on_pos) >= 1, f'pos {pos} has no shapes on it. No solution possible!!!'
+            self.model.AddExactlyOne(shapes_on_pos)
+        for s1 in self.all_shapes:  # active shapes can't collide
+            for s2 in self.all_shapes:
+                if s1.uid != s2.uid and s1.shape.intersection(s2.shape):
+                    self.model.Add(s1.is_active + s2.is_active <= 1)
+
+    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.size) for s in self.all_shapes for pos in s.shape if solver.Value(s.is_active) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            arr_dict = {k: v[0] for k, v in single_res.assignment.items()}
+            arr_size = {k: v[1] for k, v in single_res.assignment.items()}
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(np.array([[arr_dict.get(get_pos(x=c, y=r), "") for c in range(self.H)] for r in range(self.V)])),
+                center_char=lambda r, c: f'{arr_size.get(get_pos(x=c, y=r), "")}'
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=99)