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

puzzle_solver/puzzles/thermometers/thermometers.py

@@ -0,0 +1,82 @@
+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, Direction, get_opposite_direction, get_next_pos, in_bounds, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+def get_direction(pos: Pos, board: np.array) -> Optional[Direction]:
+    if get_char(board, pos) == 'R':
+        return Direction.RIGHT
+    elif get_char(board, pos) == 'D':
+        return Direction.DOWN
+    elif get_char(board, pos) == 'U':
+        return Direction.UP
+    elif get_char(board, pos) == 'L':
+        return Direction.LEFT
+    return None
+
+def move_backward(pos: Pos, board: np.array) -> Pos:
+    for direction in Direction:
+        opposite_direction = get_opposite_direction(direction)
+        neighbor = get_next_pos(pos, direction)
+        if in_bounds(neighbor, board.shape[0], board.shape[1]) and get_direction(neighbor, board) == opposite_direction:  # the neighbor is pointing to me
+            return neighbor
+    return None
+
+class Board:
+    def __init__(self, board: np.array, top: np.array, side: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        assert top.ndim == 1 and top.shape[0] == self.H, 'top must be a 1d array of length board width'
+        assert side.ndim == 1 and side.shape[0] == self.V, 'side must be a 1d array of length board height'
+        assert all((c in ['R', 'D', 'U', 'X', 'L']) for c in np.nditer(board)), 'board must contain only valid characters: R, D, U, X, L'
+        self.board = board
+        self.top = top
+        self.side = side
+        self.tip: set[Pos] = {pos for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos) == 'X'}
+
+        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):
+        visited: set[Pos] = set()
+        for cur_pos in self.tip:
+            visited.add(cur_pos)
+            while cur_pos is not None:
+                backward_pos = move_backward(cur_pos, self.board)
+                if backward_pos is None:
+                    break
+                self.model.Add(self.model_vars[backward_pos] == 1).OnlyEnforceIf(self.model_vars[cur_pos])
+                cur_pos = backward_pos
+                visited.add(cur_pos)
+        assert len(visited) == self.V * self.H, f'all positions must be visited, got {len(visited)}. missing {set(get_all_pos(self.V, self.H)) - visited}'
+        for row in range(self.V):
+            self.model.Add(sum([self.model_vars[pos] for pos in get_row_pos(row, self.H)]) == self.side[row])
+        for col in range(self.H):
+            self.model.Add(sum([self.model_vars[pos] for pos in get_col_pos(col, self.V)]) == self.top[col])
+
+    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):
+                c = get_char(self.board, pos)
+                c = 'X' if single_res.assignment[pos] == 1 else ' '
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/towers/towers.py

@@ -0,0 +1,89 @@
+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_pos, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution
+
+
+def bool_from_greater_than(model, a, b, name):
+    res = model.NewBoolVar(name)
+    model.add(a > b).OnlyEnforceIf(res)
+    model.add(a <= b).OnlyEnforceIf(res.Not())
+    return res
+
+
+class Board:
+    def __init__(self, board: np.array, top: np.array, bottom: np.array, right: np.array, left: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c == ' ') or str(c).isdecimal() for c in np.nditer(board)), 'board must contain space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        assert top.shape == (self.H,) and bottom.shape == (self.H,) and right.shape == (self.V,) and left.shape == (self.V,), 'top, bottom, right, and left must be 1d arrays of length board width and height'
+        self.top = top
+        self.bottom = bottom
+        self.right = right
+        self.left = left
+        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}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force board clues
+            v = get_char(self.board, pos)
+            if str(v).isdecimal():
+                self.model.Add(self.model_vars[pos] == int(v))
+        for row_i in range(self.V):  # all different for rows
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_row_pos(row_i, self.H)])
+        for col_i in range(self.H):  # all different for cols
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_col_pos(col_i, self.V)])
+        for x in range(self.H):  # top
+            self.tower_constraints(real=self.top[x], pos_list=[get_pos(x=x, y=y) for y in range(self.V)], name=f'top:{x}')
+        for x in range(self.H):  # bottom
+            self.tower_constraints(real=self.bottom[x], pos_list=[get_pos(x=x, y=y) for y in range(self.V-1, -1, -1)], name=f'bottom:{x}')
+        for y in range(self.V):  # left
+            self.tower_constraints(real=self.left[y], pos_list=[get_pos(x=x, y=y) for x in range(self.H)], name=f'left:{y}')
+        for y in range(self.H):  # right
+            self.tower_constraints(real=self.right[y], pos_list=[get_pos(x=x, y=y) for x in range(self.V-1, -1, -1)], name=f'right:{y}')
+
+    def tower_constraints(self, real: int, pos_list: list[Pos], name: str):
+        if real == -1:
+            return
+        can_see_variables = []
+        previous_towers: list[cp_model.IntVar] = []
+        for pos in pos_list:
+            current_tower = self.model_vars[pos]
+            can_see_variables.append(self.can_see_tower(previous_towers, current_tower, f'{name}:{pos}'))
+            previous_towers.append(current_tower)
+        self.model.add(lxp.sum(can_see_variables) == real)
+
+    def can_see_tower(self, blocks: list[cp_model.IntVar], tower: cp_model.IntVar, name: str) -> cp_model.IntVar:
+        """Returns a boolean variable of whether a position BEFORE the blocks can see the "tower" parameter."""
+        if len(blocks) == 0:
+            return True
+        # I can see "tower" if it's larger that all the blocks before it, lits is a list of [(tower > b0), (tower > b1), ..., (tower > bi)]
+        res = self.model.NewBoolVar(name)
+        and_constraint(self.model, target=res, cs=[bool_from_greater_than(self.model, tower, block, f'{name}:lits:{block}') for block in blocks])
+        return res
+
+    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):
+                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 if verbose else None, verbose=verbose)

