daviddoji
/
Advent_of_code
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of ssh://git.elnota.space:10222/daviddoji/Advent_of_code

This commit is contained in:
David Doblas Jiménez 2022-07-27 17:18:06 +02:00
parent 570776b2ad 772abe6588
commit c25363a677
3 changed files with 552 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
src/Year_2016/P12.py Normal file
View File

@ -0,0 +1,108 @@
# --- Day 12: Leonardo's Monorail ---
# You finally reach the top floor of this building: a garden with a slanted
# glass ceiling. Looks like there are no more stars to be had.
# While sitting on a nearby bench amidst some tiger lilies, you manage to
# decrypt some of the files you extracted from the servers downstairs.
# According to these documents, Easter Bunny HQ isn't just this building - it's
# a collection of buildings in the nearby area. They're all connected by a
# local monorail, and there's another building not far from here!
# Unfortunately, being night, the monorail is currently not operating.
# You remotely connect to the monorail control systems and discover that the
# boot sequence expects a password. The password-checking logic (your puzzle
# input) is easy to extract, but the code it uses is strange: it's assembunny
# code designed for the new computer you just assembled. You'll have to execute
# the code and get the password.
# The assembunny code you've extracted operates on four registers (a, b, c, and
# d) that start at 0 and can hold any integer. However, it seems to make use of
# only a few instructions:
# cpy x y copies x (either an integer or the value of a register) into
# register y.
# inc x increases the value of register x by one.
# dec x decreases the value of register x by one.
# jnz x y jumps to an instruction y away (positive means forward; negative
# means backward), but only if x is not zero.
# The jnz instruction moves relative to itself: an offset of -1 would continue
# at the previous instruction, while an offset of 2 would skip over the next
# instruction.
# For example:
# cpy 41 a
# inc a
# inc a
# dec a
# jnz a 2
# dec a
# The above code would set register a to 41, increase its value by 2, decrease
# its value by 1, and then skip the last dec a (because a is not zero, so the
# jnz a 2 skips it), leaving register a at 42. When you move past the last
# instruction, the program halts.
# After executing the assembunny code in your puzzle input, what value is left
# in register a?
with open("files/P12.txt") as f:
lines = [line.strip().split() for line in f]
def value(key: str, dic: dict[str, int]) -> int:
return dic[key] if key in dic else int(key)
def part_1() -> None:
register = {"a": 0, "b": 0, "c": 0, "d": 0}
instruction = 0
while instruction != len(lines):
instr = lines[instruction]
if instr[0] == "cpy":
register[instr[2]] = value(instr[1], register)
elif instr[0] == "inc":
register[instr[1]] += 1
elif instr[0] == "dec":
register[instr[1]] -= 1
elif instr[0] == "jnz" and value(instr[1], register) != 0:
instruction += int(instr[2])
continue
instruction += 1
print(f"The register a has the following value: {register['a']}")
# --- Part Two ---
# As you head down the fire escape to the monorail, you notice it didn't start;
# register c needs to be initialized to the position of the ignition key.
# If you instead initialize register c to be 1, what value is now left in
# register a?
def part_2() -> None:
register = {"a": 0, "b": 0, "c": 1, "d": 0}
instruction = 0
while instruction != len(lines):
instr = lines[instruction]
if instr[0] == "cpy":
register[instr[2]] = value(instr[1], register)
elif instr[0] == "inc":
register[instr[1]] += 1
elif instr[0] == "dec":
register[instr[1]] -= 1
elif instr[0] == "jnz" and value(instr[1], register) != 0:
instruction += int(instr[2])
continue
instruction += 1
print(f"The value left in register a is: {register['a']}")
if __name__ == "__main__":
part_1()
part_2()

23
src/Year_2016/files/P12.txt Normal file
View File

@ -0,0 +1,23 @@
cpy 1 a
cpy 1 b
cpy 26 d
jnz c 2
jnz 1 5
cpy 7 c
inc d
dec c
jnz c -2
cpy a c
inc a
dec b
jnz b -2
cpy c b
dec d
jnz d -6
cpy 19 c
cpy 14 d
inc a
dec d
jnz d -2
dec c
jnz c -5

421
src/Year_2021/P11.py Normal file
View File

