Year 2017 Day 10

Author: maneatingape

README.md

@@ -249,6 +249,7 @@ pie
 | 7 | [Recursive Circus](https://adventofcode.com/2017/day/7) | [Source](src/year2017/day07.rs) | 85 |
 | 8 | [I Heard You Like Registers](https://adventofcode.com/2017/day/8) | [Source](src/year2017/day08.rs) | 46 |
 | 9 | [Stream Processing](https://adventofcode.com/2017/day/9) | [Source](src/year2017/day09.rs) | 13 |
+| 10 | [Knot Hash](https://adventofcode.com/2017/day/10) | [Source](src/year2017/day10.rs) | 112 |
 
 ## 2016
 

benches/benchmark.rs

@@ -101,6 +101,7 @@ mod year2017 {
     benchmark!(year2017, day07);
     benchmark!(year2017, day08);
     benchmark!(year2017, day09);
+    benchmark!(year2017, day10);
 }
 
 mod year2019 {

input/year2017/day10.txt

@@ -0,0 +1 @@
+14,58,0,116,179,16,1,104,2,254,167,86,255,55,122,244

src/lib.rs

@@ -90,6 +90,7 @@ pub mod year2017 {
     pub mod day07;
     pub mod day08;
     pub mod day09;
+    pub mod day10;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/main.rs

@@ -151,6 +151,7 @@ fn year2017() -> Vec<Solution> {
         solution!(year2017, day07),
         solution!(year2017, day08),
         solution!(year2017, day09),
+        solution!(year2017, day10),
     ]
 }
 

src/year2017/day10.rs

@@ -0,0 +1,55 @@
+//! # Knot Hash
+//!
+//! Instead of reversing elements from the starting position then trying to handle wrap around,
+//! its easier use [`rotate_left`] to rotate the array by the same amount so that the starting
+//! position is always zero, then take advantage of the built in [`reverse`] method.
+//!
+//! [`rotate_left`]: slice::rotate_left
+//! [`reverse`]: slice::reverse
+use crate::util::parse::*;
+use std::fmt::Write;
+
+pub fn parse(input: &str) -> &str {
+    input
+}
+
+pub fn part1(input: &str) -> u32 {
+    let lengths: Vec<_> = input.iter_unsigned().collect();
+    let knot = hash(&lengths, 1);
+    knot.iter().take(2).product()
+}
+
+pub fn part2(input: &str) -> String {
+    let mut lengths: Vec<_> = input.trim().bytes().map(|b| b as usize).collect();
+    lengths.extend([17, 31, 73, 47, 23]);
+
+    let knot = hash(&lengths, 64);
+    let mut result = String::new();
+
+    for chunk in knot.chunks_exact(16) {
+        let reduced = chunk.iter().fold(0, |acc, n| acc ^ n);
+        let _ = write!(&mut result, "{reduced:02x}");
+    }
+
+    result
+}
+
+fn hash(lengths: &[usize], rounds: usize) -> Vec<u32> {
+    let mut knot: Vec<_> = (0..256).collect();
+    let mut position = 0;
+    let mut skip = 0;
+
+    for _ in 0..rounds {
+        for &length in lengths {
+            let next = length + skip;
+            knot[0..length].reverse();
+            knot.rotate_left(next % 256);
+            position += next;
+            skip += 1;
+        }
+    }
+
+    // Rotate the array the other direction so that the original starting position is restored.
+    knot.rotate_right(position % 256);
+    knot
+}

tests/test.rs

@@ -94,6 +94,7 @@ mod year2017 {
     mod day07_test;
     mod day08_test;
     mod day09_test;
+    mod day10_test;
 }
 
 mod year2019 {

tests/year2017/day10_test.rs

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