feat: 2024 Day 20

Author: mfulton26

2024/day/20/part/1/solve.test.ts

@@ -1,4 +1,4 @@
-import solve, { findSavedTimeCountsByCheating, parseTrack } from "./solve.ts";
+import { findSavedTimeCountsByCheating, parseTrack } from "./solve.ts";
 
 import { assertEquals } from "@std/assert";
 

2024/day/20/part/1/solve.ts

@@ -1,7 +1,5 @@
 const directions = [[0, -1], [0, 1], [-1, 0], [1, 0]];
 
-const factorials = [1, 1, 2];
-
 export function parseTrack(text: string) {
   return text.split("\n").map((line) => [...line]);
 }
@@ -13,7 +11,6 @@ function buildTimeTrack(track: string[][]) {
   const stack = [[xf, yf, 0]];
   const seen = new Set<`${number},${number}`>();
   while (stack.length) {
-    // console.log(stack.at(-1));
     const [x, y, t] = stack.pop()!;
     const hash = `${x},${y}` as const;
     if (seen.has(hash)) continue;
@@ -38,18 +35,17 @@ function* manhattanDirections(d: number) {
 export function findSavedTimeCountsByCheating(track: string[][]) {
   const result = new Map<number, number>();
   const timeTrack = buildTimeTrack(track);
+  const cheatTime = 2;
   for (let y = 0; y < timeTrack.length; y++) {
     for (let x = 0; x < timeTrack[y].length; x++) {
       const t = timeTrack[y][x];
       if (t === Infinity) continue;
-      for (const [dx, dy] of manhattanDirections(2)) {
+      for (const [dx, dy] of manhattanDirections(cheatTime)) {
         const rt = timeTrack[y + dy]?.[x + dx];
         if (!isFinite(rt)) continue;
-        const saved = t - rt - 2;
+        const saved = t - rt - cheatTime;
         if (saved <= 0) continue;
-        const ax = Math.abs(dx), ay = Math.abs(dy);
-        const count = factorials[2] / (factorials[ax] * factorials[ay]);
-        result.set(saved, (result.get(saved) ?? 0) + count);
+        result.set(saved, (result.get(saved) ?? 0) + 1);
       }
     }
   }

2024/day/20/part/2/solve.test.ts

@@ -0,0 +1,44 @@
+import { findSavedTimeCountsByCheating, parseTrack } from "./solve.ts";
+
+import { assertEquals } from "@std/assert";
+
+Deno.test("example", () => {
+  const input = `\
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############`;
+
+  const track = parseTrack(input);
+
+  assertEquals(
+    findSavedTimeCountsByCheating(track, { min: 50 }),
+    new Map([
+      [50, 32],
+      [52, 31],
+      [54, 29],
+      [56, 39],
+      [58, 25],
+      [60, 23],
+      [62, 20],
+      [64, 19],
+      [66, 12],
+      [68, 14],
+      [70, 12],
+      [72, 22],
+      [74, 4],
+      [76, 3],
+    ]),
+  );
+});

2024/day/20/part/2/solve.ts

@@ -0,0 +1,65 @@
+const directions = [[0, -1], [0, 1], [-1, 0], [1, 0]];
+
+export function parseTrack(text: string) {
+  return text.split("\n").map((line) => [...line]);
+}
+
+function buildTimeTrack(track: string[][]) {
+  const result = track.map((row) => row.map(() => Infinity));
+  const yf = track.findIndex((line) => line.includes("E")),
+    xf = track[yf].indexOf("E");
+  const stack = [[xf, yf, 0]];
+  const seen = new Set<`${number},${number}`>();
+  while (stack.length) {
+    const [x, y, t] = stack.pop()!;
+    const hash = `${x},${y}` as const;
+    if (seen.has(hash)) continue;
+    seen.add(hash);
+    if (track[y][x] === "#") continue;
+    result[y][x] = t;
+    for (const [dx, dy] of directions) stack.push([x + dx, y + dy, t + 1]);
+  }
+  return result;
+}
+
+function* manhattanDirections(d: number) {
+  for (let offset = 0; offset < d; offset++) {
+    const complement = d - offset;
+    yield [offset, complement];
+    yield [complement, -offset];
+    yield [-offset, -complement];
+    yield [-complement, offset];
+  }
+}
+
+export function findSavedTimeCountsByCheating(
+  track: string[][],
+  { min = 1 } = {},
+) {
+  const result = new Map<number, number>();
+  const timeTrack = buildTimeTrack(track);
+  for (let cheatTime = 2; cheatTime <= 20; cheatTime++) {
+    for (let y = 0; y < timeTrack.length; y++) {
+      for (let x = 0; x < timeTrack[y].length; x++) {
+        const t = timeTrack[y][x];
+        if (t === Infinity) continue;
+        for (const [dx, dy] of manhattanDirections(cheatTime)) {
+          const rt = timeTrack[y + dy]?.[x + dx];
+          if (!isFinite(rt)) continue;
+          const saved = t - rt - cheatTime;
+          if (saved < min) continue;
+          result.set(saved, (result.get(saved) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+export default function solve(input: string) {
+  const track = parseTrack(input);
+  let sum = 0;
+  const savedTimeCounts = findSavedTimeCountsByCheating(track);
+  for (const [saved, count] of savedTimeCounts) if (saved >= 100) sum += count;
+  return sum;
+}