multi-puzzle-solver 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

puzzle_solver/puzzles/palisade/palisade.py

@@ -1,106 +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_pos, set_char, in_bounds, get_next_pos, Direction, polyominoes
-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
-
-
-
-# a shape on the 2d board is just a set of positions
-Shape = frozenset[Pos]
-
-@dataclass(frozen=True)
-class ShapeOnBoard:
-    is_active: cp_model.IntVar
-    shape: Shape
-    shape_id: int
-    body: set[Pos]
-
-
-def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
-    # give a shape and a board, return all valid translations of the shape that are fully contained in the board AND consistent with the clues on the board
-    shape_list = list(shape)
-    shape_borders = []  # will contain the number of borders for each pos in the shape; this has to be consistent with the clues on the board
-    for pos in shape_list:
-        v = 0
-        for direction in Direction:
-            next_pos = get_next_pos(pos, direction)
-            if not in_bounds(next_pos, board.shape[0], board.shape[1]) or next_pos not in shape:
-                v += 1
-        shape_borders.append(v)
-    shape_list = [(p.x, p.y) for p in shape_list]
-    # min x/y is always 0
-    max_x = max(p[0] for p in shape_list)
-    max_y = max(p[1] for p in shape_list)
-
-    for dy in range(0, board.shape[0] - max_y):
-        for dx in range(0, board.shape[1] - max_x):
-            body = tuple((p[0] + dx, p[1] + dy) for p in shape_list)
-            for i, p in enumerate(body):
-                c = board[p[1], p[0]]
-                if c != ' ' and c != str(shape_borders[i]):  # there is a clue and it doesn't match my translated shape, skip
-                    break
-            else:
-                yield frozenset(get_pos(x=p[0], y=p[1]) for p in body)
-
-
-
-class Board:
-    def __init__(self, board: np.array, region_size: int):
-        assert region_size >= 1 and isinstance(region_size, int), 'region_size must be an integer greater than or equal to 1'
-        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.region_size = region_size
-        self.region_count = (self.V * self.H) // self.region_size
-        assert self.region_count * self.region_size == self.V * self.H, f'region_size must be a factor of the board size, got {self.region_size} and {self.region_count}'
-
-        self.polyominoes = polyominoes(self.region_size)
-
-        self.model = cp_model.CpModel()
-        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
-        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = defaultdict(set)
-        self.create_vars()
-        self.add_all_constraints()
-
-    def create_vars(self):
-        for shape in self.polyominoes:
-            for body in get_valid_translations(shape, self.board):
-                uid = len(self.shapes_on_board)
-                shape_on_board = ShapeOnBoard(
-                    is_active=self.model.NewBoolVar(f'{uid}:is_active'),
-                    shape=shape,
-                    shape_id=uid,
-                    body=body,
-                )
-                self.shapes_on_board.append(shape_on_board)
-                for pos in body:
-                    self.pos_to_shapes[pos].add(shape_on_board)
-
-    def add_all_constraints(self):
-        for pos in get_all_pos(self.V, self.H):  # each position has exactly one shape active
-            self.model.AddExactlyOne(shape.is_active for shape in self.pos_to_shapes[pos])
-
-    def solve_and_print(self, verbose: bool = True):
-        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for shape in board.shapes_on_board:
-                if solver.Value(shape.is_active) == 1:
-                    for pos in shape.body:
-                        assignment[pos] = shape.shape_id
-            return SingleSolution(assignment=assignment)
-        def callback(single_res: SingleSolution):
-            print("Solution found")
-            id_board = np.full((self.V, self.H), ' ', dtype=object)
-            for pos in get_all_pos(self.V, self.H):
-                region_idx = single_res.assignment[pos]
-                set_char(id_board, pos, region_idx)
-            print(combined_function(self.V, self.H,
-                cell_flags=id_board_to_wall_fn(id_board),
-                center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else '·'))
-        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
+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_pos, in_bounds, get_next_pos, Direction, polyominoes
+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
+
+
+Shape = frozenset[Pos]  # a shape on the 2d board is just a set of positions
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    shape: Shape
+    shape_id: int
+    body: set[Pos]
+
+
+def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
+    # give a shape and a board, return all valid translations of the shape that are fully contained in the board AND consistent with the clues on the board
+    shape_list = list(shape)
+    shape_borders = []  # will contain the number of borders for each pos in the shape; this has to be consistent with the clues on the board
+    for pos in shape_list:
+        v = 0
+        for direction in Direction:
+            next_pos = get_next_pos(pos, direction)
+            if not in_bounds(next_pos, board.shape[0], board.shape[1]) or next_pos not in shape:
+                v += 1
+        shape_borders.append(v)
+    shape_list = [(p.x, p.y) for p in shape_list]
+    # min x/y is always 0
+    max_x = max(p[0] for p in shape_list)
+    max_y = max(p[1] for p in shape_list)
+    for dy in range(0, board.shape[0] - max_y):
+        for dx in range(0, board.shape[1] - max_x):
+            body = tuple((p[0] + dx, p[1] + dy) for p in shape_list)
+            for i, p in enumerate(body):
+                c = board[p[1], p[0]]
+                if c != ' ' and c != str(shape_borders[i]):  # there is a clue and it doesn't match my translated shape, skip
+                    break
+            else:
+                yield frozenset(get_pos(x=p[0], y=p[1]) for p in body)
+
+
+class Board:
+    def __init__(self, board: np.array, region_size: int):
+        assert region_size >= 1 and isinstance(region_size, int), 'region_size must be an integer greater than or equal to 1'
+        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.region_size = region_size
+        self.region_count = (self.V * self.H) // self.region_size
+        assert self.region_count * self.region_size == self.V * self.H, f'region_size must be a factor of the board size, got {self.region_size} and {self.region_count}'
+        self.polyominoes = polyominoes(self.region_size)
+
+        self.model = cp_model.CpModel()
+        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = defaultdict(set)
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for shape in self.polyominoes:
+            for body in get_valid_translations(shape, self.board):
+                uid = len(self.shapes_on_board)
+                shape_on_board = ShapeOnBoard(
+                    is_active=self.model.NewBoolVar(f'{uid}:is_active'),
+                    shape=shape, shape_id=uid, body=body
+                )
+                self.shapes_on_board.append(shape_on_board)
+                for pos in body:
+                    self.pos_to_shapes[pos].add(shape_on_board)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # each position has exactly one shape active
+            self.model.AddExactlyOne(shape.is_active for shape in self.pos_to_shapes[pos])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            active_shapes = [shape for shape in board.shapes_on_board if solver.Value(shape.is_active) == 1]
+            return SingleSolution(assignment={pos: shape.shape_id for shape in active_shapes for pos in shape.body})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(np.array([[single_res.assignment[get_pos(x=c, y=r)] for c in range(self.H)] for r in range(self.V)])),
+                center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else '·'))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/shingoki/shingoki.py

