day2

1 files changed, 72 insertions, 1 deletions

diff --git a/src/main.rs b/src/main.rs
index ee10457..51a4a74 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,11 +2,19 @@
 
 use std::fs;
 use std::collections::HashSet;
+use regex::Regex;
 
 fn read_file(file: &str) -> String {
     fs::read_to_string(file).unwrap()
 }
 
+fn read_lines(file: &str) -> Vec<String> {
+    read_file(file).split('\n')
+                   .filter(|x| !x.is_empty())
+                   .map(String::from)
+                   .collect()
+}
+
 fn read_numbers(file: &str) -> Vec<i32> {
     read_file(file).split('\n')
                    .filter(|x| !x.is_empty())
@@ -45,8 +53,55 @@ fn day1() {
     }
 }
 
+struct PasswordEntry {
+    min : usize,
+    max : usize,
+    character : char,
+    password : String,
+}
+
+impl PasswordEntry {
+    fn new(input: &str) -> PasswordEntry {
+        let re = Regex::new(r"^([0-9]+)-([0-9]+) ([a-z]): ([a-z]+)$").unwrap();
+        let caps = re.captures(&input).unwrap();
+        PasswordEntry {
+            min : caps[1].parse::<usize>().unwrap(),
+            max : caps[2].parse::<usize>().unwrap(),
+            character : caps[3].parse::<char>().unwrap(),
+            password : caps[4].to_string(),
+        }
+    }
+
+    fn is_valid(&self) -> bool {
+        let count = self.password.chars().filter(|x| *x == self.character).count();
+        count >= self.min && count <= self.max
+    }
+
+    fn is_valid_new(&self) -> bool {
+        let c1 = self.password.chars().nth(self.min-1).unwrap();
+        let c2 = self.password.chars().nth(self.max-1).unwrap();
+        c1 != c2 && (c1 == self.character || c2 == self.character)
+    }
+}
+
+fn day2() {
+    let input : Vec<PasswordEntry> = read_lines("input02")
+                                     .iter()
+                                     .map(|x| PasswordEntry::new(&x))
+                                     .collect();
+    let count = input.iter()
+                     .filter(|x| x.is_valid())
+                     .count();
+    println!("2a: {}", count);
+
+    let count = input.iter()
+                     .filter(|x| x.is_valid_new())
+                     .count();
+    println!("2b: {}", count);
+}
+
 fn main() {
-    day1();
+    day2();
 }
 
 #[cfg(test)]
@@ -73,4 +128,20 @@ mod tests {
             break;
         }
     }
+
+    #[test]
+    fn test_day2() {
+        let lines = ["1-3 a: abcde",
+                     "1-3 b: cdefg",
+                     "2-9 c: ccccccccc"];
+        let entries : Vec<PasswordEntry> = lines.iter().map(|x| PasswordEntry::new(&x)).collect();
+        assert_eq!(entries[0].is_valid(), true);
+        assert_eq!(entries[1].is_valid(), false);
+        assert_eq!(entries[2].is_valid(), true);
+
+        assert_eq!(entries[0].is_valid_new(), true);
+        assert_eq!(entries[1].is_valid_new(), false);
+        assert_eq!(entries[2].is_valid_new(), false);
+
+    }
 }