Upload aoc.csv

aoc.csv

@@ -16069,52 +16069,41 @@ Your puzzle answer was 219150360.
 
 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 re
-from functools import reduce
-from operator import mul
-
-with open('input.txt') as f:
-    lines = f.read().splitlines()
-
-positions = []
-velocities = []
-for line in lines:
-    m = re.match(""p=(\\d+),(\\d+) v=(\\-?\\d+),(\\-?\\d+)"", line)
-    positions.append(tuple(map(int, m.groups()[0:2])))
-    velocities.append(tuple(map(int, m.groups()[2:])))
-
-x_len = 101
-y_len = 103
-
-initial_positions = positions[:]
-
-for num_seconds in range(10000):
-    for i in range(len(positions)):
-        new_x = (initial_positions[i][0] + num_seconds * velocities[i][0]) % x_len
-        new_y = (initial_positions[i][1] + num_seconds * velocities[i][1]) % y_len
-        positions[i] = (new_x, new_y)
-
-    grid = [[0] * x_len for j in range(y_len)]
+What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"from collections import defaultdict
+from statistics import stdev
 
-    for pos in positions:
-        grid[pos[1]][pos[0]] += 1
+def read_input(file_path):
+    """"""Read input from file and parse positions and velocities.""""""
+    positions, velocities = [], []
+    with open(file_path) as f:
+        for line in f:
+            p_sec, v_sec = line.split()
+            positions.append([int(i) for i in p_sec.split(""="")[1].split("","")])
+            velocities.append([int(i) for i in v_sec.split(""="")[1].split("","")])
+    return positions, velocities
+
+def simulate_motion(positions, velocities, num_x=101, num_y=103, steps=10000):
+    """"""Simulate motion and detect significant changes in distribution.""""""
+    for step in range(1, steps + 1):
+        block_counts = defaultdict(int)
+        new_positions = []
+
+        for pos, vel in zip(positions, velocities):
+            new_x = (pos[0] + vel[0]) % num_x
+            new_y = (pos[1] + vel[1]) % num_y
+            new_positions.append([new_x, new_y])
+            block_counts[(new_x // 5, new_y // 5)] += 1
+
+        if stdev(block_counts.values()) > 3:
+            print(step)
+            break
 
-    no_dupes = True
-    for y in range(y_len):
-        for x in range(x_len):
-            if grid[y][x] > 1:
-                no_dupes = False
-                break
+        positions = new_positions
 
-    if no_dupes:
-        print(""after"", num_seconds, ""seconds:"")
-        for y in range(y_len):
-            row = """"
-            for x in range(x_len):
-                v = grid[y][x]
-                row += f'{v}' if v > 0 else '.'
-            print(row)
-        break",python:3.9.21-slim
+if __name__ == ""__main__"":
+    positions, velocities = read_input(""input.txt"")
+    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.
@@ -16387,48 +16376,25 @@ Your puzzle answer was 219150360.
 
 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 re
-
-
-with open(""input.txt"") as i:
-    input = [x.strip() for x in i.readlines()]
-
-test_data = """"""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"""""".split(""\n"")
-
-w, h = 101, 103
-
-# w, h = 11, 7
-# input = test_data
-
-start_robots = []
-for l in input:
-    a, b, c, d = re.match(r""p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)"", l).groups()
-    start_robots.append((int(a),int(b),int(c),int(d)))
-
-robots = start_robots
-for i in range(100):
-    tmp = []
-    for x, y, dx, dy in robots:
-        tmp.append(((x+dx) % w, (y+dy)%h, dx, dy))
-    robots = tmp
-
-q1 = [(x,y,dx,dy) for x,y,dx,dy in robots if x<w//2 and y<h//2]
-q2 = [(x,y,dx,dy) for x,y,dx,dy in robots if x<w//2 and y>h//2]
-q3 = [(x,y,dx,dy) for x,y,dx,dy in robots if x>w//2 and y<h//2]
-q4 = [(x,y,dx,dy) for x,y,dx,dy in robots if x>w//2 and y>h//2]
-
-print(len(q1)*len(q2)*len(q3)*len(q4))",python:3.9.21-slim
+What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"import re; L = len(M:=[*map(int, re.findall('[-\d]+', open(0).read()))])
+
+R, C = 103, 101; B = (1, -1)
+for T in range(R*C):
+    G = [['.']*C for _ in range(R)]
+    Z = [0]*4
+    for i in range(0, L, 4):
+        py, px, vy, vx = M[i:i+4]
+        x = (px+vx*T)%R; y = (py+vy*T)%C
+        G[x][y] = '#'
+        if x == R//2 or y == C//2: continue
+        Z[(x<R//2)+2*(y<C//2)] += 1
+    S = '\n'.join(''.join(r) for r in G)
+    t = B[0]
+    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
 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.
@@ -16551,57 +16517,78 @@ Your puzzle answer was 219150360.
 
 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,"#!/usr/bin/env python3
+What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"with open(""Day-14-Challenge/input.txt"", ""r"") as file:
+    lines = file.readlines()
 
-import re
-from collections import defaultdict
+WIDE = 101
+TALL = 103
 
-myfile = open(""14.in"", ""r"")
-lines = myfile.read().strip().splitlines()
-myfile.close()
+robots = []
+for robot in lines: #  format
+    sides = robot.split("" "")
+    left_side = sides[0]
+    right_side = sides[1]
+    left_sides = left_side.split("","")
+    Px = left_sides[0].split(""="")[-1]
+    Py = left_sides[1]
+    right_sides = right_side.split("","")
+    Vx = right_sides[0].split(""="")[-1]
+    Vy = right_sides[1].strip()
+    Px = int(Px)
+    Py = int(Py)
+    Vx = int(Vx)
+    Vy = int(Vy)
+    robots.append([Px,Py,Vx,Vy])
+
+smallest_answer = 999999999999
+found_at_second = 0
+for second in range(WIDE * TALL): # pattern will repeat every WIDE * TALL times
+    q1 = 0
+    q2 = 0
+    q3 = 0
+    q4 = 0
+    final_grid = [[0]*WIDE for _ in range(TALL)]
+    for i in range(len(robots)):
+        Px,Py,Vx,Vy = robots[i]
+        new_Py, new_Px = (Px + Vx * second),(Py + Vy * second) # swap X and Y coords because its swapped in the examples too
+        # for matplotlib
+        new_Px, new_Py = (new_Px % TALL), (new_Py % WIDE)
+        final_grid[new_Px][new_Py] += 1 
+        vertical_middle = WIDE // 2
+        horizontal_middle = TALL // 2
+
+
+        if new_Px < vertical_middle and new_Py < horizontal_middle:
+            q1 += 1
+        if new_Px > vertical_middle and new_Py < horizontal_middle:
+            q2 += 1
+        if new_Px < vertical_middle and new_Py > horizontal_middle:
+            q3 += 1
+        if new_Px > vertical_middle and new_Py > horizontal_middle:
+            q4 += 1
+
+    answer = q1 * q2 * q3 * q4 # when answer is smallest, 
+    # robots are bunched together to draw the christmas tree, so one corner will have most robots
+    # so when we multiply with other quadrants answer will be smaller
+    # If we have 40 robots, answer is smaller if 37 are in Q1 and 1 each in rest = 37
+    # If they are evenly split its 10 * 10 * 10 * 10 = 10000
+    # So we assume that tree is drawn when smallest answer.
+    # Mirrored approach doesnt work
+    if(answer < smallest_answer): # find smallest answer
+        smallest_answer = answer
+        found_at_second = second
 
-part_one = 0
-part_two = 0
+    
+print(""Found smallest safety factor: "", smallest_answer)
+print(""at second: "", found_at_second)
 
-width = 101
-height = 103
-robots = []
-for line in lines:
-    p, v = line.split()
-    p = [int(x) for x in re.findall(r""-?\d+"", p)]
-    v = [int(x) for x in re.findall(r""-?\d+"", v)]
-    robots.append((p, v))
-
-found_tree = False
-for s in range(1, 10000):
-    if found_tree:
-        break
 
-    grid = defaultdict(bool)
-    for i, r in enumerate(robots):
-        p, v = r
-        new_p = ((p[0] + v[0]) % width, (p[1] + v[1]) % height)
-        grid[new_p] = True
-        robots[i] = (new_p, v)
-
-    if s == 100:
-        quad_1 = quad_2 = quad_3 = quad_4 = 0
-        for r in robots:
-            mid_x = width // 2
-            mid_y = height // 2
-
-            p = r[0]
-            if p[0] < mid_x and p[1] < mid_y:
-                quad_1 += 1
-            elif p[0] > mid_x and p[1] < mid_y:
-                quad_2 += 1
-            elif p[0] < mid_x and p[1] > mid_y:
-                quad_3 += 1
-            elif p[0] > mid_x and p[1] > mid_y:
-                quad_4 += 1
-        part_one = quad_1 * quad_2 * quad_3 * quad_4
+# Total time complexity
+# O(WIDE * TALL * n) so kindof O(n) :)
 
-print(""Part One:"", part_one)",python:3.9.21-slim
+# Total space complexity
+# 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.
@@ -16724,46 +16711,66 @@ Your puzzle answer was 219150360.
 
 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,"from collections import defaultdict
+What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"import pathlib
 import re
+import math
 
-def move_hundred_times(curr_x, curr_y, curr_vel_x, curr_vel_y, max_w, max_h):
-    pos_x = (100 * curr_vel_x + curr_x) % max_w
-    pos_y = (100 * curr_vel_y + curr_y) % max_h
-
-    return pos_x, pos_y
-
-
-def move_n_times(n, curr_x, curr_y, curr_vel_x, curr_vel_y, max_w, max_h):
-    pos_x = (n * curr_vel_x + curr_x) % max_w
-    pos_y = (n * curr_vel_y + curr_y) % max_h
-
-    return pos_x, pos_y
-
-
-positions = defaultdict(int)
-# max_pos = (11, 7)
-max_pos = (101, 103)
-
-start_pos = []
-
-for line in open(""input.txt""):
-    x, y, v_x, v_y = re.findall(r""-?[0-9]+"", line)
+lines = pathlib.Path(""data.txt"").read_text().split(""\n"")
 
-    start_pos.append((int(x), int(y), int(v_x), int(v_y)))
-
-    pos_x, pos_y = move_hundred_times(int(x), int(y), int(v_x), int(v_y), *max_pos)
-
-    positions[(pos_x, pos_y)] += 1
+iterations = 100
+width = 101
+height = 103
+robots = []
 
+#example input only
+#width = 11
+#height = 7
 
-res = 1
-res *= sum(val for (x, y), val in positions.items() if x < (max_pos[0] - 1) // 2 and y < (max_pos[1] - 1) // 2)
-res *= sum(val for (x, y), val in positions.items() if x < (max_pos[0] - 1) // 2 and y > (max_pos[1] - 1) // 2)
-res *= sum(val for (x, y), val in positions.items() if x > (max_pos[0] - 1) // 2 and y < (max_pos[1] - 1) // 2)
-res *= sum(val for (x, y), val in positions.items() if x > (max_pos[0] - 1) // 2 and y > (max_pos[1] - 1) // 2)
+for line in lines:
+  matches = re.findall(r""[-\d]+"", line)
+  x, y, vx, vy = [int(i) for i in matches]
+  robots.append([x, y, vx, vy])
+
+quadrants = [0, 0, 0, 0]
+
+for x, y, vx, vy in robots:
+  x = (x + vx * iterations) % width
+  y = (y + vy * iterations) % height
+
+  mid_x = width//2
+  mid_y = height//2
+  if x < mid_x and y < mid_y:
+    quadrants[0] += 1
+  elif x < mid_x and y > mid_y:
+    quadrants[1] += 1
+  elif x > mid_x and y < mid_y:
+    quadrants[2] += 1
+  elif x > mid_x and y > mid_y:
+    quadrants[3] += 1
+
+safety_factor = math.prod(quadrants)
+print(safety_factor)
+
+pictures = 0
+for i in range(1, 100000):
+  new_robots = []
+  board = [[0 for j in range(width)] for j in range(height)]
+  for x, y, vx, vy in robots:
+    x = (x + vx * i) % width
+    y = (y + vy * i) % height
+    new_robots.append((x, y))
+    board[y][x] = 1
+
+  if len(set(new_robots)) != len(new_robots):
+    continue
+  
+  max_sum = max((sum(row) for row in board))
+  #the tree picture has 31 robots in a single row 
+  if max_sum > 30:
+    print(i)
+    break
 
-print(res)",python:3.9.21-slim
+",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?
@@ -51493,7 +51500,7 @@ During the bathroom break, someone notices that these robots seem awfully simila
 
 What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"import { readFileSync } from ""fs"";
 
-const input = readFileSync(‘input.txt', {
+const input = readFileSync('input.txt', {
   encoding: 'utf-8'
 })
 
@@ -51655,48 +51662,78 @@ Your puzzle answer was 219150360.
 
 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,"const fs = require('fs');
-const input = fs.readFileSync('input.txt', 'utf8').trim().split('\n');
+What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"const fs = require(""fs"");
 
-const robots = input.map(line => {
-    const parts = line.split(/[ ,]/);
-    const x = parseInt(parts[0].substring(2));
-    const y = parseInt(parts[1]);
-    const vx = parseInt(parts[3].substring(2));
-    const vy = parseInt(parts[4]);
-    return { x, y, vx, vy };
-});
+// Read input file and split lines
+const lines = fs.readFileSync(""input.txt"", ""utf8"").trim().split(""\n"");
 
+const ITERATIONS = 100;
 const WIDTH = 101;
 const HEIGHT = 103;
+const robots = [];
+
+// Parse input data
+lines.forEach(line => {
+    const [x, y, vx, vy] = line.match(/-?\d+/g).map(Number);
+    robots.push({ x, y, vx, vy });
+});
+
+const quadrants = [0, 0, 0, 0];
+
+// Compute quadrant distribution after 100 iterations
+robots.forEach(({ x, y, vx, vy }) => {
+    const newX = (x + vx * ITERATIONS) % WIDTH;
+    const newY = (y + vy * ITERATIONS) % HEIGHT;
+
+    const midX = Math.floor(WIDTH / 2);
+    const midY = Math.floor(HEIGHT / 2);
+
+    if (newX < midX && newY < midY) quadrants[0]++;
+    else if (newX < midX && newY > midY) quadrants[1]++;
+    else if (newX > midX && newY < midY) quadrants[2]++;
+    else if (newX > midX && newY > midY) quadrants[3]++;
+});
+
+// Compute safety factor
+const safetyFactor = quadrants.reduce((acc, val) => acc * val, 1);
+console.log(""Safety Factor:"", safetyFactor);
+
+// Find the iteration when the tree shape appears
+for (let i = 1; i < 100000; i++) {
+    const seenPositions = new Set();
+    const board = Array.from({ length: HEIGHT }, () => Array(WIDTH).fill(0));
+
+    let collision = false;
 
-function computeArea(t) {
-    let minX = Infinity, maxX = -Infinity;
-    let minY = Infinity, maxY = -Infinity;
     for (const { x, y, vx, vy } of robots) {
-        const rx = (x + vx * t) % WIDTH;
-        const posX = rx < 0 ? rx + WIDTH : rx;
-        const ry = (y + vy * t) % HEIGHT;
-        const posY = ry < 0 ? ry + HEIGHT : ry;
-        minX = Math.min(minX, posX);
-        maxX = Math.max(maxX, posX);
-        minY = Math.min(minY, posY);
-        maxY = Math.max(maxY, posY);
-    }
-    return (maxX - minX + 1) * (maxY - minY + 1);
-}
+        let newX = (x + vx * i) % WIDTH;
+        let newY = (y + vy * i) % HEIGHT;
+
+        if (newX < 0) newX += WIDTH;
+        if (newY < 0) newY += HEIGHT;
 
-let bestT = 0;
-let minArea = Infinity;
-for (let t = 0; t < 100000; t++) {
-    const area = computeArea(t);
-    if (area < minArea) {
-        minArea = area;
-        bestT = t;
+        const posKey = `${newX},${newY}`;
+
+        if (seenPositions.has(posKey)) {
+            collision = true;
+            break;
+        }
+
+        seenPositions.add(posKey);
+        board[newY][newX] = 1;
     }
-}
 
-console.log(bestT);",node:14
+    if (collision) continue;
+
+    const maxRowSum = Math.max(...board.map(row => row.reduce((sum, cell) => sum + cell, 0)));
+
+    // The tree picture has 31 robots in a single row
+    if (maxRowSum > 30) {
+        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.
@@ -52235,119 +52272,58 @@ Your puzzle answer was 219150360.
 
 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,"""use strict""
-
-const input = Deno.readTextFileSync(""day14-input.txt"").trim()
-
-const width = 101
-const height = 103
-
-const map = [ ]
-
-const allGuards = [ ]
-
-var time = 0
+What is the fewest number of seconds that must elapse for the robots to display the Easter egg?",8053,"const fs = require(""fs"");
 
+// Read input file
+const inputText = fs.readFileSync(""input.txt"", ""utf8"").trim().split(""\n"");
 
-function main() {
-
-    processInput()
+const numX = 101;
+const numY = 103;
+let initialPositions = [];
+let velocities = [];
 
-    setMap()
-    
-    while (true) {
-        
-        time += 1    
-        const clashes = moveGuards()
+// Parse input
+inputText.forEach(line => {
+    let [pSec, vSec] = line.split("" "");
+    let position = pSec.split(""="")[1].split("","").map(Number);
+    let velocity = vSec.split(""="")[1].split("","").map(Number);
+    initialPositions.push(position);
+    velocities.push(velocity);
+});
 
-        if (! clashes) { showMap(); break }
-    }    
-    
-    console.log(""If there is a xmas tree in the picture above, the answer is"", time)        
+// Standard deviation function
+function standardDeviation(values) {
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length;
+    return Math.sqrt(variance);
 }
 
-function processInput() {
-        
-    const lines = input.split(""\n"")
-    
-    for (const line of lines) { 
-    
-        const parts = line.trim().split("" "")
-        
-        const tokensP = parts.shift().substr(2).split("","")
-        const tokensV = parts.shift().substr(2).split("","")
-        
-        const posX = parseInt(tokensP.shift())
-        const posY = parseInt(tokensP.shift())
-        const velX = parseInt(tokensV.shift())
-        const velY = parseInt(tokensV.shift())
-        
-        const guard = { ""posX"": posX, ""posY"": posY, ""velX"": velX, ""velY"": velY }
-        
-        Object.freeze(guard) // will not be edited
-        
-        allGuards.push(guard)
-    }
-}
+// Simulation loop
+for (let counter = 0; counter < 10000; counter++) {
+    let blockCounts = new Map();
+    let newInitialPositions = [];
 
-function setMap() {
+    initialPositions.forEach((initialPos, index) => {
+        let velocity = velocities[index];
+        let newX = (initialPos[0] + velocity[0]) % numX;
+        let newY = (initialPos[1] + velocity[1]) % numY;
 
-    for (let row = 0; row < height; row++) { 
+        if (newX < 0) newX += numX;
+        if (newY < 0) newY += numY;
 
-        const line = [ ]
-        map.push(line)
+        newInitialPositions.push([newX, newY]);
 
-        for (let col = 0; col < height; col++) { line.push(0) }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-function moveGuards() {
+        let blockKey = `${Math.floor(newX / 5)},${Math.floor(newY / 5)}`;
+        blockCounts.set(blockKey, (blockCounts.get(blockKey) || 0) + 1);
+    });
 
-    for (const guard of allGuards) { 
-    
-        const clashes = moveGuard(guard)
-        
-        if (clashes) { return true } 
+    if (blockCounts.size > 0 && standardDeviation([...blockCounts.values()]) > 3) {
+        console.log(counter + 1);
     }
-    return false
-}
 
-function moveGuard(guard) { 
-                
-    const bruteX = guard.posX + (time * guard.velX)
-    const bruteY = guard.posY + (time * guard.velY)
-    
-    let finalX = bruteX % width
-    if (finalX < 0) { finalX += width }
-    
-    let finalY = bruteY % height
-    if (finalY < 0) { finalY += height }
-        
-    if (map[finalY][finalX] == time) { return true }
-    
-    map[finalY][finalX] = time
-    
-    return false
-}
-
-function showMap() {
-
-    console.log("""")
-    
-    for (const line of map) { 
-    
-        let s = """"
-        for (const number of line) { s += number == time ? ""X"" : ""."" }    
-        console.log(s)
-    }
-    console.log("""")
+    initialPositions = newInitialPositions;
 }
-
-console.time(""execution time"")
-main()
-console.timeEnd(""execution time"") // 30ms",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.