@@ -1,35 +1,20 @@
-import json
-from dataclasses import dataclass
-import time
+from collections import defaultdict
 
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_neighbors4, get_next_pos, get_char, in_bounds
-from puzzle_solver.core.utils_ortools import generic_solve_all, force_connected_component, and_constraint
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_char, in_bounds, set_char, get_pos, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, force_connected_component, and_constraint, SingleSolution
 from puzzle_solver.core.utils_visualizer import combined_function
 
 
-@dataclass(frozen=True)
-class SingleSolution:
-    assignment: dict[tuple[Pos, Pos], int]
-
-    def get_hashable_solution(self) -> str:
-        result = []
-        for (pos, neighbor), v in self.assignment.items():
-            result.append((pos.x, pos.y, neighbor.x, neighbor.y, v))
-        return json.dumps(result, sort_keys=True)
-
-
-def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[tuple[Pos, Pos]]:
+def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
     out = []
-    prev_pos = pos
     while True:
+        out.append(pos)
         pos = get_next_pos(pos, direction)
         if not in_bounds(pos, V, H):
             break
-        out.append((prev_pos, pos))
-        prev_pos = pos
     return out
 
 
@@ -37,8 +22,8 @@ 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() == '') or (str(c.item())[:-1].isdecimal() and c.item()[-1].upper() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only space or digits and B/W'
-
         self.V, self.H = board.shape
+        self.board = board
         self.board_numbers: dict[Pos, int] = {}
         self.board_colors: dict[Pos, str] = {}
         for pos in get_all_pos(self.V, self.H):
@@ -47,112 +32,84 @@ class Board:
                 continue
             self.board_numbers[pos] = int(c[:-1])
             self.board_colors[pos] = c[-1].upper()
+
         self.model = cp_model.CpModel()
-        self.edge_vars: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.cell_active: dict[Pos, cp_model.IntVar] = {}
+        self.cell_direction: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
 
         self.create_vars()
         self.add_all_constraints()
 
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
-            for neighbor in get_neighbors4(pos, self.V, self.H):
-                if (neighbor, pos) in self.edge_vars:  # already added in opposite direction
-                    self.edge_vars[(pos, neighbor)] = self.edge_vars[(neighbor, pos)]
-                else:  # new edge
-                    self.edge_vars[(pos, neighbor)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
+            self.cell_active[pos] = self.model.NewBoolVar(f'{pos}')
+            for direction in Direction:
+                neighbor = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if not in_bounds(neighbor, self.V, self.H):
+                    self.cell_direction[(pos, direction)] = self.model.NewConstant(0)
+                    continue
+                if (neighbor, opposite_direction) in self.cell_direction:
+                    self.cell_direction[(pos, direction)] = self.cell_direction[(neighbor, opposite_direction)]
+                else:
+                    self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
 
     def add_all_constraints(self):
-        # each corners must have either 0 or 2 neighbors
-        for pos in get_all_pos(self.V, self.H):
-            corner_connections = [self.edge_vars[(pos, n)] for n in get_neighbors4(pos, self.V, self.H)]
-            if pos not in self.board_numbers:  # no color, either 0 or 2 edges
-                self.model.AddLinearExpressionInDomain(sum(corner_connections), cp_model.Domain.FromValues([0, 2]))
-            else:  # color, must have exactly 2 edges
-                self.model.Add(sum(corner_connections) == 2)
-
-        # enforce colors
         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())
             if pos not in self.board_numbers:
                 continue
-            self.enforce_corner_color(pos, self.board_colors[pos])
-            self.enforce_corner_number(pos, self.board_numbers[pos])
-
-        # enforce single connected component
-        def is_neighbor(edge1: tuple[Pos, Pos], edge2: tuple[Pos, Pos]) -> bool:
-            return any(c1 == c2 for c1 in edge1 for c2 in edge2)
-        force_connected_component(self.model, self.edge_vars, is_neighbor=is_neighbor)
+            self.enforce_corner_color_and_number(pos, self.board_colors[pos], self.board_numbers[pos])  # enforce colors and number
+        self.force_connected_component()  # enforce single connected component
 
-    def enforce_corner_color(self, pos: Pos, pos_color: str):
-        assert pos_color in ['W', 'B'], f'Invalid color: {pos_color}'
-        pos_r = get_next_pos(pos, Direction.RIGHT)
-        var_r = self.edge_vars[(pos, pos_r)] if (pos, pos_r) in self.edge_vars else False
-        pos_d = get_next_pos(pos, Direction.DOWN)
-        var_d = self.edge_vars[(pos, pos_d)] if (pos, pos_d) in self.edge_vars else False
-        pos_l = get_next_pos(pos, Direction.LEFT)
-        var_l = self.edge_vars[(pos, pos_l)] if (pos, pos_l) in self.edge_vars else False
-        pos_u = get_next_pos(pos, Direction.UP)
-        var_u = self.edge_vars[(pos, pos_u)] if (pos, pos_u) in self.edge_vars else False
+    def enforce_corner_color_and_number(self, pos: Pos, pos_color: str, pos_number: int):
+        assert pos_color in ['W', 'B'] and pos_number > 0, f'Invalid color or number: {pos_color}, {pos_number}'
+        self.model.Add(self.cell_active[pos] == 1)
         if pos_color == 'W':  # White circles must be passed through in a straight line
-            self.model.Add(var_r == var_l)
-            self.model.Add(var_u == var_d)
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == self.cell_direction[(pos, Direction.LEFT)])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == self.cell_direction[(pos, Direction.UP)])
         elif pos_color == 'B':  # Black circles must be turned upon
