Recursion, extension functions, and operators to the rescue! https://todd.ginsberg.com/post/advent-of-code/2018/day17/

My video visualization for Day 18 in thread (SPOILER)

First part was a variation on the "Game of life" and Part B I did with a little of math magic inspired by @andyb's thoughts from one of the previous days 🙂

So one of my bad habits is to read AoC at some point in the middle of the night if I happen to wake up. It comes out at 11pm, so I don’t compete. Anyway. I read today’s and thought “oh this is a game of life. I can do that” and went back to sleep. But then I had this dream where I solved yesterday’s water drop puzzle by inferring transform rules. I’m not going to do it but it sure is an interesting idea. Not sure if it is possible though.

Meh. I'm not a fan of the "reverse engineer this machine code" puzzles.

TWIMC: I’m hacking together a Gradle plugin with multiplatform benchmarks (JMH on the JVM, benchmark.js in node, something not yet decided in Native, if possible). Decided to test-drive it in smaller audience here (compared to #multiplatform). If you’re interested, send me your mpp project link to play with in the thread

Dammit, another map!!?! I wish I hadn't decided to put all my code in a single package, I'm running out of pseudonyms for grids and positions....

My video visualization of Day 20 in thread

Here's mine. I'll write it up later. I already had a

Point

class that I just reused.

class Day20(rawInput: String) {

    private val grid: Map<Point, Int> = parseGrid(rawInput)

    fun solvePart1(): Int =
        grid.maxBy { it.value }!!.value

    fun solvePart2(): Int =
        grid.count { it.value >= 1000 }


    private fun parseGrid(input: String): Map<Point, Int> {
        val grid = mutableMapOf(startingPoint to 0)
        val stack = ArrayDeque<Point>()
        var current = startingPoint
        input.forEach {
            when (it) {
                '(' -> stack.push(current)
                ')' -> current = stack.pop()
                '|' -> current = stack.peek()
                in movementRules -> {
                    // If we are moving to a spot we haven't seen before, we can
                    // record this as a new distance.
                    val nextDistance = grid.getValue(current) + 1
                    current = movementRules.getValue(it).invoke(current)
                    if (current !in grid) grid[current] = nextDistance
                }
            }
        }
        return grid
    }

    companion object {
        private val startingPoint = Point(0, 0)
        private val movementRules = mapOf(
            'N' to Point::up,
            'S' to Point::down,
            'E' to Point::right,
            'W' to Point::left
        )
    }
}

@SiebelsTim @todd.ginsberg Why should that input return

4

? The question is

How many rooms have a shortest path from your current location that pass through at least 1000 doors?

Integer underflow in time itself you say.

A bit disappointed with Day 20 of AoC. The Stack + Dynamic Programming approach to parse the Path only works if you assume that each subpath returns the branch point, that sounds like a massive assumption to me. I spent ages attempting to parse the path using a recursive descent parser to generate the maze (& still failed 😭). Day 21 is back to Elf Assembly Language & the problem statement seems a bit vague which has not really lightened my mood.

My solutions for Day 21: https://github.com/Rtchaik/AoC2018/blob/master/src/advent2018/day21/solution21.kt https://github.com/Rtchaik/AoC2018/blob/master/src/advent2018/day21/solution21manual.kt First I did Day 21 manually and later I've understood that it could be made programmatically with minor modification of Day 19 ☹️

I simply ran the program until it hits the instruction with register 0 and look into register 3. Part 2 runs the program until it hits a cycle at that instruction. Most code is from day 19

I have an off by one in my data, but the example is fine. Earlier I had 43 in the example, since I didn't use the different geologic index to calculate the points 'behind' it.

Took a while to make the solution finish under a second, including a whole new debugging phase. But I'm reasonably happy with the code: https://github.com/jorispz/aoc-2018/blob/master/src/commonMain/kotlin/P22.kt Times (first/best of 25): JVM

1036/159 ms

, JS

1876/1058 ms

. Native did not finish with exit code -1073741819, which seems to be some sort of access violation

Nope that hasn't fixed it 😞. Something slightly off in my logic

What do you need to represent?

Surely somebody collects all of the AoC inputs and the answers. Anybody know where to find that?

I am also one of lucky ones that got right answer by relying on data being "good" ( https://www.reddit.com/r/adventofcode/comments/a8s17l/2018_day_23_solutions/ecdbr1i ). Would be interesting to get some input that fails to produce correct answer.

Today was pretty cool, a bit similar to day 15 but without a grid. I got a lot of use out of

sortedBy

,

sumBy

,

filter

,

maxWith

,

takeIf

etc! (spoiler in thread)

Eh. I caught the fact that fights can end in ties but I can't get the answer to part 2. Seems like WAY lower boost than the example data.

Day 25 is extremely easy. https://github.com/Rtchaik/AoC2018/blob/master/src/advent2018/day25/solution25.kt So we did it! 🙂 Merry Christmas!

📣 Please post your repos in this thread so we can collect them and analyse 🙂 If you don’t mind…

I love all of the things people do with the puzzles after it’s all over. Amazing.

2^5 days!

Plus my daughter is home from college (yay!) so we will probably have extra plans in there, whereas December last year was just another month.

I'm very proud that my company is formally sponsoring AoC this year! It's been a lot of fun participating with colleagues on a private leaderboard, so it's good we get to do something in return. Not sure if I'm gonna do Kotlin again this year. On the one hand it's a nice chance to try something new, on the other hand writing Kotlin is just so enjoyable... 🙂

I feel like this countdown is getting faster somehow.

Less then 2^64 hours