Struct sudoku::Sudoku

pub struct Sudoku(_);

The main structure exposing all the functionality of the library Sudokus can be parsed in either the line format or the block format

line format:

..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3.. optional comment

block format:

__3_2_6__ optional comment
9__3_5__1 another comment
__18_64__
__81_29__
7_______8
__67_82__
__26_95__
8__2_3__9
__5_1_3__

alternatively also with field delimiters

__3|_2_|6__ optional comment
9__|3_5|__1 another comment
__1|8_6|4__
---+---+--- comment: "-----------", i.e. '-' 11 times is also allowed
__8|1_2|9__          but has to be consistent
7__|___|__8
__6|7_8|2__
---+---+---
__2|6_9|5__
8__|2_3|__9
__5|_1_|3__

'_', '.' and '0' are accepted interchangeably as unfilled cells

Methods

impl Sudoku

pub fn generate_filled() -> Self

Generate a random, solved sudoku

pub fn generate_unique() -> Self

Generate a random, uniquely solvable sudoku The puzzles are minimal in that no cell can be removed without losing uniquess of solution Most puzzles generated by this are easy

pub fn generate_unique_from(sudoku: Sudoku) -> Self

Generate a random, uniqely solvable sudoku that has the same solution as the given sudoku by removing the contents of some of its cells. The puzzles are minimal in that no cell can be removed without losing uniquess of solution. Most puzzles generated by this from solved sudokus are easy.

If the source sudoku is invalid or has multiple solutions, it will be returned as is.

pub fn from_bytes_slice(bytes: &[u8]) -> Result<Sudoku, ()>

Creates a sudoku from a byte slice. All numbers must be below 10. Empty cells are denoted by 0, clues by the numbers 1-9. The slice must be of length 81.

pub fn from_bytes(bytes: [u8; 81]) -> Result<Sudoku, ()>

Creates a sudoku from a byte array. All numbers must be below 10. Empty cells are denoted by 0, clues by the numbers 1-9.

pub fn from_str_line(s: &str) -> Result<Sudoku, LineFormatParseError>

Reads a sudoku in the line format Stops parsing after the first sudoku

pub fn from_str_block(s: &str) -> Result<Sudoku, BlockFormatParseError>

Reads a sudoku in the block format with or without field delimiters Stops parsing after the first sudoku

pub fn from_str_block_permissive(s: &str) -> Result<Sudoku, NotEnoughRows>

Reads a sudoku in a variety of block formats, applying few constraints. '_', '.' and '0' are treated as empty cells. '1' to '9' as clues. Each line needs to have 9 valid cells. Lines that don't contain 9 valid entries are ignored. Stops parsing after the first sudoku. Due to the lax format rules, the only failure that can occur is that there are not enough rows.

pub fn solve(&mut self) -> bool

Try to find a solution to the sudoku and fill it in. Return true if a solution was found. This is a convenience interface. Use one of the other solver methods for better error handling

pub fn solve_one(self) -> Option<Sudoku>

Find a solution to the sudoku. If multiple solutions exist, it will not find them and just stop at the first. Return None if no solution exists.

pub fn solve_unique(self) -> Option<Sudoku>

Solve sudoku and return solution if solution is unique.

pub fn count_at_most(self, limit: usize) -> usize

Counts number of solutions to sudoku up to limit This solves the sudoku but does not return the solutions which allows for slightly faster execution.

pub fn is_uniquely_solvable(self) -> bool

Checks whether sudoku has one and only one solution. This solves the sudoku but does not return the solution which allows for slightly faster execution.

pub fn solve_at_most(self, limit: usize) -> Vec<Sudoku>

Solve sudoku and return the first limit solutions it finds. If less solutions exist, return only those. Return None if no solution exists. No specific ordering of solutions is promised. It can change across versions.

pub fn solve_at_most_buffer(     self,     target: &mut [[u8; 81]],     limit: usize ) -> usize

Counts number of solutions to sudoku up to limit and writes any solution found into target up to its capacity. Additional solutions will be counted but not saved. No specific ordering of solutions is promised. It can change across versions. This is primarily meant for C FFI.

pub fn is_solved(&self) -> bool

Check whether the sudoku is solved.

pub fn n_clues(&self) -> u8

Returns number of filled cells

pub fn shuffle(&mut self)

Perform various transformations that create a different but equivalent sudoku. The transformations preserve the sudoku's validity and the amount of solutions as well a the applicability of solution strategies. Shuffling can be used to quickly generate sudokus of the same difficulty as a given sudoku.

Transformations that are applied:

• Relabel numbers, e.g. swap all 1s and all 3s (9! permutations)
• Permute rows within their band and columns within their stack (3!3 * 2 permutations)
• Permute stacks and bands (3!2 permutations)
• Transpose the board, i.e. mirror it along the diagonal (2 permutations) The remaining rotations as well as mirrorings can be produced by a combination with the other transformations

This results in a total of up to 2 * 9! * 3!8 = 1,218,998,108,160 permutations Less permutations exists if the sudoku is symmetrical in respect to some combinations of the transformations The vast majority of sudokus do not have any such symmetries (automorphisms). The highest number of automorphisms a sudoku can have is 648 and ~99.99% of all non-equivalent sudokus have only 1, the identity transformation.

pub fn iter(&self) -> Map<Iter<'a, u8>, fn(_: &u8) -> Option<u8>>

Returns an Iterator over sudoku, going from left to right, top to bottom

pub fn to_bytes(self) -> [u8; 81]

Returns a byte array for the sudoku. Empty cells are denoted by 0, clues by the numbers 1-9.

pub fn to_str_line(&self) -> SudokuLine

Returns a representation of the sudoku in line format that can be printed and which derefs into a &str

use sudoku::Sudoku;

let mut grid = [0; 81];
grid[3] = 5;
let sudoku = Sudoku::from_bytes(grid).unwrap();
let line = sudoku.to_str_line(); // :SudokuLine
println!("{}", line);

let line_str: &str = &line;
assert_eq!(
    "...5.............................................................................",
    line_str
);

Trait Implementations

impl PartialEq<Sudoku> for Sudoku

fn eq(&self, other: &Sudoku) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Clone for Sudoku

fn clone(&self) -> Sudoku

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Sudoku

impl Ord for Sudoku

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl Eq for Sudoku

impl PartialOrd<Sudoku> for Sudoku

The ordering is lexicographical in the cells of the sudoku going from left to right, top to bottom

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Display for Sudoku

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for Sudoku

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for Sudoku

fn hash<H>(&self, state: &mut H) where     H: Hasher,

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].