Add solutions to day 21

Author: maxdavidson

src/day21/day21.test.ts

@@ -0,0 +1,21 @@
+import * as fs from "node:fs/promises";
+import { suite, test } from "node:test";
+
+import { part1, part2 } from "./day21.ts";
+
+const [INPUT, INPUT_TEST] = await Promise.all([
+  fs.readFile(new URL("input.txt", import.meta.url), "utf-8"),
+  fs.readFile(new URL("input-test.txt", import.meta.url), "utf-8"),
+]);
+
+suite("day21", () => {
+  test("part1", (t) => {
+    t.assert.equal(part1(INPUT_TEST), 126_384);
+    t.assert.equal(part1(INPUT), 134_120);
+  });
+
+  test("part2", (t) => {
+    t.assert.equal(part2(INPUT_TEST), 154_115_708_116_294);
+    t.assert.equal(part2(INPUT), 167_389_793_580_400);
+  });
+});

src/day21/day21.ts

@@ -0,0 +1,123 @@
+import { lines, memoize } from "../utils.ts";
+
+const GRID = "789456123 0A ^@<v>";
+const GRID_WIDTH = 3;
+const GRID_HEIGHT = GRID.length / GRID_WIDTH;
+
+const DIRECTIONS = [
+  [">", 1, 0],
+  ["v", 0, 1],
+  ["<", -1, 0],
+  ["^", 0, -1],
+] as const;
+
+const uniquePathsBetween = memoize(
+  (startTile, endTile) => `${startTile}${endTile}`,
+  (startTile: string, endTile: string): readonly string[] => {
+    const startPos = GRID.indexOf(startTile);
+    const endPos = GRID.indexOf(endTile);
+
+    if (startPos === -1 || endPos === -1) {
+      throw new RangeError("No tile pos found!");
+    }
+
+    const queue = [{ pos: startPos, seq: "" }];
+    const costs = new Map<number, number>();
+    const sequences = [];
+
+    let next;
+    while ((next = queue.shift()) !== undefined) {
+      const { pos, seq } = next;
+
+      if (pos === endPos) {
+        sequences.push(seq);
+        continue;
+      }
+
+      const x = pos % GRID_WIDTH;
+      const y = (pos - x) / GRID_WIDTH;
+
+      for (const [dir, dx, dy] of DIRECTIONS) {
+        const nextX = x + dx;
+        const nextY = y + dy;
+
+        if (
+          0 <= nextX &&
+          nextX < GRID_WIDTH &&
+          0 <= nextY &&
+          nextY < GRID_HEIGHT
+        ) {
+          const nextPos = GRID_WIDTH * nextY + nextX;
+          const nextSeq = seq + dir;
+          const nextCost = nextSeq.length;
+          const prevBestCost = costs.get(nextPos);
+          if (
+            GRID[nextPos] !== " " &&
+            (prevBestCost === undefined || nextCost <= prevBestCost)
+          ) {
+            costs.set(nextPos, nextCost);
+            queue.push({ pos: nextPos, seq: seq.concat(dir) });
+          }
+        }
+      }
+    }
+
+    return sequences;
+  },
+);
+
+const shortestSequenceLength = memoize(
+  (sequence, depth, limit) => `${sequence},${depth},${limit}`,
+  (sequence: string, depth: number, limit: number): number => {
+    if (depth > limit) {
+      return sequence.length;
+    }
+
+    let sequenceLength = 0;
+
+    let prevTile = depth === 0 ? "A" : "@";
+
+    for (let nextTile of sequence) {
+      if (0 < depth && nextTile === "A") {
+        nextTile = "@";
+      }
+
+      let shortestSubSequenceLength = Infinity;
+
+      for (const nextPath of uniquePathsBetween(prevTile, nextTile)) {
+        shortestSubSequenceLength = Math.min(
+          shortestSubSequenceLength,
+          shortestSequenceLength(nextPath + "@", depth + 1, limit),
+        );
+      }
+
+      sequenceLength += shortestSubSequenceLength;
+
+      prevTile = nextTile;
+    }
+
+    return sequenceLength;
+  },
+);
+
+function solve(input: string, limit: number): number {
+  const codes = lines(input);
+
+  let sum = 0;
+
+  for (const code of codes) {
+    const length = shortestSequenceLength(code, 0, limit);
+    const numeric = Number.parseInt(code.slice(0, -1));
+    sum += length * numeric;
+  }
+
+  return sum;
+}
+
+export function part1(input: string): number {
+  return solve(input, 2);
+}
+
+export function part2(input: string): number {
+  return solve(input, 25);
+}

src/day21/input-test.txt

@@ -0,0 +1,5 @@
+029A
+980A
+179A
+456A
+379A

src/day21/input.txt

@@ -0,0 +1,5 @@
+789A
+540A
+285A
+140A
+189A