I'm thinking about making

IntCode<T : Number>

. Need to refactor it for Day 7 anyway.

Now with Long support!

Turns out I think my Mark 1 computer was calculating write positions wrong this whole time.

OK, solve and wrote day 9. I ended up implementing a new computer that's much simpler than the old one I had.

Just got called out publicly on twitter for including the puzzle text on my blog. They don't like that. Bah

While converting my IntComputer to use coroutines. I finally located the bug

My solution for day 10 https://github.com/sustainablepace/Advent-of-Code-2019/blob/master/src/main/kotlin/advent_of_code/Day10.kt :kotlin-flag:

I'll post my code later (after work, when I can clean it up) but I'm pretty happy with it. I found a nice way to turn a

Collection<List<T>>

into a

List<T>

by doing round-robin (so,

[ [A, D], [B, E], [C] ]

becomes

[A, B, C, D, E]

) and used that for part 2.

My solution for Day 10. Still needs some polishing but works well 🙂 https://github.com/Rtchaik/AoC2019/blob/master/src/advent2019/day10/solution10.kt

Day 10. I'm pretty happy with how this turned out.

I've solved it, but man is it ugly.

I'm reasonably happy with my solution, took me a while to figure out why my letters were upside down. In my coordinate system positive Y is upwards, which is the reverse of what the IntCode computer uses. Also, I need to find a more elegant way than closing stdout to signal end of execution, the try-catch is an eyesore. Code is https://github.com/jorispz/aoc-2019/blob/master/src/commonMain/kotlin/day11/p11.kt

[Day 11]

So my solution came from the realization that if two asteroids supposedly visible from your origin asteroid occluded each other, the coordinate difference from the origin to these asteroids would just be a multiple of the other. For instance, if you have an asteroid 1 spot down and 2 spots over from the origin, it will occlude a point at 3 spots down and 6 spots over (because 1 * 3 = 3 and 2 * 3 = 6). Given this realization, you can effectively reduce all the differences in coordinates down to the smallest “multiple” or in linear algebra terms effectively an identity vector. You take the greatest common factor of the coordinate difference, then divide the x and y value of the difference by the GCF to get your “identity vector”. At that point all you need to do is come up with the distinct set of identity vectors!

Today’s part 2 is really hard. Anyone here managed to solve it yet? 🙂

I’ll admit going to reddit for hints on part 2. I’ve written a solution but I want to think about it some more because I’m not sure I’m happy with it.

Could I get some coroutine help, please? (sort of spoilers for part 2?)

Here's mine: https://github.com/jorispz/aoc-2019/blob/master/src/commonMain/kotlin/day12/p12.kt Needed a small nudge for part 2. It was obvious we needed to look for cycles (the hints in the text were strong, and we have a few of these every year unfortunately), but it didn't occur to me to look the dimensions independently. The code is OK but nothing special.

Here's mine for the day. Kinda not great, but my head is killing me so I'm going to lie down. https://todd.ginsberg.com/post/advent-of-code/2019/day12/

Ok so I did the game, https://github.com/jakubgwozdz/AdventOfCode/blob/master/src/advent2019/day13/Day13.kt and it works, but I still have this feeling that I don't really understand channels in coroutines. main problem is that I wanted to create the lazy producer (ReceiveChannel) that is called a) only when it's

.receive()

is explicitly called and b) only after another channel (output from the Intcode) has been completely processed. I failed to do it, so instead I created a wrapper that does something like

override suspend fun receive(): BigInteger {
    while (!output.isEmpty) {
        val x = output.receive()
        // ... process x
    }
    return something
}

But I think I'm missing some point here and it could be more elegant

https://github.com/edgars-supe/advent-of-code/blob/master/src/main/kotlin/lv/esupe/aoc/year2019/Day13.kt That was fun.

My Day13, my coroutine/Channel IntCode implementation is holding up fairly well, though it requires a bit too much boilerplate right now to setup the channels etc. https://github.com/jorispz/aoc-2019/blob/master/src/commonMain/kotlin/day13/p13.kt I have somewhat lost interest in doing the performance measurements for JS and native, I'll do them at some point and update the README in Github then.

Does anyone here have an implementation for day 13 with graphical output? I was wondering how this could be done on the command line...

Day 13

My Day14: https://github.com/Rtchaik/AoC2019/blob/master/src/advent2019/day14/solution14.kt

Hey! I'm back after a while of having too much work and then being sick, so I have some catching up to do as well 🙂 Both of todays parts were begging to be solved with integer linear programming, but I managed to ignore that and bruteforce my way trough everything instead:

I got 27/8 today. Very happy about it.

My solution for Day15: https://github.com/Rtchaik/AoC2019/blob/master/src/advent2019/day15/solution15.kt

Day16: https://github.com/Rtchaik/AoC2019/blob/master/src/advent2019/day16/solution16.kt