puzzle_solver/puzzles/tracks/tracks.py

@@ -0,0 +1,88 @@
+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_row_pos, get_col_pos, get_opposite_direction, get_pos
+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, side: np.array, top: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((len(c.item()) == 2) and all(ch in [' ', 'U', 'L', 'D', 'R'] for ch in c.item()) for c in np.nditer(board)), 'board must contain only digits or space'
+        self.board = board
+        self.V, self.H = board.shape
+        self.side = side
+        self.top = top
+
+        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)]
+                else:
+                    self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def add_all_constraints(self):
+        # force the already given hints
+        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.board, pos).strip():
+                self.model.Add(self.cell_direction[(pos, str_to_direction[char])] == 1)
+
+        # force the already given sides
+        for i in range(self.V):
+            self.model.Add(sum([self.cell_active[pos] for pos in get_row_pos(i, self.H)]) == self.side[i])
+        for i in range(self.H):
+            self.model.Add(sum([self.cell_active[pos] for pos in get_col_pos(i, self.V)]) == self.top[i])
+
+        # cell active means exactly 2 directions are active, cell not active means no directions are active
+        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).OnlyEnforceIf(self.cell_active[pos])
+            self.model.Add(s == 0).OnlyEnforceIf(self.cell_active[pos].Not())
+
+        # force borders to only have 2 point outside the board
+        pointing_outside = []
+        for pos in get_col_pos(0, self.V):  # left border
+            pointing_outside.append(self.cell_direction[(pos, Direction.LEFT)])
+        for pos in get_col_pos(self.H - 1, self.V):  # right border
+            pointing_outside.append(self.cell_direction[(pos, Direction.RIGHT)])
+        for pos in get_row_pos(0, self.H):  # top border
+            pointing_outside.append(self.cell_direction[(pos, Direction.UP)])
+        for pos in get_row_pos(self.V - 1, self.H):  # bottom border
+            pointing_outside.append(self.cell_direction[(pos, Direction.DOWN)])
+        self.model.Add(sum(pointing_outside) == 2)
+
+        # 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, show_grid=False, special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)].strip(), center_char=lambda r, c: '.', text_on_shaded_cells=False))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=20)

puzzle_solver/puzzles/trees_logic/trees_logic.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, get_char, get_neighbors8, 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, id_board_to_wall_fn
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.block_numbers = {int(c.item()) for c in np.nditer(board)}
+        self.blocks = {num: [] for num in self.block_numbers}
+        for pos in get_all_pos(self.V, self.H):
+            self.blocks[int(get_char(board, pos))].append(pos)
+
+        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 row in range(self.V):  # each row must have exactly one tree
+            self.model.Add(lxp.sum([self.model_vars[pos] for pos in get_row_pos(row, self.H)]) == 1)
+        for col in range(self.H):  # each column must have exactly one tree
+            self.model.Add(lxp.sum([self.model_vars[pos] for pos in get_col_pos(col, self.V)]) == 1)
+        for block_number in self.block_numbers:  # each block must have exactly one tree
+            self.model.Add(lxp.sum([self.model_vars[pos] for pos in self.blocks[block_number]]) == 1)
+        # trees cannot touch even diagonally
+        for pos in get_all_pos(self.V, self.H):
+            for neighbor in get_neighbors8(pos, self.V, self.H, include_self=False):
+                self.model.Add(self.model_vars[neighbor] == 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, cell_flags=id_board_to_wall_fn(self.board)))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/troix/dumplings.py

