Faster fixed size array instead of vec

Author: maneatingape

README.md

@@ -109,15 +109,15 @@ pie
     "Day 18" : 1904
     "Day 23" : 1709
     "Day 19" : 933
-    "Others" : 1941
+    "Others" : 1916
 ```
 
 | Day | Problem | Solution | Benchmark (μs) |
 | --- | --- | --- | --: |
 | 1 | [Sonar Sweep](https://adventofcode.com/2021/day/1) | [Source](src/year2021/day01.rs) | 22 |
 | 2 | [Dive!](https://adventofcode.com/2021/day/2) | [Source](src/year2021/day02.rs) | 15 |
 | 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) | 45 |
+| 4 | [Giant Squid](https://adventofcode.com/2021/day/4) | [Source](src/year2021/day04.rs) | 20 |
 | 5 | [Hydrothermal Venture](https://adventofcode.com/2021/day/5) | [Source](src/year2021/day05.rs) | 202 |
 | 6 | [Lanternfish](https://adventofcode.com/2021/day/6) | [Source](src/year2021/day06.rs) | 2 |
 | 7 | [The Treachery of Whales](https://adventofcode.com/2021/day/7) | [Source](src/year2021/day07.rs) | 19 |

src/year2021/day04.rs

@@ -13,6 +13,7 @@
 //! score for each board. Sort each result by turn and the answers for part 1 and part1 are the
 //! first and last values respectively.
 use crate::util::parse::*;
+use std::array::from_fn;
 
 pub struct Input {
     turn: usize,
@@ -23,23 +24,25 @@ pub fn parse(input: &str) -> Vec<Input> {
     let mut to_turn = [0; 100];
     let mut from_turn = [0; 100];
 
-    let chunks: Vec<Vec<usize>> =
-        input.split("\n\n").map(|s| s.iter_unsigned().collect()).collect();
+    let mut chunks = input.split("\n\n");
 
-    for (i, &n) in chunks[0].iter().enumerate() {
+    for (i, n) in chunks.next().unwrap().iter_unsigned().enumerate() {
         to_turn[n] = i;
         from_turn[i] = n;
     }
 
-    let score = |board: &Vec<usize>| {
-        let turns: Vec<_> = board.iter().map(|&n| to_turn[n]).collect();
+    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().skip(0).step_by(5).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(),
@@ -48,18 +51,19 @@ pub fn parse(input: &str) -> Vec<Input> {
         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];
+
         Input { turn: winning_turn, score: unmarked * just_called }
     };
 
-    let mut result: Vec<_> = chunks.iter().skip(1).map(score).collect();
-    result.sort_unstable_by(|a, b| a.turn.cmp(&b.turn));
-    result
+    let mut scores: Vec<_> = chunks.map(score).collect();
+    scores.sort_unstable_by_key(|s| s.turn);
+    scores
 }
 
 pub fn part1(input: &[Input]) -> usize {
-    input[0].score
+    input.first().unwrap().score
 }
 
 pub fn part2(input: &[Input]) -> usize {
-    input[input.len() - 1].score
+    input.last().unwrap().score
 }