continue day22

Author: EmRe-One

src/main/kotlin/tr/emreone/adventofcode/days/Day22.kt

@@ -1,37 +1,15 @@
 package tr.emreone.adventofcode.days
 
 import tr.emreone.kotlin_utils.automation.Day
-import tr.emreone.kotlin_utils.math.Point2D
 import tr.emreone.kotlin_utils.math.Point3D
 import java.util.*
+import kotlin.collections.ArrayDeque
 import kotlin.math.max
 import kotlin.math.min
 
 class Day22 : Day(22, 2023, "Sand Slabs") {
 
-    data class Brick(val id: Int, val a: Point3D, val b: Point3D) {
-        private val xRange = rangeBy { it.x.toInt() }
-        private val yRange = rangeBy { it.y.toInt() }
-        private val zRange = rangeBy { it.z.toInt() }
-
-        private fun rangeBy(f: (Point3D) -> Int) = min(f(a), f(b))..max(f(a), f(b))
-
-        val xyPoints = xRange.flatMap { xi ->
-            yRange.map { yi ->
-                Point2D(xi.toLong(), yi.toLong())
-            }
-        }
-
-        val minZ
-            get() = zRange.first
-        val maxZ
-            get() = zRange.last
-
-        fun fallBy(fallAmount: Int) = copy(
-            a = Point3D(x = a.x, y = a.y, z = a.z - fallAmount),
-            b = Point3D(x = b.x, y = b.y, z = b.z - fallAmount)
-        )
-
+    data class Brick(val id: Int, var a: Point3D, var b: Point3D) {
         override fun toString() = "[$id] $a~$b"
 
         fun overlapsWith(other: Brick): Boolean {
@@ -40,33 +18,6 @@ class Day22 : Day(22, 2023, "Sand Slabs") {
         }
     }
 
-    data class Snapshot(val bricks: Set<Brick>) {
-
-        fun makeBricksFall(): Snapshot {
-            val tetris = BrickTetris(this)
-            tetris.makeAllBricksFall(print = true)
-            return Snapshot(tetris.bricks().toSet())
-        }
-
-        // returns number of bricks that would fall if given brick were removed
-        private fun countAffectedBricksAfterRemovalOf(brick: Brick): Int {
-            val tetris = BrickTetris(this)
-            tetris.remove(brick)
-            tetris.makeAllBricksFall()
-            return tetris.bricks().count { it !in bricks }
-        }
-
-        fun findBrickRemovalCounts(): Map<Brick, Int> = bricks.associateWith { brick ->
-            countAffectedBricksAfterRemovalOf(brick)
-        }
-    }
-
-    data class BrickFall(val oldBrick: Brick, val fallAmount: Int) {
-        fun newBrick(): Brick {
-            return oldBrick.fallBy(fallAmount)
-        }
-    }
-
     private val bricks = inputAsList
         .mapIndexed { index, line ->
             val (left, right) = line.split("~")
@@ -76,105 +27,81 @@ class Day22 : Day(22, 2023, "Sand Slabs") {
 
             Brick(index, Point3D(x1, y1, z1), Point3D(x2, y2, z2))
         }
-        .toSet()
-
-    class BrickTetris(snapshot: Snapshot) {
-
-        private val bricksByXY: MutableMap<Point2D, SortedSet<Brick>> = snapshot.bricks
-            .flatMap { brick -> brick.xyPoints.map { xy -> xy to brick } }
-            .groupBy({ (xy, _) -> xy }, { (_, brick) -> brick })
-            .mapValues { (_, bricks) -> bricks.toSortedSet(compareBy { it.minZ }) }
-            .toMutableMap()
-
-        private val bricksByMinZ: SortedMap<Int, MutableList<Brick>> = snapshot.bricks
-            .groupBy { it.minZ }
-            .mapValues { (_, bricks) -> bricks.toMutableList() }
-            .toSortedMap()
-
-
-        private var lastCheckedMinZ = 1
-
-        fun bricks() = bricksByMinZ.values.asSequence().flatten()
+        .sortedBy { it.a.z }
+        .also {
+            it.forEachIndexed { index, brick ->
+                var maxZ = 1L
+                for (i in 0 until index) {
+                    val other = it.elementAt(i)
+                    if (brick.overlapsWith(other)) {
+                        maxZ = max(maxZ, other.b.z + 1)
+                    }
+                }
+                brick.b = Point3D(brick.b.x, brick.b.y, brick.b.z - brick.a.z + maxZ)
+                brick.a = Point3D(brick.a.x, brick.a.y, maxZ)
+            }
+        }
+        .sortedBy { it.a.z }
 
-        private fun bricksAt(xy: Point2D) = bricksByXY[xy]!!
 
-        private fun bricksAt(minZ: Int) = bricksByMinZ[minZ]
+    override fun part1(): Int {
+        // https://www.youtube.com/watch?v=imz7uexX394
 
-        fun remove(brick: Brick) {
-            brick.xyPoints.forEach { xy -> bricksAt(xy) -= brick }
+        val supports = this.bricks.associate { it.id to mutableSetOf<Int>() }
+        val supportedBy = this.bricks.associate { it.id to mutableSetOf<Int>() }
 
-            bricksAt(brick.minZ)?.let {
-                it -= brick
+        this.bricks.forEachIndexed { j, upperBrick ->
+            this.bricks.subList(0, j).forEachIndexed { i, lowerBrick ->
+                if (upperBrick.overlapsWith(lowerBrick) && upperBrick.a.z == lowerBrick.b.z + 1) {
+                    supports[i]!! += j
+                    supportedBy[j]!! += i
+                }
             }
         }
 
-        private fun add(brick: Brick) {
-            brick.xyPoints.forEach { xy -> bricksAt(xy) += brick }
-
-            bricksAt(brick.minZ)?.let {
-                it += brick
-            }
+        return supports.values.count { set ->
+            set.all { supportedBy[it]!!.size > 1 }
         }
+    }
 
-        fun makeAllBricksFall(print: Boolean = false) {
-            var counter = 0
-            while (tryMakeNextBrickFall()) {
-                counter++
+    override fun part2(): Int {
+        val supports = this.bricks.associate { it.id to mutableSetOf<Int>() }
+        val supportedBy = this.bricks.associate { it.id to mutableSetOf<Int>() }
+
+        this.bricks.forEachIndexed { j, upperBrick ->
+            this.bricks.subList(0, j).forEachIndexed { i, lowerBrick ->
+                if (upperBrick.overlapsWith(lowerBrick) && upperBrick.a.z == lowerBrick.b.z + 1) {
+                    supports[i]!! += j
+                    supportedBy[j]!! += i
+                }
             }
-            if (print) println("Made $counter bricks fall")
         }
 
-        private fun tryMakeNextBrickFall(): Boolean {
-            val brickFall = findNextBrickToFall() ?: return false
+        var total = 0
 
-            remove(brickFall.oldBrick)
-            add(brickFall.newBrick())
+        this.bricks.forEachIndexed { i, brick ->
+            val q: Deque<Int> = LinkedList(supports[brick.id]!!.filter { supportedBy[it]!!.size == 1 })
 
-            lastCheckedMinZ = brickFall.oldBrick.minZ
-            return true
-        }
+            val falling = q.toMutableSet()
+            falling.add(i)
 
-        private fun findNextBrickToFall(): BrickFall? = bricksByMinZ
-            .tailMap(lastCheckedMinZ) // do not check below last checked minZ
-            .values
-            .asSequence()
-            .flatten()
-            .firstNotNullOfOrNull { brick -> findFallAmount(brick)?.let { fall -> BrickFall(brick, fall) } }
+            while (q.isNotEmpty()) {
+                val j = q.pop()
+                for (k in (supports[j]!! - falling)) {
+                    if (supportedBy[k]!!.all { falling.contains(it) }) {
+                        q.add(k)
+                        falling.add(k)
+                    }
+                }
+            }
 
-        private fun findFallAmount(brick: Brick): Int? {
-            val zAfterFall = brick.xyPoints.maxOf { xy -> minZAfterFallAt(brick, xy) }
-            return (brick.minZ - zAfterFall).takeIf { it > 0 }
+            total += falling.size - 1
         }
 
-        private fun minZAfterFallAt(brick: Brick, xy: Point2D): Int {
-            val bricksBelow = bricksAt(xy).headSet(brick)
-            if (bricksBelow.isEmpty()) {
-                return 1
-            }
-            return bricksBelow.last().maxZ + 1
-        }
+        return total
     }
 
-    override fun part1(): Int {
-        // https://www.youtube.com/watch?v=imz7uexX394
-
-        val removal = Snapshot(this.bricks)
-            .makeBricksFall()
-            .findBrickRemovalCounts()
-
-        println(removal)
+}
 
-        return removal
-            .values
-            .count { it == 0 }
-    }
 
-    override fun part2(): Int {
-        return Snapshot(this.bricks)
-            .makeBricksFall()
-            .findBrickRemovalCounts()
-            .values
-            .sum()
-    }
 
-}

src/test/kotlin/tr/emreone/adventofcode/days/Day22Test.kt

@@ -10,7 +10,7 @@ internal class Day22Test {
     fun `execute_tests`() {
         solve<Day22>(false) {
             Resources.resourceAsList("day22_example.txt")
-                .joinToString("\n") part1 5 // part2 7
+                .joinToString("\n") part1 5 part2 7
         }
     }