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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use sudoko::{Sudoku, SudokuSolver, YWing, XYWing, SolvingStrategy};

fn main() {
    println!("Testing Y-Wing and XY-Wing with Specific Pattern Puzzles");
    println!("{}", "=".repeat(65));
    
    // Test puzzle specifically designed to have Y-Wing patterns
    // This is a more advanced puzzle that requires Y-Wing/XY-Wing techniques
    let y_wing_puzzle = "000000000904607000076804100637000000000080000000000249008306070000709800000000000";
    
    println!("Testing Y-Wing Pattern Recognition:");
    println!("{}", "-".repeat(40));
    
    let mut puzzle = Sudoku::from_string(y_wing_puzzle, 9).unwrap();
    println!("Original puzzle:");
    println!("{}", puzzle);
    
    // Apply basic strategies first to set up the Y-Wing pattern
    let mut solver = SudokuSolver::new();
    let basic_strategies = vec![
        Box::new(sudoko::NakedSingles) as Box<dyn SolvingStrategy>,
        Box::new(sudoko::HiddenSingles) as Box<dyn SolvingStrategy>,
    ];
    
    for strategy in basic_strategies {
        while strategy.apply(&mut puzzle) {
            println!("Applied {} strategy", strategy.name());
        }
    }
    
    println!("\nAfter basic strategies:");
    println!("{}", puzzle);
    
    // Now test advanced strategies
    let y_wing = YWing;
    let xy_wing = XYWing;
    
    println!("\nTesting Y-Wing:");
    if y_wing.apply(&mut puzzle) {
        println!("✅ Y-Wing pattern found and applied!");
    } else {
        println!("ℹ️  No Y-Wing patterns found");
    }
    
    println!("\nTesting XY-Wing:");
    if xy_wing.apply(&mut puzzle) {
        println!("✅ XY-Wing pattern found and applied!");
    } else {
        println!("ℹ️  No XY-Wing patterns found");
    }
    
    // Show candidate analysis for better understanding
    println!("\n{}", "=".repeat(65));
    println!("Candidate Analysis for Advanced Strategy Detection:");
    println!("{}", "=".repeat(65));
    
    let mut bi_value_cells = Vec::new();
    for row in 0..puzzle.size {
        for col in 0..puzzle.size {
            if puzzle.get(row, col).unwrap().is_empty() {
                let candidates = puzzle.get_candidates(row, col);
                if candidates.len() == 2 {
                    let values: Vec<u8> = candidates.into_iter().collect();
                    bi_value_cells.push((row, col, values.clone()));
                    println!("Cell ({}, {}): candidates {:?}", row + 1, col + 1, values);
                }
            }
        }
    }
    
    if bi_value_cells.len() >= 3 {
        println!("\n✅ Found {} bi-value cells - good for Y-Wing/XY-Wing patterns!", bi_value_cells.len());
        println!("💡 Bi-value cells are essential for advanced wing strategies");
    } else {
        println!("\n⚠️  Only {} bi-value cells found - need at least 3 for wing patterns", bi_value_cells.len());
    }
    
    // Demonstrate the solving power
    println!("\n{}", "=".repeat(65));
    println!("Complete Solve with All Strategies:");
    println!("{}", "=".repeat(65));
    
    let original = Sudoku::from_string(y_wing_puzzle, 9).unwrap();
    match solver.solve_with_stats(original) {
        Ok((solution, stats)) => {
            println!("✅ Puzzle solved!");
            println!("\nFinal solution:");
            println!("{}", solution);
            
            println!("\n📊 Solver Statistics:");
            println!("• Iterations: {}", stats.iterations);
            println!("• Cells filled: {}", stats.cells_filled);
            println!("• Backtrack steps: {}", stats.backtrack_steps);
            
            println!("\n🧠 Strategies Usage:");
            for (strategy, count) in &stats.strategies_used {
                if *count > 0 {
                    println!("• {}: {} applications", strategy, count);
                }
            }
            
            if stats.strategies_used.iter().any(|(name, count)| 
                (*name == "Y-Wing" || *name == "XY-Wing") && *count > 0) {
                println!("\n🎉 Advanced wing strategies were used in solving!");
            } else {
                println!("\n📝 This puzzle was solved with basic strategies only");
                println!("   Try more challenging puzzles to see wing patterns in action");
            }
        }
        Err(e) => {
            println!("❌ Failed to solve: {}", e);
        }
    }
    
    println!("\n{}", "=".repeat(65));
    println!("🎓 Educational Notes:");
    println!("{}", "=".repeat(65));
    println!("• Y-Wing and XY-Wing are advanced logical techniques");
    println!("• They work by finding chains of bi-value cells (cells with exactly 2 candidates)");
    println!("• These strategies can eliminate candidates without guessing");
    println!("• They're particularly useful in harder puzzles where basic strategies fail");
    println!("• The solver now includes these techniques in its strategy arsenal!");
}