Day 22, 23

Author: WVerlaek

src/main/kotlin/common/datastructures/DisjointSets.kt

@@ -5,13 +5,13 @@ class DisjointSets<T> {
     val parent: MutableMap<T, T> = mutableMapOf()
 
     val size get() = rank.size
-    val sets: MutableSet<T> = mutableSetOf()
+    val sets: MutableMap<T, MutableSet<T>> = mutableMapOf()
 
     private fun checkInit(x: T) {
         if (x in rank) return
         rank[x] = 0
         parent[x] = x
-        sets += x
+        sets[x] = mutableSetOf(x)
     }
 
     fun find(x: T): T {
@@ -22,6 +22,10 @@ class DisjointSets<T> {
         return parent[x]!!
     }
 
+    fun elementsInSet(root: T): Set<T> {
+        return sets.getValue(root)
+    }
+
     fun union(x: T, y: T) {
         val rootX = find(x)
         val rootY = find(y)
@@ -30,13 +34,16 @@ class DisjointSets<T> {
         }
         if (rank[rootX]!! < rank[rootY]!!) {
             parent[rootX] = rootY
+            sets.getValue(rootY).addAll(sets.getValue(rootX))
             sets -= rootX
         } else if (rank[rootY]!! < rank[rootX]!!) {
             parent[rootY] = rootX
+            sets.getValue(rootX).addAll(sets.getValue(rootY))
             sets -= rootY
         } else {
             parent[rootY] = rootX
             rank[rootX] = rank[rootX]!! + 1
+            sets.getValue(rootX).addAll(sets.getValue(rootY))
             sets -= rootY
         }
     }

src/main/kotlin/y24/Day22.kt

@@ -0,0 +1,85 @@
+package y24
+
+import common.puzzle.solvePuzzle
+import common.puzzle.Input
+import common.puzzle.Puzzle
+import common.datastructures.*
+import common.ext.*
+import common.util.*
+import java.util.*
+import kotlin.math.*
+import kotlin.system.exitProcess
+
+
+fun main() = solvePuzzle(year = 2024, day = 22, dryRun = true) { Day22(it) }
+
+// 2^24=16777216
+class Day22(val input: Input) : Puzzle {
+
+    fun evolve(secret: Long): Long {
+        var s = secret
+        s = (s shl 6) xor s
+        s = s and 16777215 // 2^24 - 1
+
+        s = (s shr 5) xor s
+        s = s and 16777215 // 2^24 - 1
+
+        s = (s shl 11) xor s
+        s = s and 16777215 // 2^24 - 1
+
+        return s
+    }
+
+    fun sequence(secret: Long, n: Int): List<Long> {
+        var s = secret
+        return (0..n).map {
+            s.also { s = evolve(s) }
+        }
+    }
+
+    override fun solveLevel1(): Any {
+        return input.lines.sumOf { sequence(it.toLong(), 2000).last() }
+    }
+
+    data class Sequence(
+        val priceDiffs: List<Long>,
+    )
+
+    private fun computeBananas(prices: List<Long>, diffs: List<Long>): Map<Sequence, Long> {
+        val result = mutableMapOf<Sequence, Long>()
+        for (i in 0 until diffs.size - 3) {
+            val sequence = Sequence(diffs.subList(i, i + 4))
+            val bananas = prices[i + 4]
+            if (sequence !in result) {
+                result[sequence] = bananas
+            }
+        }
+
+        return result
+    }
+
+    override fun solveLevel2(): Any {
+        val sequences = input.lines.map { sequence(it.toLong(), 2000) }
+        val sequencePrices = sequences.map { sequence ->
+            sequence.map { l -> l % 10 }
+        }
+        val diffs = sequencePrices.map { prices ->
+            prices.mapIndexedNotNull { index, price ->
+                if (index == 0) {
+                    null
+                } else {
+                    price - prices[index - 1]
+                }
+            }
+        }
+
+        val bananas = List(sequences.size) { i ->
+            computeBananas(sequencePrices[i], diffs[i])
+        }
+
+        val allSequences = bananas.flatMap { it.keys }.distinct()
+        return allSequences.maxOf { seq ->
+            bananas.sumOf { it[seq] ?: 0 }
+        }
+    }
+}

src/main/kotlin/y24/Day23.kt

@@ -0,0 +1,90 @@
+@file:Suppress("UnstableApiUsage")
+package y24
+
+import com.google.common.graph.Graph
+import com.google.common.graph.GraphBuilder
+import common.puzzle.solvePuzzle
+import common.puzzle.Input
+import common.puzzle.Puzzle
+import common.datastructures.*
+import common.ext.*
+import common.util.*
+import java.util.*
+import kotlin.math.*
+import kotlin.system.exitProcess
+
+
+fun main() = solvePuzzle(year = 2024, day = 23) { Day23(it) }
+
+class Day23(val input: Input) : Puzzle {
+    private val links = input.lines.map {
+        val (a, b) = it.split("-")
+        a to b
+    }
+
+    private fun largestFullyConnectedSet(graph: Graph<String>, edges: List<String>, curSet: MutableSet<String>, i: Int): Set<String> {
+        // Try adding edges i+
+        var maxSet = curSet.toSet()
+        for (j in i until edges.size) {
+            // Try adding j
+            if (curSet.any { it !in graph.adjacentNodes(edges[j]) }) {
+                continue
+            }
+
+            curSet += edges[j]
+            val set = largestFullyConnectedSet(graph, edges, curSet, j + 1)
+            if (set.size > maxSet.size) {
+                maxSet = set.toSet()
+            }
+            curSet -= edges[j]
+        }
+
+        return maxSet
+    }
+
+    override fun solveLevel1(): Any {
+        val graph = GraphBuilder.undirected().build<String>()
+        links.forEach { (a, b) ->
+            graph.putEdge(a, b)
+        }
+
+        val uniqueSets = mutableSetOf<List<String>>()
+
+        graph.nodes().forEach { node ->
+            val edges = graph.adjacentNodes(node).toList()
+            for (i in edges.indices) {
+                for (j in i + 1 until edges.size) {
+                    if (edges[j] !in graph.adjacentNodes(edges[i])) {
+                        continue
+                    }
+
+                    val set = listOf(node, edges[i], edges[j])
+                    if (set.none { it.startsWith('t') }) {
+                        continue
+                    }
+
+                    uniqueSets += set.sorted()
+                }
+            }
+        }
+
+        return uniqueSets.size
+    }
+
+    override fun solveLevel2(): Any {
+        val graph = GraphBuilder.undirected().build<String>()
+        links.forEach { (a, b) ->
+            graph.putEdge(a, b)
+        }
+
+        var maxSet: Set<String>? = null
+        graph.nodes().forEach { node ->
+            val max = largestFullyConnectedSet(graph, graph.adjacentNodes(node).toList(), mutableSetOf(node), 0)
+            if (maxSet == null || max.size > maxSet!!.size) {
+                maxSet = max
+            }
+        }
+
+        return maxSet!!.sorted().joinToString(",")
+    }
+}

src/test/kotlin/y24/Day22Test.kt

@@ -0,0 +1,31 @@
+package y24
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day22Test {
+    private val sample = Input("""
+    1
+    10
+    100
+    2024
+    """.trimIndent())
+
+    private val day = Day22(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(37327623L, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+         assertEquals(23L, Day22(Input("""
+         1
+         2
+         3
+         2024
+         """.trimIndent())).solveLevel2())
+    }
+}

src/test/kotlin/y24/Day23Test.kt

@@ -0,0 +1,54 @@
+package y24
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day23Test {
+    private val sample = 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
+    """.trimIndent())
+
+    private val day = Day23(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(7, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+         assertEquals("co,de,ka,ta", day.solveLevel2())
+    }
+}