Day 17 Part 1

Author: monpie3

Day_17/README.md

@@ -0,0 +1,68 @@
+## \--- Day 17: Chronospatial Computer ---
+
+The Historians push the button on their strange device, but this time, you all just feel like you're [falling](https://adventofcode.com/2018/day/6).
+
+"Situation critical", the device announces in a familiar voice. "Bootstrapping process failed. Initializing debugger...."
+
+The small handheld device suddenly unfolds into an entire computer! The Historians look around nervously before one of them tosses it to you.
+
+This seems to be a 3-bit computer: its program is a list of 3-bit numbers (0 through 7), like `0,1,2,3`. The computer also has three _registers_ named `A`, `B`, and `C`, but these registers aren't limited to 3 bits and can instead hold any integer.
+
+The computer knows _eight instructions_, each identified by a 3-bit number (called the instruction's _opcode_). Each instruction also reads the 3-bit number after it as an input; this is called its _operand_.
+
+A number called the _instruction pointer_ identifies the position in the program from which the next opcode will be read; it starts at `0`, pointing at the first 3-bit number in the program. Except for jump instructions, the instruction pointer increases by `2` after each instruction is processed (to move past the instruction's opcode and its operand). If the computer tries to read an opcode past the end of the program, it instead _halts_.
+
+So, the program `0,1,2,3` would run the instruction whose opcode is `0` and pass it the operand `1`, then run the instruction having opcode `2` and pass it the operand `3`, then halt.
+
+There are two types of operands; each instruction specifies the type of its operand. The value of a _literal operand_ is the operand itself. For example, the value of the literal operand `7` is the number `7`. The value of a _combo operand_ can be found as follows:
+
+- Combo operands `0` through `3` represent literal values `0` through `3`.
+- Combo operand `4` represents the value of register `A`.
+- Combo operand `5` represents the value of register `B`.
+- Combo operand `6` represents the value of register `C`.
+- Combo operand `7` is reserved and will not appear in valid programs.
+
+The eight instructions are as follows:
+
+The `adv` instruction (opcode `0`) performs _division_. The numerator is the value in the `A` register. The denominator is found by raising 2 to the power of the instruction's _combo_ operand. (So, an operand of `2` would divide `A` by `4` (`2^2`); an operand of `5` would divide `A` by `2^B`.) The result of the division operation is _truncated_ to an integer and then written to the `A` register.
+
+The `bxl` instruction (opcode `1`) calculates the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of register `B` and the instruction's _literal_ operand, then stores the result in register `B`.
+
+The `bst` instruction (opcode `2`) calculates the value of its _combo_ operand [modulo](https://en.wikipedia.org/wiki/Modulo) 8 (thereby keeping only its lowest 3 bits), then writes that value to the `B` register.
+
+The `jnz` instruction (opcode `3`) does _nothing_ if the `A` register is `0`. However, if the `A` register is _not zero_, it _jumps_ by setting the instruction pointer to the value of its _literal_ operand; if this instruction jumps, the instruction pointer is _not_ increased by `2` after this instruction.
+
+The `bxc` instruction (opcode `4`) calculates the _bitwise XOR_ of register `B` and register `C`, then stores the result in register `B`. (For legacy reasons, this instruction reads an operand but _ignores_ it.)
+
+The `out` instruction (opcode `5`) calculates the value of its _combo_ operand modulo 8, then _outputs_ that value. (If a program outputs multiple values, they are separated by commas.)
+
+The `bdv` instruction (opcode `6`) works exactly like the `adv` instruction except that the result is stored in the `B` register_. (The numerator is still read from the `A` register.)
+
+The `cdv` instruction (opcode `7`) works exactly like the `adv` instruction except that the result is stored in the `C` register_. (The numerator is still read from the `A` register.)
+
+Here are some examples of instruction operation:
+
+- If register `C` contains `9`, the program `2,6` would set register `B` to `1`.
+- If register `A` contains `10`, the program `5,0,5,1,5,4` would output `0,1,2`.
+- If register `A` contains `2024`, the program `0,1,5,4,3,0` would output `4,2,5,6,7,7,7,7,3,1,0` and leave `0` in register `A`.
+- If register `B` contains `29`, the program `1,7` would set register `B` to `26`.
+- If register `B` contains `2024` and register `C` contains `43690`, the program `4,0` would set register `B` to `44354`.
+
+The Historians' strange device has finished initializing its debugger and is displaying some _information about the program it is trying to run_ (your puzzle input). For example:
+
+```
+Register A: 729
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0
+```
+
+Your first task is to _determine what the program is trying to output_. To do this, initialize the registers to the given values, then run the given program, collecting any output produced by `out` instructions. (Always join the values produced by `out` instructions with commas.) After the above program halts, its final output will be `4,6,3,5,6,3,5,2,1,0`.
+
+Using the information provided by the debugger, initialize the registers to the given values, then run the program. Once it halts, _what do you get if you use commas to join the values it output into a single string?_
+
+
+Your puzzle answer was `[REDACTED]`.
+
+The first half of this puzzle is complete! It provides one gold star: ⭐

Day_17/example_17a.txt

@@ -0,0 +1,5 @@
+Register A: 729
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0

Day_17/example_17b.txt

@@ -0,0 +1,5 @@
+Register A: 10
+Register B: 0
+Register C: 9
+
+Program: 2,6

Day_17/example_17c.txt

@@ -0,0 +1,5 @@
+Register A: 10
+Register B: 0
+Register C: 0
+
+Program: 5,0,5,1,5,4

Day_17/example_17d.txt

@@ -0,0 +1,5 @@
+Register A: 2024
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0

Day_17/example_17e.txt

@@ -0,0 +1,5 @@
+Register A: 2024
+Register B: 29
+Register C: 0
+
+Program: 1,7

Day_17/example_17f.txt

@@ -0,0 +1,5 @@
+Register A: 2024
+Register B: 2024
+Register C: 43690
+
+Program: 4,0

Day_17/task_17a.py

@@ -0,0 +1,63 @@
+import math
+
+
+def load_data(filename):
+    with open(filename, "r") as file:
+        registers, program = file.read().split("\n\n")
+
+    registers = [int(register.split(": ")[1]) for register in registers.split("\n")]
+    program = program.strip().split(": ")[1].split(",")
+    return registers, list(map(int, program))
+
+
+def run_program(program, registers):
+
+    def combo(operand):
+        if operand <= 3:
+            return operand
+        if operand == 4:
+            return a
+        if operand == 5:
+            return b
+        if operand == 6:
+            return c
+        raise ValueError(f"Invalid operand: {operand}")
+
+    a, b, c = registers
+
+    output = []
+    pointer = 0
+    while pointer < len(program) - 1:
+        jumped = False
+        instruction = program[pointer]
+        operand = program[pointer + 1]
+
+        if instruction == 0:    # adv
+            a = math.floor(a / pow(2, combo(operand)))
+        elif instruction == 1:  # bxl
+            b = b ^ operand
+        elif instruction == 2:  # bst
+            b = combo(operand) % 8
+        elif instruction == 3:  # jnz
+            if a != 0:
+                pointer = operand
+                jumped = True
+        elif instruction == 4:  # bxc
+            b = b ^ c
+        elif instruction == 5:  # out
+            output.append(combo(operand) % 8)
+        elif instruction == 6:  # bdv
+            b = math.floor(a / pow(2, combo(operand)))
+        elif instruction == 7:  # cdv
+            c = math.floor(a / pow(2, combo(operand)))
+
+        if not jumped:
+            pointer += 2
+
+    return output, a, b, c
+
+
+if __name__ == "__main__":
+    registers, program = load_data("Day_17/puzzle_input.txt")
+    output, a, b, c = run_program(program, registers)
+    print(",".join(map(str, output)))

Day_17/test_task_17a.py

@@ -0,0 +1,30 @@
+from task_17a import load_data, run_program
+import pytest
+
+
+@pytest.mark.parametrize(
+    "file_path, exp_a, exp_b, exp_c, exp_output",
+    [
+        ("Day_17/example_17a.txt", "X", "X", "X", "4,6,3,5,6,3,5,2,1,0"),
+        ("Day_17/example_17b.txt", "X", 1, "X", "X"),
+        ("Day_17/example_17c.txt", "X", "X", "X", "0,1,2"),
+        ("Day_17/example_17d.txt", 0, "X", "X", "4,2,5,6,7,7,7,7,3,1,0"),
+        ("Day_17/example_17e.txt", "X", 26, "X", "X"),
+        ("Day_17/example_17f.txt", "X", 44354, "X", "X"),
+    ],
+)
+def test_run_programe(file_path, exp_a, exp_b, exp_c, exp_output):
+    registers, program = load_data(file_path)
+    output, a, b, c = run_program(program, registers)
+
+    if exp_a != "X":
+        assert a == exp_a
+
+    if exp_b != "X":
+        assert b == exp_b
+
+    if exp_c != "X":
+        assert c == exp_c
+
+    if exp_output != "X":
+        assert ",".join(map(str, output)) == exp_output