Year 2024 Day 21

Author: maneatingape

README.md

@@ -92,6 +92,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 18 | [RAM Run](https://adventofcode.com/2024/day/18) | [Source](src/year2024/day18.rs) | 42 |
 | 19 | [Linen Layout](https://adventofcode.com/2024/day/19) | [Source](src/year2024/day19.rs) | 118 |
 | 20 | [Race Condition](https://adventofcode.com/2024/day/20) | [Source](src/year2024/day20.rs) | 1354 |
+| 21 | [Keypad Conundrum](https://adventofcode.com/2024/day/21) | [Source](src/year2024/day21.rs) | 184 |
 | 22 | [Monkey Market](https://adventofcode.com/2024/day/22) | [Source](src/year2024/day22.rs) | 1350 |
 | 23 | [LAN Party](https://adventofcode.com/2024/day/23) | [Source](src/year2024/day23.rs) | 43 |
 

benches/benchmark.rs

@@ -88,5 +88,5 @@ benchmark!(year2023
 
 benchmark!(year2024
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15, day16, day17, day18, day19, day20, day22, day23
+    day14, day15, day16, day17, day18, day19, day20, day21, day22, day23
 );

src/lib.rs

@@ -68,5 +68,5 @@ library!(year2023 "Restore global snow production."
 
 library!(year2024 "Locate the Chief Historian in time for the big Christmas sleigh launch."
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15, day16, day17, day18, day19, day20, day22, day23
+    day14, day15, day16, day17, day18, day19, day20, day21, day22, day23
 );

src/main.rs

@@ -138,5 +138,5 @@ run!(year2023
 
 run!(year2024
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15, day16, day17, day18, day19, day20, day22, day23
+    day14, day15, day16, day17, day18, day19, day20, day21, day22, day23
 );

src/year2024/day21.rs

@@ -0,0 +1,149 @@
+use crate::util::hash::*;
+use crate::util::parse::*;
+use crate::util::point::*;
+
+type Cache = FastMap<(Vec<u8>, usize), usize>;
+
+pub fn parse(input: &str) -> &str {
+    input
+}
+
+pub fn part1(input: &str) -> usize {
+    chain(input, 3)
+}
+
+pub fn part2(input: &str) -> usize {
+    chain(input, 26)
+}
+
+fn chain(input: &str, limit: usize) -> usize {
+    let cache = &mut FastMap::with_capacity(500);
+    input
+        .lines()
+        .map(str::as_bytes)
+        .zip(input.iter_unsigned::<usize>())
+        .map(|(code, numeric)| dfs(cache, code, 0, limit) * numeric)
+        .sum()
+}
+
+fn dfs(cache: &mut Cache, slice: &[u8], depth: usize, limit: usize) -> usize {
+    if depth == limit {
+        return slice.len();
+    }
+
+    let key = (slice.to_vec(), depth);
+    if let Some(&previous) = cache.get(&key) {
+        return previous;
+    }
+
+    let mut shortest = usize::MAX;
+    let keypad = if depth == 0 { NUMERIC } else { DIRECTIONAL };
+
+    for sequence in combinations(slice, &keypad) {
+        let mut presses = 0;
+
+        for chunk in sequence.split_inclusive(|&b| b == b'A') {
+            presses += dfs(cache, chunk, depth + 1, limit);
+        }
+
+        shortest = shortest.min(presses);
+    }
+
+    cache.insert(key, shortest);
+    shortest
+}
+
+fn combinations(current: &[u8], keypad: &Keypad) -> Vec<Vec<u8>> {
+    let mut next = Vec::new();
+    pad_dfs(&mut next, &mut Vec::new(), keypad, current, 0, keypad.start);
+    next
+}
+
+fn pad_dfs(
+    combinations: &mut Vec<Vec<u8>>,
+    path: &mut Vec<u8>,
+    keypad: &Keypad,
+    sequence: &[u8],
+    depth: usize,
+    from: Point,
+) {
+    // Success
+    if depth == sequence.len() {
+        combinations.push(path.clone());
+        return;
+    }
+
+    // Failure
+    if from == keypad.gap {
+        return;
+    }
+
+    let to = keypad.lookup[sequence[depth] as usize];
+
+    if from == to {
+        // Push button.
+        path.push(b'A');
+        pad_dfs(combinations, path, keypad, sequence, depth + 1, from);
+        path.pop();
+    } else {
+        // Move towards button.
+        let mut step = |next: u8, direction: Point| {
+            path.push(next);
+            pad_dfs(combinations, path, keypad, sequence, depth, from + direction);
+            path.pop();
+        };
+
+        if to.x < from.x {
+            step(b'<', LEFT);
+        }
+        if to.x > from.x {
+            step(b'>', RIGHT);
+        }
+        if to.y < from.y {
+            step(b'^', UP);
+        }
+        if to.y > from.y {
+            step(b'v', DOWN);
+        }
+    }
+}
+
+struct Keypad {
+    start: Point,
+    gap: Point,
+    lookup: [Point; 128],
+}
+
+const NUMERIC: Keypad = {
+    let start = Point::new(2, 3);
+    let gap = Point::new(0, 3);
+    let mut lookup = [ORIGIN; 128];
+
+    lookup[b'7' as usize] = Point::new(0, 0);
+    lookup[b'8' as usize] = Point::new(1, 0);
+    lookup[b'9' as usize] = Point::new(2, 0);
+    lookup[b'4' as usize] = Point::new(0, 1);
+    lookup[b'5' as usize] = Point::new(1, 1);
+    lookup[b'6' as usize] = Point::new(2, 1);
+    lookup[b'1' as usize] = Point::new(0, 2);
+    lookup[b'2' as usize] = Point::new(1, 2);
+    lookup[b'3' as usize] = Point::new(2, 2);
+    lookup[b'0' as usize] = Point::new(1, 3);
+    lookup[b'A' as usize] = Point::new(2, 3);
+
+    Keypad { start, gap, lookup }
+};
+
+const DIRECTIONAL: Keypad = {
+    let start = Point::new(2, 0);
+    let gap = Point::new(0, 0);
+    let mut lookup = [ORIGIN; 128];
+
+    lookup[b'^' as usize] = Point::new(1, 0);
+    lookup[b'A' as usize] = Point::new(2, 0);
+    lookup[b'<' as usize] = Point::new(0, 1);
+    lookup[b'v' as usize] = Point::new(1, 1);
+    lookup[b'>' as usize] = Point::new(2, 1);
+
+    Keypad { start, gap, lookup }
+};

tests/test.rs

@@ -81,5 +81,5 @@ test!(year2023
 
 test!(year2024
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15, day16, day17, day18, day19, day20, day22, day23
+    day14, day15, day16, day17, day18, day19, day20, day21, day22, day23
 );

tests/year2024/day21.rs

@@ -0,0 +1,20 @@
+use aoc::year2024::day21::*;
+
+const EXAMPLE: &str = "\
+029A
+980A
+179A
+456A
+379A";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(input), 126384);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(input), 154115708116294);
+}