multi-puzzle-solver 1.0.4__py3-none-any.whl → 1.0.7__py3-none-any.whl

puzzle_solver/puzzles/aquarium/aquarium.py

@@ -1,14 +1,13 @@
 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_row_pos, get_col_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors4, get_row_pos, get_col_pos, get_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
-def _sanity_check(board: np.array):
-    # percolation check
-    V = board.shape[0]
-    H = board.shape[1]
+def _sanity_check(board: np.array):  # percolation check
+    V, H = board.shape
     visited: set[Pos] = set()
     finished_islands: set[int] = set()
     def dfs(pos: Pos, target_i: int):
@@ -28,15 +27,13 @@ def _sanity_check(board: np.array):
         assert current_i not in finished_islands, f'island {current_i} already finished'
         dfs(pos, current_i)
         finished_islands.add(current_i)
-
     assert len(finished_islands) == len(set(board.flatten())), 'board is not connected'
 
 class Board:
     def __init__(self, board: np.array, top: np.array, side: np.array):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
         _sanity_check(board)
-        self.V = board.shape[0]
-        self.H = board.shape[1]
+        self.V, self.H = board.shape
         assert top.ndim == 1 and top.shape[0] == self.H, 'top must be a 1d array of length board width'
         assert side.ndim == 1 and side.shape[0] == self.V, 'side must be a 1d array of length board height'
         assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
@@ -69,15 +66,12 @@ class Board:
         for aq_i in self.aquarium_numbers:
             for pos in self.aquariums[aq_i]:
                 self.model.Add(self.is_aquarium_here[pos.y, aq_i] == 1).OnlyEnforceIf(self.model_vars[pos])
-
         # aquarium always start from the bottom
         for aq_i in self.aquarium_numbers:
             for row in self.aquariums_exist_in_row[aq_i]:
-                # (row + 1) is below (row)
-                if row + 1 not in self.aquariums_exist_in_row[aq_i]:
+                if row + 1 not in self.aquariums_exist_in_row[aq_i]:  # (row + 1) is below (row) thus currently (row) is the bottom of the aquarium
                     continue
                 self.model.Add(self.is_aquarium_here[row + 1, aq_i] == 1).OnlyEnforceIf(self.is_aquarium_here[row, aq_i])
-
         for row in range(self.V):
             for aq_i in self.aquarium_numbers:
                 aq_i_row_pos = [pos for pos in self.aquariums[aq_i] if pos.y == row]
@@ -88,7 +82,6 @@ class Board:
                 if len(aq_i_row_pos) > 0:
                     self.model.Add(sum([self.model_vars[pos] for pos in aq_i_row_pos]) == len(aq_i_row_pos)).OnlyEnforceIf(self.is_aquarium_here[row, aq_i])
                     self.model.Add(sum([self.model_vars[pos] for pos in aq_i_row_pos]) == 0).OnlyEnforceIf(self.is_aquarium_here[row, aq_i].Not())
-
         # force the top and side constraints
         for col in range(self.H):
             self.model.Add(sum([self.model_vars[pos] for pos in get_col_pos(col, self.V)]) == self.top[col])
@@ -97,16 +90,8 @@ 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 pos, var in board.model_vars.items():
-                assignment[pos] = solver.value(var)
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.value(board.model_vars[pos]) for pos in board.model_vars.keys()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=str)
-            for pos, val in single_res.assignment.items():
-                c = str(val)
-                set_char(res, pos, c)
-            print(res)
-
+            print(combined_function(self.V, self.H, cell_flags=id_board_to_wall_fn(self.board), center_char=lambda r, c: 'O' if single_res.assignment[get_pos(x=c, y=r)] == 1 else ''))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=99)

puzzle_solver/puzzles/battleships/battleships.py

@@ -1,11 +1,15 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
+from collections import defaultdict
 from typing import Optional
 
 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, get_char, get_neighbors8, get_row_pos, get_col_pos, get_pos, in_bounds
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors8, set_char, get_row_pos, get_col_pos, get_pos, in_bounds
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, or_constraint
 
 @dataclass
 class Ship:
