feat: 2024 Day 23

Author: mfulton26

2024/day/23/part/1/solve.test.ts

@@ -0,0 +1,41 @@
+import solve from "./solve.ts";
+
+import { assertEquals } from "@std/assert";
+
+Deno.test("example", () => {
+  const input = `\
+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`;
+
+  assertEquals(solve(input), 7);
+});

2024/day/23/part/1/solve.ts

@@ -0,0 +1,25 @@
+export default function solve(input: string) {
+  const connections = input.split("\n").map((line) => line.split("-"));
+  const edges = new Map<string, Set<string>>();
+  for (const [u, v] of connections) {
+    edges.get(u)?.add(v) ?? edges.set(u, new Set([v]));
+    edges.get(v)?.add(u) ?? edges.set(v, new Set([u]));
+  }
+  const interconnections = new Set<string>();
+  for (const [u, uNeighbors] of edges) {
+    for (const v of uNeighbors) {
+      const vNeighbors = edges.get(v);
+      if (!vNeighbors?.has(u)) continue;
+      for (const w of vNeighbors) {
+        const wNeighbors = edges.get(w);
+        if (!wNeighbors?.has(u)) continue;
+        interconnections.add([u, v, w].sort().join(","));
+      }
+    }
+  }
+  let count = 0;
+  for (const interconnection of interconnections) {
+    if (interconnection.split(",").some((n) => n.startsWith("t"))) count++;
+  }
+  return count;
+}

2024/day/23/part/2/solve.test.ts

@@ -0,0 +1,41 @@
+import solve from "./solve.ts";
+
+import { assertEquals } from "@std/assert";
+
+Deno.test("example", () => {
+  const input = `\
+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`;
+
+  assertEquals(solve(input), "co,de,ka,ta");
+});

2024/day/23/part/2/solve.ts

@@ -0,0 +1,37 @@
+type Graph<N> = { nodes: ReadonlySet<N>; neighbors(n: N): ReadonlySet<N> };
+
+function findLargestClique<N>(graph: Graph<N>) {
+  let maxClique = new Set<N>();
+  function bronKerbosch(R: ReadonlySet<N>, P: Set<N>, X: Set<N>) {
+    if (P.size === 0 && X.size === 0) {
+      if (R.size > maxClique.size) maxClique = new Set(R);
+      return;
+    }
+    for (const v of P) {
+      const vNeighbors = graph.neighbors(v);
+      bronKerbosch(
+        new Set(R).add(v),
+        P.intersection(vNeighbors),
+        X.intersection(vNeighbors),
+      );
+      P.delete(v);
+      X.add(v);
+    }
+  }
+  bronKerbosch(new Set<N>(), new Set(graph.nodes), new Set<N>());
+  return maxClique;
+}
+
+export default function solve(input: string) {
+  const connections = input.split("\n").map((line) => line.split("-"));
+  const edges = new Map<string, Set<string>>();
+  for (const [u, v] of connections) {
+    edges.get(u)?.add(v) ?? edges.set(u, new Set([v]));
+    edges.get(v)?.add(u) ?? edges.set(v, new Set([u]));
+  }
+  const graph: Graph<string> = {
+    nodes: new Set(edges.keys()),
+    neighbors: (n: string) => edges.get(n) ?? new Set(),
+  };
+  return findLargestClique(graph).values().toArray().sort().join(",");
+}