@Joris PZ Super subjective of course but I felt that

metaSum()

and

value()

aren't really behaviors _ of_

Node

but more like operations on them.

I'm happy with this and can explain it to people. Tail recursive would just make it more confusing.

And of course it figures that now I'm back home and have all day, we get one that I finish in a few minutes. I really could have used this yesterday or the day before. Next Friday we're moving, so of course that will be a hard one too. ha.

ooh, nice one, intellij. I had a

.map {}.filterNotNull()

and it converted it to a

.mapNotNull

for me.

reading back over the other day 8 solutions

Array(childCount) { parseNode(tape) }

ah, using the array initializer, I forgot about that one. I ended up with

(1..childCount).map { parseNode(tape) }

and I felt a little weird about that use of range.

tailrec.kt

In the tailrec version the recursive call is in the “tail” position, because it’s the last thing the function does before returning. All the calls are tail recursive

Day_8_Part_1__Zero_allocation_edition.kt

1.79ms on my hardware

so that reminds me of something I've been wondering during these. It doesn't matter for this data set, where the words are only one or two characters long, but is there some sort of buffer view where you do

word = input.get(start = 7, length=5)

that returns without copying?

Everything I tried to speed up my impl only made it slower. Then I realized I had low battery on my laptop. CPU was throttled.

yes that helps too, add more voltage

Spent over an hour debugging Day 9 because

currentPlayer = (currentPlayer++) % numPlayers

does not do what I intended it to do.... And IDEA even warned me!

Haha yeah it's postincrement for a reason simple smile

I'm really struggling with the lack of a LinkedList implementation in the common stdlib, to the point of considering writing my own

Really struggling with this task, looks deceptively easy but my pointer to current position is misbehaving 🙂

Another example between 25 and 1618 would have been nice 😛

Ordering of current marble is the Josephus problem

Finally the penny dropped, and Part 2 now finishes in a second instead of forever 🙂

IMHO, these are the best challenges, where part 2 forces you to reconsider part 1

My Day 9 solution in common code

I wrote my own queue today:

Untitled.kt

It runs in about 150ms now, the code I wrote for part one would have taken ~20 minutes.

This one was tough for me especially from the performance side. I managed to solve part A myself, but couldn't get pass the part B, so I took inspiration from @Joris PZ (big thanks) which really helped me. Originally I started with

mutableListOf<Marble>()

which would be probably impossible to solve it with in a reasonable time since the number of elements would go as up as 7M. So today I've learned that making one's own "linked elements" implementation could do a lot 🙂 . Thanks once again for the inspiration!

I tried to use the actual

LinkedList

at first, but that's a struggle since

ListIterator

is akwardly defined as:

Note that the remove() and set(Object) methods are not defined in terms of the cursor position; they are defined to operate on the last element returned by a call to next() or previous().

It looks like today is "write it yourself day"!

Works for me. Albeit with errors from the runtime and quite slow.

$ time ./build/bin/HelloWorld/main/release/executable/KotlinNative.kexe 
The maximum score was 3148209772
/opt/buildAgent/work/4d622a065c544371/runtime/src/main/cpp/Memory.cpp:1150: runtime assert: Memory leaks found
Command terminated by signal 6
24.29user 1.36system 0:26.38elapsed 97%CPU (0avgtext+0avgdata 528480maxresident)k
0inputs+0outputs (0major+540609minor)pagefaults 0swaps

no need for a list, you just need to know which the next marble is. https://github.com/gklijs/advent_of_code_2018/blob/master/Gerard/src/main/java/com/gklijs/adventofcode/day9/MarbleGame.java

Well that was fun. https://github.com/tginsberg/advent-2018-kotlin/blob/master/src/main/kotlin/com/ginsberg/advent2018/Day09.kt