faster Day 11

Author: prevostc

Cargo.lock

@@ -33,6 +33,7 @@ mygrid = { version = "0.0.1", path = "mygrid" }
 nalgebra = "0.33.2"
 num = "0.4.3"
 object-pool = "0.6.0"
+phf = { version = "0.11.2", features = ["macros"] }
 pico-args = "0.5.0"
 rayon = "1.10.0"
 regex = "1.11.1"

Cargo.toml

@@ -21,14 +21,14 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 8](./src/bin/08.rs) | `7.4µs` | `15.5µs` |
 | [Day 9](./src/bin/09.rs) | `149.0µs` | `6.5ms` |
 | [Day 10](./src/bin/10.rs) | `31.1µs` | `28.6µs` |
-| [Day 11](./src/bin/11.rs) | `284.6µs` | `12.8ms` |
+| [Day 11](./src/bin/11.rs) | `71.0µs` | `766.0µs` |
 | [Day 12](./src/bin/12.rs) | `434.7µs` | `674.6µs` |
 | [Day 13](./src/bin/13.rs) | `90.9µs` | `91.8µs` |
 | [Day 14](./src/bin/14.rs) | `30.8µs` | `3.5ms` |
 | [Day 15](./src/bin/15.rs) | `119.7µs` | `591.0µs` |
 | [Day 16](./src/bin/16.rs) | `193.4µs` | `22.6ms` |
 
-**Total: 54.12ms**
+**Total: 41.87ms**
 <!--- benchmarking table --->
 
 ---

README.md

@@ -1,61 +1,104 @@
-use memoize::memoize;
-use num::traits::Euclid;
+use rustc_hash::FxHashMap;
 
 advent_of_code::solution!(11);
 
 type Stone = u64;
 type Step = u8;
 
-#[memoize]
-// have a memoize cache buster to fix timing multiple runs
-fn blink_rec(_cache_buster: u64, stone: Stone, times: Step) -> u64 {
-    if times == 0 {
-        return 1;
-    }
+const MAX_STONE_COUNT: usize = 5000;
+const MAX_DIGIT_COUNT: usize = 40;
 
-    if stone == 0 {
-        return blink_rec(_cache_buster, 1, times - 1);
+// take advantage of the fact that there is a limited number of stone numbers
+// found by @maneatingape: https://github.com/maneatingape/advent-of-code-rust/blob/main/src/year2024/day11.rs#L3
+struct StoneIdxPool {
+    count: usize,
+    stone_num_to_stone_idx: FxHashMap<Stone, usize>,
+    stone_idx_to_stone_num: [Stone; MAX_STONE_COUNT],
+}
+impl StoneIdxPool {
+    #[inline]
+    fn new() -> Self {
+        Self {
+            count: 0,
+            stone_num_to_stone_idx: FxHashMap::default(),
+            stone_idx_to_stone_num: [0; MAX_STONE_COUNT],
+        }
     }
 
-    let mut digit_count = 0;
-    let mut temp = stone;
-    while temp > 0 {
-        digit_count += 1;
-        temp /= 10;
-    }
-    // makes p1 2x slower but p2 0.2x faster
-    // let digit_count = stone.checked_ilog10().unwrap_or(0);
-    if digit_count % 2 == 0 {
-        let divisor: u64 = 10_u64.pow(digit_count / 2);
-        let (upper, lower) = stone.div_rem_euclid(&divisor);
-        return blink_rec(_cache_buster, lower, times - 1)
-            + blink_rec(_cache_buster, upper, times - 1);
+    #[inline]
+    fn get_idx(&mut self, stone_num: Stone) -> usize {
+        if let Some(idx) = self.stone_num_to_stone_idx.get(&stone_num) {
+            return *idx;
+        }
+
+        let idx = self.count;
+        self.stone_idx_to_stone_num[idx] = stone_num;
+        self.stone_num_to_stone_idx.insert(stone_num, idx);
+        self.count += 1;
+        idx
     }
 
-    return blink_rec(_cache_buster, stone * 2024, times - 1);
+    #[inline]
+    fn get_stone_num(&self, idx: usize) -> Stone {
+        self.stone_idx_to_stone_num[idx]
+    }
 }
 
-static mut GLOBAL_SEQ: u64 = 0;
-
 fn solve(input: &str, times: Step) -> u64 {
-    let cache_buster = unsafe { GLOBAL_SEQ };
-    unsafe {
-        GLOBAL_SEQ += 1;
+    let mut idx_pool = StoneIdxPool::new();
+
+    let mut divisors = [0; MAX_DIGIT_COUNT];
+    for i in 1..MAX_DIGIT_COUNT {
+        divisors[i] = 10_u64.pow(i as u32 / 2);
     }
-    let stones = input
+
+    let mut stone_count: [Stone; MAX_STONE_COUNT] = [0; MAX_STONE_COUNT];
+    input
         .split_whitespace()
         .filter(|p| !p.is_empty())
-        .map(|s| s.parse::<u64>())
+        .map(|s| s.parse::<Stone>())
         .filter(|r| r.is_ok())
         .map(|r| r.unwrap())
-        .collect::<Vec<_>>();
+        .for_each(|stone_num| {
+            stone_count[idx_pool.get_idx(stone_num)] += 1;
+        });
+
+    for _ in 0..times {
+        let mut new_stone_count: [Stone; MAX_STONE_COUNT] = [0; MAX_STONE_COUNT];
+        stone_count
+            .iter()
+            .enumerate()
+            .filter(|(_, &count)| count > 0)
+            .for_each(|(stone_idx, &count)| {
+                let stone_num = idx_pool.get_stone_num(stone_idx);
+                if stone_num == 0 {
+                    new_stone_count[idx_pool.get_idx(1)] += count;
+                    return;
+                }
+
+                // this is a bit faster than ilog10
+                let mut digit_count = 0;
+                let mut temp = stone_num;
+                while temp > 0 {
+                    digit_count += 1;
+                    temp /= 10;
+                }
+
+                if digit_count % 2 == 0 {
+                    let divisor = divisors[digit_count];
+                    new_stone_count[idx_pool.get_idx(stone_num / divisor)] += count;
+                    new_stone_count[idx_pool.get_idx(stone_num % divisor)] += count;
 
-    let count = stones
-        .iter() // so fast that parallel is slower
-        .map(|start_stone| blink_rec(cache_buster, *start_stone, times))
-        .sum::<u64>();
+                    return;
+                }
+
+                new_stone_count[idx_pool.get_idx(stone_num * 2024)] += count;
+            });
+
+        stone_count = new_stone_count;
+    }
 
-    return count;
+    stone_count.iter().sum()
 }
 
 pub fn part_one(input: &str) -> Option<u64> {