finished day 23

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: 44](https://img.shields.io/badge/⭐_Stars-44-yellow)](https://adventofcode.com/2024)
+[![Stars: 46](https://img.shields.io/badge/⭐_Stars-46-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
@@ -41,3 +41,4 @@ information.
 - [Day 20](https://adventofcode.com/2024/day/20): [⭐ ⭐ solution](src/day20/solution.gleam)
 - [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)

inputs

@@ -0,0 +1,194 @@
+import gleam/dict.{type Dict}
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/option.{None, Some}
+import gleam/result
+import gleam/set.{type Set}
+import gleam/string
+import internal/aoc_utils
+
+pub fn main() {
+  let filename = "inputs/day23.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) {
+  let conn = parse(lines)
+
+  dict.keys(conn)
+  |> list.filter(fn(item) { string.starts_with(item, "t") })
+  |> list.map(find_cycles(_, 3, conn))
+  |> list.fold(set.new(), fn(combined, single) { set.union(combined, single) })
+  |> set.size
+  |> int.to_string
+  |> Ok
+}
+
+// Part 2
+pub fn solve_p2(lines: List(String)) -> Result(String, String) {
+  let conn = parse(lines)
+
+  let cycles =
+    dict.keys(conn)
+    |> list.map(find_cycles(_, 3, conn))
+    |> list.fold(set.new(), fn(combined, single) { set.union(combined, single) })
+    |> set.to_list
+
+  let connset =
+    dict.to_list(conn)
+    |> list.map(fn(tup) { #(tup.0, set.from_list(tup.1)) })
+    |> dict.from_list
+
+  largest_group(cycles, connset, set.new())
+  |> set.to_list
+  |> list.sort(string.compare)
+  |> string.join(",")
+  |> Ok
+}
+
+fn parse(lines: List(String)) -> Dict(String, List(String)) {
+  lines
+  |> list.map(string.split(_, "-"))
+  |> list.fold(dict.new(), fn(connections, values) {
+    case values {
+      [a, b] -> {
+        let alist = dict.get(connections, a) |> result.unwrap([])
+        let blist = dict.get(connections, b) |> result.unwrap([])
+
+        let connections = dict.insert(connections, a, [b, ..alist])
+        dict.insert(connections, b, [a, ..blist])
+      }
+      _ -> connections
+    }
+  })
+}
+
+fn find_cycles(
+  start: String,
+  length: Int,
+  conn: Dict(String, List(String)),
+) -> Set(Set(String)) {
+  find_cycles_acc([start], length, conn, start, set.new(), set.new())
+}
+
+fn find_cycles_acc(
+  search: List(String),
+  length: Int,
+  conn: Dict(String, List(String)),
+  end: String,
+  prev: Set(String),
+  found: Set(Set(String)),
+) -> Set(Set(String)) {
+  case search {
+    [first, ..rest] -> {
+      let next =
+        dict.get(conn, first)
+        |> result.unwrap([])
+
+      case length == 1 {
+        True -> {
+          // Add found set where next element is the end element
+          case list.contains(next, end) {
+            True ->
+              find_cycles_acc(
+                rest,
+                length,
+                conn,
+                end,
+                prev,
+                set.insert(found, set.insert(prev, first)),
+              )
+            False -> find_cycles_acc(rest, length, conn, end, prev, found)
+          }
+        }
+        False -> {
+          // continue traversing the cycle, ignoring where we've already been
+          let found =
+            find_cycles_acc(
+              list.filter(next, fn(item) { !set.contains(prev, item) }),
+              length - 1,
+              conn,
+              end,
+              set.insert(prev, first),
+              found,
+            )
+          find_cycles_acc(rest, length, conn, end, prev, found)
+        }
+      }
+    }
+    [] -> found
+  }
+}
+
+// Starting from a group, find another computer which is connected to every
+// computer in the group, then continue to grow from that larger group until
+// no further systems can be added.
+fn grow(group: Set(String), connset: Dict(String, Set(String))) -> Set(String) {
+  // find largest set containing group
+  let candidates =
+    group
+    |> set.fold(None, fn(u, vertex) {
+      case u {
+        None -> {
+          dict.get(connset, vertex)
+          |> result.unwrap(set.new())
+          |> Some
+        }
+        Some(u) ->
+          set.intersection(
+            u,
+            dict.get(connset, vertex) |> result.unwrap(set.new()),
+          )
+          |> Some
+      }
+    })
+    |> option.unwrap(set.new())
+    |> set.difference(group)
+    |> set.to_list
+    |> list.first
+
+  case candidates {
+    Ok(c) -> grow(set.insert(group, c), connset)
+    Error(Nil) -> group
+  }
+}
+
+// If a cycle is contained entirely within the group we found, it will only
+// grow to be that same group, so we can ignore it and test other cycles.
+fn prune(group: Set(String), cycles: List(Set(String))) -> List(Set(String)) {
+  // remove cycles within group
+  list.filter(cycles, fn(c) { !set.is_subset(c, group) })
+}
+
+// Start growing from each cycle to find the largest group
+// pruning searched cycles at each step.
+fn largest_group(
+  cycles: List(Set(String)),
+  connset: Dict(String, Set(String)),
+  largest: Set(String),
+) -> Set(String) {
+  // Search all cycles for largest group
+  case cycles {
+    [first, ..rest] -> {
+      let candidate = grow(first, connset)
+      let remaining = prune(candidate, rest)
+      case set.size(candidate) > set.size(largest) {
+        True -> largest_group(remaining, connset, candidate)
+        False -> largest_group(remaining, connset, largest)
+      }
+    }
+    [] -> largest
+  }
+}

src/day23/solution.gleam

@@ -0,0 +1,48 @@
+import day23/solution
+import gleam/string
+import gleeunit/should
+
+const testinput = "kh-tc
+qp-kh
+de-cg
+ka-co
+yn-aq
+qp-ub
+cg-tb
+vc-aq
+tb-ka
+wh-tc
+yn-cg
+kh-ub
+ta-co
+de-co
+tc-td
+tb-wq
+wh-td
+ta-ka
+td-qp
+aq-cg
+wq-ub
+ub-vc
+de-ta
+wq-aq
+wq-vc
+wh-yn
+ka-de
+kh-ta
+co-tc
+wh-qp
+tb-vc
+td-yn"
+
+pub fn part1_test() {
+  let lines = string.split(testinput, "\n")
+  solution.solve_p1(lines)
+  |> should.equal(Ok("7"))
+}
+
+pub fn part2_test() {
+  let lines = string.split(testinput, "\n")
+  solution.solve_p2(lines)
+  |> should.equal(Ok("co,de,ka,ta"))
+}