Year 2018 Day 5

README.md

@@ -241,6 +241,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 2 | [Inventory Management System](https://adventofcode.com/2018/day/2) | [Source](src/year2018/day02.rs) | 77 |
 | 3 | [No Matter How You Slice It](https://adventofcode.com/2018/day/3) | [Source](src/year2018/day03.rs) | 56 |
 | 4 | [Repose Record](https://adventofcode.com/2018/day/4) | [Source](src/year2018/day04.rs) | 46 |
+| 5 | [Alchemical Reduction](https://adventofcode.com/2018/day/5) | [Source](src/year2018/day05.rs) | 353 |
 
 ## 2017
 

benches/benchmark.rs

@@ -133,6 +133,7 @@ mod year2018 {
     benchmark!(year2018, day02);
     benchmark!(year2018, day03);
     benchmark!(year2018, day04);
+    benchmark!(year2018, day05);
 }
 
 mod year2019 {

src/lib.rs

@@ -116,6 +116,7 @@ pub mod year2018 {
     pub mod day02;
     pub mod day03;
     pub mod day04;
+    pub mod day05;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/main.rs

@@ -183,6 +183,7 @@ fn year2018() -> Vec<Solution> {
         solution!(year2018, day02),
         solution!(year2018, day03),
         solution!(year2018, day04),
+        solution!(year2018, day05),
     ]
 }
 

src/year2018/day05.rs

@@ -0,0 +1,65 @@
+//! # Alchemical Reduction
+//!
+//! ## Part One
+//!
+//! This problem is similar to checking if a parentheses expression is balanced or not.
+//! We use a similar approach, maintaining a stack of unreacted polymer units. Each unit from the
+//! polymer is compared to the head of the stack using bitwise logic. Lowercase and uppercase ASCII
+//! codes for the same lettter are always are 32 apart, which can be checked very quickly using
+//! bitwise XOR. For example:
+//!
+//! ```none
+//!         A = 65 = 01000001
+//!         a = 97 = 01100001
+//!     A ^ a = 32 = 00100000
+//! ```
+//!
+//! If two units are the same type but opposite polarity then they are popped from the stack.
+//!
+//! ## Part Two
+//!
+//! An important optimization is to use the already reacted polymer from part one. This is
+//! approximately 20% of the size of the raw input. Then this smaller polymer is filtered
+//! further for each of the 26 kinds of unit.
+pub fn parse(input: &str) -> Vec<u8> {
+    collapse(input.trim().bytes())
+}
+
+pub fn part1(input: &[u8]) -> usize {
+    input.len()
+}
+
+pub fn part2(input: &[u8]) -> usize {
+    (b'a'..=b'z')
+        .map(|kind| collapse(input.iter().copied().filter(|&b| b | 32 != kind)).len())
+        .min()
+        .unwrap()
+}
+
+fn collapse(polymer: impl Iterator<Item = u8>) -> Vec<u8> {
+    // It's faster to keep the head of the stack in a dedicated variable. 0 is used as a special
+    // sentinel kind to indicate an empty stack as it will never match with any unit kind.
+    let mut head = 0;
+    let mut stack = Vec::with_capacity(10_000);
+
+    for unit in polymer {
+        // Uppercase and lowercase ASCII are always 32 apart.
+        if head ^ unit == 32 {
+            // The head reacts with the unit to annihilate each other so replace with the next unit
+            // from the stack.
+            head = stack.pop().unwrap_or(0);
+        } else {
+            // Don't push sentinel values.
+            if head != 0 {
+                stack.push(head);
+            }
+            head = unit;
+        }
+    }
+
+    if head != 0 {
+        stack.push(head);
+    }
+
+    stack
+}

tests/test.rs

@@ -117,6 +117,7 @@ mod year2018 {
     mod day02_test;
     mod day03_test;
     mod day04_test;
+    mod day05_test;
 }
 
 mod year2019 {

tests/year2018/day05_test.rs

@@ -0,0 +1,15 @@
+use aoc::year2018::day05::*;
+
+const EXAMPLE: &str = "dabAcCaCBAcCcaDA";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 10);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 4);
+}