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

{multi_puzzle_solver-1.0.3.dist-info → multi_puzzle_solver-1.0.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-puzzle_solver/__init__.py,sha256=g1rzu3qSDD7oz46Els59z3HCxigzjkkFmoG244ymWro,4966
+puzzle_solver/__init__.py,sha256=j1j97BCo0zoRY1QF6G4248BMWQCYB9TV55hbkbxbDWI,5178
 puzzle_solver/core/utils.py,sha256=XBW5j-IwtJMPMP-ycmY6SqRCM1NOVl5O6UeoGqNj618,8153
 puzzle_solver/core/utils_ortools.py,sha256=ACV3HgKWpEUTt1lpqsPryK1DeZpu7kdWQKEWTLJ2tfs,10384
 puzzle_solver/core/utils_visualizer.py,sha256=ymuhF75uwJbNhN8XVDYEPqw6sPKoqRaaxlhGeHtXpLs,20201
@@ -12,12 +12,13 @@ puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=D-_Oi8OyxsVe1j3dIKYwRlxg
 puzzle_solver/puzzles/chess_range/chess_range.py,sha256=_VHlpUPnqeBstvSIt9RtTV-w2etSK7UrEHg6sErNqtU,21068
 puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=ByDfcRsk5FVmFicpU_DpLoLTJ99Kr___vX4y8ln8_EQ,400
 puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
+puzzle_solver/puzzles/connect_the_dots/connect_the_dots.py,sha256=PvxwoIUDHITxo51uD_JGoFcW33vf0YXTsvlm-gUjMNY,2610
 puzzle_solver/puzzles/dominosa/dominosa.py,sha256=Nmb7pn8U27QJwGy9F3wo8ylqo2_U51OAo3GN2soaNpc,7195
 puzzle_solver/puzzles/filling/filling.py,sha256=R8UIbztk3zNCeNbVClBJoKZHKeHwK_pesjGmMaEEQO0,5536
 puzzle_solver/puzzles/flip/flip.py,sha256=ZngJLUhRNc7qqo2wtNLdMPx4u9w9JTUge27PmdXyDCw,3985
 puzzle_solver/puzzles/flood_it/flood_it.py,sha256=jnCtH1sZIt6K4hbQDSsiM1Cd8FjQNP7cfw2ObUW5fEQ,7948
-puzzle_solver/puzzles/flood_it/parse_map/parse_map.py,sha256=0aw1TbiyxknY2hUAXaP3nXqT6I6mT9BIiERJSCj57xw,8245
-puzzle_solver/puzzles/galaxies/galaxies.py,sha256=36X9jaQfvLIWFkBY1VZH6I59eCDkc77U06NDtKRUECY,5571
+puzzle_solver/puzzles/flood_it/parse_map/parse_map.py,sha256=m7gcpvN3THZdYLowdR_Jwx3HyttaV4K2DqrX_U7uFqU,8209
+puzzle_solver/puzzles/galaxies/galaxies.py,sha256=CTSCNqRR35QT7qBiYdXYu9GLnDJmI9Cfd4C5t4_Kqhg,5535
 puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=XmFqVN_oRfq9AZFWy5ViUJ2Szjgx-srrRkFPJXEEyFo,9358
 puzzle_solver/puzzles/guess/guess.py,sha256=MpyrF6YVu0S1fzX-BllwxGKRGacWJpeLbNn5GetuEyo,10792
 puzzle_solver/puzzles/heyawake/heyawake.py,sha256=L_y44dHArOvO_tDyO35dwkvqdk9eEGItO7n4FDfzNDc,5586
@@ -28,13 +29,13 @@ puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGp
 puzzle_solver/puzzles/kakuro/kakuro.py,sha256=m22Ju-V2BdQl2Ng_pjVUSrxPCtIfqezdpebutURlhvg,4348
 puzzle_solver/puzzles/keen/keen.py,sha256=adSA_pc1m6F6jV7a-PpQxdci1bv4psCNRNt9hMIQdSY,5034
 puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
-puzzle_solver/puzzles/lits/lits.py,sha256=3fPIkhAIUz8JokcfaE_ZM3b0AFEnf5xPzGJ2qnm8SWY,7099
+puzzle_solver/puzzles/lits/lits.py,sha256=-iKgsdfFHA0aOQD8QCjSCXabQaHFaHN5idk6LBvgqRc,7166
 puzzle_solver/puzzles/magnets/magnets.py,sha256=-Wl49JD_PKeq735zQVMQ3XSQX6gdHiY-7PKw-Sh16jw,6474
 puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy3us,2582
 puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=gSdFsuZ-KrwVxgI1HF2q_pYleZ6vBm9jjRTFlboVnLY,5871
 puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
 puzzle_solver/puzzles/nonograms/nonograms.py,sha256=dTKfMwBL49hW3bNd34ETXW7lBRPuQeSPNSCHqHmfybg,6066
-puzzle_solver/puzzles/norinori/norinori.py,sha256=qR7V7NbZRN_ME90R2jL47AkGik1CY6JlAPhLBMXP2Gw,4714
+puzzle_solver/puzzles/norinori/norinori.py,sha256=iwJ2UgQJfx6JLYPQqJHdg1GJ8IBAjMDOtNybhO1jmNc,4968
 puzzle_solver/puzzles/nurikabe/nurikabe.py,sha256=3cbW7X4kAMQK8PkH_t65fzT5cI0O6tWWOqpQUVyuGT4,6501
 puzzle_solver/puzzles/palisade/palisade.py,sha256=T-LXlaLU5OwUQ24QWJWhBUFUktg0qDODTilNmBaXs4I,5014
 puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5omYLChM,6798
@@ -48,7 +49,7 @@ puzzle_solver/puzzles/singles/singles.py,sha256=KKn_Yl-eW874Bl1UmmcqoQ5vhNiO1JbM
 puzzle_solver/puzzles/slant/slant.py,sha256=xF-N4PuXYfx638NP1f1mi6YncIZB4mLtXtdS79XyPbg,6122
 puzzle_solver/puzzles/slant/parse_map/parse_map.py,sha256=8thQxWbq0qjehKb2VzgUP22PGj-9n9djwbt3LGMVLJw,4811
 puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=JpyNQk8K4nUziwWKxSvWEkF1RRBGLnCppCWK1Yf5bt0,7052
-puzzle_solver/puzzles/star_battle/star_battle.py,sha256=IX6w4H3sifN01kPPtrAVRCK0Nl_xlXXSHvJKw8K1EuE,3718
+puzzle_solver/puzzles/star_battle/star_battle.py,sha256=hFV5IKPQDWrIWr50YpiOS9VF2kUScDQpvAGvZKBwuyM,3937
 puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
 puzzle_solver/puzzles/stitches/stitches.py,sha256=bb5JXyclkbKq350MQ9d8AuGteQwSF8knaJ0DU9M92Uw,6515
 puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=b21SQvlnDM6wOl_1iUhZ7X6akpBZoOnj3kEzImBCh8Q,10497
@@ -58,13 +59,14 @@ puzzle_solver/puzzles/tents/tents.py,sha256=jccUXWA7KWAtPKpVJJYNI6masTYWQgx0eitc
 puzzle_solver/puzzles/thermometers/thermometers.py,sha256=bGcVmpPeqL5AJtj8jkK8gYThzv9aGCd_QrWEiYBCA2s,4011
 puzzle_solver/puzzles/towers/towers.py,sha256=OLyTf9nTFR5L32-S_fhVyBmpz4i5YUNJotwOwbw_Fjg,6500
 puzzle_solver/puzzles/tracks/tracks.py,sha256=98xds9SKNqtOLFTRUX_KSMC7XYmZo567LOFeqotVQaM,7237
+puzzle_solver/puzzles/twiddle/twiddle.py,sha256=3gPoeD0DoiiZbIhtptdXFldO_t1QShL6IxkDqJMzjkk,5446
 puzzle_solver/puzzles/undead/undead.py,sha256=IGFQysgoaKZH8rKjqlrkoHsH28ve4_hKor2f0QOsWY0,6596
 puzzle_solver/puzzles/unequal/unequal.py,sha256=ExY2XDCrqROCDpRLfHo8uVr1zuli1QvbCdNCiDhlCac,6978
 puzzle_solver/puzzles/unruly/unruly.py,sha256=xwOUpC12uHbmlDj2guN60VaaHpLr1Y-WmMD5TKeHbZE,3826
 puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=5WixT_7K1HwfQ_dWbuBlQfpU8p69zB2KvOg32XJ8vno,5255
 puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=drjfoHqmFf6U-ZQUwrBbfGINRxDQpgbvy4U3D9QyMhM,6617
 puzzle_solver/utils/visualizer.py,sha256=T2g5We9J3tkhyXWoN2OrIDIJDjt6w5sDd2ksOub0ZI8,6819
-multi_puzzle_solver-1.0.3.dist-info/METADATA,sha256=XxSydqNr_sbU-cmZcqvrI5ODi-vrpx7KuLWNmK9q4W4,350517
-multi_puzzle_solver-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-1.0.3.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-1.0.3.dist-info/RECORD,,
+multi_puzzle_solver-1.0.4.dist-info/METADATA,sha256=JSM2UZgGRSx0oipFuvGnNmKLfXWWfZGxgVWHNtWIH3I,372540
+multi_puzzle_solver-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-1.0.4.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-1.0.4.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -7,6 +7,7 @@ from puzzle_solver.puzzles.bridges import bridges as bridges_solver
 from puzzle_solver.puzzles.chess_range import chess_range as chess_range_solver
 from puzzle_solver.puzzles.chess_range import chess_solo as chess_solo_solver
 from puzzle_solver.puzzles.chess_range import chess_melee as chess_melee_solver
+from puzzle_solver.puzzles.connect_the_dots import connect_the_dots as connect_the_dots_solver
 from puzzle_solver.puzzles.dominosa import dominosa as dominosa_solver
 from puzzle_solver.puzzles.filling import filling as filling_solver
 from puzzle_solver.puzzles.flood_it import flood_it as flood_it_solver
@@ -47,6 +48,7 @@ from puzzle_solver.puzzles.tents import tents as tents_solver
 from puzzle_solver.puzzles.thermometers import thermometers as thermometers_solver
 from puzzle_solver.puzzles.towers import towers as towers_solver
 from puzzle_solver.puzzles.tracks import tracks as tracks_solver
+from puzzle_solver.puzzles.twiddle import twiddle as twiddle_solver
 from puzzle_solver.puzzles.undead import undead as undead_solver
 from puzzle_solver.puzzles.unequal import unequal as unequal_solver
 from puzzle_solver.puzzles.unruly import unruly as unruly_solver
@@ -64,6 +66,7 @@ __all__ = [
     chess_range_solver,
     chess_solo_solver,
     chess_melee_solver,
+    connect_the_dots_solver,
     dominosa_solver,
     filling_solver,
     flood_it_solver,
@@ -104,6 +107,7 @@ __all__ = [
     thermometers_solver,
     towers_solver,
     tracks_solver,
+    twiddle_solver,
     undead_solver,
     unequal_solver,
     unruly_solver,
@@ -111,4 +115,4 @@ __all__ = [
     inertia_image_parser,
 ]
 
-__version__ = '1.0.3'
+__version__ = '1.0.4'

puzzle_solver/puzzles/connect_the_dots/connect_the_dots.py

@@ -0,0 +1,48 @@
+import numpy as np
+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
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.board = board
+        self.V, self.H = board.shape
+        self.unique_colors = set([str(c.item()).strip() for c in np.nditer(board) if str(c.item()).strip() not in ['', '#']])
+        assert all(np.count_nonzero(board == color) >= 2 for color in self.unique_colors), f'each color must appear >= 2 times, got {self.unique_colors}'
+        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 color in self.unique_colors:
+                self.model_vars[(pos, color)] = self.model.NewBoolVar(f'{pos}:{color}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne([self.model_vars[(pos, color)] for color in self.unique_colors])
+            c = get_char(self.board, pos)
+            if c.strip() not in ['', '#']:
+                self.model.Add(self.model_vars[(pos, c)] == 1)
+        for color in self.unique_colors:
+            force_connected_component(self.model, {pos: self.model_vars[(pos, color)] for pos in get_all_pos(self.V, self.H)})
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for (pos, color), var in board.model_vars.items():
+                if solver.Value(var) == 1:
+                    assignment[pos] = color
+            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(render_grid(id_board_to_wall_board(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/flood_it/parse_map/parse_map.py

@@ -75,7 +75,6 @@ def mean_consecutives(arr: np.ndarray) -> np.ndarray:
 def main(image):
     global Image
     global cv
-    import matplotlib.pyplot as plt
     from PIL import Image as Image_module
     import cv2 as cv_module
     Image = Image_module

puzzle_solver/puzzles/galaxies/galaxies.py

@@ -1,110 +1,108 @@
-from collections import defaultdict
-from typing import Iterable, Union
-
-import numpy as np
-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
-
-
-def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:
-    result = defaultdict(list)
-    for pos, arr_id in np.ndenumerate(galaxies):
-        if not arr_id.strip():
-            continue
-        result[arr_id].append(get_pos(x=pos[1], y=pos[0]))
-    return [positions for _, positions in sorted(result.items(), key=lambda x: x[0])]
-
-
-class Board:
-    def __init__(self, galaxies: Union[list[tuple[Pos, ...]], np.ndarray], V: int = None, H: int = None):
-        if isinstance(galaxies, np.ndarray):
-            V, H = galaxies.shape
-            galaxies = parse_numpy(galaxies)
-        else:
-            assert V is not None and H is not None, 'V and H must be provided if galaxies is not a numpy array'
-        assert V >= 1 and H >= 1, 'V and H must be at least 1'
-        assert all(isinstance(galaxy, Iterable) for galaxy in galaxies), 'galaxies must be a list of Iterables'
-        assert all(len(galaxy) in [1, 2, 4] for galaxy in galaxies), 'each galaxy must be exactly 1, 2, or 4 positions'
-        self.V = V
-        self.H = H
-        self.n_galaxies = len(galaxies)
-        self.galaxies = galaxies
-        self.prelocated_positions: set[Pos] = {pos: i for i, galaxy in enumerate(galaxies) for pos in galaxy}
-
-        self.model = cp_model.CpModel()
-        self.pos_to_galaxy: dict[Pos, dict[int, cp_model.IntVar]] = {p: {} for p in get_all_pos(V, H)}  # each position can be part of exactly one out of many possible galaxies
-        self.allocated_pairs: set[tuple[Pos, Pos]] = set()  # each pair is allocated to exactly one galaxy
-
-        self.create_vars()
-        self.add_all_constraints()
-
-    def create_vars(self):
-        for i in range(self.n_galaxies):
-            galaxy = self.galaxies[i]
-            if len(galaxy) == 1:
-                p1, p2 = galaxy[0], galaxy[0]
-            elif len(galaxy) == 2:
-                p1, p2 = galaxy[0], galaxy[1]
-            elif len(galaxy) == 4:
-                p1, p2 = galaxy[0], galaxy[3]  # [1] and [2] will be linked with symmetry
-            self.expand_galaxy(p1, p2, i)
-
-    def expand_galaxy(self, p1: Pos, p2: Pos, galaxy_idx: int):
-        if (p1, p2) in self.allocated_pairs or (p2, p1) in self.allocated_pairs:
-            return
-        if p1 in self.prelocated_positions and self.prelocated_positions[p1] != galaxy_idx:
-            return
-        if p2 in self.prelocated_positions and self.prelocated_positions[p2] != galaxy_idx:
-            return
-        if not in_bounds(p1, self.V, self.H) or not in_bounds(p2, self.V, self.H):
-            return
-        self.bind_pair(p1, p2, galaxy_idx)
-        # symmetrically expand the galaxy until illegal position is hit
-        for direction in [Direction.RIGHT, Direction.UP, Direction.DOWN, Direction.LEFT]:
-            symmetrical_direction = get_opposite_direction(direction)
-            new_p1 = get_next_pos(p1, direction)
-            new_p2 = get_next_pos(p2, symmetrical_direction)
-            self.expand_galaxy(new_p1, new_p2, galaxy_idx)
-
-    def bind_pair(self, p1: Pos, p2: Pos, galaxy_idx: int):
-        assert galaxy_idx not in self.pos_to_galaxy[p1], f'p1={p1} already has galaxy idx={galaxy_idx}'
-        assert galaxy_idx not in self.pos_to_galaxy[p2], f'p2={p2} already has galaxy idx={galaxy_idx}'
-        self.allocated_pairs.add((p1, p2))
-        v1 = self.model.NewBoolVar(f'{p1}:{galaxy_idx}')
-        v2 = self.model.NewBoolVar(f'{p2}:{galaxy_idx}')
-        self.model.Add(v1 == v2)
-        self.pos_to_galaxy[p1][galaxy_idx] = v1
-        self.pos_to_galaxy[p2][galaxy_idx] = v2
-
-    def add_all_constraints(self):
-        galaxy_vars = {}
-        for pos in get_all_pos(self.V, self.H):
-            pos_vars = list(self.pos_to_galaxy[pos].values())
-            self.model.AddExactlyOne(pos_vars)
-            for galaxy_idx, v in self.pos_to_galaxy[pos].items():
-                galaxy_vars.setdefault(galaxy_idx, {})[pos] = v
-        for pos_vars in galaxy_vars.values():
-            force_connected_component(self.model, pos_vars)
-
-
-    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, galaxy_vars in board.pos_to_galaxy.items():
-                for galaxy_idx, var in galaxy_vars.items():  # every pos is part of exactly one galaxy
-                    if solver.Value(var) == 1:
-                        assignment[pos] = galaxy_idx
-                        break
-            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, str(single_res.assignment[pos]).zfill(2))
-            print('[')
-            for row in range(self.V):
-                print('   ', res[row].tolist(), end=',\n')
-            print(']')
-        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)
+from collections import defaultdict
+from typing import Iterable, Union
+
+import numpy as np
+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
+
+
+def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:
+    result = defaultdict(list)
+    for pos, arr_id in np.ndenumerate(galaxies):
+        if not arr_id.strip():
+            continue
+        result[arr_id].append(get_pos(x=pos[1], y=pos[0]))
+    return [positions for _, positions in sorted(result.items(), key=lambda x: x[0])]
+
+
+class Board:
+    def __init__(self, galaxies: Union[list[tuple[Pos, ...]], np.ndarray], V: int = None, H: int = None):
+        if isinstance(galaxies, np.ndarray):
+            V, H = galaxies.shape
+            galaxies = parse_numpy(galaxies)
+        else:
+            assert V is not None and H is not None, 'V and H must be provided if galaxies is not a numpy array'
+        assert V >= 1 and H >= 1, 'V and H must be at least 1'
+        assert all(isinstance(galaxy, Iterable) for galaxy in galaxies), 'galaxies must be a list of Iterables'
+        assert all(len(galaxy) in [1, 2, 4] for galaxy in galaxies), 'each galaxy must be exactly 1, 2, or 4 positions'
+        self.V = V
+        self.H = H
+        self.n_galaxies = len(galaxies)
+        self.galaxies = galaxies
+        self.prelocated_positions: set[Pos] = {pos: i for i, galaxy in enumerate(galaxies) for pos in galaxy}
+
+        self.model = cp_model.CpModel()
+        self.pos_to_galaxy: dict[Pos, dict[int, cp_model.IntVar]] = {p: {} for p in get_all_pos(V, H)}  # each position can be part of exactly one out of many possible galaxies
+        self.allocated_pairs: set[tuple[Pos, Pos]] = set()  # each pair is allocated to exactly one galaxy
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for i in range(self.n_galaxies):
+            galaxy = self.galaxies[i]
+            if len(galaxy) == 1:
+                p1, p2 = galaxy[0], galaxy[0]
+            elif len(galaxy) == 2:
+                p1, p2 = galaxy[0], galaxy[1]
+            elif len(galaxy) == 4:
+                p1, p2 = galaxy[0], galaxy[3]  # [1] and [2] will be linked with symmetry
+            self.expand_galaxy(p1, p2, i)
+
+    def expand_galaxy(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        if (p1, p2) in self.allocated_pairs or (p2, p1) in self.allocated_pairs:
+            return
+        if p1 in self.prelocated_positions and self.prelocated_positions[p1] != galaxy_idx:
+            return
+        if p2 in self.prelocated_positions and self.prelocated_positions[p2] != galaxy_idx:
+            return
+        if not in_bounds(p1, self.V, self.H) or not in_bounds(p2, self.V, self.H):
+            return
+        self.bind_pair(p1, p2, galaxy_idx)
+        # symmetrically expand the galaxy until illegal position is hit
+        for direction in [Direction.RIGHT, Direction.UP, Direction.DOWN, Direction.LEFT]:
+            symmetrical_direction = get_opposite_direction(direction)
+            new_p1 = get_next_pos(p1, direction)
+            new_p2 = get_next_pos(p2, symmetrical_direction)
+            self.expand_galaxy(new_p1, new_p2, galaxy_idx)
+
+    def bind_pair(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        assert galaxy_idx not in self.pos_to_galaxy[p1], f'p1={p1} already has galaxy idx={galaxy_idx}'
+        assert galaxy_idx not in self.pos_to_galaxy[p2], f'p2={p2} already has galaxy idx={galaxy_idx}'
+        self.allocated_pairs.add((p1, p2))
+        v1 = self.model.NewBoolVar(f'{p1}:{galaxy_idx}')
+        v2 = self.model.NewBoolVar(f'{p2}:{galaxy_idx}')
+        self.model.Add(v1 == v2)
+        self.pos_to_galaxy[p1][galaxy_idx] = v1
+        self.pos_to_galaxy[p2][galaxy_idx] = v2
+
+    def add_all_constraints(self):
+        galaxy_vars = {}
+        for pos in get_all_pos(self.V, self.H):
+            pos_vars = list(self.pos_to_galaxy[pos].values())
+            self.model.AddExactlyOne(pos_vars)
+            for galaxy_idx, v in self.pos_to_galaxy[pos].items():
+                galaxy_vars.setdefault(galaxy_idx, {})[pos] = v
+        for pos_vars in galaxy_vars.values():
+            force_connected_component(self.model, pos_vars)
+
+
+    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, galaxy_vars in board.pos_to_galaxy.items():
+                for galaxy_idx, var in galaxy_vars.items():  # every pos is part of exactly one galaxy
+                    if solver.Value(var) == 1:
+                        assignment[pos] = galaxy_idx
+                        break
+            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(render_grid(id_board_to_wall_board(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)

puzzle_solver/puzzles/lits/lits.py

@@ -6,6 +6,7 @@ import numpy as np
 
 from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, in_bounds, Direction, get_next_pos, polyominoes_with_shape_id
 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
 
 
 # a shape on the 2d board is just a set of positions
@@ -128,9 +129,8 @@ class Board:
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=str)
+            res = np.full((self.V, self.H), ' ', dtype=object)
             for pos, val in single_res.assignment.items():
-                c = 'X' if val == 1 else ' '
-                set_char(res, pos, c)
-            print('[\n' + '\n'.join(['  ' + str(res[row].tolist()) + ',' for row in range(self.V)]) + '\n]')
+                set_char(res, pos, '▒▒▒' if val == 1 else ' ')
+            print(render_grid(id_board_to_wall_board(self.board), center_char=lambda r, c: res[r][c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)

puzzle_solver/puzzles/norinori/norinori.py

@@ -5,6 +5,7 @@ from ortools.sat.python import cp_model
 
 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
+from puzzle_solver.core.utils_visualizer import id_board_to_wall_board, render_grid
 
 
 @dataclass
@@ -89,13 +90,14 @@ class Board:
             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 = 'X' if pos in single_res.assignment else ' '
-                set_char(res, pos, c)
-            print('[')
-            for row in res:
-                print("    [ '" + "', '".join(row.tolist()) + "' ],")
-            print(']')
+            # 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 = 'X' if pos in single_res.assignment else ' '
+            #     set_char(res, pos, c)
+            # print('[')
+            # for row in res:
+            #     print("    [ '" + "', '".join(row.tolist()) + "' ],")
+            # print(']')
+            print(render_grid(id_board_to_wall_board(self.board), center_char=lambda r, c: 'X' if (Pos(x=c, y=r) in single_res.assignment) else ' '))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/star_battle/star_battle.py

@@ -3,6 +3,7 @@ from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_neighbors8, get_row_pos, get_col_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import id_board_to_wall_board, render_grid
 
 
 class Board:
@@ -61,11 +62,13 @@ class Board:
             print("Solution found")
             res = np.full((self.V, self.H), ' ', dtype=object)
             for pos in get_all_pos(self.V, self.H):
-                c = '*' if single_res.assignment[pos] == 1 else ' '
-                set_char(res, pos, c)
-            for row in range(self.V):
-                print(res[row].tolist(), end='')
-                if row != self.V - 1:
-                    print(',', end='')
-                print()
+                if single_res.assignment[pos] == 1:
+                    set_char(res, pos, 'X')
+                else:
+                    b = get_char(self.board, pos)
+                    if b == 'B':
+                        set_char(res, pos, ' ')
+                    else:
+                        set_char(res, pos, '.')
+            print(render_grid(id_board_to_wall_board(self.board), 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/twiddle/twiddle.py

@@ -0,0 +1,112 @@
+import time
+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_next_pos, Direction
+
+
+class Board:
+    def __init__(self, board: np.array, time_horizon: int = 10):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only digits'
+        self.board = board
+        self.target_state = np.sort(board, axis=None).reshape(board.shape)
+        self.V, self.H = board.shape
+        self.min_value = int(np.min(board.flatten()))
+        self.max_value = int(np.max(board.flatten()))
+        self.time_horizon = time_horizon
+
+        self.model = cp_model.CpModel()
+        self.state: dict[tuple[Pos, int], cp_model.IntVar] = {}
+        self.decision: dict[int, dict[Pos, cp_model.IntVar]] = {t: {} for t in range(self.time_horizon - 1)}
+
+        self.create_vars()
+        self.add_all_constraints()
+        self.minimize_actions()
+        self.constrain_final_state()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for t in range(self.time_horizon):
+                self.state[pos, t] = self.model.NewIntVar(self.min_value, self.max_value, f'state:{pos}:{t}')
+        for t in range(self.time_horizon - 1):
+            self.decision[t]['NOOP'] = self.model.NewBoolVar(f'decision:NOOP:{t}')
+            for pos in get_all_pos(self.V, self.H):
+                if pos.x == self.H - 1 or pos.y == self.V - 1:
+                    continue
+                self.decision[t][pos] = self.model.NewBoolVar(f'decision:{pos}:{t}')
+
+    def add_all_constraints(self):
+        # one action at most every time
+        for decision_at_t in self.decision.values():
+            self.model.AddExactlyOne(list(decision_at_t.values()))
+        # constrain the state at t=0
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(self.state[pos, 0] == get_char(self.board, pos))
+        # constrain the state dynamics at t=1..T
+        for action_pos in get_all_pos(self.V, self.H):
+            if action_pos.x == self.H - 1 or action_pos.y == self.V - 1:
+                continue
+            self.constrain_state(action_pos)
+        # state does not change if NOOP is chosen
+        for t in range(1, self.time_horizon):
+            noop_var = self.decision[t - 1]['NOOP']
+            for pos in get_all_pos(self.V, self.H):
+                self.model.Add(self.state[pos, t] == self.state[pos, t - 1]).OnlyEnforceIf(noop_var)
+
+    def constrain_state(self, action: Pos):
+        tl = action
+        tr = get_next_pos(tl, Direction.RIGHT)
+        bl = get_next_pos(tl, Direction.DOWN)
+        br = get_next_pos(tr, Direction.DOWN)
+        two_by_two = (tl, tr, br, bl)
+        # lock state outside the two by two
+        for pos in get_all_pos(self.V, self.H):
+            if pos in two_by_two:
+                continue
+            for t in range(1, self.time_horizon):
+                self.model.Add(self.state[pos, t] == self.state[pos, t - 1]).OnlyEnforceIf(self.decision[t - 1][action])
+        # rotate clockwise inside the two by two
+        clockwise = two_by_two[-1:] + two_by_two[:-1]
+        # print('action', action)
+        # print('two_by_two', two_by_two)
+        # print('clockwise', clockwise)
+        for pre_pos, post_pos in zip(clockwise, two_by_two):
+            for t in range(1, self.time_horizon):
+                # print(f'IF self.decision[{t - 1}][{action}] THEN self.state[{post_pos}, {t}] == self.state[{pre_pos}, {t - 1}]')
+                self.model.Add(self.state[post_pos, t] == self.state[pre_pos, t - 1]).OnlyEnforceIf(self.decision[t - 1][action])
+
+    def constrain_final_state(self):
+        final_time = self.time_horizon - 1
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(self.state[pos, final_time] == get_char(self.target_state, pos))
+
+    def minimize_actions(self):
+        flat_decisions = [(var, t+1) for t, tvs in self.decision.items() for pos, var in tvs.items() if pos != 'NOOP']
+        self.model.Minimize(lxp.weighted_sum([p[0] for p in flat_decisions], [p[1] for p in flat_decisions]))
+
+    def solve_and_print(self, verbose: bool = True):
+        solver = cp_model.CpSolver()
+        tic = time.time()
+        solver.solve(self.model)
+        assignment: dict[Pos] = [None for _ in range(self.time_horizon - 1)]
+        if solver.StatusName() in ['OPTIMAL', 'FEASIBLE']:
+            for t, tvs in self.decision.items():
+                for pos, var in tvs.items():
+                    if solver.Value(var) == 1:
+                        assignment[t] = (pos.x, pos.y) if pos != 'NOOP' else 'NOOP'
+            for t in range(self.time_horizon):
+                res_at_t = np.full((self.V, self.H), ' ', dtype=object)
+                for pos in get_all_pos(self.V, self.H):
+                    res_at_t[pos.y][pos.x] = solver.Value(self.state[pos, t])
+                print(f't={t}')
+                print(res_at_t)
+            if verbose:
+                print("Solution found:", assignment)
+        if verbose:
+            print("status:", solver.StatusName())
+            toc = time.time()
+            print(f"Time taken: {toc - tic:.2f} seconds")
+        return assignment
+