AOC 2024 Day 05

Author: raul-sauco

aoc/2024/rust/Cargo.lock

@@ -24,10 +24,11 @@ test_lib = []
 # Template dependencies
 chrono = { version = "0.4.38", optional = true }
 dhat = { version = "0.3.3", optional = true }
-glam = "0.29.2"
-itertools = "0.13.0"
 pico-args = "0.5.0"
-regex = "1.11.1"
 tinyjson = "2.5.1"
 
 # Solution dependencies
+glam = "0.29.2"
+itertools = "0.13.0"
+nom = "7.1.3"
+regex = "1.11.1"

aoc/2024/rust/Cargo.toml

@@ -0,0 +1,28 @@
+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

aoc/2024/rust/data/examples/05.txt

@@ -0,0 +1,111 @@
+advent_of_code::solution!(5);
+
+use nom::{
+    bytes::complete::tag,
+    character::complete::{digit1, line_ending},
+    combinator::map_res,
+    multi::separated_list1,
+    sequence::separated_pair,
+    IResult,
+};
+use std::{
+    cmp::Ordering,
+    collections::{HashMap, HashSet},
+};
+
+fn parse_u32(input: &str) -> IResult<&str, u32> {
+    map_res(digit1, str::parse::<u32>)(input)
+}
+
+fn parse_ordering(input: &str) -> IResult<&str, Vec<(u32, u32)>> {
+    separated_list1(line_ending, separated_pair(parse_u32, tag("|"), parse_u32))(input)
+}
+
+fn parse_books(input: &str) -> IResult<&str, Vec<Vec<u32>>> {
+    separated_list1(line_ending, separated_list1(tag(","), parse_u32))(input)
+}
+
+fn parse(input: &str) -> IResult<&str, (Vec<(u32, u32)>, Vec<Vec<u32>>)> {
+    separated_pair(parse_ordering, tag("\n\n"), parse_books)(input)
+}
+
+fn is_sorted_book(rules: &HashMap<u32, HashSet<u32>>, book: &Vec<u32>) -> bool {
+    let mut seen = HashSet::new();
+    for page in book {
+        if let Some(not_allowed_pages) = rules.get(&page) {
+            if seen.intersection(not_allowed_pages).count() > 0 {
+                return false;
+            }
+        }
+        seen.insert(*page);
+    }
+    true
+}
+
+/// Given a vector of tuples with values that need to be before | after each other, return a hashmap
+/// of u32 => HashSet<u32> where the hashsets contain values that cannot come before the key.
+fn get_rules(pairs: Vec<(u32, u32)>) -> HashMap<u32, HashSet<u32>> {
+    let mut rules: HashMap<u32, HashSet<u32>> = HashMap::new();
+    for (before, after) in pairs {
+        rules
+            .entry(before)
+            .and_modify(|hm| {
+                hm.insert(after);
+            })
+            .or_insert(HashSet::from([after]));
+    }
+    rules
+}
+
+pub fn part_one(input: &str) -> Option<u32> {
+    let (_, (pairs, books)) = parse(input).unwrap();
+    let rules = get_rules(pairs);
+    Some(
+        books
+            .into_iter()
+            .filter(|book| is_sorted_book(&rules, &book))
+            .map(|v| v[v.len() / 2])
+            .sum(),
+    )
+}
+
+pub fn part_two(input: &str) -> Option<u32> {
+    let (_, (pairs, books)) = parse(input).unwrap();
+    let rules = get_rules(pairs);
+    Some(
+        books
+            .into_iter()
+            .filter(|book| !is_sorted_book(&rules, &book))
+            .map(|mut book| {
+                book.sort_by(|a, b| {
+                    if rules
+                        .get(a)
+                        .is_some_and(|not_before| not_before.contains(&b))
+                    {
+                        Ordering::Less
+                    } else {
+                        Ordering::Greater
+                    }
+                });
+                book[book.len() / 2]
+            })
+            .sum(),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_part_one() {
+        let result = part_one(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(143));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(123));
+    }
+}