the discord was abuzz with disjoint sets so I had to try it

Author: devries

src/day08/solution.gleam

@@ -1,11 +1,10 @@
-import gleam/dict
 import gleam/int
 import gleam/io
 import gleam/list
 import gleam/result
-import gleam/set
 import gleam/string
 import internal/aoc_utils
+import internal/disjoint_set
 
 pub fn main() {
   let filename = "inputs/day08.txt"
@@ -36,12 +35,11 @@ pub fn solve_p1(lines: List(String), connections: Int) -> Result(String, String)
     |> list.take(connections)
     |> list.map(fn(t) { t.0 })
 
-  wire(dict.new(), closest_boxes)
-  |> dict.to_list
-  |> list.map(fn(dtup) { dtup.1 })
-  |> set.from_list
-  |> set.to_list
-  |> list.map(set.size)
+  let circuits = wire(disjoint_set.from_list(boxes), closest_boxes)
+
+  disjoint_set.setlist(circuits)
+  |> list.map(disjoint_set.size(circuits, _))
+  |> result.values
   |> list.sort(int.compare)
   |> list.reverse
   |> list.take(3)
@@ -63,7 +61,11 @@ pub fn solve_p2(lines: List(String)) -> Result(String, String) {
     |> list.sort(fn(v1, v2) { int.compare(v1.1, v2.1) })
     |> list.map(fn(t) { t.0 })
 
-  build_circuit_sized(list.length(boxes), dict.new(), closest_boxes)
+  build_circuit_sized(
+    list.length(boxes),
+    disjoint_set.from_list(boxes),
+    closest_boxes,
+  )
   |> fn(v) { { v.0 }.x * { v.1 }.x }
   |> int.to_string
   |> Ok
@@ -90,21 +92,12 @@ fn parse_line(line: String) -> Junction {
 // When I combine two boxes I have to update the circuit of all involed
 // junctions.
 fn wire(
-  circuit_table: dict.Dict(Junction, set.Set(Junction)),
+  circuit_table: disjoint_set.DisjointSet(Junction),
   connections: List(#(Junction, Junction)),
-) -> dict.Dict(Junction, set.Set(Junction)) {
+) -> disjoint_set.DisjointSet(Junction) {
   list.fold(connections, circuit_table, fn(acc, conn) {
-    // Get the circuit for a box, if it's not part of a circuit yet
-    // just provide a set containing only itself
-    let s1 = dict.get(acc, conn.0) |> result.unwrap(set.from_list([conn.0]))
-    let s2 = dict.get(acc, conn.1) |> result.unwrap(set.from_list([conn.1]))
-
-    // new combined circuit
-    let combined = set.union(s1, s2)
-
-    set.fold(combined, acc, fn(acc_inner, jb) {
-      dict.insert(acc_inner, jb, combined)
-    })
+    let assert Ok(new_table) = disjoint_set.union(acc, conn.0, conn.1)
+    new_table
   })
 }
 
@@ -113,33 +106,17 @@ fn wire(
 // connection that achieved that size.
 fn build_circuit_sized(
   size: Int,
-  circuit_table: dict.Dict(Junction, set.Set(Junction)),
+  circuit_table: disjoint_set.DisjointSet(Junction),
   connections: List(#(Junction, Junction)),
 ) -> #(Junction, Junction) {
   case connections {
     [] -> panic as "unable to build requested circuit size"
     [first, ..rest] -> {
-      // Get the circuit for a box, if it's not part of a circuit yet
-      // just provide a set containing only itself
-      let s1 =
-        dict.get(circuit_table, first.0)
-        |> result.unwrap(set.from_list([first.0]))
-      let s2 =
-        dict.get(circuit_table, first.1)
-        |> result.unwrap(set.from_list([first.1]))
-
-      // new combined circuit
-      let combined = set.union(s1, s2)
-
-      case set.size(combined) {
-        s if s == size -> first
-        _ -> {
-          let new_table =
-            set.fold(combined, circuit_table, fn(acc, jb) {
-              dict.insert(acc, jb, combined)
-            })
-          build_circuit_sized(size, new_table, rest)
-        }
+      let assert Ok(new_table) =
+        disjoint_set.union(circuit_table, first.0, first.1)
+      case disjoint_set.size(new_table, first.0) {
+        Ok(s) if s == size -> first
+        _ -> build_circuit_sized(size, new_table, rest)
       }
     }
   }

src/internal/disjoint_set.gleam

@@ -0,0 +1,101 @@
+import gleam/dict
+import gleam/list
+
+pub opaque type DisjointSet(a) {
+  DisjointSet(parents: dict.Dict(a, a), sizes: dict.Dict(a, Int))
+}
+
+pub fn from_list(items: List(a)) -> DisjointSet(a) {
+  let #(parents, sizes) =
+    list.fold(items, #(dict.new(), dict.new()), fn(acc, item) {
+      #(dict.insert(acc.0, item, item), dict.insert(acc.1, item, 1))
+    })
+  DisjointSet(parents:, sizes:)
+}
+
+pub fn find(dj: DisjointSet(a), item: a) -> Result(#(DisjointSet(a), a), Nil) {
+  case dict.get(dj.parents, item) {
+    Ok(parent) -> {
+      case parent == item {
+        True -> Ok(#(dj, item))
+        False -> {
+          // Path compression to make each item point to a single representative set parent
+          case find(dj, parent) {
+            Error(_) -> Error(Nil)
+            Ok(#(dj, rep_parent)) -> {
+              let updated_dj =
+                DisjointSet(
+                  parents: dict.insert(dj.parents, item, rep_parent),
+                  sizes: dj.sizes,
+                )
+              Ok(#(updated_dj, rep_parent))
+            }
+          }
+        }
+      }
+    }
+    Error(_) -> Error(Nil)
+  }
+}
+
+pub fn union(dj: DisjointSet(a), x: a, y: a) -> Result(DisjointSet(a), Nil) {
+  case find(dj, x) {
+    Error(Nil) -> Error(Nil)
+    Ok(#(dj, root_x)) -> {
+      case find(dj, y) {
+        Error(Nil) -> Error(Nil)
+        Ok(#(dj, root_y)) if root_x != root_y -> {
+          case dict.get(dj.sizes, root_x), dict.get(dj.sizes, root_y) {
+            Ok(size_x), Ok(size_y) if size_x < size_y -> {
+              Ok(DisjointSet(
+                dict.insert(dj.parents, root_x, root_y),
+                dict.insert(dj.sizes, root_y, size_x + size_y),
+              ))
+            }
+            Ok(size_x), Ok(size_y) -> {
+              Ok(DisjointSet(
+                dict.insert(dj.parents, root_y, root_x),
+                dict.insert(dj.sizes, root_x, size_x + size_y),
+              ))
+            }
+            _, _ -> Error(Nil)
+          }
+        }
+        _ -> Ok(dj)
+      }
+    }
+  }
+}
+
+pub fn size(dj: DisjointSet(a), item: a) -> Result(Int, Nil) {
+  case find(dj, item) {
+    Error(Nil) -> Error(Nil)
+    Ok(#(dj, rep_parent)) -> dict.get(dj.sizes, rep_parent)
+  }
+}
+
+pub fn to_list(dj: DisjointSet(a), item: a) -> Result(List(a), Nil) {
+  case find(dj, item) {
+    Error(Nil) -> Error(Nil)
+    Ok(#(dj, rep_parent)) -> {
+      dict.keys(dj.parents)
+      |> list.filter(fn(i) {
+        case find(dj, i) {
+          Ok(#(_, p)) if p == rep_parent -> True
+          _ -> False
+        }
+      })
+      |> Ok
+    }
+  }
+}
+
+pub fn setlist(dj: DisjointSet(a)) -> List(a) {
+  dict.keys(dj.parents)
+  |> list.filter(fn(item) {
+    case find(dj, item) {
+      Ok(#(_, p)) if p == item -> True
+      _ -> False
+    }
+  })
+}

test/aoc2025_test.gleam

@@ -1,6 +1,5 @@
 import gleam/time/duration
 import gleeunit
-import gleeunit/should
 import internal/aoc_utils
 import internal/point
 
@@ -9,30 +8,28 @@ pub fn main() {
 }
 
 pub fn solution_or_error_test() {
-  aoc_utils.solution_or_error(Ok("This is good"))
-  |> should.equal("This is good")
+  assert aoc_utils.solution_or_error(Ok("This is good")) == "This is good"
 
-  aoc_utils.solution_or_error(Error("This is bad"))
-  |> should.equal("ERROR: This is bad")
+  assert aoc_utils.solution_or_error(Error("This is bad"))
+    == "ERROR: This is bad"
 }
 
 pub fn chunk_up_test() {
-  ["aaa", "bbb", "ccc", "", "ddd", "eee", "", "", "fff"]
-  |> aoc_utils.chunk_around_empty_strings()
-  |> should.equal([["aaa", "bbb", "ccc"], ["ddd", "eee"], ["fff"]])
+  assert {
+      ["aaa", "bbb", "ccc", "", "ddd", "eee", "", "", "fff"]
+      |> aoc_utils.chunk_around_empty_strings()
+    }
+    == [["aaa", "bbb", "ccc"], ["ddd", "eee"], ["fff"]]
 }
 
 pub fn point_addition_test() {
-  point.add(#(2, 1), #(-1, 1))
-  |> should.equal(#(1, 2))
+  assert point.add(#(2, 1), #(-1, 1)) == #(1, 2)
 }
 
 pub fn point_multiplication_test() {
-  point.mul(#(2, 5), 5)
-  |> should.equal(#(10, 25))
+  assert point.mul(#(2, 5), 5) == #(10, 25)
 
-  point.mul(#(2, 5), 0)
-  |> should.equal(#(0, 0))
+  assert point.mul(#(2, 5), 0) == #(0, 0)
 }
 
 pub fn duration_to_string_test() {