Year 2019 speed and code quality improvements

Author: maneatingape

README.md

@@ -238,18 +238,18 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 1 | [The Tyranny of the Rocket Equation](https://adventofcode.com/2019/day/1) | [Source](src/year2019/day01.rs) | 1 |
 | 2 | [1202 Program Alarm](https://adventofcode.com/2019/day/2) | [Source](src/year2019/day02.rs) | 1 |
 | 3 | [Crossed Wires](https://adventofcode.com/2019/day/3) | [Source](src/year2019/day03.rs) | 17 |
-| 4 | [Secure Container](https://adventofcode.com/2019/day/4) | [Source](src/year2019/day04.rs) | 12 |
+| 4 | [Secure Container](https://adventofcode.com/2019/day/4) | [Source](src/year2019/day04.rs) | 7 |
 | 5 | [Sunny with a Chance of Asteroids](https://adventofcode.com/2019/day/5) | [Source](src/year2019/day05.rs) | 3 |
 | 6 | [Universal Orbit Map](https://adventofcode.com/2019/day/6) | [Source](src/year2019/day06.rs) | 29 |
 | 7 | [Amplification Circuit](https://adventofcode.com/2019/day/7) | [Source](src/year2019/day07.rs) | 79 |
 | 8 | [Space Image Format](https://adventofcode.com/2019/day/8) | [Source](src/year2019/day08.rs) | 4 |
 | 9 | [Sensor Boost](https://adventofcode.com/2019/day/9) | [Source](src/year2019/day09.rs) | 1008 |
 | 10 | [Monitoring Station](https://adventofcode.com/2019/day/10) | [Source](src/year2019/day10.rs) | 1092 |
-| 11 | [Space Police](https://adventofcode.com/2019/day/11) | [Source](src/year2019/day11.rs) | 341 |
-| 12 | [The N-Body Problem](https://adventofcode.com/2019/day/12) | [Source](src/year2019/day12.rs) | 1309 |
+| 11 | [Space Police](https://adventofcode.com/2019/day/11) | [Source](src/year2019/day11.rs) | 320 |
+| 12 | [The N-Body Problem](https://adventofcode.com/2019/day/12) | [Source](src/year2019/day12.rs) | 838 |
 | 13 | [Care Package](https://adventofcode.com/2019/day/13) | [Source](src/year2019/day13.rs) | 2527 |
 | 14 | [Space Stoichiometry](https://adventofcode.com/2019/day/14) | [Source](src/year2019/day14.rs) | 17 |
-| 15 | [Oxygen System](https://adventofcode.com/2019/day/15) | [Source](src/year2019/day15.rs) | 360 |
+| 15 | [Oxygen System](https://adventofcode.com/2019/day/15) | [Source](src/year2019/day15.rs) | 291 |
 | 16 | [Flawed Frequency Transmission](https://adventofcode.com/2019/day/16) | [Source](src/year2019/day16.rs) | 1956 |
 | 17 | [Set and Forget](https://adventofcode.com/2019/day/17) | [Source](src/year2019/day17.rs) | 338 |
 | 18 | [Many-Worlds Interpretation](https://adventofcode.com/2019/day/18) | [Source](src/year2019/day18.rs) | 1157 |

src/year2019/day02.rs

@@ -60,7 +60,7 @@ fn search(input: &Input, x1: i32, x2: i32, y1: i32, y2: i32) -> Option<i32> {
 
     let x = x1.midpoint(x2);
     let y = y1.midpoint(y2);
-    let [a, b, c] = input;
+    let [a, b, c] = *input;
     let result = a * x + b * y + c;
 
     match result.cmp(&19690720) {

src/year2019/day04.rs

@@ -3,89 +3,54 @@
 //! We speed things up by only checking numbers that have digits in non-decreasing order for pairs.
 //! These numbers become rapidly less dense as the password value increases and there
 //! are only 3003 total of these numbers with 6 digits.
+use crate::util::iter::*;
 use crate::util::parse::*;
-use crate::util::slice::*;
 
-pub fn parse(input: &str) -> Vec<u32> {
-    input.iter_unsigned().collect()
-}
-
-/// Password must contain at least one pair.
-pub fn part1(input: &[u32]) -> u32 {
-    let predicate = |first: bool, second: bool, third: bool, fourth: bool, fifth: bool| {
-        first || second || third || fourth || fifth
-    };
-    passwords(input, predicate)
-}
+type Input = (u32, u32);
 
-/// Password must contain at least one pair that's not part of a larger group.
-pub fn part2(input: &[u32]) -> u32 {
-    let predicate = |first: bool, second: bool, third: bool, fourth: bool, fifth: bool| {
-        (first && !second)
-            || (!first && second && !third)
-            || (!second && third && !fourth)
-            || (!third && fourth && !fifth)
-            || (!fourth && fifth)
-    };
-    passwords(input, predicate)
-}
+pub fn parse(input: &str) -> Input {
+    let [start, end] = input.iter_unsigned::<u32>().chunk::<2>().next().unwrap();
 
-fn passwords(input: &[u32], predicate: impl Fn(bool, bool, bool, bool, bool) -> bool) -> u32 {
-    let start = input[0];
-    let end = input[1];
+    let mut digits = to_digits(start);
+    let end = to_digits(end);
 
-    // Split into six digits.
-    let mut digits = [
-        start / 100000,
-        (start / 10000) % 10,
-        (start / 1000) % 10,
-        (start / 100) % 10,
-        (start / 10) % 10,
-        start % 10,
-    ];
+    let mut part_one = 0;
+    let mut part_two = 0;
 
     // Increase the starting number to the next number that has all digits in non-decreasing order
     // to ensure that the incrementing logic in the search loop works correctly.
     // For example 223450 => 223455, 120568 => 122222 and 439999 => 444444.
-    for i in 1..6 {
-        if digits[i] < digits[i - 1] {
-            for j in i..6 {
-                digits[j] = digits[i - 1];
-            }
-            break;
-        }
+    if let Some(index) = digits.windows(2).position(|w| w[0] > w[1]) {
+        let next = digits[index];
+        digits[index..].fill(next);
     }
 
-    let mut n = 0;
-    let mut count = 0;
-
-    while n <= end {
-        // Check current number
-        let first = digits[0] == digits[1];
-        let second = digits[1] == digits[2];
-        let third = digits[2] == digits[3];
-        let fourth = digits[3] == digits[4];
-        let fifth = digits[4] == digits[5];
+    while digits <= end {
+        // Build a 5 bit binary mask with a `1` if two adjacent digits are equal.
+        let mask = digits.windows(2).fold(0, |acc, w| (acc << 1) | (w[0] == w[1]) as u32);
 
-        if predicate(first, second, third, fourth, fifth) {
-            count += 1;
-        }
+        // Password must contain at least one pair.
+        part_one += (mask != 0) as u32;
+        // Password must contain at least one pair that's not part of a larger group.
+        part_two += (mask & !(mask >> 1) & !(mask << 1) != 0) as u32;
 
         // Find the next number with all digits in non-decreasing order.
-        let mut i = 5;
-        while digits[i] == 9 {
-            i -= 1;
-        }
+        let index = digits.iter().rposition(|&d| d < b'9').unwrap();
+        let next = digits[index] + 1;
+        digits[index..].fill(next);
+    }
 
-        let next = digits[i] + 1;
-        while i <= 5 {
-            digits[i] = next;
-            i += 1;
-        }
+    (part_one, part_two)
+}
 
-        // Convert number to `u32`.
-        n = digits.fold_decimal();
-    }
+pub fn part1(input: &Input) -> u32 {
+    input.0
+}
+
+pub fn part2(input: &Input) -> u32 {
+    input.1
+}
 
-    count
+fn to_digits(n: u32) -> [u8; 6] {
+    format!("{n:06}").into_bytes().try_into().unwrap()
 }

src/year2019/day06.rs

@@ -49,8 +49,8 @@ pub fn parse(input: &str) -> Vec<usize> {
     let mut parent = vec![0; lines.len() + 2];
 
     for line in lines {
-        let left = lookup(&line[..3]);
-        let right = lookup(&line[4..]);
+        let left = lookup(&line[0..3]);
+        let right = lookup(&line[4..7]);
         parent[right] = left;
     }
 
@@ -71,8 +71,8 @@ pub fn part1(input: &[usize]) -> usize {
     }
 
     let cache = &mut vec![None; input.len()];
-    cache[0] = Some(0);
-    cache[1] = Some(0);
+    cache[0] = Some(0); // Special empty value
+    cache[1] = Some(0); // COM
     (0..input.len()).map(|index| orbits(input, cache, index)).sum()
 }
 

src/year2019/day08.rs

@@ -1,7 +1,10 @@
 //! # Space Image Format
+const WIDTH: usize = 25;
+const HEIGHT: usize = 6;
+const LAYER_SIZE: usize = WIDTH * HEIGHT;
 
-pub fn parse(input: &str) -> &str {
-    input
+pub fn parse(input: &str) -> &[u8] {
+    input.as_bytes()
 }
 
 /// Each layer is 25 * 6 = 150 bytes and there are 100 layers total.
@@ -10,64 +13,56 @@ pub fn parse(input: &str) -> &str {
 /// so we must handle the last 6 bytes specially.
 ///
 /// [`count_ones`]: u64::count_ones
-pub fn part1(input: &str) -> u32 {
-    let bytes = input.as_bytes();
-    let mut index = 0;
-    let mut ones = 0;
-    let mut twos = 0;
+pub fn part1(input: &[u8]) -> u32 {
     let mut most = 0;
     let mut result = 0;
 
-    for _ in 0..100 {
+    for layer in input.chunks_exact(LAYER_SIZE) {
+        let mut ones = 0;
+        let mut twos = 0;
+
         // First 144 of 150 bytes.
-        for _ in 0..18 {
-            let slice = &bytes[index..(index + 8)];
+        for slice in layer.chunks_exact(8) {
             let n = u64::from_be_bytes(slice.try_into().unwrap());
             ones += (n & 0x0101010101010101).count_ones();
             twos += (n & 0x0202020202020202).count_ones();
-            index += 8;
         }
 
         // Handle remaining 6 bytes.
         // The masks exclude the most significant 2 bytes to prevent double counting.
-        let slice = &bytes[(index - 2)..(index + 6)];
+        let slice = &layer[142..150];
         let n = u64::from_be_bytes(slice.try_into().unwrap());
         ones += (n & 0x0000010101010101).count_ones();
         twos += (n & 0x0000020202020202).count_ones();
-        index += 6;
 
         if ones + twos > most {
             most = ones + twos;
             result = ones * twos;
         }
-
-        ones = 0;
-        twos = 0;
     }
 
     result
 }
 
 /// Since a black or white pixel covers those in lower layers, it's faster to check each pixel
 /// stopping as soon as we hit a non-transparent value.
-pub fn part2(input: &str) -> String {
-    let bytes = input.as_bytes();
-    let mut image = ['.'; 150];
+pub fn part2(input: &[u8]) -> String {
+    // Ensure enough capacity including newlines.
+    let mut result = String::with_capacity((WIDTH + 1) * HEIGHT);
 
-    for (i, pixel) in image.iter_mut().enumerate() {
-        let mut j = i;
+    for y in 0..HEIGHT {
+        result.push('\n');
 
-        while bytes[j] == b'2' {
-            j += 150;
-        }
+        for x in 0..WIDTH {
+            let mut i = WIDTH * y + x;
+
+            while input[i] == b'2' {
+                i += LAYER_SIZE;
+            }
 
-        if bytes[j] == b'1' {
-            *pixel = '#';
+            result.push(if input[i] == b'1' { '#' } else { '.' });
         }
     }
 
-    let mut result =
-        image.chunks_exact(25).map(|row| row.iter().collect()).collect::<Vec<String>>().join("\n");
-    result.insert(0, '\n');
     result
 }

src/year2019/day11.rs

@@ -2,6 +2,7 @@
 //!
 //! This problem is a variant of [Langton's Ant](https://en.wikipedia.org/wiki/Langton%27s_ant).
 use super::intcode::*;
+use crate::util::grid::*;
 use crate::util::hash::*;
 use crate::util::parse::*;
 use crate::util::point::*;
@@ -21,38 +22,24 @@ pub fn part2(input: &[i64]) -> String {
     let panels: Vec<_> = hull.iter().filter(|&(_, &v)| v == 1).map(|(&k, _)| k).collect();
 
     // Get maximum extents
-    let mut x1 = i32::MAX;
-    let mut x2 = i32::MIN;
-    let mut y1 = i32::MAX;
-    let mut y2 = i32::MIN;
-
-    for &point in &panels {
-        x1 = x1.min(point.x);
-        x2 = x2.max(point.x);
-        y1 = y1.min(point.y);
-        y2 = y2.max(point.y);
-    }
+    let (x1, x2, y1, y2) = panels.iter().fold(
+        (i32::MAX, i32::MIN, i32::MAX, i32::MIN),
+        |(min_x, max_x, min_y, max_y), p| {
+            (min_x.min(p.x), max_x.max(p.x), min_y.min(p.y), max_y.max(p.y))
+        },
+    );
 
     // Convert panels to characters
-    let width = (x2 - x1 + 1) as usize;
-    let height = (y2 - y1 + 1) as usize;
-    let offset = Point::new(x1, y1);
-    let mut image = vec!['.'; width * height];
+    let width = x2 - x1 + 2; // Leave room for newline character.
+    let height = y2 - y1 + 1;
+    let mut image = Grid::new(width, height, b'.');
 
-    for &point in &panels {
-        let adjusted = point - offset;
-        let index = (width * adjusted.y as usize) + (adjusted.x as usize);
-        image[index] = '#';
-    }
+    let offset = Point::new(x1 - 1, y1);
+    panels.iter().for_each(|&point| image[point - offset] = b'#');
+
+    (0..height).for_each(|y| image[Point::new(0, y)] = b'\n');
 
-    // Convert to multiline string
-    let mut result = image
-        .chunks_exact(width)
-        .map(|row| row.iter().collect())
-        .collect::<Vec<String>>()
-        .join("\n");
-    result.insert(0, '\n');
-    result
+    String::from_utf8(image.bytes).unwrap()
 }
 
 fn paint(input: &[i64], initial: i64) -> FastMap<Point, i64> {
@@ -64,12 +51,12 @@ fn paint(input: &[i64], initial: i64) -> FastMap<Point, i64> {
     hull.insert(position, initial);
 
     loop {
-        let panel = hull.get(&position).unwrap_or(&0);
+        let panel = hull.entry(position).or_default();
         computer.input(*panel);
 
         match computer.run() {
             State::Output(color) => {
-                hull.insert(position, color);
+                *panel = color;
             }
             _ => break,
         }

src/year2019/day12.rs

@@ -16,6 +16,7 @@
 //! [`signum`]: i32::signum
 use crate::util::math::*;
 use crate::util::parse::*;
+use std::array::from_fn;
 
 type Axis = [i32; 8];
 type Input = [Axis; 3];
@@ -39,16 +40,16 @@ pub fn part1(input: &Input) -> i32 {
         z = step(z);
     }
 
-    let e: Vec<_> = (0..8).map(|i| x[i].abs() + y[i].abs() + z[i].abs()).collect();
-    e[0] * e[4] + e[1] * e[5] + e[2] * e[6] + e[3] * e[7]
+    let [p0, p1, p2, p3, v0, v1, v2, v3] = from_fn(|i| x[i].abs() + y[i].abs() + z[i].abs());
+    p0 * v0 + p1 * v1 + p2 * v2 + p3 * v3
 }
 
 pub fn part2(input: &Input) -> usize {
     let [mut x, mut y, mut z] = *input;
     let [mut a, mut b, mut c] = [0, 0, 0];
     let mut count = 0;
 
-    while a == 0 || b == 0 || c == 0 {
+    while a * b * c == 0 {
         count += 1;
 
         if a == 0 {
@@ -81,10 +82,17 @@ fn step(axis: Axis) -> Axis {
     // "p" is position and "v" velocity
     let [p0, p1, p2, p3, v0, v1, v2, v3] = axis;
 
-    let n0 = v0 + (p1 - p0).signum() + (p2 - p0).signum() + (p3 - p0).signum();
-    let n1 = v1 + (p0 - p1).signum() + (p2 - p1).signum() + (p3 - p1).signum();
-    let n2 = v2 + (p0 - p2).signum() + (p1 - p2).signum() + (p3 - p2).signum();
-    let n3 = v3 + (p0 - p3).signum() + (p1 - p3).signum() + (p2 - p3).signum();
+    let a = (p1 - p0).signum();
+    let b = (p2 - p0).signum();
+    let c = (p3 - p0).signum();
+    let d = (p2 - p1).signum();
+    let e = (p3 - p1).signum();
+    let f = (p3 - p2).signum();
+
+    let n0 = v0 + a + b + c;
+    let n1 = v1 - a + d + e;
+    let n2 = v2 - b - d + f;
+    let n3 = v3 - c - e - f;
 
     [p0 + n0, p1 + n1, p2 + n2, p3 + n3, n0, n1, n2, n3]
 }