Year 2017 Day 17

Author: maneatingape

README.md

@@ -252,6 +252,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 14 | [Disk Defragmentation](https://adventofcode.com/2017/day/14) | [Source](src/year2017/day14.rs) | 422 |
 | 15 | [Dueling Generators](https://adventofcode.com/2017/day/15) | [Source](src/year2017/day15.rs) | 425000 |
 | 16 | [Permutation Promenade](https://adventofcode.com/2017/day/16) | [Source](src/year2017/day16.rs) | 66 |
+| 17 | [Spinlock](https://adventofcode.com/2017/day/17) | [Source](src/year2017/day17.rs) | 84 |
 
 ## 2016
 

benches/benchmark.rs

@@ -117,6 +117,7 @@ mod year2017 {
     benchmark!(year2017, day14);
     benchmark!(year2017, day15);
     benchmark!(year2017, day16);
+    benchmark!(year2017, day17);
 }
 
 mod year2019 {

src/lib.rs

@@ -99,6 +99,7 @@ pub mod year2017 {
     pub mod day14;
     pub mod day15;
     pub mod day16;
+    pub mod day17;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/main.rs

@@ -164,6 +164,7 @@ fn year2017() -> Vec<Solution> {
         solution!(year2017, day14),
         solution!(year2017, day15),
         solution!(year2017, day16),
+        solution!(year2017, day17),
     ]
 }
 

src/year2017/day17.rs

@@ -0,0 +1,52 @@
+//! # Spinlock
+//!
+//! There are two insights that speed up part two.
+//!
+//! The first is that we don't need a buffer. We only need to preserve the last value inserted
+//! whenever the index becomes zero. Once 50 million values have been inserted then this value
+//! is the final result.
+//!
+//! The second trick is realizing that we can insert multiple values at a time before the index
+//! wraps around. For example if the index is 1, the current value 10,000 and the step 300,
+//! then we can insert 34 values at once. The [`div_ceil`] method is perfect for this computation.
+//!
+//! This reduces the number of loops needed to approximately √50000000 = 7071.
+//!
+//! [`div_ceil`]: usize::div_ceil
+use crate::util::parse::*;
+
+pub fn parse(input: &str) -> usize {
+    input.unsigned()
+}
+
+pub fn part1(input: &usize) -> u16 {
+    let step = input + 1;
+    let mut index = 0;
+    let mut buffer = vec![0];
+
+    for n in 0..2017 {
+        index = (index + step) % buffer.len();
+        buffer.insert(index, n + 1);
+    }
+
+    buffer[(index + 1) % buffer.len()]
+}
+
+pub fn part2(input: &usize) -> usize {
+    let step = input + 1;
+    let mut n: usize = 1;
+    let mut index = 0;
+    let mut result = 0;
+
+    while n <= 50_000_000 {
+        if index == 0 {
+            result = n;
+        }
+
+        let skip = (n - index).div_ceil(step);
+        n += skip;
+        index = (index + skip * step) % n;
+    }
+
+    result
+}

tests/test.rs

@@ -101,6 +101,7 @@ mod year2017 {
     mod day14_test;
     mod day15_test;
     mod day16_test;
+    mod day17_test;
 }
 
 mod year2019 {

tests/year2017/day17_test.rs

@@ -0,0 +1,15 @@
+use aoc::year2017::day17::*;
+
+const EXAMPLE: &str = "3";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 638);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 1222153);
+}