Add solution for puzzle 14 (both)

Author: AlexeyMz

src/core/math.mts

@@ -0,0 +1,88 @@
+export function modulo(a: number, b: number): number {
+  return (a % b + b) % b;
+}
+
+export function lcm(a: number, b: number): number {
+  return (a / gcd(a, b)) * b;
+}
+
+export function gcd(a: number, b: number): number {
+  let x = a;
+  let y = b;
+  if (x < y) {
+    [x, y] = [y, x];
+  }
+  while (y !== 0) {
+    const reminder = x % y;
+    x = y;
+    y = reminder;
+  }
+  return x;
+}
+
+export function extendedEuclidean(a: number, b: number): [s: number, t: number] {
+  if (a <= 0 || b <= 0) {
+    throw new Error('Arguments to extended Euclidean algorithm must be positive');
+  }
+
+  let sa = 1;
+  let sb = 0;
+  let ta = 0;
+  let tb = 1;
+
+  while (b > 0) {
+    const q = Math.floor(a / b);
+
+    const r = a - b * q;
+    const sr = sa - sb * q;
+    const tr = ta - tb * q;
+
+    [a, b] = [b, r];
+    [sa, sb] = [sb, sr];
+    [ta, tb] = [tb, tr];
+  }
+
+  return [sa, ta];
+}
+
+export function chineseRemainderTheorem(
+  input: ReadonlyArray<readonly [modulus: number, remainder: number]>
+): number {
+  for (let i = 0; i < input.length; i++) {
+    for (let j = i + 1; j < input.length; j++) {
+      const [modulusA] = input[i];
+      const [modulusB] = input[j];
+      if (gcd(modulusA, modulusB) !== 1) {
+        throw new Error(`Non-coprime mod for CTR: ${modulusA}, ${modulusB}`);
+      }
+    }
+  }
+
+  let solution = 0n;
+
+  const grandMod = input.reduce((acc, [modulus]) => acc * BigInt(modulus), 1n);
+  for (let i = 0; i < input.length; i++) {
+    const [m, r] = input[i];
+    if (!(m > 0 && r >= 0)) {
+      throw new Error(`CTR modulus must be > 0 and remainder >= 0`);
+    }
+    const coMod = Number(grandMod / BigInt(m));
+    let [inverse] = extendedEuclidean(coMod, m);
+    if (inverse < 0) {
+      inverse += m;
+    }
+    solution += BigInt(coMod) * BigInt(inverse) * BigInt(r);
+  }
+
+  return Number(solution % grandMod);
+}
+
+export function gaussArea(points: ReadonlyArray<readonly [number, number]>): number {
+  let total = 0;
+  for (let i = 0; i < points.length; i++) {
+    const [x0, y0] = i === 0 ? points[points.length - 1] : points[i - 1];
+    const [x1, y1] = points[i];
+    total += x0 * y1 - x1 * y0;
+  }
+  return Math.abs(total) / 2;
+}

src/puzzle14.mts

