Advent of Code 2024 Day 3

Part 1

I fear for Part 2

I peeked at the puzzle input and got very intimidated.

Then I read what I have to do for Part 1 and was put temporarily at ease:

• Just find all instances of mul(N,N)

I can use a simple regular expression to do that!

Using regex to find all valid muls

I had to remember to escape the parentheses, then I got this working regex:

/mul\((\d*),(\d*)\)/g

• This matches all valid mul portions
• And creates capture groups for each of the digits in each pair

Now I need to do the appropriate extraction and math for each match

Writing the algorithm

Here is the full working code:

let total = [...input.matchAll(/mul\((\d*),(\d*)\)/g)].reduce(
  (total, match) => {
    total += match
      .slice(1, 3)
      .map(Number)
      .reduce((a, b) => a * b);
    return total;
  },
  0
);

• It finds all matches and spreads them out into an array
• Then iterates through each one, accumulating a value from 0
• For each match, it grabs only the two captured groups, at indices 1 and 2
• Converts them to numbers
• Reduces them to their product
• And adds that amount to the running total

It generates the correct answer for the example input.

Trying on my puzzle input generates...

The correct answer!!!

Deep breath...........

............for Part 2

Part 2

Oh, that's not so bad

I figured that since the input is full of different words, it was going to add all sorts of new rules to account for.

Thankfully, just two new words that act as starts and ends for valid mul statements.

This now feels like an exercise in isolating each stretch of valid statements by indexing each do() and don't() and searching the right portions for mul statements to parse.

Indexing the condition flags

I want to use regex to match all occurrences of do() and don't():

/don't\(\)|do\(\)/g

With that, I should have alternating checkpoints along the path of the input string.

If so, I can extract substrings between a do() and don't() checkpoint, and check for muls.

Let me confirm on both example and full inputs.

Here's my algorithm for isolating the flag and its index:

let flags = [...input.matchAll(/don't\(\)|do\(\)/g)].map((el) => {
  return [el[0], el.index];
});

Confirmed:

• Alternating conditions in the example
• No trusted pattern in my input: multiple do() and don't() in a row

This just got a bit more complicated.

New strategy

Since things start enabled, I must grab from index 0 until the first don't(). So, I need to find its index. And check that substring.

From then on, I can skip all subsequent don't()s, and look for the next do().

With that as my new starting index, I need to find the next don't(). That's my new end spot. Check that substring.

And repeat: find next do(), find next don't(), check substring.

This feels like a while loop.

I'll know more when as I write my algorithm.

New, longer algorithm

Lots of conditions to handle the pattern-lacking do-don't occurrence order:

let total = 0;
let start = 0;
let end = 0;
let flag = true;
let i = 0;
while (i < flags.length) {
  if (flag) {
    // find next don't()
    if (flags[i][0] == "don't()") {
      // set new end
      end = flags[i][1];
      // swap flag
      flag = false;
      // calculate muls in substring
      total += [
        ...input.slice(start, end).matchAll(/mul\((\d*),(\d*)\)/g),
      ].reduce((total, match) => {
        total += match
          .slice(1, 3)
          .map(Number)
          .reduce((a, b) => a * b);
        return total;
      }, 0);
    } else {
      // keep walking the array
      i++;
    }
  } else {
    // find next do()
    if (flags[i][0] == "do()") {
      // set new start
      start = flags[i][1];
      // swap flag
      flag = true;
      // keep walking the array
      i++;
    } else {
      // keep walking the array
      i++;
    }
  }
}
// calculate muls for the last substring
total += [...input.slice(start).matchAll(/mul\((\d*),(\d*)\)/g)].reduce(
  (total, match) => {
    total += match
      .slice(1, 3)
      .map(Number)
      .reduce((a, b) => a * b);
    return total;
  },
  0
);

To my gleeful surprise, it generates the correct answer for the example input.

What will it generate after processing my puzzle input?

...

The correct answer!!!

Before I checked, though, I added a console logging statement to confirm each start and end index for the substring to check.

I compared them to the order of flags in the array.

Everything looked right, so I submitted.

And got the correct answer!

What a delightful and rewarding feeling!

Another early day. Another hard-earned two gold stars.

On to Day 4!