Day 2 (refactor)

src/day2.rs

@@ -1,50 +1,40 @@
+const DAMPENING: bool = true;
+
 pub fn day2() {
     let puzzle_input = std::fs::read_to_string("res/puzzle_2.txt").unwrap();
 
-    let mut safe_count_without_dampening: u32 = 0;
-    let mut safe_count: u32 = 0;
-    for line in puzzle_input.lines() {
-        if line.is_empty() {
-            continue;
-        }
+    let lines: Vec<Vec<u64>> = puzzle_input
+        .lines()
+        .filter(|line| !line.is_empty())
+        .map(|line| {
+            line.split_whitespace()
+                .map(|x| x.parse::<u64>().unwrap())
+                .collect()
+        })
+        .collect();
 
-        let levels: Vec<u64> = line
-            .split_whitespace()
-            .map(|x| x.parse::<u64>().unwrap())
-            .collect();
-
-        fn check_levels(levels: &[u64]) -> bool {
-            let mut previous = levels[0];
-            let direction = levels[1] > levels[0];
-            for x in &levels[1..] {
-                if dist(*x, previous) > 3 || dist(*x, previous) == 0 || (*x > previous) != direction {
-                    return false;
-                }
-                previous = *x;
+    let safe_count = lines
+        .into_iter()
+        .filter(|levels| {
+            if DAMPENING {
+                (0..levels.len()).any(|skip| {
+                    let mut levels = levels.clone();
+                    levels.remove(skip);
+                    check_levels(&levels)
+                })
+            } else {
+                check_levels(&levels)
             }
-            true
-        }
-
-        if check_levels(&levels) {
-            safe_count += 1;
-            safe_count_without_dampening += 1;
-        } else if (0..levels.len()).any(|skip| {
-            let mut levels = levels.clone();
-            levels.remove(skip);
-            check_levels(&levels)
-        }) {
-            safe_count += 1;
-        }
-    }
+        })
+        .count();
 
     println!("Safe: {}", safe_count);
-    println!("Safe Without Dampening: {}", safe_count_without_dampening);
 }
 
-fn dist(a: u64, b: u64) -> u64 {
-    if a > b {
-        a - b
-    } else {
-        b - a
-    }
+fn check_levels(levels: &[u64]) -> bool {
+    let direction = levels[1] > levels[0];
+    levels.windows(2).all(|w| {
+        let dist: i32 = w[0] as i32 - w[1] as i32;
+        (w[1] > w[0]) == direction && dist >= -3 && dist <= 3 && dist != 0
+    })
 }