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
|
#![feature(test)]
use std::error::Error;
use std::str::FromStr;
extern crate test;
#[cfg(test)]
mod tests {
use super::*;
use test::Bencher;
#[bench]
fn other(b: &mut Bencher) {
b.iter(|| main());
}
}
#[derive(Debug)]
struct Number {
value: u32,
begin: usize,
end: usize,
}
#[derive(Debug)]
struct SchematicLine {
numbers: Vec<Number>,
symbols: Vec<(usize, char)>,
}
impl FromStr for SchematicLine {
type Err = std::convert::Infallible;
fn from_str(line: &str) -> Result<Self, <Self as FromStr>::Err> {
let numbers = (1..4).rev().fold(vec![], |mut acc, window_size| {
acc.extend(
line.as_bytes()
.windows(window_size as usize)
.enumerate()
.filter(|(i, _)| !acc.iter().any(|n: &Number| n.begin <= *i && *i <= n.end))
.filter_map(|(i, w)| {
if w[0] as char == '+' {
return None;
}
if let Some(num) = std::str::from_utf8(w).ok()?.parse().ok() {
Some(Number {
value: num,
begin: i,
end: i + window_size - 1,
})
} else {
None
}
})
.collect::<Vec<_>>(),
);
acc
});
let symbols = line
.char_indices()
.filter(|(_, c)| !c.is_digit(10) && *c != '.')
.collect::<Vec<_>>();
Ok(SchematicLine { numbers, symbols })
}
}
impl SchematicLine {
pub fn check_against_symbols<'a>(&'a self, mut symbols: impl Iterator<Item=&'a (usize, char)> + 'a + Clone) -> impl Iterator<Item=&Number> + 'a {
let s = symbols.collect::<Vec<_>>();
self.numbers
.iter()
.filter(move |n| {
s.iter().any(|&&(pos, _)| {
(pos as i32 - n.begin as i32).abs() <= 1
|| (pos as i32 - n.end as i32).abs() <= 1
}) || self
.symbols
.iter()
.find(|&&(s, _)| {
s as isize == n.begin as isize - 1 || s as isize == n.end as isize + 1
})
.is_some()
})
}
pub fn get_gear_products(&self, mut numbers: impl Iterator<Item=&Number>) -> impl Iterator<Item=&u32> {
self.symbols
.filter(|(i, symbol)| symbol == '*')
.map(|(i, _)| i as u32)
}
}
// 467..114.. ...*...... ..35..633. ......#...
fn main() -> Result<(), Box<dyn Error>> {
let file = std::fs::read_to_string("input/3/in.txt")?;
let lines: &[SchematicLine] = &file
.lines()
.map(|line| line.parse().unwrap())
.collect::<Vec<_>>();
let numbers = lines
.windows(3)
.enumerate()
.fold(vec![], |mut machine_part_numbers, (i, w)| {
if i == 0 {
machine_part_numbers
.extend(w[0].check_against_symbols(w[1].symbols.iter()));
}
machine_part_numbers
.extend(w[1].check_against_symbols(w[0].symbols.iter().chain(w[2].symbols.iter())));
if i == lines.len() - 3 {
machine_part_numbers
.extend(w[2].check_against_symbols(w[1].symbols.iter()));
}
machine_part_numbers
});
let part1: u32 = numbers.iter().map(|n| n.value).sum();
let part2 = lines
.windows(3)
.enumerate()
.fold(vec![], |mut gear_products, (i, w)| {
gear_products.extend();
gear_products
});
dbg!(&part2);
Ok(())
}
|
