Day 17

Author: drewolson

src/aoc/runner/year2024.gleam

@@ -14,6 +14,7 @@ import aoc/year2024/day13
 import aoc/year2024/day14
 import aoc/year2024/day15
 import aoc/year2024/day16
+import aoc/year2024/day17
 import gleam/string
 
 pub fn run(input: String, day: Int, part: Int) {
@@ -50,6 +51,8 @@ pub fn run(input: String, day: Int, part: Int) {
     15, 2 -> input |> day15.part2 |> string.inspect
     16, 1 -> input |> day16.part1 |> string.inspect
     16, 2 -> input |> day16.part2 |> string.inspect
+    17, 1 -> input |> day17.part1
+    17, 2 -> input |> day17.part2 |> string.inspect
     _, _ ->
       "Unknown day and part for 2024: day "
       <> string.inspect(day)

src/aoc/year2024/day16.gleam

@@ -82,8 +82,7 @@ fn neighbors(
     ]
   }
 
-  candidates
-  |> list.filter(fn(node) {
+  list.filter(candidates, fn(node) {
     !set.contains(seen, #(node.1, node.2))
     && case dict.get(grid, node.1) {
       Ok(v) -> v != "#"

src/aoc/year2024/day17.gleam

@@ -0,0 +1,157 @@
+import aoc/util/parser.{type Parser}
+import gleam/dict.{type Dict}
+import gleam/float
+import gleam/int
+import gleam/list
+import gleam/result
+import gleam/string
+import gleam/yielder.{type Yielder, Next}
+import party
+
+type Vm {
+  Vm(a: Int, b: Int, c: Int, pos: Int, prog: Dict(Int, Int))
+}
+
+fn reg_p(name: String) -> Parser(Int) {
+  use <- party.drop(party.string("Register " <> name <> ": "))
+  use v <- party.do(parser.int())
+  use <- party.drop(party.string("\n"))
+  party.return(v)
+}
+
+fn vm_p() -> Parser(Vm) {
+  use a <- party.do(reg_p("A"))
+  use b <- party.do(reg_p("B"))
+  use c <- party.do(reg_p("C"))
+  use <- party.drop(party.string("\nProgram: "))
+  use ops <- party.map(party.sep1(parser.int(), party.string(",")))
+  let prog = ops |> list.index_map(fn(o, i) { #(i, o) }) |> dict.from_list
+  Vm(a:, b:, c:, pos: 0, prog:)
+}
+
+fn combo(vm: Vm, i: Int) -> Int {
+  case i {
+    4 -> vm.a
+    5 -> vm.b
+    6 -> vm.c
+    i -> i
+  }
+}
+
+fn pow(a: Int, b: Int) -> Int {
+  a
+  |> int.power(int.to_float(b))
+  |> result.unwrap(0.0)
+  |> float.floor
+  |> float.round
+}
+
+fn opcode(vm: Vm) -> Result(Int, Nil) {
+  dict.get(vm.prog, vm.pos)
+}
+
+fn operand(vm: Vm) -> Result(Int, Nil) {
+  dict.get(vm.prog, vm.pos + 1)
+}
+
+fn run(vm: Vm, output: List(Int)) -> List(Int) {
+  let res = {
+    use op <- result.try(opcode(vm))
+    case op {
+      0 -> {
+        use arg <- result.map(operand(vm))
+        let res = vm.a / pow(2, combo(vm, arg))
+        #(Vm(..vm, a: res, pos: vm.pos + 2), output)
+      }
+      1 -> {
+        use arg <- result.map(operand(vm))
+        let res = int.bitwise_exclusive_or(vm.b, arg)
+        #(Vm(..vm, b: res, pos: vm.pos + 2), output)
+      }
+      2 -> {
+        use arg <- result.map(operand(vm))
+        let res = arg |> combo(vm, _) |> int.modulo(8) |> result.unwrap(0)
+        #(Vm(..vm, b: res, pos: vm.pos + 2), output)
+      }
+      3 -> {
+        case vm.a == 0 {
+          True -> Ok(#(Vm(..vm, pos: vm.pos + 2), output))
+          False -> {
+            use arg <- result.map(operand(vm))
+            #(Vm(..vm, pos: arg), output)
+          }
+        }
+      }
+      4 -> {
+        let res = int.bitwise_exclusive_or(vm.b, vm.c)
+        Ok(#(Vm(..vm, b: res, pos: vm.pos + 2), output))
+      }
+      5 -> {
+        use arg <- result.map(operand(vm))
+        let res = arg |> combo(vm, _) |> int.modulo(8) |> result.unwrap(0)
+        #(Vm(..vm, pos: vm.pos + 2), [res, ..output])
+      }
+      6 -> {
+        use arg <- result.map(operand(vm))
+        let res = vm.a / pow(2, combo(vm, arg))
+        #(Vm(..vm, b: res, pos: vm.pos + 2), output)
+      }
+      _ -> {
+        use arg <- result.map(operand(vm))
+        let res = vm.a / pow(2, combo(vm, arg))
+        #(Vm(..vm, c: res, pos: vm.pos + 2), output)
+      }
+    }
+  }
+
+  case res {
+    Error(_) -> list.reverse(output)
+    Ok(#(vm, output)) -> run(vm, output)
+  }
+}
+
+fn ints(start: Int) -> Yielder(Int) {
+  yielder.unfold(start, fn(n) { Next(n, n + 1) })
+}
+
+fn search(vm: Vm, n: Int, d: Int, goal: List(Int)) -> Int {
+  case d > list.length(goal) {
+    True -> n / 8
+    False -> {
+      let cur_goal = list.take(goal, d)
+      let assert Ok(next) =
+        n
+        |> ints
+        |> yielder.find(fn(i) {
+          let actual =
+            run(Vm(..vm, a: i), [])
+            |> list.reverse
+            |> list.take(d)
+
+          actual == cur_goal
+        })
+
+      search(vm, next * 8, d + 1, goal)
+    }
+  }
+}
+
+pub fn part1(input: String) -> String {
+  input
+  |> parser.go(vm_p())
+  |> run([])
+  |> list.map(int.to_string)
+  |> string.join(",")
+}
+
+pub fn part2(input: String) -> Int {
+  let vm = parser.go(input, vm_p())
+
+  let goal =
+    vm.prog
+    |> dict.to_list
+    |> list.sort(fn(a, b) { int.compare(b.0, a.0) })
+    |> list.map(fn(p) { p.1 })
+
+  search(vm, 0, 1, goal)
+}

test/aoc/year2024/day17_test.gleam

@@ -0,0 +1,50 @@
+import aoc/year2024/day17
+import glacier/should
+
+const input = "Register A: 729
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0
+"
+
+const input1 = "Register A: 10
+Register B: 0
+Register C: 0
+
+Program: 5,0,5,1,5,4
+"
+
+const input2 = "Register A: 2024
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0
+"
+
+const input3 = "Register A: 2024
+Register B: 0
+Register C: 0
+
+Program: 0,3,5,4,3,0
+"
+
+pub fn part1_test() {
+  input
+  |> day17.part1
+  |> should.equal("4,6,3,5,6,3,5,2,1,0")
+
+  input1
+  |> day17.part1
+  |> should.equal("0,1,2")
+
+  input2
+  |> day17.part1
+  |> should.equal("4,2,5,6,7,7,7,7,3,1,0")
+}
+
+pub fn part2_test() {
+  input3
+  |> day17.part2
+  |> should.equal(117_440)
+}