Day 11

Author: prevostc

Cargo.lock

@@ -27,6 +27,7 @@ chrono = { version = "0.4.38", optional = true }
 dhat = { version = "0.3.3", optional = true }
 heapless = "0.8.0"
 itertools = "0.13.0"
+memoize = "0.4.2"
 mygrid = { version = "0.0.1", path = "mygrid" }
 pico-args = "0.5.0"
 rayon = "1.10.0"

Cargo.toml

@@ -21,9 +21,9 @@ 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) | `104.4µs` | `1.8ms` |
+| [Day 11](./src/bin/11.rs) | `318.0ns` | `292.0ns` |
 
-**Total: 14.61ms**
+**Total: 12.71ms**
 <!--- benchmarking table --->
 
 ---

README.md

@@ -1,79 +1,57 @@
-use rustc_hash::FxHashMap;
-
-use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+use memoize::memoize;
 
 advent_of_code::solution!(11);
 
 type Stone = u64;
 type Step = u8;
-type MemoKey = (Step, Stone);
-type Memo = FxHashMap<MemoKey, u64>;
 
-fn blink_rec(memo: &mut Memo, stone: Stone, times: Step) -> u64 {
+#[memoize]
+fn blink_rec(stone: Stone, times: Step) -> u64 {
     if times == 0 {
         return 1;
     }
-    if let Some(count) = memo.get(&(times, stone)) {
-        return *count;
-    }
 
-    let res = {
-        let mut digit_count = 0;
-        let mut temp = stone;
-        while temp > 0 {
-            digit_count += 1;
-            temp /= 10;
-        }
+    if stone == 0 {
+        return blink_rec(1, times - 1);
+    }
+    let mut digit_count = 0;
+    let mut temp = stone;
+    while temp > 0 {
+        digit_count += 1;
+        temp /= 10;
+    }
 
-        if stone == 0 {
-            blink_rec(memo, 1, times - 1)
-        } else if digit_count % 2 == 0 {
-            let divisor = 10_u64.pow(digit_count / 2);
-            blink_rec(memo, stone / divisor, times - 1)
-                + blink_rec(memo, stone % divisor, times - 1)
-        } else {
-            blink_rec(memo, stone * 2024, times - 1)
-        }
-    };
+    if digit_count % 2 == 0 {
+        let divisor = 10_u64.pow(digit_count / 2);
+        return blink_rec(stone / divisor, times - 1) + blink_rec(stone % divisor, times - 1);
+    }
 
-    memo.insert((times, stone), res);
-    res
+    return blink_rec(stone * 2024, times - 1);
 }
 
-fn parse_input(input: &str) -> Vec<Stone> {
-    input
+fn solve(input: &str, times: Step) -> u64 {
+    let stones = input
         .split_whitespace()
         .filter(|p| !p.is_empty())
         .map(|s| s.parse::<u64>())
         .filter(|r| r.is_ok())
         .map(|r| r.unwrap())
-        .collect::<Vec<_>>()
-}
+        .collect::<Vec<_>>();
 
-pub fn part_one(input: &str) -> Option<u64> {
-    let times = 25;
-    let stones = parse_input(input);
-    let mut memo = FxHashMap::with_capacity_and_hasher(100000, Default::default());
     let count = stones
-        .iter()
-        .map(|start_stone| blink_rec(&mut memo, *start_stone, times))
+        .iter() // so fast that parallel is slower
+        .map(|start_stone| blink_rec(*start_stone, times))
         .sum::<u64>();
 
-    Some(count as u64)
+    return count;
 }
 
-pub fn part_two(input: &str) -> Option<u64> {
-    let times = 75;
-    let stones = parse_input(input);
-    let count = stones
-        .par_iter()
-        .map(|start_stone| {
-            let mut memo = FxHashMap::with_capacity_and_hasher(100000, Default::default());
-            blink_rec(&mut memo, *start_stone, times)
-        })
-        .sum::<u64>();
+pub fn part_one(input: &str) -> Option<u64> {
+    Some(solve(input, 25))
+}
 
-    Some(count as u64)
+pub fn part_two(input: &str) -> Option<u64> {
+    Some(solve(input, 75))
 }
 
 #[cfg(test)]