Day 19

answers/19.txt

@@ -0,0 +1,2 @@
+1536
+17540352

data/19.txt

@@ -0,0 +1,37 @@
+#ip 2
+addi 2 16 2 #  0: jmp 16
+seti 1 0 1  #  1: r[1] = 1
+seti 1 3 3  #  2: r[3] = 1
+mulr 1 3 5  #  3: r[5] = r[1] * r[3]
+eqrr 5 4 5  #  4: r[5] = r[5] == r[4]?
+addr 5 2 2  #  5: jmp r[5] (either to 6 or 7)
+addi 2 1 2  #  6: jmp 2 (to 9)
+addr 1 0 0  #  7: r[0] += r[1]
+addi 3 1 3  #  8: r[3]++
+gtrr 3 4 5  #  9: r[5] = r[3] > r[4]
+addr 2 5 2  # 10: jmp r[5] (either to 11 or 12)
+seti 2 6 2  # 11: jmp @2
+addi 1 1 1  # 12: r[1]++
+gtrr 1 4 5  # 13: r[5] = r[1] > r[4]
+addr 5 2 2  # 14: jmp r[5] (either to 15 or 16)
+seti 1 1 2  # 15: jmp @1
+mulr 2 2 2  # 16: r[2] = 16 * 16 == EXIT
+addi 4 2 4  # 17: r[4] += 2
+mulr 4 4 4  # 18: r[4] = r[4] * r[4]
+mulr 2 4 4  # 19: r[4] = r[2] * r[4] = 19 * r[4]
+muli 4 11 4 # 20: r[4] = r[4] * 11
+addi 5 6 5  # 21: r[5] += 6
+mulr 5 2 5  # 22: r[5] = r[2] * r[5] = 22 * r[5]
+addi 5 19 5 # 23: r[5] += 19
+addr 4 5 4  # 24: r[4] += r[5]
+addr 2 0 2  # 25: jmp r[0]
+seti 0 7 2  # 26: jmp @0
+setr 2 6 5  # 27: r[5] = 27
+mulr 5 2 5  # 28: r[5] = r[5] * r[2] = 27 * 28 = 756
+addr 2 5 5  # 29: r[5] = r[5] + r[2] = 756 + 29 = 785
+mulr 2 5 5  # 30: r[5] = r[5] * r[2] = 785 * 30 = 23550
+muli 5 14 5 # 31: r[5] *= 14 = 329700
+mulr 5 2 5  # 32: r[5] = r[5] * r[2] = 10550400
+addr 4 5 4  # 33: r[4] = r[4] + r[5] = r[4] + 10550400
+seti 0 7 0  # 34: r[0] = 0
+seti 0 3 2  # 35: jmp @0

day19.nim

@@ -0,0 +1,64 @@
+import math, sequtils, strutils, tables
+
+type instr = tuple[op: string, a,b,c: int]
+
+let ops = {
+    "addi": proc(regs: seq[int], a,b: int): int = regs[a] + b,
+    "addr": proc(regs: seq[int], a,b: int): int = regs[a] + regs[b],
+
+    "muli": proc(regs: seq[int], a,b: int): int = regs[a] * b,
+    "mulr": proc(regs: seq[int], a,b: int): int = regs[a] * regs[b],
+
+    "bani": proc(regs: seq[int], a,b: int): int = regs[a] and b,
+    "banr": proc(regs: seq[int], a,b: int): int = regs[a] and regs[b],
+
+    "bori": proc(regs: seq[int], a,b: int): int = regs[a] or b,
+    "borr": proc(regs: seq[int], a,b: int): int = regs[a] or regs[b],
+
+    "seti": proc(regs: seq[int], a,b: int): int = a,
+    "setr": proc(regs: seq[int], a,b: int): int = regs[a],
+
+    "gtir": proc(regs: seq[int], a,b: int): int = cast[int](a > regs[b]),
+    "gtri": proc(regs: seq[int], a,b: int): int = cast[int](regs[a] > b),
+    "gtrr": proc(regs: seq[int], a,b: int): int = cast[int](regs[a] > regs[b]),
+
+    "eqir": proc(regs: seq[int], a,b: int): int = cast[int](a == regs[b]),
+    "eqri": proc(regs: seq[int], a,b: int): int = cast[int](regs[a] == b),
+    "eqrr": proc(regs: seq[int], a,b: int): int = cast[int](regs[a] == regs[b]),
+}.toTable
+
+var
+    instructions: seq[instr]
+    ip: int
+
+for line in readFile("data/19.txt").strip.splitlines:
+    var parts = line.split(' ')
+    if parts[0] == "#ip":
+        ip = parts[1].parseInt
+    else:
+        instructions.add((parts[0], parts[1].parseInt, parts[2].parseInt, parts[3].parseInt))
+
+proc findTarget(part2: bool): int =
+    # The instructions calculate the sum of all factors of a target number. The
+    # target is initialised first, and then execution jumps back to near the
+    # start of the program to perform the calculation. To find the target
+    # number, we evaluate until a backwards jump and then just take the largest
+    # register. (Yuck.)
+    var registers = @[if part2: 1 else: 0, 0, 0, 0, 0, 0]
+    while true:
+        let
+            i = registers[ip]
+            instr = instructions[i]
+        registers[instr.c] = ops[instr.op](registers, instr.a, instr.b)
+        registers[ip].inc
+        if registers[ip] < i:
+            return registers.max
+
+proc factors(n: int): seq[int] =
+    for x in 1 .. int(sqrt(float(n))):
+        if n mod x == 0:
+            result.add(x)
+            result.add(n div x)
+   
+echo findTarget(false).factors.sum
+echo findTarget(true).factors.sum