sudoko 0.6.0

A comprehensive Sudoku solving library with multiple strategies, puzzle generation, and WebAssembly support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use sudoko::{Sudoku, SudokuSolver};

fn main() {
    // Example 9x9 Sudoku puzzle
    let puzzle_str = "530070000600195000098000060800060003400803001700020006060000280000419005000080079";
    
    println!("=== Basic Sudoku Solving Example ===\n");
    
    // Parse the puzzle
    let puzzle = match Sudoku::from_string(puzzle_str, 9) {
        Ok(p) => p,
        Err(e) => {
            eprintln!("Error parsing puzzle: {}", e);
            return;
        }
    };
    
    println!("Original puzzle:");
    println!("{}", puzzle);
    
    // Create solver and solve with statistics
    let mut solver = SudokuSolver::new();
    
    match solver.solve_with_stats(puzzle) {
        Ok((solution, stats)) => {
            println!("Solution found!");
            println!("{}", solution);
            
            println!("\n=== Solver Statistics ===");
            println!("Iterations: {}", stats.iterations);
            println!("Cells filled: {}", stats.cells_filled);
            println!("Backtrack steps: {}", stats.backtrack_steps);
            
            if !stats.strategies_used.is_empty() {
                println!("\nStrategies used:");
                for (strategy, count) in stats.strategies_used {
                    println!("  {}: {} times", strategy, count);
                }
            }
            
            // Validate the solution
            if solver.validate_solution(&solution) {
                println!("\n✓ Solution is valid and complete!");
            } else {
                println!("\n✗ Solution is invalid!");
            }
        }
        Err(e) => {
            eprintln!("Failed to solve puzzle: {}", e);
        }
    }
    
    // Example with different sizes
    println!("\n=== 4x4 Sudoku Example ===\n");
    
    let small_puzzle_str = "1.3..2.43.1..4.2";
    let small_puzzle = Sudoku::from_string(small_puzzle_str, 4).unwrap();
    
    println!("4x4 puzzle:");
    println!("{}", small_puzzle);
    
    match solver.solve(small_puzzle) {
        Ok(solution) => {
            println!("4x4 solution:");
            println!("{}", solution);
        }
        Err(e) => {
            eprintln!("Failed to solve 4x4 puzzle: {}", e);
        }
    }
}