day-02 part-2

2024/benchmarks.txt

@@ -14,6 +14,25 @@ running 0 tests
 test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
 day_01_bench  fastest       │ slowest       │ median        │ mean          │ samples │ iters
-├─ part1      89.39 µs      │ 119 µs        │ 89.79 µs      │ 92.23 µs      │ 100     │ 100
+├─ part1      87.73 µs      │ 151.9 µs      │ 89.5 µs       │ 95.49 µs      │ 100     │ 100
-╰─ part2      237.9 µs      │ 310.8 µs      │ 241.7 µs      │ 244.3 µs      │ 100     │ 100
+╰─ part2      235.9 µs      │ 335.2 µs      │ 240.3 µs      │ 246.5 µs      │ 100     │ 100
+
+
+running 2 tests
+ii
+test result: ok. 0 passed; 0 failed; 2 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+day_02_bench  fastest       │ slowest       │ median        │ mean          │ samples │ iters
+├─ part1      147.8 µs      │ 162.6 µs      │ 149.6 µs      │ 150.6 µs      │ 100     │ 100
+╰─ part2      214.8 µs      │ 304.3 µs      │ 219.8 µs      │ 224.6 µs      │ 100     │ 100
 

2024/day-02/src/part2.rs

@@ -1,9 +1,50 @@
 use miette::Result;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Level {
+    Safe,
+    Unsafe,
+}
+
+impl From<&Vec<usize>> for Level {
+    fn from(value: &Vec<usize>) -> Self {
+        if is_safe(value) {
+            return Self::Safe;
+        }
+        for (idx, _) in value.iter().enumerate() {
+            let mut new_levels = value.clone();
+            new_levels.remove(idx);
+            if is_safe(&new_levels) {
+                return Self::Safe;
+            }
+        }
+        Self::Unsafe
+    }
+}
+
+fn is_safe(levels: &[usize]) -> bool {
+    (levels.iter().is_sorted() || levels.iter().rev().is_sorted())
+        && levels.windows(2).all(|pairs| {
+            let diff = pairs[0].abs_diff(pairs[1]);
+            (1..=3).contains(&diff)
+        })
+}
+
 #[tracing::instrument]
 pub fn process(input: &str) -> Result<usize> {
-    todo!("day xx - part 2");
+    let sum = input
-    Ok(0)
+        .lines()
+        .map(|line| {
+            let levels = line
+                .split_whitespace()
+                .map(|x| x.parse::<usize>().unwrap())
+                .collect::<Vec<_>>();
+
+            Level::from(&levels)
+        })
+        .filter(|&report| report == Level::Safe)
+        .count();
+    Ok(sum)
 }
 
 #[cfg(test)]
@@ -12,9 +53,14 @@ mod tests {
 
     #[test]
     fn test_process() -> Result<()> {
-        let input = "";
+        let input = "7 6 4 2 1
-        todo!("haven't built test yet");
+1 2 7 8 9
-        let result = 0;
+9 7 6 2 1
+1 3 2 4 5
+8 6 4 4 1
+1 3 6 7 9
+";
+        let result = 4;
         assert_eq!(process(input)?, result);
         Ok(())
     }