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
|
pub struct StoneWall {
rows: Vec<Vec<u32>>,
}
impl StoneWall {
pub fn create_empty(n: u32) -> Self {
let n = n as usize;
let h = n / 2 + 1;
let mut rows = vec![vec![0; n]; h];
rows.get_mut(0).map(|r| r[0] = 1);
rows.get_mut(1).map(|r| r[1] = 2);
Self {
rows,
}
}
}
pub struct GapHeights {
heights: Vec<u32>,
}
impl GapHeights {
pub fn from_heights(heights: Vec<u32>) -> Self {
Self { heights }
}
#[allow(dead_code)]
fn create_empty(w: u32) -> Self {
let heights = if w == 0 {
vec![]
} else if w == 1 {
vec![0]
} else {
let mut v = Vec::with_capacity(w as usize);
v.push(0);
v.push(1);
v
};
Self { heights }
}
pub fn add_gap(&mut self, height: u32) {
self.add_gap(height)
}
pub fn calculate_row(&self, r: u32, stones: &mut [u32]) {
let mut len = 1;
let mut i = 0;
for &height in self.heights.iter().chain([r].iter()) {
if height == r {
stones[i] = len;
i += 1;
len = 0;
}
len += 1;
}
}
pub fn output(&self, n: u32, h: u32) {
let mut stones = vec![0; n as usize];
let mut toggle = 0;
let colors = [
"\x1b[31m", "\x1b[32m", "\x1b[33m", "\x1b[34m", "\x1b[35m", "\x1b[36m",
];
for row in 0..h {
self.calculate_row(row, &mut stones);
for &len in stones.iter() {
print!("{}", colors[toggle]);
toggle = (toggle + 1) % colors.len();
for _ in 0..len {
print!("◙");
}
}
println!("\x1b[m");
}
}
pub fn iter<'a>(&'a self) -> GapIter<'a> {
GapIter {
gap_heights: self,
i: 0,
}
}
}
pub struct GapIter<'a> {
gap_heights: &'a GapHeights,
i: usize,
}
impl<'a> Iterator for GapIter<'a> {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
let i = self.i;
self.i += 1;
self.gap_heights.heights.get(i).map(|&x| x)
}
}
|
