Year 2016 speed and code quality improvements

Author: maneatingape

README.md

@@ -336,10 +336,10 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 3 | [Squares With Three Sides](https://adventofcode.com/2016/day/3) | [Source](src/year2016/day03.rs) | 24 |
 | 4 | [Security Through Obscurity](https://adventofcode.com/2016/day/4) | [Source](src/year2016/day04.rs) | 79 |
 | 5 | [How About a Nice Game of Chess?](https://adventofcode.com/2016/day/5) | [Source](src/year2016/day05.rs) | 37000 |
-| 6 | [Signals and Noise](https://adventofcode.com/2016/day/6) | [Source](src/year2016/day06.rs) | 4 |
+| 6 | [Signals and Noise](https://adventofcode.com/2016/day/6) | [Source](src/year2016/day06.rs) | 3 |
 | 7 | [Internet Protocol Version 7](https://adventofcode.com/2016/day/7) | [Source](src/year2016/day07.rs) | 364 |
 | 8 | [Two-Factor Authentication](https://adventofcode.com/2016/day/8) | [Source](src/year2016/day08.rs) | 9 |
-| 9 | [Explosives in Cyberspace](https://adventofcode.com/2016/day/9) | [Source](src/year2016/day09.rs) | 6 |
+| 9 | [Explosives in Cyberspace](https://adventofcode.com/2016/day/9) | [Source](src/year2016/day09.rs) | 7 |
 | 10 | [Balance Bots](https://adventofcode.com/2016/day/10) | [Source](src/year2016/day10.rs) | 16 |
 | 11 | [Radioisotope Thermoelectric Generators](https://adventofcode.com/2016/day/11) | [Source](src/year2016/day11.rs) | 719 |
 | 12 | [Leonardo's Monorail](https://adventofcode.com/2016/day/12) | [Source](src/year2016/day12.rs) | 1 |
@@ -348,7 +348,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 15 | [Timing is Everything](https://adventofcode.com/2016/day/15) | [Source](src/year2016/day15.rs) | 1 |
 | 16 | [Dragon Checksum](https://adventofcode.com/2016/day/16) | [Source](src/year2016/day16.rs) | 1 |
 | 17 | [Two Steps Forward](https://adventofcode.com/2016/day/17) | [Source](src/year2016/day17.rs) | 3858 |
-| 18 | [Like a Rogue](https://adventofcode.com/2016/day/18) | [Source](src/year2016/day18.rs) | 728 |
+| 18 | [Like a Rogue](https://adventofcode.com/2016/day/18) | [Source](src/year2016/day18.rs) | 400 |
 | 19 | [An Elephant Named Joseph](https://adventofcode.com/2016/day/19) | [Source](src/year2016/day19.rs) | 1 |
 | 20 | [Firewall Rules](https://adventofcode.com/2016/day/20) | [Source](src/year2016/day20.rs) | 21 |
 | 21 | [Scrambled Letters and Hash](https://adventofcode.com/2016/day/21) | [Source](src/year2016/day21.rs) | 10 |

src/year2016/day03.rs

@@ -13,16 +13,19 @@ pub fn parse(input: &str) -> Vec<u32> {
 }
 
 pub fn part1(input: &[u32]) -> usize {
-    count(input.iter().copied())
+    count(input.iter())
 }
 
 pub fn part2(input: &[u32]) -> usize {
-    let first = count(input.iter().copied().step_by(3));
-    let second = count(input.iter().copied().skip(1).step_by(3));
-    let third = count(input.iter().copied().skip(2).step_by(3));
+    let first = count(input.iter().step_by(3));
+    let second = count(input.iter().skip(1).step_by(3));
+    let third = count(input.iter().skip(2).step_by(3));
     first + second + third
 }
 
-fn count(iter: impl Iterator<Item = u32>) -> usize {
-    iter.chunk::<3>().filter(|&[a, b, c]| a + b > c && a + c > b && b + c > a).count()
+fn count<'a, I>(iter: I) -> usize
+where
+    I: Iterator<Item = &'a u32>,
+{
+    iter.chunk::<3>().filter(|&[&a, &b, &c]| a + b > c && a + c > b && b + c > a).count()
 }

src/year2016/day04.rs

@@ -28,7 +28,7 @@ pub fn parse(input: &str) -> Vec<Room<'_>> {
         // Count the frequency of each digit, the frequency of each frequency `fof` and the
         // highest total frequency.
         let mut freq = [0; 26];
-        let mut fof = [0; 64];
+        let mut fof = [0; 26];
         let mut highest = 0;
 
         for b in name.bytes() {

src/year2016/day06.rs

@@ -2,31 +2,35 @@
 //!
 //! The cardinality of uppercase letters is only 26 so we can use a fixed size array to
 //! count the frequency of each character efficiently.
-type Input = Vec<[u32; 26]>;
+type Input = (String, String);
 
 pub fn parse(input: &str) -> Input {
     let width = input.lines().next().unwrap().len();
-    let mut freq = vec![[0; 26]; width];
+    let stride = width + 1;
+    let input = input.as_bytes();
 
-    for (i, b) in input.bytes().filter(u8::is_ascii_lowercase).enumerate() {
-        freq[i % width][(b - b'a') as usize] += 1;
-    }
+    let to_index = |b: u8| (b - b'a') as usize;
+    let to_char = |i: usize| ((i as u8) + b'a') as char;
 
-    freq
-}
+    (0..width)
+        .map(|offset| {
+            let mut freq = [0; 26];
+            input.iter().skip(offset).step_by(stride).for_each(|&b| freq[to_index(b)] += 1);
+
+            let (max, _) =
+                freq.iter().enumerate().filter(|(_, f)| **f > 0).max_by_key(|(_, f)| **f).unwrap();
+            let (min, _) =
+                freq.iter().enumerate().filter(|(_, f)| **f > 0).min_by_key(|(_, f)| **f).unwrap();
 
-pub fn part1(input: &Input) -> String {
-    find(input, |freq| {
-        freq.iter().enumerate().filter(|(_, f)| **f > 0).max_by_key(|(_, f)| **f).unwrap()
-    })
+            (to_char(max), to_char(min))
+        })
+        .unzip()
 }
 
-pub fn part2(input: &Input) -> String {
-    find(input, |freq| {
-        freq.iter().enumerate().filter(|(_, f)| **f > 0).min_by_key(|(_, f)| **f).unwrap()
-    })
+pub fn part1(input: &Input) -> &str {
+    &input.0
 }
 
-fn find(input: &Input, ec: impl Fn(&[u32; 26]) -> (usize, &u32)) -> String {
-    input.iter().map(ec).map(|(index, _)| ((index as u8) + b'a') as char).collect()
+pub fn part2(input: &Input) -> &str {
+    &input.1
 }

src/year2016/day07.rs

@@ -1,84 +1,73 @@
 //! # Internet Protocol Version 7
 //!
-//! It's faster to treat the entire input as one big stream, using line breaks to increment
-//! the count if an address is valid.
-//!
 //! For part two there are at most 26 * 26 = 676 possible ABA or BAB sequences so we can use
 //! a fixed size array to keep track of which ones we've seen for the current address so far.
-pub fn parse(input: &str) -> &[u8] {
-    input.as_bytes()
+pub fn parse(input: &str) -> Vec<&[u8]> {
+    input.lines().map(str::as_bytes).collect()
 }
 
-pub fn part1(input: &[u8]) -> usize {
-    let mut count = 0;
-    let mut inside = false;
-    let mut positive = false;
-    let mut negative = false;
+pub fn part1(input: &[&[u8]]) -> usize {
+    input
+        .iter()
+        .filter(|line| {
+            let mut has_abba = false;
+            let mut inside_brackets = false;
 
-    for w in input.windows(4) {
-        if w[0].is_ascii_lowercase() {
-            if w[0] == w[3] && w[1] == w[2] && w[0] != w[1] {
-                if inside {
-                    negative = true;
+            for w in line.windows(4) {
+                if w[0].is_ascii_lowercase() {
+                    if w[0] == w[3] && w[1] == w[2] && w[0] != w[1] {
+                        if inside_brackets {
+                            return false;
+                        }
+                        has_abba = true;
+                    }
                 } else {
-                    positive = true;
+                    inside_brackets = w[0] == b'[';
                 }
             }
-        } else if w[0] == b'[' {
-            inside = true;
-        } else if w[0] == b']' {
-            inside = false;
-        } else {
-            // Next line
-            if positive && !negative {
-                count += 1;
-            }
-            positive = false;
-            negative = false;
-        }
-    }
 
-    if positive && !negative { count + 1 } else { count }
+            has_abba
+        })
+        .count()
 }
 
-pub fn part2(input: &[u8]) -> usize {
-    let mut count = 0;
-    let mut version = 0;
-    let mut inside = false;
-    let mut positive = false;
+pub fn part2(input: &[&[u8]]) -> usize {
     let mut aba = [usize::MAX; 676];
     let mut bab = [usize::MAX; 676];
 
-    for w in input.windows(3) {
-        if w[1].is_ascii_lowercase() {
-            if w[0] == w[2] && w[0] != w[1] {
-                let first = (w[0] - b'a') as usize;
-                let second = (w[1] - b'a') as usize;
+    input
+        .iter()
+        .enumerate()
+        .filter(|&(version, line)| {
+            let mut inside_brackets = false;
 
-                if inside {
-                    // Reverse the order of letters
-                    let index = 26 * second + first;
-                    bab[index] = version;
-                    positive |= aba[index] == version;
+            for w in line.windows(3) {
+                if w[0].is_ascii_lowercase() {
+                    if w[0] == w[2] && w[0] != w[1] && w[1].is_ascii_lowercase() {
+                        let first = (w[0] - b'a') as usize;
+                        let second = (w[1] - b'a') as usize;
+
+                        if inside_brackets {
+                            // Reverse the order of letters
+                            let index = 26 * second + first;
+                            bab[index] = version;
+                            if aba[index] == version {
+                                return true;
+                            }
+                        } else {
+                            let index = 26 * first + second;
+                            aba[index] = version;
+                            if bab[index] == version {
+                                return true;
+                            }
+                        }
+                    }
                 } else {
-                    let index = 26 * first + second;
-                    aba[index] = version;
-                    positive |= bab[index] == version;
+                    inside_brackets = w[0] == b'[';
                 }
             }
-        } else if w[1] == b'[' {
-            inside = true;
-        } else if w[1] == b']' {
-            inside = false;
-        } else {
-            // Next line
-            if positive {
-                count += 1;
-            }
-            version += 1;
-            positive = false;
-        }
-    }
 
-    if positive { count + 1 } else { count }
+            false
+        })
+        .count()
 }

src/year2016/day09.rs

@@ -15,39 +15,35 @@ pub fn part2(input: &[u8]) -> usize {
     decompress(input, true)
 }
 
-fn decompress(mut slice: &[u8], recurse: bool) -> usize {
+fn decompress(mut slice: &[u8], part_two: bool) -> usize {
     let mut length = 0;
 
-    while !slice.is_empty() {
-        if slice[0] == b'(' {
-            let (next, amount) = number(slice);
-            let (next, repeat) = number(next);
-
-            let start = 1;
-            let end = start + amount;
-            let result = if recurse { decompress(&next[start..end], true) } else { amount };
-
-            slice = &next[end..];
-            length += result * repeat;
-        } else {
-            slice = &slice[1..];
-            length += 1;
-        }
+    // Find the next marker.
+    while let Some(start) = slice.iter().position(|&b| b == b'(') {
+        let (next, amount) = number(&slice[start + 1..]);
+        let (next, repeat) = number(next);
+
+        // For part two, recursively decompress data.
+        let result = if part_two { decompress(&next[..amount], true) } else { amount };
+
+        slice = &next[amount..];
+        length += start + result * repeat;
     }
 
-    length
+    // Add remaining plain data that doesn't container any marker.
+    length + slice.len()
 }
 
 fn number(slice: &[u8]) -> (&[u8], usize) {
-    // Parse number digit by digit, skipping over the delimeter at the start but leaving the
-    // delimeter at the end.
-    let mut index = 2;
-    let mut acc = slice[1].to_decimal() as usize;
+    // Parse number digit by digit.
+    let mut index = 0;
+    let mut acc = 0;
 
     while slice[index].is_ascii_digit() {
         acc = 10 * acc + slice[index].to_decimal() as usize;
         index += 1;
     }
 
-    (&slice[index..], acc)
+    // Skip over trailing delimeter.
+    (&slice[index + 1..], acc)
 }

src/year2016/day18.rs

@@ -1,49 +1,57 @@
 //! # Like a Rogue
 //!
-//! We represent a trap with a 1 bit and a safe tile with a 0 bit storing the entire row
-//! in a [`u128`]. We then use bitwise logic to calculate the next row.
-//!
+//! We represent a trap with a 1 bit and a safe tile with a 0 bit.
 //! Writing out the [truth table](https://en.wikipedia.org/wiki/Truth_table) for the rules:
 //!
-//! | Left | Center | Right |
-//! | ---- | ------ | ----- |
-//! |    1 |      1 |     0 |
-//! |    0 |      1 |     1 |
-//! |    1 |      0 |     0 |
-//! |    0 |      0 |     1 |
+//! | Left | Center | Right | Output |
+//! | ---- | ------ | ----- | ------ |
+//! |    1 |      1 |     0 |      1 |
+//! |    0 |      1 |     1 |      1 |
+//! |    1 |      0 |     0 |      1 |
+//! |    0 |      0 |     1 |      1 |
+//! |    1 |      1 |     1 |      0 |
+//! |    0 |      1 |     0 |      0 |
+//! |    1 |      0 |     1 |      0 |
+//! |    0 |      0 |     0 |      0 |
 //!
 //! We can see that the value of the center doesn't matter and that the next tile will be a trap
 //! if the left and right values are different. We calculate this for all traps at the same time
 //! with a bitwise [XOR](https://en.wikipedia.org/wiki/XOR_gate).
+//!
+//! Since even columns depend only on odd columns and vice-versa, we split the input into two,
+//! storing each half using 50 bits of a `u64`.
 pub fn parse(input: &str) -> &str {
     input.trim()
 }
 
-pub fn part1(input: &str) -> u32 {
+pub fn part1(input: &str) -> usize {
     count(input, 40)
 }
 
-pub fn part2(input: &str) -> u32 {
+pub fn part2(input: &str) -> usize {
     count(input, 400_000)
 }
 
-fn count(input: &str, rows: u32) -> u32 {
-    let width = input.len() as u32;
-    // We don't use the full 128 bit width so create a mask the same width as the input
-    // to prevent bits spilling over.
-    let mask = (1 << width) - 1;
-
+fn count(input: &str, rows: usize) -> usize {
+    // We don't use all the bits in each `u64` so create a mask the same width as
+    // half the input to prevent bits spilling over.
+    let mask = (1 << (input.len() / 2)) - 1;
     // Represent each trap as a `1` bit.
+    let traps = |acc: u64, b: u8| (acc << 1) | (b == b'^') as u64;
+
+    // Split traps into two halves.
+    let mut even = input.bytes().step_by(2).fold(0, traps);
+    let mut odd = input.bytes().skip(1).step_by(2).fold(0, traps);
     let mut total = 0;
-    let mut row = input.bytes().fold(0, |acc, b| (acc << 1) | (b == b'^') as u128);
 
     for _ in 0..rows {
         // Count the traps in each row.
-        total += row.count_ones();
-        // Only consider the left and right values for the next row.
-        row = ((row << 1) ^ (row >> 1)) & mask;
+        total += even.count_ones() + odd.count_ones();
+
+        // Calculate the next row of even traps from odd traps and vice-versa.
+        (even, odd) = (odd ^ (odd >> 1), even ^ ((even << 1) & mask));
     }
 
     // We want the number of safe tiles so convert from the number of traps.
-    rows * width - total
+    input.len() * rows - total as usize
 }

tests/year2016/day07.rs

@@ -15,11 +15,11 @@ zazbz[bzb]cdb";
 #[test]
 fn part1_test() {
     let input = parse(FIRST_EXAMPLE);
-    assert_eq!(part1(input), 2);
+    assert_eq!(part1(&input), 2);
 }
 
 #[test]
 fn part2_test() {
     let input = parse(SECOND_EXAMPLE);
-    assert_eq!(part2(input), 3);
+    assert_eq!(part2(&input), 3);
 }