Day 7 part 1

Author: timocp

src/adventofcode2024.gleam

@@ -13,6 +13,7 @@ import day3
 import day4
 import day5
 import day6
+import day7
 
 pub fn main() {
   case argv.load().arguments {
@@ -21,7 +22,7 @@ pub fn main() {
         Ok(d) -> run(d)
         Error(_) -> io.println("Invalid day: " <> arg)
       }
-    _ -> list.range(1, 6) |> list.each(fn(d) { run(d) })
+    _ -> list.range(1, 7) |> list.each(fn(d) { run(d) })
   }
 }
 
@@ -35,6 +36,7 @@ fn run(d: Int) -> Nil {
       4 -> day4.part1(input) |> int.to_string
       5 -> day5.part1(input) |> int.to_string
       6 -> day6.part1(input) |> int.to_string
+      7 -> day7.part1(input) |> int.to_string
       _ -> "(not implemented)"
     }
   })

src/day7.gleam

@@ -0,0 +1,100 @@
+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 {
+  input
+  |> parse_input
+  |> list.filter(is_valid)
+  |> list.map(pair.first)
+  |> int.sum
+}
+
+pub type Op {
+  Number(Int)
+  Add
+  Multiply
+}
+
+fn evaluate(ops: List(Op)) -> Int {
+  ops |> list.reverse |> forward_evaluate
+}
+
+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)] -> 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)
+  |> list.find(fn(ops) { evaluate(ops) == equation.0 })
+  |> result.is_ok
+}
+
+fn possible_ops(ops: List(Op)) -> List(List(Op)) {
+  case ops {
+    [Number(a)] -> [[Number(a)]]
+    [Number(a), ..rest] -> {
+      possible_ops(rest)
+      |> list.flat_map(fn(restops) {
+        [[Number(a), Add, ..restops], [Number(a), Multiply, ..restops]]
+      })
+    }
+    [] -> []
+    [Add, ..] | [Multiply, ..] ->
+      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
+  |> list.map(fn(line) {
+    line |> string.split_once(": ") |> result.unwrap(#("0", "0"))
+  })
+  |> list.map(fn(row) {
+    #(
+      row.0 |> int.parse |> result.unwrap(0),
+      row.1
+        |> string.split(" ")
+        |> list.filter_map(int.parse)
+        |> list.map(fn(i) { Number(i) }),
+    )
+  })
+}

test/day7_test.gleam

@@ -0,0 +1,23 @@
+import gleeunit
+import gleeunit/should
+
+import day7
+
+pub fn main() {
+  gleeunit.main()
+}
+
+const example1 = "190: 10 19
+3267: 81 40 27
+83: 17 5
+156: 15 6
+7290: 6 8 6 15
+161011: 16 10 13
+192: 17 8 14
+21037: 9 7 18 13
+292: 11 6 16 20
+"
+
+pub fn part1_test() {
+  day7.part1(example1) |> should.equal(3749)
+}