use memoize macro

Author: majcn

src/bin/11.rs

@@ -1,52 +1,42 @@
 advent_of_code::solution!(11);
 
+use advent_of_code_macros::memoize;
+
 use advent_of_code::majcn::math::*;
-use advent_of_code::maneatingape::hash::*;
 use advent_of_code::maneatingape::parse::*;
 
 fn parse_data(input: &str) -> Vec<u32> {
     input.iter_unsigned().collect()
 }
 
-fn calculate_step(v: u64) -> [Option<u64>; 2] {
+fn calculate_step(v: u64) -> Vec<u64> {
     if v == 0 {
-        return [Some(1), None];
+        return vec![1];
     }
 
     let n = v.count_digits() as u32;
     if n % 2 == 0 {
         let split_value = 10_u64.pow(n / 2);
-        return [Some(v / split_value), Some(v % split_value)];
+        return vec![v / split_value, v % split_value];
     }
 
-    [Some(v * 2024), None]
+    vec![v * 2024]
 }
 
-fn calculate<const N: usize>(v: u64, i: usize, cache: &mut FastMap<(usize, u64), u64>) -> u64 {
-    if i == N {
+#[memoize]
+fn calculate(v: u64, n: usize) -> u64 {
+    if n == 0 {
         return 1;
     }
 
-    if let Some(cached_result) = cache.get(&(i, v)) {
-        return *cached_result;
-    }
-
-    let result = calculate_step(v)
+    calculate_step(v)
         .into_iter()
-        .filter_map(|x| Some(calculate::<N>(x?, i + 1, cache)))
-        .sum();
-
-    cache.insert((i, v), result);
-
-    result
+        .map(|x| calculate(x, n - 1))
+        .sum()
 }
 
 fn part_x<const N: usize>(data: Vec<u32>) -> u64 {
-    let mut cache = FastMap::new();
-
-    data.into_iter()
-        .map(|x| calculate::<N>(x as u64, 0, &mut cache))
-        .sum()
+    data.into_iter().map(|x| calculate(x as u64, N)).sum()
 }
 
 pub fn part_one(input: &str) -> Option<u64> {

src/bin/19.rs

@@ -1,6 +1,6 @@
 advent_of_code::solution!(19);
 
-use advent_of_code::maneatingape::hash::*;
+use advent_of_code_macros::memoize;
 
 fn parse_data(input: &str) -> (Vec<&str>, Vec<&str>) {
     let (left, right) = input.split_once("\n\n").unwrap();
@@ -23,24 +23,21 @@ fn validate_message(message: &str, towels: &[&str]) -> bool {
         .any(|towel| validate_message(&message[towel.len()..], towels))
 }
 
-fn count_valid_message(cache: &mut FastMap<String, u64>, message: &str, towels: &[&str]) -> u64 {
+fn count_valid_message_cache_key(message: &str, _: &[&str]) -> String {
+    String::from(message)
+}
+
+#[memoize(key_function = "count_valid_message_cache_key -> String")]
+fn count_valid_message(message: &str, towels: &[&str]) -> u64 {
     if message.is_empty() {
         return 1;
     }
 
-    if let Some(&result) = cache.get(message) {
-        return result;
-    }
-
     towels
         .iter()
         .filter(|towel| message.len() >= towel.len())
         .filter(|towel| &&&message[..towel.len()] == towel)
-        .map(|towel| {
-            let result = count_valid_message(cache, &message[towel.len()..], towels);
-            cache.insert(String::from(&message[towel.len()..]), result);
-            result
-        })
+        .map(|towel| count_valid_message(&message[towel.len()..], towels))
         .sum()
 }
 
@@ -58,11 +55,9 @@ pub fn part_one(input: &str) -> Option<u32> {
 pub fn part_two(input: &str) -> Option<u64> {
     let (towels, messages) = parse_data(input);
 
-    let mut cache = FastMap::new();
-
     let result = messages
         .into_iter()
-        .map(|message| count_valid_message(&mut cache, message, &towels))
+        .map(|message| count_valid_message(message, &towels))
         .sum();
 
     Some(result)

src/bin/21.rs

@@ -1,8 +1,9 @@
 advent_of_code::solution!(21);
 
+use advent_of_code_macros::memoize;
+
 use advent_of_code::maneatingape::heap::*;
 use advent_of_code::maneatingape::parse::*;
-use advent_of_code_macros::memoize;
 
 fn parse_data(input: &str) -> Vec<u32> {
     input.lines().map(|line| line.unsigned()).collect()