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

puzzle_solver/puzzles/abc_view/abc_view.py

@@ -0,0 +1,75 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_pos, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array, top: np.array, left: np.array, bottom: np.array, right: np.array, characters: list[str]):
+        self.BLANK = 'BLANK'
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.characters_no_blank = characters
+        self.characters = characters + [self.BLANK]
+        assert all(c.strip() in self.characters or c.strip() == '' for c in board.flatten()), f'board must contain characters in {self.characters}'
+        assert all(c.strip() in self.characters or c.strip() == '' for c in np.concatenate([top, left, bottom, right])), f'top, bottom, left, and right must contain only characters in {self.characters}'
+        self.board = board
+        self.V, self.H = board.shape
+        assert top.shape == (self.H,) and bottom.shape == (self.H,) and left.shape == (self.V,) and right.shape == (self.V,), 'top, bottom, left, and right must be 1d arrays of length board width and height'
+        self.top = top
+        self.left = left
+        self.bottom = bottom
+        self.right = right
+
+        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 character in self.characters:
+                self.model_vars[pos, character] = self.model.NewBoolVar(f'{pos}:{character}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne([self.model_vars[pos, character] for character in self.characters])
+            c = get_char(self.board, pos).strip()  # force the clue if on the board
+            if not c:
+                continue
+            self.model.Add(self.model_vars[pos, c] == 1)
+
+        # each row and column must have exactly one of each character, except for BLANK
+        for row in range(self.V):
+            for character in self.characters_no_blank:
+                self.model.AddExactlyOne([self.model_vars[pos, character] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):
+            for character in self.characters_no_blank:
+                self.model.AddExactlyOne([self.model_vars[pos, character] for pos in get_col_pos(col, self.V)])
+
+        # a character clue on that side means the first character that appears on the side is the clue
+        for i, top_char in enumerate(self.top):
+            self.force_first_character(list(get_col_pos(i, self.V)), top_char)
+        for i, bottom_char in enumerate(self.bottom):
+            self.force_first_character(list(get_col_pos(i, self.V))[::-1], bottom_char)
+        for i, left_char in enumerate(self.left):
+            self.force_first_character(list(get_row_pos(i, self.H)), left_char)
+        for i, right_char in enumerate(self.right):
+            self.force_first_character(list(get_row_pos(i, self.H))[::-1], right_char)
+
+    def force_first_character(self, pos_list: list[Pos], target_character: str):
+        if not target_character:
+            return
+        for i, pos in enumerate(pos_list):
+            is_first_char = self.model.NewBoolVar(f'{i}:{target_character}:is_first_char')
+            and_constraint(self.model, is_first_char, [self.model_vars[pos, self.BLANK] for pos in pos_list[:i]] + [self.model_vars[pos_list[i], self.BLANK].Not()])
+            self.model.Add(self.model_vars[pos, target_character] == 1).OnlyEnforceIf(is_first_char)
+
+    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 and char != board.BLANK})
+        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), ''), text_on_shaded_cells=False))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/heyawake/heyawake.py

@@ -1,9 +1,9 @@
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, get_char
+from puzzle_solver.core.utils import Pos, get_all_pos, get_col_pos, get_neighbors4, get_pos, get_char, get_row_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
-from puzzle_solver.core.utils_visualizer import combined_function
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
@@ -20,6 +20,17 @@ def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
         out.append((begin_idx, end_idx))
     return out
 
+
+def get_diagonal(pos1: Pos, pos2: Pos) -> list[Pos]:
+    assert pos1 != pos2, 'positions must be different'
+    dx = pos1.x - pos2.x
+    dy = pos1.y - pos2.y
+    assert abs(dx) == abs(dy), 'positions must be on a diagonal'
+    sdx = 1 if dx > 0 else -1
+    sdy = 1 if dy > 0 else -1
+    return [get_pos(x=pos2.x + i*sdx, y=pos2.y + i*sdy) for i in range(abs(dx) + 1)]
+
+
 class Board:
     def __init__(self, board: np.array, region_to_clue: dict[str, int]):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
@@ -59,6 +70,10 @@ class Board:
         force_connected_component(self.model, self.W)
         # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
         self.disallow_white_lines_spanning_3_regions()
+        # straight diagonal black lines from side wall to horizontal wall are not allowed; because they would disconnect the white cells
+        self.disallow_full_black_diagonal()
+        # disallow a diagonal black line coming out of a wall of length N then coming back in on the same wall; because it would disconnect the white cells
+        self.disallow_zigzag_on_wall()
 
     def disallow_white_lines_spanning_3_regions(self):
         # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
