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