# Generate_sudokuCSV_V2.1.py # # Description: # This script generates a high-quality, diverse dataset of Sudoku puzzles and their solutions. # # Key Logic of V2.1: # 1. **Generates Unique Base Solutions:** Uses a randomized backtracking algorithm to # create a set of unique solved grids. # 2. **Intentionally Creates Symmetries:** For each unique base grid, it generates all 8 # of its symmetries (rotations and mirrors) and adds them to the dataset. # 3. **Removes ONLY Literal Duplicates:** After generating all grids, it performs a # deduplication step that ONLY removes grids that are 100% identical, block-for-block. # This ensures that rotated and mirrored versions of a grid are KEPT in the final set. # 4. **Creates Puzzles:** A unique puzzle with a different pattern of empty cells is # created for each final, unique grid. import numpy as np import pandas as pd import random import sys import os from tqdm import tqdm class SudokuGeneratorV2_1: """ A class to generate a Sudoku dataset that includes symmetric variations but removes only literal duplicates. """ def __init__(self, num_base_solutions: int, difficulty: float): if not (0.1 <= difficulty <= 0.99): raise ValueError("Difficulty must be between 0.1 and 0.99") self.num_base_solutions = num_base_solutions self.difficulty = difficulty def _find_empty(self, grid): """Finds the next empty cell (value 0) in the grid.""" for i in range(9): for j in range(9): if grid[i, j] == 0: return (i, j) return None def _is_valid(self, grid, pos, num): """Checks if placing a number in a position is valid.""" row, col = pos # Check row, column, and 3x3 box if num in grid[row, :] or num in grid[:, col]: return False box_x, box_y = col // 3, row // 3 if num in grid[box_y*3:box_y*3+3, box_x*3:box_x*3+3]: return False return True def _backtrack_solve(self, grid): """A randomized backtracking solver to generate a filled grid.""" find = self._find_empty(grid) if not find: return True else: row, col = find nums = list(range(1, 10)) random.shuffle(nums) for num in nums: if self._is_valid(grid, (row, col), num): grid[row, col] = num if self._backtrack_solve(grid): return True grid[row, col] = 0 return False def _get_symmetries(self, grid): """Generates all 8 symmetries of a grid (4 rotations and their mirrors).""" symmetries = [] current_grid = grid.copy() for _ in range(4): symmetries.append(current_grid) symmetries.append(np.flipud(current_grid)) # Horizontal mirror current_grid = np.rot90(current_grid) return symmetries def _create_puzzle_from_solution(self, solution_grid): """Removes a percentage of cells from a solved grid to create a puzzle.""" puzzle = solution_grid.copy().flatten() num_to_remove = int(81 * self.difficulty) indices = list(range(81)) random.shuffle(indices) puzzle[indices[:num_to_remove]] = 0 return puzzle.reshape((9, 9)) def generate_and_save(self, output_path: str): """Main orchestrator method.""" print("--- Sudoku Generator V2.1 ---") # --- Step 1: Generate unique base solutions --- print(f"Generating {self.num_base_solutions} random base solutions...") base_solutions = [] # Use a simple set of strings to avoid generating duplicate bases upfront seen_base_strings = set() with tqdm(total=self.num_base_solutions, desc="Generating Bases") as pbar: while len(base_solutions) < self.num_base_solutions: grid = np.zeros((9, 9), dtype=int) self._backtrack_solve(grid) grid_str = "".join(map(str, grid.flatten())) if grid_str not in seen_base_strings: seen_base_strings.add(grid_str) base_solutions.append(grid) pbar.update(1) # --- Step 2: Expand base solutions with all 8 symmetries --- print("Applying all 8 symmetries to each base solution to create the full candidate set...") all_candidate_solutions = [] for grid in tqdm(base_solutions, desc="Applying Symmetries"): all_candidate_solutions.extend(self._get_symmetries(grid)) print(f"Generated {len(all_candidate_solutions)} total solutions (including potential literal duplicates).") # --- Step 3: Deduplicate ONLY literal, block-for-block duplicates --- print("Removing literal duplicates, keeping all rotations and mirrors...") final_solutions = [] seen_literal_strings = set() grid_to_string = lambda g: "".join(map(str, g.flatten())) for grid in tqdm(all_candidate_solutions, desc="Deduplicating Literals"): grid_str = grid_to_string(grid) if grid_str not in seen_literal_strings: seen_literal_strings.add(grid_str) final_solutions.append(grid) print(f"Found {len(final_solutions)} unique grids after removing literal duplicates.") print(f"({len(all_candidate_solutions) - len(final_solutions)} literal duplicates were removed).") # --- Step 4: Create a puzzle for each unique solution --- print(f"Creating a puzzle for each of the {len(final_solutions)} final grids...") puzzles_and_solutions = [] for solution_grid in tqdm(final_solutions, desc="Creating Puzzles"): puzzle_grid = self._create_puzzle_from_solution(solution_grid) puzzles_and_solutions.append({ 'quizzes': grid_to_string(puzzle_grid), 'solutions': grid_to_string(solution_grid) }) # --- Step 5: Save to CSV --- print(f"\nSaving {len(puzzles_and_solutions)} puzzles to '{output_path}'...") df = pd.DataFrame(puzzles_and_solutions) # Shuffle the final dataset so symmetric puzzles aren't clumped together df = df.sample(frac=1).reset_index(drop=True) df.to_csv(output_path, index=False) print("\n--- Generation Complete ---") print(f"Final dataset contains {len(df)} puzzles.") if __name__ == '__main__': # --- Configuration --- # Number of unique base solutions to generate before applying symmetries. # The final dataset size will be approximately this number * 8. NUM_BASE_SOLUTIONS = 200 # The fraction of cells to be empty in the puzzle. DIFFICULTY = 0.7 # The output file name. OUTPUT_FILE = 'sudoku.csv' # --- Execution --- if os.path.exists(OUTPUT_FILE): overwrite = input(f"WARNING: '{OUTPUT_FILE}' already exists. Overwrite? (y/n): ").lower() if overwrite != 'y': print("Generation cancelled by user.") sys.exit(0) generator = SudokuGeneratorV2_1( num_base_solutions=NUM_BASE_SOLUTIONS, difficulty=DIFFICULTY ) generator.generate_and_save(OUTPUT_FILE)