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

multi_puzzle_solver-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+puzzle_solver/__init__.py,sha256=wc05n-PjDpBTNOH7VyTQCz-vFm6ixcRHqa-DoVc-5RA,1599
+puzzle_solver/core/utils.py,sha256=3LlBDuie_G0uSlzibpQS2ULmEYSZmpJXh1kawj7rjkg,3396
+puzzle_solver/core/utils_ortools.py,sha256=d1YAmNuSIx6pf8pTlcbbk6oXQex2_lBpnyW_Hgiip48,2890
+puzzle_solver/puzzles/bridges/bridges.py,sha256=W03M4UWucgdcQ9freO21sZQYiXV5wu8lxovT67HS8Jo,5429
+puzzle_solver/puzzles/dominosa/dominosa.py,sha256=fPNL7KuoPQNjQwamEu3fGN6iTY3NglJFG7JOgliZ0o0,7182
+puzzle_solver/puzzles/filling/filling.py,sha256=FP7Qdbk1Jh1Y259IXXb6WmLUSn2n-aE99BDKJm1GRrg,9079
+puzzle_solver/puzzles/guess/guess.py,sha256=w8ZE-0MswR1_e7_MX622OiCJ8fGTloRHblYFvSA4yHc,10812
+puzzle_solver/puzzles/inertia/inertia.py,sha256=xHtQ09sI7hqPcs20foz6YVMuYCsw59TZQxTumAKJuBs,5658
+puzzle_solver/puzzles/inertia/tsp.py,sha256=qMyT_W5vBmmaFUB7Cl9rC5xJNdAdQvIJEx6yxlbG9hw,15240
+puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=DCV8oI4lAp4CbRVrxeki51t_uJCx1hcCxxpdka1J8AA,8382
+puzzle_solver/puzzles/keen/keen.py,sha256=isojmF9KaRtDgvZFFyIJWDkM8atv51x285iZ_JBn8VQ,4979
+puzzle_solver/puzzles/light_up/light_up.py,sha256=9p0pFyCnXmrprLgCC7FLQ515tnw23KtqTiUSPGHdKUU,4477
+puzzle_solver/puzzles/magnets/magnets.py,sha256=9p6atYUfkK5G8exNukzVDkfjXe557w8eif8DGtgdQVk,6414
+puzzle_solver/puzzles/map/map.py,sha256=vVq0Dtw8a3HMUGMZfXlGX58mKePfJqLpOEqusxeq1V4,2522
+puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=ztFOiZF6SV1T8E8d3XqW7wCNNsZyFsJxcibZ7chWr0U,5109
+puzzle_solver/puzzles/mosaic/mosaic.py,sha256=KKHk0fLYQfylujKlT0J9TneTV2cKxKqCvBCD3V_DMR4,2111
+puzzle_solver/puzzles/nonograms/nonograms.py,sha256=rcnsSKptyVklJaWc--xNYqcFmviHTiftKU8pksLoY_4,5996
+puzzle_solver/puzzles/pearl/pearl.py,sha256=vyzZ1T_jcd14RgouDfCHj9AH8gStW7OTtI_nTh2cE_o,8506
+puzzle_solver/puzzles/range/range.py,sha256=IuzWuz3TYL4N-7KejI_f1nZWcIN8IVYkgv6wt-FbY9Y,6933
+puzzle_solver/puzzles/signpost/signpost.py,sha256=K7KCV53Uhn21P-dK7aHuDBt-UQzhPQE_gHX3wcXa0cU,3871
+puzzle_solver/puzzles/singles/singles.py,sha256=FFKrXbHGiMgspZW77n_5hFMnfvvDucNg-naj1Hp2JiI,5598
+puzzle_solver/puzzles/sudoku/sudoku.py,sha256=RWSicDOOpUVGdZq39RIwO9vWIfHwKZXV1FuttmxAcwA,3524
+puzzle_solver/puzzles/tents/tents.py,sha256=StGVhX54Lnj7PT1ep4MpBKaPse5a2Ptwq6pHcItI7jY,6219
+puzzle_solver/puzzles/towers/towers.py,sha256=UFy-uhpQNqAp_3XJl7Tpnt5WkSadX0Mc6a1tz3EaKJo,6319
+puzzle_solver/puzzles/tracks/tracks.py,sha256=vO9bryajvnBXgV-1Gd3naS26wgJd-C3A201w3VzNaRs,9025
+puzzle_solver/puzzles/undead/undead.py,sha256=sXAc_mSQ94qnX0XxGyNL4vbTFyBu13fHEtbSXIdclJk,6570
+puzzle_solver/puzzles/unruly/unruly.py,sha256=tMH9saoga9Y2imqxqryuAz0_TKxnOCrFxSenaIOFySA,3767
+multi_puzzle_solver-0.1.0.dist-info/METADATA,sha256=xQnVqwjGEcXBTqWom5lVcyWpHwHevsCZj7TZL2dlJvg,90635
+multi_puzzle_solver-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.1.0.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.1.0.dist-info/RECORD,,

