optimizations

Author: rene-d

src/year2017/day17/day17.rs

@@ -25,19 +25,21 @@ impl Puzzle {
     }
 
     /// Solve part two.
-    fn part2(&self) -> usize {
-        let mut buflen = 1;
+    const fn part2(&self) -> usize {
+        let step = self.step + 1;
+        let mut buflen: usize = 1;
         let mut pos = 0;
         let mut result = 0;
 
-        for i in 1..50_000_000 {
-            pos = (pos + self.step) % buflen + 1;
-            buflen += 1;
-            if pos == 1 {
-                result = i;
+        while buflen <= 50_000_000 {
+            if pos == 0 {
+                result = buflen;
             }
-        }
 
+            let skip = (buflen - pos).div_ceil(step);
+            buflen += skip;
+            pos = (pos + skip * step) % buflen;
+        }
         result
     }
 }

src/year2018/day11/day11.rs

@@ -1,5 +1,7 @@
 //! [Day 11: Chronal Charge](https://adventofcode.com/2018/day/11)
 
+use rayon::prelude::*;
+
 struct Puzzle {
     serial_number: i32,
 }
@@ -47,19 +49,16 @@ impl Puzzle {
 
     /// Solve part two.
     fn part2(&self) -> String {
-        let mut max = (0, 0, 0, 0);
-
-        for size in 3..300 {
-            let (x, y, p) = self.square_power(size);
-
-            if p < 0 {
-                break;
-            }
-
-            if p > max.0 {
-                max = (p, x, y, size);
-            }
-        }
+        let max = (3..300)
+            .par_bridge()
+            .map(|size| {
+                let (x, y, p) = self.square_power(size);
+
+                if p < 0 { None } else { Some((p, x, y, size)) }
+            })
+            .while_some()
+            .max()
+            .unwrap();
 
         format!("{},{},{}", max.1, max.2, max.3)
     }

src/year2018/day6/day6.rs

@@ -1,5 +1,7 @@
 //! [Day 6: Chronal Coordinates](https://adventofcode.com/2018/day/6)
 
+use rayon::prelude::*;
+
 const N: usize = 512;
 
 struct Puzzle {
@@ -99,25 +101,25 @@ impl Puzzle {
 
     /// Solve part two.
     fn part2(&self, limit: i32) -> u32 {
-        let mut result = 0;
-
-        for y in -limit..(limit + 400) {
-            for x in -limit..(limit + 400) {
-                let mut d = 0;
-
-                for &(px, py) in &self.points {
-                    d += (x - px).abs() + (y - py).abs();
-                    if d >= limit {
-                        break;
-                    }
-                }
-
-                if d < limit {
-                    result += 1;
-                }
-            }
-        }
-        result
+        (-limit..(limit + 400))
+            .par_bridge()
+            .map(|y| {
+                (-limit..(limit + 400))
+                    .map(|x| {
+                        let mut d = 0;
+
+                        for &(px, py) in &self.points {
+                            d += (x - px).abs() + (y - py).abs();
+                            if d >= limit {
+                                break;
+                            }
+                        }
+
+                        u32::from(d < limit)
+                    })
+                    .sum::<u32>()
+            })
+            .sum()
     }
 }
 

src/year2020/day19/day19.rs

@@ -1,6 +1,7 @@
 //! [Day 19: Monster Messages](https://adventofcode.com/2020/day/19)
 
 use rustc_hash::FxHashMap;
+use rayon::prelude::*;
 
 enum Rule {
     Ch(char),
@@ -112,7 +113,7 @@ impl Rules {
 
     fn solve(&self, messages: &[String]) -> usize {
         messages
-            .iter()
+            .par_iter()
             .filter(|message| self.matches(0, message))
             .count()
     }

src/year2024/day7/day7.rs

@@ -1,5 +1,7 @@
 //! [Day 7: Bridge Repair](https://adventofcode.com/2024/day/7)
 
+use rayon::prelude::*;
+
 struct Equation {
     test_value: u64,
     values: Vec<u64>,
@@ -107,7 +109,7 @@ impl Puzzle {
     /// Solve part one.
     fn part1(&self) -> u64 {
         self.equations
-            .iter()
+            .par_iter()
             .filter(|e| Self::check_two_operators(e))
             .map(|x| x.test_value)
             .sum()
@@ -116,7 +118,7 @@ impl Puzzle {
     /// Solve part two.
     fn part2(&self) -> u64 {
         self.equations
-            .iter()
+            .par_iter()
             .filter(|e| Self::check_three_operators(e))
             .map(|x| x.test_value)
             .sum()