multi-puzzle-solver 0.9.31__py3-none-any.whl → 1.0.3__py3-none-any.whl

puzzle_solver/puzzles/inertia/tsp.py

@@ -197,7 +197,7 @@ def solve_optimal_walk(
             changed = False
             i = 0
             while i + 3 < len(ns):
-                u, v, w, z = ns[i], ns[i+1], ns[i+2], ns[i+3]
+                u, v, w = ns[i], ns[i+1], ns[i+2]
                 if w == u:  # u->v, v->u
                     before_edges = walk_edges(ns[:i+1])
                     removed_edges = [(u, v), (v, u)]
@@ -235,7 +235,7 @@ def solve_optimal_walk(
         for i in range(N_no_depot):
             gi = state_group[i]
             for j in range(N_no_depot):
-                if i == j: 
+                if i == j:
                     continue
                 gj = state_group[j]
                 if gi != gj:
@@ -244,9 +244,9 @@ def solve_optimal_walk(
         # ring + shift
         INF = 10**12
         succ_in_cluster: Dict[int, int] = {}
-        for g, order in cluster_orders.items():
+        for order in cluster_orders.values():
             k = len(order)
-            if k == 0: 
+            if k == 0:
                 continue
             pred = {}
             for idx, v in enumerate(order):
@@ -327,7 +327,6 @@ def solve_optimal_walk(
 
     best_nodes = None
     best_cost = float('inf')
-    best_reps = None
 
     # initial deterministic order as a baseline
     def shuffled_cluster_orders():
@@ -339,7 +338,7 @@ def solve_optimal_walk(
         return orders
 
     attempts = max(1, restarts)
-    for attempt in range(attempts):
+    for _ in range(attempts):
         cluster_orders = shuffled_cluster_orders()
         for meta in meta_list:
             # print('solve once')
@@ -382,7 +381,6 @@ def solve_optimal_walk(
             if cost < best_cost:
                 best_cost = cost
                 best_nodes = nodes_seq
-                best_reps = reps
 
     if best_nodes is None:
         raise RuntimeError("No solution found.")

puzzle_solver/puzzles/kakuro/kakuro.py

@@ -4,7 +4,7 @@ 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, get_pos, in_bounds, set_char, get_char, get_neighbors8
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_pos, in_bounds, get_char
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 from puzzle_solver.core.utils_visualizer import render_shaded_grid
 

puzzle_solver/puzzles/keen/keen.py

@@ -75,9 +75,9 @@ class Board:
         for col in range(self.N):
             col_vars = [self.model_vars[pos] for pos in get_col_pos(col, self.N)]
             self.model.AddAllDifferent(col_vars)
-    
+
     def constrain_block_results(self):
-        # The digits in each block can be combined to form the number stated in the clue, using the arithmetic operation given in the clue. That is: 
+        # The digits in each block can be combined to form the number stated in the clue, using the arithmetic operation given in the clue. That is:
         for block, (op, result) in self.block_results.items():
             block_vars = [self.model_vars[p] for p in self.get_block_pos(block)]
             add_opcode_constraint(self.model, block_vars, op, result)

puzzle_solver/puzzles/minesweeper/minesweeper.py

@@ -103,7 +103,7 @@ def give_next_guess(board: np.array, mine_count: Optional[int] = None, verbose:
             print(new_garuneed_mine_positions)
             print('-'*10)
         if len(wrong_flag_positions) > 0:
-            print(f"WARNING | "*4 + "WARNING")
+            print("WARNING | "*4 + "WARNING")
             print(f"Found {len(wrong_flag_positions)} wrong flag positions")
             print(wrong_flag_positions)
             print('-'*10)
@@ -120,5 +120,4 @@ def print_board(board: np.array, safe_positions: set[Pos], new_garuneed_mine_pos
             set_char(res, pos, 'M')
         elif get_char(board, pos) == 'F' and pos not in wrong_flag_positions:
             set_char(res, pos, 'F')
-    
-    print(res)
+    print(res)

puzzle_solver/puzzles/nonograms/nonograms.py

@@ -7,8 +7,8 @@ from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 class Board:
     def __init__(self, top: list[list[int]], side: list[list[int]]):
-        assert all(isinstance(i, int) for l in top for i in l), 'top must be a list of lists of integers'
-        assert all(isinstance(i, int) for l in side for i in l), 'side must be a list of lists of integers'
+        assert all(isinstance(i, int) for line in top for i in line), 'top must be a list of lists of integers'
+        assert all(isinstance(i, int) for line in side for i in line), 'side must be a list of lists of integers'
         self.top = top
         self.side = side
         self.V = len(side)
@@ -63,7 +63,7 @@ class Board:
         # Start variables for each run. This is the most critical variable for the problem.
         starts = []
         self.extra_vars[f"{ns}_starts"] = starts
-        for i, c in enumerate(clues):
+        for i in range(len(clues)):
             s = self.model.NewIntVar(0, L, f"{ns}_s[{i}]")
             starts.append(s)
         # Enforce order and >=1 blank between consecutive runs.

puzzle_solver/puzzles/norinori/norinori.py

@@ -3,8 +3,8 @@ from dataclasses import dataclass
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, Shape, get_all_pos, get_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint
+from puzzle_solver.core.utils import Pos, Shape, get_all_pos, get_char, set_char, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 
 
 @dataclass

puzzle_solver/puzzles/nurikabe/nurikabe.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 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, in_bounds, set_char, get_char, polyominoes, Shape, Direction, get_next_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, in_bounds, get_char, polyominoes, Shape, Direction, get_next_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
 
@@ -62,7 +62,7 @@ class Board:
             assert len(hint_shapes) > 0, f'no shapes found for hint {hint_pos} with value {hint_value}'
             self.model.AddExactlyOne([s.is_active for s in hint_shapes])
             self.shapes_on_board.extend(hint_shapes)
-        
+
         # if no shape is active on the spot then it must be black
         for pos in self.get_all_legal_pos():
             shapes_here = [s for s in self.shapes_on_board if pos in s.body]

puzzle_solver/puzzles/pipes/pipes.py

@@ -0,0 +1,81 @@
+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, set_char, get_char, Direction, get_next_pos, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+
+
+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() in ['1', '2L', '2I', '3', '4'] for c in np.nditer(board)), 'board must contain only 1, 2L, 2I, 3, 4. Found:' + str(set(c.item().strip() for c in np.nditer(board)) - set(['1', '2L', '2I', '3', '4']))
+        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):
+            for direction in Direction:
+                mirrored = (get_next_pos(pos, direction), get_opposite_direction(direction))
+                if mirrored in self.model_vars:
+                    self.model_vars[(pos, direction)] = self.model_vars[mirrored]
+                else:
+                    self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.force_position(pos, get_char(self.board, pos).strip())
+        # single connected component
+        self.force_connected_component()
+
+    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.model_vars, is_neighbor=is_neighbor)
+
+    def force_position(self, pos: Pos, value: str):
+        # cells with 1 or 3 or 4 neighbors each only have 1 unique state under rotational symmetry
+        # cells with 2 neighbors can either be a straight line (2I) or curved line (2L)
+        if value == '1':
+            self.model.Add(lxp.sum([self.model_vars[(pos, direction)] for direction in Direction]) == 1)
+        elif value == '2L':
+            self.model.Add(self.model_vars[(pos, Direction.LEFT)] != self.model_vars[(pos, Direction.RIGHT)])
+            self.model.Add(self.model_vars[(pos, Direction.UP)] != self.model_vars[(pos, Direction.DOWN)])
+        elif value == '2I':
+            self.model.Add(self.model_vars[(pos, Direction.LEFT)] == self.model_vars[(pos, Direction.RIGHT)])
+            self.model.Add(self.model_vars[(pos, Direction.UP)] == self.model_vars[(pos, Direction.DOWN)])
+            self.model.Add(self.model_vars[(pos, Direction.UP)] != self.model_vars[(pos, Direction.RIGHT)])
+        elif value == '3':
+            self.model.Add(lxp.sum([self.model_vars[(pos, direction)] for direction in Direction]) == 3)
+        elif value == '4':
+            self.model.Add(lxp.sum([self.model_vars[(pos, direction)] for direction in Direction]) == 4)
+        else:
+            raise ValueError(f'invalid value: {value}')
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment = {}
+            for pos in get_all_pos(self.V, self.H):
+                assignment[pos] = ''
+                for direction in Direction:
+                    if solver.Value(board.model_vars[(pos, direction)]) == 1:
+                        assignment[pos] += direction.name[0]
+            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):
+                set_char(res, pos, single_res.assignment[pos])
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/range/range.py

@@ -2,7 +2,7 @@ import numpy as np
 from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_neighbors4, in_bounds, Direction, get_next_pos, get_char
-from puzzle_solver.core.utils_ortools import and_constraint, or_constraint, generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
 
 
 def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:

puzzle_solver/puzzles/rectangles/rectangles.py

@@ -97,7 +97,7 @@ class Board:
     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):
+            for rectangle in 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}'
@@ -121,10 +121,6 @@ class Board:
                     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))
