Generator is much more efficient.

607011 · 607011 · commit 7986b2549694 · 2025-04-01T21:09:01.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,6 +11,7 @@ categories = ["games"]
 
 [dependencies]
 rand = { version = "^0.9" }
+clap = { version = "^4.5", features = ["derive"] }
 eframe = { version = "^0.31", features = [
     "persistence",
     "glow",
diff --git a/src/gen/gen.rs b/src/gen/gen.rs
@@ -1,30 +1,57 @@
-use rate_my_sudoku::Sudoku;
+use clap::Parser;
+use rate_my_sudoku::generator::{FillAlgorithm, SudokuGenerator};
 use std::io::Write;
 use std::sync::mpsc;
 use std::thread;
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug"))
-        .format_timestamp(None)
-        .format_target(false)
-        .init();
+#[derive(clap::Parser, Debug)]
+#[command(name = "sudokugen", version = "0.1.0", about = "Generate Sudokus")]
+struct Cli {
+    #[arg(short, long, default_value_t = FillAlgorithm::DiagonalThinOut, help = "Algorithm to use for generating Sudoku puzzles")]
+    algorithm: FillAlgorithm,
+    #[arg(
+        short,
+        long,
+        default_value_t = 24,
+        value_name = "N",
+        help = "Number of filled cells in the Sudoku puzzle"
+    )]
+    max_filled_cells: usize,
+    #[arg(short, long, help = "Number of threads to use for generation")]
+    num_threads: Option<usize>,
+    #[arg(short, long, help = "Enable logging")]
+    logging: Option<String>,
+}
 
-    let default_filled_cells: usize = 20;
-    let args: Vec<String> = std::env::args().collect();
-    let filled_cells = if args.len() > 1 {
-        args[1].parse::<usize>().unwrap_or(default_filled_cells)
-    } else {
-        default_filled_cells
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let cli = Cli::parse();
+    if let Some(ref filter) = cli.logging {
+        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or(filter))
+            .format_timestamp(None)
+            .format_target(false)
+            .init();
     };
-    let thread_count = num_cpus::get();
+    let max_filled_cells = cli.max_filled_cells;
+    let fill_algorithm = cli.algorithm;
+    let thread_count = match cli.num_threads {
+        Some(num_threads) => num_threads,
+        None => num_cpus::get(),
+    };
+    log::info!(
+        "Starting Sudoku generation with {} threads using the fill algorithm {} for a maximum of {} filled cells ...",
+        thread_count,
+        fill_algorithm,
+        max_filled_cells
+    );
+
     let (tx, rx) = mpsc::channel();
     let stdout_mutex = std::sync::Mutex::new(());
