185 lines
6.8 KiB
Rust
185 lines
6.8 KiB
Rust
//! Samurai Sudoku.
|
|
//!
|
|
//! https://en.wikipedia.org/wiki/Sudoku#Variants
|
|
//! http://www.samurai-sudoku.com/#ai
|
|
|
|
extern crate puzzle_solver;
|
|
|
|
use puzzle_solver::{Puzzle,Solution,VarToken};
|
|
|
|
const SQRT_SIZE: usize = 3;
|
|
const SIZE: usize = 9;
|
|
const X: i32 = -1;
|
|
type Board = [[i32; SIZE + SQRT_SIZE + SIZE]; SIZE + SQRT_SIZE + SIZE];
|
|
type SudokuVars = Vec<Vec<VarToken>>;
|
|
type SamuraiVars = (SudokuVars, SudokuVars, SudokuVars, SudokuVars, SudokuVars);
|
|
|
|
fn make_sudoku(sys: &mut Puzzle) -> SudokuVars {
|
|
let vars = sys.new_vars_with_candidates_2d(SIZE, SIZE, &[1,2,3,4,5,6,7,8,9]);
|
|
|
|
for y in 0..SIZE {
|
|
sys.all_different(&vars[y]);
|
|
}
|
|
|
|
for x in 0..SIZE {
|
|
sys.all_different(vars.iter().map(|row| &row[x]));
|
|
}
|
|
|
|
for block in 0..SIZE {
|
|
let x0 = SQRT_SIZE * (block % SQRT_SIZE);
|
|
let y0 = SQRT_SIZE * (block / SQRT_SIZE);
|
|
sys.all_different((0..SIZE).map(|n|
|
|
&vars[y0 + (n / SQRT_SIZE)][x0 + (n % SQRT_SIZE)]));
|
|
}
|
|
|
|
vars
|
|
}
|
|
|
|
fn make_samurai_sudoku(board: &Board) -> (Puzzle, SamuraiVars) {
|
|
let set = |sys: &mut Puzzle, var, val| if val != 0 { sys.set_value(var, val) };
|
|
|
|
let mut sys = Puzzle::new();
|
|
let tl = make_sudoku(&mut sys);
|
|
let tr = make_sudoku(&mut sys);
|
|
let bl = make_sudoku(&mut sys);
|
|
let br = make_sudoku(&mut sys);
|
|
let mid = make_sudoku(&mut sys);
|
|
|
|
for y in 0..SQRT_SIZE {
|
|
for x in 0..SQRT_SIZE {
|
|
sys.equals(mid[0 * SQRT_SIZE + y][0 * SQRT_SIZE + x], tl[2 * SQRT_SIZE + y][2 * SQRT_SIZE + x]);
|
|
sys.equals(mid[0 * SQRT_SIZE + y][2 * SQRT_SIZE + x], tr[2 * SQRT_SIZE + y][0 * SQRT_SIZE + x]);
|
|
sys.equals(mid[2 * SQRT_SIZE + y][0 * SQRT_SIZE + x], bl[0 * SQRT_SIZE + y][2 * SQRT_SIZE + x]);
|
|
sys.equals(mid[2 * SQRT_SIZE + y][2 * SQRT_SIZE + x], br[0 * SQRT_SIZE + y][0 * SQRT_SIZE + x]);
|
|
}
|
|
}
|
|
|
|
for y in 0..SIZE {
|
|
for x in 0..SIZE {
|
|
set(&mut sys, tl[y][x], board[y][x]);
|
|
set(&mut sys, tr[y][x], board[y][SIZE + SQRT_SIZE + x]);
|
|
set(&mut sys, bl[y][x], board[SIZE + SQRT_SIZE + y][x]);
|
|
set(&mut sys, br[y][x], board[SIZE + SQRT_SIZE + y][SIZE + SQRT_SIZE + x]);
|
|
set(&mut sys, mid[y][x], board[2 * SQRT_SIZE + y][2 * SQRT_SIZE + x]);
|
|
}
|
|
}
|
|
|
|
(sys, (tl, tr, bl, br, mid))
|
|
}
|
|
|
|
fn print_samurai_sudoku(dict: &Solution, vars: &SamuraiVars) {
|
|
let &(ref tl, ref tr, ref bl, ref br, ref mid) = vars;
|
|
let pr3 = |a: &[VarToken], j| print!(" {}{}{}", dict[a[j]], dict[a[j + 1]], dict[a[j + 2]]);
|
|
let pr9 = |a| { pr3(a, 0); pr3(a, 3); pr3(a, 6); };
|
|
let gap = || print!(" ");
|
|
|
|
for i in 0..SIZE {
|
|
pr9(&tl[i]);
|
|
if 2 * SQRT_SIZE <= i {
|
|
pr3(&mid[i - 2 * SQRT_SIZE], 3);
|
|
} else {
|
|
gap();
|
|
}
|
|
pr9(&tr[i]);
|
|
println!();
|
|
}
|
|
|
|
for i in SQRT_SIZE..(2 * SQRT_SIZE) {
|
|
gap();
|
|
gap();
|
|
pr9(&mid[i]);
|
|
println!();
|
|
}
|
|
|
|
for i in 0..SIZE {
|
|
pr9(&bl[i]);
|
|
if i < SQRT_SIZE {
|
|
pr3(&mid[2 * SQRT_SIZE + i], 3);
|
|
} else {
|
|
gap();
|
|
}
|
|
pr9(&br[i]);
|
|
println!();
|
|
}
|
|
}
|
|
|
|
fn verify_samurai_sudoku(dict: &Solution, vars: &SamuraiVars, expected: &Board) {
|
|
let &(ref tl, ref tr, ref bl, ref br, ref mid) = vars;
|
|
for i in 0..SIZE {
|
|
for j in 0..SIZE {
|
|
assert_eq!(dict[tl[i][j]], expected[i][j]);
|
|
assert_eq!(dict[tr[i][j]], expected[i][SIZE + SQRT_SIZE + j]);
|
|
assert_eq!(dict[bl[i][j]], expected[SIZE + SQRT_SIZE + i][j]);
|
|
assert_eq!(dict[br[i][j]], expected[SIZE + SQRT_SIZE + i][SIZE + SQRT_SIZE + j]);
|
|
assert_eq!(dict[mid[i][j]], expected[2 * SQRT_SIZE + i][2 * SQRT_SIZE + j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn samuraisudoku_easy() {
|
|
let puzzle = [
|
|
[ 0,0,3, 0,0,0, 2,0,0, X,X,X, 0,0,6, 0,0,0, 2,0,0 ],
|
|
[ 0,2,0, 4,0,8, 0,3,0, X,X,X, 0,3,0, 4,0,2, 0,8,0 ],
|
|
[ 8,0,0, 0,9,0, 0,0,4, X,X,X, 8,0,0, 0,1,0, 0,0,4 ],
|
|
|
|
[ 0,5,0, 6,0,1, 0,2,0, X,X,X, 0,2,0, 1,0,7, 0,9,0 ],
|
|
[ 0,0,8, 0,0,0, 6,0,0, X,X,X, 0,0,9, 0,0,0, 8,0,0 ],
|
|
[ 0,7,0, 8,0,4, 0,1,0, X,X,X, 0,8,0, 5,0,9, 0,4,0 ],
|
|
|
|
[ 1,0,0, 0,7,0, 0,0,0, 0,0,0, 0,0,0, 0,7,0, 0,0,5 ],
|
|
[ 0,4,0, 1,0,2, 0,0,0, 0,0,0, 0,0,0, 2,0,8, 0,7,0 ],
|
|
[ 0,0,9, 0,0,0, 0,0,0, 0,6,0, 0,0,0, 0,0,0, 1,0,0 ],
|
|
|
|
[ X,X,X, X,X,X, 0,0,0, 5,0,1, 0,0,0, X,X,X, X,X,X ],
|
|
[ X,X,X, X,X,X, 0,0,9, 0,0,0, 6,0,0, X,X,X, X,X,X ],
|
|
[ X,X,X, X,X,X, 0,0,0, 3,0,6, 0,0,0, X,X,X, X,X,X ],
|
|
|
|
[ 0,0,8, 0,0,0, 0,0,0, 0,7,0, 0,0,0, 0,0,0, 4,0,0 ],
|
|
[ 0,4,0, 5,0,1, 0,0,0, 0,0,0, 0,0,0, 9,0,5, 0,7,0 ],
|
|
[ 6,0,0, 0,2,0, 0,0,0, 0,0,0, 0,0,0, 0,6,0, 0,0,9 ],
|
|
|
|
[ 0,9,0, 1,0,3, 0,7,0, X,X,X, 0,7,0, 5,0,1, 0,9,0 ],
|
|
[ 0,0,5, 0,0,0, 1,0,0, X,X,X, 0,0,3, 0,0,0, 6,0,0 ],
|
|
[ 0,1,0, 6,0,8, 0,9,0, X,X,X, 0,2,0, 8,0,6, 0,1,0 ],
|
|
|
|
[ 5,0,0, 0,7,0, 0,0,6, X,X,X, 7,0,0, 0,2,0, 0,0,5 ],
|
|
[ 0,2,0, 3,0,5, 0,1,0, X,X,X, 0,9,0, 6,0,4, 0,3,0 ],
|
|
[ 0,0,6, 0,0,0, 2,0,0, X,X,X, 0,0,4, 0,0,0, 1,0,0 ] ];
|
|
|
|
let expected = [
|
|
[ 4,9,3, 7,1,5, 2,6,8, X,X,X, 9,4,6, 8,3,5, 2,1,7 ],
|
|
[ 5,2,7, 4,6,8, 9,3,1, X,X,X, 1,3,7, 4,9,2, 5,8,6 ],
|
|
[ 8,6,1, 2,9,3, 5,7,4, X,X,X, 8,5,2, 7,1,6, 9,3,4 ],
|
|
|
|
[ 9,5,4, 6,3,1, 8,2,7, X,X,X, 5,2,4, 1,8,7, 6,9,3 ],
|
|
[ 3,1,8, 9,2,7, 6,4,5, X,X,X, 7,1,9, 6,4,3, 8,5,2 ],
|
|
[ 2,7,6, 8,5,4, 3,1,9, X,X,X, 6,8,3, 5,2,9, 7,4,1 ],
|
|
|
|
[ 1,8,2, 3,7,9, 4,5,6, 7,1,3, 2,9,8, 3,7,1, 4,6,5 ],
|
|
[ 6,4,5, 1,8,2, 7,9,3, 8,5,2, 4,6,1, 2,5,8, 3,7,9 ],
|
|
[ 7,3,9, 5,4,6, 1,8,2, 9,6,4, 3,7,5, 9,6,4, 1,2,8 ],
|
|
|
|
[ X,X,X, X,X,X, 6,4,8, 5,9,1, 7,2,3, X,X,X, X,X,X ],
|
|
[ X,X,X, X,X,X, 3,1,9, 2,8,7, 6,5,4, X,X,X, X,X,X ],
|
|
[ X,X,X, X,X,X, 2,7,5, 3,4,6, 1,8,9, X,X,X, X,X,X ],
|
|
|
|
[ 1,7,8, 9,3,6, 5,2,4, 1,7,8, 9,3,6, 2,8,7, 4,5,1 ],
|
|
[ 2,4,3, 5,8,1, 9,6,7, 4,3,5, 8,1,2, 9,4,5, 3,7,6 ],
|
|
[ 6,5,9, 4,2,7, 8,3,1, 6,2,9, 5,4,7, 1,6,3, 8,2,9 ],
|
|
|
|
[ 8,9,2, 1,4,3, 6,7,5, X,X,X, 6,7,8, 5,3,1, 2,9,4 ],
|
|
[ 4,6,5, 7,9,2, 1,8,3, X,X,X, 1,5,3, 4,9,2, 6,8,7 ],
|
|
[ 3,1,7, 6,5,8, 4,9,2, X,X,X, 4,2,9, 8,7,6, 5,1,3 ],
|
|
|
|
[ 5,8,1, 2,7,9, 3,4,6, X,X,X, 7,6,1, 3,2,8, 9,4,5 ],
|
|
[ 9,2,4, 3,6,5, 7,1,8, X,X,X, 2,9,5, 6,1,4, 7,3,8 ],
|
|
[ 7,3,6, 8,1,4, 2,5,9, X,X,X, 3,8,4, 7,5,9, 1,6,2 ] ];
|
|
|
|
let (mut sys, vars) = make_samurai_sudoku(&puzzle);
|
|
let dict = sys.solve_any().expect("solution");
|
|
print_samurai_sudoku(&dict, &vars);
|
|
verify_samurai_sudoku(&dict, &vars, &expected);
|
|
println!("samuraisudoku_easy: {} guesses", sys.num_guesses());
|
|
}
|