[2025] Cleanup day 11

Author: connorslade

aoc_2025/src/day_11.rs

@@ -2,87 +2,81 @@ use std::collections::HashMap;
 
 use common::{Answer, solution};
 
+type Graph<'a> = HashMap<&'a str, Vec<&'a str>>;
+
 solution!("Reactor", 11);
 
 fn part_a(input: &str) -> Answer {
-    let mut map = HashMap::new();
-
-    for line in input.lines() {
-        let (from, to) = line.split_once(": ").unwrap();
-        let to = to.split_whitespace().collect::<Vec<_>>();
-        map.insert(from, to);
-    }
-
-    fn count_paths(map: &HashMap<&str, Vec<&str>>, current: &str) -> u64 {
+    fn count_paths(map: &Graph, current: &str) -> u64 {
         if current == "out" {
             return 1;
         }
 
-        let mut out = 0;
-
-        for child in &map[current] {
-            out += count_paths(map, child);
-        }
-
-        out
+        (map[current].iter())
+            .map(|child| count_paths(map, child))
+            .sum()
     }
 
-    count_paths(&map, "you").into()
+    count_paths(&parse(input), "you").into()
 }
 
 fn part_b(input: &str) -> Answer {
-    let mut map = HashMap::new();
-
-    for line in input.lines() {
-        let (from, to) = line.split_once(": ").unwrap();
-        let to = to.split_whitespace().collect::<Vec<_>>();
-        map.insert(from, to);
-    }
-
     fn count_paths<'a>(
-        memo: &mut HashMap<(&'a str, bool, bool), u64>,
-        map: &HashMap<&str, Vec<&'a str>>,
+        memo: &mut HashMap<(&'a str, (bool, bool)), u64>,
+        map: &Graph<'a>,
         current: &'a str,
-        mut fft: bool,
-        mut dac: bool,
+        (fft, dac): (bool, bool),
     ) -> u64 {
-        let key = (current, fft, dac);
-        if let Some(memo) = memo.get(&key) {
+        let entry = (current, (fft, dac));
+        if let Some(memo) = memo.get(&entry) {
             return *memo;
         }
 
         if current == "out" {
-            if fft && dac {
-                return 1;
-            }
-            return 0;
+            return (fft && dac) as u64;
         }
 
-        if current == "fft" {
-            fft = true;
-        }
+        let seen = (fft || current == "fft", dac || current == "dac");
+        let out = (map[current].iter())
+            .map(|child| count_paths(memo, map, child, seen))
+            .sum();
 
-        if current == "dac" {
-            dac = true;
-        }
+        memo.insert(entry, out);
+        out
+    }
 
-        let mut out = 0;
-        for child in &map[current] {
-            out += count_paths(memo, map, child, fft, dac);
-        }
+    count_paths(&mut HashMap::new(), &parse(input), "svr", (false, false)).into()
+}
 
-        memo.insert(key, out);
-        out
+fn parse(input: &str) -> HashMap<&str, Vec<&str>> {
+    let mut map = HashMap::new();
+    for line in input.lines() {
+        let (from, to) = line.split_once(": ").unwrap();
+        let to = to.split_whitespace().collect::<Vec<_>>();
+        map.insert(from, to);
     }
 
-    count_paths(&mut HashMap::new(), &map, "svr", false, false).into()
+    map
 }
 
 #[cfg(test)]
 mod test {
     use indoc::indoc;
 
-    const CASE: &str = indoc! {"
+    const CASE_A: &str = indoc! {"
+        aaa: you hhh
+        you: bbb ccc
+        bbb: ddd eee
+        ccc: ddd eee fff
+        ddd: ggg
+        eee: out
+        fff: out
+        ggg: out
+        hhh: ccc fff iii
+        iii: out
+    "};
+
+    const CASE_B: &str = indoc! {"
         svr: aaa bbb
         aaa: fft
         fft: ccc
@@ -100,11 +94,11 @@ mod test {
 
     #[test]
     fn part_a() {
-        assert_eq!(super::part_a(CASE), 5.into());
+        assert_eq!(super::part_a(CASE_A), 5.into());
     }
 
     #[test]
     fn part_b() {
-        assert_eq!(super::part_b(CASE), 2.into());
+        assert_eq!(super::part_b(CASE_B), 2.into());
     }
 }