+            print(render_grid(res, 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

@@ -76,7 +76,7 @@ class Board:
                 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)

puzzle_solver/puzzles/signpost/signpost.py

@@ -65,7 +65,7 @@ class Board:
                 continue
             direction = CHAR_TO_DIRECTION8[c]
             self.constrain_plus_one(pos, direction)
-    
+
     def constrain_plus_one(self, pos: Pos, direction: Direction8):
         beam_res = beam(pos, self.V, self.H, direction)
         is_eq_list = []
@@ -75,7 +75,7 @@ class Board:
             self.model.Add(self.model_vars[p] != self.model_vars[pos] + 1).OnlyEnforceIf(aux.Not())
             is_eq_list.append(aux)
         self.model.Add(lxp.Sum(is_eq_list) == 1)
-    
+
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, str] = {}

puzzle_solver/puzzles/slant/parse_map/parse_map.py

@@ -1,10 +1,10 @@
 """
-    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html and converts them to a json file. 
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html and converts them to a json file.
     Look at the ./input_output/ directory for examples of input images and output json files.
     The output json is used in the test_solve.py file to test the solver.
 """
 
-import json, itertools
+import itertools
 from pathlib import Path
 import numpy as np
 cv = None
@@ -37,9 +37,11 @@ def mean_consecutives(arr):
     sums, counts = [arr[0]], [1]
     for k in arr[1:]:
         if k == sums[-1] + counts[-1]:
