Year 2024 Day 5

Author: maneatingape

README.md

@@ -81,6 +81,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 2 | [Red-Nosed Reports](https://adventofcode.com/2024/day/2) | [Source](src/year2024/day02.rs) | 43 |
 | 3 | [Mull It Over](https://adventofcode.com/2024/day/3) | [Source](src/year2024/day03.rs) | 8 |
 | 4 | [Ceres Search](https://adventofcode.com/2024/day/4) | [Source](src/year2024/day04.rs) | 77 |
+| 5 | [Print Queue](https://adventofcode.com/2024/day/5) | [Source](src/year2024/day05.rs) | 32 |
 
 ## 2023
 

benches/benchmark.rs

@@ -296,4 +296,5 @@ mod year2024 {
     benchmark!(year2024, day02);
     benchmark!(year2024, day03);
     benchmark!(year2024, day04);
+    benchmark!(year2024, day05);
 }

src/lib.rs

@@ -295,4 +295,5 @@ pub mod year2024 {
     pub mod day02;
     pub mod day03;
     pub mod day04;
+    pub mod day05;
 }

src/main.rs

@@ -365,5 +365,6 @@ fn year2024() -> Vec<Solution> {
         solution!(year2024, day02),
         solution!(year2024, day03),
         solution!(year2024, day04),
+        solution!(year2024, day05),
     ]
 }

src/year2024/day05.rs

@@ -0,0 +1,62 @@
+//! # Print Queue
+//!
+//! Numbers are always 2 digits so storing directed edges in a fixed size 100 x 100 array is much
+//! faster than using a `HashMap`.
+//!
+//! The ordering graph has cycles so we can't use a
+//! [topological sort](https://en.wikipedia.org/wiki/Topological_sorting).
+//! A simple `O(n²)` [selection sort](https://en.wikipedia.org/wiki/Selection_sort) works well as
+//! the length of each updates is reasonably short.
+use crate::util::iter::*;
+use crate::util::parse::*;
+
+type Input = (usize, usize);
+
+pub fn parse(input: &str) -> Input {
+    let (prefix, suffix) = input.split_once("\n\n").unwrap();
+    let mut after = [[true; 100]; 100];
+
+    for [from, to] in prefix.iter_unsigned::<usize>().chunk::<2>() {
+        after[to][from] = false;
+    }
+
+    let mut todo = Vec::new();
+    let mut part_one = 0;
+    let mut part_two = 0;
+
+    for line in suffix.lines() {
+        let mut ordered = true;
+
+        todo.clear();
+        todo.extend(line.iter_unsigned::<usize>());
+
+        // Sort updates into correct order.
+        for current in 0..todo.len() {
+            let offset = todo[current..]
+                .iter()
+                .enumerate()
+                .position(|(i, &from)| todo[current + i + 1..].iter().all(|&to| after[from][to]))
+                .unwrap();
+
+            let next = current + offset;
+            todo.swap(current, next);
+            ordered &= current == next;
+        }
+
+        if ordered {
+            part_one += todo[todo.len() / 2];
+        } else {
+            part_two += todo[todo.len() / 2];
+        }
+    }
+
+    (part_one, part_two)
+}
+
+pub fn part1(input: &Input) -> usize {
+    input.0
+}
+
+pub fn part2(input: &Input) -> usize {
+    input.1
+}

tests/test.rs

@@ -285,4 +285,5 @@ mod year2024 {
     mod day02_test;
     mod day03_test;
     mod day04_test;
+    mod day05_test;
 }

tests/year2024/day05_test.rs

@@ -0,0 +1,43 @@
+use aoc::year2024::day05::*;
+
+const EXAMPLE: &str = "\
+47|53
+97|13
+97|61
+97|47
+75|29
+61|13
+75|53
+29|13
+97|29
+53|29
+61|53
+97|53
+61|29
+47|13
+75|47
+97|75
+47|61
+75|61
+47|29
+75|13
+53|13
+
+75,47,61,53,29
+97,61,53,29,13
+75,29,13
+75,97,47,61,53
+61,13,29
+97,13,75,29,47";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 143);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 123);
+}