Struct Solver 

pub struct Solver { /* private fields */ }

A Sudoku solver using logical strategies and optional backtracking.

Implementations

impl Solver

pub fn new() -> Self

Creates a new solver with default strategies.

Examples found in repository

examples/generate.rs (line 4)

fn main() {
    let mut solver = Solver::new();

    for difficulty in [
        Difficulty::Easy,
        Difficulty::Medium,
        Difficulty::Hard,
        Difficulty::Expert,
    ] {
        let puzzle = solver.generate(9, difficulty).unwrap();
        println!("{difficulty:?}:\n{puzzle}");
    }
}

examples/solve.rs (line 12)

fn main() {
    let puzzle = Sudoku::from_string(
        "530070000600195000098000060800060003400803001700020006060000280000419005000080079",
        9,
    )
    .unwrap();

    println!("Puzzle:\n{puzzle}");

    let mut solver = Solver::new();
    let (solution, stats) = solver.solve_with_stats(puzzle).unwrap();

    println!("Solution:\n{solution}");
    println!(
        "Stats: {} iterations, {} backtracks",
        stats.iterations, stats.backtracks
    );
}

examples/basic.rs (line 29)

fn main() {
    // Create empty 9x9 sudoku
    let mut sudoku = Sudoku::new(9);

    // Set some values
    sudoku.set(0, 0, 5).unwrap();
    sudoku.set(0, 1, 3).unwrap();
    sudoku.set(0, 4, 7).unwrap();

    // Check validity
    println!("Valid: {}", sudoku.is_valid());
    println!("Complete: {}", sudoku.is_complete());

    // Get candidates for a cell
    let candidates = sudoku.candidates(0, 2);
    println!("Candidates at (0,2): {:?}", candidates);

    // Check cell state
    match sudoku.get(0, 0) {
        Some(Cell::Filled(v)) => println!("Cell (0,0) = {v}"),
        Some(Cell::Given(v)) => println!("Cell (0,0) = {v} (given)"),
        Some(Cell::Empty) => println!("Cell (0,0) is empty"),
        None => println!("Out of bounds"),
    }

    // Get hint
    let solver = Solver::new();
    if let Some((r, c, val)) = solver.hint(&sudoku) {
        println!("Hint: Place {val} at ({r}, {c})");
    }
}

pub fn with_strategies(strategies: Vec<Box<dyn Strategy>>) -> Self

Creates a solver with custom strategies.

pub fn max_iterations(self, n: usize) -> Self

Sets maximum iterations for logical solving.

pub fn use_backtracking(self, enabled: bool) -> Self

Enables or disables backtracking.

pub fn solve(&mut self, sudoku: Sudoku) -> Result<Sudoku, String>

Solves the puzzle, returning the solution.

pub fn solve_with_stats( &mut self, sudoku: Sudoku, ) -> Result<(Sudoku, Stats), String>

Solves the puzzle, returning solution and statistics.

Examples found in repository

examples/solve.rs (line 13)

fn main() {
    let puzzle = Sudoku::from_string(
        "530070000600195000098000060800060003400803001700020006060000280000419005000080079",
        9,
    )
    .unwrap();

    println!("Puzzle:\n{puzzle}");

    let mut solver = Solver::new();
    let (solution, stats) = solver.solve_with_stats(puzzle).unwrap();

    println!("Solution:\n{solution}");
    println!(
        "Stats: {} iterations, {} backtracks",
        stats.iterations, stats.backtracks
    );
}

pub fn hint(&self, sudoku: &Sudoku) -> Option<(usize, usize, u8)>

Returns a hint: (row, col, value) for the next logical move.

Examples found in repository

examples/basic.rs (line 30)

fn main() {
    // Create empty 9x9 sudoku
    let mut sudoku = Sudoku::new(9);

    // Set some values
    sudoku.set(0, 0, 5).unwrap();
    sudoku.set(0, 1, 3).unwrap();
    sudoku.set(0, 4, 7).unwrap();

    // Check validity
    println!("Valid: {}", sudoku.is_valid());
    println!("Complete: {}", sudoku.is_complete());

    // Get candidates for a cell
    let candidates = sudoku.candidates(0, 2);
    println!("Candidates at (0,2): {:?}", candidates);

    // Check cell state
    match sudoku.get(0, 0) {
        Some(Cell::Filled(v)) => println!("Cell (0,0) = {v}"),
        Some(Cell::Given(v)) => println!("Cell (0,0) = {v} (given)"),
        Some(Cell::Empty) => println!("Cell (0,0) is empty"),
        None => println!("Out of bounds"),
    }

    // Get hint
    let solver = Solver::new();
    if let Some((r, c, val)) = solver.hint(&sudoku) {
        println!("Hint: Place {val} at ({r}, {c})");
    }
}

pub fn count_solutions(&self, sudoku: Sudoku, max: usize) -> usize

Counts solutions up to a maximum.

pub fn generate( &mut self, size: usize, difficulty: Difficulty, ) -> Result<Sudoku, String>

Generates a puzzle of the given size and difficulty.

Examples found in repository

examples/generate.rs (line 12)

fn main() {
    let mut solver = Solver::new();

    for difficulty in [
        Difficulty::Easy,
        Difficulty::Medium,
        Difficulty::Hard,
        Difficulty::Expert,
    ] {
        let puzzle = solver.generate(9, difficulty).unwrap();
        println!("{difficulty:?}:\n{puzzle}");
    }
}

pub fn step(&self, sudoku: &mut Sudoku) -> bool

Applies one strategy step. Returns true if progress was made.

Trait Implementations

impl Default for Solver

fn default() -> Self

Returns the “default value” for a type.