Detroit Kotliners, unite 😄 ✋

[Spoilers] I'll be posting solutions here: https://github.com/stkent/AdventOfCode2017

Ah you can be invited to channels? Amazing, thanks.

[poorly written spoilers] would be interesting to get some feedback on how bad my Kotlin is at the moment - solved day 1 in a rush https://gist.github.com/CraicOverflow89/bbb15b69d82c22d0845380514a43d613 https://gist.github.com/CraicOverflow89/ece2fc083f39d2c63889156628ecd317

took a different approach to my solution, would appreciate if anyone could tell me if I’m doing anything in a particularly roundabout fashion: https://pastebin.com/DbdhPeK0

Take a look at my solution, put the filter in you

sumBy

using

if

.

Funny that @adam-mcneilly @Jan Vomlel and me used the same ugly char to int conversion. I was tricked by

toInt

initially, but learnt my lesson quickly.

@andyb d2 part 1 would be more concise by using

max

min

instead of folding. See my solution above.

for part2 you could use

flatMap

to cut down code. And it would also fail (same as mine, but not in @karelpeeters solution) if there would be number duplicates in a row.

I was disappointed how easy today was:

val simple = input.map {  it.split(" ") }
            .map { it.size to it.toSet() }
            .map { it.second.size == it.first }
            .count { it }

val advanced =  input.map { it.split(" ") }
            .map { it.size to it.map { it.toCharArray().toSet() }.toSet() }
            .map { it.second.size == it.first }
            .count { it }

Does anyone have a Private Leaderboard that I could join or alternatively would anyone be interested if we create one for Kotliners?

I'm quite happy with my solution now, except for the implementation of

leaf

🙂.

I got to use a

when

as the condition of an

if

, and finally found a use for anonymous local objects.

@karelpeeters Cool a local object! Totally forgot about those. I think I’ll force them into my day9.

Today was bit easy again when you use a reluctant regex modifier for the garbage.

@karelpeeters still, your amazing regex approach rulez da kotlin house today.

My solution is not so short, clean, nice as solutions with regular expressions, but it can be used for big data because it calculates everything during data reading. https://github.com/JanVomlel/advent2017/blob/master/src/Day9.kt

wow, I didn't know there was an example with swap. They probably didn't add it to the stdlib because it's so short to implement

Hmm looks like just converting to

fold

wouldn't work for me either @andyb.

Checking in after pushing code. I found this resource and read it, that really helped. https://www.redblobgames.com/grids/hexagons/

My solution to part two was a bit different, I stored off all the nodes I'd seen previously (because they'll only ever show up in one group) and it turned out about 6x faster. But I only really did it that way because I wanted to write about it.

Just had a look at @todd.ginsberg solution for yesterday, that use of the sequence() to provide lazy filtering is very neat. I will definitely have to use that pattern in future.

@andyb"// Assume timeout will only occur on Deadlock." indeed.

I tried combining them into one but I only managed to come up with ugly solutions, the dependency on the register value for part 1 always got in the way.

@dave08 Nope, it just hangs if I put a 0 in there

Well work and home got in the way yesterday but I finally finished and wrote it up late. I pre-calculated all the transforms as well and that saved a ton of time. Part 2 ran in 3.4s for me, so not terrible. I probably do a lot more slicing and dicing than I needed to. Splitting the grid was the hardest part for me but I eventually settled on two infix functions to split into rows and then groups of rows into columns and that was easier for me to comprehend. I won't post the code since it was yesterday but it's in my repo https://github.com/tginsberg/advent-2017-kotlin

I had so much fun with AoC this year. I'm sad it's over, but honestly I need a break. Solving, refactoring, and writing about each solution has become a lifestyle and I need to do other things. Still, I have a few good ideas for small projects and libraries out of this, so that's good. Any it was really fun coming here every day and seeing what you guys did and how you solved things!

Half way there... heh

Did some more from-the-hip testing, here are the durations of AoC 2017 Day 2 (both parts), when repeating the calculation ten times (in-process):

JVM:    76,  3,  3,  6,  4,  4,  3,  2,  1,  3 ms
JS:     34, 16,  7,  6,  6,  4,  4,  4,  7,  5 ms
Native: 15, 14, 15, 16, 14, 14, 13, 14, 13, 13 ms

I didn't expect Node to become faster over time, but apparently there's some runtime optimization going on there as well