multi_puzzle_solver-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

multi_puzzle_solver-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+puzzle_solver

puzzle_solver/__init__.py

@@ -0,0 +1,26 @@
+from puzzle_solver.puzzles.bridges import bridges as bridges_solver
+from puzzle_solver.puzzles.dominosa import dominosa as dominosa_solver
+from puzzle_solver.puzzles.filling import filling as filling_solver
+from puzzle_solver.puzzles.guess import guess as guess_solver
+from puzzle_solver.puzzles.inertia import inertia as inertia_solver
+from puzzle_solver.puzzles.keen import keen as keen_solver
+from puzzle_solver.puzzles.light_up import light_up as light_up_solver
+from puzzle_solver.puzzles.magnets import magnets as magnets_solver
+from puzzle_solver.puzzles.map import map as map_solver
+from puzzle_solver.puzzles.minesweeper import minesweeper as minesweeper_solver
+from puzzle_solver.puzzles.mosaic import mosaic as mosaic_solver
+from puzzle_solver.puzzles.nonograms import nonograms as nonograms_solver
+from puzzle_solver.puzzles.pearl import pearl as pearl_solver
+from puzzle_solver.puzzles.range import range as range_solver
+from puzzle_solver.puzzles.signpost import signpost as signpost_solver
+from puzzle_solver.puzzles.singles import singles as singles_solver
+from puzzle_solver.puzzles.sudoku import sudoku as sudoku_solver
+from puzzle_solver.puzzles.tents import tents as tents_solver
+from puzzle_solver.puzzles.towers import towers as towers_solver
+from puzzle_solver.puzzles.tracks import tracks as tracks_solver
+from puzzle_solver.puzzles.undead import undead as undead_solver
+from puzzle_solver.puzzles.unruly import unruly as unruly_solver
+
+from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
+
+__version__ = '0.1.0'

puzzle_solver/core/utils.py

