Year 2016 Day 25

Author: maneatingape

README.md

@@ -267,6 +267,7 @@ pie
 | 22 | [Grid Computing](https://adventofcode.com/2016/day/22) | [Source](src/year2016/day22.rs) | 31 |
 | 23 | [Safe Cracking](https://adventofcode.com/2016/day/23) | [Source](src/year2016/day23.rs) | 1 |
 | 24 | [Air Duct Spelunking](https://adventofcode.com/2016/day/24) | [Source](src/year2016/day24.rs) | 335 |
+| 25 | [Clock Signal](https://adventofcode.com/2016/day/25) | [Source](src/year2016/day25.rs) | 1 |
 
 ## 2015
 

benches/benchmark.rs

@@ -88,6 +88,7 @@ mod year2016 {
     benchmark!(year2016, day22);
     benchmark!(year2016, day23);
     benchmark!(year2016, day24);
+    benchmark!(year2016, day25);
 }
 
 mod year2019 {

input/year2016/day25.txt

@@ -0,0 +1,30 @@
+cpy a d
+cpy 4 c
+cpy 633 b
+inc d
+dec b
+jnz b -2
+dec c
+jnz c -5
+cpy d a
+jnz 0 0
+cpy a b
+cpy 0 a
+cpy 2 c
+jnz b 2
+jnz 1 6
+dec b
+dec c
+jnz c -4
+inc a
+jnz 1 -7
+cpy 2 b
+jnz c 2
+jnz 1 4
+dec b
+dec c
+jnz 1 -4
+jnz 0 0
+out b
+jnz a -19
+jnz 1 -21

src/lib.rs

@@ -215,6 +215,7 @@ pub mod year2016 {
     pub mod day22;
     pub mod day23;
     pub mod day24;
+    pub mod day25;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/main.rs

@@ -126,6 +126,7 @@ fn all_solutions() -> Vec<Solution> {
         solution!(year2016, day22),
         solution!(year2016, day23),
         solution!(year2016, day24),
+        solution!(year2016, day25),
         // 2019
         solution!(year2019, day01),
         solution!(year2019, day02),

src/year2016/day25.rs

@@ -0,0 +1,41 @@
+//! # Clock Signal
+//!
+//! Like [`Day 12`] and [`Day 23`] this problem is all about *reading* code not writing code.
+//!
+//! Reverse engineering the code shows that it takes the initial value of `a` then adds
+//! two constants multiplied by each other to create a seed.
+//!
+//! This seed is then repeatedly bit shifted right by dividing by 2 using an inefficient linear
+//! time loop. The remainder (the bit that drops off) is the output. This means that output
+//! sequence is simply the binary digits of `a + offset` in reverse repeated over and over.
+//!
+//! To obtain the desired pattern we need the next highest binary number that has the
+//! pattern `101010..`.
+//!
+//! [`Day 12`]: crate::year2016::day12
+//! [`Day 23`]: crate::year2016::day23
+use crate::util::parse::*;
+
+/// Extract the constant offset from the assembunny code.
+pub fn parse(input: &str) -> u32 {
+    let lines: Vec<_> = input.lines().collect();
+    let first: u32 = lines[1].unsigned();
+    let second: u32 = lines[2].unsigned();
+    first * second
+}
+
+pub fn part1(input: &u32) -> u32 {
+    let offset = *input;
+    let mut result = 0;
+
+    // Find the next number with binary pattern `101010..` greater than the input.
+    while result < offset {
+        result = (result << 2) | 2;
+    }
+
+    result - offset
+}
+
+pub fn part2(_input: &u32) -> &'static str {
+    "n/a"
+}

tests/test.rs

@@ -81,6 +81,7 @@ mod year2016 {
     mod day22_test;
     mod day23_test;
     mod day24_test;
+    mod day25_test;
 }
 
 mod year2019 {

tests/year2016/day25_test.rs

@@ -0,0 +1,9 @@
+#[test]
+fn part1_test() {
+    // No example data
+}
+
+#[test]
+fn part2_test() {
+    // No example data
+}