173 lines
5.2 KiB
Rust
173 lines
5.2 KiB
Rust
#![feature(test, str_split_once, bool_to_option)]
|
|
extern crate test;
|
|
use aoc2020::common::*;
|
|
use itertools::Itertools;
|
|
|
|
#[derive(Debug, PartialEq, Clone, Copy)]
|
|
enum Rule {
|
|
Char(u8),
|
|
And((usize, usize)),
|
|
AndOr((usize, usize), (usize, usize)),
|
|
Or((usize, usize)),
|
|
Useless(usize), // just delegates to another rule and makes parsing annoying
|
|
// This is why you don’t change the requirements once the implementation is done. REEEEEE
|
|
Special8(usize, (usize, usize)),
|
|
Special11((usize, usize), (usize, usize, usize)),
|
|
// If Rule was a recursive struct, this could have been defined as And(first, And(second, third)), but alas
|
|
Triple((usize, usize, usize)),
|
|
}
|
|
|
|
type Parsed<'a> = (RuleSet, &'a str);
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct RuleSet(Vec<Rule>);
|
|
|
|
impl RuleSet {
|
|
fn matches(&self, s: &str, rule: Rule) -> Option<usize> {
|
|
let res = match rule {
|
|
Rule::Char(c) => (s.as_bytes().first() == Some(&c)).then_some(1),
|
|
Rule::And((r1, r2)) => self
|
|
.matches(s, self.0[r1])
|
|
.and_then(|i| self.matches(&s[i..], self.0[r2]).map(|j| i + j)),
|
|
Rule::AndOr((r1, r2), (r3, r4)) => self
|
|
.matches(s, Rule::And((r1, r2)))
|
|
.or_else(|| self.matches(s, Rule::And((r3, r4)))),
|
|
Rule::Or((r1, r2)) => self.matches(s, Rule::Useless(r1)).or_else(|| self.matches(s, Rule::Useless(r2))),
|
|
Rule::Useless(r) => self.matches(s, self.0[r]),
|
|
// part 2 shit below:
|
|
Rule::Special8(first, second) => self.matches(s, Rule::Useless(first)).or_else(|| self.matches(s, Rule::And(second))),
|
|
Rule::Special11(first, second) => self.matches(s, Rule::And(first)).or_else(|| self.matches(s, Rule::Triple(second))),
|
|
Rule::Triple((r1, r2, r3)) => self
|
|
.matches(s, self.0[r1])
|
|
.and_then(|i| self.matches(&s[i..], self.0[r2]).map(|j| i + j))
|
|
.and_then(|i| self.matches(&s[i..], self.0[r3]).map(|j| i + j)),
|
|
};
|
|
res
|
|
}
|
|
}
|
|
|
|
fn read_input() -> String {
|
|
read_file(19)
|
|
}
|
|
|
|
fn parse_input<'a>(raw: &'a str) -> Parsed<'a> {
|
|
let (rules, inputs) = raw.split_once("\n\n").unwrap();
|
|
let rules = RuleSet(
|
|
rules
|
|
.lines()
|
|
.filter_map(|l| l.split_once(": "))
|
|
// why isn’t this already sorted like it was in the example?
|
|
.sorted_by_key(|t| t.0.parse::<i32>().unwrap())
|
|
.map(|(_, r)| match r {
|
|
or if or.contains('|') => {
|
|
let mut split = or.split(' ').filter(|s| s != &"|").map(|s| s.parse().unwrap());
|
|
split
|
|
.clone()
|
|
.next_tuple()
|
|
.map(|(a, b, c, d)| Rule::AndOr((a, b), (c, d)))
|
|
.or_else(|| split.next_tuple().map(|(a, b)| Rule::Or((a, b))))
|
|
.unwrap()
|
|
}
|
|
chr if chr.contains('"') => Rule::Char(chr.bytes().skip_while(|&b| b != b'"').skip(1).next().unwrap()),
|
|
and if and.contains(' ') => Rule::And(and.split(' ').map(|s| s.parse().unwrap()).next_tuple().unwrap()),
|
|
useless => Rule::Useless(useless.parse().unwrap()),
|
|
})
|
|
.collect(),
|
|
);
|
|
(rules, inputs)
|
|
}
|
|
|
|
fn part1((rules, input): &Parsed) -> usize {
|
|
input.lines().filter(|l| rules.matches(l, rules.0[0]) == Some(l.len())).count()
|
|
}
|
|
|
|
fn part2(parsed: &Parsed) -> usize {
|
|
let mut rules = parsed.0.clone();
|
|
rules.0[8] = Rule::Special8(42, (42, 8));
|
|
rules.0[11] = Rule::Special11((42, 31), (42, 11, 31));
|
|
dbg!(parsed.1.lines().map(|l| (l, rules.matches(l, rules.0[0]))).collect_vec());
|
|
parsed.1.lines().filter(|l| rules.matches(l, rules.0[0]) == Some(l.len())).count()
|
|
}
|
|
|
|
fn main() {
|
|
let raw = read_input();
|
|
let input = parse_input(&raw);
|
|
println!("Part 1: {}", part1(&input));
|
|
// 265 too low, 395 too high. apparently 379? no idea how that’s supposed to work
|
|
println!("Part 2: {}", part2(&input));
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use aoc2020::*;
|
|
use paste::paste;
|
|
use test::black_box;
|
|
|
|
const TEST_INPUT: &str = r#"0: 8 11
|
|
1: "a"
|
|
2: 1 24 | 14 4
|
|
3: 5 14 | 16 1
|
|
4: 1 1
|
|
5: 1 14 | 15 1
|
|
6: 14 14 | 1 14
|
|
7: 14 5 | 1 21
|
|
8: 42
|
|
9: 14 27 | 1 26
|
|
10: 23 14 | 28 1
|
|
11: 42 31
|
|
12: 24 14 | 19 1
|
|
13: 14 3 | 1 12
|
|
14: "b"
|
|
15: 1 | 14
|
|
16: 15 1 | 14 14
|
|
17: 14 2 | 1 7
|
|
18: 15 15
|
|
19: 14 1 | 14 14
|
|
20: 14 14 | 1 15
|
|
21: 14 1 | 1 14
|
|
22: 14 14
|
|
23: 25 1 | 22 14
|
|
24: 14 1
|
|
25: 1 1 | 1 14
|
|
26: 14 22 | 1 20
|
|
27: 1 6 | 14 18
|
|
28: 16 1
|
|
29: 29
|
|
30: 30
|
|
31: 14 17 | 1 13
|
|
32: 32
|
|
33: 33
|
|
34: 34
|
|
35: 35
|
|
36: 36
|
|
37: 37
|
|
38: 38
|
|
39: 39
|
|
40: 40
|
|
41: 41
|
|
42: 9 14 | 10 1
|
|
|
|
abbbbbabbbaaaababbaabbbbabababbbabbbbbbabaaaa
|
|
bbabbbbaabaabba
|
|
babbbbaabbbbbabbbbbbaabaaabaaa
|
|
aaabbbbbbaaaabaababaabababbabaaabbababababaaa
|
|
bbbbbbbaaaabbbbaaabbabaaa
|
|
bbbababbbbaaaaaaaabbababaaababaabab
|
|
ababaaaaaabaaab
|
|
ababaaaaabbbaba
|
|
baabbaaaabbaaaababbaababb
|
|
abbbbabbbbaaaababbbbbbaaaababb
|
|
aaaaabbaabaaaaababaa
|
|
aaaabbaaaabbaaa
|
|
aaaabbaabbaaaaaaabbbabbbaaabbaabaaa
|
|
babaaabbbaaabaababbaabababaaab
|
|
aabbbbbaabbbaaaaaabbbbbababaaaaabbaaabba"#;
|
|
|
|
test!(part1() == 3);
|
|
test!(part2() == 12);
|
|
bench!(part1() == 235);
|
|
// bench!(part2() == 0);
|
|
// bench_input!(0.len == 0);
|
|
}
|