Kotlin:

    
import kotlin.math.abs
import kotlin.math.sign

data class Report(val levels: List<Int>) {
    fun isSafe(withProblemDampener: Boolean): Boolean {
        var orderSign = 0.0f  // - 1 is descending; +1 is ascending

        levels.zipWithNext().forEachIndexed { index, level ->
            val difference = (level.second - level.first).toFloat()
            if (orderSign == 0.0f) orderSign = sign(difference)
            if (sign(difference) != orderSign || abs(difference) !in 1.0..3.0) {
                // With problem dampener: Drop either element in the pair or the first element from the original list and check if the result is now safe.
                return if (withProblemDampener) {
                    Report(levels.drop(1)).isSafe(false) || Report(levels.withoutElementAt(index)).isSafe(false) || Report(levels.withoutElementAt(index + 1)).isSafe(false)
                }  else false
            }
        }

        return true
    }
}

fun main() {
    fun part1(input: List<String>): Int = input.map { Report(it.split(" ").map { it.toInt() }).isSafe(false) }.count { it }

    fun part2(input: List<String>): Int = input.map { Report(it.split(" ").map { it.toInt() }).isSafe(true) }.count { it }

    // Or read a large test input from the `src/Day01_test.txt` file:
    val testInput = readInput("Day02_test")
    check(part1(testInput) == 2)
    check(part2(testInput) == 4)

    // Read the input from the `src/Day01.txt` file.
    val input = readInput("Day02")
    part1(input).println()
    part2(input).println()
}


  

The Report#isSafe method essentially solves both parts.

I've had a bit of a trip up in part 2:

I initially only checked, if the report was safe, if either elements in the pair were to be removed. But in the edge case, that the first pair has different monotonic behaviour than the rest, the issue would only be detected by the second pair with indices (2, 3), whilst removing the first element in the list would yield a safe report.

Quite the interesting language choice. It's so clean. I love it!

I have another Kotlin (albeit similar) solution:

    
import kotlin.math.abs

fun main() {

    fun getLists(input: List<String>): Pair<List<Int>, List<Int>> {
        val unsortedPairs = input.map {
            it.split("   ").map { it.toInt() }
        }

        val listA = unsortedPairs.map { it.first() }
        val listB = unsortedPairs.map { it.last() }
        return Pair(listA, listB)
    }

    fun part1(input: List<String>): Int {
        val (listA, listB) = getLists(input)

        return listA.sorted().zip(listB.sorted()).sumOf { abs(it.first - it.second) }
    }

    fun part2(input: List<String>): Int {
        val (listA, listB) = getLists(input)

        return listA.sumOf { number ->
            number * listB.count { it == number }
        }
    }

    // Or read a large test input from the `src/Day01_test.txt` file:
    val testInput = readInput("Day01_test")
    check(part1(testInput) == 11)
    check(part2(testInput) == 31)

    // Read the input from the `src/Day01.txt` file.
    val input = readInput("Day01")
    part1(input).println()
    part2(input).println()
}


  

It's a bit more compact. (If you take out the part that actually calls the functions on the (test-)input.)

My „comfort language“ Kotlin and Python, because I really got to refamiliarize myself with that language. I probably won‘t have the time to do much more than that, but if I do, I‘d love to try to solve the problems with a Minecraft datapack.

Oh, trust me, he‘s quite the troublemaker. Not for us, but he‘s often fighting with cats in the neighbourhood. He‘s not that smart though… Maybe Scar would‘ve been a better name.

:O another Loki!

One can either be cynical about it and don‘t help others ever, because they can‘t expect it to ever be reciprocated by the ones you help or others, or they can help for the sake of helping.

The former can make one more cold and isolated, whilst the later, even if they enjoy the act of helping others just by itself, can burn one out.

My approach to this is trying to be helpful by default, but setting and communicating limits. In finding a healthy balance lies the art, as with so many other things in life.

Alwaysonemorethanyoushadowing

An extremely valid reaction.

Ich habe ein Repo und ein Gist, die jeweils einen Stern von jemanden haben, der/die nicht ich selbst ist.

Das ist mein ganzer Stolz.

Die Aussage des Transparents ist: Faschisten behaupten Anti-Faschisten zu sein.

Unter der Annahme, dass die AfD gegen Faschismus ist, folgt per Definition, dass sie antifaschistisch ist. Laut der Aussage ist die AfD also faschistisch, was aber einen Widerspruch darstellt.

Insgesamt muss die Aussage nicht allgemeingültig sein, die AfD ist nicht gegen den Faschismus oder beides. (Ich tippe da ja mal auf Letzteres.)

… Aber mit Logik braucht man da sowieso nicht anfangen und ich habe mir viel zu viel Mühe mit diesem Kommentar gegeben.

Don‘t worry!

Gibt es eigentlich eine Gemeinschaft für diese „Deutschland - Die Versammlung“ Karten?

More like „not safe from Wario“, am I right?

Ich, der die letzten 4 Ziffern von π nimmt.

Dann pfostiere, was du sehen willst. Sei die Veränderung, die du wünscht.

This one. Let them know, what they‘re up against.

SPRICH

Oh hey, just like in Soma.

Edit: Link broke… https://en.wikipedia.org/wiki/Soma_(video_game)?wprov=sfti1

:O This is THE shitpost.