finished day 24 part 1

Author: devries

README.md

@@ -1,7 +1,7 @@
 # Advent of Code 2024
 
 [![Tests](https://github.com/devries/advent_of_code_2024/actions/workflows/test.yml/badge.svg)](https://github.com/devries/advent_of_code_2024/actions/workflows/test.yml)
-[![Stars: 46](https://img.shields.io/badge/⭐_Stars-46-yellow)](https://adventofcode.com/2024)
+[![Stars: 47](https://img.shields.io/badge/⭐_Stars-47-yellow)](https://adventofcode.com/2024)
 
 This year I am going to try to do Advent of Code in  [Gleam](https://gleam.run).
 To run a day's problems use the command
@@ -42,3 +42,4 @@ information.
 - [Day 21](https://adventofcode.com/2024/day/21): [⭐ ⭐ solution](src/day21/solution.gleam)
 - [Day 22](https://adventofcode.com/2024/day/22): [⭐ ⭐ solution](src/day22/solution.gleam)
 - [Day 23](https://adventofcode.com/2024/day/23): [⭐ ⭐ solution](src/day23/solution.gleam)
+- [Day 24](https://adventofcode.com/2024/day/24): [⭐    solution](src/day24/solution.gleam)

inputs

@@ -0,0 +1,152 @@
+import gleam/dict.{type Dict}
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/result
+import gleam/string
+import internal/aoc_utils
+
+pub fn main() {
+  let filename = "inputs/day24.txt"
+
+  let lines_result = aoc_utils.read_lines(from: filename)
+  case lines_result {
+    Ok(lines) -> {
+      // If the file was converting into a list of lines
+      // successfully then run each part of the problem
+      aoc_utils.run_part_and_print("Part 1", fn() { solve_p1(lines) })
+      aoc_utils.run_part_and_print("Part 2", fn() { solve_p2(lines) })
+    }
+    Error(_) -> io.println("Error reading file")
+  }
+}
+
+// Part 1
+pub fn solve_p1(lines: List(String)) -> Result(String, String) {
+  use #(wires, gates) <- result.map(parse(lines))
+
+  find_wire_values(wires, gates)
+  |> get_number("z")
+  |> int.to_string
+}
+
+// Part 2
+pub fn solve_p2(lines: List(String)) -> Result(String, String) {
+  use #(wires, gates) <- result.map(parse(lines))
+
+  get_number(wires, "x")
+  |> int.to_base2
+  |> io.debug
+
+  get_number(wires, "y")
+  |> int.to_base2
+  |> io.debug
+
+  find_wire_values(wires, gates)
+  |> get_number("z")
+  |> int.to_base2
+  |> io.debug
+  todo
+}
+
+type Gate {
+  And(input1: String, input2: String, output: String)
+  Or(input1: String, input2: String, output: String)
+  Xor(input1: String, input2: String, output: String)
+}
+
+fn parse(
+  lines: List(String),
+) -> Result(#(Dict(String, Int), List(Gate)), String) {
+  let assert [values, gates] = aoc_utils.chunk_around_empty_strings(lines)
+
+  use wire_dict <- result.try(parse_values(values))
+
+  use gate_list <- result.map(parse_gates(gates))
+
+  #(wire_dict, gate_list)
+}
+
+fn parse_values(values: List(String)) -> Result(Dict(String, Int), String) {
+  use value_list <- result.map({
+    values
+    |> list.map(fn(line) {
+      case string.split(line, ": ") {
+        [wire, boolstring] ->
+          case int.parse(boolstring) {
+            Ok(n) -> Ok(#(wire, n))
+            Error(Nil) -> Error("Unable to parse wire value")
+          }
+        _ -> Error("Unexpected wire value line")
+      }
+    })
+    |> result.all
+  })
+
+  dict.from_list(value_list)
+}
+
+fn parse_gates(gates: List(String)) -> Result(List(Gate), String) {
+  gates
+  |> list.map(fn(line) {
+    case string.split(line, " ") {
+      [i1, name, i2, _, o] -> {
+        case name {
+          "AND" -> Ok(And(i1, i2, o))
+          "OR" -> Ok(Or(i1, i2, o))
+          "XOR" -> Ok(Xor(i1, i2, o))
+          _ -> Error("Gate type not recognized")
+        }
+      }
+      _ -> Error("Unexpected gate format")
+    }
+  })
+  |> result.all
+}
+
+fn find_wire_values(
+  wires: Dict(String, Int),
+  gates: List(Gate),
+) -> Dict(String, Int) {
+  case gates {
+    [] -> wires
+    _ -> {
+      let newdict =
+        gates
+        |> list.fold(wires, fn(d, gate) {
+          case resolve_gate(gate, wires) {
+            Ok(#(output, value)) -> {
+              dict.insert(d, output, value)
+            }
+            _ -> d
+          }
+        })
+
+      find_wire_values(
+        newdict,
+        gates |> list.filter(fn(g) { !dict.has_key(newdict, g.output) }),
+      )
+    }
+  }
+}
+
+fn resolve_gate(
+  gate: Gate,
+  wires: Dict(String, Int),
+) -> Result(#(String, Int), Nil) {
+  use v1 <- result.try(dict.get(wires, gate.input1))
+  use v2 <- result.map(dict.get(wires, gate.input2))
+
+  case gate {
+    And(_, _, o) -> #(o, int.bitwise_and(v1, v2))
+    Or(_, _, o) -> #(o, int.bitwise_or(v1, v2))
+    Xor(_, _, o) -> #(o, int.bitwise_exclusive_or(v1, v2))
+  }
+}
+
+fn get_number(wires: Dict(String, Int), prefix: String) -> Int {
+  dict.to_list(wires)
+  |> list.filter(fn(tup) { string.starts_with(tup.0, prefix) })
+  |> list.sort(fn(tupa, tupb) { string.compare(tupb.0, tupa.0) })
+  |> list.fold(0, fn(value, tup) { { value * 2 } + tup.1 })
+}

src/day24/solution.gleam

@@ -0,0 +1,63 @@
+import day24/solution
+import gleam/string
+import gleeunit/should
+
+const testinput = "x00: 1
+x01: 0
+x02: 1
+x03: 1
+x04: 0
+y00: 1
+y01: 1
+y02: 1
+y03: 1
+y04: 1
+
+ntg XOR fgs -> mjb
+y02 OR x01 -> tnw
+kwq OR kpj -> z05
+x00 OR x03 -> fst
+tgd XOR rvg -> z01
+vdt OR tnw -> bfw
+bfw AND frj -> z10
+ffh OR nrd -> bqk
+y00 AND y03 -> djm
+y03 OR y00 -> psh
+bqk OR frj -> z08
+tnw OR fst -> frj
+gnj AND tgd -> z11
+bfw XOR mjb -> z00
+x03 OR x00 -> vdt
+gnj AND wpb -> z02
+x04 AND y00 -> kjc
+djm OR pbm -> qhw
+nrd AND vdt -> hwm
+kjc AND fst -> rvg
+y04 OR y02 -> fgs
+y01 AND x02 -> pbm
+ntg OR kjc -> kwq
+psh XOR fgs -> tgd
+qhw XOR tgd -> z09
+pbm OR djm -> kpj
+x03 XOR y03 -> ffh
+x00 XOR y04 -> ntg
+bfw OR bqk -> z06
+nrd XOR fgs -> wpb
+frj XOR qhw -> z04
+bqk OR frj -> z07
+y03 OR x01 -> nrd
+hwm AND bqk -> z03
+tgd XOR rvg -> z12
+tnw OR pbm -> gnj"
+
+pub fn part1_test() {
+  let lines = string.split(testinput, "\n")
+  solution.solve_p1(lines)
+  |> should.equal(Ok("2024"))
+}
+
+pub fn part2_test() {
+  let lines = string.split(testinput, "\n")
+  solution.solve_p2(lines)
+  |> should.equal(Ok("24"))
+}