Javascript on May's Blog

🎄 Advent of Code '25 Day 5: Cafeteria

Fri, 05 Dec 2025 09:55:54 +0200

Day 5 felt like running a little data pipeline: we ingest ranges, normalize them, and answer two slightly different queries.

Part 1 – Checking the available IDs

The database lists “fresh” ID ranges followed by a blank line and then the list of available items we need to classify. My approach:

Parse the ranges and IDs.
Sort and merge overlapping or adjacent ranges so we end up with disjoint intervals.
For each ID, run a binary search to see whether it lands inside any merged interval.

Complexity: Merging ranges costs O(R log R) where R is the number of range lines. Each ID lookup is O(log R), so the total runtime is O(R log R + I log R); memory stays O(R) for the merged intervals.

🎄 Advent of Code '25 Day 4: Printing Department

Thu, 04 Dec 2025 08:23:54 +0200

Forklifts, paper rolls, and lots of adjacency checks: Day 4 turned into a neat graph-like puzzle. Here’s how I solved both parts and what their complexity looks like.

Part 1 – Finding accessible rolls

Each roll of paper is represented by @ on a grid. A roll is accessible if fewer than four of the eight neighboring cells also contain rolls. The solver:

Parses the grid from input.txt.
Walks every cell; when it finds an @, it counts the occupied neighbors using the eight-direction offsets.
Increments the answer whenever the neighbor count is < 4.

Complexity: Let the grid be H x W. We inspect each cell once and examine up to eight neighbors, so runtime is O(H * W) with O(1) auxiliary memory.

🎄 Advent of Code '25 Day 3: Lobby

Wed, 03 Dec 2025 11:23:54 +0200

I spent Day 3 hanging out in the lobby with a pile of battery banks and a stubborn escalator. Here is how I cracked both puzzles using a pair of lean JavaScript scripts (part1.js and part2.js).

Part 1 – Two batteries, one number

Each bank is a string of digits. I needed the largest possible two-digit value that preserves order. Rather than evaluate every pair, I sweep the string once while tracking the best “first” digit seen so far. Every new digit forms a candidate pair with that best digit; if the candidate beats the running maximum, I store it, and if the new digit is even better as a first digit, I promote it. This greedy pass extracts the answer for a bank in linear time.

🎄 Advent of Code '25 Day 2: Gift Shop

Tue, 02 Dec 2025 09:07:54 +0200

Day 2 was all about spotting playful ID patterns inside huge numerical ranges. Here’s how both parts came together.

Input parsing shared by both parts

The puzzle input is one comma-separated line of inclusive ranges (start-end). I parse everything as BigInt so that the gigantic IDs stay precise. After that, each part does its own math on top of the same parsed data.

Part 1 – Double-half IDs

Condition. An ID is invalid if it is exactly two copies of some digit string (e.g., 64 64). If the repeated block has length h, then the ID equals pattern * 10^h + pattern.

🎄 Advent of Code '25 Day 1: Secret Entrance

Mon, 01 Dec 2025 10:02:54 +0200

For Day 1 I had to open a safe with a dial numbered 0–99. Here’s how both halves of the puzzle fell.

Part 1 – Counting end-of-rotation zeros

The dial starts at 50 and each instruction looks like L68 or R48. I only needed to know how many times the dial ended on 0 after finishing each rotation.

Implementation notes:

Parse every instruction once.
Track the current dial position; rotate by converting L to negative steps and R to positive steps.
Apply the delta with (position + delta) mod 100 keeping values non-negative.
Increment the answer whenever the resulting position equals 0.

This runs in O(n) with n rotations and needs only a handful of integers.