@@ -14,17 +18,16 @@ class Ship:
     top_left_pos: Pos
     body: set[Pos]
     water: set[Pos]
-    mid_body: set[Pos] = field(default_factory=set)
-    top_tip: Optional[Pos] = field(default=None)
-    bottom_tip: Optional[Pos] = field(default=None)
-    left_tip: Optional[Pos] = field(default=None)
-    right_tip: Optional[Pos] = field(default=None)
+    mid_body: set[Pos]
+    top_tip: Optional[Pos]
+    bottom_tip: Optional[Pos]
+    left_tip: Optional[Pos]
+    right_tip: Optional[Pos]
 
 class Board:
     def __init__(self, board: np.array, top: np.array, side: np.array, ship_counts: dict[int, int]):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
-        self.V = board.shape[0]
-        self.H = board.shape[1]
+        self.V, self.H = board.shape
         assert top.ndim == 1 and top.shape[0] == self.H, 'top must be a 1d array of length board width'
         assert side.ndim == 1 and side.shape[0] == self.V, 'side must be a 1d array of length board height'
         assert all((str(c.item()) in [' ', 'W', 'O', 'S', 'U', 'D', 'L', 'R'] for c in np.nditer(board))), 'board must contain only spaces, W, O, S, U, D, L, R'
@@ -46,7 +49,6 @@ class Board:
             self.model_vars[pos] = self.model.NewBoolVar(f'{pos}:is_ship')
 
     def get_ship(self, pos: Pos, length: int, orientation: str) -> Optional[Ship]:
-        assert orientation in ['horizontal', 'vertical'], 'orientation must be horizontal or vertical'
         if length == 1:
             body = {pos}
             top_tip = None
@@ -59,28 +61,22 @@ class Board:
             bottom_tip = None
             left_tip = pos
             right_tip = get_pos(x=pos.x + length - 1, y=pos.y)
-        else:
+        elif orientation == 'vertical':
             body = set(get_pos(x=pos.x, y=y) for y in range(pos.y, pos.y + length))
             left_tip = None
             right_tip = None
             top_tip = pos
             bottom_tip = get_pos(x=pos.x, y=pos.y + length - 1)
+        else:
+            raise ValueError(f'invalid orientation: {orientation}')
         if any(not in_bounds(p, self.V, self.H) for p in body):
             return None
-        water = set(p for pos in body for p in get_neighbors8(pos, self.V, self.H))
-        water -= body
+        water = set(p for pos in body for p in get_neighbors8(pos, self.V, self.H)) - body
         mid_body = body - {top_tip, bottom_tip, left_tip, right_tip} if length > 1 else set()
         return Ship(
-            is_active=self.model.NewBoolVar(f'{pos}:is_active'),
-            length=length,
-            top_left_pos=pos,
-            body=body,
-            water=water,
-            mid_body=mid_body,
-            top_tip=top_tip,
-            bottom_tip=bottom_tip,
-            left_tip=left_tip,
-            right_tip=right_tip,
+            is_active=self.model.NewBoolVar(f'{pos}:is_active'), length=length,
+            top_left_pos=pos, body=body, mid_body=mid_body, water=water,
+            top_tip=top_tip, bottom_tip=bottom_tip, left_tip=left_tip, right_tip=right_tip,
         )
 
     def init_shipyard(self):
@@ -94,60 +90,50 @@ class Board:
                         self.shipyard.append(ship)
 
     def add_all_constraints(self):
-        # ship and cells linked
+        # if a ship is active then all its body is active and all its water is inactive
+        pos_to_ships: dict[Pos, list[Ship]] = defaultdict(list)
         for ship in self.shipyard:
             for pos in ship.body:
                 self.model.Add(self.model_vars[pos] == 1).OnlyEnforceIf(ship.is_active)
+                pos_to_ships[pos].append(ship)
             for pos in ship.water:
                 self.model.Add(self.model_vars[pos] == 0).OnlyEnforceIf(ship.is_active)
