chore: implement day 3 solution

Author: Rudy Puig

docs/2024/day-03.md

@@ -0,0 +1,48 @@
+# Day 1: Mull It Over
+
+## Part One
+
+--- Day 3: Mull It Over ---
+
+"Our computers are having issues, so I have no idea if we have any Chief Historians in stock! You're welcome to check the warehouse, though," says the mildly flustered shopkeeper at the [North Pole Toboggan Rental Shop](https://adventofcode.com/2020/day/2). The Historians head out to take a look.
+
+The shopkeeper turns to you. "Any chance you can see why our computers are having issues again?"
+
+The computer appears to be trying to run a program, but its memory (your puzzle input) is _corrupted_. All of the instructions have been jumbled up!
+
+It seems like the goal of the program is just to _multiply some numbers_. It does that with instructions like `mul(X,Y)`, where `X` and `Y` are each 1-3 digit numbers. For instance, `mul(44,46)` multiplies `44` by `46` to get a result of `2024`. Similarly, `mul(123,4)` would multiply `123` by `4`.
+
+However, because the program's memory has been corrupted, there are also many invalid characters that should be _ignored_, even if they look like part of a `mul` instruction. Sequences like `mul(4*`, `mul(6,9!`, `?(12,34)`, or `mul ( 2 , 4 )` do _nothing_.
+
+For example, consider the following section of corrupted memory:
+
+```
+xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))
+```
+
+Only the four highlighted sections are real `mul` instructions. Adding up the result of each instruction produces `_161_` (`2*4 + 5*5 + 11*8 + 8*5`).
+
+Scan the corrupted memory for uncorrupted `mul` instructions. _What do you get if you add up all of the results of the multiplications?_
+
+## Part Two
+
+As you scan through the corrupted memory, you notice that some of the conditional statements are also still intact. If you handle some of the uncorrupted conditional statements in the program, you might be able to get an even more accurate result.
+
+There are two new instructions you'll need to handle:
+
+- The `do()` instruction _enables_ future `mul` instructions.
+- The `don't()` instruction _disables_ future `mul` instructions.
+
+Only the _most recent_ `do()` or `don't()` instruction applies. At the beginning of the program, `mul` instructions are _enabled_.
+
+For example:
+
+```
+xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))
+```
+
+This corrupted memory is similar to the example from before, but this time the `mul(5,5)` and `mul(11,8)` instructions are _disabled_ because there is a `don't()` instruction before them. The other `mul` instructions function normally, including the one at the end that gets re-_enabled_ by a `do()` instruction.
+
+This time, the sum of the results is `48` (`2*4 + 8*5`).
+
+Handle the new instructions; _what do you get if you add up all of the results of just the enabled multiplications?_

src/aoc/2024/day_03.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+import re
+
+from functools import reduce
+from operator import mul
+from typing import Iterable, Iterator, List
+
+
+RE_INSTRUCTION_P1 = re.compile(r"(?P<value>mul\(\d+,\d+\))+?", re.I)
+RE_INSTRUCTION_P2 = re.compile(r"(?P<value>(mul\(\d+,\d+\)|do(n't)?\(\)))+?", re.I)
+
+
+def answer_1(input: List[str]) -> int:
+    instructions = extract_instructions(input, RE_INSTRUCTION_P1)
+    multiplications = extract_multiplications(instructions)
+    return sum(multiplications)
+
+
+def answer_2(input: List[str]) -> int:
+    instructions = extract_instructions(input, RE_INSTRUCTION_P2)
+    multiplications = extract_multiplications(instructions)
+    return sum(multiplications)
+
+
+def extract_instructions(input: List[str], search_pattern: re.Pattern, /) -> Iterator[re.Match[str]]:
+    instructions = search_pattern.finditer("".join(input))
+    yield from instructions
+
+
+def extract_multiplications(input: Iterator[re.Match[str]], /) -> Iterator[int]:
+    instruction_enabled = True
+    for instruction in input:
+        instruction_value = instruction.group("value")
+        if instruction_value.startswith("don't("):
+            instruction_enabled = False
+        elif instruction_value.startswith("do("):
+            instruction_enabled = True
+        elif instruction_value.startswith("mul("):
+            instruction_result = reduce(mul, extract_operands(instruction_value)) if instruction_enabled else 0
+            yield instruction_result
+
+
+def extract_operands(input: str) -> Iterable[int]:
+    operands = map(lambda s: int(re.sub(r"\D+", "", s)), input.split(","))
+    return operands

tests/fixtures/2024/03-example.txt

@@ -0,0 +1,5 @@
+xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))
+--EXPECT--
+161
+--EXPECT--
+48