rustoku-lib 0.14.0

Lightning-fast Sudoku solving and generation
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
124
125
126
127
128

use crate::core::TechniqueFlags;

use super::board::Board;

/// Solved board and its solution path.
///
/// Most of the time, users just want to see the solved board, but this struct also
/// provides the sequence of moves that led to the solution, which can be useful for debugging
/// or understanding the solving process.
#[derive(Debug, Clone)]
pub struct Solution {
    /// The solved Sudoku board, represented as a 2D array.
    pub board: Board,
    /// The sequence of moves (row, col, value) made to reach the solution.
    pub solve_path: SolvePath,
}

/// Solve path associated with a solution.
#[derive(Debug, Clone, Default)]
pub struct SolvePath {
    /// The sequence of steps taken to solve the Sudoku puzzle.
    pub steps: Vec<SolveStep>,
}

impl SolvePath {
    pub fn new() -> Self {
        SolvePath { steps: Vec::new() }
    }
}

/// Single step in the solving process.
#[derive(Debug, Clone)]
pub enum SolveStep {
    /// A placement of a single value on the Sudoku board.
    Placement {
        /// The row where the value is placed.
        row: usize,
        /// The column where the value is placed.
        col: usize,
        /// The value being placed in the Sudoku board.
        value: u8,
        /// Flags indicating the technique used for this placement.
        flags: TechniqueFlags,
        /// Position of this step in the solve sequence (0-indexed).
        step_number: u32,
        /// Bitmask of candidate values eliminated by this placement.
        candidates_eliminated: u32,
        /// Count of related cells involved in determining this placement.
        related_cell_count: u8,
        /// Difficulty metric for this step (0-10): 0=trivial, 10=hardest.
        difficulty_point: u8,
    },
    /// A removal of a candidate value from the Sudoku board.
    CandidateElimination {
        /// The row where the candidate is eliminated.
        row: usize,
        /// The column where the candidate is eliminated.
        col: usize,
        /// The value being eliminated as a candidate.
        value: u8,
        /// Flags indicating the technique used for this elimination.
        flags: TechniqueFlags,
        /// Position of this step in the solve sequence (0-indexed).
        step_number: u32,
        /// Bitmask of other candidate values eliminated along with this one.
        candidates_eliminated: u32,
        /// Count of related cells involved in determining this elimination.
        related_cell_count: u8,
        /// Difficulty metric for this step (0-10): 0=trivial, 10=hardest.
        difficulty_point: u8,
    },
}

impl SolveStep {
    /// 4-letter code for the solve step.
    pub fn code(&self) -> &str {
        match self {
            Self::CandidateElimination { .. } => "elim",
            Self::Placement { .. } => "plac",
        }
    }

    /// Returns the step number (position in solve sequence).
    pub fn step_number(&self) -> u32 {
        match self {
            Self::Placement { step_number, .. }
            | Self::CandidateElimination { step_number, .. } => *step_number,
        }
    }

    /// Returns the bitmask of candidates eliminated by this step.
    pub fn candidates_eliminated(&self) -> u32 {
        match self {
            Self::Placement {
                candidates_eliminated,
                ..
            }
            | Self::CandidateElimination {
                candidates_eliminated,
                ..
            } => *candidates_eliminated,
        }
    }

    /// Returns the count of related cells involved in this step.
    pub fn related_cell_count(&self) -> u8 {
        match self {
            Self::Placement {
                related_cell_count, ..
            }
            | Self::CandidateElimination {
                related_cell_count, ..
            } => *related_cell_count,
        }
    }

    /// Returns the difficulty metric for this step (0-10).
    pub fn difficulty_point(&self) -> u8 {
        match self {
            Self::Placement {
                difficulty_point, ..
            }
            | Self::CandidateElimination {
                difficulty_point, ..
            } => *difficulty_point,
        }
    }
}