Day 23 Notes
+--------+
| Part 1 |
+--------+
$ elixir day23part1.exs
59374826
Thoughts:
Need to represent a circle.
Use a combination of lists, and Stream.cycle to handle the wrap-around.
+--------+
| Part 2 |
+--------+
$ elixir day23part2.exs
Next two cups: 266262, 251174
Answer: 66878091588
Thoughts:
Considering the numbers involved (1M items, 10M iterations), the Part 1 solution with its
O(n) list operations is just not going to work. We need a solution that works in constant time.
How to represent the circle: we need a doubly-linked list with random access *in constant time*.
Two options I can think of: Erlang's :array, or :ets. :array's documentation doesn't say anything
about its performance and the arrays seem resizable, however :ets says it's constant time, so I
decided to use ETS.
Completely re-write the part 1 implementation. Represent the circle in ETS with the keys being the
cup label, and the values being a {prev, next} tuple.
Remove from the circle: Update the two new neighbours to point to each other.
Add to the circle: Update the four new neighbours (left & right extremities) to point to each
other.
Even after these efficiency improvements, this still takes 22 seconds on my machine >.<
+------------------+
| Overall Thoughts |
+------------------+
Interesting problem. Produced an elegant solution for Part 1 that simply wasn't scalable for Part
2. Part 2 required working around the beam's limitations of number-crunching a large dataset. ETS
kind of worked, but was still very slow, so this is obviously not scalable. I will be interested
to see if people came up with a solution that completes in less than a second (or even 10 seconds,
as per the guideline).
