## Advent of Code 2016 Day 19

## Part 1

- Going in circles, again!
- This is making my head spin!
- Writing an algorithm that works on my examples
- A pattern emerges!
- Simulating the pattern with an algorithm

### Going in circles, again!

- The example is wonderfully explanatory
- My puzzle input is an integer over 3M
- I want to explore more example circle sizes before writing an algorithm
- Because I anticipate a pattern emerging

### This is making my head spin!

Good news:

- I now have several unit tests
- I feel comfortable writing a brute-force algorithm that will definitely finish quickly on circles with up to 100K Elves probably

Bad news:

- I don't think I found a faithful pattern for identifying the winning Elf based on the number of Elves in the circle
- I'm not sure the brute-force algorithm I intend to write will work for circles with millions of Elves

### Writing an algorithm that works on my examples

```
For i from 1 to 20, inclusive
Create an array called circle of length i where each value is 1
Set pointer to 0
Set next to 0
Do as long as circle does not include i
Increment next, wrapping when appropriate
Continue incrementing next until the value in circle at next is not 0
Update the value in circle at pointer to the sum of the current value in circle at pointer and the current value in circle at next
Set the value in circle at next to 0
Increment next until the value in circle at next is not 0
Set pointer to the value stored in next
Log the number one greater than the location of i in circle
```

- I spent quite some time fiddling with this algorithm
- I was either forgetting to update
`next`

or incorrectly updating it - For a while, I was logging
`circle`

after each iteration of the inner`while`

loop to confirm whether it was working as intended - Thankfully, I eventually worked out all the kinks and got it to print the values I was expecting

### A pattern emerges!

I ran the loop above for Elven circles up to 99 in size.

This animation shows circles up to 26, which is enough to demonstrate the pattern:

- I was almost certain there would be a pattern!
- Unsurprisingly, I missed it by skipping 6-9, 11-14, and 16-19 in my initial GIF
- Now that I see and understand it, I need to re-create it with a different algorithm!

### Simulating the pattern with an algorithm

```
Set circle to 0
Set multiple to 1
Set answer to null
Do as long as circle is less than the puzzle input
Set winner to -1
For i from 1 up to and including multiple
Increment winner by 2
Increment circle by 1
If circle is the puzzle input
Set answer to winner
Double multiple
```

- This also took some fiddling to get right
- At first I had two
`for`

loops, then realized I didn't need both - The outer loop condition causes this algorithm to overextend itself a bit, unfortunately
- And I'm not sure how to achieve the same result without starting
`winner`

at a value two less than my first desired value of`1`

, since I increment it by`2`

each time

Regardless, this algorithm terminates near-instantly!

And it generates the correct answer for every example and my puzzle input!

That's wonderful, especially since my brute-force algorithm outlined earlier seemingly never finishes when run on my 3M+ puzzle input number!

## Part 2

- Ugh, more example GIFs
- Writing the algorithm that I animated
- A pattern emerges again!
- Simulating the pattern with a similar algorithm

### Ugh, more example GIFs

- Seeing a 5-Elf circle demonstrated is nice
- But I need to find another pattern
- So, I need to play out at least circle sizes 1-10

It took a long time, but it helped prepare me to write the algorithm...I hope:

Sadly, `10`

circles isn't enough to reveal a pattern:

### Writing the algorithm that I animated

```
For i from 1 to 10, inclusive
Create an array called circle of length i where each value is one greater than its index
Set pointer to 0
Do until circle contains one item
Set removed as the remainder resulting from:
The sum of pointer and the length of circle divided by two, rounded down to the nearest whole number
Divided by the length of circle
Delete the item at the location stored in removed
Update pointer based on the value of removed
If removed is less than pointer
Set pointer to the remainder after dividing pointer by the length of circle
Else
Set pointer to the remainder after dividing one greater than pointer by the length of circle
Log the single value remaining in circle
```

- I had the most trouble fiddling with updating
`pointer`

correctly - Thankfully, this algorithm generated the same winners as in my animation, so I could trust my work and the computer's!
- Next, I ran it on numbers up to 100
- I was delighted by what I saw!

### A pattern emerges again!

I ran the loop above for Elven circles up to 99 in size.

This animation shows circles up to 28, which is enough to demonstrate the pattern:

- I was almost certain there would be a similar pattern!
- Unsurprisingly, I couldn't see it clearly with just 10 circles
- Now that I see and understand it, I need to re-create it with a similar algorithm!

### Simulating the pattern with a similar algorithm

```
Set circle to 1
Set multiple to 3
Set answer to null
Do as long as circle is less than the puzzle input
Set winner to 0
Set counter to 1
Do as long as counter is less than or equal to multiple
If counter is less than or equal to multiple divided by 3
Increment counter by 1
Increment winner by 1
Else
Increment counter by 2
Increment winner by 2
Increment circle by 1
If circle is the puzzle input
Set answer to winner
Triple multiple
```

- This also took some fiddling to get right
- I had a lot of trial and error getting counter to increment the correct amount based on the condition
- And I still don't know how to start this algorithm from a circle of size 1 - my divide by 3 rule makes that impossible

Regardless, this algorithm terminates near-instantly, too!

And it generates the correct answer for every example and my puzzle input!

## I did it!!

- I solved both parts!
- Through a journey of animation, brute-force algorithm as pattern-identification, then number-processing algorithm for a near-instant answer!
- I made so many slides as part of several GIFs!
- And I'm glad I did, as it helped me understand the many algorithms I would have to write!

This may be my favorite puzzle of all of Advent of Code thus far!

With the exception of building a simulator - which I can't reliably use to visualize a circle with over 3 million Elves - I got to use all of my design and developer skills to solve it...and I succeeded!

Who knew circular data structures could be this fun?

## Top comments (0)