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
|
#![allow(dead_code)]
#![allow(unused_variables)]
use advent_of_code::prelude::*;
pub struct Pair {
first: (i64, i64),
second: (i64, i64),
}
impl Pair {
fn contains(&self) -> bool {
range_contains(self.first, self.second)
|| range_contains(self.second, self.first)
}
fn overlaps(&self) -> bool {
range_overlaps(self.first, self.second)
|| range_overlaps(self.second, self.first)
}
}
fn range_contains(a: (i64, i64), b: (i64, i64)) -> bool {
(a.0..=a.1).contains(&b.0) && (a.0..=a.1).contains(&b.1)
}
fn range_overlaps(a: (i64, i64), b: (i64, i64)) -> bool {
(a.0..=a.1).contains(&b.0) || (a.0..=a.1).contains(&b.1)
}
pub fn parse(fh: File) -> Result<impl Iterator<Item = Pair>> {
Ok(parse::raw_lines(fh).map(|line| {
let mut parts = line.split(',');
let first = parts.next().unwrap();
let mut first_parts = first.split('-');
let second = parts.next().unwrap();
let mut second_parts = second.split('-');
Pair {
first: (
first_parts.next().unwrap().parse().unwrap(),
first_parts.next().unwrap().parse().unwrap(),
),
second: (
second_parts.next().unwrap().parse().unwrap(),
second_parts.next().unwrap().parse().unwrap(),
),
}
}))
}
pub fn part1(pairs: impl Iterator<Item = Pair>) -> Result<usize> {
Ok(pairs.filter(|pair| pair.contains()).count())
}
pub fn part2(pairs: impl Iterator<Item = Pair>) -> Result<usize> {
Ok(pairs.filter(|pair| pair.overlaps()).count())
}
#[test]
fn test() {
assert_eq!(
part1(parse(parse::data(2022, 4).unwrap()).unwrap()).unwrap(),
515
);
assert_eq!(
part2(parse(parse::data(2022, 4).unwrap()).unwrap()).unwrap(),
883
);
}
|