-            sums[-1] += k; counts[-1] += 1
+            sums[-1] += k
+            counts[-1] += 1
         else:
-            sums.append(k); counts.append(1)
+            sums.append(k)
+            counts.append(1)
     return np.array(sums)//np.array(counts)
 
 def main(img_path):
@@ -90,7 +92,7 @@ def main(img_path):
 
     # Build KD-like search by grid proximity
     tol = int(cell*0.5)  # max distance from an intersection to accept a circle
-    for (cx, cy, r) in detected:
+    for (cx, cy, _) in detected:
         # find nearest indices
         j = int(np.argmin(np.abs(h_idx - cy)))
         i = int(np.argmin(np.abs(v_idx - cx)))

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -56,7 +56,7 @@ class Board:
         next_pos = get_next_pos(pos, direction)
         if in_bounds(next_pos, self.V, self.H):
             self.cell_borders[(next_pos, get_opposite_direction(direction))] = var
-    
+
     def add_corner_vars(self, cell_border: CellBorder, var: cp_model.IntVar):
         """
         An edge always belongs to two corners. Note that the cell xi,yi has the 4 corners (xi,yi), (xi+1,yi), (xi,yi+1), (xi+1,yi+1). (memorize these 4 coordinates or the function wont make sense)

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -1,5 +1,5 @@
 """
