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

src/Year_2016/P12.py

@@ -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()

src/Year_2016/files/P12.txt

@@ -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

src/Year_2021/P11.py

@@ -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()