-            self.model.Add(var_r == 0).OnlyEnforceIf([var_l])
-            self.model.Add(var_l == 0).OnlyEnforceIf([var_r])
-            self.model.Add(var_u == 0).OnlyEnforceIf([var_d])
-            self.model.Add(var_d == 0).OnlyEnforceIf([var_u])
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.LEFT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.RIGHT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.UP)]])
+            self.model.Add(self.cell_direction[(pos, Direction.UP)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.DOWN)]])
         else:
             raise ValueError(f'Invalid color: {pos_color}')
-
-    def enforce_corner_number(self, pos: Pos, pos_number: int):
-        # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
-        # Build visibility chains per direction (exclude self)
-        vis_vars: list[cp_model.IntVar] = []
-        for direction in Direction:
-            rays = get_ray(pos, self.V, self.H, direction)  # cells outward
-            if not rays:
-                continue
-            # Chain: v0 = w[ray[0]]; vt = w[ray[t]] & vt-1
-            prev = None
-            for idx, (pos1, pos2) in enumerate(rays):
-                v = self.model.NewBoolVar(f"vis[{pos1}-{pos2}]->({direction.name})[{idx}]")
+        vis_vars: list[cp_model.IntVar] = []  # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
+        for direction in Direction:  # Build visibility chains in four direction
+            ray = get_ray(pos, self.V, self.H, direction)  # cells outward
+            for idx in range(len(ray)):
+                v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                and_constraint(self.model, target=v, cs=[self.cell_direction[(p, direction)] for p in ray[:idx+1]])
                 vis_vars.append(v)
