mend

src/aoc_2025/day_10.gleam

···
+import crew
+import gleam/erlang/process
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/result
+import gleam/set.{type Set}
+import gleam/string
+
+pub type Joltages {
+  Joltages(joltages: List(Int))
+}
+
+pub type State {
+  State(lamps: List(Bool))
+}
+
+pub type Button {
+  Button(toggles: List(Int))
+}
+
+pub type Machine {
+  Machine(target: State, buttons: List(Button), joltages: Joltages)
+}
+
+pub fn parse(input: String) -> List(Machine) {
+  input
+  |> string.split("\n")
+  |> list.map(fn(line) {
+    line
+    |> string.split(" ")
+    |> list.fold(Machine(State([]), [], Joltages([])), fn(acc, item) {
+      let Machine(state, buttons, joltages) = acc
+
+      case item {
+        "[" <> state ->
+          state
+          |> string.drop_end(1)
+          |> parse_state([])
+          |> Machine(buttons, joltages)
+
+        "(" <> button ->
+          button
+          |> string.drop_end(1)
+          |> parse_int_list
+          |> Button
+          |> fn(button) { Machine(state, [button, ..buttons], joltages) }
+
+        "{" <> joltages ->
+          joltages
+          |> string.drop_end(1)
+          |> parse_int_list
+          |> Joltages
+          |> fn(joltages) { Machine(state, buttons, joltages) }
+
+        "" -> acc
+
+        other -> {
+          echo other
+          panic as "huh"
+        }
+      }
+    })
+  })
+}
+
+fn parse_state(state_string: String, acc) {
+  case state_string {
+    "." <> rest -> parse_state(rest, [False, ..acc])
+    "#" <> rest -> parse_state(rest, [True, ..acc])
+    _ -> State(acc |> list.reverse)
+  }
+}
+
+fn parse_int_list(button_string: String) {
+  button_string
+  |> string.split(",")
+  |> list.map(int.parse)
+  |> result.values
+}
+
+pub fn pt_1(input: List(Machine)) {
+  input
+  |> list.fold(0, fn(sum, machine) {
+    sum + pt_1_loop(machine, [#(machine.target, 0)], set.new())
+  })
+}
+
+fn pt_1_loop(
+  machine: Machine,
+  last_states: List(#(State, Int)),
+  next_states: Set(#(State, Int)),
+) {
+  case last_states {
+    [] -> pt_1_loop(machine, next_states |> set.to_list, set.new())
+    [#(state, num), ..rest] -> {
+      // all off?
+      case state.lamps |> list.all(fn(lamp) { !lamp }) {
+        True -> num
+        False -> {
+          // click all buttons on this state
+          machine.buttons
+          |> list.fold(next_states, fn(next_states, button) {
+            next_states
+            |> set.insert(#(click_lamp_button(button, state), num + 1))
+          })
+          |> pt_1_loop(machine, rest, _)
+        }
+      }
+    }
+  }
+}
+
+fn click_lamp_button(button: Button, state: State) {
+  state.lamps
+  |> list.index_map(fn(lamp, index) {
+    case button.toggles |> list.contains(index) {
+      True -> !lamp
+      False -> lamp
+    }
+  })
+  |> State
+}
+
+pub fn pt_2(input: List(Machine)) {
+  let pool_name = process.new_name("worker_pool")
+  let assert Ok(_) =
+    crew.new(pool_name, run_pt_2_loop_for_machine)
+    |> crew.fixed_size(input |> list.length)
+    |> crew.start()
+
+  input
+  |> crew.call_parallel(pool_name, 120_000, _)
+  |> list.fold(0, int.add)
+}
+
+fn run_pt_2_loop_for_machine(machine: Machine) {
+  pt_2_loop(
+    machine,
+    [
+      #(
+        list.repeat(0, times: list.length(machine.joltages.joltages))
+          |> Joltages,
+        0,
+      ),
+    ],
+    set.new(),
+  )
+  |> echo
+}
+
+fn pt_2_loop(
+  machine: Machine,
+  last_joltages: List(#(Joltages, Int)),
+  next_joltages: Set(#(Joltages, Int)),
+) {
+  case last_joltages {
+    [] -> pt_2_loop(machine, next_joltages |> set.to_list, set.new())
+
+    [#(joltages, num), ..rest] if num > 100 -> {
+      echo machine
+
+      num
+    }
+    [#(joltages, num), ..rest] -> {
+      // all correct?
+      case joltages.joltages == machine.joltages.joltages {
+        True -> num
+        False -> {
+          // click all buttons on this state
+          machine.buttons
+          |> list.fold(next_joltages, fn(next_joltages, button) {
+            next_joltages
+            |> set.insert(#(click_joltage_button(button, joltages), num + 1))
+          })
+          |> pt_2_loop(machine, rest, _)
+        }
+      }
+    }
+  }
+}
+
+fn click_joltage_button(button: Button, joltages: Joltages) -> Joltages {
+  joltages.joltages
+  |> list.index_map(fn(joltage, index) {
+    case button.toggles |> list.contains(index) {
+      True -> joltage + 1
+      False -> joltage
+    }
+  })
+  |> Joltages
+}

src/aoc_2025/day_8.gleam

···
+import gleam/bool
+import gleam/dict
+import gleam/float
+import gleam/int
+import gleam/list
+import gleam/option.{None, Some}
+import gleam/pair
+import gleam/string
+
+pub type Position {
+  Position(x: Int, y: Int, z: Int)
+}
+
+type Edge {
+  Edge(length: Int, a: Position, b: Position)
+}
+
+fn equal_edge(edge_a, edge_b) {
+  let Edge(_, a1, b1) = edge_a
+  let Edge(_, a2, b2) = edge_b
+
+  a1 == a2 && b1 == b2 || a1 == b2 && a2 == b1
+}
+
+fn connecting_edge(edge_a, edge_b) {
+  let Edge(_, a1, b1) = edge_a
+  let Edge(_, a2, b2) = edge_b
+
+  a1 == a2 || b1 == b2 || a1 == b2 || b1 == a2
+}
+
+pub fn parse(input: String) {
+  input
+  |> string.split("\n")
+  |> list.map(string.split(_, ","))
+  |> list.map(fn(coords) {
+    case coords {
+      [x, y, z] -> {
+        let assert Ok(x) = int.parse(x)
+        let assert Ok(y) = int.parse(y)
+        let assert Ok(z) = int.parse(z)
+        Position(x:, y:, z:)
+      }
+      _ -> panic as "Invalid input"
+    }
+  })
+}
+
+pub fn pt_1(input: List(Position)) {
+  let distances =
+    input
+    |> list.fold(dict.new(), fn(distances, point) {
+      list.fold(input, distances, fn(distances, npoint) {
+        let dist = distance_3d(point, npoint)
+        dict.upsert(distances, point, fn(item) {
+          case item {
+            Some(item) -> [Edge(dist, point, npoint), ..item]
+            _ -> [Edge(dist, point, npoint)]
+          }
+        })
+      })
+    })
+    |> dict.map_values(fn(key, value) {
+      list.filter(value, fn(item) { item.length != 0 })
+    })
+
+  let circuits = dict.new()
+  pt_1_loop(distances, circuits, 1)
+  // |> echo
+  |> dict.values()
+  |> list.map(fn(circuit) {
+    list.fold(circuit, [], fn(acc, edge) {
+      let is_in_acc =
+        acc
+        |> list.any(fn(in_acc) { equal_edge(in_acc, edge) })
+      case is_in_acc {
+        True -> acc
+        False -> [edge, ..acc]
+      }
+    })
+  })
+  |> list.map(list.length)
+  |> list.sort(int.compare)
+  |> echo
+  |> list.take(3)
+  |> echo
+  |> list.reduce(fn(a, b) { a * b })
+  // todo as "part 1 not implemented"
+}
+
+fn pt_1_loop(
+  distances: dict.Dict(Position, List(Edge)),
+  circuits: dict.Dict(Int, List(Edge)),
+  index_multi: Int,
+) -> dict.Dict(Int, List(Edge)) {
+  let distances =
+    distances
+    // filter out already assigned edges
+    |> dict.map_values(fn(_, edges) {
+      let circuits =
+        circuits
+        |> dict.values
+        |> list.flatten
+
+      edges
+      |> list.filter(fn(edge) {
+        circuits
+        |> list.any(fn(in_circuit) { equal_edge(edge, in_circuit) })
+        |> bool.negate()
+      })
+    })
+
+  let remaining = distances |> dict.values() |> list.flatten() |> list.length()
+
+  case remaining == 0 {
+    True -> circuits
+    False -> {
+      pt_1_loop(
+        distances,
+        pt_1_loop_inner(distances, circuits, index_multi),
+        index_multi * 10,
+      )
+    }
+  }
+}
+
+fn pt_1_loop_inner(distances, circuits, index_multi) {
+  distances
+  |> dict.fold([], fn(smallest, _, distances) {
+    let closest = closest(distances)
+    [closest, ..smallest]
+  })
+  |> list.filter_map(fn(item) { item })
+  // get shortest first
+  |> list.sort(fn(a, b) { int.compare(a.length, b.length) })
+  // make sure there are no self referencing edges
+  |> list.filter(fn(a) { a.length != 0 })
+  |> list.index_fold(circuits, fn(circuits, edge, index) {
+    // are there any already existing circuits?
+    let connected =
+      dict.filter(circuits, fn(key, value) {
+        list.any(value, fn(item) { connecting_edge(item, edge) })
+      })
+
+    let index = case connected |> dict.keys() {
+      // yes? add to it
+      [index, ..] -> index
+      // no? add to current index
+      _ -> index * index_multi
+    }
+    dict_append(circuits, index, edge)
+  })
+}
+
+fn dict_append(dict, key, item) {
+  dict.upsert(dict, key, fn(in_dict) {
+    case in_dict {
+      Some(in_dict) -> [item, ..in_dict] |> list.unique()
+      None -> [item]
+    }
+  })
+}
+
+fn closest(distances: List(Edge)) {
+  list.fold(distances, [], fn(smallest, item) {
+    case smallest {
+      [Edge(0, _, _)] | [] -> [item]
+      [Edge(distance, _, _)] if distance > item.length -> [item]
+      [Edge(distance, _, _)] if distance <= item.length -> smallest
+      _ -> todo as "huh"
+    }
+  })
+  |> list.first()
+}
+
+fn distance_3d(point_a, point_b) {
+  let Position(x1, y1, z1) = point_a
+  let Position(x2, y2, z2) = point_b
+
+  let xdistance = dist_1d(x1, x2)
+  let ydistance = dist_1d(y1, y2)
+  let zdistance = dist_1d(z1, z2)
+
+  xdistance + ydistance + zdistance
+}
+
+fn dist_1d(c1, c2) {
+  let diff = c2 - c1
+  let dist = diff * diff
+  dist
+}
+
+pub fn pt_2(input: List(Position)) {
+  todo as "part 2 not implemented"
+}

src/aoc_2025/day_9.gleam

···
+import gleam/float
+import gleam/int
+import gleam/list
+import gleam/set
+import gleam/string
+
+pub fn parse(input: String) {
+  input
+  |> string.split("\n")
+  |> list.map(fn(line) {
+    let assert [x, y] = string.split(line, ",")
+    let assert Ok(x) = int.parse(x)
+    let assert Ok(y) = int.parse(y)
+    Point(x:, y:)
+  })
+}
+
+pub type Point {
+  Point(x: Int, y: Int)
+}
+
+pub type FloatPoint {
+  FloatPoint(x: Float, y: Float)
+}
+
+pub type Area {
+  Area(a: Point, b: Point, area: Int)
+}
+
+pub type Area4Point {
+  Area4Point(
+    a: FloatPoint,
+    b: FloatPoint,
+    c: FloatPoint,
+    d: FloatPoint,
+    area: Float,
+  )
+}
+
+pub fn pt_1(input: List(Point)) {
+  input
+  |> list.fold(set.new(), fn(areas, point_a) {
+    input
+    |> list.fold(areas, fn(areas, point_b) {
+      let area =
+        { int.absolute_value(point_a.x - point_b.x) + 1 }
+        * { int.absolute_value(point_a.y - point_b.y) + 1 }
+
+      areas
+      |> set.insert(Area(point_a, point_b, area))
+    })
+  })
+  |> set.fold(0, fn(acc, area) {
+    case area {
+      Area(a:, b:, area:) if area > acc -> area
+      _ -> acc
+    }
+  })
+}
+
+pub fn pt_2(input: List(Point)) {
+  // echo intersect(#(Point(0, 0), Point(10, 10)), #(Point(0, 5), Point(0, 2)))
+
+  // let mid_x = { largest_x - smallest_x } / 2
+  // |> echo
+  // let mid_y = { largest_y - smallest_y } / 2
+  // |> echo
+
+  let input =
+    input
+    |> list.map(fn(point) {
+      FloatPoint(int.to_float(point.x), int.to_float(point.y))
+    })
+
+  input
+  |> list.fold(set.new(), fn(acc, point_a) {
+    input
+    |> list.fold(acc, fn(acc, point_b) {
+      case point_a, point_b {
+        point_a, point_b if point_a == point_b -> acc
+
+        _, _ -> acc |> set.insert(other_corners(point_a, point_b))
+      }
+    })
+  })
+  |> set.filter(fn(area) {
+    let Area4Point(_, _, c, d, _) = area
+    let assert Ok(first) = list.first(input)
+
+    let input = list.append(input, [first])
+
+    // case a {
+    //   FloatPoint(x:, y:) if x == 11.0 && y == 1.0 && area.area == 50.0 -> {
+    //     echo area
+    //     echo count_intersections(of: c, in: input, acc: 0) as "c"
+    //     echo count_intersections(of: d, in: input, acc: 0) as "d"
+    //     Nil
+    //   }
+    //   _ -> Nil
+    // }
+
+    count_intersections(of: c, in: input, acc: 0) |> int.is_odd()
+    && count_intersections(of: d, in: input, acc: 0) |> int.is_odd()
+    // #(
+    //   area,
+    //   count_intersections(of: c, in: input, acc: 0),
+    //   count_intersections(of: d, in: input, acc: 0),
+    // )
+    // False
+  })
+  |> echo
+  |> set.fold(0.0, fn(acc, area) {
+    case area {
+      Area4Point(a: _, b: _, c: _, d: _, area:) if area >. acc -> area
+      _ -> acc
+    }
+  })
+  // |> echo
+}
+
+fn count_intersections(
+  of intersecting_point: FloatPoint,
+  in all_points: List(FloatPoint),
+  acc sum: Int,
+) {
+  case all_points {
+    [] | [_] -> sum
+    [a, b, ..rest] -> {
+      case a {
+        a if a == intersecting_point -> 1
+        _ -> {
+          case
+            intersect(
+              line: #(FloatPoint(0.0, 0.0), intersecting_point),
+              on_line: #(a, b),
+            )
+          {
+            True -> {
+              // echo string.inspect(a) <> " | " <> string.inspect(b) as "a-b, true"
+              count_intersections(intersecting_point, [b, ..rest], sum + 1)
+            }
+            False -> count_intersections(intersecting_point, [b, ..rest], sum)
+          }
+        }
+      }
+    }
+
+    s -> {
+      echo s
+      panic as "huh"
+    }
+  }
+}
+
+fn other_corners(point_a: FloatPoint, point_b: FloatPoint) {
+  let area =
+    { float.absolute_value(point_a.x -. point_b.x) +. 1.0 }
+    *. { float.absolute_value(point_a.y -. point_b.y) +. 1.0 }
+
+  Area4Point(
+    point_a,
+    point_b,
+    FloatPoint(point_a.x, point_b.y),
+    FloatPoint(point_b.x, point_a.y),
+    area,
+  )
+}
+
+fn intersect(
+  line line_a: #(FloatPoint, FloatPoint),
+  on_line line_b: #(FloatPoint, FloatPoint),
+) {
+  let #(FloatPoint(x1, y1), FloatPoint(x2, y2)) = line_a
+  let #(FloatPoint(x3, y3), FloatPoint(x4, y4)) = line_b
+
+  let denominator = { x1 -. x2 } *. { y3 -. y4 } -. { y1 -. y2 } *. { x3 -. x4 }
+
+  case denominator {
+    0.0 -> False
+    _ -> {
+      let px =
+        {
+          { x1 *. y2 -. y1 *. x2 }
+          *. { x3 -. x4 }
+          -. { x1 -. x2 }
+          *. { x3 *. y4 -. y3 *. x4 }
+        }
+        /. denominator
+
+      let py =
+        {
+          { x1 *. y2 -. y1 *. x2 }
+          *. { y3 -. y4 }
+          -. { y1 -. y2 }
+          *. { x3 *. y4 -. y3 *. x4 }
+        }
+        /. denominator
+
+      echo string.inspect(line_a)
+        <> " intersects "
+        <> string.inspect(line_b)
+        <> " at "
+        <> string.inspect(FloatPoint(px, py))
+        <> " on line_b?: "
+        <> string.inspect(on_line(line_b, FloatPoint(px, py)))
+
+      on_line(line_b, FloatPoint(px, py))
+    }
+  }
+}
+
+fn on_line(line: #(FloatPoint, FloatPoint), point: FloatPoint) {
+  case line {
+    #(a, b)
+      if {
+        a.x >=. point.x
+        && b.x <=. point.x
+        && a.y >=. point.y
+        && b.y <=. point.y
+      }
+      || {
+        a.x >=. point.x
+        && b.x <=. point.x
+        && a.y <=. point.y
+        && b.y >=. point.y
+      }
+      || {
+        a.x <=. point.x
+        && b.x >=. point.x
+        && a.y >=. point.y
+        && b.y <=. point.y
+      }
+      || {
+        a.x <=. point.x
+        && b.x >=. point.x
+        && a.y <=. point.y
+        && b.y >=. point.y
+      }
+    -> True
+    _ -> False
+  }
+}