@@ -0,0 +1,152 @@
+import { readFile, writeFile } from 'node:fs/promises';
+
+import { NumericGrid, CharGrid } from './core/grid.mjs';
+import { modulo } from './core/math.mjs';
+import { Stopwatch } from './core/performance.mjs';
+import { getDataPath } from './core/project.mjs';
+
+export async function solvePuzzleBasic() {
+  const content = await readFile(getDataPath('input/puzzle14.txt'), {encoding: 'utf8'});
+  const robots = parseRobots(content);
+
+  // const room = NumericGrid.empty(7, 11);
+  const room = NumericGrid.empty(103, 101);
+
+  const roomSize: Vector = [room.columns, room.rows];
+  for (const robot of robots) {
+    const [x, y] = robotPositionAfterTime(robot, 100, roomSize);
+    room.set(y, x, room.get(y, x) + 1);
+  }
+
+  await writeFile(
+    getDataPath('output/puzzle14_after100.txt'),
+    Array.from(CharGrid.from(room, countToChar).lines()).join(''),
+    {encoding: 'utf8'}
+  );
+
+  const factor = computeSafetyFactor(room);
+  console.log(`Puzzle 14 (basic): ${factor}`);
+}
+
+export async function solvePuzzleAdvanced() {
+  const content = await readFile(getDataPath('input/puzzle14.txt'), {encoding: 'utf8'});
+  const robots = parseRobots(content);
+
+  const room = NumericGrid.empty(103, 101);
+
+  const roomSize: Vector = [room.columns, room.rows];
+  const factors: number[] = [];
+  let targetTime: number | undefined;
+  for (let i = 0; i < 10_000; i++) {
+    room.fill(0);
+    for (const robot of robots) {
+      const [x, y] = robotPositionAfterTime(robot, i, roomSize);
+      room.set(y, x, room.get(y, x) + 1);
+    }
+    const factor = computeSafetyFactor(room);
+    factors.push(factor);
+    if (targetTime === undefined && factor < 50_000_000) {
+      targetTime = i;
+    }
+  }
+
+  await writeFile(
+    getDataPath('output/puzzle14_factors.txt'),
+    factors.map(f => String(f)).join('\n'),
+    {encoding: 'utf8'}
+  );
+
+  if (targetTime !== undefined) {
+    room.fill(0);
+    for (const robot of robots) {
+      const [x, y] = robotPositionAfterTime(robot, targetTime, roomSize);
+      room.set(y, x, room.get(y, x) + 1);
+    }
+    await writeFile(
+      getDataPath('output/puzzle14_easterEgg.txt'),
+      Array.from(CharGrid.from(room, countToChar).lines()).join(''),
+      {encoding: 'utf8'}
+    );
+  }
+
+  console.log(`Puzzle 14 (advanced): ${targetTime}`);
+}
+
+type Vector = readonly [x: number, y: number];
+
+interface Robot {
+  readonly index: number;
+  readonly position: Vector;
+  readonly velocity: Vector;
+}
+
+function parseRobots(content: string): Robot[] {
+  const result: Robot[] = [];
+
+  for (const line of content.split(/\r?\n/)) {
+    if (!line) {
+      continue;
+    }
+    const match = /^p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)$/.exec(line);
+    if (!match) {
+      throw new Error(`Invalid robot line: ${line}`);
+    }
+    const [, x, y, vx, vy] = Array.from(match, n => Number(n));
+    result.push({
+      index: result.length,
+      position: [x, y],
+      velocity: [vx, vy],
+    });
+  }
+
+  return result;
+}
+
+function robotPositionAfterTime(robot: Robot, seconds: number, roomSize: Vector): Vector {
+  let [x, y] = robot.position;
+  const [vx, vy] = robot.velocity;
+  const [width, height] = roomSize;
+  const rx = modulo(x + vx * seconds, width);
+  const ry = modulo(y + vy * seconds, height);
+  return [rx, ry];
+}
+
+function computeSafetyFactor(room: NumericGrid): number {
+  const halfRow = Math.floor(room.rows / 2);
+  const halfColumn = Math.floor(room.columns / 2);
+  let totalTL = 0;
+  let totalTR = 0;
+  let totalBL = 0;
+  let totalBR = 0;
+  for (let i = 0; i < room.rows; i++) {
+    for (let j = 0; j < room.columns; j++) {
+      const count = room.get(i, j);
+      if (i < halfRow) {
+        if (j < halfColumn) {
+          totalTL += count;
+        } else if (j > halfColumn) {
+          totalBL += count;
+        }
+      } else if (i > halfRow) {
+        if (j < halfColumn) {
+          totalTR += count;
+        } else if (j > halfColumn) {
+          totalBR += count;
+        }
+      }
+    }
+  }
+  return totalTL * totalTR * totalBL * totalBR;
+}
+
+const COUNT_TO_CHAR = '.123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+function countToChar(n: number): string {
+  return COUNT_TO_CHAR[n] ?? '!';
+}
+
+(async function main() {
+  using _ = Stopwatch.start();
+  await solvePuzzleBasic();
+  await solvePuzzleAdvanced();
+})();