Icky day 21.

Abstract elfcode handling into its own file.

answers/21.txt

@@ -0,0 +1,2 @@
+3345459
+5857354

data/21.txt

@@ -0,0 +1,32 @@
+#ip 2
+seti 123 0 1            # r1 = 123        <-\
+bani 1 456 1            # r1 = r1 and 456   | F
+eqri 1 72 1             # r1 = r1 == 72  ---+
+addr 1 2 2              # jmp r1            | T
+seti 0 0 2              # jmp @1            |
+seti 0 9 1              # r1 = 0          <-/
+bori 1 65536 4          # r4 = r1 or 65536  <------------------\
+seti 16298264 8 1       # r1 = 16298264                        |
+bani 4 255 5            # r5 = r4 and 255    <------\          |
+addr 1 5 1              # r1 = r1 + r5              |          |
+bani 1 16777215 1       # r1 = r1 and 16777215      |          |
+muli 1 65899 1          # r1 = r1 * 65899           |          |
+bani 1 16777215 1       # r1 = r1 and 16777215      |          |
+gtir 256 4 5            # r5 = 256 > r4  -----------------\    |
+addr 5 2 2              # jmp @r5                   |     |    |
+addi 2 1 2              # jmp 1                     |     |    |
+seti 27 1 2             # jmp @28                   |  F  |    |
+seti 0 3 5              # r5 = 0          <---------------+    |
+addi 5 1 3              # r3 = r5 + 1               |     | T  |
+muli 3 256 3            # r3 = r3 * 256             |     |    |
+gtrr 3 4 3              # r3 = r3 > r4              |     |    |
+addr 3 2 2              # jmp @r3          ----\    |     |    |
+addi 2 1 2              # jmp 1                |    |     |    |
+seti 25 4 2             # jmp @26            F |    |     |    |
+addi 5 1 5              # r5 = r5 + 1      <---+    |     |    |
+seti 17 1 2             # jmp @18            T |    |     |    |
+setr 5 3 4              # r4 = r5          <---/    |     |    |
+seti 7 7 2              # jmp @8        ------------/     |    | F
+eqrr 1 0 5              # r5 = r1 == r0                   \----+
+addr 5 2 2              # jmp @r5                              | T
+seti 5 3 2              # jmp @6                               v 

day16.nim

@@ -1,29 +1,4 @@
-import sequtils, strutils
-
-let ops = [
-    proc(regs: seq[int], a,b: int): int = regs[a] + b,
-    proc(regs: seq[int], a,b: int): int = regs[a] + regs[b],
-
-    proc(regs: seq[int], a,b: int): int = regs[a] * b,
-    proc(regs: seq[int], a,b: int): int = regs[a] * regs[b],
-
-    proc(regs: seq[int], a,b: int): int = regs[a] and b,
-    proc(regs: seq[int], a,b: int): int = regs[a] and regs[b],
-
-    proc(regs: seq[int], a,b: int): int = regs[a] or b,
-    proc(regs: seq[int], a,b: int): int = regs[a] or regs[b],
-
-    proc(regs: seq[int], a,b: int): int = a,
-    proc(regs: seq[int], a,b: int): int = regs[a],
-
-    proc(regs: seq[int], a,b: int): int = cast[int](a > regs[b]),
-    proc(regs: seq[int], a,b: int): int = cast[int](regs[a] > b),
-    proc(regs: seq[int], a,b: int): int = cast[int](regs[a] > regs[b]),
-
-    proc(regs: seq[int], a,b: int): int = cast[int](a == regs[b]),
-    proc(regs: seq[int], a,b: int): int = cast[int](regs[a] == b),
-    proc(regs: seq[int], a,b: int): int = cast[int](regs[a] == regs[b]),
-]
+import elfcode, sequtils, strutils, tables
 
 func toInstr(line: string): seq[int] = line.strip.split(" ").map(parseInt)
 func toRegisterSample(line: string): seq[int] = line.substr(9, line.len - 2).split(", ").map(parseInt)
