rustgym 0.2.0

rustgym solutions
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

struct Solution;
use std::collections::HashSet;

type Point = Vec<i32>;

struct Chessboard {
    directions: Vec<Point>,
    queens: HashSet<Point>,
    king: Point,
}

impl Chessboard {
    fn new(queens_vec: Vec<Point>, king: Point) -> Self {
        let directions: Vec<Point> = vec![
            vec![1, 0],
            vec![-1, 0],
            vec![0, 1],
            vec![0, -1],
            vec![1, 1],
            vec![-1, 1],
            vec![1, -1],
            vec![-1, -1],
        ];
        let mut queens: HashSet<Point> = HashSet::new();
        for queen in queens_vec {
            queens.insert(queen);
        }
        Chessboard {
            king,
            queens,
            directions,
        }
    }
    fn contains(&self, point: &[i32]) -> bool {
        point[0] >= 0 && point[1] >= 0 && point[0] < 8 && point[1] < 8
    }
    fn attack(&self, i: usize, step: i32) -> Point {
        let direction = &self.directions[i];
        let king = &self.king;
        vec![king[0] + direction[0] * step, king[1] + direction[1] * step]
    }
}

impl Solution {
    fn queens_attackthe_king(queens: Vec<Vec<i32>>, king: Vec<i32>) -> Vec<Vec<i32>> {
        let mut res = vec![];
        let cb = Chessboard::new(queens, king);
        for i in 0..8 {
            let mut step = 1;
            loop {
                let p = cb.attack(i, step);
                if cb.contains(&p) {
                    if cb.queens.contains(&p) {
                        res.push(p);
                        break;
                    } else {
                        step += 1;
                    }
                } else {
                    break;
                }
            }
        }
        res
    }
}

#[test]
fn test() {
    let queens = vec_vec_i32![[0, 1], [1, 0], [4, 0], [0, 4], [3, 3], [2, 4]];
    let king = vec![0, 0];
    let mut res = vec_vec_i32![[0, 1], [1, 0], [3, 3]];
    let mut ans = Solution::queens_attackthe_king(queens, king);
    res.sort();
    ans.sort();
    assert_eq!(ans, res);
    let queens = vec_vec_i32![[0, 0], [1, 1], [2, 2], [3, 4], [3, 5], [4, 4], [4, 5]];
    let king = vec![3, 3];
    let mut res = vec_vec_i32![[2, 2], [3, 4], [4, 4]];
    let mut ans = Solution::queens_attackthe_king(queens, king);
    res.sort();
    ans.sort();
    assert_eq!(ans, res);
    let queens = vec_vec_i32![
        [5, 6],
        [7, 7],
        [2, 1],
        [0, 7],
        [1, 6],
        [5, 1],
        [3, 7],
        [0, 3],
        [4, 0],
        [1, 2],
        [6, 3],
        [5, 0],
        [0, 4],
        [2, 2],
        [1, 1],
        [6, 4],
        [5, 4],
        [0, 0],
        [2, 6],
        [4, 5],
        [5, 2],
        [1, 4],
        [7, 5],
        [2, 3],
        [0, 5],
        [4, 2],
        [1, 0],
        [2, 7],
        [0, 1],
        [4, 6],
        [6, 1],
        [0, 6],
        [4, 3],
        [1, 7]
    ];
    let king = vec![3, 4];
    let mut res = vec_vec_i32![[2, 3], [1, 4], [1, 6], [3, 7], [4, 3], [5, 4], [4, 5]];
    let mut ans = Solution::queens_attackthe_king(queens, king);
    res.sort();
    ans.sort();
    assert_eq!(ans, res);
}