Upload aoc.csv

aoc.csv

@@ -16102,8 +16102,7 @@ def simulate_motion(positions, velocities, num_x=101, num_y=103, steps=10000):
 
 if __name__ == ""__main__"":
     positions, velocities = read_input(""input.txt"")
-    simulate_motion(positions, velocities)
-",python:3.9.21-slim
+    simulate_motion(positions, velocities)",python:3.9.21-slim
 2024,14,2,"--- Day 14: Restroom Redoubt ---
 
 One of The Historians needs to use the bathroom; fortunately, you know there's a bathroom near an unvisited location on their list, and so you're all quickly teleported directly to the lobby of Easter Bunny Headquarters.
@@ -16393,8 +16392,7 @@ for T in range(R*C):
     while '#'*t in S: t += 1
     if t > B[0]: B = (t, T)
     if T == 100: print('Part 1:', Z[0]*Z[1]*Z[2]*Z[3])
-print('Part 2:', B[1])
-",python:3.9.21-slim
+print('Part 2:', B[1])",python:3.9.21-slim
 2024,14,2,"--- Day 14: Restroom Redoubt ---
 
 One of The Historians needs to use the bathroom; fortunately, you know there's a bathroom near an unvisited location on their list, and so you're all quickly teleported directly to the lobby of Easter Bunny Headquarters.
@@ -16587,8 +16585,7 @@ print(""at second: "", found_at_second)
 # O(WIDE * TALL * n) so kindof O(n) :)
 
 # Total space complexity
-# O(WIDE * TALL + n) so kindof O(n) :)
-",python:3.9.21-slim
+# O(WIDE * TALL + n) so kindof O(n) :)",python:3.9.21-slim
 2024,14,2,"--- Day 14: Restroom Redoubt ---
 
 One of The Historians needs to use the bathroom; fortunately, you know there's a bathroom near an unvisited location on their list, and so you're all quickly teleported directly to the lobby of Easter Bunny Headquarters.
@@ -16768,9 +16765,7 @@ for i in range(1, 100000):
   #the tree picture has 31 robots in a single row 
   if max_sum > 30:
     print(i)
-    break
-
-",python:3.9.21-slim
+    break",python:3.9.21-slim
 2024,15,1,"--- Day 15: Warehouse Woes ---
 
 You appear back inside your own mini submarine! Each Historian drives their mini submarine in a different direction; maybe the Chief has his own submarine down here somewhere as well?
@@ -27627,12 +27622,161 @@ The keypads form a chain, just like before: your directional keypad controls a r
 
 The door codes are the same this time around; only the number of robots and directional keypads has changed.
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,"from part1 import parse_input, solve
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,"import sys
+from collections import Counter
+from functools import cache
 
-if __name__ == ""__main__"":
-    input_data = parse_input('input.txt')
-    result = sum(solve(sequence, 0, 25) * multiplier for sequence, multiplier in input_data)
-    print(result)",python:3.9.21-slim
+
+def test_input():
+    _input = """"""029A
+980A
+179A
+456A
+379A"""""".strip().split('\n')
+
+    assert part_1(_input) == 126384
+
+
+class Pad:
+    LOOKUPS = {}
+
+    def inputs(self, sequence: str):
+        inputs = []
+
+        def _inputs(result, current, sequence):
+            if len(sequence) == 0:
+                inputs.append(result)
+                return
+            for move in self._inputs(current, sequence[0]):
+                _inputs(result + move, sequence[0], sequence[1:])
+
+        _inputs('', 'A', sequence)
+
+        return inputs
+
+    def _inputs(self, start: str, end: str):
+        sx, sy = self.LOOKUPS[start]
+        ex, ey = self.LOOKUPS[end]
+        dx, dy = ex - sx, ey - sy
+
+        x_str = '<' * -dx if dx < 0 else '>' * dx
+        y_str = '^' * -dy if dy < 0 else 'v' * dy
+
+        value = []
+        if dy != 0 and (sx, sy + dy) != self.LOOKUPS[' ']:
+            value.append(f'{y_str}{x_str}A')
+        if dx != 0 and (sx + dx, sy) != self.LOOKUPS[' ']:
+            value.append(f'{x_str}{y_str}A')
+        if dx == dy == 0:
+            value.append('A')
+
+        return value
+
+
+class Numpad(Pad):
+    """"""
+    A class representing a numpad with a specific layout.
+
+    The numpad layout is as follows:
+    +---+---+---+
+    | 7 | 8 | 9 |
+    +---+---+---+
+    | 4 | 5 | 6 |
+    +---+---+---+
+    | 1 | 2 | 3 |
+    +---+---+---+
+        | 0 | A |
+        +---+---+
+
+    Attributes:
+        LOOKUPS (dict): A dictionary containing lookup values for the numpad.
+    """"""
+
+    LOOKUPS = {
+        '7': (0, 0),
+        '8': (1, 0),
+        '9': (2, 0),
+        '4': (0, 1),
+        '5': (1, 1),
+        '6': (2, 1),
+        '1': (0, 2),
+        '2': (1, 2),
+        '3': (2, 2),
+        ' ': (0, 3),
+        '0': (1, 3),
+        'A': (2, 3),
+    }
+
+
+class Dirpad(Pad):
+    """"""
+    A class representing a direction pad with a specific layout.
+    
+    The direction pad layout is as follows:
+        +---+---+
+        | ^ | A |
+    +---+---+---+
+    | < | v | > |
+    +---+---+---+
+
+    Attributes:
+        LOOKUPS (dict): A dictionary containing lookup values for the direction pad.
+    """"""
+
+    LOOKUPS = {
+        ' ': (0, 0),
+        '^': (1, 0),
+        'A': (2, 0),
+        '<': (0, 1),
+        'v': (1, 1),
+        '>': (2, 1),
+    }
+
+
+def read_input(path: str) -> list[str]:
+    with open(path) as input_file:
+        return [line.strip() for line in input_file]
+
+
+@cache
+def shortest(sequence: str, depth: int):
+    dirpad = Dirpad()
+    if depth == 0:
+        return len(sequence)
+
+    total = 0
+    for sub in sequence.split('A')[:-1]:
+        sequences = dirpad.inputs(sub + 'A')
+        total += min(shortest(seq, depth - 1) for seq in sequences)
+    return total
+
+
+def score_at_depth(input_data: list[str], depth: int) -> int:
+    total = 0
+    numpad = Numpad()
+    for code in input_data:
+        numcode = numpad.inputs(code)
+        min_len = min(shortest(nc, depth) for nc in numcode)
+        total += min_len * int(code[:-1])
+    return total
+
+
+def part_1(input_data: list[str]) -> int:
+    return score_at_depth(input_data, 2)
+
+
+def part_2(input_data: list[str]) -> int:
+    return score_at_depth(input_data, 25)
+
+
+def main():
+    input_data = read_input(sys.argv[1])
+    print(f'Part 1: {part_1(input_data)}')
+    print(f'Part 2: {part_2(input_data)}')
+
+
+if __name__ == '__main__':
+    main()",python:3.9.21-slim
 2024,21,2,"--- Day 21: Keypad Conundrum ---
 
 As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
@@ -51732,210 +51876,209 @@ for (let i = 1; i < 100000; i++) {
         console.log(""Tree appears at second:"", i);
         break;
     }