@ -0,0 +1,421 @@
# --- Day 11: Dumbo Octopus ---
# You enter a large cavern full of rare bioluminescent dumbo octopuses! They
# seem to not like the Christmas lights on your submarine, so you turn them off
# for now.
# There are 100 octopuses arranged neatly in a 10 by 10 grid. Each octopus
# slowly gains energy over time and flashes brightly for a moment when its
# energy is full. Although your lights are off, maybe you could navigate
# through the cave without disturbing the octopuses if you could predict when
# the flashes of light will happen.
# Each octopus has an energy level - your submarine can remotely measure the
# energy level of each octopus (your puzzle input). For example:
# 5483143223
# 2745854711
# 5264556173
# 6141336146
# 6357385478
# 4167524645
# 2176841721
# 6882881134
# 4846848554
# 5283751526
# The energy level of each octopus is a value between 0 and 9. Here, the
# top-left octopus has an energy level of 5, the bottom-right one has an energy
# level of 6, and so on.
# You can model the energy levels and flashes of light in steps. During a
# single step, the following occurs:
# First, the energy level of each octopus increases by 1.
# Then, any octopus with an energy level greater than 9 flashes. This
# increases the energy level of all adjacent octopuses by 1, including
# octopuses that are diagonally adjacent. If this causes an octopus to have an
# energy level greater than 9, it also flashes. This process continues as long
# as new octopuses keep having their energy level increased beyond 9. (An
# octopus can only flash at most once per step.)
# Finally, any octopus that flashed during this step has its energy level
# set to 0, as it used all of its energy to flash.
# Adjacent flashes can cause an octopus to flash on a step even if it begins
# that step with very little energy. Consider the middle octopus with 1 energy
# in this situation:
# Before any steps:
# 11111
# 19991
# 19191
# 19991
# 11111
# After step 1:
# 34543
# 40004
# 50005
# 40004
# 34543
# After step 2:
# 45654
# 51115
# 61116
# 51115
# 45654
# An octopus is highlighted when it flashed during the given step.
# Here is how the larger example above progresses:
# Before any steps:
# 5483143223
# 2745854711
# 5264556173
# 6141336146
# 6357385478
# 4167524645
# 2176841721
# 6882881134
# 4846848554
# 5283751526
# After step 1:
# 6594254334
# 3856965822
# 6375667284
# 7252447257
# 7468496589
# 5278635756
# 3287952832
# 7993992245
# 5957959665
# 6394862637
# After step 2:
# 8807476555
# 5089087054
# 8597889608
# 8485769600
# 8700908800
# 6600088989
# 6800005943
# 0000007456
# 9000000876
# 8700006848
# After step 3:
# 0050900866
# 8500800575
# 9900000039
# 9700000041
# 9935080063
# 7712300000
# 7911250009
# 2211130000
# 0421125000
# 0021119000
# After step 4:
# 2263031977
# 0923031697
# 0032221150
# 0041111163
# 0076191174
# 0053411122
# 0042361120
# 5532241122
# 1532247211
# 1132230211
# After step 5:
# 4484144000
# 2044144000
# 2253333493
# 1152333274
# 1187303285
# 1164633233
# 1153472231
# 6643352233
# 2643358322
# 2243341322
# After step 6:
# 5595255111
# 3155255222
# 3364444605
# 2263444496
# 2298414396
# 2275744344
# 2264583342
# 7754463344
# 3754469433
# 3354452433
# After step 7:
# 6707366222
# 4377366333
# 4475555827
# 3496655709
# 3500625609
# 3509955566
# 3486694453
# 8865585555
# 4865580644
# 4465574644
# After step 8:
# 7818477333
# 5488477444
# 5697666949
# 4608766830
# 4734946730
# 4740097688
# 6900007564
# 0000009666
# 8000004755
# 6800007755
# After step 9:
# 9060000644
# 7800000976
# 6900000080
# 5840000082
# 5858000093
# 6962400000
# 8021250009
# 2221130009
# 9111128097
# 7911119976
# After step 10:
# 0481112976
# 0031112009
# 0041112504
# 0081111406
# 0099111306
# 0093511233
# 0442361130
# 5532252350
# 0532250600
# 0032240000
# After step 10, there have been a total of 204 flashes. Fast forwarding, here
# is the same configuration every 10 steps:
# After step 20:
# 3936556452
# 5686556806
# 4496555690
# 4448655580
# 4456865570
# 5680086577
# 7000009896
# 0000000344
# 6000000364
# 4600009543
# After step 30:
# 0643334118
# 4253334611
# 3374333458
# 2225333337
# 2229333338
# 2276733333
# 2754574565
# 5544458511
# 9444447111
# 7944446119
# After step 40:
# 6211111981
# 0421111119
# 0042111115
# 0003111115
# 0003111116
# 0065611111
# 0532351111
# 3322234597
# 2222222976
# 2222222762
# After step 50:
# 9655556447
# 4865556805
# 4486555690
# 4458655580
# 4574865570
# 5700086566
# 6000009887
# 8000000533
# 6800000633
# 5680000538
# After step 60:
# 2533334200
# 2743334640
# 2264333458
# 2225333337
# 2225333338
# 2287833333
# 3854573455
# 1854458611
# 1175447111
# 1115446111
# After step 70:
# 8211111164
# 0421111166
# 0042111114
# 0004211115
# 0000211116
# 0065611111
# 0532351111
# 7322235117
# 5722223475
# 4572222754
# After step 80:
# 1755555697
# 5965555609
# 4486555680
# 4458655580
# 4570865570
# 5700086566
# 7000008666
# 0000000990
# 0000000800
# 0000000000
# After step 90:
# 7433333522
# 2643333522
# 2264333458
# 2226433337
# 2222433338
# 2287833333
# 2854573333
# 4854458333
# 3387779333
# 3333333333
# After step 100:
# 0397666866
# 0749766918
# 0053976933
# 0004297822
# 0004229892
# 0053222877
# 0532222966
# 9322228966
# 7922286866
# 6789998766
# After 100 steps, there have been a total of 1656 flashes.
# Given the starting energy levels of the dumbo octopuses in your cavern,
# simulate 100 steps. How many total flashes are there after 100 steps?
from itertools import count, product
with open("files/P11.txt") as f:
grid = {
(x, y): int(n)
for y, row in enumerate(f.readlines())
for x, n in enumerate(row.strip())
}
def increment(row: int, col: int, _set: set[tuple[int, int]]) -> int:
if (row, col) not in grid or (row, col) in _set:
return 0
grid[row, col] += 1
if grid[row, col] > 9:
grid[row, col] = 0
_set.add((row, col))
return 1 + sum(
increment(row - row_delta, col - col_delta, _set)
for row_delta, col_delta in set(product((-1, 0, 1), repeat=2))
- {(0, 0)}
)
return 0
def part_1() -> None:
flashes = 0
for _ in range(100):
flashed: set[tuple[int, int]] = set()
flashes += sum(increment(r, c, flashed) for r, c in grid)
print(f"There are {flashes} flashes after 100 steps")
# --- Part Two ---
# It seems like the individual flashes aren't bright enough to navigate.
# However, you might have a better option: the flashes seem to be
# synchronizing!
# In the example above, the first time all octopuses flash simultaneously is
# step 195:
# After step 193:
# 5877777777
# 8877777777
# 7777777777
# 7777777777
# 7777777777
# 7777777777
# 7777777777
# 7777777777
# 7777777777
# 7777777777
# After step 194:
# 6988888888
# 9988888888
# 8888888888
# 8888888888
# 8888888888
# 8888888888
# 8888888888
# 8888888888
# 8888888888
# 8888888888
# After step 195:
# 0000000000
# 0000000000
# 0000000000
# 0000000000
# 0000000000
# 0000000000
# 0000000000
# 0000000000
# 0000000000
# 0000000000
# If you can calculate the exact moments when the octopuses will all flash
# simultaneously, you should be able to navigate through the cavern. What is
# the first step during which all octopuses flash?
def part_2() -> None:
for step in count(1):
flashed: set[tuple[int, int]] = set()
if sum(increment(row, col, flashed) for row, col in grid) == len(grid):
print(
f"All octopuses will flash simultaneously after {step} steps"
)
break
if __name__ == "__main__":
part_1()
part_2()