Year 2018 Day 12

Author: maneatingape

README.md

@@ -248,6 +248,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 9 | [Marble Mania](https://adventofcode.com/2018/day/9) | [Source](src/year2018/day09.rs) | 980 |
 | 10 | [The Stars Align](https://adventofcode.com/2018/day/10) | [Source](src/year2018/day10.rs) | 12 |
 | 11 | [Chronal Charge](https://adventofcode.com/2018/day/11) | [Source](src/year2018/day11.rs) | 1552 |
+| 12 | [Subterranean Sustainability](https://adventofcode.com/2018/day/12) | [Source](src/year2018/day12.rs) | 75 |
 
 ## 2017
 

benches/benchmark.rs

@@ -140,6 +140,7 @@ mod year2018 {
     benchmark!(year2018, day09);
     benchmark!(year2018, day10);
     benchmark!(year2018, day11);
+    benchmark!(year2018, day12);
 }
 
 mod year2019 {

src/lib.rs

@@ -123,6 +123,7 @@ pub mod year2018 {
     pub mod day09;
     pub mod day10;
     pub mod day11;
+    pub mod day12;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/main.rs

@@ -190,6 +190,7 @@ fn year2018() -> Vec<Solution> {
         solution!(year2018, day09),
         solution!(year2018, day10),
         solution!(year2018, day11),
+        solution!(year2018, day12),
     ]
 }
 

src/year2018/day12.rs

@@ -0,0 +1,87 @@
+//! # Subterranean Sustainability
+//!
+//! The problem is a one dimensional version of
+//! [Conway's Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life).
+//!
+//! The trick for part two is that the plants will eventually stabilize into a repeating pattern
+//! that expands by the same amount each generation. Once 2 deltas between 3 subsequent
+//! generations are the same we extrapolate 50 billion generations into the future.
+use std::iter::repeat;
+
+pub struct Input {
+    rules: Vec<usize>,
+    state: Tunnel,
+}
+
+#[derive(Clone)]
+pub struct Tunnel {
+    plants: Vec<usize>,
+    start: i64,
+    sum: i64,
+}
+
+pub fn parse(input: &str) -> Input {
+    let lines: Vec<_> = input.lines().map(str::as_bytes).collect();
+    // Convert ASCII characters to `1` for a plant and `0` for an empty pot.
+    let plants: Vec<_> = lines[0][15..].iter().map(|b| (b & 1) as usize).collect();
+    // 5 plants gives 2⁵ = 32 possible combinations to consider.
+    let mut rules = vec![0; 32];
+
+    // Convert each pattern into an index for fast lookup. For example `..#.#` becomes 5.
+    for line in &lines[2..] {
+        let binary = line.iter().fold(0, |acc, b| (acc << 1) | (b & 1) as usize);
+        rules[binary >> 5] = binary & 1;
+    }
+
+    Input { rules, state: Tunnel { plants, start: 0, sum: 0 } }
+}
+
+pub fn part1(input: &Input) -> i64 {
+    let mut current = input.state.clone();
+
+    for _ in 0..20 {
+        current = step(&input.rules, &current);
+    }
+
+    current.sum
+}
+
+pub fn part2(input: &Input) -> i64 {
+    let mut current = input.state.clone();
+    let mut delta = 0;
+    let mut generations = 0;
+
+    loop {
+        let next = step(&input.rules, &current);
+        let next_delta = next.sum - current.sum;
+
+        // Two identical deltas indicates that the pattern has stabilized.
+        if delta == next_delta {
+            break current.sum + delta * (50_000_000_000 - generations);
+        }
+
+        current = next;
+        delta = next_delta;
+        generations += 1;
+    }
+}
+
+fn step(rules: &[usize], tunnel: &Tunnel) -> Tunnel {
+    let mut index = 0;
+    let mut sum = 0;
+    let mut position = tunnel.start - 2;
+    let mut plants = Vec::with_capacity(1_000);
+
+    // Add four extra empty pots to the end to make checking the last pattern easier.
+    for plant in tunnel.plants.iter().chain(repeat(&0).take(4)) {
+        index = ((index << 1) | plant) & 0b11111;
+
+        sum += position * rules[index] as i64;
+        position += 1;
+
+        plants.push(rules[index]);
+    }
+
+    // Tunnel expands by 2 pots at each end.
+    Tunnel { plants, start: tunnel.start - 2, sum }
+}

tests/test.rs

@@ -124,6 +124,7 @@ mod year2018 {
     mod day09_test;
     mod day10_test;
     mod day11_test;
+    mod day12_test;
 }
 
 mod year2019 {

tests/year2018/day12_test.rs

@@ -0,0 +1,31 @@
+use aoc::year2018::day12::*;
+
+const EXAMPLE: &str = "\
+initial state: #..#.#..##......###...###
+
+...## => #
+..#.. => #
+.#... => #
+.#.#. => #
+.#.## => #
+.##.. => #
+.#### => #
+#.#.# => #
+#.### => #
+##.#. => #
+##.## => #
+###.. => #
+###.# => #
+####. => #";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 325);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 50000000501);
+}