Year 2021 speed and code quality improvements

Author: maneatingape

README.md

@@ -173,14 +173,14 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | --- | --- | --- | --: |
 | 1 | [Sonar Sweep](https://adventofcode.com/2021/day/1) | [Source](src/year2021/day01.rs) | 6 |
 | 2 | [Dive!](https://adventofcode.com/2021/day/2) | [Source](src/year2021/day02.rs) | 12 |
-| 3 | [Binary Diagnostic](https://adventofcode.com/2021/day/3) | [Source](src/year2021/day03.rs) | 20 |
-| 4 | [Giant Squid](https://adventofcode.com/2021/day/4) | [Source](src/year2021/day04.rs) | 12 |
+| 3 | [Binary Diagnostic](https://adventofcode.com/2021/day/3) | [Source](src/year2021/day03.rs) | 22 |
+| 4 | [Giant Squid](https://adventofcode.com/2021/day/4) | [Source](src/year2021/day04.rs) | 8 |
 | 5 | [Hydrothermal Venture](https://adventofcode.com/2021/day/5) | [Source](src/year2021/day05.rs) | 181 |
 | 6 | [Lanternfish](https://adventofcode.com/2021/day/6) | [Source](src/year2021/day06.rs) | 1 |
 | 7 | [The Treachery of Whales](https://adventofcode.com/2021/day/7) | [Source](src/year2021/day07.rs) | 8 |
 | 8 | [Seven Segment Search](https://adventofcode.com/2021/day/8) | [Source](src/year2021/day08.rs) | 14 |
 | 9 | [Smoke Basin](https://adventofcode.com/2021/day/9) | [Source](src/year2021/day09.rs) | 64 |
-| 10 | [Syntax Scoring](https://adventofcode.com/2021/day/10) | [Source](src/year2021/day10.rs) | 25 |
+| 10 | [Syntax Scoring](https://adventofcode.com/2021/day/10) | [Source](src/year2021/day10.rs) | 14 |
 | 11 | [Dumbo Octopus](https://adventofcode.com/2021/day/11) | [Source](src/year2021/day11.rs) | 55 |
 | 12 | [Passage Pathing](https://adventofcode.com/2021/day/12) | [Source](src/year2021/day12.rs) | 25 |
 | 13 | [Transparent Origami](https://adventofcode.com/2021/day/13) | [Source](src/year2021/day13.rs) | 22 |

src/year2021/day02.rs

@@ -16,34 +16,37 @@ pub enum Sub {
 }
 
 pub fn parse(input: &str) -> Vec<Sub> {
-    let helper = |[a, b]: [&str; 2]| {
-        let amount = b.signed();
-        match a {
-            "up" => Sub::Up(amount),
-            "down" => Sub::Down(amount),
-            "forward" => Sub::Forward(amount),
-            _ => unreachable!(),
-        }
-    };
-    input.split_ascii_whitespace().chunk::<2>().map(helper).collect()
+    input
+        .split_ascii_whitespace()
+        .chunk::<2>()
+        .map(|[first, second]| {
+            let amount = second.signed();
+            match first {
+                "up" => Sub::Up(amount),
+                "down" => Sub::Down(amount),
+                "forward" => Sub::Forward(amount),
+                _ => unreachable!(),
+            }
+        })
+        .collect()
 }
 
 pub fn part1(input: &[Sub]) -> i32 {
-    let helper = |(position, depth), next| match next {
-        Sub::Up(n) => (position, depth - n),
-        Sub::Down(n) => (position, depth + n),
-        Sub::Forward(n) => (position + n, depth),
-    };
-    let (position, depth) = input.iter().copied().fold((0, 0), helper);
+    let (position, depth) =
+        input.iter().copied().fold((0, 0), |(position, depth), next| match next {
+            Sub::Up(n) => (position, depth - n),
+            Sub::Down(n) => (position, depth + n),
+            Sub::Forward(n) => (position + n, depth),
+        });
     position * depth
 }
 
 pub fn part2(input: &[Sub]) -> i32 {
-    let helper = |(position, depth, aim), next| match next {
-        Sub::Up(n) => (position, depth, aim - n),
-        Sub::Down(n) => (position, depth, aim + n),
-        Sub::Forward(n) => (position + n, depth + aim * n, aim),
-    };
-    let (position, depth, _) = input.iter().copied().fold((0, 0, 0), helper);
+    let (position, depth, _) =
+        input.iter().copied().fold((0, 0, 0), |(position, depth, aim), next| match next {
+            Sub::Up(n) => (position, depth, aim - n),
+            Sub::Down(n) => (position, depth, aim + n),
+            Sub::Forward(n) => (position + n, depth + aim * n, aim),
+        });
     position * depth
 }

src/year2021/day03.rs

@@ -2,77 +2,51 @@
 //!
 //! Part 1 uses bit manipulation to build up the binary numbers directly one digit at a time.
 //!
-//! Part 2 clones the input `vec` then uses [`swap_remove`] to efficiently discard numbers that
-//! don't meet the criteria without having to move all subsequent elements.
+//! Part 2 clones the input `vec` then uses [`retain`] to efficiently discard numbers that
+//! don't meet the criteria.
 //!
-//! [`swap_remove`]: Vec::swap_remove
-
-pub struct Input<'a> {
-    width: usize,
-    numbers: Vec<&'a [u8]>,
-}
-
-pub fn parse(input: &str) -> Input<'_> {
-    let numbers: Vec<_> = input.lines().map(str::as_bytes).collect();
-    Input { width: numbers[0].len(), numbers }
+//! [`retain`]: Vec::retain
+pub fn parse(input: &str) -> Vec<&[u8]> {
+    input.lines().map(str::as_bytes).collect()
 }
 
-pub fn part1(input: &Input<'_>) -> u32 {
+pub fn part1(input: &[&[u8]]) -> u32 {
     let mut gamma = 0;
     let mut epsilon = 0;
 
-    for i in 0..input.width {
-        let sum = sum(&input.numbers, i);
-        if sum > input.numbers.len() - sum {
-            gamma = (gamma << 1) | 1;
-            epsilon <<= 1;
-        } else {
-            gamma <<= 1;
-            epsilon = (epsilon << 1) | 1;
-        }
+    for column in 0..input[0].len() {
+        let ones = ones(input, column);
+        let zeros = input.len() - ones;
+
+        gamma = (gamma << 1) | (ones > zeros) as u32;
+        epsilon = (epsilon << 1) | (zeros > ones) as u32;
     }
 
     gamma * epsilon
 }
 
-pub fn part2(input: &Input<'_>) -> u32 {
+pub fn part2(input: &[&[u8]]) -> u32 {
     let gamma = rating(input, |a, b| a >= b);
     let epsilon = rating(input, |a, b| a < b);
     gamma * epsilon
 }
 
-fn sum(numbers: &[&[u8]], i: usize) -> usize {
-    let total: usize = numbers.iter().map(|b| b[i] as usize).sum();
-    total - 48 * numbers.len()
+fn ones(numbers: &[&[u8]], i: usize) -> usize {
+    numbers.iter().filter(|b| b[i] == b'1').count()
 }
 
-fn fold(numbers: &[u8], width: usize) -> u32 {
-    numbers.iter().take(width).fold(0, |acc, &n| (acc << 1) | (n & 1) as u32)
-}
+fn rating(input: &[&[u8]], cmp: fn(usize, usize) -> bool) -> u32 {
+    let mut numbers = input.to_vec();
+    let mut column = 0;
 
-fn rating(input: &Input<'_>, cmp: impl Fn(usize, usize) -> bool) -> u32 {
-    let mut numbers = input.numbers.clone();
+    while numbers.len() > 1 {
+        let ones = ones(&numbers, column);
+        let zeros = numbers.len() - ones;
+        let keep = if cmp(ones, zeros) { b'1' } else { b'0' };
 
-    for i in 0..input.width {
-        let sum = sum(&numbers, i);
-        let keep = if cmp(sum, numbers.len() - sum) { b'1' } else { b'0' };
-        filter(&mut numbers, i, keep);
-        if numbers.len() == 1 {
-            return fold(numbers[0], input.width);
-        }
+        numbers.retain(|n| n[column] == keep);
+        column += 1;
     }
 
-    unreachable!()
-}
-
-fn filter(numbers: &mut Vec<&[u8]>, i: usize, keep: u8) {
-    let mut j = 0;
-
-    while j < numbers.len() {
-        if numbers[j][i] == keep {
-            j += 1;
-        } else {
-            numbers.swap_remove(j);
-        }
-    }
+    numbers[0].iter().fold(0, |acc, &n| (acc << 1) | (n == b'1') as u32)
 }

src/year2021/day04.rs

@@ -10,60 +10,51 @@
 //! these maximum values. This is the turn that the entire board will win.
 //!
 //! Filtering the board numbers by turn and a reverse lookup from turn to number gives the
-//! score for each board. Sort each result by turn and the answers for part 1 and part1 are the
+//! score for each board. Sort each result by turn and the answers for part one and two are the
 //! first and last values respectively.
 use crate::util::parse::*;
 use std::array::from_fn;
 
-pub struct Input {
+const BOARD_SIZE: usize = 25;
+const ROWS_AND_COLS: [(usize, usize); 10] =
+    [(0, 1), (5, 1), (10, 1), (15, 1), (20, 1), (0, 5), (1, 5), (2, 5), (3, 5), (4, 5)];
+
+pub struct Board {
     turn: usize,
     score: usize,
 }
 
-pub fn parse(input: &str) -> Vec<Input> {
-    let mut to_turn = [0; 100];
-    let mut from_turn = [0; 100];
+pub fn parse(input: &str) -> Vec<Board> {
+    let (prefix, suffix) = input.split_once("\n\n").unwrap();
+    let boards: Vec<_> = suffix.iter_unsigned().collect();
 
-    let mut chunks = input.split("\n\n");
+    let mut number_to_turn = [0; 100];
+    let mut turn_to_number = [0; 100];
 
-    for (i, n) in chunks.next().unwrap().iter_unsigned().enumerate() {
-        to_turn[n] = i;
-        from_turn[i] = n;
+    for (i, n) in prefix.iter_unsigned().enumerate() {
+        number_to_turn[n] = i;
+        turn_to_number[i] = n;
     }
 
-    let score = |chunk: &str| {
-        let mut iter = chunk.iter_unsigned();
-        let board: [usize; 25] = from_fn(|_| iter.next().unwrap());
-        let turns: [usize; 25] = from_fn(|i| to_turn[board[i]]);
-
-        let row_and_cols = [
-            turns[0..5].iter().max().unwrap(),
-            turns[5..10].iter().max().unwrap(),
-            turns[10..15].iter().max().unwrap(),
-            turns[15..20].iter().max().unwrap(),
-            turns[20..25].iter().max().unwrap(),
-            turns.iter().step_by(5).max().unwrap(),
-            turns.iter().skip(1).step_by(5).max().unwrap(),
-            turns.iter().skip(2).step_by(5).max().unwrap(),
-            turns.iter().skip(3).step_by(5).max().unwrap(),
-            turns.iter().skip(4).step_by(5).max().unwrap(),
-        ];
-        let winning_turn = **row_and_cols.iter().min().unwrap();
-        let unmarked: usize = board.iter().filter(|&&n| to_turn[n] > winning_turn).sum();
-        let just_called = from_turn[winning_turn];
+    boards
+        .chunks_exact(BOARD_SIZE)
+        .map(|board| {
+            let turns: [usize; BOARD_SIZE] = from_fn(|i| number_to_turn[board[i]]);
+            let max = |&(skip, step)| *turns.iter().skip(skip).step_by(step).take(5).max().unwrap();
 
-        Input { turn: winning_turn, score: unmarked * just_called }
-    };
+            let winning_turn = ROWS_AND_COLS.iter().map(max).min().unwrap();
+            let unmarked: usize = board.iter().filter(|&&n| number_to_turn[n] > winning_turn).sum();
+            let just_called = turn_to_number[winning_turn];
 
-    let mut scores: Vec<_> = chunks.map(score).collect();
-    scores.sort_unstable_by_key(|s| s.turn);
-    scores
+            Board { turn: winning_turn, score: unmarked * just_called }
+        })
+        .collect()
 }
 
-pub fn part1(input: &[Input]) -> usize {
-    input.first().unwrap().score
+pub fn part1(input: &[Board]) -> usize {
+    input.iter().min_by_key(|b| b.turn).unwrap().score
 }
 
-pub fn part2(input: &[Input]) -> usize {
-    input.last().unwrap().score
+pub fn part2(input: &[Board]) -> usize {
+    input.iter().max_by_key(|b| b.turn).unwrap().score
 }

src/year2021/day05.rs

@@ -13,32 +13,32 @@
 use crate::util::iter::*;
 use crate::util::parse::*;
 
-type Vent = [u32; 4];
+type Input = (usize, usize);
 
-pub fn parse(input: &str) -> [usize; 2] {
+pub fn parse(input: &str) -> Input {
     let all: Vec<_> = input.iter_unsigned().chunk::<4>().collect();
     let (orthogonal, diagonal): (Vec<_>, Vec<_>) =
         all.iter().partition(|[x1, y1, x2, y2]| x1 == x2 || y1 == y2);
 
     let mut grid = vec![0_u8; 1_000_000];
-    let first = vents(&orthogonal, &mut grid);
-    let second = vents(&diagonal, &mut grid);
+    let first = vents(orthogonal, &mut grid);
+    let second = vents(diagonal, &mut grid);
 
-    [first, second]
+    (first, first + second)
 }
 
-pub fn part1(input: &[usize]) -> usize {
-    input[0]
+pub fn part1(input: &Input) -> usize {
+    input.0
 }
 
-pub fn part2(input: &[usize]) -> usize {
-    input[0] + input[1]
+pub fn part2(input: &Input) -> usize {
+    input.1
 }
 
-fn vents(input: &[Vent], grid: &mut [u8]) -> usize {
+fn vents(input: Vec<[usize; 4]>, grid: &mut [u8]) -> usize {
     let mut result = 0;
 
-    for &[x1, y1, x2, y2] in input {
+    for [x1, y1, x2, y2] in input {
         let (x1, y1, x2, y2) = (x1 as i32, y1 as i32, x2 as i32, y2 as i32);
         let count = (y2 - y1).abs().max((x2 - x1).abs());
         let delta = (y2 - y1).signum() * 1000 + (x2 - x1).signum();

src/year2021/day10.rs

@@ -8,39 +8,41 @@
 //! For part 2 the completion score is the remaining items on the stack, reversed and converted from
 //! corresponding closing delimiters. For example the completion string `])}>` would have a stack
 //! that looks like `<{([`, where the right hand side is the top of the stack.
-pub fn parse(input: &str) -> Vec<&[u8]> {
-    input.lines().map(str::as_bytes).collect()
-}
-
-pub fn part1(input: &[&[u8]]) -> u64 {
-    let mut stack = Vec::new();
-    let mut score = 0;
-
-    for line in input {
-        score += syntax_score(line, &mut stack);
-        stack.clear();
-    }
-
-    score
-}
+type Input = (u64, u64);
 
-pub fn part2(input: &[&[u8]]) -> u64 {
+pub fn parse(input: &str) -> Input {
     let mut stack = Vec::new();
     let mut scores = Vec::new();
+    let mut part_one = 0;
 
-    for line in input {
-        if syntax_score(line, &mut stack) == 0 {
+    for line in input.lines() {
+        let score = syntax_score(line, &mut stack);
+
+        if score == 0 {
             scores.push(autocomplete_score(&stack));
+        } else {
+            part_one += score;
         }
+
         stack.clear();
     }
 
     scores.sort_unstable();
-    scores[scores.len() / 2]
+    let part_two = scores[scores.len() / 2];
+
+    (part_one, part_two)
+}
+
+pub fn part1(input: &Input) -> u64 {
+    input.0
+}
+
+pub fn part2(input: &Input) -> u64 {
+    input.1
 }
 
-fn syntax_score(line: &[u8], stack: &mut Vec<u8>) -> u64 {
-    for &b in line {
+fn syntax_score(line: &str, stack: &mut Vec<u8>) -> u64 {
+    for b in line.bytes() {
         match b {
             b'(' | b'[' | b'{' | b'<' => stack.push(b),
             b')' => {

src/year2021/day11.rs

@@ -36,7 +36,7 @@ pub fn part2(input: &Input) -> usize {
     steps
 }
 
-fn simulate(input: &Input, predicate: impl Fn(usize, usize) -> bool) -> (usize, usize) {
+fn simulate(input: &Input, predicate: fn(usize, usize) -> bool) -> (usize, usize) {
     let mut grid = *input;
     let mut flashed = [true; 144];
     let mut todo = Vec::with_capacity(100);