@@ -31,6 +6,8 @@ func toRegisterSample(line: string): seq[int] = line.substr(9, line.len - 2).spl
 proc execute(regs: var seq[int], instr: seq[int], opcodes: array[16, proc(regs: seq[int], a,b: int): int]) =
     regs[instr[3]] = opcodes[instr[0]](regs, instr[1], instr[2])
 
+let opsSeq = toSeq(ops.values)
+
 var
     before, instr, after: seq[int]
     opPossibilities: array[16, array[16, bool]]
@@ -49,7 +26,7 @@ for line in readFile("data/16.txt").splitlines:
     elif step == 2:
         after = line.toRegisterSample
         var count = 0
-        for i, op in ops:
+        for i, op in opsSeq:
             var actual: seq[int]
             actual.shallowCopy(before)
             actual[instr[3]] = op(before, instr[1], instr[2])
@@ -71,7 +48,7 @@ for line in readFile("data/16.txt").splitlines:
                 if matrix.count((false, false)) == 1:
                     let index = matrix.find((false, false))
                     found[index] = true
-                    opMappings[opcode] = ops[index]
+                    opMappings[opcode] = opsSeq[index]
         step = -1
     
     if step == -1 and line.len > 5:

day19.nim

@@ -1,44 +1,8 @@
-import math, sequtils, strutils, tables
+import elfcode, math, sequtils, strutils, tables
 
-type instr = tuple[op: string, a,b,c: int]
+var instructionSet = readInstructions(readFile("data/19.txt").strip.splitlines)
 
-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 =
+proc findTarget(part2: bool = false): 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
@@ -46,12 +10,9 @@ proc findTarget(part2: bool): int =
     # 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:
+        let i = instructionSet.ip(registers)
+        instructionSet.step(registers)
+        if instructionSet.ip(registers) < i:
             return registers.max
 
 proc factors(n: int): seq[int] =
@@ -60,5 +21,5 @@ proc factors(n: int): seq[int] =
             result.add(x)
             result.add(n div x)
    
-echo findTarget(false).factors.sum
+echo findTarget().factors.sum
 echo findTarget(true).factors.sum

day21.nim

@@ -0,0 +1,27 @@
+import elfcode, math, sequtils, strutils, sets
+
+var
+    instructionSet = readInstructions(readFile("data/21.txt").strip.splitlines)
+    seen = initSet[int](15000.nextPowerOfTwo)
+    last = 0
+
+iterator emulate(): int =
+    var r1, r4 = 0
+    
+    while true:
+        r4 = r1 or 65536
+        r1 = instructionSet.instructions[7].a
+        
+        while r4 > 0:
+            r1 = (((r1 + (r4 and 255)) and instructionSet.instructions[10].b) *
+                    instructionSet.instructions[11].b) and instructionSet.instructions[12].b
+            r4 = r4 div 256
+        yield r1
+
+for i in emulate():
+    if seen.len == 0:
+        echo i
+    if seen.containsOrIncl(i):
+        echo last
+        break
+    last = i

elfcode.nim

@@ -0,0 +1,49 @@
+import strutils, tables
+
+type
+    instr* = tuple[op: string, a,b,c: int]
+    instructionSet* = tuple[ipr: int, instructions: seq[instr]]
+
+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
+
+proc readInstructions*(input: seq[string]): instructionSet =
+    for line in input:
+        var parts = line.split(' ')
+        if parts[0] == "#ip":
+            result.ipr = parts[1].parseInt
+        else:
+            result.instructions.add((parts[0], parts[1].parseInt, parts[2].parseInt, parts[3].parseInt))
+
+proc ip*(instructionSet: instructionSet, registers: seq[int]): int {.inline.} =
+    registers[instructionSet.ipr]
+
+proc currentInstr*(instructionSet: instructionSet, registers: seq[int]): instr {.inline.} =
+    instructionSet.instructions[instructionSet.ip(registers)]
+
+proc step*(instructionSet: instructionSet, registers: var seq[int]) {.inline.} =
+    let instr = instructionSet.currentInstr(registers)
+    registers[instr.c] = ops[instr.op](registers, instr.a, instr.b)
+    registers[instructionSet.ipr].inc