@@ -0,0 +1,127 @@
+from dataclasses import dataclass
+from typing import Tuple, Iterable, Union
+from enum import Enum
+
+import numpy as np
+
+
+class Direction(Enum):
+    UP = 1
+    DOWN = 2
+    LEFT = 3
+    RIGHT = 4
+
+class Direction8(Enum):
+    UP = 1
+    DOWN = 2
+    LEFT = 3
+    RIGHT = 4
+    UP_LEFT = 5
+    UP_RIGHT = 6
+    DOWN_LEFT = 7
+    DOWN_RIGHT = 8
+
+@dataclass(frozen=True)
+class Pos:
+    x: int
+    y: int
+
+
+def get_pos(x: int, y: int) -> Pos:
+    return Pos(x=x, y=y)
+
+
+def get_next_pos(cur_pos: Pos, direction: Union[Direction, Direction8]) -> Pos:
+    delta_x, delta_y = get_deltas(direction)
+    return get_pos(cur_pos.x+delta_x, cur_pos.y+delta_y)
+
+
+def get_neighbors4(pos: Pos, V: int, H: int) -> Iterable[Pos]:
+    for dx, dy in ((1,0),(-1,0),(0,1),(0,-1)):
+        p2 = get_pos(x=pos.x+dx, y=pos.y+dy)
+        if in_bounds(p2, V, H):
+            yield p2
+
+
+def get_neighbors8(pos: Pos, V: int, H: int = None, include_self: bool = False) -> Iterable[Pos]:
+    if H is None:
+        H = V
+    for dx in [-1, 0, 1]:
+        for dy in [-1, 0, 1]:
+            if not include_self and (dx, dy) == (0, 0):
+                continue
+            d_pos = get_pos(x=pos.x+dx, y=pos.y+dy)
+            if in_bounds(d_pos, V, H):
+                yield d_pos
+
+
+def get_row_pos(row_idx: int, H: int) -> Iterable[Pos]:
+    for x in range(H):
+        yield get_pos(x=x, y=row_idx)
+
+
+def get_col_pos(col_idx: int, V: int) -> Iterable[Pos]:
+    for y in range(V):
+        yield get_pos(x=col_idx, y=y)
+
+
+def get_all_pos(V, H=None):
+    if H is None:
+        H = V
+    for y in range(V):
+        for x in range(H):
+            yield get_pos(x=x, y=y)
+
+
+def get_all_pos_to_idx_dict(V, H=None) -> dict[Pos, int]:
+    if H is None:
+        H = V
+    return {get_pos(x=x, y=y): y*H+x for y in range(V) for x in range(H)}
+
+
+def get_char(board: np.array, pos: Pos) -> str:
+    return board[pos.y][pos.x]
+
+
+def set_char(board: np.array, pos: Pos, char: str):
+    board[pos.y][pos.x] = char
+
+
+def in_bounds(pos: Pos, V: int, H: int = None) -> bool:
+    if H is None:
+        H = V
+    return 0 <= pos.y < V and 0 <= pos.x < H
+
+
+def get_opposite_direction(direction: Direction) -> Direction:
+    if direction == Direction.RIGHT:
+        return Direction.LEFT
+    elif direction == Direction.LEFT:
+        return Direction.RIGHT
+    elif direction == Direction.DOWN:
+        return Direction.UP
+    elif direction == Direction.UP:
+        return Direction.DOWN
+    else:
+        raise ValueError(f'invalid direction: {direction}')
+
+
+def get_deltas(direction: Union[Direction, Direction8]) -> Tuple[int, int]:
+    if direction == Direction.RIGHT or direction == Direction8.RIGHT:
+        return +1, 0
+    elif direction == Direction.LEFT or direction == Direction8.LEFT:
+        return -1, 0
+    elif direction == Direction.DOWN or direction == Direction8.DOWN:
+        return 0, +1
+    elif direction == Direction.UP or direction == Direction8.UP:
+        return 0, -1
+    elif direction == Direction8.UP_LEFT:
+        return -1, -1
+    elif direction == Direction8.UP_RIGHT:
+        return +1, -1
+    elif direction == Direction8.DOWN_LEFT:
+        return -1, +1
+    elif direction == Direction8.DOWN_RIGHT:
+        return +1, +1
+    else:
+        raise ValueError(f'invalid direction: {direction}')

puzzle_solver/core/utils_ortools.py