-        # constrain the cell to be an OR of all the ships that can be placed at that position
+        # if a pos is active then exactly one ship can be placed at that position
         for pos in get_all_pos(self.V, self.H):
-            or_constraint(self.model, self.model_vars[pos], [ship.is_active for ship in self.shipyard if pos in ship.body])
+            self.model.Add(lxp.Sum([ship.is_active for ship in pos_to_ships[pos]]) == 1).OnlyEnforceIf(self.model_vars[pos])
         # force ship counts
         for length, count in self.ship_counts.items():
-            self.constrain_ship_counts([ship for ship in self.shipyard if ship.length == length], count)
-        # force initial board placement
+            self.model.Add(lxp.Sum([ship.is_active for ship in self.shipyard if ship.length == length]) == count)
+        # force the initial board placement
         for pos in get_all_pos(self.V, self.H):
             c = get_char(self.board, pos)
             if c == 'S':  # single-length ship
-                self.constrain_ship_counts([ship for ship in self.shipyard if ship.length == 1 and ship.top_left_pos == pos], 1)
+                self.model.Add(lxp.Sum([ship.is_active for ship in self.shipyard if ship.length == 1 and ship.top_left_pos == pos]) == 1)
             elif c == 'W':  # water
                 self.model.Add(self.model_vars[pos] == 0)
             elif c == 'O':  # mid-body of a ship
-                self.constrain_ship_counts([ship for ship in self.shipyard if pos in ship.mid_body], 1)
+                self.model.Add(lxp.Sum([ship.is_active for ship in self.shipyard if pos in ship.mid_body]) == 1)
             elif c == 'U':  # top tip of a ship
-                self.constrain_ship_counts([ship for ship in self.shipyard if ship.top_tip == pos], 1)
+                self.model.Add(lxp.Sum([ship.is_active for ship in self.shipyard if ship.top_tip == pos]) == 1)
             elif c == 'D':  # bottom tip of a ship
-                self.constrain_ship_counts([ship for ship in self.shipyard if ship.bottom_tip == pos], 1)
+                self.model.Add(lxp.Sum([ship.is_active for ship in self.shipyard if ship.bottom_tip == pos]) == 1)
             elif c == 'L':  # left tip of a ship
-                self.constrain_ship_counts([ship for ship in self.shipyard if ship.left_tip == pos], 1)
+                self.model.Add(lxp.Sum([ship.is_active for ship in self.shipyard if ship.left_tip == pos]) == 1)
             elif c == 'R':  # right tip of a ship
-                self.constrain_ship_counts([ship for ship in self.shipyard if ship.right_tip == pos], 1)
+                self.model.Add(lxp.Sum([ship.is_active for ship in self.shipyard if ship.right_tip == pos]) == 1)
             elif c == ' ':  # empty cell
                 pass
             else:
                 raise ValueError(f'invalid character: {c}')
-        # force the top and side counts
-        for row in range(self.V):
-            self.model.Add(sum([self.model_vars[p] for p in get_row_pos(row, self.H)]) == self.side[row])
-        for col in range(self.H):
-            self.model.Add(sum([self.model_vars[p] for p in get_col_pos(col, self.V)]) == self.top[col])
-
-    def constrain_ship_counts(self, ships: list[Ship], count: int):
-        self.model.Add(sum([ship.is_active for ship in ships]) == count)
+        for row in range(self.V):  # force the top counts
+            self.model.Add(lxp.Sum([self.model_vars[p] for p in get_row_pos(row, self.H)]) == self.side[row])
+        for col in range(self.H):  # force the side counts
+            self.model.Add(lxp.Sum([self.model_vars[p] for p in get_col_pos(col, self.V)]) == self.top[col])
 
     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)
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=str)
-            for pos, val in single_res.assignment.items():
-                c = 'S' if val == 1 else ' '
-                set_char(res, pos, c)
-            print(res)
-
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/binairo/binairo.py

