5 files changed, 134 insertions, 6 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 8018f3d..766c71c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,3 +1,3 @@
 [workspace]
-members = ["aoc", "day1"]
-resolver = "2"
\ No newline at end of file
+members = ["aoc", "day1", "day2"]
+resolver = "2"
diff --git a/aoc/src/lib.rs b/aoc/src/lib.rs
index 5fad72d..c4318e1 100644
--- a/aoc/src/lib.rs
+++ b/aoc/src/lib.rs
@@ -2,6 +2,7 @@ use clap::Parser;
 use std::fs::File;
 use std::io;
 use std::io::{BufRead, BufReader, Read};
+use std::time::Instant;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -47,13 +48,17 @@ pub fn main(day: &dyn Day) {
     let buffer = BufReader::new(reader);
 
     let result: String;
+
+    let now = Instant::now();
+
     if args.part == 1 {
         result = day.part_1(buffer);
     } else {
         result = day.part_2(buffer);
     }
 
-    println!("Result: {result}")
+    println!("Result: {result}");
+    println!("Time to run: {}s", now.elapsed().as_secs_f64());
 }
 
 pub fn test_day<T: Day>(day: &T) {
diff --git a/day1/src/main.rs b/day1/src/main.rs
index fd78563..5ac96f2 100644
--- a/day1/src/main.rs
+++ b/day1/src/main.rs
@@ -1,3 +1,8 @@
+
+use aoc;
+use std::io::{BufReader, Read};
+use aoc::Day;
+
 struct Day1 {}
 
 impl Day1 {
@@ -88,9 +93,6 @@ impl Day for Day1 {
     }
 }
 
-use aoc;
-use std::io::{BufReader, Read};
-use aoc::Day;
 
 fn main() {
     aoc::main(&Day1 {});
diff --git a/day2/Cargo.toml b/day2/Cargo.toml
new file mode 100644
index 0000000..a4354d4
--- /dev/null
+++ b/day2/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "day2"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aoc = { path = "../aoc" }
diff --git a/day2/src/main.rs b/day2/src/main.rs
new file mode 100644
index 0000000..15d0224
--- /dev/null
+++ b/day2/src/main.rs
@@ -0,0 +1,114 @@
+use std::io::{BufReader, Read};
+use aoc::Day;
+
+struct Day2{}
+
+impl Day2 {
+    fn part_n(&self, input: BufReader<Box<dyn Read>>) -> Vec<Vec<i32>> {
+        self.read_lines(input)
+            .iter()
+            .map(|l| {
+                l.split_whitespace().map(|c| {
+                    c.parse::<i32>().unwrap()
+                })
+                .collect()
+            })
+            .collect()
+    }
+
+    fn is_safe(&self, line: &Vec<i32>) -> Result<bool, usize> {
+        let mut last: Option<&i32> = None;
+        let mut ascending: Option<bool> = None;
+
+        for (index, i) in line.iter().enumerate() {
+            if let Some(l) = last {
+                let abs_diff = l.abs_diff(*i);
+
+
+                if abs_diff < 1 || abs_diff > 3 {
+                    return Err(index)
+                }
+
+                if let Some(asc) = ascending {
+                    let diff = i - l;
+
+                    if (asc && diff < 0) || (!asc && diff > 0) {
+                        return Err(index)
+                    }
+
+                } else {
+                    ascending = Some(i > l);
+                }
+            }
+
+            last = Some(i);
+        }
+
+        Ok(true)
+    }
+}
+
+impl Day for Day2 {
+    fn example_input(&self) -> &'static str {
+        r#"
+        7 6 4 2 1
+        1 2 7 8 9
+        9 7 6 2 1
+        1 3 2 4 5
+        8 6 4 4 1
+        1 3 6 7 9
+        "#.trim()
+    }
+
+    fn example_result_part_1(&self) -> &'static str {
+        "2"
+    }
+
+    fn example_result_part_2(&self) -> &'static str {
+        "4"
+    }
+
+    fn part_1(&self, input: BufReader<Box<dyn Read>>) -> String {
+        self.part_n(input)
+            .iter()
+            .filter(|&l| self.is_safe(l).unwrap_or(false))
+            .count()
+            .to_string()
+    }
+
+    fn part_2(&self, input: BufReader<Box<dyn Read>>) -> String {
+        self.part_n(input)
+            .iter()
+            .filter(|&l| {
+                match self.is_safe(l) {
+                    Ok(val) => val,
+                    Err(_index) => {
+                        l
+                            .iter()
+                            .enumerate()
+                            .map(|(index, _)| {
+                                let mut copy = l.clone();
+                                copy.remove(index);
+                                self.is_safe(&copy).unwrap_or(false)
+                            })
+                            .any(|val| val)
+                    },
+                }
+            })
+            .count()
+            .to_string()
+    }
+}
+
+fn main() {
+    aoc::main(&Day2 {});
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_day2() {
+        aoc::test_day(&Day2 {});
+    }
+}