-}
-",node:14
-2024,14,2,"--- Day 14: Restroom Redoubt ---
-
-One of The Historians needs to use the bathroom; fortunately, you know there's a bathroom near an unvisited location on their list, and so you're all quickly teleported directly to the lobby of Easter Bunny Headquarters.
-
-Unfortunately, EBHQ seems to have ""improved"" bathroom security again after your last visit. The area outside the bathroom is swarming with robots!
-
-To get The Historian safely to the bathroom, you'll need a way to predict where the robots will be in the future. Fortunately, they all seem to be moving on the tile floor in predictable straight lines.
-
-You make a list (your puzzle input) of all of the robots' current positions (p) and velocities (v), one robot per line. For example:
-
-p=0,4 v=3,-3
-p=6,3 v=-1,-3
-p=10,3 v=-1,2
-p=2,0 v=2,-1
-p=0,0 v=1,3
-p=3,0 v=-2,-2
-p=7,6 v=-1,-3
-p=3,0 v=-1,-2
-p=9,3 v=2,3
-p=7,3 v=-1,2
-p=2,4 v=2,-3
-p=9,5 v=-3,-3
-Each robot's position is given as p=x,y where x represents the number of tiles the robot is from the left wall and y represents the number of tiles from the top wall (when viewed from above). So, a position of p=0,0 means the robot is all the way in the top-left corner.
-
-Each robot's velocity is given as v=x,y where x and y are given in tiles per second. Positive x means the robot is moving to the right, and positive y means the robot is moving down. So, a velocity of v=1,-2 means that each second, the robot moves 1 tile to the right and 2 tiles up.
-
-The robots outside the actual bathroom are in a space which is 101 tiles wide and 103 tiles tall (when viewed from above). However, in this example, the robots are in a space which is only 11 tiles wide and 7 tiles tall.
-
-The robots are good at navigating over/under each other (due to a combination of springs, extendable legs, and quadcopters), so they can share the same tile and don't interact with each other. Visually, the number of robots on each tile in this example looks like this:
-
-1.12.......
-...........
-...........
-......11.11
-1.1........
-.........1.
-.......1...
-These robots have a unique feature for maximum bathroom security: they can teleport. When a robot would run into an edge of the space they're in, they instead teleport to the other side, effectively wrapping around the edges. Here is what robot p=2,4 v=2,-3 does for the first few seconds:
-
-Initial state:
-...........
-...........
-...........
-...........
-..1........
-...........
-...........
-
-After 1 second:
-...........
-....1......
-...........
-...........
-...........
-...........
-...........
-
-After 2 seconds:
-...........
-...........
-...........
-...........
-...........
-......1....
-...........
-
-After 3 seconds:
-...........
-...........
-........1..
-...........
-...........
-...........
-...........
-
-After 4 seconds:
-...........
-...........
-...........
-...........
-...........
-...........
-..........1
-
-After 5 seconds:
-...........
-...........
-...........
-.1.........
-...........
-...........
-...........
-The Historian can't wait much longer, so you don't have to simulate the robots for very long. Where will the robots be after 100 seconds?
-
-In the above example, the number of robots on each tile after 100 seconds has elapsed looks like this:
-
-......2..1.
-...........
-1..........
-.11........
-.....1.....
-...12......
-.1....1....
-To determine the safest area, count the number of robots in each quadrant after 100 seconds. Robots that are exactly in the middle (horizontally or vertically) don't count as being in any quadrant, so the only relevant robots are:
-
-..... 2..1.
-..... .....
-1.... .....
-           
-..... .....
-...12 .....
-.1... 1....
-In this example, the quadrants contain 1, 3, 4, and 1 robot. Multiplying these together gives a total safety factor of 12.
-
-Predict the motion of the robots in your list within a space which is 101 tiles wide and 103 tiles tall. What will the safety factor be after exactly 100 seconds have elapsed?
-
-Your puzzle answer was 219150360.
-
---- Part Two ---
-
-During the bathroom break, someone notices that these robots seem awfully similar to ones built and used at the North Pole. If they're the same type of robots, they should have a hard-coded Easter egg: very rarely, most of the robots should arrange themselves into a picture of a Christmas tree.
-
-What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"import { readFileSync } from 'node:fs';
-
-// Constants
-const WIDTH = 101;
-const HEIGHT = 103;
-const SECONDS = 100;
-
-// Read input data
-const inputData = readFileSync('input.txt', { encoding: 'utf8', flag: 'r' });
-
-// Robot class definition
-class Robot {
-  constructor(initialState) {
-    const { px, py, vx, vy } = /p=(?<px>-{0,1}\d+),(?<py>-{0,1}\d+) v=(?<vx>-{0,1}\d+),(?<vy>-{0,1}\d+)/.exec(initialState).groups;
-    this.position = { x: parseInt(px), y: parseInt(py) };
-    this.velocity = { x: parseInt(vx), y: parseInt(vy) };
-  }
-
-  move() {
-    this.position.x = (this.position.x + this.velocity.x + WIDTH) % WIDTH;
-    this.position.y = (this.position.y + this.velocity.y + HEIGHT) % HEIGHT;
-  }
-
-  isWithinBounds(topLeft, bottomRight) {
-    return (
-      topLeft.x <= this.position.x && this.position.x < bottomRight.x &&
-      topLeft.y <= this.position.y && this.position.y < bottomRight.y
-    );
-  }
-}
-
-// Parse input and initialize robots
-const robots = inputData
-  .split('\n')
-  .filter(line => line.trim())
-  .map(line => new Robot(line));
-
-// Simulate robot movements for the initial period
-for (let i = 0; i < SECONDS; i++) {
-  robots.forEach(robot => robot.move());
-}
-
-// Calculate quadrant counts
-const quadrants = [
-  { topLeft: { x: 0, y: 0 }, bottomRight: { x: Math.floor(WIDTH / 2), y: Math.floor(HEIGHT / 2) } },
-  { topLeft: { x: Math.ceil(WIDTH / 2), y: 0 }, bottomRight: { x: WIDTH, y: Math.floor(HEIGHT / 2) } },
-  { topLeft: { x: 0, y: Math.ceil(HEIGHT / 2) }, bottomRight: { x: Math.floor(WIDTH / 2), y: HEIGHT } },
-  { topLeft: { x: Math.ceil(WIDTH / 2), y: Math.ceil(HEIGHT / 2) }, bottomRight: { x: WIDTH, y: HEIGHT } }
-];
-
-const quadrantCounts = quadrants.map(({ topLeft, bottomRight }) =>
-  robots.reduce((count, robot) => robot.isWithinBounds(topLeft, bottomRight) ? count + 1 : count, 0)
-);
-
-console.log(quadrantCounts.reduce((product, count) => product * count, 1));
-
-// Extended simulation to find a stable pattern
-for (let i = SECONDS; i < 19000; i++) {
-  const grid = Array.from({ length: HEIGHT }, () => Array(WIDTH).fill('.'));
-  let robotsInCentralArea = 0;
-
-  robots.forEach(robot => {
-    const { x, y } = robot.position;
-    grid[y][x] = '#';
-
-    if (robot.isWithinBounds(
-      { x: Math.floor(WIDTH * 0.25), y: Math.floor(HEIGHT * 0.25) },
-      { x: Math.floor(WIDTH * 0.75), y: Math.floor(HEIGHT * 0.75) }
-    )) {
-      robotsInCentralArea++;
-    }
-
-    robot.move();
-  });
-
-  if (robotsInCentralArea >= Math.floor(robots.length / 2)) {
-    console.log(i);
-    grid.forEach(row => console.log(row.join('')));
-    break;
-  }
+}",node:14
+2024,14,2,"--- Day 14: Restroom Redoubt ---
+
+One of The Historians needs to use the bathroom; fortunately, you know there's a bathroom near an unvisited location on their list, and so you're all quickly teleported directly to the lobby of Easter Bunny Headquarters.
+
+Unfortunately, EBHQ seems to have ""improved"" bathroom security again after your last visit. The area outside the bathroom is swarming with robots!
+
+To get The Historian safely to the bathroom, you'll need a way to predict where the robots will be in the future. Fortunately, they all seem to be moving on the tile floor in predictable straight lines.
+
+You make a list (your puzzle input) of all of the robots' current positions (p) and velocities (v), one robot per line. For example:
+
+p=0,4 v=3,-3
+p=6,3 v=-1,-3
+p=10,3 v=-1,2
+p=2,0 v=2,-1
+p=0,0 v=1,3
+p=3,0 v=-2,-2
+p=7,6 v=-1,-3
+p=3,0 v=-1,-2
+p=9,3 v=2,3
+p=7,3 v=-1,2
+p=2,4 v=2,-3
+p=9,5 v=-3,-3
+Each robot's position is given as p=x,y where x represents the number of tiles the robot is from the left wall and y represents the number of tiles from the top wall (when viewed from above). So, a position of p=0,0 means the robot is all the way in the top-left corner.
+
+Each robot's velocity is given as v=x,y where x and y are given in tiles per second. Positive x means the robot is moving to the right, and positive y means the robot is moving down. So, a velocity of v=1,-2 means that each second, the robot moves 1 tile to the right and 2 tiles up.
+
+The robots outside the actual bathroom are in a space which is 101 tiles wide and 103 tiles tall (when viewed from above). However, in this example, the robots are in a space which is only 11 tiles wide and 7 tiles tall.
+
+The robots are good at navigating over/under each other (due to a combination of springs, extendable legs, and quadcopters), so they can share the same tile and don't interact with each other. Visually, the number of robots on each tile in this example looks like this:
+
+1.12.......
+...........
+...........
+......11.11
+1.1........
+.........1.
+.......1...
+These robots have a unique feature for maximum bathroom security: they can teleport. When a robot would run into an edge of the space they're in, they instead teleport to the other side, effectively wrapping around the edges. Here is what robot p=2,4 v=2,-3 does for the first few seconds:
+
+Initial state:
+...........
+...........
+...........
+...........
+..1........
+...........
+...........
+
+After 1 second:
+...........
+....1......
+...........
+...........
+...........
+...........
+...........
+
+After 2 seconds:
+...........
+...........
+...........
+...........
+...........
+......1....
+...........
+
+After 3 seconds:
+...........
+...........
+........1..
+...........
+...........
+...........
+...........
+
+After 4 seconds:
+...........
+...........
+...........
+...........
+...........
+...........
+..........1
+
+After 5 seconds:
+...........
+...........
+...........
+.1.........
+...........
+...........
+...........
+The Historian can't wait much longer, so you don't have to simulate the robots for very long. Where will the robots be after 100 seconds?
+
+In the above example, the number of robots on each tile after 100 seconds has elapsed looks like this:
+
+......2..1.
+...........
+1..........
+.11........
+.....1.....
+...12......
+.1....1....
+To determine the safest area, count the number of robots in each quadrant after 100 seconds. Robots that are exactly in the middle (horizontally or vertically) don't count as being in any quadrant, so the only relevant robots are:
+
+..... 2..1.
+..... .....
+1.... .....
+           
+..... .....
+...12 .....
+.1... 1....
+In this example, the quadrants contain 1, 3, 4, and 1 robot. Multiplying these together gives a total safety factor of 12.
+
+Predict the motion of the robots in your list within a space which is 101 tiles wide and 103 tiles tall. What will the safety factor be after exactly 100 seconds have elapsed?
+
+Your puzzle answer was 219150360.
+
+--- Part Two ---
+
+During the bathroom break, someone notices that these robots seem awfully similar to ones built and used at the North Pole. If they're the same type of robots, they should have a hard-coded Easter egg: very rarely, most of the robots should arrange themselves into a picture of a Christmas tree.
+
+What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"import { readFileSync } from 'node:fs';
+
+// Constants
+const WIDTH = 101;
+const HEIGHT = 103;
+const SECONDS = 100;
+
+// Read input data
+const inputData = readFileSync('input.txt', { encoding: 'utf8', flag: 'r' });
+
+// Robot class definition
+class Robot {
+  constructor(initialState) {
+    const { px, py, vx, vy } = /p=(?<px>-{0,1}\d+),(?<py>-{0,1}\d+) v=(?<vx>-{0,1}\d+),(?<vy>-{0,1}\d+)/.exec(initialState).groups;
+    this.position = { x: parseInt(px), y: parseInt(py) };
+    this.velocity = { x: parseInt(vx), y: parseInt(vy) };
+  }
+
+  move() {
+    this.position.x = (this.position.x + this.velocity.x + WIDTH) % WIDTH;
+    this.position.y = (this.position.y + this.velocity.y + HEIGHT) % HEIGHT;
+  }
+
+  isWithinBounds(topLeft, bottomRight) {
+    return (
+      topLeft.x <= this.position.x && this.position.x < bottomRight.x &&
+      topLeft.y <= this.position.y && this.position.y < bottomRight.y
+    );
+  }
+}
+
+// Parse input and initialize robots
+const robots = inputData
+  .split('\n')
+  .filter(line => line.trim())
+  .map(line => new Robot(line));
+
+// Simulate robot movements for the initial period
+for (let i = 0; i < SECONDS; i++) {
+  robots.forEach(robot => robot.move());
+}
+
+// Calculate quadrant counts
+const quadrants = [
+  { topLeft: { x: 0, y: 0 }, bottomRight: { x: Math.floor(WIDTH / 2), y: Math.floor(HEIGHT / 2) } },
+  { topLeft: { x: Math.ceil(WIDTH / 2), y: 0 }, bottomRight: { x: WIDTH, y: Math.floor(HEIGHT / 2) } },
+  { topLeft: { x: 0, y: Math.ceil(HEIGHT / 2) }, bottomRight: { x: Math.floor(WIDTH / 2), y: HEIGHT } },
+  { topLeft: { x: Math.ceil(WIDTH / 2), y: Math.ceil(HEIGHT / 2) }, bottomRight: { x: WIDTH, y: HEIGHT } }
+];
+
+const quadrantCounts = quadrants.map(({ topLeft, bottomRight }) =>
+  robots.reduce((count, robot) => robot.isWithinBounds(topLeft, bottomRight) ? count + 1 : count, 0)
+);
+
+console.log(quadrantCounts.reduce((product, count) => product * count, 1));
+
+// Extended simulation to find a stable pattern
+for (let i = SECONDS; i < 19000; i++) {
+  const grid = Array.from({ length: HEIGHT }, () => Array(WIDTH).fill('.'));
+  let robotsInCentralArea = 0;
+
+  robots.forEach(robot => {
+    const { x, y } = robot.position;
+    grid[y][x] = '#';
+
+    if (robot.isWithinBounds(
+      { x: Math.floor(WIDTH * 0.25), y: Math.floor(HEIGHT * 0.25) },
+      { x: Math.floor(WIDTH * 0.75), y: Math.floor(HEIGHT * 0.75) }
+    )) {
+      robotsInCentralArea++;
+    }
+
+    robot.move();
+  });
+
+  if (robotsInCentralArea >= Math.floor(robots.length / 2)) {
+    console.log(i);
+    grid.forEach(row => console.log(row.join('')));
+    break;
+  }
 }",node:14
 2024,14,2,"--- Day 14: Restroom Redoubt ---
 
