Solved 2024/03 P1+P2
This commit is contained in:
@@ -0,0 +1,81 @@
|
||||
## \-\-- Day 3: Mull It Over \-\--
|
||||
|
||||
\"Our computers are having issues, so I have no idea if we have any
|
||||
Chief Historians [in
|
||||
stock]{title="There's a spot reserved for Chief Historians between the green toboggans and the red toboggans. They've never actually had any Chief Historians in stock, but it's best to be prepared."}!
|
||||
You\'re welcome to check the warehouse, though,\" says the mildly
|
||||
flustered shopkeeper at the [North Pole Toboggan Rental
|
||||
Shop](/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?*
|
||||
|
||||
Your puzzle answer was `174561379`.
|
||||
|
||||
## \-\-- Part Two \-\-- {#part2}
|
||||
|
||||
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?*
|
||||
|
||||
Your puzzle answer was `106921067`.
|
||||
|
||||
Both parts of this puzzle are complete! They provide two gold stars:
|
||||
\*\*
|
||||
|
||||
At this point, you should [return to your Advent calendar](/2024) and
|
||||
try another puzzle.
|
||||
|
||||
If you still want to see it, you can [get your puzzle
|
||||
input](3/input).
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
#!/bin/python3
|
||||
import sys,re
|
||||
from pprint import pprint
|
||||
sys.path.insert(0, '../../')
|
||||
from fred import list2int,get_re,nprint,lprint
|
||||
|
||||
input_f = 'input'
|
||||
|
||||
part = 2
|
||||
#########################################
|
||||
# #
|
||||
# Part 1 #
|
||||
# #
|
||||
#########################################
|
||||
result = 0
|
||||
if part == 1:
|
||||
with open(input_f) as file:
|
||||
for line in file:
|
||||
for i in re.findall(r"(mul\((\d+),{1}(\d+)\))",line.rstrip()):
|
||||
result += (int(i[1])*int(i[2]))
|
||||
|
||||
print(result)
|
||||
|
||||
|
||||
|
||||
#########################################
|
||||
# #
|
||||
# Part 2 #
|
||||
# #
|
||||
#########################################
|
||||
result = 0
|
||||
do = True
|
||||
if part == 2:
|
||||
with open(input_f) as file:
|
||||
for line in file:
|
||||
matches = re.findall(r"mul\(\d+,\d+\)|do\(\)|don't\(\)",line.rstrip())
|
||||
for match in matches:
|
||||
if match == 'do()':
|
||||
do = True
|
||||
elif match == "don't()":
|
||||
do = False
|
||||
else:
|
||||
if do:
|
||||
m = get_re(r"mul\((\d+),{1}(\d+)\)",match)
|
||||
result += (int(m.group(1))*int(m.group(2)))
|
||||
print(result)
|
||||
|
||||
# Not really happy with my code. I would prefer to find all mul(x,y) between do() and don't(),
|
||||
# instead of finding all the mul/do/don't and then turning calculation on/off.
|
||||
|
||||
#(do\(\).*?mul\((\d+),{1}(\d+)\))
|
||||
@@ -0,0 +1,16 @@
|
||||
from re import findall
|
||||
|
||||
total1 = total2 = 0
|
||||
enabled = True
|
||||
data = open('input').read()
|
||||
|
||||
for a, b, do, dont in findall(r"mul\((\d+),(\d+)\)|(do\(\))|(don't\(\))", data):
|
||||
if do or dont:
|
||||
enabled = bool(do)
|
||||
else:
|
||||
x = int(a) * int(b)
|
||||
total1 += x
|
||||
total2 += x * enabled
|
||||
|
||||
print(total1, total2)
|
||||
|
||||
Reference in New Issue
Block a user