Solved day17 part 1

Author: Gentleman1983

build.gradle

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

day17/src/main/kotlin/de/havox_design/aoc2023/day17/Coordinate.kt

@@ -0,0 +1,41 @@
+package de.havox_design.aoc2023.day17
+
+import kotlin.math.abs
+
+data class Coordinate(val x: Int, val y: Int) : Comparable<Coordinate> {
+    override fun compareTo(other: Coordinate): Int =
+        when (val result = y.compareTo(other.y)) {
+            0 -> x.compareTo(other.x)
+            else -> result
+        }
+
+    operator fun minus(other: Coordinate): Coordinate =
+        Coordinate(x - other.x, y - other.y)
+
+    operator fun plus(other: Coordinate): Coordinate =
+        Coordinate(x + other.x, y + other.y)
+
+    operator fun plus(i: Number): Coordinate =
+        plus(Coordinate(i.toInt(), i.toInt()))
+
+    operator fun times(i: Number): Coordinate =
+        this * Coordinate(i.toInt(), i.toInt())
+
+    operator fun times(other: Coordinate): Coordinate =
+        Coordinate(x * other.x, y * other.y)
+
+    operator fun div(other: Coordinate): Coordinate =
+        Coordinate(x / other.x, y / other.y)
+}
+
+fun manhattanDistance(a: Coordinate, b: Coordinate) =
+    abs(a.x - b.x) + abs(a.y - b.y)
+
+val origin = Coordinate(0, 0)
+
+fun <V> Map<Coordinate, V>.yRange() =
+    keys.minByOrNull { it.y }!!.y to keys.maxByOrNull { it.y }!!.y
+
+fun <V> Map<Coordinate, V>.xRange() =
+    keys.minByOrNull { it.x }!!.x to keys.maxByOrNull { it.x }!!.x
+

day17/src/main/kotlin/de/havox_design/aoc2023/day17/Day17.kt

@@ -1,12 +1,77 @@
 package de.havox_design.aoc2023.day17
 
+import java.util.*
+import kotlin.Comparator
+
 class Day17(private var filename: String) {
     fun solvePart1(): Long =
-        102L
+        parseCoodinateMap()
+            .findPath()
 
     fun solvePart2(): Long =
         0L
 
+    private fun Map<Coordinate, Int>.findPath(
+        maxConsecutive: Int = 3, minConsecutive: Int = 0, minMovedForEnd: Int = 0
+    ): Long {
+        val xRange = xRange()
+            .let { (a, b) -> a..b }
+        val yRange = yRange()
+            .let { (a, b) -> a..b }
+        val target = Coordinate(xRange.last, yRange.last)
+        val queue = priorityQueueOf(
+            Comparator.comparing { -manhattanDistance(it.first.location, target) },
+            History(FourDirectionFlipped.RIGHT, origin, 0) to 0L
+        )
+        val visited = mutableMapOf<History, Long>()
+        var min = Long.MAX_VALUE
+
+        while (queue.isNotEmpty()) {
+            val (history, loss) = queue.poll()
+
+            when {
+                loss > (visited[history] ?: Long.MAX_VALUE) -> continue
+            }
+            when {
+                history.location == target && history.count >= minMovedForEnd -> {
+                    min = min.coerceAtMost(loss)
+                    continue
+                }
+            }
+
+            history
+                .moveDirections(maxConsecutive, minConsecutive)
+                .asSequence()
+                .filter { it.location.x in xRange && it.location.y in yRange }
+                .map { it to loss + get(it.location)!! }
+                .filter { it.second < (visited[it.first] ?: Long.MAX_VALUE) }
+                .onEach { visited[it.first] = it.second }
+                .toCollection(queue)
+        }
+
+        return min
+
+    }
+
+    fun <T> priorityQueueOf(comparator: Comparator<T>, vararg args: T): PriorityQueue<T> {
+        val queue = PriorityQueue<T>(comparator)
+        queue.addAll(args)
+
+        return queue
+    }
+
+    private fun parseCoodinateMap(): Map<Coordinate, Int> =
+        getResourceAsText(filename)
+            .flatMapIndexed { rowNumber, row ->
+                row.mapIndexed { columnNumber, char ->
+                    Coordinate(columnNumber, rowNumber) to char.toIntValue()
+                }
+            }
+            .toMap()
+
     private fun getResourceAsText(path: String): List<String> =
         this.javaClass.classLoader.getResourceAsStream(path)!!.bufferedReader().readLines()
+
+    private fun Char.toIntValue() =
+        code - '0'.code
 }

day17/src/main/kotlin/de/havox_design/aoc2023/day17/FourDirectionsFlipped.kt

@@ -0,0 +1,32 @@
+package de.havox_design.aoc2023.day17
+
+enum class FourDirectionFlipped(private val direction: Coordinate) {
+    DOWN(Coordinate(0, 1)),
+    UP(Coordinate(0, -1)),
+    LEFT(Coordinate(-1, 0)),
+    RIGHT(Coordinate(1, 0));
+
+    operator fun plus(other: Coordinate) =
+        direction + other
+
+    fun turnLeft() = when (this) {
+        UP -> LEFT
+        LEFT -> DOWN
+        DOWN -> RIGHT
+        RIGHT -> UP
+    }
+
+    fun turnRight() = when (this) {
+        UP -> RIGHT
+        RIGHT -> DOWN
+        DOWN -> LEFT
+        LEFT -> UP
+    }
+
+    fun turnAround() = when (this) {
+        UP -> DOWN
+        DOWN -> UP
+        LEFT -> RIGHT
+        RIGHT -> LEFT
+    }
+}

day17/src/main/kotlin/de/havox_design/aoc2023/day17/History.kt

@@ -0,0 +1,33 @@
+package de.havox_design.aoc2023.day17
+
+data class History(
+    val lastDirection: FourDirectionFlipped, val location: Coordinate, val count: Int
+) {
+    @SuppressWarnings("kotlin:S6510")
+    fun moveDirections(maxConsecutive: Int, minConsecutive: Int): List<History> {
+        when (count) {
+            0 -> {
+                return listOf(FourDirectionFlipped.RIGHT, FourDirectionFlipped.DOWN)
+                    .map { History(it, it + location, 1) }
+            }
+            else -> {
+                val leftRight =
+                    listOf(lastDirection.turnLeft(), lastDirection.turnRight())
+                        .map { History(it, it + location, 1) }
+                val forward = History(lastDirection, lastDirection + location, count + 1)
+
+                return when {
+                    count < minConsecutive -> {
+                        listOf(forward)
+                    }
+
+                    count == maxConsecutive -> {
+                        leftRight
+                    }
+
+                    else -> leftRight + forward
+                }
+            }
+        }
+    }
+}