Day 2

src/day1.rs

@@ -0,0 +1,32 @@
+pub fn day1() {
+    let puzzle_input = std::fs::read_to_string("res/puzzle_1.txt").unwrap();
+    let (mut left, mut right): (Vec<u64>, Vec<u64>) = puzzle_input
+        .lines()
+        .filter(|line| !line.is_empty())
+        .map(|line| {
+            let nums: Vec<&str> = line.split_whitespace().collect();
+            (
+                nums[0].parse::<u64>().expect("Invalid left number"),
+                nums[1].parse::<u64>().expect("Invalid right number")
+            )
+        })
+        .unzip();
+    println!("Found {} number pairs.", left.len());
+
+    left.sort();
+    right.sort();
+
+    let differences: u64 = left.iter()
+        .zip(right.iter())
+        .map(|(a, b)| if a > b { a - b } else { b - a })
+        .sum();
+    println!("{}", differences);
+
+    let similarity: u64 = left.iter()
+        .map(|a| {
+            let occurences = right.iter().filter(|b| a == *b).count();
+            a * occurences as u64
+        })
+        .sum();
+    println!("{}", similarity);
+}

src/day2.rs

@@ -0,0 +1,50 @@
+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 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;
+            }
+            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;
+        }
+    }
+
+    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
+    }
+}

src/main.rs

@@ -1,34 +1,6 @@
-use std::fs;
+mod day1;
+mod day2;
 
 fn main() {
-    let puzzle_input = fs::read_to_string("res/puzzle_1.txt").unwrap();
+    day2::day2();
-    let (mut left, mut right): (Vec<u64>, Vec<u64>) = puzzle_input
-        .lines()
-        .filter(|line| !line.is_empty())
-        .map(|line| {
-            let nums: Vec<&str> = line.split_whitespace().collect();
-            (
-                nums[0].parse::<u64>().expect("Invalid left number"),
-                nums[1].parse::<u64>().expect("Invalid right number")
-            )
-        })
-        .unzip();
-    println!("Found {} number pairs.", left.len());
-
-    left.sort();
-    right.sort();
-
-    let differences: u64 = left.iter()
-        .zip(right.iter())
-        .map(|(a, b)| if a > b { a - b } else { b - a })
-        .sum();
-    println!("{}", differences);
-
-    let similarity: u64 = left.iter()
-        .map(|a| {
-            let occurences = right.iter().filter(|b| a == *b).count();
-            a * occurences as u64
-        })
-        .sum();
-    println!("{}", similarity);
 }