@@ -0,0 +1,78 @@
+import time
+import json
+from dataclasses import dataclass
+from typing import Optional, Callable, Any, Union
+
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import CpSolverSolutionCallback
+
+from puzzle_solver.core.utils import Pos
+
+
+@dataclass(frozen=True)
+class SingleSolution:
+    assignment: dict[Pos, Union[str, int]]
+
+    def get_hashable_solution(self) -> str:
+        result = []
+        for pos, v in self.assignment.items():
+            result.append((pos.x, pos.y, v))
+        return json.dumps(result, sort_keys=True)
+
+
+def and_constraint(model: cp_model.CpModel, target: cp_model.IntVar, cs: list[cp_model.IntVar]):
+    for c in cs:
+        model.Add(target <= c)
+    model.Add(target >= sum(cs) - len(cs) + 1)
+
+
+def or_constraint(model: cp_model.CpModel, target: cp_model.IntVar, cs: list[cp_model.IntVar]):
+    for c in cs:
+        model.Add(target >= c)
+    model.Add(target <= sum(cs))
+
+
+
+class AllSolutionsCollector(CpSolverSolutionCallback):
+    def __init__(self,
+            board: Any,
+            board_to_solution: Callable[Any, SingleSolution],
+            max_solutions: Optional[int] = None,
+            callback: Optional[Callable[SingleSolution, None]] = None
+        ):
+        super().__init__()
+        self.board = board
+        self.board_to_solution = board_to_solution
+        self.max_solutions = max_solutions
+        self.callback = callback
+        self.solutions = []
+        self.unique_solutions = set()
+
+    def on_solution_callback(self):
+        try:
+            result = self.board_to_solution(self.board, self)
+            result_json = result.get_hashable_solution()
+            if result_json in self.unique_solutions:
+                return
+            self.unique_solutions.add(result_json)
+            self.solutions.append(result)
+            if self.callback is not None:
+                self.callback(result)
+            if self.max_solutions is not None and len(self.solutions) >= self.max_solutions:
+                self.StopSearch()
+        except Exception as e:
+            print(e)
+            raise e
+
+def generic_solve_all(board: Any, board_to_solution: Callable[Any, SingleSolution], max_solutions: Optional[int] = None, callback: Optional[Callable[[SingleSolution], None]] = None, verbose: bool = True) -> list[SingleSolution]:
+    solver = cp_model.CpSolver()
+    solver.parameters.enumerate_all_solutions = True
+    collector = AllSolutionsCollector(board, board_to_solution, max_solutions=max_solutions, callback=callback)
+    tic = time.time()
+    solver.solve(board.model, collector)
+    if verbose:
+        print("Solutions found:", len(collector.solutions))
+        print("status:", solver.StatusName())
+        toc = time.time()
+        print(f"Time taken: {toc - tic:.2f} seconds")
+    return collector.solutions

puzzle_solver/puzzles/bridges/bridges.py

@@ -0,0 +1,106 @@
+import json
+from collections import defaultdict
+from dataclasses import dataclass
+
+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, get_next_pos, Direction, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, board: np.array, max_bridges_per_direction: int = 2):
+        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 spaces or digits'
+        self.board = board
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.max_bridges_per_direction = max_bridges_per_direction
+        self.horiz_bridges: set[tuple[Pos, Pos]] = set()
+        self.vert_bridges: set[tuple[Pos, Pos]] = set()
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.is_bridge_active: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+
+        self.init_bridges()
+        self.create_vars()
+        self.add_all_constraints()
+
+    def init_bridges(self):
+        for row_i in range(self.V):
+            cells_in_row = [i for i in get_row_pos(row_i, self.H) if get_char(self.board, i) != ' ']
+            for cell_i in range(len(cells_in_row) - 1):
+                self.horiz_bridges.add((cells_in_row[cell_i], cells_in_row[cell_i + 1]))
+        for col_i in range(self.H):
+            cells_in_col = [i for i in get_col_pos(col_i, self.V) if get_char(self.board, i) != ' ']
+            for cell_i in range(len(cells_in_col) - 1):
+                self.vert_bridges.add((cells_in_col[cell_i], cells_in_col[cell_i + 1]))
+
+    def create_vars(self):
+        for bridge in self.horiz_bridges | self.vert_bridges:
+            self.model_vars[bridge] = self.model.NewIntVar(0, self.max_bridges_per_direction, f'{bridge}')
+            self.is_bridge_active[bridge] = self.model.NewBoolVar(f'{bridge}:is_active')
+            self.model.Add(self.model_vars[bridge] == 0).OnlyEnforceIf(self.is_bridge_active[bridge].Not())
+            self.model.Add(self.model_vars[bridge] > 0).OnlyEnforceIf(self.is_bridge_active[bridge])
+
+    def add_all_constraints(self):
+        self.constrain_sums()
+        self.constrain_no_overlapping_bridges()
+
+    def constrain_sums(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c == ' ':
+                continue
+            all_pos_bridges = [bridge for bridge in self.horiz_bridges if pos in bridge] + [bridge for bridge in self.vert_bridges if pos in bridge]
+            self.model.Add(lxp.sum([self.model_vars[bridge] for bridge in all_pos_bridges]) == int(c))
+
+    def constrain_no_overlapping_bridges(self):
+        for horiz_bridge in self.horiz_bridges:
+            for vert_bridge in self.vert_bridges:
+                if self.is_overlapping(horiz_bridge, vert_bridge):
+                    self.model.AddImplication(self.is_bridge_active[horiz_bridge], self.is_bridge_active[vert_bridge].Not())
+                    self.model.AddImplication(self.is_bridge_active[vert_bridge], self.is_bridge_active[horiz_bridge].Not())
+
+    def is_overlapping(self, horiz_bridge: tuple[Pos, Pos], vert_bridge: tuple[Pos, Pos]) -> bool:
+        assert vert_bridge[0].x == vert_bridge[1].x, 'vertical bridge must have constant x'
+        assert horiz_bridge[0].y == horiz_bridge[1].y, 'horizontal bridge must have constant y'
+        xvert = vert_bridge[0].x
+        yvert_min = min(vert_bridge[0].y, vert_bridge[1].y)
+        yvert_max = max(vert_bridge[0].y, vert_bridge[1].y)
+
+        xhoriz_min = min(horiz_bridge[0].x, horiz_bridge[1].x)
+        xhoriz_max = max(horiz_bridge[0].x, horiz_bridge[1].x)
+        yhoriz = horiz_bridge[0].y
+        
+        # no equals because thats what the puzzle says
+        x_contained = xhoriz_min < xvert < xhoriz_max
+        y_contained = yvert_min < yhoriz < yvert_max
+        return x_contained and y_contained
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment = defaultdict(lambda: [0, 0, 0, 0])
+            for bridge in board.horiz_bridges:
+                v = solver.Value(board.model_vars[bridge])
+                assignment[bridge[0]][0] += v
+                assignment[bridge[1]][1] += v
+            for bridge in board.vert_bridges:
+                v = solver.Value(board.model_vars[bridge])
+                assignment[bridge[0]][2] += v
+                assignment[bridge[1]][3] += v
+            # convert to tuples
+            assignment = {pos: tuple(assignment[pos]) for pos in assignment.keys()}
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), '    ', dtype=object)
+            for pos, (h1, h2, v1, v2) in single_res.assignment.items():
+                c = str(h1) + str(h2) + str(v1) + str(v2)
+                set_char(res, pos, c)
+            for row in res:
+                print('|' + '|'.join(row) + '|\n')
+        return generic_solve_all(self, board_to_solution, callback=callback, max_solutions=20)

