finished day 25, still working on a nice solution to 24 pt 2

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: 47](https://img.shields.io/badge/⭐_Stars-47-yellow)](https://adventofcode.com/2024)
+[![Stars: 48](https://img.shields.io/badge/⭐_Stars-48-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
@@ -43,3 +43,4 @@ information.
 - [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)
+- [Day 25](https://adventofcode.com/2024/day/25): [⭐    solution](src/day25/solution.gleam)

inputs

@@ -15,7 +15,7 @@ pub fn main() {
       // 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) })
+      aoc_utils.run_part_and_print("Part 2", fn() { solve_p2(lines, 45) })
     }
     Error(_) -> io.println("Error reading file")
   }
@@ -30,22 +30,32 @@ pub fn solve_p1(lines: List(String)) -> Result(String, String) {
   |> int.to_string
 }
 
+//
+// Half adder
+// x0 XOR y0 -> z0
+// x0 AND y0 -> c0
+//
+// Full adder
+// xn XOR yn -> an
+// xn AND yn -> bn
+// an XOR cn-1 -> zn
+// an AND cn-1 -> dn
+// bn OR dn -> cn
+//
+
 // Part 2
-pub fn solve_p2(lines: List(String)) -> Result(String, String) {
+pub fn solve_p2(lines: List(String), bits: Int) -> 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
+  let avals = find_a(gates)
+  let bvals = find_b(gates)
+  list.range(0, bits)
+  |> list.map(fn(i) {
+    let a = dict.get(avals, i)
+    let b = dict.get(bvals, i)
+    io.debug(#(i, a, b))
+    trace_gate(gates, i, "")
+  })
   todo
 }
 
@@ -144,9 +154,121 @@ fn resolve_gate(
   }
 }
 
+fn find_a(gates: List(Gate)) -> Dict(Int, String) {
+  list.fold(gates, dict.new(), fn(d, gate) {
+    case gate {
+      Xor(a, _, c) -> {
+        case string.starts_with(a, "x") || string.starts_with(a, "y") {
+          True -> {
+            let val = string.drop_start(a, 1) |> int.parse |> result.unwrap(0)
+            dict.insert(d, val, c)
+          }
+          False -> d
+        }
+      }
+      _ -> d
+    }
+  })
+}
+
+fn find_b(gates: List(Gate)) -> Dict(Int, String) {
+  list.fold(gates, dict.new(), fn(d, gate) {
+    case gate {
+      And(a, _, c) -> {
+        case string.starts_with(a, "x") || string.starts_with(a, "y") {
+          True -> {
+            let val = string.drop_start(a, 1) |> int.parse |> result.unwrap(0)
+            dict.insert(d, val, c)
+          }
+          False -> d
+        }
+      }
+      _ -> d
+    }
+  })
+}
+
 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 })
 }
