puzzle-solver 0.4.1

Solve logic puzzles by describing their constraints. Suitable for puzzles such as Sudoku and Kakuro.
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

//! Hidato.
//!
//! https://en.wikipedia.org/wiki/Hidato

extern crate puzzle_solver;

use puzzle_solver::{Puzzle,Solution,Val,VarToken};

const WIDTH: usize = 8;
const HEIGHT: usize = 8;
const NA: i32 = -1;
type Board = [[i32; WIDTH]; HEIGHT];

fn make_hidato(board: &Board) -> (Puzzle, Vec<VarToken>) {
    let mut sys = Puzzle::new();
    let mut pos = Vec::new();
    let mut count = 0;

    for y in 0..HEIGHT {
        for x in 0..WIDTH {
            if board[y][x] != NA {
                pos.push((WIDTH * y + x) as Val);
                count = count + 1;
            }
        }
    }

    let vars = sys.new_vars_with_candidates_1d(count, &pos);

    for y in 0..HEIGHT {
        for x in 0..WIDTH {
            if board[y][x] > 0 {
                let idx = (board[y][x] - 1) as usize;
                sys.set_value(vars[idx], (WIDTH * y + x) as Val);
            }
        }
    }

    sys.all_different(&vars);

    let stride = WIDTH as Val;
    let deltas = [
        -stride - 1, -stride, -stride + 1,
        -1, 1,
        stride - 1, stride, stride + 1 ];

    for i in 1..vars.len() {
        let step = sys.new_var_with_candidates(&deltas);
        sys.equals(vars[i], vars[i - 1] + step);
    }

    (sys, vars)
}

fn print_hidato(dict: &Solution, vars: &Vec<VarToken>) {
    let mut board = [[NA; WIDTH]; HEIGHT];

    for (idx, &var) in vars.iter().enumerate() {
        let x = (dict[var] as usize) % WIDTH;
        let y = (dict[var] as usize) / WIDTH;
        board[y][x] = (idx as i32) + 1;
    }

    for y in 0..HEIGHT {
        for x in 0..WIDTH {
            if board[y][x] == NA {
                print!(" --");
            } else {
                print!(" {:2}", board[y][x]);
            }
        }
        println!();
    }
}

fn verify_hidato(dict: &Solution, vars: &Vec<VarToken>, expected: &Board) {
    for (idx, &var) in vars.iter().enumerate() {
        let x = (dict[var] as usize) % WIDTH;
        let y = (dict[var] as usize) / WIDTH;
        assert_eq!((idx as i32) + 1, expected[y][x]);
    }
}

#[test]
fn hidato_wikipedia() {
    let puzzle = [
        [  0, 33, 35,  0,  0, NA, NA, NA ],
        [  0,  0, 24, 22,  0, NA, NA, NA ],
        [  0,  0,  0, 21,  0,  0, NA, NA ],
        [  0, 26,  0, 13, 40, 11, NA, NA ],
        [ 27,  0,  0,  0,  9,  0,  1, NA ],
        [ NA, NA,  0,  0, 18,  0,  0, NA ],
        [ NA, NA, NA, NA,  0,  7,  0,  0 ],
        [ NA, NA, NA, NA, NA, NA,  5,  0 ] ];

    let expected = [
        [ 32, 33, 35, 36, 37, NA, NA, NA ],
        [ 31, 34, 24, 22, 38, NA, NA, NA ],
        [ 30, 25, 23, 21, 12, 39, NA, NA ],
        [ 29, 26, 20, 13, 40, 11, NA, NA ],
        [ 27, 28, 14, 19,  9, 10,  1, NA ],
        [ NA, NA, 15, 16, 18,  8,  2, NA ],
        [ NA, NA, NA, NA, 17,  7,  6,  3 ],
        [ NA, NA, NA, NA, NA, NA,  5,  4 ] ];

    let (mut sys, vars) = make_hidato(&puzzle);
    let dict = sys.solve_any().expect("solution");
    print_hidato(&dict, &vars);
    verify_hidato(&dict, &vars, &expected);
    println!("hidato_wikipedia: {} guesses", sys.num_guesses());
}