Added 2017/16
This commit is contained in:
@@ -0,0 +1,92 @@
|
||||
## \-\-- Day 17: Spinlock \-\--
|
||||
|
||||
Suddenly, whirling in the distance, you notice what looks like a
|
||||
massive, [pixelated
|
||||
hurricane]{title="You know, as opposed to all those non-pixelated hurricanes you see on TV."}:
|
||||
a deadly [spinlock](https://en.wikipedia.org/wiki/Spinlock). This
|
||||
spinlock isn\'t just consuming computing power, but memory, too; vast,
|
||||
digital mountains are being ripped from the ground and consumed by the
|
||||
vortex.
|
||||
|
||||
If you don\'t move quickly, fixing that printer will be the least of
|
||||
your problems.
|
||||
|
||||
This spinlock\'s algorithm is simple but efficient, quickly consuming
|
||||
everything in its path. It starts with a circular buffer containing only
|
||||
the value `0`, which it marks as the *current position*. It then steps
|
||||
forward through the circular buffer some number of steps (your puzzle
|
||||
input) before inserting the first new value, `1`, after the value it
|
||||
stopped on. The inserted value becomes the *current position*. Then, it
|
||||
steps forward from there the same number of steps, and wherever it
|
||||
stops, inserts after it the second new value, `2`, and uses that as the
|
||||
new *current position* again.
|
||||
|
||||
It repeats this process of *stepping forward*, *inserting a new value*,
|
||||
and *using the location of the inserted value as the new current
|
||||
position* a total of `2017` times, inserting `2017` as its final
|
||||
operation, and ending with a total of `2018` values (including `0`) in
|
||||
the circular buffer.
|
||||
|
||||
For example, if the spinlock were to step `3` times per insert, the
|
||||
circular buffer would begin to evolve like this (using parentheses to
|
||||
mark the current position after each iteration of the algorithm):
|
||||
|
||||
- `(0)`, the initial state before any insertions.
|
||||
- `0 (1)`: the spinlock steps forward three times (`0`, `0`, `0`), and
|
||||
then inserts the first value, `1`, after it. `1` becomes the current
|
||||
position.
|
||||
- `0 (2) 1`: the spinlock steps forward three times (`0`, `1`, `0`),
|
||||
and then inserts the second value, `2`, after it. `2` becomes the
|
||||
current position.
|
||||
- `0 2 (3) 1`: the spinlock steps forward three times (`1`, `0`,
|
||||
`2`), and then inserts the third value, `3`, after it. `3` becomes
|
||||
the current position.
|
||||
|
||||
And so on:
|
||||
|
||||
- `0 2 (4) 3 1`
|
||||
- `0 (5) 2 4 3 1`
|
||||
- `0 5 2 4 3 (6) 1`
|
||||
- `0 5 (7) 2 4 3 6 1`
|
||||
- `0 5 7 2 4 3 (8) 6 1`
|
||||
- `0 (9) 5 7 2 4 3 8 6 1`
|
||||
|
||||
Eventually, after 2017 insertions, the section of the circular buffer
|
||||
near the last insertion looks like this:
|
||||
|
||||
1512 1134 151 (2017) 638 1513 851
|
||||
|
||||
Perhaps, if you can identify the value that will ultimately be *after*
|
||||
the last value written (`2017`), you can short-circuit the spinlock. In
|
||||
this example, that would be `638`.
|
||||
|
||||
*What is the value after `2017`* in your completed circular buffer?
|
||||
|
||||
Your puzzle answer was `725`.
|
||||
|
||||
## \-\-- Part Two \-\-- {#part2}
|
||||
|
||||
The spinlock does not short-circuit. Instead, it gets *more* angry. At
|
||||
least, you assume that\'s what happened; it\'s spinning significantly
|
||||
faster than it was a moment ago.
|
||||
|
||||
You have good news and bad news.
|
||||
|
||||
The good news is that you have improved calculations for how to stop the
|
||||
spinlock. They indicate that you actually need to identify *the value
|
||||
after `0`* in the current state of the circular buffer.
|
||||
|
||||
The bad news is that while you were determining this, the spinlock has
|
||||
just finished inserting its fifty millionth value (`50000000`).
|
||||
|
||||
*What is the value after `0`* the moment `50000000` is inserted?
|
||||
|
||||
Your puzzle answer was `27361412`.
|
||||
|
||||
Both parts of this puzzle are complete! They provide two gold stars:
|
||||
\*\*
|
||||
|
||||
At this point, you should [return to your Advent calendar](/2017) and
|
||||
try another puzzle.
|
||||
|
||||
Your puzzle input was `329`{.puzzle-input}.
|
||||
@@ -0,0 +1,77 @@
|
||||
#!/bin/python3
|
||||
import sys,re
|
||||
from pprint import pprint
|
||||
sys.path.insert(0, '../../')
|
||||
from fred import list2int
|
||||
|
||||
input_f = 'input'
|
||||
|
||||
part = 2
|
||||
#########################################
|
||||
# #
|
||||
# Part 1 #
|
||||
# #
|
||||
#########################################
|
||||
|
||||
if part == 1:
|
||||
jump = 0
|
||||
arr = [0]
|
||||
pos = 0
|
||||
with open(input_f) as file:
|
||||
jump = int(file.read().rstrip())
|
||||
|
||||
for i in range(1,2017+1):
|
||||
#print(arr)
|
||||
#print(len(arr),i)
|
||||
pos = (pos+jump)%len(arr)
|
||||
loc = (pos)+1
|
||||
#print(loc)
|
||||
pos += 1
|
||||
arr.insert(loc,i)
|
||||
#input()
|
||||
|
||||
f_pos = arr.index(2017)
|
||||
|
||||
|
||||
print(arr[f_pos-1],arr[f_pos],arr[f_pos+1])
|
||||
|
||||
|
||||
#########################################
|
||||
# #
|
||||
# Part 2 #
|
||||
# #
|
||||
#########################################
|
||||
if part == 2:
|
||||
jump = 0
|
||||
arr = [0]
|
||||
pos = 0
|
||||
loc = 0
|
||||
with open(input_f) as file:
|
||||
jump = int(file.read().rstrip())
|
||||
|
||||
prev = 0
|
||||
|
||||
for i in range(1,50000000+1):
|
||||
#print(arr)
|
||||
#print(len(arr),i)
|
||||
pos = (pos+jump)%i
|
||||
loc = (pos)+1
|
||||
#print(loc)
|
||||
pos += 1
|
||||
|
||||
#arr.insert(loc,i)
|
||||
#input()
|
||||
if i%1000000 == 0:
|
||||
print(i)
|
||||
|
||||
if pos == 1:
|
||||
#print('INSERT')
|
||||
prev = i
|
||||
#print(i-1)
|
||||
#print(pos,loc)
|
||||
print(prev)
|
||||
|
||||
#f_pos = arr.index(0)
|
||||
|
||||
|
||||
#print(arr[f_pos-1],arr[f_pos],arr[f_pos+1])
|
||||
Reference in New Issue
Block a user