Tidy code

Author: maneatingape

README.md

@@ -80,7 +80,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 3 | [Mull It Over](https://adventofcode.com/2024/day/3) | [Source](src/year2024/day03.rs) | 8 |
 | 4 | [Ceres Search](https://adventofcode.com/2024/day/4) | [Source](src/year2024/day04.rs) | 77 |
 | 5 | [Print Queue](https://adventofcode.com/2024/day/5) | [Source](src/year2024/day05.rs) | 18 |
-| 6 | [Guard Gallivant](https://adventofcode.com/2024/day/6) | [Source](src/year2024/day06.rs) | 439 |
+| 6 | [Guard Gallivant](https://adventofcode.com/2024/day/6) | [Source](src/year2024/day06.rs) | 405 |
 | 7 | [Bridge Repair](https://adventofcode.com/2024/day/7) | [Source](src/year2024/day07.rs) | 136 |
 | 8 | [Resonant Collinearity](https://adventofcode.com/2024/day/8) | [Source](src/year2024/day08.rs) | 8 |
 | 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 106 |

src/year2016/day03.rs

@@ -17,10 +17,7 @@ pub fn part1(input: &[u32]) -> usize {
 }
 
 pub fn part2(input: &[u32]) -> usize {
-    let first = count(input.iter().step_by(3));
-    let second = count(input.iter().skip(1).step_by(3));
-    let third = count(input.iter().skip(2).step_by(3));
-    first + second + third
+    (0..3).map(|skip| count(input.iter().skip(skip).step_by(3))).sum()
 }
 
 fn count<'a, I>(iter: I) -> usize

src/year2017/day06.rs

@@ -55,19 +55,10 @@ pub fn parse(input: &str) -> Input {
         // the mask unchanged.
         // If some nibbles have that bit set, then we will "narrow" the mask to only consider
         // those nibbles.
-        let mut mask = 0x8888888888888888;
-
-        let first = memory & mask;
-        mask = if first == 0 { mask } else { first };
-
-        let second = (memory << 1) & mask;
-        mask = if second == 0 { mask } else { second };
-
-        let third = (memory << 2) & mask;
-        mask = if third == 0 { mask } else { third };
-
-        let fourth = (memory << 3) & mask;
-        mask = if fourth == 0 { mask } else { fourth };
+        let mask = (0..4).fold(0x8888888888888888, |mask, shift| {
+            let result = (memory << shift) & mask;
+            if result == 0 { mask } else { result }
+        });
 
         // The mask will have a 1 bit set for each of the joint highest values.
         // Choose the lowest index which is the most significant bit set.

src/year2017/day13.rs

@@ -65,16 +65,13 @@ pub fn parse(input: &str) -> Input {
 
 /// Leaving at time zero the packet will encounter each scanner at time `depth`.
 pub fn part1(input: &Input) -> u32 {
-    let mut result = 0;
-
-    for &[depth, range] in input {
-        let period = 2 * (range - 1);
-        if depth.is_multiple_of(period) {
-            result += depth * range;
-        }
-    }
-
-    result
+    input
+        .iter()
+        .filter_map(|&[depth, range]| {
+            let period = 2 * (range - 1);
+            depth.is_multiple_of(period).then_some(depth * range)
+        })
+        .sum()
 }
 
 /// Sieves possible values at each scanner stage to reduce the number of possible values.

src/year2018/day07.rs

@@ -35,17 +35,7 @@ pub fn parse(input: &str) -> Input {
 pub fn part1(input: &Input) -> String {
     // Move all steps with no dependencies to the `ready` map. A `BTreeMap` is sorted by key
     // so will retrieve steps in alphabetical order.
-    let mut ready = BTreeMap::new();
-    let mut blocked = FastMap::new();
-
-    for (key, step) in input.clone() {
-        if step.remaining == 0 {
-            ready.insert(key, step);
-        } else {
-            blocked.insert(key, step);
-        }
-    }
-
+    let (mut ready, mut blocked) = split_by_readiness(input);
     let mut done = String::new();
 
     while let Some((key, step)) = ready.pop_first() {
@@ -75,16 +65,7 @@ pub fn part2(input: &Input) -> u32 {
 
 pub fn part2_testable(input: &Input, max_workers: usize, base_duration: u32) -> u32 {
     // Same as part one, move all tasks that are root nodes to the `ready` map.
-    let mut ready = BTreeMap::new();
-    let mut blocked = FastMap::new();
-
-    for (key, step) in input.clone() {
-        if step.remaining == 0 {
-            ready.insert(key, step);
-        } else {
-            blocked.insert(key, step);
-        }
-    }
+    let (mut ready, mut blocked) = split_by_readiness(input);
 
     // Loop until there are no more steps available and all workers are idle.
     let mut time = 0;
@@ -123,3 +104,18 @@ pub fn part2_testable(input: &Input, max_workers: usize, base_duration: u32) ->
 
     time
 }
+
+fn split_by_readiness(input: &Input) -> (BTreeMap<u8, Step>, FastMap<u8, Step>) {
+    let mut ready = BTreeMap::new();
+    let mut blocked = FastMap::new();
+
+    for (key, step) in input.clone() {
+        if step.remaining == 0 {
+            ready.insert(key, step);
+        } else {
+            blocked.insert(key, step);
+        }
+    }
+
+    (ready, blocked)
+}

src/year2018/day16.rs

@@ -72,7 +72,7 @@ pub fn part2(input: &Input) -> usize {
     // that only has one possibility.
     let mut convert = [0; 16];
 
-    while let Some(index) = masks.iter().position(|m| m.count_ones() == 1) {
+    while let Some(index) = masks.iter().position(|&n| n.count_ones() == 1) {
         let mask = masks[index];
         // This opcode has only 1 possible mapping, so remove possibility from other opcodes.
         masks.iter_mut().for_each(|m| *m &= !mask);

src/year2020/day06.rs

@@ -20,31 +20,23 @@ pub fn parse(input: &str) -> Vec<u32> {
 }
 
 pub fn part1(input: &[u32]) -> u32 {
-    let mut total = 0;
-    let mut group = u32::MIN;
-
-    for &passenger in input {
-        if passenger == 0 {
-            total += group.count_ones();
-            group = u32::MIN;
-        } else {
-            group |= passenger;
-        }
-    }
-
-    total + group.count_ones()
+    count_answers(input, u32::MIN, |group, passenger| group | passenger)
 }
 
 pub fn part2(input: &[u32]) -> u32 {
+    count_answers(input, u32::MAX, |group, passenger| group & passenger)
+}
+
+fn count_answers(input: &[u32], initial: u32, combine: fn(u32, u32) -> u32) -> u32 {
     let mut total = 0;
-    let mut group = u32::MAX;
+    let mut group = initial;
 
     for &passenger in input {
         if passenger == 0 {
             total += group.count_ones();
-            group = u32::MAX;
+            group = initial;
         } else {
-            group &= passenger;
+            group = combine(group, passenger);
         }
     }
 

src/year2020/day09.rs

@@ -1,4 +1,4 @@
-//! # Custom Customs
+//! # Encoding Error
 //!
 //! Part one is solved with a brute force search over every possible pair in the preamble, using a
 //! sliding window to advance to each number. To allow testing with the sample data that uses a

src/year2021/day07.rs

@@ -24,10 +24,7 @@ pub fn part2(input: &[i32]) -> i32 {
         (n * (n + 1)) / 2
     };
 
-    let first: i32 = input.iter().map(|&x| triangle(x, mean)).sum();
-    let second: i32 = input.iter().map(|&x| triangle(x, mean + 1)).sum();
-    let third: i32 = input.iter().map(|&x| triangle(x, mean - 1)).sum();
-    first.min(second).min(third)
+    (-1..=1).map(|delta| input.iter().map(|&x| triangle(x, mean + delta)).sum()).min().unwrap()
 }
 
 fn median(input: &[i32]) -> i32 {

src/year2021/day11.rs

@@ -49,15 +49,8 @@ fn simulate(input: &Input, predicate: fn(usize, usize) -> bool) -> (usize, usize
         for y in 0..10 {
             for x in 0..10 {
                 let index = 12 * (y + 1) + (x + 1);
-
-                if grid[index] < 9 {
-                    grid[index] += 1;
-                    flashed[index] = false;
-                } else {
-                    grid[index] = 0;
-                    flashed[index] = true;
-                    todo.push(index);
-                }
+                flashed[index] = false;
+                bump_octopus(&mut grid, &mut flashed, &mut todo, index);
             }
         }
 
@@ -75,16 +68,8 @@ fn simulate(input: &Input, predicate: fn(usize, usize) -> bool) -> (usize, usize
                 index - 12,
                 index - 13,
             ] {
-                if flashed[next] {
-                    continue;
-                }
-
-                if grid[next] < 9 {
-                    grid[next] += 1;
-                } else {
-                    grid[next] = 0;
-                    flashed[next] = true;
-                    todo.push(next);
+                if !flashed[next] {
+                    bump_octopus(&mut grid, &mut flashed, &mut todo, next);
                 }
             }
         }
@@ -95,3 +80,15 @@ fn simulate(input: &Input, predicate: fn(usize, usize) -> bool) -> (usize, usize
 
     (total, steps)
 }
+
+/// Increments an octopus's energy. If it reaches 10, it flashes and is added to the queue.
+#[inline]
+fn bump_octopus(grid: &mut [u8], flashed: &mut [bool], todo: &mut Vec<usize>, index: usize) {
+    if grid[index] < 9 {
+        grid[index] += 1;
+    } else {
+        grid[index] = 0;
+        flashed[index] = true;
+        todo.push(index);
+    }
+}