Year 2015 speed and code quality improvements

Author: maneatingape

README.md

@@ -370,14 +370,14 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 5 | [Doesn't He Have Intern-Elves For This?](https://adventofcode.com/2015/day/5) | [Source](src/year2015/day05.rs) | 38 |
 | 6 | [Probably a Fire Hazard](https://adventofcode.com/2015/day/6) | [Source](src/year2015/day06.rs) | 6572 |
 | 7 | [Some Assembly Required](https://adventofcode.com/2015/day/7) | [Source](src/year2015/day07.rs) | 27 |
-| 8 | [Matchsticks](https://adventofcode.com/2015/day/8) | [Source](src/year2015/day08.rs) | 12 |
+| 8 | [Matchsticks](https://adventofcode.com/2015/day/8) | [Source](src/year2015/day08.rs) | 5 |
 | 9 | [All in a Single Night](https://adventofcode.com/2015/day/9) | [Source](src/year2015/day09.rs) | 34 |
-| 10 | [Elves Look, Elves Say](https://adventofcode.com/2015/day/10) | [Source](src/year2015/day10.rs) | 15 |
+| 10 | [Elves Look, Elves Say](https://adventofcode.com/2015/day/10) | [Source](src/year2015/day10.rs) | 17 |
 | 11 | [Corporate Policy](https://adventofcode.com/2015/day/11) | [Source](src/year2015/day11.rs) | 1 |
-| 12 | [JSAbacusFramework.io](https://adventofcode.com/2015/day/12) | [Source](src/year2015/day12.rs) | 83 |
+| 12 | [JSAbacusFramework.io](https://adventofcode.com/2015/day/12) | [Source](src/year2015/day12.rs) | 71 |
 | 13 | [Knights of the Dinner Table](https://adventofcode.com/2015/day/13) | [Source](src/year2015/day13.rs) | 37 |
-| 14 | [Reindeer Olympics](https://adventofcode.com/2015/day/14) | [Source](src/year2015/day14.rs) | 28 |
-| 15 | [Science for Hungry People](https://adventofcode.com/2015/day/15) | [Source](src/year2015/day15.rs) | 53 |
+| 14 | [Reindeer Olympics](https://adventofcode.com/2015/day/14) | [Source](src/year2015/day14.rs) | 24 |
+| 15 | [Science for Hungry People](https://adventofcode.com/2015/day/15) | [Source](src/year2015/day15.rs) | 43 |
 | 16 | [Aunt Sue](https://adventofcode.com/2015/day/16) | [Source](src/year2015/day16.rs) | 20 |
 | 17 | [No Such Thing as Too Much](https://adventofcode.com/2015/day/17) | [Source](src/year2015/day17.rs) | 45 |
 | 18 | [Like a GIF For Your Yard](https://adventofcode.com/2015/day/18) | [Source](src/year2015/day18.rs) | 154 |
@@ -386,7 +386,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 21 | [RPG Simulator 20XX](https://adventofcode.com/2015/day/21) | [Source](src/year2015/day21.rs) | 2 |
 | 22 | [Wizard Simulator 20XX](https://adventofcode.com/2015/day/22) | [Source](src/year2015/day22.rs) | 235 |
 | 23 | [Opening the Turing Lock](https://adventofcode.com/2015/day/23) | [Source](src/year2015/day23.rs) | 6 |
-| 24 | [It Hangs in the Balance](https://adventofcode.com/2015/day/24) | [Source](src/year2015/day24.rs) | 380 |
+| 24 | [It Hangs in the Balance](https://adventofcode.com/2015/day/24) | [Source](src/year2015/day24.rs) | 237 |
 | 25 | [Let It Snow](https://adventofcode.com/2015/day/25) | [Source](src/year2015/day25.rs) | 1 |
 
 [checks-badge]: https://img.shields.io/github/actions/workflow/status/maneatingape/advent-of-code-rust/checks.yml?label=checks

src/year2015/day01.rs

@@ -1,17 +1,9 @@
 //! # Not Quite Lisp
 //!
 //! The input is first converted into bytes. This is safe as it contains only ASCII characters.
-//! Then each parenthesis is parsed into either +1 or -1, treating the trailing newline
-//! as a special case of 0.
+//! Then each parenthesis is parsed into either +1 or -1.
 pub fn parse(input: &str) -> Vec<i32> {
-    fn helper(b: u8) -> i32 {
-        match b {
-            b'(' => 1,
-            b')' => -1,
-            _ => 0,
-        }
-    }
-    input.bytes().map(helper).collect()
+    input.trim().bytes().map(|b| if b == b'(' { 1 } else { -1 }).collect()
 }
 
 pub fn part1(input: &[i32]) -> i32 {
@@ -20,13 +12,12 @@ pub fn part1(input: &[i32]) -> i32 {
 
 pub fn part2(input: &[i32]) -> usize {
     let mut floor = 0;
-
-    for (i, x) in input.iter().enumerate() {
-        floor += x;
-        if floor < 0 {
-            return i + 1;
-        }
-    }
-
-    unreachable!()
+    input
+        .iter()
+        .position(|&b| {
+            floor += b;
+            floor < 0
+        })
+        .map(|i| i + 1)
+        .unwrap()
 }

src/year2015/day02.rs

@@ -11,9 +11,9 @@
 use crate::util::iter::*;
 use crate::util::parse::*;
 
-type Gift = [u32; 3];
+type Input = Vec<[u32; 3]>;
 
-pub fn parse(input: &str) -> Vec<Gift> {
+pub fn parse(input: &str) -> Input {
     input
         .iter_unsigned()
         .chunk::<3>()
@@ -25,10 +25,10 @@ pub fn parse(input: &str) -> Vec<Gift> {
         .collect()
 }
 
-pub fn part1(input: &[Gift]) -> u32 {
+pub fn part1(input: &Input) -> u32 {
     input.iter().map(|[l, w, h]| 2 * (l * w + w * h + h * l) + l * w).sum()
 }
 
-pub fn part2(input: &[Gift]) -> u32 {
+pub fn part2(input: &Input) -> u32 {
     input.iter().map(|[l, w, h]| 2 * (l + w) + (l * w * h)).sum()
 }

src/year2015/day03.rs

@@ -24,15 +24,16 @@ pub fn part2(input: &[Point]) -> usize {
 fn deliver(input: &[Point], predicate: fn(usize) -> bool) -> usize {
     let mut santa = ORIGIN;
     let mut robot = ORIGIN;
-    let mut set = FastSet::with_capacity(10_000);
+
+    let mut set = FastSet::with_capacity(input.len());
     set.insert(ORIGIN);
 
-    for (index, point) in input.iter().enumerate() {
+    for (index, &point) in input.iter().enumerate() {
         if predicate(index) {
-            santa += *point;
+            santa += point;
             set.insert(santa);
         } else {
-            robot += *point;
+            robot += point;
             set.insert(robot);
         }
     }

src/year2015/day05.rs

@@ -29,24 +29,30 @@ pub fn parse(input: &str) -> Vec<&[u8]> {
 }
 
 pub fn part1(input: &[&[u8]]) -> usize {
+    // Bitmask for vowels (a, e, i, o, u)
+    const VOWEL_MASK: u32 = 0x0104111;
+    // Bitmask for forbidden pairs
+    const FORBIDDEN_MASK: u32 = 0x101000a;
+
     let nice = |line: &&&[u8]| {
         let mut vowels = 0;
         let mut pairs = 0;
         let mut previous = 0;
 
-        for c in line.iter() {
+        for &c in line.iter() {
             let current = 1 << (c - b'a');
-            if 0x101000a & current & (previous << 1) != 0 {
+
+            if FORBIDDEN_MASK & current & (previous << 1) != 0 {
                 return false;
             }
-            if 0x0104111 & current != 0 {
+            if VOWEL_MASK & current != 0 {
                 vowels += 1;
             }
             if previous == current {
                 pairs += 1;
-            } else {
-                previous = current;
             }
+
+            previous = current;
         }
 
         vowels >= 3 && pairs >= 1
@@ -73,8 +79,10 @@ pub fn part2(input: &[&[u8]]) -> usize {
             let delta = position - pairs[index];
 
             if delta > offset {
+                // This is the first time we've seen the pair for this string.
                 pairs[index] = position;
             } else if delta > 1 {
+                // No overlapping means that the distance must be at least two.
                 two_pair = true;
             }
             if first == third {

src/year2015/day08.rs

@@ -1,44 +1,53 @@
 //! # Matchsticks
 //!
 //! While [regular expressions](https://en.wikipedia.org/wiki/Regular_expression) may feel like a
-//! natural choice, it's much faster and easier to simply treat the input as a stream of raw
-//! ASCII `u8` bytes including newlines.
+//! natural choice, it's much faster and easier to simply treat the input as a single stream of raw
+//! ASCII `u8` bytes without splitting line by line.
 //!
-//! For part one we run a small state machine using [`fold`] to keep track of the current and
-//! previous characters. If we encounter a hexadecimal escape then four characters become one so the
-//! difference increases by three. The sequences `\\` and `\"` both increase the difference by one.
-//! Each newline increases the difference by two since every line is enclosed with two quotes.
+//! For part one we skip over the first quote of each line. The last quote on each line increases
+//! the difference by two since every line is enclosed with two quotes. If we encounter a
+//! hexadecimal escape then four characters become one so the difference increases by three.
+//! The sequences `\\` and `\"` both increase the difference by one.
 //!
-//! Part two is even more straightforward with no need for statekeeping. Quotes and backslashes
-//! need to be escaped so increase the difference by one. As before each newline increases by the
-//! difference by two.
-//!
-//! [`fold`]: Iterator::fold
-const NEWLINE: u8 = 10;
-const QUOTE: u8 = 34;
-const SLASH: u8 = 92;
-const ESCAPE: u8 = 120;
+//! Part two is even more straightforward. Quotes and backslashes need to be escaped so increase
+//! the difference by one. Each newline increases by the difference by two.
+const NEWLINE: u8 = b'\n';
+const QUOTE: u8 = b'\"';
+const SLASH: u8 = b'\\';
+const ESCAPE: u8 = b'x';
 
-pub fn parse(input: &str) -> &str {
-    input
+pub fn parse(input: &str) -> &[u8] {
+    input.as_bytes()
 }
 
-pub fn part1(input: &str) -> u32 {
-    let (_, result) = input.bytes().fold((false, 0), |(flag, count), b| match (flag, b) {
-        (true, ESCAPE) => (false, count + 3),
-        (true, _) => (false, count + 1),
-        (false, SLASH) => (true, count),
-        (false, NEWLINE) => (false, count + 2),
-        _ => (false, count),
-    });
+pub fn part1(input: &[u8]) -> usize {
+    // Skip very first quote to prevent double counting.
+    let mut index = 1;
+    let mut result = 0;
+
+    while index < input.len() {
+        let skip = match input[index] {
+            SLASH => match input[index + 1] {
+                ESCAPE => 4,
+                _ => 2,
+            },
+            QUOTE => 3,
+            _ => 1,
+        };
+        result += skip - 1;
+        index += skip;
+    }
+
     result
 }
 
-pub fn part2(input: &str) -> u32 {
+pub fn part2(input: &[u8]) -> u32 {
     input
-        .bytes()
-        .map(|b| match b {
+        .iter()
+        .map(|&b| match b {
+            // Escape special characters.
             QUOTE | SLASH => 1,
+            // Each line needs two enclosing quotes.
             NEWLINE => 2,
             _ => 0,
         })

src/year2015/day09.rs

@@ -65,9 +65,11 @@ pub fn parse(input: &str) -> Result {
             local_max = local_max.max(distance);
         };
 
+        // First trip.
         trip(0, slice[0]);
+        // Last trip.
         trip(0, slice[slice.len() - 1]);
-
+        // Intermediate trips.
         for i in 1..slice.len() {
             trip(slice[i], slice[i - 1]);
         }

src/year2015/day10.rs

@@ -12,6 +12,9 @@
 //!
 //! Computing the result is simply multiplying the number of each element by its length. There are
 //! 92 elements total so we can use a fixed size array to store the decay chain information.
+//!
+//! It would be possible (but less fun) to precompute all possible 92 answers into a
+//! look up table.
 use crate::util::hash::*;
 
 const ELEMENTS: &str = "\
@@ -113,34 +116,34 @@ type Result = (usize, usize);
 pub fn parse(input: &str) -> Result {
     let elements: Vec<Vec<_>> =
         ELEMENTS.lines().map(|line| line.split_ascii_whitespace().collect()).collect();
-    let mut indices = FastMap::with_capacity(92);
+    let mut indices = FastMap::with_capacity(92 * 2);
 
+    // Map both sequence and element name to indices.
     for (i, tokens) in elements.iter().enumerate() {
+        indices.insert(tokens[0], i);
         indices.insert(tokens[2], i);
     }
 
-    let mut sequence = [""; 92];
-    let mut decays = [[None; 6]; 92];
+    // Build list of decay chains.
+    let sizes: Vec<_> = elements.iter().map(|e| e[0].len()).collect();
+    let decays: Vec<Vec<_>> =
+        elements.iter().map(|e| e[4..].iter().map(|t| indices[t]).collect()).collect();
 
-    for (i, tokens) in elements.iter().enumerate() {
-        sequence[i] = tokens[0];
-        for (j, &token) in tokens.iter().skip(4).enumerate() {
-            decays[i][j] = Some(indices[token]);
-        }
-    }
+    // Each input is a single element.
+    let mut current = [0; 92];
+    current[indices[input.trim()]] = 1;
 
-    let mut current = initial_state(input, &sequence);
     for _ in 0..40 {
         current = step(&current, &decays);
     }
+    let part1 = length(&current, &sizes);
 
-    let result1 = length(&current, &sequence);
     for _ in 0..10 {
         current = step(&current, &decays);
     }
+    let part2 = length(&current, &sizes);
 
-    let result2 = length(&current, &sequence);
-    (result1, result2)
+    (part1, part2)
 }
 
 pub fn part1(input: &Result) -> usize {
@@ -151,31 +154,20 @@ pub fn part2(input: &Result) -> usize {
     input.1
 }
 
-fn initial_state(input: &str, sequence: &[&str]) -> [usize; 92] {
-    let input = input.trim();
-    let start = sequence.iter().position(|&s| s == input).unwrap();
-
-    let mut current = [0; 92];
-    current[start] += 1;
-    current
-}
-
-fn step(current: &[usize; 92], decays: &[[Option<usize>; 6]; 92]) -> [usize; 92] {
+fn step(current: &[usize], decays: &[Vec<usize>]) -> [usize; 92] {
     let mut next = [0; 92];
 
-    for i in 0..92 {
-        let c = current[i];
-        if c > 0 {
-            let mut iter = decays[i].iter();
-            while let Some(Some(index)) = iter.next() {
-                next[*index] += c;
+    for (i, &count) in current.iter().enumerate() {
+        if count > 0 {
+            for &element in &decays[i] {
+                next[element] += count;
             }
         }
     }
 
     next
 }
 
-fn length(current: &[usize; 92], sequence: &[&str; 92]) -> usize {
-    current.iter().zip(sequence.iter()).map(|(c, s)| c * s.len()).sum()
+fn length(current: &[usize], sizes: &[usize]) -> usize {
+    current.iter().zip(sizes.iter()).map(|(c, s)| c * s).sum()
 }

src/year2015/day11.rs

@@ -48,17 +48,10 @@ pub fn part2(input: &Input) -> &str {
 /// Sanitize the input to make sure it has no invalid characters. We increment the first invalid
 /// character found, for example `abcixyz` becomes `abcjaaa`.
 fn clean(mut password: Password) -> Password {
-    let mut reset = false;
-
-    for digit in &mut password {
-        if reset {
-            *digit = b'a';
-        } else if matches!(digit, b'i' | b'o' | b'l') {
-            *digit += 1;
-            reset = true;
-        }
+    if let Some(index) = password.iter().position(|&d| matches!(d, b'i' | b'o' | b'l')) {
+        password[index] += 1;
+        password[index + 1..].fill(b'a');
     }
-
     password
 }
 

src/year2015/day12.rs

@@ -75,7 +75,7 @@ fn parse_object(input: &[u8], start: usize) -> Result {
     let mut ignore = false;
 
     while input[index] != b'}' {
-        let Result { next: first, .. } = parse_json(input, index + 1);
+        let Result { next: first, .. } = parse_string(input, index + 1);
         let Result { next: second, ignore: red, value } = parse_json(input, first + 1);
         index = second;
         total += value;