-    This file is a simple helper that parses the images from https://www.puzzle-stitches.com/ and converts them to a json file. 
+    This file is a simple helper that parses the images from https://www.puzzle-stitches.com/ and converts them to a json file.
     Look at the ./input_output/ directory for examples of input images and output json files.
     The output json is used in the test_solve.py file to test the solver.
 """
@@ -26,7 +26,7 @@ def extract_lines(bw):
     # location where the horizontal lines are
     horizontal_idx = np.where(horizontal_means > horizontal_cutoff)[0]
     # print(f"horizontal_idx: {horizontal_idx}")
-    height = len(horizontal_idx)
+    # height = len(horizontal_idx)
     # show_wait_destroy("horizontal", horizontal)  # this has the horizontal lines
 
     rows = vertical.shape[0]
@@ -39,7 +39,7 @@ def extract_lines(bw):
     vertical_cutoff = np.percentile(vertical_means, 50)
     vertical_idx = np.where(vertical_means > vertical_cutoff)[0]
     # print(f"vertical_idx: {vertical_idx}")
-    width = len(vertical_idx)
+    # width = len(vertical_idx)
     # print(f"height: {height}, width: {width}")
     # print(f"vertical_means: {vertical_means}")
     # show_wait_destroy("vertical", vertical)  # this has the vertical lines
@@ -126,7 +126,6 @@ def main(image):
     print(f"vertical_idx: {vertical_idx}")
     arr = np.zeros((height - 1, width - 1), dtype=object)
     output = {'top': arr.copy(), 'left': arr.copy(), 'right': arr.copy(), 'bottom': arr.copy()}
-    target = 200_000
     hists = {'top': {}, 'left': {}, 'right': {}, 'bottom': {}}
     for j in range(height - 1):
         for i in range(width - 1):
@@ -244,4 +243,6 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.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')
+    # main(Path(__file__).parent / 'input_output' / 'heyawake_MTQ6ODQ4LDEzOQ==.png')
+    main(Path(__file__).parent / 'input_output' / 'sudoku_jigsaw.png')
+

puzzle_solver/puzzles/stitches/stitches.py

@@ -77,7 +77,7 @@ class Board:
                 # print(f'{pos}:{direction} must == {neighbor}:{opposite_direction}')
 
         # all blocks connected exactly N times (N usually 1 but can be 2 or 3)
-        for (block_i, block_j), connections in self.block_neighbors.items():
+        for connections in self.block_neighbors.values():
             is_connected_list = []
             for pos_a, direction_a, pos_b, direction_b in connections:
                 v = self.model.NewBoolVar(f'{pos_a}:{direction_a}->{pos_b}:{direction_b}')

puzzle_solver/puzzles/sudoku/sudoku.py

@@ -1,4 +1,5 @@
 from typing import Union, Optional
+from collections import defaultdict
 
 import numpy as np
 from ortools.sat.python import cp_model
@@ -35,32 +36,77 @@ def get_block_pos(i: int, Bv: int, Bh: int) -> list[Pos]:
 
 
 class Board:
-    def __init__(self, board: np.array, block_size: Optional[tuple[int, int]] = None, sandwich: Optional[dict[str, list[int]]] = None, unique_diagonal: bool = False):
+    def __init__(self,
+            board: np.array,
+            constrain_blocks: bool = True,
+            block_size: Optional[tuple[int, int]] = None,
+            sandwich: Optional[dict[str, list[int]]] = None,
+            unique_diagonal: bool = False,
+            jigsaw: Optional[np.array] = None,
+            killer: Optional[tuple[np.array, dict[str, int]]] = None,
+            ):
+        """
+        board: 2d array of characters
+        constrain_blocks: whether to constrain the blocks. If True, each block must contain all numbers from 1 to 9 exactly once.
+        block_size: tuple of block size (vertical, horizontal). If not provided, the block size is the square root of the board size.
+        sandwich: dictionary of sandwich clues (side, bottom). If provided, the sum of the values between 1 and 9 for each row and column is equal to the clue.
+        unique_diagonal: whether to constrain the 2 diagonals to be unique. If True, each diagonal must contain all numbers from 1 to 9 exactly once.
+        killer: tuple of (killer board, killer clues). If provided, the killer board must be a 2d array of ids of the killer blocks. The killer clues must be a dictionary of killer block ids to clues.
+            Each numbers in a killer block must be unique and sum to the clue.
+        """
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
         assert board.shape[0] == board.shape[1], 'board must be square'
         assert all(isinstance(i.item(), str) and len(i.item()) == 1 and (i.item().isalnum() or i.item() == ' ') for i in np.nditer(board)), 'board must contain only alphanumeric characters or space'
         self.board = board
         self.V, self.H = board.shape
-        if block_size is None:
-            B = np.sqrt(self.V)  # block size
-            assert B.is_integer(), 'board size must be a perfect square or provide block_size'
-            Bv, Bh = int(B), int(B)
+        self.L = max(self.V, self.H)
+        self.constrain_blocks = constrain_blocks
+        self.unique_diagonal = unique_diagonal
+        self.sandwich = None
+        self.jigsaw_id_to_pos = None
+        self.killer = None
+
+        if self.constrain_blocks:
+            if block_size is None:
+                B = np.sqrt(self.V)  # block size
+                assert B.is_integer(), 'board size must be a perfect square or provide block_size'
+                Bv, Bh = int(B), int(B)
+            else:
+                Bv, Bh = block_size
+                assert Bv * Bh == self.V, 'block size must be a factor of board size'
+            # can be different in 4x3 for example
+            self.Bv = Bv
+            self.Bh = Bh
+            self.B = Bv * Bh  # block count
         else:
-            Bv, Bh = block_size
-            assert Bv * Bh == self.V, 'block size must be a factor of board size'
-        # can be different in 4x3 for example
-        self.Bv = Bv
-        self.Bh = Bh
-        self.B = Bv * Bh  # block count
+            assert block_size is None, 'cannot set block size if blocks are not constrained'
+
+        if jigsaw is not None:
+            if self.constrain_blocks is not None:
+                print('Warning: jigsaw and blocks are both constrained, are you sure you want to do this?')
+            assert jigsaw.ndim == 2, f'jigsaw must be 2d, got {jigsaw.ndim}'
+            assert jigsaw.shape[0] == self.V and jigsaw.shape[1] == self.H, 'jigsaw must be the same size as the board'
+            assert all(isinstance(i.item(), str) and i.item().isdecimal() for i in np.nditer(jigsaw)), 'jigsaw must contain only digits or space'
+            self.jigsaw_id_to_pos: dict[int, list[Pos]] = defaultdict(list)
+            for pos in get_all_pos(self.V, self.H):
+                v = get_char(jigsaw, pos)
+                if v.isdecimal():
+                    self.jigsaw_id_to_pos[int(v)].append(pos)
+            assert all(len(pos_list) <= self.L for pos_list in self.jigsaw_id_to_pos.values()), 'jigsaw areas cannot be larger than the number of digits'
+
         if sandwich is not None:
             assert set(sandwich.keys()) == set(['side', 'bottom']), 'sandwich must contain only side and bottom'
             assert len(sandwich['side']) == self.H, 'side must be equal to board width'
             assert len(sandwich['bottom']) == self.V, 'bottom must be equal to board height'
             self.sandwich = sandwich
-        else:
-            self.sandwich = None
-        self.unique_diagonal = unique_diagonal
-    
+
+        if killer is not None:
+            assert killer[0].ndim == 2, f'killer board must be 2d, got {killer[0].ndim}'
+            assert killer[0].shape[0] == self.V and killer[0].shape[1] == self.H, 'killer board must be the same size as the board'
+            assert all(isinstance(i.item(), str) and i.item().isdecimal() for i in np.nditer(killer[0])), 'killer board must contain only digits or space'
+            assert set(killer[1].keys()).issubset(set(killer[0].flatten())), f'killer clues must contain all killer block ids, {set(killer[0].flatten()) - set(killer[1].keys())}'
+            self.killer = killer
+
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
 
@@ -69,7 +115,7 @@ class Board:
 
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
-            self.model_vars[pos] = self.model.NewIntVar(1, self.B, f'{pos}')
+            self.model_vars[pos] = self.model.NewIntVar(1, self.L, f'{pos}')
 
     def add_all_constraints(self):
         # some squares are already filled
@@ -86,16 +132,21 @@ class Board:
         for col in range(self.H):
             col_vars = [self.model_vars[pos] for pos in get_col_pos(col, V=self.V)]
             self.model.AddAllDifferent(col_vars)
-        # each block
-        for block_i in range(self.B):
-            block_vars = [self.model_vars[p] for p in get_block_pos(block_i, Bv=self.Bv, Bh=self.Bh)]
-            self.model.AddAllDifferent(block_vars)
+        if self.constrain_blocks:  # each block must contain all numbers from 1 to 9 exactly once
+            for block_i in range(self.B):
+                block_vars = [self.model_vars[p] for p in get_block_pos(block_i, Bv=self.Bv, Bh=self.Bh)]
+                self.model.AddAllDifferent(block_vars)
         if self.sandwich is not None:
             self.add_sandwich_constraints()
         if self.unique_diagonal:
             self.add_unique_diagonal_constraints()
+        if self.jigsaw_id_to_pos is not None:
+            self.add_jigsaw_constraints()
+        if self.killer is not None:
+            self.add_killer_constraints()
 
     def add_sandwich_constraints(self):
+        """Sandwich constraints, enforce that the sum of the values between 1 and 9 for each row and column is equal to the clue."""
         for c, clue in enumerate(self.sandwich['bottom']):
             if clue is None or int(clue) < 0:
                 continue
@@ -113,6 +164,26 @@ class Board:
         anti_diagonal_vars = [self.model_vars[get_pos(x=i, y=self.V-i-1)] for i in range(min(self.V, self.H))]
         self.model.AddAllDifferent(anti_diagonal_vars)
 
+    def add_jigsaw_constraints(self):
+        """All digits in one jigsaw area must be unique."""
+        for pos_list in self.jigsaw_id_to_pos.values():
+            self.model.AddAllDifferent([self.model_vars[p] for p in pos_list])
+
+    def add_killer_constraints(self):
+        """Killer constraints, enforce that the sum of the values in each killer block is equal to the clue and all numbers in a block are unique."""
+        killer_board, killer_clues = self.killer
+        # change clue keys to ints
+        killer_clues = {int(k): v for k, v in killer_clues.items()}
+        killer_id_to_pos = defaultdict(list)
+        for pos in get_all_pos(self.V, self.H):
+            v = get_char(killer_board, pos)
+            if v.isdecimal():
+                killer_id_to_pos[int(v)].append(pos)
+        for killer_id, pos_list in killer_id_to_pos.items():
+            self.model.AddAllDifferent([self.model_vars[p] for p in pos_list])
+            clue = killer_clues[killer_id]
+            self.model.Add(sum([self.model_vars[p] for p in pos_list]) == clue)
+
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, int] = {}

puzzle_solver/puzzles/tents/tents.py

@@ -45,14 +45,14 @@ class Board:
                 if get_char(self.board, neighbour) != ' ':
                     continue
                 self.model.Add(self.is_tent[neighbour] == 0).OnlyEnforceIf(self.is_tent[pos])
-        # - the number of tents in each row and column matches the numbers around the edge of the grid 
+        # - the number of tents in each row and column matches the numbers around the edge of the grid
         for row in range(self.N):
             row_vars = [self.is_tent[pos] for pos in get_row_pos(row, self.N)]
             self.model.Add(lxp.sum(row_vars) == self.sides['side'][row])
         for col in range(self.N):
             col_vars = [self.is_tent[pos] for pos in get_col_pos(col, self.N)]
             self.model.Add(lxp.sum(col_vars) == self.sides['top'][col])
-        # - it is possible to match tents to trees so that each tree is orthogonally adjacent to its own tent (but may also be adjacent to other tents). 
+        # - it is possible to match tents to trees so that each tree is orthogonally adjacent to its own tent (but may also be adjacent to other tents).
         # for each tree, one of the following must be true:
         # a tent on its left has direction RIGHT
         # a tent on its right has direction LEFT

puzzle_solver/puzzles/thermometers/thermometers.py

@@ -47,7 +47,7 @@ class Board:
     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:

puzzle_solver/puzzles/towers/towers.py

@@ -120,7 +120,7 @@ class Board:
         # create a single bool which decides if I can see it or not
         res = self.model.NewBoolVar(name)
         self.model.AddBoolAnd(lits).OnlyEnforceIf(res)
-        self.model.AddBoolOr([res] + [l.Not() for l in lits])
+        self.model.AddBoolOr([res] + [lit.Not() for lit in lits])
         return res
 
     def solve_and_print(self, verbose: bool = True):

puzzle_solver/puzzles/undead/undead.py

@@ -131,7 +131,7 @@ class Board:
             pos = get_pos(x=i, y=self.N-1)
             beam_result = beam(self.board, pos, Direction.UP)
             self.model.add(self.get_var(beam_result) == ground)
-        
+
         if self.monster_count is not None:
             for monster, count in self.monster_count.items():
                 if count == -1:

puzzle_solver/puzzles/unruly/unruly.py

@@ -49,7 +49,7 @@ class Board:
                 continue
             v = 1 if c == 'B' else 0
             self.model.Add(self.model_vars[pos] == v)
-        # no three consecutive squares, horizontally or vertically, are the same colour 
+        # no three consecutive squares, horizontally or vertically, are the same colour
         for pos in get_all_pos(self.V, self.H):
             horiz, vert = get_3_consecutive_horiz_and_vert(pos, self.V, self.H)
             if len(horiz) == 3:

puzzle_solver/puzzles/yin_yang/yin_yang.py

@@ -48,7 +48,7 @@ class Board:
                 continue
             self.model.AddBoolOr([self.B[tl], self.B[tr], self.B[bl], self.B[br]])
             self.model.AddBoolOr([self.B[tl].Not(), self.B[tr].Not(), self.B[bl].Not(), self.B[br].Not()])
-    
+
     def disallow_checkers(self):
         # from https://ralphwaldo.github.io/yinyang_summary.html
         for pos in get_all_pos(self.V, self.H):  # disallow (WB/BW) and (BW/WB)

puzzle_solver/utils/visualizer.py

@@ -152,4 +152,4 @@ if __name__ == '__main__':
     print('max i:', max(nums))
     if all(str(c).isdigit() for c in nums):
         print('skipped:', set(range(int(max(nums)) + 1)) - set(int(i) for i in nums))
-    render_board_image(board, colors)
+    render_board_image(board, colors)