Tidy

src/year2024/day01.rs

@@ -13,10 +13,9 @@ pub fn parse(input: &str) -> Input {
 }
 
 pub fn part1(input: &Input) -> u32 {
-    let mut left = input.0.clone();
-    left.sort_unstable();
+    let (mut left, mut right) = input.clone();
 
-    let mut right = input.1.clone();
+    left.sort_unstable();
     right.sort_unstable();
 
     left.iter().zip(right).map(|(l, r)| l.abs_diff(r)).sum()

src/year2024/day09.rs

@@ -63,7 +63,6 @@ pub fn part1(disk: &[usize]) -> usize {
     checksum
 }
 
-#[allow(clippy::needless_range_loop)]
 pub fn part2(disk: &[usize]) -> usize {
     let mut block = 0;
     let mut checksum = 0;
@@ -80,9 +79,9 @@ pub fn part2(disk: &[usize]) -> usize {
     }
 
     // Add sentinel value and reverse vecs so that smallest blocks are last.
-    for i in 0..10 {
-        free[i].push(block);
-        free[i].reverse();
+    for heap in &mut free {
+        heap.push(block);
+        heap.reverse();
     }
 
     for (index, &size) in disk.iter().enumerate().rev() {
@@ -97,9 +96,9 @@ pub fn part2(disk: &[usize]) -> usize {
         let mut next_block = block;
         let mut next_index = usize::MAX;
 
-        for i in size..free.len() {
-            let top = free[i].len() - 1;
-            let first = free[i][top];
+        for (i, heap) in free.iter().enumerate().skip(size) {
+            let top = heap.len() - 1;
+            let first = heap[top];
 
             if first < next_block {
                 next_block = first;

src/year2024/day22.rs

@@ -76,6 +76,7 @@ fn worker(mutex: &Mutex<Exclusive>, batch: &[usize]) {
             let index = 6859 * a + 361 * b + 19 * c + d;
 
             // Only sell the first time we see a sequence.
+            // By storing the id in the array we don't need to zero every iteration which is faster.
             if seen[index] != id {
                 part_two[index] += price as u16;
                 seen[index] = id;

src/year2024/day24.rs

@@ -126,36 +126,37 @@ pub fn part2(input: &Input<'_>) -> String {
     }
 
     for &[left, kind, right, _, to] in gates {
-        if kind == "AND" {
-            // Check that all AND gates point to an OR, except for first AND.
-            if left != "x00" && right != "x00" && !output.contains(&(to, "OR")) {
-                swapped.insert(to);
-            }
-        }
-
-        if kind == "OR" {
-            // Check that only XOR gates point to output, except for last carry which is OR.
-            if to.starts_with('z') && to != "z45" {
-                swapped.insert(to);
-            }
-            // OR can never point to OR.
-            if output.contains(&(to, "OR")) {
-                swapped.insert(to);
+        match kind {
+            "AND" => {
+                // Check that all AND gates point to an OR, except for first AND.
+                if left != "x00" && right != "x00" && !output.contains(&(to, "OR")) {
+                    swapped.insert(to);
+                }
             }
-        }
-
-        if kind == "XOR" {
-            if left.starts_with('x') || right.starts_with('x') {
-                // Check that first level XOR points to second level XOR, except for first XOR.
-                if left != "x00" && right != "x00" && !output.contains(&(to, "XOR")) {
+            "OR" => {
+                // Check that only XOR gates point to output, except for last carry which is OR.
+                if to.starts_with('z') && to != "z45" {
                     swapped.insert(to);
                 }
-            } else {
-                // Second level XOR must point to output.
-                if !to.starts_with('z') {
+                // OR can never point to OR.
+                if output.contains(&(to, "OR")) {
                     swapped.insert(to);
                 }
             }
+            "XOR" => {
+                if left.starts_with('x') || right.starts_with('x') {
+                    // Check that first level XOR points to second level XOR, except for first XOR.
+                    if left != "x00" && right != "x00" && !output.contains(&(to, "XOR")) {
+                        swapped.insert(to);
+                    }
+                } else {
+                    // Second level XOR must point to output.
+                    if !to.starts_with('z') {
+                        swapped.insert(to);
+                    }
+                }
+            }
+            _ => unreachable!(),
         }
     }