multi-puzzle-solver 0.9.26__py3-none-any.whl → 0.9.30__py3-none-any.whl

puzzle_solver/puzzles/shingoki/shingoki.py

@@ -0,0 +1,158 @@
+import json
+from dataclasses import dataclass
+import time
+
+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_visualizer import render_grid
+
+
+@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]]:
+    out = []
+    prev_pos = pos
+    while True:
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, V, H):
+            break
+        out.append((prev_pos, pos))
+        prev_pos = pos
+    return out
+
+
+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_numbers: dict[Pos, int] = {}
+        self.board_colors: dict[Pos, str] = {}
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(board, pos)
+            if c.strip() == '':
+                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.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}')
+
+    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):
+            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)
+
+    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
+        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)
+        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])
+        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.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 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)
+            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(render_grid(res, center_char='.'))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/singles/singles.py

@@ -1,8 +1,9 @@
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos, get_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
 
 
 class Board:
@@ -14,62 +15,35 @@ class Board:
         self.H = board.shape[1]
         self.N = self.V * self.H
         self.idx_of: dict[Pos, int] = get_all_pos_to_idx_dict(self.V, self.H)
-
         self.model = cp_model.CpModel()
-        self.B = {} # black squares
-        self.W = {} # white squares
+        self.B = {}
+        self.W = {}
         self.Num = {} # value of squares (Num = N + idx if black, else board[pos])
-
         self.create_vars()
         self.add_all_constraints()
 
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
             self.B[pos] = self.model.NewBoolVar(f'B:{pos}')
-            self.W[pos] = self.model.NewBoolVar(f'W:{pos}')
-            # either black or white
-            self.model.AddExactlyOne([self.B[pos], self.W[pos]])
+            self.W[pos] = self.B[pos].Not()
             self.Num[pos] = self.model.NewIntVar(0, 2*self.N, f'{pos}')
             self.model.Add(self.Num[pos] == self.N + self.idx_of[pos]).OnlyEnforceIf(self.B[pos])
-            self.model.Add(self.Num[pos] == int(get_char(self.board, pos))).OnlyEnforceIf(self.B[pos].Not())
+            self.model.Add(self.Num[pos] == int(get_char(self.board, pos))).OnlyEnforceIf(self.W[pos])
 
     def add_all_constraints(self):
-        self.no_adjacent_blacks()
-        self.no_number_appears_twice()
-        self.force_connected_component()
-
-    def no_adjacent_blacks(self):
-        # no two black squares are adjacent 
-        for pos in get_all_pos(self.V, self.H):
+        for pos in get_all_pos(self.V, self.H):  # no two black squares are adjacent
             for neighbor in get_neighbors4(pos, self.V, self.H):
                 self.model.Add(self.B[pos] + self.B[neighbor] <= 1)
-
-    def no_number_appears_twice(self):
-        # no number appears twice in any row or column (numbers are ignored if black)
-        for row in range(self.V):
-            var_list = [self.Num[pos] for pos in get_row_pos(row, self.H)]
-            self.model.AddAllDifferent(var_list)
-        for col in range(self.H):
-            var_list = [self.Num[pos] for pos in get_col_pos(col, self.V)]
-            self.model.AddAllDifferent(var_list)
-
-    def force_connected_component(self):
-        force_connected_component(self.model, self.W)
-
-
+        for row in range(self.V):  # no number appears twice in any row (numbers are ignored if black)
+            self.model.AddAllDifferent([self.Num[pos] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):  # no number appears twice in any column (numbers are ignored if black)
+            self.model.AddAllDifferent([self.Num[pos] for pos in get_col_pos(col, self.V)])
+        force_connected_component(self.model, self.W)  # all white squares must be a single connected component
 
     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.B.items():
-                assignment[pos] = solver.value(var)
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: 1 if solver.Value(val) == 1 else 0 for pos, val in board.B.items()})
         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 = 'B' if single_res.assignment[pos] == 1 else ' '
