Year 2024 Day 11

Author: maneatingape

README.md

@@ -82,6 +82,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 8 | [Resonant Collinearity](https://adventofcode.com/2024/day/8) | [Source](src/year2024/day08.rs) | 8 |
 | 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 106 |
 | 10 | [Hoof It](https://adventofcode.com/2024/day/10) | [Source](src/year2024/day10.rs) | 38 |
+| 11 | [Plutonian Pebbles](https://adventofcode.com/2024/day/11) | [Source](src/year2024/day11.rs) | 2378 |
 
 ## 2023
 

benches/benchmark.rs

@@ -302,4 +302,5 @@ mod year2024 {
     benchmark!(year2024, day08);
     benchmark!(year2024, day09);
     benchmark!(year2024, day10);
+    benchmark!(year2024, day11);
 }

src/lib.rs

@@ -301,4 +301,5 @@ pub mod year2024 {
     pub mod day08;
     pub mod day09;
     pub mod day10;
+    pub mod day11;
 }

src/main.rs

@@ -371,5 +371,6 @@ fn year2024() -> Vec<Solution> {
         solution!(year2024, day08),
         solution!(year2024, day09),
         solution!(year2024, day10),
+        solution!(year2024, day11),
     ]
 }

src/year2024/day11.rs

@@ -0,0 +1,53 @@
+//! # Plutonian Pebbles
+//!
+//! Each stone is independent and does not affect its neighbours. This means that we can
+//! recursively split each stone, skipping trillions of calculations by memoizing the count for
+//! each `(stone, blinks)` tuple.
+//!
+//! Interestingly the number of distinct stones is not too large, about 5000 for part two.
+use crate::util::hash::*;
+use crate::util::parse::*;
+
+pub fn parse(input: &str) -> Vec<u64> {
+    input.iter_unsigned().collect()
+}
+
+pub fn part1(input: &[u64]) -> u64 {
+    let cache = &mut FastMap::with_capacity(5_000);
+    input.iter().map(|&stone| count(cache, stone, 25)).sum()
+}
+
+pub fn part2(input: &[u64]) -> u64 {
+    let cache = &mut FastMap::with_capacity(150_000);
+    input.iter().map(|&stone| count(cache, stone, 75)).sum()
+}
+
+fn count(cache: &mut FastMap<(u64, u64), u64>, stone: u64, blinks: u64) -> u64 {
+    if blinks == 1 {
+        if stone == 0 {
+            return 1;
+        }
+        let digits = stone.ilog10() + 1;
+        return if digits % 2 == 0 { 2 } else { 1 };
+    }
+
+    let key = (stone, blinks);
+    if let Some(&value) = cache.get(&key) {
+        return value;
+    }
+
+    let next = if stone == 0 {
+        count(cache, 1, blinks - 1)
+    } else {
+        let digits = stone.ilog10() + 1;
+        if digits % 2 == 0 {
+            let power = 10_u64.pow(digits / 2);
+            count(cache, stone / power, blinks - 1) + count(cache, stone % power, blinks - 1)
+        } else {
+            count(cache, stone * 2024, blinks - 1)
+        }
+    };
+
+    cache.insert(key, next);
+    next
+}

tests/test.rs

@@ -291,4 +291,5 @@ mod year2024 {
     mod day08_test;
     mod day09_test;
     mod day10_test;
+    mod day11_test;
 }

tests/year2024/day11_test.rs

@@ -0,0 +1,15 @@
+use aoc::year2024::day11::*;
+
+const EXAMPLE: &str = "125 17";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 55312);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 65601038650482);
+}