multi-puzzle-solver 0.9.20__py3-none-any.whl → 0.9.24__py3-none-any.whl

puzzle_solver/core/utils.py

@@ -188,6 +188,7 @@ def polyominoes(N):
     shapes = {frozenset(Pos(x, y) for x, y in s) for s in shapes}  # regular class, not the dirty-fast one
     return shapes
 
+
 def polyominoes_with_shape_id(N):
     """Refer to polyominoes() for more details. This function returns a set of all polyominoes of size N (rotated and reflected up to D4 symmetry) along with a unique ID for each polyomino that is unique up to D4 symmetry.
     Args:
@@ -226,3 +227,137 @@ def polyominoes_with_shape_id(N):
     result = {(s, canon_to_id[shape_to_canon[s]]) for s in shapes}
     result = {(frozenset(Pos(x, y) for x, y in s), _id) for s, _id in result}
     return result
+
+
+def render_grid(cell_flags: np.ndarray,
+                center_char: Union[np.ndarray, str, None] = None,
+                show_axes: bool = True,
+                scale_x: int = 2) -> str:
+    """
+    most of this function was AI generated then modified by me, I don't currently care about the details of rendering to the terminal this looked good enough during my testing.
+    cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
+    center_char: np.ndarray of shape (N, N) with the center of the cells, or a string to use for all cells, or None to not show centers.
+    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
+    """
+    if cell_flags is not None:
+        N = cell_flags.shape[0]
+        H = np.zeros((N+1, N), dtype=bool)
+        V = np.zeros((N, N+1), dtype=bool)
+        for r in range(N):
+            for c in range(N):
+                s = cell_flags[r, c]
+                if 'U' in s: H[r, c]   = True          # edge between (r,c) and (r, c+1) above the cell
+                if 'D' in s: H[r+1, c] = True          # edge below the cell
+                if 'L' in s: V[r, c]   = True          # edge left of the cell
+                if 'R' in s: V[r, c+1] = True          # edge right of the cell
+    assert H is not None and V is not None, 'H and V must be provided'
+    # Bitmask for corner connections
+    U, R, D, L = 1, 2, 4, 8
+    JUNCTION = {
+        0: ' ',
+        U: '│', D: '│', U|D: '│',
+        L: '─', R: '─', L|R: '─',
+        U|R: '└', R|D: '┌', D|L: '┐', L|U: '┘',
+        U|D|L: '┤', U|D|R: '├', L|R|U: '┴', L|R|D: '┬',
+        U|R|D|L: '┼',
+    }
+
+    assert scale_x >= 1
+    N = V.shape[0]
+    assert H.shape == (N+1, N) and V.shape == (N, N+1)
+
+    rows = 2*N + 1
+    cols = 2*N*scale_x + 1                 # stretched width
+    canvas = [[' ']*cols for _ in range(rows)]
+
+    def x_corner(c):     # x of corner column c
+        return (2*c) * scale_x
+    def x_between(c,k):  # kth in-between column (1..scale_x) between c and c+1 corners
+        return (2*c) * scale_x + k
+
+    # horizontal edges: fill the stretched band between corners with '─'
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N):
+            if H[r, c]:
+                # previously: for k in range(1, scale_x*2, 2):
+                for k in range(1, scale_x*2):          # 1..(2*scale_x-1), no gaps
+                    canvas[rr][x_between(c, k)] = '─'
+
+    # vertical edges: draw at the corner columns (no horizontal stretching needed)
+    for r in range(N):
+        rr = 2*r + 1
+        for c in range(N+1):
+            if V[r, c]:
+                canvas[rr][x_corner(c)] = '│'
+
+    # junctions at corners
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N+1):
+            m = 0
+            if r > 0   and V[r-1, c]: m |= U
+            if c < N   and H[r, c]:   m |= R
+            if r < N   and V[r, c]:   m |= D
+            if c > 0   and H[r, c-1]: m |= L
+            canvas[rr][x_corner(c)] = JUNCTION[m]
+
+    # centers
+    # ── Centers (now safe for multi-character strings) ──────────────────────
+    # We render center text within the interior span (between corner columns),
+    # centered if it fits; otherwise we truncate to the span width.
+    def put_center_text(rr: int, c: int, text: str):
+        # interior span (exclusive of the corner columns)
+        left  = x_corner(c) + 1
+        right = x_corner(c+1) - 1
+        if right < left:
+            return  # no interior space (shouldn’t happen when scale_x>=1)
+        span_width = right - left + 1
+
+        s = str(text)
+        if len(s) > span_width:
+            s = s[:span_width]  # hard truncate if it doesn't fit
+        # center within the span
+        start = left + (span_width - len(s)) // 2
+        for i, ch in enumerate(s):
+            canvas[rr][start + i] = ch
+
+    if center_char is not None:
+        for r in range(N):
+            rr = 2*r + 1
+            for c in range(N):
+                val = center_char if isinstance(center_char, str) else center_char[r, c]
+                put_center_text(rr, c, '' if val is None else str(val))
+
+    # turn canvas rows into strings
+    art_rows = [''.join(row) for row in canvas]
+
+    if not show_axes:
+        return '\n'.join(art_rows)
+
+    # ── Axes ────────────────────────────────────────────────────────────────
+    gut = max(2, len(str(N-1)))       # left gutter width
+    gutter = ' ' * gut
+    top_tens = list(gutter + ' ' * cols)
+    top_ones = list(gutter + ' ' * cols)
+
+    for c in range(N):
+        xc_center = x_corner(c) + scale_x
+        if N >= 10:
+            top_tens[gut + xc_center] = str((c // 10) % 10)
+        top_ones[gut + xc_center] = str(c % 10)
+
+    # tiny corner labels
+    if gut >= 2:
+        top_tens[gut-2:gut] = list('  ')
+        top_ones[gut-2:gut] = list('  ')
+
+    labeled = []
+    for r, line in enumerate(art_rows):
+        if r % 2 == 1:                     # cell-center row
+            label = str(r//2).rjust(gut)
+        else:
+            label = ' ' * gut
+        labeled.append(label + line)
+
+    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)

puzzle_solver/puzzles/binairo/binairo.py

@@ -0,0 +1,98 @@
+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_next_pos, in_bounds, set_char, get_char, get_neighbors8, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item() in [' ', 'B', 'W'] for c in np.nditer(board)), 'board must contain only space or B'
+        self.board = board
+        self.V, self.H = board.shape
+        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 pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos)
+            if c == 'B':
+                self.model.Add(self.model_vars[pos] == 1)
+            elif c == 'W':
+                self.model.Add(self.model_vars[pos] == 0)
+        # 1. Each row and each column must contain an equal number of white and black circles.
+        for row in range(self.V):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row, self.H)]
+            self.model.Add(lxp.sum(row_vars) == len(row_vars) // 2)
+        for col in range(self.H):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.V)]
+            self.model.Add(lxp.sum(col_vars) == len(col_vars) // 2)
+        # 2. More than two circles of the same color can't be adjacent.
+        for pos in get_all_pos(self.V, self.H):
+            self.disallow_three_in_a_row(pos, Direction.RIGHT)
+            self.disallow_three_in_a_row(pos, Direction.DOWN)
+        # 3. Each row and column is unique. 
+        # a list per row
+        self.force_unique([[self.model_vars[pos] for pos in get_row_pos(row, self.H)] for row in range(self.V)])
+        # a list per column
+        self.force_unique([[self.model_vars[pos] for pos in get_col_pos(col, self.V)] for col in range(self.H)])
+
+    def disallow_three_in_a_row(self, p1: Pos, direction: Direction):
+        p2 = get_next_pos(p1, direction)
+        p3 = get_next_pos(p2, direction)
+        if any(not in_bounds(p, self.V, self.H) for p in [p1, p2, p3]):
+            return
+        self.model.AddBoolOr([
+            self.model_vars[p1],
+            self.model_vars[p2],
+            self.model_vars[p3],
+        ])
+        self.model.AddBoolOr([
+            self.model_vars[p1].Not(),
+            self.model_vars[p2].Not(),
+            self.model_vars[p3].Not(),
+        ])
+
+    def force_unique(self, model_vars: list[list[cp_model.IntVar]]):
+        if not model_vars or len(model_vars) < 2:
+            return
+        m = len(model_vars[0])
+        assert m <= 61, f"Too many cells for binary encoding in int64: m={m}, model_vars={model_vars}"
+
+        codes = []
+        pow2 = [1 << k for k in range(m)]  # weights for bit positions (LSB at index 0)
+        for i, l in enumerate(model_vars):
+            code = self.model.NewIntVar(0, (1 << m) - 1, f"code_{i}")
+            # Sum 2^k * r[k] == code
+            self.model.Add(code == sum(pow2[k] * l[k] for k in range(m)))
+            codes.append(code)
+
+        self.model.AddAllDifferent(codes)
+
+    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 = 'B' if single_res.assignment[pos] == 1 else 'W'
+                set_char(res, pos, c)
+            print('[')
+            for row in res:
+                print("    [ '" + "', '".join(row.tolist()) + "' ],")
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -0,0 +1,130 @@
+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, in_bounds, set_char, get_char, get_neighbors8, Direction, get_next_pos, render_grid
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def factor_pairs(N: int, upper_limit_i: int, upper_limit_j: int):
+    """Return all unique pairs (a, b) such that a * b == N, with a, b <= upper_limit."""
+    if N <= 0 or upper_limit_i <= 0 or upper_limit_j <= 0:
+        return []
+
+    pairs = []
+    i = 1
+    while i * i <= N:
+        if N % i == 0:
+            j = N // i
+            if i <= upper_limit_i and j <= upper_limit_j:
+                pairs.append((i, j))
+            if i != j and j <= upper_limit_i and i <= upper_limit_j:
+                pairs.append((j, i))
+        i += 1
+    return pairs
+
+
+@dataclass
+class Rectangle:
+    active: cp_model.IntVar
+    N: int
+    clue_id: int
+    width: int
+    height: int
+    body: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.array):
+        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.clue_pos: list[Pos] = [pos for pos in get_all_pos(self.V, self.H) if str(get_char(self.board, pos)).isdecimal()]
+        self.clue_pos_to_id: dict[Pos, int] = {pos: i for i, pos in enumerate(self.clue_pos)}
+        self.clue_pos_to_value: dict[Pos, int] = {pos: int(get_char(self.board, pos)) for pos in self.clue_pos}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.rectangles: list[Rectangle] = []
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        self.init_rectangles()
+        # for each position it belongs to exactly 1 clue
+        # instead of iterating over all clues, we only look at the clues that are possible for this position (by looking at the rectangles that contain this position)
+        for pos in get_all_pos(self.V, self.H):
+            possible_clue_here = {rectangle.clue_id for rectangle in self.rectangles if pos in rectangle.body}  # get the clue position for any rectangle that contains this position
+            for possible_clue in possible_clue_here:
+                self.model_vars[(pos, possible_clue)] = self.model.NewBoolVar(f'{pos}:{possible_clue}')
+
+    def init_rectangles(self) -> list[Rectangle]:
+        self.fixed_pos: set[Pos] = set(self.clue_pos)
+        for pos in self.clue_pos:  # for each clue on the board
+            clue_id = self.clue_pos_to_id[pos]
+            clue_num = self.clue_pos_to_value[pos]
+            other_fixed_pos = self.fixed_pos - {pos}
+            for width, height in factor_pairs(clue_num, self.V, self.H):  # for each possible width x height rectangle that can fit the clue
+                # if the digit is at pos and we have a width x height rectangle then we can translate the rectangle "0 to width" to the left and "0 to height" to the top
+                for dx in range(width):
+                    for dy in range(height):
+                        body = {Pos(x=pos.x - dx + i, y=pos.y - dy + j) for i in range(width) for j in range(height)}
+                        if any(not in_bounds(p, self.V, self.H) for p in body):  # a rectangle cannot be out of bounds
+                            continue
+                        if any(p in other_fixed_pos for p in body):  # a rectangle cannot contain a different clue; each clue is 1 rectangle only
+                            continue
+                        rectangle = Rectangle(active=self.model.NewBoolVar(f'{clue_id}'), N=clue_num, clue_id=clue_id, width=width, height=height, body=body)
+                        self.rectangles.append(rectangle)
+
+    def add_all_constraints(self):
+        # each pos has only 1 rectangle active
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne(rectangle.active for rectangle in self.rectangles if pos in rectangle.body)
+        # each pos has only 1 clue active
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne(self.model_vars[(pos, clue_id)] for clue_id in self.clue_pos_to_id.values() if (pos, clue_id) in self.model_vars)
+        # a rectangle being active means all its body ponts to the clue
+        for rectangle in self.rectangles:
+            is_active = rectangle.active
+            for pos in rectangle.body:
+                self.model.Add(self.model_vars[(pos, rectangle.clue_id)] == 1).OnlyEnforceIf(is_active)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for (i, rectangle) in enumerate(self.rectangles):
+                if solver.Value(rectangle.active) == 1:
+                    for pos in rectangle.body:
+                        assignment[pos] = f'id{rectangle.clue_id}:N={rectangle.N}:{rectangle.height}x{rectangle.width}'
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), '', dtype=object)
+            id_board = np.full((self.V, self.H), '', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                cur = single_res.assignment[pos]
+                set_char(id_board, pos, cur)
+                left_pos = get_next_pos(pos, Direction.LEFT)
+                right_pos = get_next_pos(pos, Direction.RIGHT)
+                top_pos = get_next_pos(pos, Direction.UP)
+                bottom_pos = get_next_pos(pos, Direction.DOWN)
+                if left_pos not in single_res.assignment or single_res.assignment[left_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'L')
+                if right_pos not in single_res.assignment or single_res.assignment[right_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'R')
+                if top_pos not in single_res.assignment or single_res.assignment[top_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'U')
+                if bottom_pos not in single_res.assignment or single_res.assignment[bottom_pos] != cur:
+                    set_char(res, pos, get_char(res, pos) + 'D')
+            # print('[')
+            # for row in id_board:
+            #     print('       ', row.tolist(), end=',\n')
+            # print('    ])')
+            print(render_grid(res, center_char=self.board))
+
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -2,7 +2,7 @@ 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
+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_ortools import generic_solve_all, SingleSolution, force_connected_component
 
 
@@ -118,131 +118,7 @@ class Board:
                     continue
                 c = ''.join(sorted(single_res.assignment[pos]))
                 set_char(res, pos, c)
-            print(render_grid(cell_flags=res, center_char=lambda c, r: self.board[r, c] if self.board[r, c] != ' ' else '·'))
+            # replace " " with "·"
+            board = np.where(self.board == ' ', '·', self.board)
+            print(render_grid(cell_flags=res, center_char=board))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=999)
-
-
-
-
-
-def render_grid(cell_flags: np.ndarray = None,
-                H: np.ndarray = None,
-                V: np.ndarray = None,
-                mark_centers: bool = True,
-                center_char: str = '·',
-                show_axes: bool = True,
-                scale_x: int = 2) -> str:
-    """
-    AI generated this because I don't currently care about the details of rendering to the terminal and I did it in a quick and dirty way while the AI made it in a pretty way, and this looks good during my development.
-        cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
-    OR:
-        H: (N+1, N) horizontal edges between corners
-        V: (N,   N+1) vertical edges between corners
-    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
-    """
-    if cell_flags is not None:
-        N = cell_flags.shape[0]
-        H = np.zeros((N+1, N), dtype=bool)
-        V = np.zeros((N, N+1), dtype=bool)
-        for r in range(N):
-            for c in range(N):
-                s = cell_flags[r, c]
-                if 'U' in s: H[r, c]   = True          # edge between (r,c) and (r, c+1) above the cell
-                if 'D' in s: H[r+1, c] = True          # edge below the cell
-                if 'L' in s: V[r, c]   = True          # edge left of the cell
-                if 'R' in s: V[r, c+1] = True          # edge right of the cell
-    assert H is not None and V is not None, 'H and V must be provided'
-    # Bitmask for corner connections
-    U, R, D, L = 1, 2, 4, 8
-    JUNCTION = {
-        0: ' ',
-        U: '│', D: '│', U|D: '│',
-        L: '─', R: '─', L|R: '─',
-        U|R: '└', R|D: '┌', D|L: '┐', L|U: '┘',
-        U|D|L: '┤', U|D|R: '├', L|R|U: '┴', L|R|D: '┬',
-        U|R|D|L: '┼',
-    }
-
-    assert scale_x >= 1
-    N = V.shape[0]
-    assert H.shape == (N+1, N) and V.shape == (N, N+1)
-
-    rows = 2*N + 1
-    cols = 2*N*scale_x + 1                 # stretched width
-    canvas = [[' ']*cols for _ in range(rows)]
-
-    def x_corner(c):     # x of corner column c
-        return (2*c) * scale_x
-    def x_between(c,k):  # kth in-between column (1..scale_x) between c and c+1 corners
-        return (2*c) * scale_x + k
-
-    # horizontal edges: fill the stretched band between corners with '─'
-    for r in range(N+1):
-        rr = 2*r
-        for c in range(N):
-            if H[r, c]:
-                # previously: for k in range(1, scale_x*2, 2):
-                for k in range(1, scale_x*2):          # 1..(2*scale_x-1), no gaps
-                    canvas[rr][x_between(c, k)] = '─'
-
-    # vertical edges: draw at the corner columns (no horizontal stretching needed)
-    for r in range(N):
-        rr = 2*r + 1
-        for c in range(N+1):
-            if V[r, c]:
-                canvas[rr][x_corner(c)] = '│'
-
-    # junctions at corners
-    for r in range(N+1):
-        rr = 2*r
-        for c in range(N+1):
-            m = 0
-            if r > 0   and V[r-1, c]: m |= U
-            if c < N   and H[r, c]:   m |= R
-            if r < N   and V[r, c]:   m |= D
-            if c > 0   and H[r, c-1]: m |= L
-            canvas[rr][x_corner(c)] = JUNCTION[m]
-
-    # centers (help count exact widths/heights)
-    if mark_centers:
-        for r in range(N):
-            rr = 2*r + 1
-            for c in range(N):
-                # center lies midway across the stretched span
-                xc = x_corner(c) + scale_x          # middle-ish; works for any integer scale_x
-                canvas[rr][xc] = center_char if isinstance(center_char, str) else center_char(c, r)
-
-    # turn canvas rows into strings
-    art_rows = [''.join(row) for row in canvas]
-
-    if not show_axes:
-        return '\n'.join(art_rows)
-
-    # ── Axes ────────────────────────────────────────────────────────────────
-    gut = max(2, len(str(N-1)))       # left gutter width
-    gutter = ' ' * gut
-    top_tens = list(gutter + ' ' * cols)
-    top_ones = list(gutter + ' ' * cols)
-
-    for c in range(N):
-        xc_center = x_corner(c) + scale_x
-        if N >= 10:
-            top_tens[gut + xc_center] = str((c // 10) % 10)
-        top_ones[gut + xc_center] = str(c % 10)
-
-    # tiny corner labels
-    if gut >= 2:
-        top_tens[gut-2:gut] = list('  ')
-        top_ones[gut-2:gut] = list('  ')
-
-    labeled = []
-    for r, line in enumerate(art_rows):
-        if r % 2 == 1:                     # cell-center row
-            label = str(r//2).rjust(gut)
-        else:
-            label = ' ' * gut
-        labeled.append(label + line)
-
-    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
-
-