-                if idx == 0:
-                    # v0 == w[cell]
-                    self.model.Add(v == self.edge_vars[(pos1, pos2)])
-                else:
-                    and_constraint(self.model, target=v, cs=[self.edge_vars[(pos1, pos2)], prev])
-                prev = v
         self.model.Add(sum(vis_vars) == pos_number)
 
+    def force_connected_component(self):
+        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):
-        tic = time.time()
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[tuple[Pos, Pos], int] = {}
-            for (pos, neighbor), var in board.edge_vars.items():
-                assignment[(pos, neighbor)] = solver.Value(var)
+            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):
-            nonlocal tic
-            print(f"Solution found in {time.time() - tic:.2f} seconds")
-            tic = time.time()
-            res = np.full((self.V - 1, self.H - 1), ' ', dtype=object)
-            for (pos, neighbor), v in single_res.assignment.items():
-                if v == 0:
-                    continue
-                min_x = min(pos.x, neighbor.x)
-                min_y = min(pos.y, neighbor.y)
-                dx = abs(pos.x - neighbor.x)
-                dy = abs(pos.y - neighbor.y)
-                if min_x == self.H - 1:  # only way to get right
-                    res[min_y][min_x - 1] += 'R'
-                elif min_y == self.V - 1:  # only way to get down
-                    res[min_y - 1][min_x] += 'D'
-                elif dx == 1:
-                    res[min_y][min_x] += 'U'
-                elif dy == 1:
-                    res[min_y][min_x] += 'L'
-                else:
-                    raise ValueError(f'Invalid position: {pos} and {neighbor}')
-            print(combined_function(self.V - 1, self.H - 1, cell_flags=lambda r, c: res[r, c], center_char=lambda r, c: '.'))
+            print("Solution found")
+            output_board = np.full((self.V, self.H), '', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if get_char(self.board, pos)[-1] in ['B', 'W']:  # if the main board has a white or black pearl, put it in the output
+                    set_char(output_board, pos, get_char(self.board, pos))
+                if not single_res.assignment[pos].strip():  # if the cell does not the line through it, put a dot
+                    set_char(output_board, pos, '.')
+            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: output_board[r, c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/tracks/tracks.py

@@ -2,7 +2,7 @@ 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, in_bounds, get_next_pos, get_row_pos, get_col_pos, get_opposite_direction, get_pos
+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