@@ -0,0 +1,7 @@
+import numpy as np
+from .troix import Board as TroixBoard
+
+
+class Board(TroixBoard):
+    def __init__(self, board: np.array):
+        super().__init__(board=board, illegal_run=None)

puzzle_solver/puzzles/troix/troix.py

@@ -0,0 +1,75 @@
+from typing import Optional
+
+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_char, get_next_pos, get_pos, get_row_pos, get_col_pos, in_bounds
+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, characters: set[str] = None, illegal_run: Optional[int] = 3, wall_char: Optional[str] = None):
+        if characters is None:
+            characters = set(c.item() for c in np.nditer(board) if c.item() not in [' ', wall_char])
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item() in ([' ', wall_char] + list(characters)) for c in np.nditer(board)), 'board must contain only space or characters'
+        self.board = board
+        self.V, self.H = board.shape
+        assert self.V % len(characters) == 0, f'board height must be divisible by number of characters, got {self.V} % {len(characters)} = {self.V % len(characters)}'
+        assert self.H % len(characters) == 0, f'board width must be divisible by number of characters, got {self.H} % {len(characters)} = {self.H % len(characters)}'
+        self.num_repeats_v = self.V // len(characters)
+        self.num_repeats_h = self.H // len(characters)
+        self.characters = characters
+        self.illegal_run = illegal_run
+        self.wall_char = wall_char
+
+        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) == self.wall_char:
+                continue
+            for char in self.characters:
+                self.model_vars[pos, char] = self.model.NewBoolVar(f'{pos}:{char}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c == self.wall_char:
+                continue
+            self.model.AddExactlyOne([self.model_vars[pos, char] for char in self.characters])
+            if c in self.characters:
+                self.model.Add(self.model_vars[pos, c] == 1)
+        for char in self.characters:
+            for row in range(self.V):
+                self.model.Add(lxp.Sum([self.model_vars[pos, char] for pos in get_row_pos(row, self.H)]) == self.num_repeats_v)
+            for col in range(self.H):
+                self.model.Add(lxp.Sum([self.model_vars[pos, char] for pos in get_col_pos(col, self.V)]) == self.num_repeats_h)
+        if self.illegal_run is not None:
+            for pos in get_all_pos(self.V, self.H):
+                self.disallow_run_constraint(pos, Direction.RIGHT)
+                self.disallow_run_constraint(pos, Direction.DOWN)
+
+    def disallow_run_constraint(self, pos: Pos, direction: Direction):
+        run = [pos]
+        while len(run) < self.illegal_run:
+            pos = get_next_pos(pos, direction)
+            if not in_bounds(pos, self.V, self.H):
+                return
+            run.append(pos)
+        assert len(run) == self.illegal_run, f'SHOULD NOT HAPPEN: run length != max run, {len(run)} != {self.illegal_run}'
+        for char in self.characters:
+            self.model.Add(lxp.Sum([self.model_vars[p, char] for p in run]) < self.illegal_run)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: char for (pos, char), var in board.model_vars.items() if solver.Value(var) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), self.board[r, c]), text_on_shaded_cells=False))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/twiddle/twiddle.py

