Solved day16 part 1

Author: Gentleman1983

build.gradle

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

day16/src/main/kotlin/de/havox_design/aoc2023/day16/Day16.kt

@@ -2,11 +2,55 @@ package de.havox_design.aoc2023.day16
 
 class Day16(private var filename: String) {
     fun solvePart1(): Long =
-        46L
+        getEnergy(parseTiles(getResourceAsText(filename)), Direction.EAST, Pair(0, 0))
+            .toLong()
 
     fun solvePart2(): Long =
         0L
 
+    private fun getEnergy(contraption: List<List<Tile>>, enteredDirection: Direction, startPoint: Pair<Int, Int>): Int {
+        traceBeam(contraption, enteredDirection, contraption[startPoint.first][startPoint.second])
+
+        return contraption
+            .flatten()
+            .count { it.isEnergized() }
+    }
+
+    private fun traceBeam(contraption: List<List<Tile>>, enteredDirection: Direction, startTile: Tile) {
+        val nextDirections = startTile
+            .getNextDirections(enteredDirection)
+        val nextLocations = nextDirections
+            .map { nextLocation(startTile.row, startTile.column, it) }
+
+        for (location in nextLocations.withIndex()) {
+            when {
+                (
+                        location.value.first !in contraption.indices
+                                || location.value.second !in contraption[startTile.row].indices
+                                || nextDirections[location.index] == Direction.NONE
+                        ) -> continue
+            }
+            traceBeam(
+                contraption,
+                nextDirections[location.index],
+                contraption[location.value.first][location.value.second]
+            )
+        }
+    }
+
+    private fun nextLocation(row: Int, column: Int, direction: Direction): Pair<Int, Int> {
+        return when (direction) {
+            Direction.NORTH -> Pair(row - 1, column)
+            Direction.SOUTH -> Pair(row + 1, column)
+            Direction.EAST -> Pair(row, column + 1)
+            Direction.WEST -> Pair(row, column - 1)
+            else -> Pair(row, column)
+        }
+    }
+
+    private fun parseTiles(input: List<String>) =
+        input.mapIndexed { row, line -> line.mapIndexed { column, c -> Tile(row, column, c) } }
+
     private fun getResourceAsText(path: String): List<String> =
         this.javaClass.classLoader.getResourceAsStream(path)!!.bufferedReader().readLines()
 }

day16/src/main/kotlin/de/havox_design/aoc2023/day16/Direction.kt

@@ -0,0 +1,9 @@
+package de.havox_design.aoc2023.day16
+
+enum class Direction {
+    NORTH,
+    SOUTH,
+    WEST,
+    EAST,
+    NONE
+}

day16/src/main/kotlin/de/havox_design/aoc2023/day16/Tile.kt

@@ -0,0 +1,74 @@
+package de.havox_design.aoc2023.day16
+
+data class Tile(val row: Int, val column: Int, val type: Char) {
+    private val MARKER_UP = "^"
+    private val MARKER_DOWN = "V"
+    private val MARKER_LEFT = "<"
+    private val MARKER_RIGHT = ">"
+    private val MARKER_EMPTY = '.'
+    private val MARKER_NORTH_EAST_MIRROR = '\\'
+    private val MARKER_SOUTH_EAST_MIRROR = '/'
+    private val MARKER_ROW_SPLITTER = '|'
+    private val MARKER_COL_SPLITTER = '-'
+
+    private val enteredDirections = mutableSetOf<Direction>()
+
+    fun isEnergized(): Boolean = enteredDirections.isNotEmpty()
+
+    fun getNextDirections(enteredDirection: Direction): List<Direction> {
+        if (enteredDirection == Direction.NONE || !enteredDirections.add(enteredDirection)) {
+            return listOf(Direction.NONE)
+        }
+        return when (type) {
+            MARKER_EMPTY -> listOf(enteredDirection)
+            MARKER_SOUTH_EAST_MIRROR -> when (enteredDirection) {
+                Direction.NORTH -> listOf(Direction.EAST)
+                Direction.EAST -> listOf(Direction.NORTH)
+                Direction.SOUTH -> listOf(Direction.WEST)
+                Direction.WEST -> listOf(Direction.SOUTH)
+                else -> listOf(Direction.NONE)
+            }
+
+            MARKER_NORTH_EAST_MIRROR -> when (enteredDirection) {
+                Direction.NORTH -> listOf(Direction.WEST)
+                Direction.EAST -> listOf(Direction.SOUTH)
+                Direction.SOUTH -> listOf(Direction.EAST)
+                Direction.WEST -> listOf(Direction.NORTH)
+                else -> listOf(Direction.NONE)
+            }
+
+            MARKER_COL_SPLITTER -> {
+                if (enteredDirection in listOf(Direction.WEST, Direction.EAST)) listOf(enteredDirection)
+                else listOf(Direction.WEST, Direction.EAST)
+            }
+
+            MARKER_ROW_SPLITTER -> {
+                if (enteredDirection in listOf(Direction.NORTH, Direction.SOUTH)) listOf(enteredDirection)
+                else listOf(Direction.NORTH, Direction.SOUTH)
+            }
+
+            else -> listOf(Direction.NONE)
+        }
+    }
+
+    @SuppressWarnings("kotlin:S6510")
+    override fun toString(): String {
+        when {
+            enteredDirections.size > 1 -> {
+                return enteredDirections.size.toString()
+            }
+
+            else -> return when (this.type) {
+                MARKER_EMPTY -> when (enteredDirections.firstOrNull()) {
+                    Direction.NORTH -> MARKER_UP
+                    Direction.EAST -> MARKER_RIGHT
+                    Direction.SOUTH -> MARKER_DOWN
+                    Direction.WEST -> MARKER_LEFT
+                    else -> this.type.toString()
+                }
+
+                else -> this.type.toString()
+            }
+        }
+    }
+}