-                set_char(res, pos, c)
-            print(res)
+            print(render_shaded_grid(self.V, self.H, lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1, empty_text=lambda r, c: self.board[r, c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -2,8 +2,9 @@ import numpy as np
 from collections import defaultdict
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, Direction, get_row_pos, get_col_pos, get_next_pos, in_bounds, get_opposite_direction, render_grid
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, Direction, get_row_pos, get_col_pos, get_next_pos, in_bounds, get_opposite_direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import render_grid
 
 
 CellBorder = tuple[Pos, Direction]

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -242,4 +242,6 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'LITS_MDoxNzksNzY3.png')
     # main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
     # main(Path(__file__).parent / 'input_output' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.png')
-    main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')
+    # main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')
+    # main(Path(__file__).parent / 'input_output' / 'heyawake_MDoxNiwxNDQ=.png')
+    main(Path(__file__).parent / 'input_output' / 'heyawake_MTQ6ODQ4LDEzOQ==.png')

puzzle_solver/puzzles/tapa/tapa.py

@@ -0,0 +1,98 @@
+from typing import Union
+from itertools import combinations
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Direction8, Pos, get_all_pos, set_char, get_char, in_bounds, Direction, get_next_pos, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import render_shaded_grid
+
+
+def rotated_assignments_N_nums(Xs: tuple[int, ...], target_length: int = 8) -> set[tuple[bool, ...]]:
+    """ Given Xs = [X1, X2, ..., Xm] (each Xi >= 1), build all unique length-`target_length`
+        boolean lists of the form: [ True*X1, False*N1, True*X2, False*N2, ..., True*Xm, False*Nm ]
+        where each Ni >= 1 and sum(Xs) + sum(Ni) = target_length,
+        including all `target_length` wrap-around rotations, de-duplicated.
+    """
+    assert len(Xs) >= 1, "Xs must have at least one block length."
+    assert all(x >= 1 for x in Xs), "All Xi must be >= 1."
+    assert sum(Xs) + len(Xs) <= target_length, f"sum(Xs) + len(Xs) <= target_length required; got {sum(Xs)} + {len(Xs)} > {target_length}"
+    num_zero_blocks = len(Xs)
+    total_zeros = target_length - sum(Xs)
+    seen: set[tuple[bool, ...]] = set()
+    for cut_positions in combinations(range(1, total_zeros), num_zero_blocks - 1):
+        cut_positions = (*cut_positions, total_zeros)
+        Ns = [cut_positions[0]]  # length of zero blocks
+        for i in range(1, len(cut_positions)):
+            Ns.append(cut_positions[i] - cut_positions[i - 1])
+        base: list[bool] = []
+        for x, n in zip(Xs, Ns):
+            base.extend([True] * x)
+            base.extend([False] * n)
+        for dx in range(target_length):  # all rotations (wrap-around)
+            rot = tuple(base[dx:] + base[:dx])
+            seen.add(rot)
+    return seen
+
+
+class Board:
+    def __init__(self, board: np.array, separator: str = '/'):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(all(str(c).strip().isdecimal() or str(c).strip() == '' for c in cell.item().split(separator)) for cell in np.nditer(board)), 'board must contain only digits and separator'
+        self.V, self.H = board.shape
+        self.board = board
+        self.separator = separator
+        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):
+        # 2x2 blacks are not allowed
+        for pos in get_all_pos(self.V, self.H):
+            tl = pos
+            tr = get_next_pos(pos, Direction.RIGHT)
+            bl = get_next_pos(pos, Direction.DOWN)
+            br = get_next_pos(bl, Direction.RIGHT)
+            if any(not in_bounds(p, self.V, self.H) for p in [tl, tr, bl, br]):
+                continue
+            self.model.AddBoolOr([self.model_vars[tl].Not(), self.model_vars[tr].Not(), self.model_vars[bl].Not(), self.model_vars[br].Not()])
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c.strip() == '':
+                continue
+            clue = tuple(int(x.strip()) for x in c.split(self.separator))
+            self.model.Add(self.model_vars[pos] == 0)  # clue cannot be black
+            self.enforce_clue(pos, clue)  # each clue must be satisfied
+        # all blacks are connected
+        force_connected_component(self.model, self.model_vars)
+
+    def enforce_clue(self, pos: Pos, clue: Union[int, tuple[int, int]]):
+        neighbors = []
+        for direction in [Direction8.UP, Direction8.UP_RIGHT, Direction8.RIGHT, Direction8.DOWN_RIGHT, Direction8.DOWN, Direction8.DOWN_LEFT, Direction8.LEFT, Direction8.UP_LEFT]:
+            n = get_next_pos(pos, direction)
+            neighbors.append(self.model_vars[n] if in_bounds(n, self.V, self.H) else self.model.NewConstant(False))
+        valid_assignments = rotated_assignments_N_nums(Xs=clue)
+        self.model.AddAllowedAssignments(neighbors, valid_assignments)
+
+    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")
+            board_justified = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos).strip()
+                if len(c) > 3:
+                    c = '...'
+                set_char(board_justified, pos, ' ' * (2 - len(c)) + c)
+            print(render_shaded_grid(self.V, self.H, lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1, empty_text=lambda r, c: str(board_justified[r, c])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=5)