@@ -0,0 +1,112 @@
+import time
+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_next_pos, Direction
+
+
+class Board:
+    def __init__(self, board: np.array, time_horizon: int = 10):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only digits'
+        self.board = board
+        self.target_state = np.sort(board, axis=None).reshape(board.shape)
+        self.V, self.H = board.shape
+        self.min_value = int(np.min(board.flatten()))
+        self.max_value = int(np.max(board.flatten()))
+        self.time_horizon = time_horizon
+
+        self.model = cp_model.CpModel()
+        self.state: dict[tuple[Pos, int], cp_model.IntVar] = {}
+        self.decision: dict[int, dict[Pos, cp_model.IntVar]] = {t: {} for t in range(self.time_horizon - 1)}
+
+        self.create_vars()
+        self.add_all_constraints()
+        self.minimize_actions()
+        self.constrain_final_state()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for t in range(self.time_horizon):
+                self.state[pos, t] = self.model.NewIntVar(self.min_value, self.max_value, f'state:{pos}:{t}')
+        for t in range(self.time_horizon - 1):
+            self.decision[t]['NOOP'] = self.model.NewBoolVar(f'decision:NOOP:{t}')
+            for pos in get_all_pos(self.V, self.H):
+                if pos.x == self.H - 1 or pos.y == self.V - 1:
+                    continue
+                self.decision[t][pos] = self.model.NewBoolVar(f'decision:{pos}:{t}')
+
+    def add_all_constraints(self):
+        # one action at most every time
+        for decision_at_t in self.decision.values():
+            self.model.AddExactlyOne(list(decision_at_t.values()))
+        # constrain the state at t=0
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(self.state[pos, 0] == get_char(self.board, pos))
+        # constrain the state dynamics at t=1..T
+        for action_pos in get_all_pos(self.V, self.H):
+            if action_pos.x == self.H - 1 or action_pos.y == self.V - 1:
+                continue
+            self.constrain_state(action_pos)
+        # state does not change if NOOP is chosen
+        for t in range(1, self.time_horizon):
+            noop_var = self.decision[t - 1]['NOOP']
+            for pos in get_all_pos(self.V, self.H):
+                self.model.Add(self.state[pos, t] == self.state[pos, t - 1]).OnlyEnforceIf(noop_var)
+
+    def constrain_state(self, action: Pos):
+        tl = action
+        tr = get_next_pos(tl, Direction.RIGHT)
+        bl = get_next_pos(tl, Direction.DOWN)
+        br = get_next_pos(tr, Direction.DOWN)
+        two_by_two = (tl, tr, br, bl)
+        # lock state outside the two by two
+        for pos in get_all_pos(self.V, self.H):
+            if pos in two_by_two:
+                continue
+            for t in range(1, self.time_horizon):
+                self.model.Add(self.state[pos, t] == self.state[pos, t - 1]).OnlyEnforceIf(self.decision[t - 1][action])
+        # rotate clockwise inside the two by two
+        clockwise = two_by_two[-1:] + two_by_two[:-1]
+        # print('action', action)
+        # print('two_by_two', two_by_two)
+        # print('clockwise', clockwise)
+        for pre_pos, post_pos in zip(clockwise, two_by_two):
+            for t in range(1, self.time_horizon):
+                # print(f'IF self.decision[{t - 1}][{action}] THEN self.state[{post_pos}, {t}] == self.state[{pre_pos}, {t - 1}]')
+                self.model.Add(self.state[post_pos, t] == self.state[pre_pos, t - 1]).OnlyEnforceIf(self.decision[t - 1][action])
+
+    def constrain_final_state(self):
+        final_time = self.time_horizon - 1
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(self.state[pos, final_time] == get_char(self.target_state, pos))
+
+    def minimize_actions(self):
+        flat_decisions = [(var, t+1) for t, tvs in self.decision.items() for pos, var in tvs.items() if pos != 'NOOP']
+        self.model.Minimize(lxp.weighted_sum([p[0] for p in flat_decisions], [p[1] for p in flat_decisions]))
+
+    def solve_and_print(self, verbose: bool = True):
+        solver = cp_model.CpSolver()
+        tic = time.time()
+        solver.solve(self.model)
+        assignment: dict[Pos] = [None for _ in range(self.time_horizon - 1)]
+        if solver.StatusName() in ['OPTIMAL', 'FEASIBLE']:
+            for t, tvs in self.decision.items():
+                for pos, var in tvs.items():
+                    if solver.Value(var) == 1:
+                        assignment[t] = (pos.x, pos.y) if pos != 'NOOP' else 'NOOP'
+            for t in range(self.time_horizon):
+                res_at_t = np.full((self.V, self.H), ' ', dtype=object)
+                for pos in get_all_pos(self.V, self.H):
+                    res_at_t[pos.y][pos.x] = solver.Value(self.state[pos, t])
+                print(f't={t}')
+                print(res_at_t)
+            if verbose:
+                print("Solution found:", assignment)
+        if verbose:
+            print("status:", solver.StatusName())
+            toc = time.time()
+            print(f"Time taken: {toc - tic:.2f} seconds")
+        return assignment
+

puzzle_solver/puzzles/undead/undead.py