@@ -52322,8 +52465,7 @@ for (let counter = 0; counter < 10000; counter++) {
     }
 
     initialPositions = newInitialPositions;
-}
-",node:14
+}",node:14
 2024,16,1,"--- Day 16: Reindeer Maze ---
 
 It's time again for the Reindeer Olympics! This year, the big event is the Reindeer Maze, where the Reindeer compete for the lowest score.
@@ -70052,94 +70194,96 @@ The length of the shortest sequence of button presses you need to type on your d
 The numeric part of the code (ignoring leading zeroes); for 029A, this would be 29.
 In the above example, complexity of the five codes can be found by calculating 68 * 29, 60 * 980, 68 * 179, 64 * 456, and 64 * 379. Adding these together produces 126384.
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",157908,,node:14
-2024,21,1,"--- Day 21: Keypad Conundrum ---
-
-As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
-
-The door to that area is locked, but the computer can't open it; it can only be opened by physically typing the door codes (your puzzle input) on the numeric keypad on the door.
-
-The numeric keypad has four rows of buttons: 789, 456, 123, and finally an empty gap followed by 0A. Visually, they are arranged like this:
-
-+---+---+---+
-| 7 | 8 | 9 |
-+---+---+---+
-| 4 | 5 | 6 |
-+---+---+---+
-| 1 | 2 | 3 |
-+---+---+---+
-    | 0 | A |
-    +---+---+
-Unfortunately, the area outside the door is currently depressurized and nobody can go near the door. A robot needs to be sent instead.
-
-The robot has no problem navigating the ship and finding the numeric keypad, but it's not designed for button pushing: it can't be told to push a specific button directly. Instead, it has a robotic arm that can be controlled remotely via a directional keypad.
-
-The directional keypad has two rows of buttons: a gap / ^ (up) / A (activate) on the first row and < (left) / v (down) / > (right) on the second row. Visually, they are arranged like this:
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",157908,"const fs = require(""fs"");
+
+const NUMS = {
+  ""0"": [3, 1],
+  ""1"": [2, 0],
+  ""2"": [2, 1],
+  ""3"": [2, 2],
+  ""4"": [1, 0],
+  ""5"": [1, 1],
+  ""6"": [1, 2],
+  ""7"": [0, 0],
+  ""8"": [0, 1],
+  ""9"": [0, 2],
+  ""A"": [3, 2],
+  """": [3, 0],
+};
 
-    +---+---+
-    | ^ | A |
-+---+---+---+
-| < | v | > |
-+---+---+---+
-When the robot arrives at the numeric keypad, its robotic arm is pointed at the A button in the bottom right corner. After that, this directional keypad remote control must be used to maneuver the robotic arm: the up / down / left / right buttons cause it to move its arm one button in that direction, and the A button causes the robot to briefly move forward, pressing the button being aimed at by the robotic arm.
+const ARROWS = {
+  ""^"": [0, 1],
+  ""A"": [0, 2],
+  ""<"": [1, 0],
+  ""v"": [1, 1],
+  "">"": [1, 2],
+  """": [0, 0],
+};
 
-For example, to make the robot type 029A on the numeric keypad, one sequence of inputs on the directional keypad you could use is:
+const DIR_TO_ARROW_MAP = {
+  ""-1,0"": ""^"",
+  ""1,0"": ""v"",
+  ""0,-1"": ""<"",
+  ""0,1"": "">"",
+};
 