+
+// Create an initial condition for testing a bit on x and
+// y with the other bits off.
+fn setup_test(
+  bit: Int,
+  max_bit: Int,
+  x: Int,
+  y: Int,
+  carry: Int,
+) -> Dict(String, Int) {
+  list.range(0, max_bit)
+  |> list.map(fn(i) {
+    let xkey = "x" <> string.pad_start(int.to_string(i), 2, "0")
+    let ykey = "y" <> string.pad_start(int.to_string(i), 2, "0")
+
+    case i {
+      v if v == bit - 1 -> {
+        case carry {
+          1 -> [#(xkey, 1), #(ykey, 1)]
+          _ -> [#(xkey, 0), #(ykey, 0)]
+        }
+      }
+
+      v if v == bit -> {
+        [#(xkey, x), #(ykey, y)]
+      }
+
+      _ -> [#(xkey, 0), #(ykey, 0)]
+    }
+  })
+  |> list.flatten
+  |> dict.from_list
+}
+
+fn get_test_result(wires: Dict(String, Int), bit: Int) -> #(Int, Int) {
+  let zkey = "z" <> string.pad_start(int.to_string(bit), 2, "0")
+  let ckey = "z" <> string.pad_start(int.to_string(bit + 1), 2, "0")
+
+  #(
+    dict.get(wires, zkey) |> result.unwrap(0),
+    dict.get(wires, ckey) |> result.unwrap(0),
+  )
+}
+
+//
+// Half adder
+// x0 XOR y0 -> z0
+// x0 AND y0 -> c0
+//
+// Full adder
+// xn XOR yn -> an
+// xn AND yn -> bn
+// an XOR cn-1 -> zn
+// an AND cn-1 -> dn
+// bn OR dn -> cn
+//
+fn trace_gate(gates: List(Gate), i: Int, c: String) {
+  let x = "x" <> string.pad_start(int.to_string(i), 2, "0")
+  let y = "y" <> string.pad_start(int.to_string(i), 2, "0")
+  let z = "z" <> string.pad_start(int.to_string(i), 2, "0")
+
+  case i {
+    0 -> {
+      find_gates(gates, x, y)
+    }
+    _ -> {
+      find_gates(gates, x, y)
+      |> io.debug
+    }
+  }
+}
+
+fn find_gates(gates: List(Gate), i1: String, i2: String) -> List(Gate) {
+  gates
+  |> list.filter(fn(g) {
+    { g.input1 == i1 && g.input2 == i2 } || { g.input1 == i2 && g.input2 == i1 }
+  })
+}

src/day24/solution.gleam

@@ -0,0 +1,81 @@
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/string
+import internal/aoc_utils
+
+pub fn main() {
+  let filename = "inputs/day25.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) })
+    }
+    Error(_) -> io.println("Error reading file")
+  }
+}
+
+// Part 1
+pub fn solve_p1(lines: List(String)) -> Result(String, String) {
+  let #(locks, keys) =
+    aoc_utils.chunk_around_empty_strings(lines)
+    |> list.map(parse_schematic)
+    |> list.partition(fn(s) {
+      case s {
+        Lock(_) -> True
+        Key(_) -> False
+      }
+    })
+
+  locks
+  |> list.fold(0, fn(sum, lock) {
+    keys
+    |> list.fold(sum, fn(sum, key) {
+      case combo_test(lock, key) {
+        True -> sum + 1
+        False -> sum
+      }
+    })
+  })
+  |> int.to_string
+  |> Ok
+}
+
+type Schematic {
+  Lock(values: List(Int))
+  Key(values: List(Int))
+}
+
+fn parse_schematic(lines: List(String)) -> Schematic {
+  let values =
+    lines
+    |> list.map(fn(l) { string.to_graphemes(l) })
+    |> list.transpose
+    |> list.map(fn(l) {
+      list.fold(l, -1, fn(sum, g) {
+        case g {
+          "#" -> sum + 1
+          _ -> sum
+        }
+      })
+    })
+
+  case list.first(lines) {
+    Ok(".....") -> Key(values)
+    Ok("#####") -> Lock(values)
+    _ -> panic as "this should not happen"
+  }
+}
+
+fn combo_test(a: Schematic, b: Schematic) -> Bool {
+  case a, b {
+    Lock(va), Key(vb) | Key(vb), Lock(va) -> {
+      list.zip(va, vb)
+      |> list.fold(True, fn(success, tup) { success && tup.0 + tup.1 < 6 })
+    }
+    _, _ -> False
+  }
+}

src/day25/solution.gleam

@@ -55,9 +55,8 @@ pub fn part1_test() {
   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"))
-}
+// pub fn part2_test() {
+//   let lines = string.split(testinput, "\n")
+//   solution.solve_p2(lines, 5)
+//   |> should.equal(Ok("24"))
+// }

test/day24_test.gleam

@@ -0,0 +1,49 @@
+import day25/solution
+import gleam/string
+import gleeunit/should
+
+const testinput = "#####
+.####
+.####
+.####
+.#.#.
+.#...
+.....
+
+#####
+##.##
+.#.##
+...##
+...#.
+...#.
+.....
+
+.....
+#....
+#....
+#...#
+#.#.#
+#.###
+#####
+
+.....
+.....
+#.#..
+###..
+###.#
+###.#
+#####
+
+.....
+.....
+.....
+#....
+#.#..
+#.#.#
+#####"
+
+pub fn part1_test() {
+  let lines = string.split(testinput, "\n")
+  solution.solve_p1(lines)
+  |> should.equal(Ok("3"))
+}