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
|
use std::collections::{HashMap, HashSet};
const DIRS: [(i32, i32); 8] = [
(-1, 0),
(1, 0),
(0, 1),
(0, -1),
(1, 1),
(-1, -1),
(-1, 1),
(1, -1),
];
fn in_bounds(i: i32, j: i32, n: i32, m: i32) -> bool {
i < n && i >= 0 && j < m && j >= 0
}
type Row = usize;
type Rng = (usize, usize);
fn get_num_range(i: usize, j: usize, grid: &Vec<&[u8]>) -> (Row, Rng) {
let row = grid[i];
let mut k = j;
while k > 0 && row[k - 1].is_ascii_digit() {
k -= 1;
}
let l = k;
while k < row.len() && row[k].is_ascii_digit() {
k += 1;
}
let r = k;
(i, (l, r))
}
fn get_num(grid: &Vec<&[u8]>, range: (Row, Rng)) -> u64 {
let (l, r) = (((range.1).0), ((range.1).1));
grid[range.0][l..r]
.iter()
.map(|x| *x as char)
.collect::<String>()
.parse::<u64>()
.expect("Should be parasable to u64")
}
fn solve_part_one(data: &str) -> u64 {
let grid: Vec<&[u8]> = data.lines().map(|line| line.as_bytes()).collect();
let (n, m) = (grid.len(), grid[0].len());
let mut set = HashSet::new();
let mut sum = 0;
for i in 0..n {
for j in 0..m {
if !".0123456789".contains(grid[i][j] as char) {
for (x, y) in DIRS.iter() {
let nx = i as i32 + x;
let ny = j as i32 + y;
if in_bounds(nx, ny, n as i32, m as i32)
&& grid[nx as usize][ny as usize].is_ascii_digit()
{
let rng = get_num_range(nx as usize, ny as usize, &grid);
if !set.contains(&rng) {
set.insert(rng);
sum += get_num(&grid, rng);
}
}
}
}
}
}
sum
}
fn solve_part_two(data: &str) -> u64 {
let grid: Vec<&[u8]> = data.lines().map(|line| line.as_bytes()).collect();
let (n, m) = (grid.len(), grid[0].len());
let mut map: HashMap<Rng, HashSet<(Row, Rng)>> = HashMap::new();
for i in 0..n {
for j in 0..m {
if grid[i][j] as char == '*' {
for (x, y) in DIRS.iter() {
let nx = i as i32 + x;
let ny = j as i32 + y;
if in_bounds(nx, ny, n as i32, m as i32)
&& grid[nx as usize][ny as usize].is_ascii_digit()
{
let rng = get_num_range(nx as usize, ny as usize, &grid);
map.entry((i, j))
.and_modify(|st| {
st.insert(rng);
})
.or_insert_with(|| HashSet::from_iter(vec![rng].iter().cloned()));
}
}
}
}
}
map.iter()
.filter(|(_, set)| set.len() == 2)
.map(|(_, rng)| {
Vec::from_iter(rng.iter().map(|rng| get_num(&grid, *rng)))
.iter()
.product::<u64>()
})
.into_iter()
.sum::<u64>()
}
fn main() {
let test_1 = include_str!("../input/day3_1.test");
let prod = include_str!("../input/day3.prod");
println!("part_1 test: {:?}", solve_part_one(test_1));
println!("part_1 prod {:?}", solve_part_one(prod));
println!("part_2 test: {:?}", solve_part_two(test_1));
println!("part_2 prod {:?}", solve_part_two(prod));
}
|
