Advent of Code 2025 Day 6

Part 1

Oh what fun! And a preview of Part 2?

This feels like an altogether new challenge. That is, the main part of separating each set of numbers and performing the math.

I also notice that in both the example input and my puzzle input the text alignment of vertical lists differ: some are left-justified, others are right-justified, and some contain numbers that are each the same length.

I have a hunch that Part 2 will require programmatically determining each justification...possibly in order to determine a subset of equations.

Until then, it's time to talk through how I intend to solve Part 1.

Going from four lines to nested arrays

In my head, I want to go from this text string...

123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  

To this data structure:

[
    [[123, 45, 6], '*'],
    [[328, 64, 98], '+'],
    [[51, 387, 215], '*'],
    [[64, 23, 314], '+']
]

Taking this one step at a time...

I can split the string at each newline character:

let input = input.split('\n')

That gets me a list with four strings. The last one is of the operators. They are all a single character, which should make it easy to isolate them:

let operators = input[input.length - 1].replaceAll(' ', '').split('')

I chose to remove all white space and make a list of each character.

As for the other lines, each number and the amount of space between numbers varies.

I want to use a regular expression in a split() to break up the string into a list of numbers with whitespace removed.

I suppose I could also:

• split() at each character
• filter() out all space characters

That seems like a fine solution:

input = input.slice(0, -1).map(line => line.split('').filter(i => i !== ' '))

Does it work?

Sure doesn't. Why not?

Because it chops each number up into digits.

Silly me.

New strategy: use regex.

I'll extract each number from the string using a regular expression:

input = input.slice(0, -1).map(line => [...line.matchAll(/\d+/g)].map(el => +el[0]))

It works! I have three lists, each with the numbers in a line.

Now I need to put the numbers in the same index but different lists together.

I'll use a good-'ol-fashioned nested for loop:

let equations = []
for (let i = 0; i < input[0].length; i++) {
    let eq = []
    for (let j = 0; j < input.length; j++) {
        eq.push(input[j][i])
    }
    equations.push([eq, operators[i]])
}

What this should do is:

• Create an empty array
• Iterate as many times as there are numbers in a line (the same for each line)
• Create an empty array
• Iterate as many times as there are lines - minus the last line which has been removed by now
• Add the number at the current index to the empty array
• Finally, add the empty array and the corresponding operator as a 2-item list to the other empty array

Does this work?

It does!

[
  [ [ 123, 45, 6 ], '*' ],
  [ [ 328, 64, 98 ], '+' ],
  [ [ 51, 387, 215 ], '*' ],
  [ [ 64, 23, 314 ], '+' ]
]

Woohoo!

Next up: Math!

Processing each equation and testing

I intend to use a reduce() and eval():

• The former as a convenient syntax to arrive at a single number
• The latter as a convenient method of performing math without having to map each string character to its programmatic operator

After a bit of debugging, my working algorithm looks like this:

let part1 = equations.reduce((answer, eq) => {
    return answer += eq[0].reduce((total, num) => {
        return eval(`${total} ${eq[1]} ${num}`) 
    })
}, 0)

It generates the correct answer when runnning the example input.

Will it do the same when running my input?

...

It will! It did!

Woohoo!!

I'm glad Part 1 didn't have any hidden tricks in the input.

Now, will Part 2 make use of the varying text alignment of each equation?

I can't wait to find out.

Part 2

I knew it! Also, I had no clue.

I was right about the text alignment coming into play!

And yet the way it comes into play goes beyond what I imagined...

...into much cooler challenge territory.

This is gonna be a blast to solve...I hope.

Finding a new strategy for processing each column

The convenient thing is the operators are still in the last line.

The only difference is I'll need to process them in reverse chronological order.

I think I can carry forward my code that extracted the last line of input:

input = input.split('\n')
let operators = input[input.length - 1].replaceAll(' ', '').split('').reverse()

Visually, that statement should go like this:

input[input.length - 1]
*   +   *   +  

.replaceAll(' ', '')
*+*+

.split('')
['*','+','*','+']

.reverse()
['+','*','+','*']

Now that the operators are removed, my input string looks like this:

123 328  51 64 
 45 64  387 23 
  6 98  215 314

I need to programmatically perform the equivalent of a 90-degree counterclockwise turn to get the numbers properly oriented, like this:

  4
431
623

175
581
 32

8
248
369

356
24
1

I plan to write another nested for loop to iterate backwards through the same index of each line and build a new array of numbers.

First, I need to walk through an example to understand how I will access each index.

To get the first number, 4, I need to access these indices:

input[0][input[0].length - 1]
input[1][input[1].length - 1]
input[2][input[2].length - 1]

I should be able to refer to my local loop variables instead of re-typing input[N].length - 1.

Now for the algorithm:

let equations = []
for (let i = input[0].length - 1; i >= 0; i--) {
    let eq = []
    for (let j = 0; j < input.length; j++) {
        eq.push(input[j][i])
    }
}

When I run it wth a logging statement, I see what I expected:

[ ' ', ' ', '4' ]
[ '4', '3', '1' ]
[ '6', '2', '3' ]
[ ' ', ' ', ' ' ]
// ...and so on

Next, I need to convert each list of strings into either a number or an indicator to start a new set of numbers.

So, in the case of the above output, turn those four list of strings into:

[ [4, 431, 623], ... ]

I'm confident I can concatenate the strings and convert to a number.

Except for the list of all space characters, as that may not be a number.

So I will need a condition to handle that case.

Here's my algorithm:

let equations = [[]]
for (let i = input[0].length - 1; i >= 0; i--) {
    let eq = []
    for (let j = 0; j < input.length; j++) {
        eq.push(input[j][i])
    }
    let num = +eq.join('').trim()
    if (num == 0) {
        equations.push([])
    } else {
        equations[equations.length - 1].push(num)
    }
}

• I added a nested empty list to equations
• The second half of the nested for loop is new
• num is the list of strings joined, with white space removed, then coerced to a number
• The condition adds a new nested list when it sees a 0
• Otherwise it inserts the number at the end of the last list

Thankfully, I see the expected result:

[ [ 4, 431, 623 ], [ 175, 581, 32 ], [ 8, 248, 369 ], [ 356, 24, 1 ] ]

Now I need to reduce each sub-list by applying the correct operator to each, just like in Part 1.

That code with some minor tweaks to work with my updated data structure looks like:

let part2 = equations.reduce((answer, eq, idx) => {
    return answer += eq.reduce((total, num) => {
        return eval(`${total} ${operators[idx]} ${num}`) 
    })
}, 0)

I think that's it, since, when I run it, I see the expected answer for the example input!

But will it generate the correct answer for my puzzle input?

...

It does!

Woohoo!!!

That was such a fun 2-part challenge!

I just knew the varyied text alignment would come into play.