@@ -0,0 +1,130 @@
+from typing import Optional
+from enum import Enum
+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_pos, get_next_pos, in_bounds, get_char, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Monster(Enum):
+    VAMPIRE = "VAMPIRE"
+    ZOMBIE = "ZOMBIE"
+    GHOST = "GHOST"
+
+
+@dataclass
+class SingleBeamResult:
+    position: Pos
+    reflect_count: int
+
+
+def can_see(reflect_count: int, monster: Monster) -> bool:
+    if monster == Monster.ZOMBIE:
+        return True
+    elif monster == Monster.VAMPIRE:
+        return reflect_count == 0
+    elif monster == Monster.GHOST:
+        return reflect_count > 0
+
+
+def beam(board, start_pos: Pos, direction: Direction) -> list[SingleBeamResult]:
+    V, H = board.shape
+    cur_result: list[SingleBeamResult] = []
+    reflect_count = 0
+    cur_pos = start_pos
+    while True:
+        if not in_bounds(cur_pos, V, H):
+            break
+        cur_pos_char = get_char(board, cur_pos)
+        if cur_pos_char == '//':
+            direction = {
+                Direction.RIGHT: Direction.UP,
+                Direction.UP: Direction.RIGHT,
+                Direction.DOWN: Direction.LEFT,
+                Direction.LEFT: Direction.DOWN
+            }[direction]
+            reflect_count += 1
+        elif cur_pos_char == '\\':
+            direction = {
+                Direction.RIGHT: Direction.DOWN,
+                Direction.DOWN: Direction.RIGHT,
+                Direction.UP: Direction.LEFT,
+                Direction.LEFT: Direction.UP
+            }[direction]
+            reflect_count += 1
+        else:  # not a mirror
+            cur_result.append(SingleBeamResult(cur_pos, reflect_count))
+        cur_pos = get_next_pos(cur_pos, direction)
+    return cur_result
+
+
+class Board:
+    def __init__(self, board: np.array, sides: dict[str, np.array], monster_count: Optional[dict[Monster, int]] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert set(sides.keys()) == set(['right', 'left', 'top', 'bottom'])
+        self.board = board
+        self.V, self.H = board.shape
+        assert sides['top'].shape == (self.H,) and sides['bottom'].shape == (self.H,) and sides['right'].shape == (self.V,) and sides['left'].shape == (self.V,), 'all sides must be equal to board size'
+        self.sides = sides
+        self.monster_count = monster_count or {}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], 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 monster in Monster:
+                self.model_vars[(pos, monster)] = self.model.NewBoolVar(f"{pos}_is_{monster}")
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            if get_char(self.board, pos).strip():
+                self.model.Add(lxp.Sum([self.model_vars[(pos, monster)] for monster in Monster]) == 0)
+                continue
+            self.model.AddExactlyOne([self.model_vars[(pos, monster)] for monster in Monster])
+        for i, ground in enumerate(self.sides['top']):  # top edge
+            if ground == -1:
+                continue
+            beam_result = beam(self.board, get_pos(x=i, y=0), Direction.DOWN)
+            self.model.add(self.get_var(beam_result) == ground)
+        for i, ground in enumerate(self.sides['left']):  # left edge
+            if ground == -1:
+                continue
+            beam_result = beam(self.board, get_pos(x=0, y=i), Direction.RIGHT)
+            self.model.add(self.get_var(beam_result) == ground)
+        for i, ground in enumerate(self.sides['right']):  # right edge
+            if ground == -1:
+                continue
+            beam_result = beam(self.board, get_pos(x=self.H-1, y=i), Direction.LEFT)
+            self.model.add(self.get_var(beam_result) == ground)
+        for i, ground in enumerate(self.sides['bottom']):  # bottom edge
+            if ground == -1:
+                continue
+            beam_result = beam(self.board, get_pos(x=i, y=self.V-1), Direction.UP)
+            self.model.add(self.get_var(beam_result) == ground)
+        for monster, count in self.monster_count.items():
+            self.model.add(lxp.Sum([self.model_vars.get((pos, monster), 0) for pos in get_all_pos(self.V, self.H)]) == count)
+
+    def get_var(self, path: list[SingleBeamResult]) -> lxp:
+        path_vars = []
+        for square in path:
+            assert get_char(self.board, square.position).strip() == '', f'square {square.position} is not a star position'
+            for monster in Monster:
+                if can_see(square.reflect_count, monster):
+                    path_vars.append(self.model_vars[(square.position, monster)])
+        return lxp.Sum(path_vars) if path_vars else 0
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: monster.name[0] for (pos, monster), var in board.model_vars.items() if solver.BooleanValue(var)})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), self.board[r, c].replace('//', '/')).strip()))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)