Solution Day 23, part two (LAN Party)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year24/day23/LANParty.kt

@@ -2,21 +2,25 @@ package de.ronny_h.aoc.year24.day23
 
 import de.ronny_h.aoc.AdventOfCode
 
-fun main() = LANParty().run(1240, 0)
+fun main() = LANParty().run("1240", "am,aq,by,ge,gf,ie,mr,mt,rw,sn,te,yi,zb")
 
-class LANParty : AdventOfCode<Int>(2024, 23) {
+class LANParty : AdventOfCode<String>(2024, 23) {
 
-    override fun part1(input: List<String>): Int = Network(input)
+    override fun part1(input: List<String>): String = Network(input)
         .searchForLANPartiesWithThreeComputers()
-        .filter { set -> set.any { it.startsWith("t") } }.size
+        .filter { set -> set.any { it.startsWith("t") } }
+        .size
+        .toString()
 
-    override fun part2(input: List<String>): Int {
-        TODO("Not yet implemented")
-    }
+    override fun part2(input: List<String>): String = Network(input)
+        .sortedConnectionSets()
+        .findLargestIntersection()
+        .sorted()
+        .joinToString(",")
 }
 
 class Network(input: List<String>) {
-    // from one computer to all others it is directly connected to
+    // a map entry for computer `c` contains all other computers that `c` is directly connected to
     private val connections: Map<String, Set<String>>
 
     init {
@@ -33,14 +37,38 @@ class Network(input: List<String>) {
         val triples = mutableSetOf<Set<String>>()
         connections.forEach { (computer, neighbors) ->
             neighbors.forEach { neighbor ->
-                val otherNeighborsNeighbors = connections.getValue(neighbor).filterNot { it == computer }
+                val neighborsOtherNeighbors = connections.getValue(neighbor).filterNot { it == computer }
                 val neighborsWithBacklinkToComputer =
-                    otherNeighborsNeighbors.filter { connections.getValue(it).contains(computer) }
+                    neighborsOtherNeighbors.filter { connections.getValue(it).contains(computer) }
                 neighborsWithBacklinkToComputer.forEach {
                     triples.add(setOf(computer, neighbor, it))
                 }
             }
         }
         return triples
     }
+
+    fun sortedConnectionSets() = connections
+        .map { (computer, neighbors) -> neighbors + computer }
+        .sortedBy { -it.size }
+}
+
+fun List<Set<String>>.findLargestIntersection(): Set<String> {
+    // precondition: `this` is sorted in decreasing order by size
+    var largestIntersection = emptySet<String>()
+    for ((i, s1) in this.withIndex()) {
+        for ((j, s2) in this.withIndex()) {
+            if (i == j) continue
+            if (s2.size < largestIntersection.size) {
+                return largestIntersection
+            }
+            val intersection = s1 intersect s2
+            if (intersection.size > largestIntersection.size) {
+                if (this.count { it.containsAll(intersection) } == intersection.size) {
+                    largestIntersection = intersection
+                }
+            }
+        }
+    }
+    return largestIntersection
 }

src/test/kotlin/de/ronny_h/aoc/year24/day23/LANPartyTest.kt

@@ -41,27 +41,67 @@ class LANPartyTest : StringSpec({
         td-yn
     """.asList()
 
-    "in a simple network with three computers, a LAN party of these three is found" {
-        val smallInput = """
+    /*
+    a: b,c   -> a,b,c
+    b: a,c,d -> a,b,c,d
+    c: a,b,e -> a,b,c,  e
+    d: b,e   ->   b,  d,e
+    e: c,d   ->     c,d,e
+     */
+    val smallInput = """
             a-b
+            b-d
             b-c
+            c-e
             c-a
+            d-e
         """.asList()
-        Network(smallInput).searchForLANPartiesWithThreeComputers() shouldBe setOf(setOf("a", "b", "c"))
-    }
 
-    "in a simple network with five computers, a LAN party of three is found" {
-        val smallInput = """
+    /*
+    a: b,c -> a,b,c
+    b: a,c -> a,b,c
+    c: a,b -> a,b,c
+     */
+    "in a simple network with three computers, a LAN party of these three is found" {
+        val minimalInput = """
             a-b
-            b-d
             b-c
-            c-e
             c-a
         """.asList()
+        Network(minimalInput).searchForLANPartiesWithThreeComputers() shouldBe setOf(setOf("a", "b", "c"))
+    }
+
+    "in a simple network with five computers, a LAN party of three is found" {
         Network(smallInput).searchForLANPartiesWithThreeComputers() shouldBe setOf(setOf("a", "b", "c"))
     }
 
     "part1: For all sets of three inter-connected computers, the number containing a computer starting with t" {
-        LANParty().part1(input) shouldBe 7
+        LANParty().part1(input) shouldBe "7"
+    }
+
+    "sortedConnectionSets() sorts the sets of computers directly connected to one of them descendant by length" {
+        Network(smallInput).sortedConnectionSets() shouldBe listOf(
+            setOf("a","b","c","d"),
+            setOf("a","b","c","e"),
+            setOf("a","b","c"),
+            setOf("b","d","e"),
+            setOf("c","d","e"),
+        )
+    }
+
+    "findLargestIntersection() finds the largest intersection that exists at least its length times over all sets" {
+        listOf(
+            setOf("a","d","e","f"), // is largest intersection but occurs only twice, not four times
+            setOf("a","d","e","f"),
+            setOf("a","b","c","d"),
+            setOf("a","b","c","e"),
+            setOf("a","b","c"),
+            setOf("b","d","e"),
+            setOf("c","d","e"),
+        ).findLargestIntersection() shouldBe setOf("a", "b", "c")
+    }
+
+    "part2: largest set of computers that are all connected to each other, sorted alphabetically" {
+        LANParty().part2(input) shouldBe "co,de,ka,ta"
     }
 })