Solved day22 part 1

Author: Gentleman1983

README.md

@@ -43,13 +43,13 @@ To run all solutions, simply run `./gradlew run`. If you want to run the solutio
 | 19      | ⭐        | ⭐        |
 | 20      | ⭐        | ⭐        |
 | 21      | ⭐        | ⭐        |
-| 22      | ❌        | ❌        |
+| 22      | ⭐        | ❌        |
 | 23      | ❌        | ❌        |
 | 24      | ❌        | ❌        |
 | 25      | ❌        | ❌        |
-| **SUM** | **21 ⭐** | **21 ⭐** |
+| **SUM** | **22 ⭐** | **21 ⭐** |
 
-Total: 42 ⭐
+Total: 43 ⭐
 
 ## Prior Years contribution:
 | Year | Language(s)                                     | Total Stars               | Link to repository                                   |

build.gradle

@@ -4,7 +4,7 @@ plugins {
 
 // project meta data
 group 'de.havox_design.aoc2023'
-version '0.21.1'
+version '0.21.2'
 
 // Switch to gradle "all" distribution.
 wrapper {

day22/src/main/kotlin/de/havox_design/aoc2023/day22/Brick.kt

@@ -0,0 +1,58 @@
+package de.havox_design.aoc2023.day22
+
+data class Brick(val startPosition: Triple<Int, Int, Int>, val endPosition: Triple<Int, Int, Int>) {
+    val fallen: Brick
+        get() =
+            Brick(
+                Triple(startPosition.x(), startPosition.y(), startPosition.z() - 1),
+                Triple(endPosition.x(), endPosition.y(), endPosition.z() - 1)
+            )
+
+    val canFall: Boolean
+        get() =
+            canFall(Day22.getBricks())
+
+    fun contains(position: Triple<Int, Int, Int>): Boolean =
+        position.x() >= startPosition.x() && position.x() <= endPosition.x() &&
+                position.y() >= startPosition.y() && position.y() <= endPosition.y() &&
+                position.z() >= startPosition.z() && position.z() <= endPosition.z()
+
+    fun intersect(other: Brick): Boolean {
+        return when {
+            other.startPosition.z() > endPosition.z() || other.endPosition.z() < startPosition.z() -> false
+            else -> {
+                for (x in other.startPosition.x()..other.endPosition.x()) {
+                    for (y in other.startPosition.y()..other.endPosition.y()) {
+                        for (z in other.startPosition.z()..other.endPosition.z()) {
+                            when {
+                                contains(Triple(x, y, z)) -> return true
+                            }
+                        }
+                    }
+                }
+                false
+            }
+        }
+    }
+
+    fun canFall(bricks: ArrayList<Brick>): Boolean {
+        val f = fallen
+
+        for (brick in bricks) {
+            when {
+                brick != this && brick.intersect(f) -> return false
+            }
+        }
+
+        return startPosition.third > 1
+    }
+}
+
+private fun Triple<Int, Any, Any>.x(): Int =
+    this.first
+
+private fun Triple<Any, Int, Any>.y(): Int =
+    this.second
+
+private fun Triple<Any, Any, Int>.z(): Int =
+    this.third

day22/src/main/kotlin/de/havox_design/aoc2023/day22/Day22.kt

@@ -1,12 +1,70 @@
 package de.havox_design.aoc2023.day22
 
 class Day22(private var filename: String) {
-    fun solvePart1(): Long =
-        5L
+    private val ID_BRICK_END_X = 3
+    private val ID_BRICK_END_Y = 4
+    private val ID_BRICK_END_Z = 5
+    private val ID_BRICK_START_X = 0
+    private val ID_BRICK_START_Y = 1
+    private val ID_BRICK_START_Z = 2
+
+    private val number = Regex("-?\\d+")
+
+    fun solvePart1(): Long {
+        bricks.clear()
+
+        for (row in getResourceAsText(filename)) {
+            val numbers = number
+                .findAll(row)
+                .map { it.value.toInt() }
+                .toList()
+
+            bricks.add(
+                Brick(
+                    Triple(numbers[ID_BRICK_START_X], numbers[ID_BRICK_START_Y], numbers[ID_BRICK_START_Z]),
+                    Triple(numbers[ID_BRICK_END_X], numbers[ID_BRICK_END_Y], numbers[ID_BRICK_END_Z])
+                )
+            )
+        }
+
+        bricks
+            .sortBy { it.startPosition.third }
+
+        for (i in 0..<bricks.size) {
+            while (bricks[i].canFall) {
+                bricks[i] = bricks[i].fallen
+            }
+        }
+
+        var countToBeAbleToBeDisintegrated = 0L
+
+        for (i in 0..<bricks.size) {
+            val save = bricks[i]
+            bricks[i] = Brick(
+                Triple(-1, -1, -1),
+                Triple(-1, -1, -1)
+            )
+
+            if (bricks.all { !it.canFall }) {
+                countToBeAbleToBeDisintegrated++
+            }
+
+            bricks[i] = save
+        }
+
+        return countToBeAbleToBeDisintegrated
+    }
 
     fun solvePart2(): Long =
         0L
 
     private fun getResourceAsText(path: String): List<String> =
         this.javaClass.classLoader.getResourceAsStream(path)!!.bufferedReader().readLines()
+
+    companion object {
+        private val bricks = ArrayList<Brick>()
+
+        fun getBricks(): ArrayList<Brick> =
+            bricks
+    }
 }