Year 2017 speed and code quality improvements

Author: maneatingape

README.md

@@ -302,14 +302,14 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 1 | [Inverse Captcha](https://adventofcode.com/2017/day/1) | [Source](src/year2017/day01.rs) | 1 |
 | 2 | [Corruption Checksum](https://adventofcode.com/2017/day/2) | [Source](src/year2017/day02.rs) | 2 |
 | 3 | [Spiral Memory](https://adventofcode.com/2017/day/3) | [Source](src/year2017/day03.rs) | 2 |
-| 4 | [High-Entropy Passphrases](https://adventofcode.com/2017/day/4) | [Source](src/year2017/day04.rs) | 98 |
+| 4 | [High-Entropy Passphrases](https://adventofcode.com/2017/day/4) | [Source](src/year2017/day04.rs) | 86 |
 | 5 | [A Maze of Twisty Trampolines, All Alike](https://adventofcode.com/2017/day/5) | [Source](src/year2017/day05.rs) | 22000 |
 | 6 | [Memory Reallocation](https://adventofcode.com/2017/day/6) | [Source](src/year2017/day06.rs) | 81 |
 | 7 | [Recursive Circus](https://adventofcode.com/2017/day/7) | [Source](src/year2017/day07.rs) | 93 |
 | 8 | [I Heard You Like Registers](https://adventofcode.com/2017/day/8) | [Source](src/year2017/day08.rs) | 47 |
 | 9 | [Stream Processing](https://adventofcode.com/2017/day/9) | [Source](src/year2017/day09.rs) | 23 |
 | 10 | [Knot Hash](https://adventofcode.com/2017/day/10) | [Source](src/year2017/day10.rs) | 66 |
-| 11 | [Hex Ed](https://adventofcode.com/2017/day/11) | [Source](src/year2017/day11.rs) | 18 |
+| 11 | [Hex Ed](https://adventofcode.com/2017/day/11) | [Source](src/year2017/day11.rs) | 15 |
 | 12 | [Digital Plumber](https://adventofcode.com/2017/day/12) | [Source](src/year2017/day12.rs) | 61 |
 | 13 | [Packet Scanners](https://adventofcode.com/2017/day/13) | [Source](src/year2017/day13.rs) | 1 |
 | 14 | [Disk Defragmentation](https://adventofcode.com/2017/day/14) | [Source](src/year2017/day14.rs) | 438 |
@@ -321,7 +321,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 20 | [Particle Swarm](https://adventofcode.com/2017/day/20) | [Source](src/year2017/day20.rs) | 245 |
 | 21 | [Fractal Art](https://adventofcode.com/2017/day/21) | [Source](src/year2017/day21.rs) | 5 |
 | 22 | [Sporifica Virus](https://adventofcode.com/2017/day/22) | [Source](src/year2017/day22.rs) | 36000 |
-| 23 | [Coprocessor Conflagration](https://adventofcode.com/2017/day/23) | [Source](src/year2017/day23.rs) | 19 |
+| 23 | [Coprocessor Conflagration](https://adventofcode.com/2017/day/23) | [Source](src/year2017/day23.rs) | 16 |
 | 24 | [Electromagnetic Moat](https://adventofcode.com/2017/day/24) | [Source](src/year2017/day24.rs) | 275 |
 | 25 | [The Halting Problem](https://adventofcode.com/2017/day/25) | [Source](src/year2017/day25.rs) | 3698 |
 

src/year2017/day02.rs

@@ -19,17 +19,17 @@ pub fn parse(input: &str) -> Input {
 }
 
 pub fn part1(input: &Input) -> u32 {
-    input.iter().map(|values| values[values.len() - 1] - values[0]).sum()
+    input.iter().map(|values| values.last().unwrap() - values.first().unwrap()).sum()
 }
 
 pub fn part2(input: &Input) -> u32 {
     input
         .iter()
         .map(|values| {
-            for i in 0..values.len() {
-                for j in i + 1..values.len() {
-                    if values[j].is_multiple_of(values[i]) {
-                        return values[j] / values[i];
+            for (i, &smaller) in values.iter().enumerate() {
+                for &larger in &values[i + 1..] {
+                    if larger.is_multiple_of(smaller) {
+                        return larger / smaller;
                     }
                 }
             }

src/year2017/day04.rs

@@ -32,9 +32,9 @@ pub fn part1(input: &Input<'_>) -> usize {
 }
 
 pub fn part2(input: &Input<'_>) -> usize {
-    // Calculate the frequency of each letter as anagrams will have the same values.
-    fn convert(token: &str) -> [u8; 26] {
-        let mut freq = [0; 26];
+    // Only 26 elements are needed but 32 is faster to hash.
+    fn convert(token: &str) -> [u8; 32] {
+        let mut freq = [0; 32];
         for b in token.bytes() {
             freq[(b - b'a') as usize] += 1;
         }

src/year2017/day11.rs

@@ -16,24 +16,32 @@ pub fn parse(input: &str) -> Input {
     let mut part_two = 0;
 
     while let Some(first) = iter.next() {
-        match first {
-            b'n' => match iter.next().unwrap_or(0) {
+        if first == b'n' {
+            match iter.next().unwrap_or(0) {
                 b'e' => {
+                    iter.next(); // Consume trailing delimeter.
                     q += 1;
                     r -= 1;
                 }
-                b'w' => q -= 1,
+                b'w' => {
+                    iter.next(); // Consume trailing delimeter.
+                    q -= 1;
+                }
                 _ => r -= 1,
-            },
-            b's' => match iter.next().unwrap_or(0) {
-                b'e' => q += 1,
+            }
+        } else {
+            match iter.next().unwrap_or(0) {
+                b'e' => {
+                    iter.next(); // Consume trailing delimeter.
+                    q += 1;
+                }
                 b'w' => {
+                    iter.next(); // Consume trailing delimeter.
                     q -= 1;
                     r += 1;
                 }
                 _ => r += 1,
-            },
-            _ => (),
+            }
         }
 
         // q + r + s = 0, so we can always determine s given the other two.

src/year2017/day23.rs

@@ -58,25 +58,30 @@ pub fn parse(input: &str) -> u32 {
 
 /// The number of `mul` operations is `(n - 2)²`
 pub fn part1(input: &u32) -> u32 {
-    (input - 2) * (input - 2)
+    let n = input - 2;
+    n * n
 }
 
 /// Count the number of composite numbers in a range calculated from the input number.
 pub fn part2(input: &u32) -> usize {
-    (0..=1000).filter_map(|n| composite(100_000 + 100 * input + 17 * n)).count()
+    let start = 100_000 + 100 * input;
+    let end = start + 17001;
+    (start..end).step_by(17).filter(|&n| is_composite(n)).count()
 }
 
 /// Simple [prime number check](https://en.wikipedia.org/wiki/Primality_test)
 /// of all factors from 2 to √n inclusive.
-fn composite(n: u32) -> Option<u32> {
+fn is_composite(n: u32) -> bool {
     if n.is_multiple_of(2) {
-        return Some(n);
+        return true;
     }
-    for f in (3..).step_by(2).take_while(|m| m * m <= n) {
+
+    let root = n.isqrt() + 1;
+    for f in (3..root).step_by(2) {
         if n.is_multiple_of(f) {
-            return Some(n);
+            return true;
         }
     }
 
-    None
+    false
 }