@@ -6,7 +6,7 @@ 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, get_char, get_row_pos, get_col_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
-from puzzle_solver.core.utils_visualizer import render_shaded_grid
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
@@ -122,5 +122,5 @@ class Board:
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            print(render_shaded_grid(self.V, self.H, lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/black_box/black_box.py

@@ -1,24 +1,10 @@
-from dataclasses import dataclass
-from typing import Optional, Union
-import json
+from typing import Optional
 
-import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_row_pos, get_col_pos, in_bounds, get_opposite_direction, get_next_pos, Direction
-from puzzle_solver.core.utils_ortools import generic_solve_all
-
-
-@dataclass(frozen=True)
-class SingleSolution:
-    assignment: dict[Pos, Union[str, int]]
-    beam_assignments: dict[Pos, list[tuple[int, Pos, Direction]]]
-
-    def get_hashable_solution(self) -> str:
-        result = []
-        for pos, v in self.assignment.items():
-            result.append((pos.x, pos.y, v))
-        return json.dumps(result, sort_keys=True)
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, get_row_pos, get_col_pos, in_bounds, get_opposite_direction, get_next_pos, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
 
 
 class Board:
@@ -33,18 +19,12 @@ class Board:
         else:
             self.T = max_travel_steps
         self.ball_count = ball_count
-
         # top and bottom entry cells are at -1 and V
         self.top_cells = set(get_row_pos(row_idx=-1, H=self.H))
         self.bottom_cells = set(get_row_pos(row_idx=self.V, H=self.H))
         # left and right entry cells are at -1 and H
         self.left_cells = set(get_col_pos(col_idx=-1, V=self.V))
         self.right_cells = set(get_col_pos(col_idx=self.H, V=self.V))
-        # self.top_cells = set([Pos(x=1, y=-1)])
-        # self.bottom_cells = set()
-        # self.left_cells = set()
-        # self.right_cells = set()
-        # print(self.top_cells)
 
         self.top_values = top
         self.right_values = right
@@ -115,12 +95,9 @@ class Board:
             # beam at t=0 is present at beam_id and facing direction
             self.model.Add(self.beam_states[(beam_id, 0, beam_id, direction)] == 1)
             for p in self.get_all_pos_extended():
-                # print(f'beam can be at {p}')
                 for direction in Direction:
                     if (p, direction) != (beam_id, direction):
                         self.model.Add(self.beam_states[(beam_id, 0, p, direction)] == 0)
-        # for p in self.get_all_pos_extended():
-        #     print(f'beam can be at {p}')
 
 
     def constrain_beam_movement(self):
@@ -128,24 +105,18 @@ class Board:
             for entry_pos in self.beam_states_at_t[t].keys():
                 next_state_dict = self.beam_states_at_t[t][entry_pos]
                 self.model.AddExactlyOne(list(next_state_dict.values()))
-                # print('add exactly one constraint for beam id', entry_pos, 'at time', t, next_state_dict.keys(), '\n')
                 if t == self.T - 1:
                     continue
                 for (cell, direction), prev_state in next_state_dict.items():
-                    # print(f'for beam id {entry_pos}, time {t}\nif its at {cell} facing {direction}')
                     self.constrain_next_beam_state(entry_pos, t+1, cell, direction, prev_state)
 
 
     def constrain_next_beam_state(self, entry_pos: Pos, t: int, cur_pos: Pos, direction: Direction, prev_state: cp_model.IntVar):
-        # print(f"constraining next beam state for {entry_pos}, {t}, {cur_pos}, {direction}")
         if cur_pos == "HIT":  # a beam that was "HIT" stays "HIT"
-            # print(f'                                        HIT -> stays HIT')
             self.model.Add(self.beam_states[(entry_pos, t, "HIT", "HIT")] == 1).OnlyEnforceIf(prev_state)
             return
-        # if a beam is outside the board AND it is not facing the board -> it maintains its state
         pos_ahead = get_next_pos(cur_pos, direction)
         if not in_bounds(pos_ahead, self.V, self.H) and not in_bounds(cur_pos, self.V, self.H):
-            # print(f'                                        OUTSIDE BOARD -> beam stays in the same state')
             self.model.Add(self.beam_states[(entry_pos, t, cur_pos, direction)] == 1).OnlyEnforceIf(prev_state)
             return
 
@@ -200,16 +171,6 @@ class Board:
         if not in_bounds(pos_reflected, self.V, self.H):
             pos_reflected = cur_pos
 
-        # debug_states = {
-        #     'if ball head': (entry_pos, t, "HIT", "HIT"),
-        #     'if ball in front-left': (entry_pos, t, get_next_pos(cur_pos, direction_right), direction_right),
-        #     'if ball in front-right': (entry_pos, t, get_next_pos(cur_pos, direction_left), direction_left),
-        #     'if ball in front-left and front-right': (entry_pos, t, get_next_pos(cur_pos, reflected), reflected),
-        #     'if no ball ahead': (entry_pos, t, pos_ahead, direction),
-        # }
-        # for k,v in debug_states.items():
-        #     print(f'                                        {k} -> {v}')
-
         # ball head-on -> beam is "HIT"
         self.model.Add(self.beam_states[(entry_pos, t, "HIT", "HIT")] == 1).OnlyEnforceIf([
             ball_ahead,
@@ -273,35 +234,10 @@ class Board:
         for reflect in reflects:
             self.model.AddExactlyOne([self.beam_states[(reflect, self.T-1, reflect, direction)] for direction in Direction])
 
-
     def solve_and_print(self, verbose: bool = True):
-        count = 0
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            nonlocal count
-            count += 1
-            # if count > 99:
-            #     import sys
-            #     sys.exit(0)
-            assignment = {}
-            for pos in get_all_pos(self.V, self.H):
-                assignment[pos] = solver.value(self.ball_states[pos])
-            beam_assignments = {}
-            # for (entry_pos, t, cell, direction), v in self.beam_states.items():
-            #     if entry_pos not in beam_assignments:
-            #         beam_assignments[entry_pos] = []
-            #     if solver.value(v):  # for every beam it can only be present in one state at a time
-            #         beam_assignments[entry_pos].append((t, cell, direction))
-            # for k,v in beam_assignments.items():
-            #     beam_assignments[k] = sorted(v, key=lambda x: x[0])
-            #     print(k, beam_assignments[k], '\n')
-            # print(beam_assignments)
-            return SingleSolution(assignment=assignment, beam_assignments=beam_assignments)
-
+            return SingleSolution(assignment={pos: solver.Value(self.ball_states[pos]) for pos in get_all_pos(self.V, self.H)})
         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):
-                ball_state = 'O' if single_res.assignment[pos] else ' '
-                res[pos.y][pos.x] = ball_state
-            print(res)
+            print(combined_function(self.V, self.H, center_char=lambda r, c: 'O' if single_res.assignment[get_pos(x=c, y=r)] else ''))
         generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/connect_the_dots/connect_the_dots.py

@@ -3,7 +3,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
-from puzzle_solver.core.utils_visualizer import id_board_to_wall_board, render_grid
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 class Board:
@@ -44,5 +44,7 @@ class Board:
             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(render_grid(id_board_to_wall_board(res), center_char=lambda r, c: res[r][c]))
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(res),
+                center_char=lambda r, c: res[r][c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/filling/filling.py

@@ -3,8 +3,9 @@ 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_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_pos, polyominoes, in_bounds, get_next_pos, Direction
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 @dataclass
@@ -23,8 +24,6 @@ class Board:
         assert all((c == ' ') or (str(c).isdecimal() and 0 <= int(c) <= 9) for c in np.nditer(board)), "board must contain space or digits 0..9"
         self.digits = digits
         self.polyominoes = {d: polyominoes(d) for d in self.digits}
-        # len_shapes = sum(len(shapes) for shapes in self.polyominoes.values())
-        # print(f'total number of shapes: {len_shapes}')
 
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
@@ -33,7 +32,7 @@ class Board:
         self.forced_pos: dict[Pos, int] = {}
 
         self.create_vars()
-        self.constrain_numbers_on_board()
+        self.force_hints()
         self.init_polyominoes_on_board()
         self.add_all_constraints()
 
@@ -42,8 +41,7 @@ class Board:
             for d in self.digits:
                 self.model_vars[(d,pos)] = self.model.NewBoolVar(f'{d}:{pos}')
 
-    def constrain_numbers_on_board(self):
-        # force numbers already on the board
+    def force_hints(self):
         for pos in get_all_pos(self.V, self.H):
             c = get_char(self.board, pos)
             if c.isdecimal():
@@ -51,7 +49,6 @@ class Board:
                 self.forced_pos[pos] = int(c)
 
     def init_polyominoes_on_board(self):
-        # total_count = 0
         for d in self.digits:  # all digits
             digit_count = 0
             for pos in get_all_pos(self.V, self.H):  # translate by shape
@@ -73,45 +70,25 @@ class Board:
                     for p in body:
                         self.body_loc_to_shape[(d,p)].append(shape_on_board)
                     digit_count += 1
-        #             total_count += 1
-        #             if total_count % 1000 == 0:
-        #                 print(f'{total_count} shapes on board')
-        # print(f'total number of shapes on board: {total_count}')
 
     def add_all_constraints(self):
         for pos in get_all_pos(self.V, self.H):
-            # exactly one digit is active at every position
-            self.model.AddExactlyOne(self.model_vars[(d,pos)] for d in self.digits)
-            # exactly one shape is active at that position
-            self.model.AddExactlyOne(s.is_active for d in self.digits for s in self.body_loc_to_shape[(d,pos)])
-        # if a shape is active then all its body is active
-
-        for s_list in self.body_loc_to_shape.values():
+            self.model.AddExactlyOne(self.model_vars[(d,pos)] for d in self.digits)  # exactly one digit is active at every position
+            self.model.AddExactlyOne(s.is_active for d in self.digits for s in self.body_loc_to_shape[(d,pos)])  # exactly one shape is active at that position
+        for s_list in self.body_loc_to_shape.values():  # if a shape is active then all its body is active
             for s in s_list:
                 for p in s.body:
                     self.model.Add(self.model_vars[(s.N,p)] == 1).OnlyEnforceIf(s.is_active)
-
-        # same shape cannot touch
-        for d, s_list in self.digit_to_shapes.items():
+        for d, s_list in self.digit_to_shapes.items():  # same shape cannot touch each other
             for s in s_list:
                 for disallow_pos in s.disallow_same_shape:
                     self.model.Add(self.model_vars[(d,disallow_pos)] == 0).OnlyEnforceIf(s.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 pos in get_all_pos(self.V, self.H):
-                for d in self.digits:
-                    if solver.Value(self.model_vars[(d,pos)]) == 1:
-                        assignment[pos] = d
-                        break
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: d for pos in get_all_pos(self.V, self.H) for d in self.digits if solver.Value(self.model_vars[(d,pos)]) == 1})
         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 = single_res.assignment[pos]
-                set_char(res, pos, c)
-            print(res)
+            res_arr = np.array([[single_res.assignment[get_pos(x=c, y=r)] for c in range(self.H)] for r in range(self.V)])
+            print(combined_function(self.V, self.H, cell_flags=id_board_to_wall_fn(res_arr), center_char=lambda r, c: res_arr[r, c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/galaxies/galaxies.py

@@ -6,7 +6,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, set_char, Direction, get_next_pos, in_bounds, get_opposite_direction, get_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
-from puzzle_solver.core.utils_visualizer import id_board_to_wall_board, render_grid
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:
@@ -104,5 +104,7 @@ class Board:
             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(render_grid(id_board_to_wall_board(res), center_char=lambda r, c: '.' if (Pos(x=c, y=r) in self.prelocated_positions) else ' '))
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(res),
+                center_char=lambda r, c: '.' if (Pos(x=c, y=r) in self.prelocated_positions) else ' '))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)