puzzle_solver/puzzles/dominosa/dominosa.py

@@ -0,0 +1,136 @@
+from collections import defaultdict
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_pos, get_all_pos, get_char, set_char, get_row_pos, get_col_pos, Direction, get_next_pos, in_bounds
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, or_constraint
+
+
+def get_bool_var(model: cp_model.CpModel, var: cp_model.IntVar, eq_val: int, name: str) -> cp_model.IntVar:
+    res = model.NewBoolVar(name)
+    model.Add(var == eq_val).OnlyEnforceIf(res)
+    model.Add(var != eq_val).OnlyEnforceIf(res.Not())
+    return res
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(0 <= int(i.item()) <= 9 for i in np.nditer(board)), 'board must contain only alphanumeric characters or *'
+        assert np.min(board) == 0, 'expected board to start from 0'
+        self.board = board
+        self.max_val = np.max(board)
+
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+
+        # for every pair, list where to find it on the board and which direction to go
+        # no need for left and up directions as the pairs are unordered (so right and down would have already captured both)
+        self.pair_to_pos_list: dict[tuple[int, int], list[tuple[Pos, Direction]]] = defaultdict(list)
+        for pos in get_all_pos(self.V, self.H):
+            right_pos = get_next_pos(pos, Direction.RIGHT)
+            if in_bounds(right_pos, self.V, self.H):
+                cur_pair = (int(get_char(self.board, pos)), int(get_char(self.board, right_pos)))
+                cur_pair = tuple(sorted(cur_pair))  # pairs are unordered
+                self.pair_to_pos_list[cur_pair].append((pos, Direction.RIGHT))
+            down_pos = get_next_pos(pos, Direction.DOWN)
+            if in_bounds(down_pos, self.V, self.H):
+                cur_pair = (int(get_char(self.board, pos)), int(get_char(self.board, down_pos)))
+                cur_pair = tuple(sorted(cur_pair))  # pairs are unordered
+                self.pair_to_pos_list[cur_pair].append((pos, Direction.DOWN))
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.pair_vars: dict[tuple[int, int], cp_model.BoolVar] = {}
+
+        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, 4, f'{pos}')  # directions
+        # for even pair, boolean variable to indicate if it appears
+        for i in range(self.max_val + 1):
+            for j in range(i, self.max_val + 1):
+                if (i, j) in self.pair_vars:
+                    print('already in pair_vars')
+                    continue
+                self.pair_vars[(i, j)] = self.model.NewBoolVar(f'{i}_{j}')
+
+    def add_all_constraints(self):
+        # all pairs must be used
+        self.all_pairs_used()
+        self.constrain_domino_shape()
+        self.constrain_pair_activation()
+
+
+        # for pos in get_all_pos(self.V, self.H):
+        #     # to the right
+        #     right_pos = get_next_pos(pos, Direction.RIGHT)
+        #     if not in_bounds(right_pos, self.V, self.H):
+        #         continue
+        #     v = self.model.NewBoolVar(f'{pos}:right')
+        #     and_constraint(self.model, v, [self.model_vars[pos] == Direction.RIGHT.value, self.model_vars[right_pos] == Direction.LEFT.value])
+
+    def all_pairs_used(self):
+        for pair in self.pair_vars:
+            self.model.Add(self.pair_vars[pair] == 1)
+
+    def constrain_domino_shape(self):
+        # if X is right then the cell to its right must be left
+        # if X is down then the cell to its down must be up
+        # if X is left then the cell to its left must be right
+        # if X is up then the cell to its up must be down
+        for pos in get_all_pos(self.V, self.H):
+            right_pos = get_next_pos(pos, Direction.RIGHT)
+            if in_bounds(right_pos, self.V, self.H):
+                aux = get_bool_var(self.model, self.model_vars[right_pos], Direction.LEFT.value, f'{pos}:right')
+                self.model.Add(self.model_vars[pos] == Direction.RIGHT.value).OnlyEnforceIf([aux])
+                self.model.Add(self.model_vars[pos] != Direction.RIGHT.value).OnlyEnforceIf([aux.Not()])
+            else:
+                self.model.Add(self.model_vars[pos] != Direction.RIGHT.value)
+            down_pos = get_next_pos(pos, Direction.DOWN)
+            if in_bounds(down_pos, self.V, self.H):
+                aux = get_bool_var(self.model, self.model_vars[down_pos], Direction.UP.value, f'{pos}:down')
+                self.model.Add(self.model_vars[pos] == Direction.DOWN.value).OnlyEnforceIf([aux])
+                self.model.Add(self.model_vars[pos] != Direction.DOWN.value).OnlyEnforceIf([aux.Not()])
+            else:
+                self.model.Add(self.model_vars[pos] != Direction.DOWN.value)
+            left_pos = get_next_pos(pos, Direction.LEFT)
+            if in_bounds(left_pos, self.V, self.H):
+                aux = get_bool_var(self.model, self.model_vars[left_pos], Direction.RIGHT.value, f'{pos}:left')
+                self.model.Add(self.model_vars[pos] == Direction.LEFT.value).OnlyEnforceIf([aux])
+                self.model.Add(self.model_vars[pos] != Direction.LEFT.value).OnlyEnforceIf([aux.Not()])
+            else:
+                self.model.Add(self.model_vars[pos] != Direction.LEFT.value)
+            top_pos = get_next_pos(pos, Direction.UP)
+            if in_bounds(top_pos, self.V, self.H):
+                aux = get_bool_var(self.model, self.model_vars[top_pos], Direction.DOWN.value, f'{pos}:top')
+                self.model.Add(self.model_vars[pos] == Direction.UP.value).OnlyEnforceIf([aux])
+                self.model.Add(self.model_vars[pos] != Direction.UP.value).OnlyEnforceIf([aux.Not()])
+            else:
+                self.model.Add(self.model_vars[pos] != Direction.UP.value)
+
+    def constrain_pair_activation(self):
+        for pair, pos_list in self.pair_to_pos_list.items():
+            aux_list = []
+            for pos, direction in pos_list:
+                aux_list.append(get_bool_var(self.model, self.model_vars[pos], direction.value, f'{pos}:{direction.name}'))
+            or_constraint(self.model, self.pair_vars[pair], aux_list)
+
+    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 = get_char(self.board, pos)
+                c = Direction(single_res.assignment[pos]).name[:1]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)