I have been quite interested recently with the new languages Go and rust. Go and rust have some very
nice new features and their design and tooling reflects the standards of this
days. So I have been hacking with go and rust.
I share this piece of rust code that solves sudoku, in the hope it will be
useful to someone. It is not very much optimized as the algorithm is naive, but
the purpose of this code was to get more comfortable with rust.
fn print_grid(g: [Option<i32>; 81]) {
let mut cnt = 0;
let mut line = 0;
for &x in g.iter() {
cnt = cnt + 1;
match x {
Some(i) => print!("{}", i),
None => print!("_"),
}
if cnt == 9 {
line = line + 1;
println!("");
cnt = 0;
if line == 3 {
line = 0;
println!("");
}
} else if cnt % 3 == 0 {
print!(" ");
} else {
print!(" ");
}
}
}
fn check_grid(g: [Option<i32>; 81]) -> bool {
// check lines
for x in 0..9 {
let i = 9 * x;
let val = [i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8];
for v in 0..(val.len() - 1) {
let valv = g[val[v]];
if valv != None {
for c in 1..val.len() {
let valc = g[val[c]];
if valc != None && val[v] != val[c] && valv == valc {
// println!("Block false at {}", x);
return false;
}
}
}
}
}
// check columns
for x in 0..9 {
let val = [x, x + 9, x + 18, x + 27, x + 36, x + 45, x + 54, x + 63, x + 72];
for v in 0..(val.len() - 1) {
let valv = g[val[v]];
if valv != None {
for c in 1..val.len() {
let valc = g[val[c]];
if valc != None && val[v] != val[c] && valv == valc {
// println!("Block false at {}", x);
return false;
}
}
}
}
}
// check blocks
for x in 0..9 {
let mut i = 3 * (x % 3);
if x > 2 {
i = i + 27;
} else if x > 5 {
i = i + 54;
}
let val = [i, i + 1, i + 2, i + 9, i + 10, i + 11, i + 18, i + 19, i + 20];
for v in 0..(val.len() - 1) {
let valv = g[val[v]];
if valv != None {
for c in 1..val.len() {
let valc = g[val[c]];
if valc != None && val[v] != val[c] && valv == valc {
// println!("Block false at {}", x);
return false;
}
}
}
}
}
return true;
}
fn is_grid_complete(g: [Option<i32>; 81]) -> bool {
let mut ret = true;
for &x in g.iter() {
match x {
Some(_) => {}
None => {
ret = false;
break;
}
}
}
return ret;
}
fn clone_grid(g: [Option<i32>; 81]) -> [Option<i32>; 81] {
let mut new_g: [Option<i32>; 81] = [None; 81];
for x in 0..g.len() {
new_g[x] = g[x];
}
return new_g;
}
fn solve_grid(g: [Option<i32>; 81]) -> Option<[Option<i32>; 81]> {
if is_grid_complete(g) {
return Some(g);
}
for x in 0..g.len() {
match g[x] {
Some(_) => {}
None => {
let mut checked: [bool; 9] = [false; 9];
for v in 1..10 {
let mut new_g = clone_grid(g);
new_g[x] = Some(v);
checked[(v - 1) as usize] = true;
if check_grid(new_g) {
match solve_grid(new_g) {
None => {
if checked == [true; 9] {
// the path is a dead end
return None;
} else {
continue;
}
}
Some(gx) => return Some(gx),
}
}
}
if checked == [true; 9] {
// Detected a dead end
return None;
}
}
}
}
return None;
}
fn parse_grid(grid_string: &str) -> [Option<i32>; 81] {
let mut grid = [None; 81];
let mut i = 0;
for s in grid_string.split_whitespace() {
match s {
"_" => {}
val => {
grid[i] = Some(val.parse::<i32>().unwrap());
}
}
i = i + 1;
}
return grid;
}
fn main() {
let grid_string = r#"
1 _ _ _ _ _ _ _ 3
_ 4 _ _ _ 9 2 6 _
_ _ _ 7 _ _ _ 5 4
_ _ _ 1 7 _ 9 _ _
_ _ 2 _ _ _ 6 _ _
_ _ 3 _ 9 5 _ _ _
2 7 _ _ _ 1 _ _ _
_ 8 9 3 _ _ _ 7 _
6 _ _ _ _ _ _ _ 2"#;
let grid: [Option<i32>; 81] = parse_grid(grid_string);
print_grid(grid);
match solve_grid(grid) {
Some(g) => {
println!("Grid complete !");
print_grid(g)
}
None => println!("Couldn't solve the sudoku"),
}
}
You can just, given you have installed rust.
cargo build
Il vise à
permettre de fusionner ses marques-pages d'un poste à l'autre et plus encore,
de manière sécurisée et 
