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

struct Solution;

struct Chess {
    r: usize,
    c: usize,
}

enum Direction {
    Right,
    Down,
    Left,
    Up,
}

impl Solution {
    fn search_rook(board: &[Vec<char>]) -> Chess {
        for r in 0..8 {
            for c in 0..8 {
                if board[r][c] == 'R' {
                    return Chess { r, c };
                }
            }
        }
        unreachable!()
    }
    fn search_pawn(board: &[Vec<char>], rook: &Chess, direction: Direction) -> bool {
        let mut r = rook.r;
        let mut c = rook.c;

        match direction {
            Direction::Right => {
                while c + 1 < 8 && board[r][c + 1] != 'B' {
                    c += 1;
                    if board[r][c] == 'p' {
                        return true;
                    }
                }
            }
            Direction::Down => {
                while r + 1 < 8 && board[r + 1][c] != 'B' {
                    r += 1;
                    if board[r][c] == 'p' {
                        return true;
                    }
                }
            }
            Direction::Left => {
                while c > 0 && board[r][c - 1] != 'B' {
                    c -= 1;
                    if board[r][c] == 'p' {
                        return true;
                    }
                }
            }
            Direction::Up => {
                while r > 0 && board[r - 1][c] != 'B' {
                    r -= 1;
                    if board[r][c] == 'p' {
                        return true;
                    }
                }
            }
        }
        false
    }
    fn num_rook_captures(board: Vec<Vec<char>>) -> i32 {
        let mut sum = 0;
        let rook: Chess = Self::search_rook(&board);
        for direction in vec![
            Direction::Right,
            Direction::Down,
            Direction::Left,
            Direction::Up,
        ] {
            if Self::search_pawn(&board, &rook, direction) {
                sum += 1;
            }
        }
        sum
    }
}

#[test]
fn test() {
    let board = vec_vec_char![
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', 'p', '.', '.', '.', '.'],
        ['.', '.', '.', 'R', '.', '.', '.', 'p'],
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', 'p', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.']
    ];
    let res = 3;
    assert_eq!(Solution::num_rook_captures(board), res);
    let board = vec_vec_char![
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', 'p', 'p', 'p', 'p', 'p', '.', '.'],
        ['.', 'p', 'p', 'B', 'p', 'p', '.', '.'],
        ['.', 'p', 'B', 'R', 'B', 'p', '.', '.'],
        ['.', 'p', 'p', 'B', 'p', 'p', '.', '.'],
        ['.', 'p', 'p', 'p', 'p', 'p', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.']
    ];
    let res = 0;
    assert_eq!(Solution::num_rook_captures(board), res);
    let board = vec_vec_char![
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', 'p', '.', '.', '.', '.'],
        ['.', '.', '.', 'p', '.', '.', '.', '.'],
        ['p', 'p', '.', 'R', '.', 'p', 'B', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', 'B', '.', '.', '.', '.'],
        ['.', '.', '.', 'p', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.']
    ];
    let res = 3;
    assert_eq!(Solution::num_rook_captures(board), res);
}