-
     for _ in 0..thread_count {
         let tx = tx.clone();
         thread::spawn(move || {
             loop {
-                if let Some(sudoku) = Sudoku::generate_incrementally(filled_cells) {
+                let generator = SudokuGenerator::new(fill_algorithm, max_filled_cells);
+                for sudoku in generator {
                     let sudoku_string = sudoku.to_board_string();
                     let mut computer_sudoku = sudoku.clone();
                     let mut sudoku = sudoku;
@@ -39,7 +66,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                             );
                         }
                     } else {
-                        tx.send((-1.0, sudoku_string)).unwrap();
+                        tx.send((f64::INFINITY, sudoku_string)).unwrap();
                     }
                 }
             }
@@ -52,7 +79,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Print results from the channel
     while let Ok((difficulty, sudoku_string)) = rx.recv() {
         let _guard = stdout_mutex.lock().unwrap();
-        if difficulty > 0.0 {
+        if difficulty != f64::INFINITY {
             println!("{:6.2} {}", difficulty, sudoku_string);
         } else {
             println!("     ? {}", sudoku_string);
diff --git a/src/generator.rs b/src/generator.rs
@@ -1,131 +1,154 @@
 use crate::{EMPTY, Sudoku};
 use rand::prelude::ThreadRng;
-use rand::seq::SliceRandom;
+use rand::{Rng, seq::SliceRandom};
+use std::fmt::{Display, Formatter};
 
-impl Sudoku {
-    fn count_solutions(sudoku: &mut Sudoku, count: &mut usize, max_count: usize) -> bool {
-        if *count >= max_count {
-            return true; // Early return if we already found enough solutions
+#[derive(clap::ValueEnum, Debug, Clone, Copy)]
+pub enum FillAlgorithm {
+    DiagonalThinOut,
+    Incremental,
+}
+
+impl Display for FillAlgorithm {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FillAlgorithm::DiagonalThinOut => write!(f, "diagonal_thin_out"),
+            FillAlgorithm::Incremental => write!(f, "incremental"),
         }
-        let mut found_empty = false;
-        let mut empty_row = 0;
-        let mut empty_col = 0;
-        'find_empty: for row in 0..9 {
-            for col in 0..9 {
-                if sudoku.board[row][col] == EMPTY {
-                    empty_row = row;
-                    empty_col = col;
-                    found_empty = true;
-                    break 'find_empty;
+    }
+}
+
+pub struct SudokuGenerator {
+    fill_algorithm: FillAlgorithm,
+    max_filled_cells: usize,
+    solutions_iter: std::vec::IntoIter<[[u8; 9]; 9]>,
+    rng: ThreadRng,
+}
+
+/// A generator for Sudoku puzzles.
+/// This struct implements the Iterator trait, allowing it to be used in a loop
+/// to generate Sudoku puzzles with a specified number of filled cells.
+/// The `max_filled_cells` parameter specifies how many cells should remain filled
+/// at most. The minimum number of cells to fill is 17 (God's Number).
+impl SudokuGenerator {
+    pub fn new(fill_algorithm: FillAlgorithm, max_filled_cells: usize) -> Self {
+        let mut rng = rand::rng();
+        let solutions = match fill_algorithm {
+            FillAlgorithm::DiagonalThinOut => {
+                let mut all_digits: Vec<u8> = (1..=9).collect();
+                let mut sudoku = Sudoku::new();
+                // Fill the 3 diagonal boxes (top-left, middle, bottom-right)
+                for box_idx in 0..3 {
+                    let start_row = box_idx * 3;
+                    let start_col = box_idx * 3;
+                    all_digits.shuffle(&mut rng);
+                    for (i, &num) in all_digits.iter().enumerate() {
+                        sudoku.board[start_row + i / 3][start_col + i % 3] = num;
+                    }
                 }
+                sudoku.all_solutions()
             }
-        }
-        // If no empty cell is found, we have a solution
-        if !found_empty {
-            *count += 1;
-            return *count >= max_count;
-        }
-        // Try each possible value
-        for num in 1..=9 {
-            if !sudoku.can_place(empty_row, empty_col, num) {
-                continue;
-            }
-            // Place and recurse
-            sudoku.board[empty_row][empty_col] = num;
-            if Self::count_solutions(sudoku, count, max_count) {
-                return true;
+            FillAlgorithm::Incremental => {
+                if let Some(solution) = Self::generate_incrementally(max_filled_cells) {
+                    vec![solution.board]
+                } else {
+                    Vec::new()
+                }
             }
-            // Backtrack
-            sudoku.board[empty_row][empty_col] = EMPTY;
+        };
+        SudokuGenerator {
+            fill_algorithm,
+            max_filled_cells,
+            solutions_iter: solutions.into_iter(),
+            rng,
         }
-        false
     }
+}
 
-    /// Generate a Sudoku puzzle by filling cells incrementally.
-    /// This method fills cells one by one, ensuring that the
-    /// puzzle has a unique solution.
-    /// The `filled_cells` parameter specifies how many cells should remain filled.
-    /// The minimum number of cells to fill is 17.
-    /// If the puzzle cannot be generated with the specified number of filled cells,
-    /// it returns `None`.
-    pub fn generate_incrementally(filled_cells: usize) -> Option<Self> {
-        let min_cells_to_fill = 17;
-        let mut rng = rand::rng();
-        let mut all_digits: Vec<u8> = (1..=9).collect();
-        let mut sudoku = Sudoku::new();
-        let mut filled = 0;
-        let mut positions: Vec<(usize, usize)> = (0..9)
-            .flat_map(|row| (0..9).map(move |col| (row, col)))
-            .collect();
-        positions.shuffle(&mut rng);
+impl Iterator for SudokuGenerator {
+    type Item = Sudoku;
 
-        // Fill cells one by one
-        while filled < filled_cells.max(min_cells_to_fill) && !positions.is_empty() {
-            let (row, col) = positions.pop().unwrap();
-            if sudoku.board[row][col] != EMPTY {
-                continue;
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.fill_algorithm {
+            FillAlgorithm::DiagonalThinOut => {
+                while let Some(board) = self.solutions_iter.next() {
+                    let sudoku = Sudoku::from_board(board);
+                    // Try to reduce this solution
+                    if let Some(reduced) = self.try_reduce_puzzle(sudoku) {
+                        return Some(reduced);
+                    }
+                }
             }
-            // Shuffle the digits for each attempt
-            all_digits.shuffle(&mut rng);
-            // Try placing each digit
-            for &digit in &all_digits {
-                if sudoku.can_place(row, col, digit) {
-                    sudoku.board[row][col] = digit;
-                    filled += 1;
-                    break;
+            FillAlgorithm::Incremental => {
+                if let Some(sudoku) = Self::generate_incrementally(self.max_filled_cells) {
+                    return Some(sudoku);
                 }
             }
         }
-        if filled == filled_cells.max(min_cells_to_fill) {
-            sudoku.original_board = sudoku.board;
-            let mut solution_count = 0;
-            Self::count_solutions(&mut sudoku, &mut solution_count, 2);
-            if solution_count != 1 {
-                return None;
+        None
+    }
+}
+
+impl SudokuGenerator {
+    fn try_reduce_puzzle(&mut self, mut sudoku: Sudoku) -> Option<Sudoku> {
+        let mut available_cells: Vec<(usize, usize)> = (0..9)
+            .flat_map(|row| (0..9).map(move |col| (row, col)))
+            .collect();
+        available_cells.shuffle(&mut self.rng);
+        let mut filled_cells = 81;
+        while let Some((row, col)) = available_cells.pop() {
+            let cell = sudoku.board[row][col];
+            sudoku.board[row][col] = EMPTY;
+            if Sudoku::has_unique_solution(&sudoku) {
+                filled_cells -= 1;
+                if filled_cells <= self.max_filled_cells {
+                    sudoku.original_board = sudoku.board;
+                    return Some(sudoku);
+                }
+            } else {
+                // Cell removal created a Sudoku with multiple solutions,
+                // so we need to backtrack
+                sudoku.board[row][col] = cell;
             }
-            return Some(sudoku);
         }
-
         None
     }
 
-    /// Generate a new Sudoku puzzle with a given number of filled cells.
-    /// This method fills the diagonal boxes first, then solves the Sudoku,
-    /// and finally removes cells while ensuring a unique solution.
+    /// Generate a Sudoku puzzle by filling cells incrementally.
+    /// This method fills cells one by one, ensuring that the
+    /// puzzle has a unique solution.
     /// The `filled_cells` parameter specifies how many cells should remain filled.
-    pub fn generate_diagonal_fill(filled_cells: usize) -> Option<Self> {
+    /// The minimum number of cells to fill is 17.
+    /// If the puzzle cannot be generated with the specified number of filled cells,
+    /// it returns `None`.
+    pub fn generate_incrementally(max_cells_to_fill: usize) -> Option<Sudoku> {
+        assert!(
+            max_cells_to_fill <= 81,
+            "Filled cells must be less than or equal to 81"
+        );
+        assert!(
+            max_cells_to_fill >= 17,
+            "Filled cells must be greater than or equal to 17"
+        );
         let mut rng: ThreadRng = rand::rng();
-        let mut all_digits: Vec<u8> = (1..=9).collect();
         let mut sudoku = Sudoku::new();
-        // Fill the 3 diagonal boxes (top-left, middle, bottom-right)
-        for box_idx in 0..3 {
-            let start_row = box_idx * 3;
-            let start_col = box_idx * 3;
-            // Fill the box with a shuffled sequence of 1-9
-            all_digits.shuffle(&mut rng);
-            for (i, &num) in all_digits.iter().enumerate() {
-                sudoku.board[start_row + i / 3][start_col + i % 3] = num;
-            }
-        }
-        sudoku.solve_by_backtracking();
-        // Get all filled cells that haven't been removed yet
         let mut available_cells: Vec<(usize, usize)> = (0..9)
             .flat_map(|row| (0..9).map(move |col| (row, col)))
             .collect();
         available_cells.shuffle(&mut rng);
-        available_cells.truncate(81 - filled_cells);
-        while let Some((row, col)) = available_cells.pop() {
-            sudoku.board[row][col] = EMPTY;
-            // Check if the puzzle still has a unique solution
-            let mut test_sudoku = sudoku.clone();
-            let mut solution_count = 0;
-            Self::count_solutions(&mut test_sudoku, &mut solution_count, 2);
-            if solution_count != 1 {
+        let mut filled = 0;
+        while filled < max_cells_to_fill {
+            if let Some((row, col)) = available_cells.pop() {
+                let digit = rng.random_range(1..=9);
+                if sudoku.can_place(row, col, digit) {
+                    sudoku.board[row][col] = digit;
+                    filled += 1;
+                }
+            } else {
                 return None;
             }
         }
-        // Store the current board state as the original board string
         sudoku.original_board = sudoku.board;
-        Some(sudoku)
+        Sudoku::has_unique_solution(&sudoku).then_some(sudoku)
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