-< to move the arm from A (its initial position) to 0.
-A to push the 0 button.
-^A to move the arm to the 2 button and push it.
->^^A to move the arm to the 9 button and push it.
-vvvA to move the arm to the A button and push it.
-In total, there are three shortest possible sequences of button presses on this directional keypad that would cause the robot to type 029A: <A^A>^^AvvvA, <A^A^>^AvvvA, and <A^A^^>AvvvA.
+function getShortest(keys, sequence) {
+  let path = [];
 
-Unfortunately, the area containing this directional keypad remote control is currently experiencing high levels of radiation and nobody can go near it. A robot needs to be sent instead.
+  for (let i = 0; i < sequence.length - 1; i++) {
+    let cur = keys[sequence[i]];
+    let target = keys[sequence[i + 1]];
+    let nextPath = [];
+    let dirs = [];
 
-When the robot arrives at the directional keypad, its robot arm is pointed at the A button in the upper right corner. After that, a second, different directional keypad remote control is used to control this robot (in the same way as the first robot, except that this one is typing on a directional keypad instead of a numeric keypad).
+    if (!cur || !target) continue;
 
-There are multiple shortest possible sequences of directional keypad button presses that would cause this robot to tell the first robot to type 029A on the door. One such sequence is v<<A>>^A<A>AvA<^AA>A<vAAA>^A.
+    for (let y = cur[1] - 1; y >= target[1]; y--) {
+      nextPath.push([cur[0], y]);
+      dirs.push([0, -1]);
+    }
 
-Unfortunately, the area containing this second directional keypad remote control is currently -40 degrees! Another robot will need to be sent to type on that directional keypad, too.
+    for (let x = cur[0] + 1; x <= target[0]; x++) {
+      nextPath.push([x, cur[1]]);
+      dirs.push([1, 0]);
+    }
 
-There are many shortest possible sequences of directional keypad button presses that would cause this robot to tell the second robot to tell the first robot to eventually type 029A on the door. One such sequence is <vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A.
+    for (let x = cur[0] - 1; x >= target[0]; x--) {
+      nextPath.push([x, cur[1]]);
+      dirs.push([-1, 0]);
+    }
 
-Unfortunately, the area containing this third directional keypad remote control is currently full of Historians, so no robots can find a clear path there. Instead, you will have to type this sequence yourself.
+    for (let y = cur[1] + 1; y <= target[1]; y++) {
+      nextPath.push([cur[0], y]);
+      dirs.push([0, 1]);
+    }
 
-Were you to choose this sequence of button presses, here are all of the buttons that would be pressed on your directional keypad, the two robots' directional keypads, and the numeric keypad:
+    if (nextPath.some((pos) => JSON.stringify(pos) === JSON.stringify(keys[""""]))) {
+      dirs.reverse();
+    }
 
-<vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A
-v<<A>>^A<A>AvA<^AA>A<vAAA>^A
-<A^A>^^AvvvA
-029A
-In summary, there are the following keypads:
+    path.push(...dirs.map((d) => DIR_TO_ARROW_MAP[d.join("","")]), ""A"");
+  }
 
-One directional keypad that you are using.
-Two directional keypads that robots are using.
-One numeric keypad (on a door) that a robot is using.
-It is important to remember that these robots are not designed for button pushing. In particular, if a robot arm is ever aimed at a gap where no button is present on the keypad, even for an instant, the robot will panic unrecoverably. So, don't do that. All robots will initially aim at the keypad's A key, wherever it is.
+  return path.join("""");
+}
 
-To unlock the door, five codes will need to be typed on its numeric keypad. For example:
+// Read input file
+const lines = fs.readFileSync(""input.txt"", ""utf8"").trim().split(""\n"");
 
-029A
-980A
-179A
-456A
-379A
-For each of these, here is a shortest sequence of button presses you could type to cause the desired code to be typed on the numeric keypad:
+let totalComplexity = 0;
 
-029A: <vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A
-980A: <v<A>>^AAAvA^A<vA<AA>>^AvAA<^A>A<v<A>A>^AAAvA<^A>A<vA>^A<A>A
-179A: <v<A>>^A<vA<A>>^AAvAA<^A>A<v<A>>^AAvA^A<vA>^AA<A>A<v<A>A>^AAAvA<^A>A
-456A: <v<A>>^AA<vA<A>>^AAvAA<^A>A<vA>^A<A>A<vA>^A<A>A<v<A>A>^AAvA<^A>A
-379A: <v<A>>^AvA^A<vA<AA>>^AAvA<^A>AAvA^A<vA>^AA<A>A<v<A>A>^AAAvA<^A>A
-The Historians are getting nervous; the ship computer doesn't remember whether the missing Historian is trapped in the area containing a giant electromagnet or molten lava. You'll need to make sure that for each of the five codes, you find the shortest sequence of button presses necessary.
+for (let line of lines) {
+  if (!line) continue;
 
-The complexity of a single code (like 029A) is equal to the result of multiplying these two values:
+  let l1 = getShortest(NUMS, ""A"" + line);
+  let l2 = getShortest(ARROWS, ""A"" + l1);
+  let l3 = getShortest(ARROWS, ""A"" + l2);
 
-The length of the shortest sequence of button presses you need to type on your directional keypad in order to cause the code to be typed on the numeric keypad; for 029A, this would be 68.
-The numeric part of the code (ignoring leading zeroes); for 029A, this would be 29.
-In the above example, complexity of the five codes can be found by calculating 68 * 29, 60 * 980, 68 * 179, 64 * 456, and 64 * 379. Adding these together produces 126384.
+  totalComplexity += parseInt(line.slice(0, -1)) * l3.length;
+}
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",157908,,node:14
+console.log(totalComplexity);",node:14
 2024,21,1,"--- Day 21: Keypad Conundrum ---
 
 As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
@@ -70226,7 +70370,511 @@ The length of the shortest sequence of button presses you need to type on your d
 The numeric part of the code (ignoring leading zeroes); for 029A, this would be 29.
 In the above example, complexity of the five codes can be found by calculating 68 * 29, 60 * 980, 68 * 179, 64 * 456, and 64 * 379. Adding these together produces 126384.
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",157908,,node:14
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",157908,"// solution for https://adventofcode.com/2024/day/21 part 1
+
+// this solution tests ALL combinations of the simplest commands!
+
+""use strict""
+
+const input = Deno.readTextFileSync(""day21-input.txt"").trim()
+
+const allCodes = [ ]
+
+const numericCommandsByMove = { // simplest commands only
+
+    ""0 to 0"": [ ""A"" ],
+    ""0 to 1"": [ ""^<A"" ],
+    ""0 to 2"": [ ""^A"" ],
+    ""0 to 3"": [ ""^>A"", "">^A"" ],
+    ""0 to 4"": [ ""^^<A"" ],
+    ""0 to 5"": [ ""^^A"" ],
+    ""0 to 6"": [ ""^^>A"", "">^^A"" ],
+    ""0 to 7"": [ ""^^^<A"" ],
+    ""0 to 8"": [ ""^^^A"" ],
+    ""0 to 9"": [ ""^^^>A"", "">^^^A"" ],
+    ""0 to A"": [ "">A"" ],
+    ""1 to 0"": [ "">vA"" ],
+    ""1 to 1"": [ ""A"" ],
+    ""1 to 2"": [ "">A"" ],
+    ""1 to 3"": [ "">>A"" ],
+    ""1 to 4"": [ ""^A"" ],
+    ""1 to 5"": [ ""^>A"", "">^A"" ],
+    ""1 to 6"": [ ""^>>A"", "">>^A"" ],
+    ""1 to 7"": [ ""^^A"" ],
+    ""1 to 8"": [ ""^^>A"", "">^^A"" ],
+    ""1 to 9"": [ ""^^>>A"", "">>^^A"" ],
+    ""1 to A"": [ "">>vA"" ],
+    ""2 to 0"": [ ""vA"" ],
+    ""2 to 1"": [ ""<A"" ],
+    ""2 to 2"": [ ""A"" ],
+    ""2 to 3"": [ "">A"" ],
+    ""2 to 4"": [ ""^<A"", ""<^A"" ],
+    ""2 to 5"": [ ""^A"" ],
+    ""2 to 6"": [ ""^>A"", "">^A"" ],
+    ""2 to 7"": [ ""^^<A"", ""<^^A"" ],
+    ""2 to 8"": [ ""^^A"" ],
+    ""2 to 9"": [ ""^^>A"", "">^^A"" ],
+    ""2 to A"": [ ""v>A"", "">vA"" ],
+    ""3 to 0"": [ ""v<A"", ""<vA"" ],
+    ""3 to 1"": [ ""<<A"" ],
+    ""3 to 2"": [ ""<A"" ],
+    ""3 to 3"": [ ""A"" ],
+    ""3 to 4"": [ ""^<<A"", ""<<^A"" ],
+    ""3 to 5"": [ ""^<A"", ""<^A"" ],
+    ""3 to 6"": [ ""^A"" ],
+    ""3 to 7"": [ ""^^<<A"", ""<<^^A"" ],
+    ""3 to 8"": [ ""^^<A"", ""<^^A"" ],
+    ""3 to 9"": [ ""^^A"" ],
+    ""3 to A"": [ ""vA"" ],
+    ""4 to 0"": [ "">vvA"" ],
+    ""4 to 1"": [ ""vA"" ],
+    ""4 to 2"": [ ""v>A"", "">vA"" ],
+    ""4 to 3"": [ ""v>>A"", "">>vA"" ],
+    ""4 to 4"": [ ""A"" ],
+    ""4 to 5"": [ "">A"" ],
+    ""4 to 6"": [ "">>A"" ],
+    ""4 to 7"": [ ""^A"" ],
+    ""4 to 8"": [ ""^>A"", "">^A"" ],
+    ""4 to 9"": [ ""^>>A"", "">>^A"" ],
+    ""4 to A"": [ "">>vvA"" ],
+    ""5 to 0"": [ ""vvA"" ],
+    ""5 to 1"": [ ""v<A"", ""<vA"" ],
+    ""5 to 2"": [ ""vA"" ],
+    ""5 to 3"": [ ""v>A"", "">vA"" ],
+    ""5 to 4"": [ ""<A"" ],
+    ""5 to 5"": [ ""A"" ],
+    ""5 to 6"": [ "">A"" ],
+    ""5 to 7"": [ ""^<A"", ""<^A"" ],
+    ""5 to 8"": [ ""^A"" ],
+    ""5 to 9"": [ ""^>A"", "">^A"" ],
+    ""5 to A"": [ ""vv>A"", "">vvA"" ],
+    ""6 to 0"": [ ""vv<A"", ""<vvA"" ],
+    ""6 to 1"": [ ""v<<A"", ""<<vA"" ],
+    ""6 to 2"": [ ""v<A"", ""<vA"" ],
+    ""6 to 3"": [ ""vA"" ],
+    ""6 to 4"": [ ""<<A"" ],
+    ""6 to 5"": [ ""<A"" ],
+    ""6 to 6"": [ ""A"" ],
+    ""6 to 7"": [ ""^<<A"", ""<<^A"" ],
+    ""6 to 8"": [ ""^<A"", ""<^A"" ],
+    ""6 to 9"": [ ""^A"" ],
+    ""6 to A"": [ ""vvA"" ],
+    ""7 to 0"": [ "">vvvA"" ],
+    ""7 to 1"": [ ""vvA"" ],
+    ""7 to 2"": [ ""vv>A"", "">vvA"" ],
+    ""7 to 3"": [ ""vv>>A"", "">>vvA"" ],
+    ""7 to 4"": [ ""vA"" ],
+    ""7 to 5"": [ ""v>A"", "">vA"" ],
+    ""7 to 6"": [ ""v>>A"", "">>vA"" ],
+    ""7 to 7"": [ ""A"" ],
+    ""7 to 8"": [ "">A"" ],
+    ""7 to 9"": [ "">>A"" ],
+    ""7 to A"": [ "">>vvvA"" ],
+    ""8 to 0"": [ ""vvvA"" ],
+    ""8 to 1"": [ ""vv<A"", ""<vvA"" ],
+    ""8 to 2"": [ ""vvA"" ],
+    ""8 to 3"": [ ""vv>A"", "">vvA"" ],
+    ""8 to 4"": [ ""v<A"", ""<vA"" ],
+    ""8 to 5"": [ ""vA"" ],
+    ""8 to 6"": [ ""v>A"", "">vA"" ],
+    ""8 to 7"": [ ""<A"" ],
+    ""8 to 8"": [ ""A"" ],
+    ""8 to 9"": [ "">A"" ],
+    ""8 to A"": [ ""vvv>A"", "">vvvA"" ],
+    ""9 to 0"": [ ""vvv<A"", ""<vvvA"" ],
+    ""9 to 1"": [ ""vv<<A"", ""<<vvA"" ],
+    ""9 to 2"": [ ""vv<A"", ""<vvA"" ],
+    ""9 to 3"": [ ""vvA"" ],
+    ""9 to 4"": [ ""v<<A"", ""<<vA"" ],
+    ""9 to 5"": [ ""v<A"", ""<vA"" ],
+    ""9 to 6"": [ ""vA"" ],
+    ""9 to 7"": [ ""<<A"" ],
+    ""9 to 8"": [ ""<A"" ],
+    ""9 to 9"": [ ""A"" ],
+    ""9 to A"": [ ""vvvA"" ],
+    ""A to 0"": [ ""<A"" ],
+    ""A to 1"": [ ""^<<A"" ],
+    ""A to 2"": [ ""^<A"", ""<^A"" ],
+    ""A to 3"": [ ""^A"" ],
+    ""A to 4"": [ ""^^<<A"" ],
+    ""A to 5"": [ ""^^<A"", ""<^^A"" ],
+    ""A to 6"": [ ""^^A"" ],
+    ""A to 7"": [ ""^^^<<A"" ],
+    ""A to 8"": [ ""^^^<A"", ""<^^^A"" ],
+    ""A to 9"": [ ""^^^A"" ],
+    ""A to A"": [ ""A"" ]
+}
+
+const directionalCommandsByMove = { // simplest commands only
+   
+    ""^ to ^"": [ ""A"" ],
+    ""^ to v"": [ ""vA"" ],
+    ""^ to <"": [ ""v<A"" ],
+    ""^ to >"": [ ""v>A"", "">vA"" ],
+    ""^ to A"": [ "">A"" ],
+    
+    ""v to ^"": [ ""^A"" ],
+    ""v to v"": [ ""A"" ],
+    ""v to <"": [ ""<A"" ],
+    ""v to >"": [ "">A"" ],
+    ""v to A"": [ ""^>A"", "">^A"" ],
+    
+    ""< to ^"": [ "">^A"" ],
+    ""< to v"": [ "">A"" ],
+    ""< to <"": [ ""A"" ],
+    ""< to >"": [ "">>A"" ],
+    ""< to A"": [ "">>^A"" ], 
+    
+    ""> to ^"": [ ""^<A"", ""<^A"" ],
+    ""> to v"": [ ""<A"" ],
+    ""> to <"": [ ""<<A"" ],
+    ""> to >"": [ ""A"" ],
+    ""> to A"": [ ""^A"" ],
+    
+    ""A to ^"": [ ""<A"" ],
+    ""A to v"": [ ""v<A"", ""<vA"" ],
+    ""A to <"": [ ""v<<A"" ], 
+    ""A to >"": [ ""vA"" ],
+    ""A to A"": [ ""A"" ]
+}
+
+const memory = { }
+
+
+function main() {
+
+    processInput()
+
+    let complexity = 0
+
+    for (const code of allCodes) { complexity += calcComplexityOf(code) }
+      
+    console.log(""the answer is"", complexity)    
+}
+
+function processInput() {
+    
+    const rawLines = input.split(""\n"")
+    
+    for (const rawLine of rawLines) { allCodes.push(rawLine.trim()) }
+}
+
+function calcComplexityOf(code) {
+
+    const initialSequences = generateInitialSequences(code)
+
+    const leastSteps = calcLeastSteps(initialSequences)
+    
+    return parseInt(code) * leastSteps
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+function generateInitialSequences(code) { 
+
+    let lastButton = ""A""
+
+    let sequences = [ """" ]
+
+    for (const button of code) { 
+        
+        const temp = [ ]
+
+        const commands = numericCommandsByMove[lastButton + "" to "" + button]
+        
+        lastButton = button
+
+        for (const command of commands) {
+        
+            for (const sequence of sequences) { temp.push(sequence + command) }
+        }
+        
+        sequences = temp
+    }
+    
+    return sequences
+}      
+
+///////////////////////////////////////////////////////////////////////////////
+
+function calcLeastSteps(initialSequences) {
+  
+    let minLength = Infinity
+    
+    for (const sequence of initialSequences) {
+
+        const length = findFutureLength(sequence)
+
+        if (length < minLength) { minLength = length }             
+    }        
+
+   return minLength
+}     
+
+function findFutureLength(sequence) {
+
+    const tokens = tokenize(sequence)
+
+    let length = 0
+    
+    for (const token of tokens) { length += smallestFutureLengthForToken(token) }
+
+    return length
+}
+
+function tokenize(sequence) {
+
+    const tokens = [ ]
+
+    let token = """"
+    
+    for (const button of sequence) {
+
+        token += button
+        
+        if (button == ""A"") { tokens. push(token); token = """" }
+    }
+    return tokens
+}
+
+function smallestFutureLengthForToken(token) {
+
+    let minLength = Infinity
+  
+    const sequences = generateSequencesFromToken(token, 2)
+    
+    for (const sequence of sequences) {
+    
+        if (sequence.length < minLength) { minLength = sequence.length }             
+    }        
+
+   return minLength
+}     
+
+///////////////////////////////////////////////////////////////////////////////
+
+function generateSequencesFromToken(sourceToken, roundsToGo) { 
+
+    if (roundsToGo == 0) { return [ sourceToken ] }
+
+    const id = sourceToken + ""~"" + roundsToGo
+    
+    if (memory[id] != undefined) { return memory[id] }
+    
+    //
+    
+    let sequences = [ """" ]
+
+    let lastButton = ""A""
+
+    for (const button of sourceToken) {
+
+        const temp = [ ]
+
+        const newTokens = directionalCommandsByMove[lastButton + "" to "" + button]
+       
+        lastButton = button
+
+        const listA = generateSequencesFromToken(newTokens[0], roundsToGo - 1)
+        
+        let listB = [ ]
+        
+        if (newTokens[1] != undefined) { listB = generateSequencesFromToken(newTokens[1], roundsToGo - 1) }
+        
+        for (const sequence of sequences) {
+        
+            for (const newSequence of listA) { temp.push(sequence + newSequence) }
+            for (const newSequence of listB) { temp.push(sequence + newSequence) }
+        }
+        
+        sequences = temp
+    }
+        
+    memory[id] = sequences
+    return sequences
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+console.time(""execution time"")
+main()
+console.timeEnd(""execution time"") // 1ms",node:14
+2024,21,1,"--- Day 21: Keypad Conundrum ---
+
+As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
+
+The door to that area is locked, but the computer can't open it; it can only be opened by physically typing the door codes (your puzzle input) on the numeric keypad on the door.
+
+The numeric keypad has four rows of buttons: 789, 456, 123, and finally an empty gap followed by 0A. Visually, they are arranged like this:
+
++---+---+---+
+| 7 | 8 | 9 |
++---+---+---+
+| 4 | 5 | 6 |
++---+---+---+
+| 1 | 2 | 3 |
++---+---+---+
+    | 0 | A |
+    +---+---+
+Unfortunately, the area outside the door is currently depressurized and nobody can go near the door. A robot needs to be sent instead.
+
+The robot has no problem navigating the ship and finding the numeric keypad, but it's not designed for button pushing: it can't be told to push a specific button directly. Instead, it has a robotic arm that can be controlled remotely via a directional keypad.
+
+The directional keypad has two rows of buttons: a gap / ^ (up) / A (activate) on the first row and < (left) / v (down) / > (right) on the second row. Visually, they are arranged like this:
+
+    +---+---+
+    | ^ | A |
++---+---+---+
+| < | v | > |
++---+---+---+
+When the robot arrives at the numeric keypad, its robotic arm is pointed at the A button in the bottom right corner. After that, this directional keypad remote control must be used to maneuver the robotic arm: the up / down / left / right buttons cause it to move its arm one button in that direction, and the A button causes the robot to briefly move forward, pressing the button being aimed at by the robotic arm.
+
+For example, to make the robot type 029A on the numeric keypad, one sequence of inputs on the directional keypad you could use is:
+
+< to move the arm from A (its initial position) to 0.
+A to push the 0 button.
+^A to move the arm to the 2 button and push it.
+>^^A to move the arm to the 9 button and push it.
+vvvA to move the arm to the A button and push it.
+In total, there are three shortest possible sequences of button presses on this directional keypad that would cause the robot to type 029A: <A^A>^^AvvvA, <A^A^>^AvvvA, and <A^A^^>AvvvA.
+
+Unfortunately, the area containing this directional keypad remote control is currently experiencing high levels of radiation and nobody can go near it. A robot needs to be sent instead.
+
+When the robot arrives at the directional keypad, its robot arm is pointed at the A button in the upper right corner. After that, a second, different directional keypad remote control is used to control this robot (in the same way as the first robot, except that this one is typing on a directional keypad instead of a numeric keypad).
+
+There are multiple shortest possible sequences of directional keypad button presses that would cause this robot to tell the first robot to type 029A on the door. One such sequence is v<<A>>^A<A>AvA<^AA>A<vAAA>^A.
+
+Unfortunately, the area containing this second directional keypad remote control is currently -40 degrees! Another robot will need to be sent to type on that directional keypad, too.
+
+There are many shortest possible sequences of directional keypad button presses that would cause this robot to tell the second robot to tell the first robot to eventually type 029A on the door. One such sequence is <vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A.
+
+Unfortunately, the area containing this third directional keypad remote control is currently full of Historians, so no robots can find a clear path there. Instead, you will have to type this sequence yourself.
+
+Were you to choose this sequence of button presses, here are all of the buttons that would be pressed on your directional keypad, the two robots' directional keypads, and the numeric keypad:
+
+<vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A
+v<<A>>^A<A>AvA<^AA>A<vAAA>^A
+<A^A>^^AvvvA
+029A
+In summary, there are the following keypads:
+
+One directional keypad that you are using.
+Two directional keypads that robots are using.
+One numeric keypad (on a door) that a robot is using.
+It is important to remember that these robots are not designed for button pushing. In particular, if a robot arm is ever aimed at a gap where no button is present on the keypad, even for an instant, the robot will panic unrecoverably. So, don't do that. All robots will initially aim at the keypad's A key, wherever it is.
+
+To unlock the door, five codes will need to be typed on its numeric keypad. For example:
+
+029A
+980A
+179A
+456A
+379A
+For each of these, here is a shortest sequence of button presses you could type to cause the desired code to be typed on the numeric keypad:
+
+029A: <vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A
+980A: <v<A>>^AAAvA^A<vA<AA>>^AvAA<^A>A<v<A>A>^AAAvA<^A>A<vA>^A<A>A
+179A: <v<A>>^A<vA<A>>^AAvAA<^A>A<v<A>>^AAvA^A<vA>^AA<A>A<v<A>A>^AAAvA<^A>A
+456A: <v<A>>^AA<vA<A>>^AAvAA<^A>A<vA>^A<A>A<vA>^A<A>A<v<A>A>^AAvA<^A>A
+379A: <v<A>>^AvA^A<vA<AA>>^AAvA<^A>AAvA^A<vA>^AA<A>A<v<A>A>^AAAvA<^A>A
+The Historians are getting nervous; the ship computer doesn't remember whether the missing Historian is trapped in the area containing a giant electromagnet or molten lava. You'll need to make sure that for each of the five codes, you find the shortest sequence of button presses necessary.
+
+The complexity of a single code (like 029A) is equal to the result of multiplying these two values:
+
+The length of the shortest sequence of button presses you need to type on your directional keypad in order to cause the code to be typed on the numeric keypad; for 029A, this would be 68.
+The numeric part of the code (ignoring leading zeroes); for 029A, this would be 29.
+In the above example, complexity of the five codes can be found by calculating 68 * 29, 60 * 980, 68 * 179, 64 * 456, and 64 * 379. Adding these together produces 126384.
+
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",157908,"const fs = require(""fs"");
+
+const positionMap = {
+  ""0"": [3, 1],
+  ""1"": [2, 0],
+  ""2"": [2, 1],
+  ""3"": [2, 2],
+  ""4"": [1, 0],
+  ""5"": [1, 1],
+  ""6"": [1, 2],
+  ""7"": [0, 0],
+  ""8"": [0, 1],
+  ""9"": [0, 2],
+  ""A"": [3, 2],
+  """": [3, 0],
+};
+
+const movementMap = {
+  ""^"": [0, 1],
+  ""A"": [0, 2],
+  ""<"": [1, 0],
+  ""v"": [1, 1],
+  "">"": [1, 2],
+  """": [0, 0],
+};
+
+const directionMapping = {
+  ""-1,0"": ""^"",
+  ""1,0"": ""v"",
+  ""0,-1"": ""<"",
+  ""0,1"": "">"",
+};
+
+function calculatePath(keyLocations, inputSequence) {
+  let pathSequence = [];
+
+  for (let i = 0; i < inputSequence.length - 1; i++) {
+    const start = keyLocations[inputSequence[i]];
+    const end = keyLocations[inputSequence[i + 1]];
+    const steps = [];
+    const directions = [];
+
+    if (!start || !end) continue;
+
+    for (let y = start[1] - 1; y >= end[1]; y--) {
+      steps.push([start[0], y]);
+      directions.push([0, -1]);
+    }
+
+    for (let x = start[0] + 1; x <= end[0]; x++) {
+      steps.push([x, start[1]]);
+      directions.push([1, 0]);
+    }
+
+    for (let x = start[0] - 1; x >= end[0]; x--) {
+      steps.push([x, start[1]]);
+      directions.push([-1, 0]);
+    }
+
+    for (let y = start[1] + 1; y <= end[1]; y++) {
+      steps.push([start[0], y]);
+      directions.push([0, 1]);
+    }
+
+    if (steps.some((coord) => JSON.stringify(coord) === JSON.stringify(keyLocations[""""]))) {
+      directions.reverse();
+    }
+
+    pathSequence.push(...directions.map((direction) => directionMapping[direction.join("","")]), ""A"");
+  }
+
+  return pathSequence.join("""");
+}
+
+const inputData = fs.readFileSync(""input.txt"", ""utf8"").trim().split(""\n"");
+
+let totalScore = 0;
+
+inputData.forEach((line) => {
+  if (!line) return;
+
+  let pathToFirstStep = calculatePath(positionMap, ""A"" + line);
+  let pathToSecondStep = calculatePath(movementMap, ""A"" + pathToFirstStep);
+  let finalPath = calculatePath(movementMap, ""A"" + pathToSecondStep);
+
+  totalScore += parseInt(line.slice(0, -1)) * finalPath.length;
+});
+
+console.log(totalScore);
+",node:14
 2024,21,1,"--- Day 21: Keypad Conundrum ---
 
 As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
@@ -70887,7 +71535,310 @@ The keypads form a chain, just like before: your directional keypad controls a r
 
 The door codes are the same this time around; only the number of robots and directional keypads has changed.
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,,node:14
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,"// solution for https://adventofcode.com/2024/day/21 part 2
+
+// this solution doesn't check all combinations of directional commands
+// at any possible branch;
+// instead it uses only directional commands that performed better when 
+// tested
+
+""use strict""
+
+const input = Deno.readTextFileSync(""day21-input.txt"").trim()
+
+const allCodes = [ ]
+
+const numericCommandsByMove = { // simplest commands only
+
+    ""0 to 0"": [ ""A"" ],
+    ""0 to 1"": [ ""^<A"" ],
+    ""0 to 2"": [ ""^A"" ],
+    ""0 to 3"": [ ""^>A"", "">^A"" ],
+    ""0 to 4"": [ ""^^<A"" ],
+    ""0 to 5"": [ ""^^A"" ],
+    ""0 to 6"": [ ""^^>A"", "">^^A"" ],
+    ""0 to 7"": [ ""^^^<A"" ],
+    ""0 to 8"": [ ""^^^A"" ],
+    ""0 to 9"": [ ""^^^>A"", "">^^^A"" ],
+    ""0 to A"": [ "">A"" ],
+    ""1 to 0"": [ "">vA"" ],
+    ""1 to 1"": [ ""A"" ],
+    ""1 to 2"": [ "">A"" ],
+    ""1 to 3"": [ "">>A"" ],
+    ""1 to 4"": [ ""^A"" ],
+    ""1 to 5"": [ ""^>A"", "">^A"" ],
+    ""1 to 6"": [ ""^>>A"", "">>^A"" ],
+    ""1 to 7"": [ ""^^A"" ],
+    ""1 to 8"": [ ""^^>A"", "">^^A"" ],
+    ""1 to 9"": [ ""^^>>A"", "">>^^A"" ],
+    ""1 to A"": [ "">>vA"" ],
+    ""2 to 0"": [ ""vA"" ],
+    ""2 to 1"": [ ""<A"" ],
+    ""2 to 2"": [ ""A"" ],
+    ""2 to 3"": [ "">A"" ],
+    ""2 to 4"": [ ""^<A"", ""<^A"" ],
+    ""2 to 5"": [ ""^A"" ],
+    ""2 to 6"": [ ""^>A"", "">^A"" ],
+    ""2 to 7"": [ ""^^<A"", ""<^^A"" ],
+    ""2 to 8"": [ ""^^A"" ],
+    ""2 to 9"": [ ""^^>A"", "">^^A"" ],
+    ""2 to A"": [ ""v>A"", "">vA"" ],
+    ""3 to 0"": [ ""v<A"", ""<vA"" ],
+    ""3 to 1"": [ ""<<A"" ],
+    ""3 to 2"": [ ""<A"" ],
+    ""3 to 3"": [ ""A"" ],
+    ""3 to 4"": [ ""^<<A"", ""<<^A"" ],
+    ""3 to 5"": [ ""^<A"", ""<^A"" ],
+    ""3 to 6"": [ ""^A"" ],
+    ""3 to 7"": [ ""^^<<A"", ""<<^^A"" ],
+    ""3 to 8"": [ ""^^<A"", ""<^^A"" ],
+    ""3 to 9"": [ ""^^A"" ],
+    ""3 to A"": [ ""vA"" ],
+    ""4 to 0"": [ "">vvA"" ],
+    ""4 to 1"": [ ""vA"" ],
+    ""4 to 2"": [ ""v>A"", "">vA"" ],
+    ""4 to 3"": [ ""v>>A"", "">>vA"" ],
+    ""4 to 4"": [ ""A"" ],
+    ""4 to 5"": [ "">A"" ],
+    ""4 to 6"": [ "">>A"" ],
+    ""4 to 7"": [ ""^A"" ],
+    ""4 to 8"": [ ""^>A"", "">^A"" ],
+    ""4 to 9"": [ ""^>>A"", "">>^A"" ],
+    ""4 to A"": [ "">>vvA"" ],
+    ""5 to 0"": [ ""vvA"" ],
+    ""5 to 1"": [ ""v<A"", ""<vA"" ],
+    ""5 to 2"": [ ""vA"" ],
+    ""5 to 3"": [ ""v>A"", "">vA"" ],
+    ""5 to 4"": [ ""<A"" ],
+    ""5 to 5"": [ ""A"" ],
+    ""5 to 6"": [ "">A"" ],
+    ""5 to 7"": [ ""^<A"", ""<^A"" ],
+    ""5 to 8"": [ ""^A"" ],
+    ""5 to 9"": [ ""^>A"", "">^A"" ],
+    ""5 to A"": [ ""vv>A"", "">vvA"" ],
+    ""6 to 0"": [ ""vv<A"", ""<vvA"" ],
+    ""6 to 1"": [ ""v<<A"", ""<<vA"" ],
+    ""6 to 2"": [ ""v<A"", ""<vA"" ],
+    ""6 to 3"": [ ""vA"" ],
+    ""6 to 4"": [ ""<<A"" ],
+    ""6 to 5"": [ ""<A"" ],
+    ""6 to 6"": [ ""A"" ],
+    ""6 to 7"": [ ""^<<A"", ""<<^A"" ],
+    ""6 to 8"": [ ""^<A"", ""<^A"" ],
+    ""6 to 9"": [ ""^A"" ],
+    ""6 to A"": [ ""vvA"" ],
+    ""7 to 0"": [ "">vvvA"" ],
+    ""7 to 1"": [ ""vvA"" ],
+    ""7 to 2"": [ ""vv>A"", "">vvA"" ],
+    ""7 to 3"": [ ""vv>>A"", "">>vvA"" ],
+    ""7 to 4"": [ ""vA"" ],
+    ""7 to 5"": [ ""v>A"", "">vA"" ],
+    ""7 to 6"": [ ""v>>A"", "">>vA"" ],
+    ""7 to 7"": [ ""A"" ],
+    ""7 to 8"": [ "">A"" ],
+    ""7 to 9"": [ "">>A"" ],
+    ""7 to A"": [ "">>vvvA"" ],
+    ""8 to 0"": [ ""vvvA"" ],
+    ""8 to 1"": [ ""vv<A"", ""<vvA"" ],
+    ""8 to 2"": [ ""vvA"" ],
+    ""8 to 3"": [ ""vv>A"", "">vvA"" ],
+    ""8 to 4"": [ ""v<A"", ""<vA"" ],
+    ""8 to 5"": [ ""vA"" ],
+    ""8 to 6"": [ ""v>A"", "">vA"" ],
+    ""8 to 7"": [ ""<A"" ],
+    ""8 to 8"": [ ""A"" ],
+    ""8 to 9"": [ "">A"" ],
+    ""8 to A"": [ ""vvv>A"", "">vvvA"" ],
+    ""9 to 0"": [ ""vvv<A"", ""<vvvA"" ],
+    ""9 to 1"": [ ""vv<<A"", ""<<vvA"" ],
+    ""9 to 2"": [ ""vv<A"", ""<vvA"" ],
+    ""9 to 3"": [ ""vvA"" ],
+    ""9 to 4"": [ ""v<<A"", ""<<vA"" ],
+    ""9 to 5"": [ ""v<A"", ""<vA"" ],
+    ""9 to 6"": [ ""vA"" ],
+    ""9 to 7"": [ ""<<A"" ],
+    ""9 to 8"": [ ""<A"" ],
+    ""9 to 9"": [ ""A"" ],
+    ""9 to A"": [ ""vvvA"" ],
+    ""A to 0"": [ ""<A"" ],
+    ""A to 1"": [ ""^<<A"" ],
+    ""A to 2"": [ ""^<A"", ""<^A"" ],
+    ""A to 3"": [ ""^A"" ],
+    ""A to 4"": [ ""^^<<A"" ],
+    ""A to 5"": [ ""^^<A"", ""<^^A"" ],
+    ""A to 6"": [ ""^^A"" ],
+    ""A to 7"": [ ""^^^<<A"" ],
+    ""A to 8"": [ ""^^^<A"", ""<^^^A"" ],
+    ""A to 9"": [ ""^^^A"" ],
+    ""A to A"": [ ""A"" ]
+}
+
+const directionalCommandsByMove = { // shortest and simplest commands only    
+
+    ""^ to ^"": ""A"",
+    ""^ to v"": ""vA"",
+    ""^ to <"": ""v<A"",
+    ""^ to >"": ""v>A"", // "">vA""  does not result in the shortest sequence 
+    ""^ to A"": "">A"",
+    
+    ""v to ^"": ""^A"",
+    ""v to v"": ""A"",
+    ""v to <"": ""<A"",
+    ""v to >"": "">A"",
+    ""v to A"": ""^>A"", // "">^A"" does not result in the shortest sequence 
+    
+    ""< to ^"": "">^A"", 
+    ""< to v"": "">A"",
+    ""< to <"": ""A"",
+    ""< to >"": "">>A"",
+    ""< to A"": "">>^A"", 
+    
+    ""> to ^"": ""<^A"", // ""^<A"" does not result in the shortest sequence 
+    ""> to v"": ""<A"",
+    ""> to <"": ""<<A"",
+    ""> to >"": ""A"",
+    ""> to A"": ""^A"",
+    
+    ""A to ^"": ""<A"",
+    ""A to v"": ""<vA"", // ""v<A"" does not result in the shortest sequence 
+    ""A to <"": ""v<<A"",
+    ""A to >"": ""vA"",
+    ""A to A"": ""A""
+}
+
+const memory = { }
+
+
+function main() {
+
+    processInput()
+
+    let complexity = 0
+
+    for (const code of allCodes) { complexity += calcComplexityOf(code) }
+      
+    console.log(""the answer is"", complexity)    
+}
+
+function processInput() {
+    
+    const rawLines = input.split(""\n"")
+    
+    for (const rawLine of rawLines) { allCodes.push(rawLine.trim()) }
+}
+
+function calcComplexityOf(code) {
+
+    const initialSequences = generateInitialSequences(code)
+
+    const leastSteps = calcLeastSteps(initialSequences)
+    
+    return parseInt(code) * leastSteps
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+function generateInitialSequences(code) { 
+
+    let lastButton = ""A""
+
+    let sequences = [ """" ]
+
+    for (const button of code) { 
+        
+        const temp = [ ]
+
+        const commands = numericCommandsByMove[lastButton + "" to "" + button]
+        
+        lastButton = button
+
+        for (const command of commands) {
+        
+            for (const sequence of sequences) { temp.push(sequence + command) }
+        }
+        
+        sequences = temp
+    }
+    
+    return sequences
+}      
+
+///////////////////////////////////////////////////////////////////////////////
+
+function calcLeastSteps(initialSequences) {
+  
+    let minLength = Infinity
+    
+    for (const sequence of initialSequences) {
+
+        const length = findFutureLength(sequence)
+
+        if (length < minLength) { minLength = length }             
+    }        
+
+   return minLength
+}     
+
+function findFutureLength(sequence) {
+
+    const tokens = tokenize(sequence)
+
+    let length = 0
+    
+    for (const token of tokens) { length += findLengthFromExpandedToken(token, 25) }
+
+    return length
+}
+
+function tokenize(sequence) {
+
+    const tokens = [ ]
+
+    let token = """"
+    
+    for (const button of sequence) {
+
+        token += button
+        
+        if (button == ""A"") { tokens. push(token); token = """" }
+    }
+    return tokens
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+function findLengthFromExpandedToken(sourceToken, roundsToGo) { 
+
+    if (roundsToGo == 0) { return sourceToken.length }
+
+    const id = sourceToken + ""~"" + roundsToGo
+    
+    if (memory[id] != undefined) { return memory[id] }
+    
+    //
+    
+    let length = 0
+
+    let lastButton = ""A""
+
+    for (const button of sourceToken) {
+
+        const newToken = directionalCommandsByMove[lastButton + "" to "" + button]
+       
+        lastButton = button
+        
+        length += findLengthFromExpandedToken(newToken, roundsToGo - 1)
+    }
+        
+    memory[id] = length
+    return length
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+console.time(""execution time"")
+main()
+console.timeEnd(""execution time"") // 1ms",node:14
 2024,21,2,"--- Day 21: Keypad Conundrum ---
 
 As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
@@ -70993,7 +71944,101 @@ The keypads form a chain, just like before: your directional keypad controls a r
 
 The door codes are the same this time around; only the number of robots and directional keypads has changed.
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,,node:14
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,"const fs = require('fs');
+
+const NUMERIC_KEYS = {
+  ""7"": [0, 0], ""8"": [1, 0], ""9"": [2, 0],
+  ""4"": [0, 1], ""5"": [1, 1], ""6"": [2, 1],
+  ""1"": [0, 2], ""2"": [1, 2], ""3"": [2, 2],
+  ""0"": [1, 3], ""A"": [2, 3]
+};
+
+const DIRECTIONAL_KEYS = {
+  ""^"": [1, 0], ""A"": [2, 0],
+  ""<"": [0, 1], ""v"": [1, 1], "">"": [2, 1]
+};
+
+const ALLOWED_NUM_POS = new Set(Object.values(NUMERIC_KEYS).map(JSON.stringify));
+const ALLOWED_DIR_POS = new Set(Object.values(DIRECTIONAL_KEYS).map(JSON.stringify));
+
+const input = fs.readFileSync('input.txt', 'utf8').split(""\n"").map(x => x.trim());
+
+function findKeystrokes(src, target, directional) {
+  if (JSON.stringify(src) === JSON.stringify(target)) return [""A""];
+  if (!directional && !ALLOWED_NUM_POS.has(JSON.stringify(src))) return [];
+  if (directional && !ALLOWED_DIR_POS.has(JSON.stringify(src))) return [];
+
+  const [x1, y1] = src;
+  const [x2, y2] = target;
+  let res = [];
+
+  if (x1 < x2) res = res.concat(findKeystrokes([x1 + 1, y1], target, directional).map(s => "">"" + s));
+  if (x1 > x2) res = res.concat(findKeystrokes([x1 - 1, y1], target, directional).map(s => ""<"" + s));
+  if (y1 < y2) res = res.concat(findKeystrokes([x1, y1 + 1], target, directional).map(s => ""v"" + s));
+  if (y1 > y2) res = res.concat(findKeystrokes([x1, y1 - 1], target, directional).map(s => ""^"" + s));
+
+  return res;
+}
+
+// Memoization to cache previous results of findShortestToClick to prevent redundant work
+const memoShortest = new Map();
+function findShortestToClick(a, b, depth = 2) {
+  const key = `${a},${b},${depth}`;
+  if (memoShortest.has(key)) {
+    return memoShortest.get(key);
+  }
+
+  const opts = findKeystrokes(DIRECTIONAL_KEYS[a], DIRECTIONAL_KEYS[b], true);
+  if (depth === 1) {
+    const minLen = Math.min(...opts.map(x => x.length));
+    memoShortest.set(key, minLen);
+    return minLen;
+  }
+
+  const tmps = opts.map(o => {
+    const tmp = [];
+    tmp.push(findShortestToClick(""A"", o[0], depth - 1));
+    for (let i = 1; i < o.length; i++) {
+      tmp.push(findShortestToClick(o[i - 1], o[i], depth - 1));
+    }
+    return tmp.reduce((acc, val) => acc + val, 0);
+  });
+
+  const minResult = Math.min(...tmps);
+  memoShortest.set(key, minResult);
+  return minResult;
+}
+
+function findShortest(code, levels) {
+  let pos = NUMERIC_KEYS[""A""];
+  let shortest = 0;
+
+  for (let key of code) {
+    const possibleKeySequences = findKeystrokes(pos, NUMERIC_KEYS[key], false);
+    const tmps = possibleKeySequences.map(sequence => {
+      const tmp = [];
+      tmp.push(findShortestToClick(""A"", sequence[0], levels));
+      for (let i = 1; i < sequence.length; i++) {
+        tmp.push(findShortestToClick(sequence[i - 1], sequence[i], levels));
+      }
+      return tmp.reduce((acc, val) => acc + val, 0);
+    });
+
+    pos = NUMERIC_KEYS[key];
+    shortest += Math.min(...tmps);
+  }
+  return shortest;
+}
+
+function findTotalComplexity(codes, levels) {
+  const complexities = codes.map(code => {
+    const s = findShortest(code, levels);
+    return s * parseInt(code.slice(0, -1), 10);
+  });
+  return complexities.reduce((acc, val) => acc + val, 0);
+}
+
+console.log(findTotalComplexity(input, 25));",node:14
 2024,21,2,"--- Day 21: Keypad Conundrum ---
 
 As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
@@ -71099,7 +72144,100 @@ The keypads form a chain, just like before: your directional keypad controls a r
 
 The door codes are the same this time around; only the number of robots and directional keypads has changed.
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,,node:14
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,"const fs = require('fs');
+
+const NUM_MAP = {
+  ""7"": [0, 0], ""8"": [1, 0], ""9"": [2, 0],
+  ""4"": [0, 1], ""5"": [1, 1], ""6"": [2, 1],
+  ""1"": [0, 2], ""2"": [1, 2], ""3"": [2, 2],
+  ""0"": [1, 3], ""A"": [2, 3]
+};
+
+const DIR_MAP = {
+  ""^"": [1, 0], ""A"": [2, 0],
+  ""<"": [0, 1], ""v"": [1, 1], "">"": [2, 1]
+};
+
+const NUM_POS_SET = new Set(Object.values(NUM_MAP).map(JSON.stringify));
+const DIR_POS_SET = new Set(Object.values(DIR_MAP).map(JSON.stringify));
+
+const rawInput = fs.readFileSync('input.txt', 'utf8').split(""\n"").map(line => line.trim());
+
+function generatePath(from, to, isDirectional) {
+  if (JSON.stringify(from) === JSON.stringify(to)) return [""A""];
+  if (!isDirectional && !NUM_POS_SET.has(JSON.stringify(from))) return [];
+  if (isDirectional && !DIR_POS_SET.has(JSON.stringify(from))) return [];
+
+  const [xFrom, yFrom] = from;
+  const [xTo, yTo] = to;
+  let movements = [];
+
+  if (xFrom < xTo) movements = movements.concat(generatePath([xFrom + 1, yFrom], to, isDirectional).map(move => "">"" + move));
+  if (xFrom > xTo) movements = movements.concat(generatePath([xFrom - 1, yFrom], to, isDirectional).map(move => ""<"" + move));
+  if (yFrom < yTo) movements = movements.concat(generatePath([xFrom, yFrom + 1], to, isDirectional).map(move => ""v"" + move));
+  if (yFrom > yTo) movements = movements.concat(generatePath([xFrom, yFrom - 1], to, isDirectional).map(move => ""^"" + move));
+
+  return movements;
+}
+
+const memoization = new Map();
+function computeMinimalSteps(start, end, maxDepth = 2) {
+  const cacheKey = `${start},${end},${maxDepth}`;
+  if (memoization.has(cacheKey)) {
+    return memoization.get(cacheKey);
+  }
+
+  const options = generatePath(DIR_MAP[start], DIR_MAP[end], true);
+  if (maxDepth === 1) {
+    const minLength = Math.min(...options.map(opt => opt.length));
+    memoization.set(cacheKey, minLength);
+    return minLength;
+  }
+
+  const stepOptions = options.map(option => {
+    const steps = [];
+    steps.push(computeMinimalSteps(""A"", option[0], maxDepth - 1));
+    for (let i = 1; i < option.length; i++) {
+      steps.push(computeMinimalSteps(option[i - 1], option[i], maxDepth - 1));
+    }
+    return steps.reduce((sum, step) => sum + step, 0);
+  });
+
+  const minResult = Math.min(...stepOptions);
+  memoization.set(cacheKey, minResult);
+  return minResult;
+}
+
+function calculateMinimalCost(sequence, depth) {
+  let position = NUM_MAP[""A""];
+  let totalCost = 0;
+
+  for (let digit of sequence) {
+    const paths = generatePath(position, NUM_MAP[digit], false);
+    const pathCosts = paths.map(path => {
+      const cost = [];
+      cost.push(computeMinimalSteps(""A"", path[0], depth));
+      for (let i = 1; i < path.length; i++) {
+        cost.push(computeMinimalSteps(path[i - 1], path[i], depth));
+      }
+      return cost.reduce((sum, cost) => sum + cost, 0);
+    });
+
+    position = NUM_MAP[digit];
+    totalCost += Math.min(...pathCosts);
+  }
+  return totalCost;
+}
+
+function calculateTotalEffort(sequences, depth) {
+  const efforts = sequences.map(sequence => {
+    const cost = calculateMinimalCost(sequence, depth);
+    return cost * parseInt(sequence.slice(0, -1), 10);
+  });
+  return efforts.reduce((total, effort) => total + effort, 0);
+}
+
+console.log(calculateTotalEffort(rawInput, 25));",node:14
 2024,21,2,"--- Day 21: Keypad Conundrum ---
 
 As you teleport onto Santa's Reindeer-class starship, The Historians begin to panic: someone from their search party is missing. A quick life-form scan by the ship's computer reveals that when the missing Historian teleported, he arrived in another part of the ship.
@@ -71205,7 +72343,189 @@ The keypads form a chain, just like before: your directional keypad controls a r
 
 The door codes are the same this time around; only the number of robots and directional keypads has changed.
 
-Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,,node:14
+Find the fewest number of button presses you'll need to perform in order to cause the robot in front of the door to type each code. What is the sum of the complexities of the five codes on your list?",196910339808654,"const fs = require('fs');
+
+// Read the input file
+const input = fs.readFileSync('input.txt', { encoding: ""utf8"", flag: ""r"" });
+const keypadCodes = input.split('\n');
+
+// Keypad and Directional Pad definitions
+const keypad = [
+    ['7', '8', '9'],
+    ['4', '5', '6'],
+    ['1', '2', '3'],
+    [null, '0', 'A'],
+];
+
+const dirpad = [
+    [null, '^', 'A'],
+    ['<', 'v', '>']
+];
+
+// Function to count occurrences of characters in a string
+const count = (str) => {
+    let countObj = {};
+    for (let char of str) {
+        countObj[char] = (countObj[char] || 0) + 1;
+    }
+    return countObj;
+};
+
+// Function to calculate all shortest best paths on the grid
+const allShortestBest = (start, grid) => {
+    let pathsObj = {};
+    let seen = new Set();
+    seen.add(start.join('|'));
+    let startVal = grid[start[0]][start[1]];
+    let queue = [[[start, '', startVal]]];
+
+    const nextStep = ([r, c], grid) => {
+        return [[r - 1, c, '^'], [r, c + 1, '>'], [r + 1, c, 'v'], [r, c - 1, '<']].filter(([nr, nc, nd]) =>
+            grid?.[nr]?.[nc] !== undefined && !seen.has(`${nr}|${nc}`) && !!grid?.[nr]?.[nc]
+        ).map(([nr, nc, nd]) => [[nr, nc], nd].concat(grid[nr][nc]));
+    };
+
+    while (queue.length > 0) {
+        let nextQueue = [];
+        let queueSeen = [];
+
+        queue.forEach((path) => {
+            let [point, dir, val] = path.at(-1);
+            let next = nextStep(point, grid);
+
+            next.forEach(([np, nd, nv]) => {
+                queueSeen.push(np.join('|'));
+                let newPath = path.concat([[np, nd, nv]]);
+                pathsObj[nv] ? pathsObj[nv].push(newPath.map((x) => x[1]).join('')) : pathsObj[nv] = [newPath.map((x) => x[1]).join('')];
+                nextQueue.push(newPath);
+            });
+        });
+
+        queueSeen.forEach((x) => seen.add(x));
+        queue = nextQueue;
+    }
+
+    let bestPaths = {};
+
+    Object.entries(pathsObj).forEach(([k, paths]) => {
+        if (paths.length === 1) {
+            bestPaths[`${startVal}${k}`] = `${paths[0]}A`;
+
+            if (startVal === 'A') bestPaths[k] = `${paths[0]}A`;
+        } else {
+            let order = '<v^>';
+            const pathscore = (path) => {
+                let split = path.split('');
+
+                return split.slice(0, -1).map((y, yx) => {
+                    let score = 0;
+                    if (y !== split[yx + 1]) score += 10;
+
+                    if (order.indexOf(split[yx + 1]) < order.indexOf(y)) score += 5;
+
+                    return score;
+                }).reduce((a, b) => a + b, 0);
+            };
+
+            let scores = paths.map((x) => [pathscore(x), x]).sort((a, c) => a[0] - c[0]);
+
+            bestPaths[`${startVal}${k}`] = `${scores[0][1]}A`;
+
+            if (startVal === 'A') bestPaths[k] = `${scores[0][1]}A`;
+        }
+    });
+    return bestPaths;
+};
+
+let numpadDirs = Object.assign(...keypad.flatMap((x, ix) => x.map((y, yx) => [ix, yx, y])).filter((z) => z[2] !== null).map(([r, c, v]) => allShortestBest([r, c], keypad)));
+
+let dirs = Object.assign(...dirpad.flatMap((x, ix) => x.map((y, yx) => [ix, yx, y])).filter((z) => z[2] !== null).map(([r, c, v]) => allShortestBest([r, c], dirpad)));
+dirs['A'] = 'A';
+dirs['AA'] = 'A';
+dirs['<<'] = 'A';
+dirs['>>'] = 'A';
+dirs['^^'] = 'A';
+dirs['vv'] = 'A';
+
+const codes = keypadCodes.map((x) => [''].concat(x.split('')).map((x, ix, arr) => `${x}${arr[ix + 1]}`).slice(0, -1)).map((x) => x.map((y) => numpadDirs[y])); // First keyboard, array of button presses e.g. ['<A','^A','>^^A','vvvA'] for example
+
+// Function to calculate the minimum presses required
+const minPresses = (keypadCodes, dircodes, keyboards) => {
+    let keypadNums = keypadCodes.map((x) => parseInt(x.slice(0, -1)));
+    let targetDepth = keyboards - 1;
+    let result = 0;
+
+    for (const [index, code] of dircodes.entries()) {
+        let countObj = count(code);
+
+        for (let i = 0; i < targetDepth; i++) {
+            let newCountObj = {};
+            for (const [key, val] of Object.entries(countObj)) {
+                if (key.length === 1) {
+                    let newKey = dirs[key];
+
+                    newCountObj[newKey] ? newCountObj[newKey] += val : newCountObj[newKey] = val;
+                } else {
+                    let keySplit = [''].concat(key.split('')).map((x, ix, arr) => `${x}${arr[ix + 1]}`).slice(0, -1);
+
+                    keySplit.forEach((sKey) => {
+                        let newKey = dirs[sKey];
+                        newCountObj[newKey] ? newCountObj[newKey] += val : newCountObj[newKey] = val;
+                    });
+                }
+            }
+            countObj = newCountObj;
+        }
+
+        result += (Object.entries(countObj).map(([k, v]) => k.length * v).reduce((a, b) => a + b, 0) * keypadNums[index]);
+    }
+    return result;
+};
+
+// Performance tracking and calculation
+const t0 = performance.now();
+let p1 = minPresses(keypadCodes, codes, 3);
+const t1 = performance.now();
+
+let p2 = minPresses(keypadCodes, codes, 26);
+const t2 = performance.now();
+
+console.log('Part 1 answer is ', p1, t1 - t0, 'ms');
+console.log('Part 2 answer is ', p2, t2 - t1, 'ms');
+
+// Old list of hardcoded directions (commented out for clarity)
+const olddirs = {
+    '<': 'v<<A',
+    '^': '<A',
+    'v': '<vA',
+    '>': 'vA',
+    'A': 'A',
+    '<^': '>^A',
+    '<v': '>A',
+    '<>': '>>A',
+    '<A': '>>^A',
+    '^<': 'v<A',
+    '^v': 'vA',
+    '^>': 'v>A',
+    '^A': '>A',
+    'v<': '<A',
+    'v^': '^A',
+    'v>': '>A',
+    'vA': '^>A',
+    '><': '<<A',
+    '>v': '<A',
+    '>^': '<^A',
+    '>A': '^A',
+    'A<': 'v<<A',
+    'A^': '<A',
+    'Av': 'v<A',
+    'A>': 'vA',
+    '<<': 'A',
+    'vv': 'A',
+    '^^': 'A',
+    '>>': 'A',
+    'AA': 'A'
+};",node:14
 2024,22,1,"--- Day 22: Monkey Market ---
 
 As you're all teleported deep into the jungle, a monkey steals The Historians' device! You'll need to get it back while The Historians are looking for the Chief.