feat: day 15 warehouse woes 1/2 soln, #24

Author: weaponsforge

src/2024/2024-12-06/lib/guard.types.ts

@@ -3,9 +3,9 @@
  *
  * @enum {string}
  * @property {string} UP - Upward direction `"^"`
- * @property {string} RIGHT - Upward direction `">"`
- * @property {string} DOWN - Upward direction `"v"`
- * @property {string} LEFT - Upward direction `"<"`
+ * @property {string} RIGHT - Right direction `">"`
+ * @property {string} DOWN - Downward direction `"v"`
+ * @property {string} LEFT - Left direction `"<"`
  */
 export enum GuardDirection {
   UP = '^',

src/2024/2024-12-15/README.md

@@ -5,6 +5,23 @@ Visit the Advent of Code website for more information on this puzzle at:
 **Source:** https://adventofcode.com/2024/day/15<br>
 **Status:** On-going ⭐
 
+## Code
+
+### `robot.ts`
+
+**Robot** class
+
+- Manages the `Robot` object that runs across the grid and moves boxes
+- **`findInitialPosition()`** - Finds the robot's initial `Point` position in the 2D grid and stores them in the `this.pos` object
+- **`readInstruction()`** - Reads the next instruction and sets the (y,x) direction
+- **`walk()`** - Increments the robot's (y,x) coordinate by direction
+- **`next()`** - Finds the next (y,x) coordinate of the robot or a given `Point` parameter.
+
+### `calculateGPS.ts`
+
+- **`moveBoxes()`** - Moves the robot and boxes across the grid
+- **`calculateGPS()`** - Calculates the GPS sum of all boxes in the grid
+
 ## Notes
 
 ### Main Objects

src/2024/2024-12-15/input.txt

@@ -0,0 +1,10 @@
+########
+#..O.O.#
+##@.O..#
+#...O..#
+#.#.O..#
+#...O..#
+#......#
+########
+
+<^>>v>>^v

src/2024/2024-12-15/input2.txt

@@ -0,0 +1,15 @@
+##########
+#..O..O.O#
+#......O.#
+#.OO..O.O#
+#..O@..O.#
+#O#..O...#
+#O..O..O.#
+#.OO.O.OO#
+#....O...#
+##########
+
+<vv>^<v^>v>^vv^v>v<>v^v<v<^vv<<<^><<><>>v<vvv<>^v^>^<<<><<v<<<v^vv^v>^
+vvv<<^>^v^^><<>>><>^<<><^vv^^<>vvv<>><^^v>^>vv<>v<<<<v<^v>^<^^>>>^<v<v
+><>vv>v^v^<>><>>>><^^>vv>v<^^^>>v^v^<^^>v^^>v^<^v>v<>>v^v^<v>v^^<^^vv<
+<<v<^>>^^^^>>>v^<>vvv^><v<<<>^^^vv^<vvv>^>v<^^^^v<>^>vvvv><>>v^<<^^^^^

src/2024/2024-12-15/lib/calculateGPS.ts

@@ -0,0 +1,79 @@
+import type { Point } from '@/aoc/point/types.js'
+
+import { getCoordinateSymbol, isOutOfBounds } from '@/aoc/grid/utils.js'
+import { Robot } from './robot.js'
+
+/**
+ * Moves the robot and boxes across the grid
+ * @param {string[][]} grid - 2D string array containing walls, boxes and space data
+ * @param {string[]} instructions - String array containing the robot's move instructions
+ * @returns {void}
+ */
+export const moveBoxes = (grid: string[][], instructions: string[]): void => {
+  const dimensions = { length: grid.length, width: grid[0]!.length }
+  const robot = new Robot(grid, instructions)
+
+  while (robot.instructions.length > 0) {
+    robot.readInstruction()
+
+    let nextPos = robot.next()
+    let nextSymbol = getCoordinateSymbol(nextPos, grid)?.symbol
+
+    // Move robot to the next blank space
+    if (nextSymbol === '.') {
+      grid[robot.pos.y]![robot.pos.x] = '.'
+      grid[nextPos.y]![nextPos.x] = robot.symbol
+      robot.walk()
+    }
+
+    // Find connected boxes until a space symbol
+    if (nextSymbol === 'O') {
+      const boxes: Point[] = [nextPos]
+
+      while (!isOutOfBounds(nextPos, dimensions) && nextSymbol === 'O') {
+        nextPos = robot.next(nextPos)
+        nextSymbol = getCoordinateSymbol(nextPos, grid)?.symbol
+
+        if (nextSymbol === 'O') {
+          boxes.push(nextPos)
+        }
+      }
+
+      // Move groups of boxes if there's a space at their end
+      if (nextSymbol === '.' && boxes.length > 0) {
+        for (let i = boxes.length - 1; i >= 0; i -= 1) {
+          const next = robot.next(boxes[i])
+
+          grid[boxes[i]!.y]![boxes[i]!.x] = '.'
+          grid[next.y]![next.x] = 'O'
+        }
+
+        // Move the robot
+        grid[robot.pos.y]![robot.pos.x] = '.'
+        robot.walk()
+
+        grid[robot.pos.y]![robot.pos.x] = robot.symbol
+      }
+    }
+  }
+}
+
+/**
+ * Calculates the GPS sum of all boxes in the grid
+ * @param {string[][]} grid - 2D string array containing walls, boxes and space data
+ * @returns {number} GPS sum of all boxes in the grid
+ */
+export const calculateGPS = (grid: string[][]): number => {
+  const dimensions = { length: grid.length, width: grid[0]!.length }
+  let sumGPS = 0
+
+  for (let y = 0; y < dimensions.length; y += 1) {
+    for (let x = 0; x < dimensions.width; x += 1) {
+      if (grid[y]![x] === 'O') {
+        sumGPS += y * 100 + x
+      }
+    }
+  }
+
+  return sumGPS
+}

src/2024/2024-12-15/lib/fileReader.ts

@@ -0,0 +1,39 @@
+import type { RobotWarehouseData } from './types.js'
+
+import { AOCOutputType, readAOCInputFile } from '@/aoc/file/aocfile.js'
+import { file } from '@/aoc/file/utils.js'
+
+/**
+ * Reads and formats the day 15 quiz input file.
+ * @param {string} fileName - Input text filename path relative to this script
+ * @returns {RobotWarehouseData} Quiz input data
+ */
+export const fileReader = (fileName: string): RobotWarehouseData => {
+  const input = readAOCInputFile({
+    filePath: file(import.meta.url, fileName),
+    type: AOCOutputType.STRING
+  }) as string
+
+  return input
+    .split('\n\n')
+    .reduce((data, item, index) => {
+      // Grid
+      if (index === 0) {
+        return {
+          ...data,
+          grid: item
+            .split('\n')
+            .map(line => line.split(''))
+        }
+      }
+
+      // Instructions
+      return {
+        ...data,
+        instructions: item
+          .split('')
+          .reverse()
+          .filter(direction => direction !== '\n')
+      }
+    }, {}) as RobotWarehouseData
+}

src/2024/2024-12-15/lib/robot.ts

@@ -0,0 +1,89 @@
+import { GuardDirection } from '@/2024/2024-12-06/lib/guard.types.js'
+import { getGridCoordinate } from '@/aoc/grid/utils.js'
+import type { Point } from '@/aoc/point/types.js'
+
+/**
+ * @class Robot
+ * @description A set of methods, objects and variables for managing a `Robot`
+ */
+export class Robot {
+  /** Symbol representation in the grid */
+  symbol: string = '@'
+
+  /** Current (y,x) grid coordinate */
+  pos: Point = { x: -1, y: -1 }
+
+  /** Direction indicator up/down/left/right */
+  direction: Point = { x: 0, y: 0 }
+
+  /** Current active move instruction symbol */
+  instruction: GuardDirection | '-' = '-'
+
+  /** Moves instructions set */
+  instructions: string[]
+
+  /**
+   * @constructor
+   * @param {string[][]} grid - 2D string array grid
+   */
+  constructor (grid: string[][], instructions: string[]) {
+    this.findInitialPosition(grid)
+    this.instructions = [...instructions]
+  }
+
+  /**
+   * Finds the robot's initial `Point` position in the 2D grid, storing them in the `this.pos` object
+   * @param {string[][]} grid - 2D string array grid
+   */
+  findInitialPosition (grid: string[][]): void {
+    const start = getGridCoordinate(grid, this.symbol)
+
+    this.pos.x = start.x
+    this.pos.y = start.y
+  }
+
+  /** Reads the next instruction and sets the (y,x) direction */
+  readInstruction (): void {
+    this.instruction = this.instructions.pop() as GuardDirection || '-'
+
+    switch(this.instruction) {
+    case GuardDirection.UP:
+      this.direction = { x: 0, y: -1 }
+      break
+    case GuardDirection.DOWN:
+      this.direction = { x: 0, y: 1 }
+      break
+    case GuardDirection.LEFT:
+      this.direction = { x: -1, y: 0 }
+      break
+    case GuardDirection.RIGHT:
+      this.direction = { x: 1, y: 0 }
+      break
+    default:
+      break
+    }
+  }
+
+  /** Increments the robot's (y,x) coordinate by direction */
+  walk (): void {
+    this.pos.x += this.direction.x
+    this.pos.y += this.direction.y
+  }
+
+  /**
+   * Finds the next (y,x) coordinate of the robot or a given `Point` parameter.
+   * @param {Point} [point] - (Optional) (y,x) coordinate to find the next step coorndinate from
+   * @returns {Point} Next (y,x) coordinate after 1 step
+   */
+  next (point?: Point): Point {
+    const x = point?.x || this.pos.x
+    const y = point?.y || this.pos.y
+
+    const nextX = x + this.direction.x
+    const nextY = y + this.direction.y
+
+    return {
+      x: nextX, y: nextY
+    }
+  }
+}

src/2024/2024-12-15/lib/types.ts

@@ -0,0 +1,9 @@
+/**
+ * @type {Object} RobotWarehouseData
+ * @property {string[][]} grid - 2D string array containng walls, boxes, spaces and robot symbols
+ * @property {string[]} instructions - String array contaning the robot's move instructions
+ */
+export type RobotWarehouseData = {
+  grid: string[][];
+  instructions: string[];
+}

src/2024/2024-12-15/main.ts

@@ -0,0 +1,17 @@
+import { fileReader } from './lib/fileReader.js'
+import { moveBoxes, calculateGPS } from './lib/calculateGPS.js'
+
+/**
+ * Part 1/2 of the 2024-12-15 quiz
+ * Moves the robot, boxes and calculates all boxes' GPS
+ */
+const quiz20241215_01 = () => {
+  const { grid, instructions } = fileReader('../input.txt')
+
+  moveBoxes(grid, instructions)
+  const gps = calculateGPS(grid)
+
+  console.log('---GPS', gps)
+}
+
+quiz20241215_01()

src/2024/2024-12-15/sample.test.ts

@@ -0,0 +1,15 @@
+import { test, expect } from 'vitest'
+
+import { fileReader } from './lib/fileReader.js'
+import { moveBoxes, calculateGPS } from './lib/calculateGPS.js'
+
+test('Part 1: Move boxes and calculate GPS', () => {
+  const data = fileReader('../input.txt')
+  const data2 = fileReader('../input2.txt')
+
+  moveBoxes(data.grid, data.instructions)
+  expect(calculateGPS(data.grid)).toBe(2027)
+
+  moveBoxes(data2.grid, data2.instructions)
+  expect(calculateGPS(data2.grid)).toBe(9897)
+})