Day 7 part 2

Author: timocp

src/adventofcode2024.gleam

@@ -48,6 +48,7 @@ fn run(d: Int) -> Nil {
       4 -> day4.part2(input) |> int.to_string
       5 -> day5.part2(input) |> int.to_string
       6 -> day6.part2(input) |> int.to_string
+      7 -> day7.part2(input) |> int.to_string
       _ -> "(not implemented)"
     }
   })

src/day7.gleam

@@ -1,15 +1,24 @@
 import gleam/int
-import gleam/io
 import gleam/list
 import gleam/pair
 import gleam/result
 import gleam/string
 import parse
 
 pub fn part1(input: String) -> Int {
+  solve(input, [Add, Multiply])
+}
+
+pub fn part2(input: String) -> Int {
+  solve(input, [Add, Multiply, Concatenate])
+}
+
+fn solve(input: String, operations: List(Op)) -> Int {
+  let valid = fn(e: #(Int, List(Op))) { is_valid(e, operations) }
+
   input
   |> parse_input
-  |> list.filter(is_valid)
+  |> list.filter(valid)
   |> list.map(pair.first)
   |> int.sum
 }
@@ -18,6 +27,7 @@ pub type Op {
   Number(Int)
   Add
   Multiply
+  Concatenate
 }
 
 fn evaluate(ops: List(Op)) -> Int {
@@ -28,60 +38,38 @@ fn forward_evaluate(ops: List(Op)) -> Int {
   case ops {
     [Number(a), Add, ..rest] -> a + forward_evaluate(rest)
     [Number(a), Multiply, ..rest] -> a * forward_evaluate(rest)
+    [Number(a), Concatenate, ..rest] -> {
+      a
+      |> int.digits(10)
+      |> result.unwrap([])
+      |> list.fold(forward_evaluate(rest), fn(acc, digit) { acc * 10 + digit })
+    }
     [Number(a)] -> a
     _ -> panic as { "Invalid expression" }
   }
 }
 
-fn is_valid(equation: #(Int, List(Op))) -> Bool {
-  let _debug_equation = fn(ops: List(Op)) {
-    io.println_error("")
-    io.println_error(
-      "checking if "
-      <> int.to_string(equation.0)
-      <> " == "
-      <> debug_ops(ops)
-      <> case evaluate(ops) == equation.0 {
-        True -> " (yes!)"
-        False -> " (no, " <> int.to_string(evaluate(ops)) <> ")"
-      },
-    )
-    ops
-  }
-
-  possible_ops(equation.1)
-  // |> list.map(debug_equation)
+fn is_valid(equation: #(Int, List(Op)), operations: List(Op)) -> Bool {
+  possible_ops(equation.1, operations)
   |> list.find(fn(ops) { evaluate(ops) == equation.0 })
   |> result.is_ok
 }
 
-fn possible_ops(ops: List(Op)) -> List(List(Op)) {
+fn possible_ops(ops: List(Op), operations: List(Op)) -> List(List(Op)) {
   case ops {
     [Number(a)] -> [[Number(a)]]
     [Number(a), ..rest] -> {
-      possible_ops(rest)
+      possible_ops(rest, operations)
       |> list.flat_map(fn(restops) {
-        [[Number(a), Add, ..restops], [Number(a), Multiply, ..restops]]
+        operations
+        |> list.map(fn(new_op) { [Number(a), new_op, ..restops] })
       })
     }
     [] -> []
-    [Add, ..] | [Multiply, ..] ->
-      panic as "possible_ops() requires numeric operands only"
+    _ -> panic as "possible_ops() requires numeric operands only"
   }
 }
 
-fn debug_ops(ops: List(Op)) -> String {
-  ops
-  |> list.map(fn(op) {
-    case op {
-      Number(a) -> int.to_string(a)
-      Add -> "+"
-      Multiply -> "*"
-    }
-  })
-  |> string.join(" ")
-}
-
 fn parse_input(input: String) -> List(#(Int, List(Op))) {
   input
   |> parse.lines

test/day7_test.gleam

@@ -21,3 +21,7 @@ const example1 = "190: 10 19
 pub fn part1_test() {
   day7.part1(example1) |> should.equal(3749)
 }
+
+pub fn part2_test() {
+  day7.part2(example1) |> should.equal(11_387)
+}