AdventOfCode2024 in Kotlin

Day01Part1.kt

import kotlin.math.abs

fun solve(input: String): Int {
    val firstList: MutableList<Int> = mutableListOf()
    val secondList: MutableList<Int> = mutableListOf()
    var result = 0

    for (line in input.lines()) {
        val components = line.split(" ").filter { it != "" }.map { it.toInt() }
        firstList.add(components[0])
        secondList.add(components[1])
    }

    firstList.sort()
    secondList.sort()

    for (index in 0 ..< firstList.count()) {
        result += abs(firstList[index] - secondList[index])
    }

    return result
}

Day 1 Part 2:

fun solve(input: String): Int {
    val lists = createLists(input)

    return lists.firstList.fold(0) { acum, number ->
        acum + number.similarityScore(list = lists.secondList)
    }
}

data class Lists(val firstList: List<Int>, val secondList: List<Int>)

fun createLists(input: String): Lists {
    val firstList: MutableList<Int> = mutableListOf()
    val secondList: MutableList<Int> = mutableListOf()

    for (line in input.lines()) {
        val components = line.split(" ").filter { it != "" }.map { it.toInt() }
        firstList.add(components[0])
        secondList.add(components[1])
    }

    return Lists(firstList, secondList)
}

fun Int.similarityScore(list: List<Int>) = this * list.filter { it == this }.count()

Day 2 Part 2

import kotlin.math.abs

fun solve(input: String): Int {
    return input.lines()
        .count { it.isSafe }
}

solve(input = challengeInput())

enum class LevelsTrend {
    DESCENDING,
    ASCENDING,
    EQUAL
}

fun Int.isSafe(previousLevel: Int, trend: LevelsTrend? = null): Boolean {
    val differenceIsCorrect = abs(this - previousLevel) in 1 .. 3
    if (trend == null) {
        return differenceIsCorrect
    }
    val trendIsCorrect = when(trend) {
        LevelsTrend.DESCENDING -> this < previousLevel
        LevelsTrend.ASCENDING -> this > previousLevel
        LevelsTrend.EQUAL -> false
    }
    return differenceIsCorrect && trendIsCorrect
}

fun getTrend(lastLevel: Int, currentLevel: Int) = when {
    currentLevel > lastLevel -> LevelsTrend.ASCENDING
    currentLevel < lastLevel -> LevelsTrend.DESCENDING
    else -> LevelsTrend.EQUAL
}

val String.isSafe: Boolean
    get() {
        val levels = this.split(" ").map { it.toInt() }

        if (isSafe(levels)) {
            return true
        } else {
            for (index in 0 ..< levels.count()) {
                val levelsCopy = levels.toMutableList()
                levelsCopy.removeAt(index)
                if (isSafe(levelsCopy)) {
                    return true
                }
            }
        }

        return false
    }

fun isSafe(levels: List<Int>): Boolean {
    var lastLevel: Int? = null
    var trend: LevelsTrend? = null
    for (level in levels) {
        if (lastLevel != null && trend != null) {
            if (!level.isSafe(previousLevel = lastLevel!!, trend = trend)) {
                return false
            }
            trend = getTrend(lastLevel = lastLevel!!, currentLevel = level)
        } else if (lastLevel != null) {
            trend = getTrend(lastLevel = lastLevel!!, currentLevel = level)
            if (!level.isSafe(previousLevel = lastLevel!!, trend = trend)) {
                return false
            }
        }
        lastLevel = level
    }

    return true
}