start day17

Author: spaenleh

Sources/AdventOfCode.swift

@@ -17,6 +17,7 @@ let allChallenges: [any AdventDay] = [
   Day13(),
   Day14(),
   Day15(),
+  Day17(),
 ]
 
 @main

Sources/Day17.swift

@@ -0,0 +1,129 @@
+import Algorithms
+
+struct Registers {
+  var A = 0
+  var B = 0
+  var C = 0
+}
+
+struct Computer {
+  var instructions = [Int]()
+  var registers = Registers()
+  var output = [Int]()
+
+  func getComboOperand(_ operand: Int) -> Int {
+    switch operand {
+    case 0...3: operand
+    case 4: registers.A
+    case 5: registers.B
+    case 6: registers.C
+    case 7: 0  // invalid
+    default: 0
+    }
+  }
+
+  mutating func executeOp(_ ops: Int, _ operand: Int, combo comboOp: Int, pointer: Int) -> Int {
+    var p = pointer
+    func div(_ num: Int, _ denomShift: Int) -> Int {
+      let denom = 1 << denomShift
+      if denom > num || denomShift > num {
+        return 0
+      }
+      if denom == 0 {
+        print("division by zero")
+        print("denomShift", denomShift)
+      }
+      return num / denom
+    }
+
+    switch ops {
+    case 0:
+      // adv
+      let res = div(comboOp, registers.A)
+      print("adv", res)
+      registers.A = res
+      p += 2
+    case 1:
+      // bxl
+      let res = registers.B ^ operand
+      print("bxl", res)
+      registers.B = res
+      p += 2
+    case 2:
+      //bst
+      let res = comboOp % 8
+      print("bst", operand, res)
+      registers.B = res
+      p += 2
+    case 3:
+      // jnz
+      if registers.A != 0 {
+        // jump by the value of the operand
+        p += comboOp
+      } else {
+        // simple increase
+        p += 2
+      }
+    case 4:
+      // bxc
+      registers.B ^= registers.C
+      // do nothing with operand
+      p += 2
+    case 5:
+      // out
+      output.append(comboOp % 8)
+      p += 2
+    case 6:
+      // bdv
+      registers.B = div(comboOp, registers.A)
+      p += 2
+    case 7:
+      // cdv
+      registers.C = div(comboOp, registers.A)
+      p += 2
+    default: break
+    }
+    return p
+  }
+
+  mutating func execute() -> String {
+    var pointer = 0
+
+    while pointer < instructions.count {
+      let op = instructions[pointer]
+      let operand = instructions[pointer + 1]
+
+      pointer = executeOp(op, operand, combo: getComboOperand(operand), pointer: pointer)
+    }
+    // join the output of program with commas
+    return output.map { String($0) }.joined(separator: ",")
+  }
+}
+
+struct Day17: AdventDay {
+  var data: String
+
+  func initialize() -> (instructions: [Int], registers: Registers) {
+    let parts = data.split(separator: "\n\n")
+    let instructions = parts[1].trimmingPrefix("Program: ").integers(separator: ",")
+    var registers = Registers()
+    if let match = parts[0].firstMatch(
+      of: /Register A: (\d+)\nRegister B: (\d+)\nRegister C: (\d+)/)
+    {
+      registers.A = Int(match.1) ?? 0
+      registers.B = Int(match.2) ?? 0
+      registers.C = Int(match.3) ?? 0
+    }
+    return (instructions: instructions, registers: registers)
+  }
+
+  func part1() -> String {
+    let (instructions, registers) = initialize()
+    var computer = Computer(instructions: instructions, registers: registers)
+    return computer.execute()
+  }
+
+  func part2() -> Int {
+    0
+  }
+}

Tests/Day17.swift

@@ -0,0 +1,71 @@
+import Testing
+
+@testable import aoc
+
+@Suite("Day17")
+struct Day17Tests {
+  let testData = """
+    Register A: 729
+    Register B: 0
+    Register C: 0
+
+    Program: 0,1,5,4,3,0
+    """
+
+  @Test("parsing")
+  func testParsing() async throws {
+    let c = Day17(data: testData).initialize()
+    let computer = Computer(instructions: c.instructions, registers: c.registers)
+
+    #expect(computer.registers.A == 729)
+    #expect(computer.registers.B == 0)
+    #expect(computer.registers.C == 0)
+    #expect(computer.instructions == [0, 1, 5, 4, 3, 0])
+
+  }
+
+  @Test("Common operations")
+  func testOperations() async throws {
+    var c1 = Computer(
+      instructions: [2, 6], registers: Registers(A: 0, B: 0, C: 9)
+    )
+    #expect(c1.execute() == "")
+    #expect(
+      c1.registers.B == 1)
+
+    var c2 = Computer(
+      instructions: [5, 0, 5, 1, 5, 4], registers: Registers(A: 10, B: 0, C: 0)
+    )
+    #expect(c2.execute() == "0,1,2")
+
+    var c3 = Computer(
+      instructions: [0, 1, 5, 4, 3, 0], registers: Registers(A: 2024, B: 0, C: 0)
+    )
+    #expect(c3.execute() == "4,2,5,6,7,7,7,7,3,1,0")
+    #expect(c3.registers.A == 0)
+
+    var c4 = Computer(
+      instructions: [1, 7], registers: Registers(A: 0, B: 29, C: 0)
+    )
+    #expect(c4.execute() == "")
+    #expect(c4.registers.B == 26)
+
+    var c5 = Computer(
+      instructions: [4, 0], registers: Registers(A: 0, B: 2024, C: 43690)
+    )
+    #expect(c5.execute() == "")
+    #expect(c5.registers.B == 44354)
+  }
+
+  @Test("part1")
+  func testPart1() async throws {
+    let challenge = Day17(data: testData)
+    #expect(challenge.part1() == "4,6,3,5,6,3,5,2,1,0")
+  }
+
+  @Test("part2")
+  func testPart2() async throws {
+    let challenge = Day17(data: testData)
+    #expect(challenge.part2() == 0)
+  }
+}