@@ -77,22 +92,61 @@ class Board:
                 pos_list = [get_pos(x=col_num, y=y) for y in range(begin_idx, end_idx+1)]
                 self.model.AddBoolOr([self.B[p] for p in pos_list])
 
-    def solve_and_print(self, verbose: bool = True):
+    def disallow_full_black_diagonal(self):
+        corners_dx_dy = [
+            ((0, 0), 1, 1),
+            ((self.H-1, 0), -1, 1),
+            ((0, self.V-1), 1, -1),
+            ((self.H-1, self.V-1), -1, -1),
+        ]
+        for (corner_x, corner_y), dx, dy in corners_dx_dy:
+            for delta in range(1, min(self.V, self.H)):
+                pos1 = get_pos(x=corner_x, y=corner_y + delta*dy)
+                pos2 = get_pos(x=corner_x + delta*dx, y=corner_y)
+                diagonal_line = get_diagonal(pos1, pos2)
+                self.model.AddBoolOr([self.W[p] for p in diagonal_line])
+
+    def disallow_zigzag_on_wall(self):
+        for pos in get_row_pos(0, self.H):  # top line
+            for end_x in range(pos.x + 2, self.H, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=end_x, y=pos.y)
+                dx = end_x - pos.x
+                mid_pos = get_pos(x=pos.x + dx//2, y=pos.y + dx//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from top wall to bottom triangle tip "\"
+                diag_2 = get_diagonal(end_pos, mid_pos)  # from bottom triangle tip to top wall "/"
+                self.model.AddBoolOr([self.W[p] for p in diag_1 + diag_2])
+        for pos in get_row_pos(self.V-1, self.H):  # bottom line
+            for end_x in range(pos.x + 2, self.H, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=end_x, y=pos.y)
+                dx = end_x - pos.x
+                mid_pos = get_pos(x=pos.x + dx//2, y=pos.y - dx//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from bottom wall to top triangle tip "/"
+                diag_2 = get_diagonal(end_pos, mid_pos)  # from top triangle tip to bottom wall "\"
+                self.model.AddBoolOr([self.W[p] for p in diag_1 + diag_2])
+        for pos in get_col_pos(0, self.V):  # left line
+            for end_y in range(pos.y + 2, self.V, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=pos.x, y=end_y)
+                dy = end_y - pos.y
+                mid_pos = get_pos(x=pos.x + dy//2, y=pos.y + dy//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from left wall to right triangle tip "\"
+                diag_2 = get_diagonal(end_pos, mid_pos)  # from right triangle tip to left wall "/"
+                self.model.AddBoolOr([self.W[p] for p in diag_1 + diag_2])
+        for pos in get_col_pos(self.H-1, self.V):  # right line
+            for end_y in range(pos.y + 2, self.V, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=pos.x, y=end_y)
+                dy = end_y - pos.y
+                mid_pos = get_pos(x=pos.x - dy//2, y=pos.y + dy//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from right wall to left triangle tip "/"
+
+    def solve_and_print(self, verbose: bool = True, max_solutions: int = 20):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for pos, var in board.B.items():
-                assignment[pos] = 1 if solver.Value(var) == 1 else 0
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var 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 = 'B' if single_res.assignment[pos] == 1 else ' '
-            #     set_char(res, pos, c)
-            # print(res)
             print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(self.board),
                 is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1,
                 center_char=lambda r, c: self.region_to_clue.get(int(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, max_solutions=1)
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=max_solutions)

puzzle_solver/puzzles/mathema_grids/mathema_grids.py

@@ -0,0 +1,119 @@
+from dataclasses import dataclass
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.util.python import sorted_interval_list
+
+from puzzle_solver.core.utils import Direction, Pos, get_char, get_next_pos, get_row_pos, get_col_pos, in_bounds, set_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+@dataclass
+class var_with_bounds:
+    var: cp_model.IntVar
+    min_value: int
+    max_value: int
+
+
+def _div_bounds(a_min: int, a_max: int, b_min: int, b_max: int) -> tuple[int, int]:
+    assert not (b_min == 0 and b_max == 0), "Denominator interval cannot be [0, 0]."
+    denoms = [b_min, b_max]
+    if 0 in denoms:
+        denoms.remove(0)
+    if b_min <= -1:
+        denoms += [-1]
+    if b_max >= 1:
+        denoms += [1]
+    candidates = [a_min // d for d in denoms] + [a_max // d for d in denoms]
+    return min(candidates), max(candidates)
+
+
+class Board:
+    def __init__(self, board: np.array, digits: list[int]):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.board = board
+        self.V, self.H = board.shape
+        assert self.V >= 3 and self.V % 2 == 1, f'board must have at least 3 rows and an odd number of rows. Got {self.V} rows.'
+        assert self.H >= 3 and self.H % 2 == 1, f'board must have at least 3 columns and an odd number of columns. Got {self.H} columns.'
+        self.digits = digits
+        self.domain_values = sorted_interval_list.Domain.FromValues(self.digits)
+        self.domain_values_no_zero = sorted_interval_list.Domain.FromValues([d for d in self.digits if d != 0])
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        assert len(self.model_vars) == len(self.digits), f'len(model_vars) != len(digits), {len(self.model_vars)} != {len(self.digits)}'
+        self.model.AddAllDifferent(list(self.model_vars.values()))
+
+    def create_vars(self):
+        for row in range(0, self.V-2, 2):
+            line_pos = [pos for pos in get_row_pos(row, self.H)]
+            self.parse_line(line_pos)
+        for col in range(0, self.H-2, 2):
+            line_pos = [pos for pos in get_col_pos(col, self.V)]
+            self.parse_line(line_pos)
+
+    def parse_line(self, line_pos: list[Pos]) -> list[int]:
+        last_num = get_char(self.board, line_pos[-1])
+        equal_sign = get_char(self.board, line_pos[-2])
+        assert equal_sign == '=', f'last element of line must be =, got {equal_sign}'
+        line_pos = line_pos[:-2]
+        operators = [get_char(self.board, pos) for pos in line_pos[1::2]]
+        assert all(c.strip() in ['+', '-', '*', '/'] for c in operators), f'even indices of line must be operators, got {operators}'
+        digits_pos = line_pos[::2]
+        running_var = self.get_var(digits_pos[0], fixed=get_char(self.board, digits_pos[0]))
+        for pos, operator in zip(digits_pos[1:], operators):
+            running_var = self.apply_operator(operator, running_var, self.get_var(pos, fixed=get_char(self.board, pos)))
+        self.model.Add(running_var.var == int(last_num))
+        return running_var
+
+    def get_var(self, pos: Pos, fixed: str) -> var_with_bounds:
+        if pos not in self.model_vars:
+            domain = self.domain_values_no_zero if self.might_be_denominator(pos) else self.domain_values
+            self.model_vars[pos] = self.model.NewIntVarFromDomain(domain, f'{pos}')
+        if fixed.strip():
+            self.model.Add(self.model_vars[pos] == int(fixed))
+        return var_with_bounds(var=self.model_vars[pos], min_value=min(self.digits), max_value=max(self.digits))
+
+    def might_be_denominator(self, pos: Pos) -> bool:
+        "Important since if the variable might be a denominator and the domain includes 0 then ortools immediately sets the model as INVALID"
+        above_pos = get_next_pos(pos, Direction.UP)
+        left_pos = get_next_pos(pos, Direction.LEFT)
+        above_operator = get_char(self.board, above_pos) if in_bounds(above_pos, self.V, self.H) else None
+        left_operator = get_char(self.board, left_pos) if in_bounds(left_pos, self.V, self.H) else None
+        return above_operator == '/' or left_operator == '/'
+
+    def apply_operator(self, operator: str, a: var_with_bounds, b: var_with_bounds) -> var_with_bounds:
+        assert operator in ['+', '-', '*', '/'], f'invalid operator: {operator}'
+        if operator == "+":
+            lo = a.min_value + b.min_value
+            hi = a.max_value + b.max_value
+            res = self.model.NewIntVar(lo, hi, "sum")
+            self.model.Add(res == a.var + b.var)
+        elif operator == "-":
+            lo = a.min_value - b.max_value
+            hi = a.max_value - b.min_value
+            res = self.model.NewIntVar(lo, hi, "diff")
+            self.model.Add(res == a.var - b.var)
+        elif operator == "*":
+            cands = [a.min_value*b.min_value, a.min_value*b.max_value, a.max_value*b.min_value, a.max_value*b.max_value]
+            lo, hi = min(cands), max(cands)
+            res = self.model.NewIntVar(lo, hi, "prod")
+            self.model.AddMultiplicationEquality(res, [a.var, b.var])
+        elif operator == "/":
+            self.model.Add(b.var != 0)
+            lo, hi = _div_bounds(a.min_value, a.max_value, b.min_value, b.max_value)
+            res = self.model.NewIntVar(lo, hi, "quot")
+            self.model.AddDivisionEquality(res, a.var, b.var)
+        return var_with_bounds(res, lo, hi)
+
+    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")
+            output_board = self.board.copy()
+            for pos, var in single_res.assignment.items():
+                set_char(output_board, pos, str(var))
+            print(combined_function(self.V, self.H, center_char=lambda r, c: str(output_board[r, c])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)