Year 2024 Day 2

Author: maneatingape

README.md

@@ -78,6 +78,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | Day | Problem | Solution | Benchmark (μs) |
 | --- | --- | --- | --: |
 | 1 | [Historian Hysteria](https://adventofcode.com/2024/day/1) | [Source](src/year2024/day01.rs) | 21 |
+| 2 | [Red-Nosed Reports](https://adventofcode.com/2024/day/2) | [Source](src/year2024/day02.rs) | 43 |
 
 ## 2023
 

benches/benchmark.rs

@@ -293,4 +293,5 @@ mod year2023 {
 
 mod year2024 {
     benchmark!(year2024, day01);
+    benchmark!(year2024, day02);
 }

src/lib.rs

@@ -292,4 +292,5 @@ pub mod year2023 {
 /// # Locate the Chief Historian in time for the big Christmas sleigh launch.
 pub mod year2024 {
     pub mod day01;
+    pub mod day02;
 }

src/main.rs

@@ -360,5 +360,5 @@ fn year2023() -> Vec<Solution> {
 }
 
 fn year2024() -> Vec<Solution> {
-    vec![solution!(year2024, day01)]
+    vec![solution!(year2024, day01), solution!(year2024, day02)]
 }

src/year2024/day02.rs

@@ -0,0 +1,85 @@
+//! # Red-Nosed Reports
+//!
+//! Computes boths parts simultaneously. Each pair of levels is converted into deltas of
+//! either +1, -1 or 0. For example:
+//!
+//! * `1 3 6 7 9` => `+1 +1 +1 +1`
+//! * `9 7 6 2 1` => `-1 -1 0 -1`
+//!
+//! If the sum of all delta equals ±4, then we know that all levels are increasing or
+//! decreasing. Any other value indicates either mixed up and down transitions or levels that
+//! are too far apart.
+//!
+//! For part two we remove each pair of deltas (or single delta at each end) then replace with
+//! the sum of the delta from the new neighbors on either side.
+use crate::util::parse::*;
+
+type Input = (u32, u32);
+
+/// Minimize allocation to only a single `vec` reused for each report.
+pub fn parse(input: &str) -> Input {
+    let mut report = Vec::new();
+    let mut part_one = 0;
+    let mut part_two = 0;
+
+    for line in input.lines() {
+        report.extend(line.iter_signed::<i32>());
+
+        let (p1, p2) = check(&report);
+        part_one += p1;
+        part_two += p2;
+
+        report.clear();
+    }
+
+    (part_one, part_two)
+}
+
+pub fn part1(input: &Input) -> u32 {
+    input.0
+}
+
+pub fn part2(input: &Input) -> u32 {
+    input.1
+}
+
+fn check(report: &[i32]) -> (u32, u32) {
+    let size = report.len();
+    let score: i32 = (1..size).map(|i| delta(report[i - 1], report[i])).sum();
+
+    if score.abs() == (size - 1) as i32 {
+        return (1, 1);
+    }
+
+    for i in 0..size {
+        let mut score = score;
+
+        // Snip out each level and replace with new level computed from neighbors to either side.
+        if i > 0 {
+            score -= delta(report[i - 1], report[i]);
+        }
+        if i < size - 1 {
+            score -= delta(report[i], report[i + 1]);
+        }
+        if i > 0 && i < size - 1 {
+            score += delta(report[i - 1], report[i + 1]);
+        }
+
+        if score.abs() == (size - 2) as i32 {
+            return (0, 1);
+        }
+    }
+
+    (0, 0)
+}
+
+/// Convert each pair of levels to either +1 for increase, -1 for decrease or 0 for invalid range.
+fn delta(a: i32, b: i32) -> i32 {
+    let diff = b - a;
+
+    if diff.abs() <= 3 {
+        diff.signum()
+    } else {
+        0
+    }
+}

tests/test.rs

@@ -282,4 +282,5 @@ mod year2023 {
 
 mod year2024 {
     mod day01_test;
+    mod day02_test;
 }

tests/year2024/day02_test.rs

@@ -0,0 +1,21 @@
+use aoc::year2024::day02::*;
+
+const EXAMPLE: &str = "\
+7 6 4 2 1
+1 2 7 8 9
+9 7 6 2 1
+1 3 2 4 5
+8 6 4 4 1
+1 3 6 7 9";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 2);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 4);
+}