Refactor day 10

2021/src/bin/day10.rs

@@ -1,71 +1,46 @@
 #![feature(test)]
 extern crate test;
-
 use aoc2021::common::*;
 
 const DAY: usize = 10;
-type Parsed<'a> = Vec<&'a str>;
 
-fn parse_input(raw: &str) -> Parsed {
+fn solve(input: &str) -> (usize, usize) {
-    raw.lines().collect()
+    let mut p1_score = 0;
-}
+    let mut p2_scores = Vec::new();
-
+    let mut stack = Vec::new();
-fn solve(parsed: &Parsed) -> (usize, usize) {
+    for line in input.lines() {
-    let mut points = 0;
+        match is_well_formed(line, &mut stack) {
-    let mut p2_points = Vec::new();
+            Ok(s) => p2_scores.push(autocomplete_points(s)), // <- clears the stack internally
-    for &line in parsed {
+            Err(p) => {
-        let mut stack = Vec::new();
+                p1_score += p;
-        let mut invalid = false;
+                stack.clear();
-        for c in line.bytes() {
-            match c {
-                b'(' | b'[' | b'<' | b'{' => stack.push(c),
-                b')' if stack.last() == Some(&b'(') => {
-                    stack.pop();
-                }
-                b']' if stack.last() == Some(&b'[') => {
-                    stack.pop();
-                }
-                b'>' if stack.last() == Some(&b'<') => {
-                    stack.pop();
-                }
-                b'}' if stack.last() == Some(&b'{') => {
-                    stack.pop();
-                }
-                b')' => {
-                    points += 3;
-                    invalid = true;
-                    break;
-                }
-                b']' => {
-                    points += 57;
-                    invalid = true;
-                    break;
-                }
-                b'}' => {
-                    points += 1197;
-                    invalid = true;
-                    break;
-                }
-                b'>' => {
-                    points += 25137;
-                    invalid = true;
-                    break;
-                }
-                _ => unreachable!(),
             }
         }
-        if invalid {
-            continue;
-        }
-        p2_points.push(autocomplete_points(stack));
     }
-    let p2_len = p2_points.len();
+    let p2_len = p2_scores.len();
-    (points, *p2_points.select_nth_unstable(p2_len / 2).1)
+    (p1_score, *p2_scores.select_nth_unstable(p2_len / 2).1)
 }
 
-fn autocomplete_points(stack: Vec<u8>) -> usize {
+fn is_well_formed<'a>(line: &str, stack: &'a mut Vec<u8>) -> Result<&'a mut Vec<u8>, usize> {
+    for c in line.bytes() {
+        match (stack.last(), c) {
+            (_, b'(' | b'[' | b'<' | b'{') => stack.push(c),
+            (Some(b'('), b')') | (Some(b'['), b']') | (Some(b'{'), b'}') | (Some(b'<'), b'>') => {
+                stack.pop();
+            }
+            (_, b')') => return Err(3),
+            (_, b']') => return Err(57),
+            (_, b'}') => return Err(1197),
+            (_, b'>') => return Err(25137),
+            _ => unreachable!(),
+        }
+    }
+    Ok(stack)
+}
+
+fn autocomplete_points(stack: &mut Vec<u8>) -> usize {
     let mut points = 0;
-    for p in stack.into_iter().rev() {
+    for p in stack.drain(..).rev() {
         points *= 5;
         match p {
             b'(' => points += 1,
@@ -80,8 +55,7 @@ fn autocomplete_points(stack: Vec<u8>) -> usize {
 
 fn main() {
     let raw = read_file(DAY);
-    let input = parse_input(&raw);
+    let (p1, p2) = solve(&raw);
-    let (p1, p2) = solve(&input);
     println!("Part 1: {p1}");
     println!("Part 2: {p2}");
 }
@@ -102,29 +76,25 @@ mod tests {
 <{([([[(<>()){}]>(<<{{
 <{([{{}}[<[[[<>{}]]]>[]]";
 
-    #[test]
+    #[bench]
-    fn test_autocomplete_points() {
+    fn bench_autocomplete_points(b: &mut test::Bencher) {
-        assert_eq!(autocomplete_points(vec![b'<', b'{', b'(', b'[']), 294);
+        let sample_stack = vec![b'<', b'{', b'(', b'['];
+        b.iter(|| assert_eq!(autocomplete_points(test::black_box(&mut sample_stack.clone())), 294));
     }
 
     #[test]
     fn part1_test() {
-        let input = parse_input(TEST_INPUT);
+        assert_eq!(solve(TEST_INPUT).0, 26397);
-        assert_eq!(solve(&input).0, 26397);
     }
 
     #[test]
     fn part2_test() {
-        let input = parse_input(TEST_INPUT);
+        assert_eq!(solve(TEST_INPUT).1, 288957);
-        assert_eq!(solve(&input).1, 288957);
     }
 
     #[bench]
     fn bench_solution(b: &mut test::Bencher) {
         let raw = read_file(DAY);
-        let input = parse_input(&raw);
+        b.iter(|| assert_eq!(solve(test::black_box(&raw)), (358737, 4329504793)))
-        b.iter(|| assert_eq!(solve(test::black_box(&input)), (358737, 4329504793)))
     }
-
-    bench_input!(Vec::len => 90);
 }