Year 2020 speed and code quality improvements

Author: maneatingape

README.md

@@ -205,8 +205,8 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | --- | --- | --- | --: |
 | 1 | [Report Repair](https://adventofcode.com/2020/day/1) | [Source](src/year2020/day01.rs) | 12 |
 | 2 | [Password Philosophy](https://adventofcode.com/2020/day/2) | [Source](src/year2020/day02.rs) | 35 |
-| 3 | [Toboggan Trajectory](https://adventofcode.com/2020/day/3) | [Source](src/year2020/day03.rs) | 12 |
-| 4 | [Passport Processing](https://adventofcode.com/2020/day/4) | [Source](src/year2020/day04.rs) | 49 |
+| 3 | [Toboggan Trajectory](https://adventofcode.com/2020/day/3) | [Source](src/year2020/day03.rs) | 8 |
+| 4 | [Passport Processing](https://adventofcode.com/2020/day/4) | [Source](src/year2020/day04.rs) | 38 |
 | 5 | [Binary Boarding](https://adventofcode.com/2020/day/5) | [Source](src/year2020/day05.rs) | 11 |
 | 6 | [Custom Customs](https://adventofcode.com/2020/day/6) | [Source](src/year2020/day06.rs) | 35 |
 | 7 | [Handy Haversacks](https://adventofcode.com/2020/day/7) | [Source](src/year2020/day07.rs) | 69 |

src/year2020/day03.rs

@@ -11,29 +11,22 @@ pub fn parse(input: &str) -> Grid<u8> {
     Grid::parse(input)
 }
 
-pub fn part1(input: &Grid<u8>) -> u64 {
+pub fn part1(input: &Grid<u8>) -> usize {
     toboggan(input, 3, 1)
 }
 
-pub fn part2(input: &Grid<u8>) -> u64 {
-    toboggan(input, 1, 1)
-        * toboggan(input, 3, 1)
-        * toboggan(input, 5, 1)
-        * toboggan(input, 7, 1)
-        * toboggan(input, 1, 2)
+pub fn part2(input: &Grid<u8>) -> usize {
+    [(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)]
+        .into_iter()
+        .map(|(dx, dy)| toboggan(input, dx, dy))
+        .product()
 }
 
-fn toboggan(grid: &Grid<u8>, dx: i32, dy: i32) -> u64 {
-    let mut point = ORIGIN;
-    let mut trees = 0;
-
-    while point.y < grid.height {
-        if grid[point] == b'#' {
-            trees += 1;
-        }
-        point.x = (point.x + dx) % grid.width;
-        point.y += dy;
-    }
-
-    trees
+fn toboggan(grid: &Grid<u8>, dx: i32, dy: i32) -> usize {
+    (0..grid.height / dy)
+        .filter(|&i| {
+            let point = Point::new((i * dx) % grid.width, i * dy);
+            grid[point] == b'#'
+        })
+        .count()
 }

src/year2020/day04.rs

@@ -5,36 +5,44 @@
 //! maximize speed we'll instead hand code validation functions for each of the
 //! passport field criteria.
 use crate::util::iter::*;
+use crate::util::parse::*;
 use std::ops::RangeInclusive;
 
-type Passport<'a> = Vec<[&'a str; 2]>;
+type Input = (u32, u32);
 
-pub fn parse(input: &str) -> Vec<Passport<'_>> {
-    input.split("\n\n").map(parse_block).collect()
-}
+pub fn parse(input: &str) -> Input {
+    let mut passport = Vec::new();
+    let mut part_one = 0;
+    let mut part_two = 0;
+
+    for block in input.split("\n\n") {
+        parse_block(&mut passport, block);
+
+        if passport.len() == 7 {
+            part_one += 1;
+            part_two += passport.iter().all(validate_field) as u32;
+        }
 
-pub fn part1(input: &[Passport<'_>]) -> usize {
-    input.iter().filter(|passport| passport.len() == 7).count()
+        passport.clear();
+    }
+
+    (part_one, part_two)
 }
 
-pub fn part2(input: &[Passport<'_>]) -> usize {
-    input
-        .iter()
-        .filter(|passport| passport.len() == 7)
-        .filter(|passport| passport.iter().all(validate_field))
-        .count()
+pub fn part1(input: &Input) -> u32 {
+    input.0
 }
 
-fn parse_block(block: &str) -> Passport<'_> {
-    let mut fields = Vec::with_capacity(7);
+pub fn part2(input: &Input) -> u32 {
+    input.1
+}
 
+fn parse_block<'a>(passport: &mut Vec<[&'a str; 2]>, block: &'a str) {
     for pair @ [key, _] in block.split([':', ' ', '\n']).chunk::<2>() {
         if key != "cid" {
-            fields.push(pair);
+            passport.push(pair);
         }
     }
-
-    fields
 }
 
 fn validate_field(&[key, value]: &[&str; 2]) -> bool {
@@ -51,7 +59,7 @@ fn validate_field(&[key, value]: &[&str; 2]) -> bool {
 }
 
 fn validate_range(s: &str, range: RangeInclusive<u32>) -> bool {
-    s.parse().is_ok_and(|n| range.contains(&n))
+    range.contains(&s.unsigned())
 }
 
 fn validate_height(hgt: &str) -> bool {

src/year2020/day05.rs

@@ -13,16 +13,10 @@ pub struct Input {
 }
 
 pub fn parse(input: &str) -> Input {
-    let mut min = u32::MAX;
-    let mut max = u32::MIN;
-    let mut xor = 0;
-
-    for line in input.lines() {
+    let (min, max, xor) = input.lines().fold((u32::MAX, u32::MIN, 0), |(min, max, xor), line| {
         let id = line.bytes().fold(0, |acc, b| (acc << 1) | (b == b'B' || b == b'R') as u32);
-        min = min.min(id);
-        max = max.max(id);
-        xor ^= id;
-    }
+        (min.min(id), max.max(id), xor ^ id)
+    });
 
     Input { min, max, xor }
 }

src/year2020/day18.rs

@@ -70,7 +70,7 @@ fn next(bytes: &mut Bytes<'_>) -> Option<u8> {
 
 /// Convenience wrapper to return the value of either the next raw digit literal or a
 /// sub-expression nested in parentheses.
-fn value(bytes: &mut Bytes<'_>, helper: impl Fn(&mut Bytes<'_>) -> u64) -> u64 {
+fn value(bytes: &mut Bytes<'_>, helper: fn(&mut Bytes<'_>) -> u64) -> u64 {
     match next(bytes).unwrap() {
         b'(' => helper(bytes),
         b => b.to_decimal() as u64,