Solution for day 2 part 1.

2020/Cargo.lock

@@ -7,6 +7,16 @@ dependencies = [
  "anyhow",
  "aoc-runner",
  "aoc-runner-derive",
+ "regex",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
+dependencies = [
+ "memchr",
 ]
 
 [[package]]
@@ -50,6 +60,18 @@ version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
 
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "memchr"
+version = "2.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.24"
@@ -68,6 +90,24 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "regex"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38cf2c13ed4745de91a5eb834e11c00bcc3709e773173b2ce4c56c9fbde04b9c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+ "thread_local",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189"
+
 [[package]]
 name = "ryu"
 version = "1.0.5"
@@ -113,6 +153,15 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.1"

2020/Cargo.toml

@@ -10,3 +10,4 @@ edition = "2018"
 anyhow = "1.0.34"
 aoc-runner = "0.3.0"
 aoc-runner-derive = "0.3.0"
+regex = "1.4.2"

2020/src/day2.rs

@@ -0,0 +1,100 @@
+//! --- Day 2: Password Philosophy ---
+//! Your flight departs in a few days from the coastal airport; the easiest way down to the coast from here is via toboggan.
+//!
+//! The shopkeeper at the North Pole Toboggan Rental Shop is having a bad day. "Something's wrong with our computers; we can't log in!" You ask if you can take a look.
+//!
+//! Their password database seems to be a little corrupted: some of the passwords wouldn't have been allowed by the Official Toboggan Corporate Policy that was in effect when they were chosen.
+//!
+//! To try to debug the problem, they have created a list (your puzzle input) of passwords (according to the corrupted database) and the corporate policy when that password was set.
+//!
+//! For example, suppose you have the following list:
+//!
+//! 1-3 a: abcde
+//! 1-3 b: cdefg
+//! 2-9 c: ccccccccc
+//! Each line gives the password policy and then the password. The password policy indicates the lowest and highest number of times a given letter must appear for the password to be valid. For example, 1-3 a means that the password must contain a at least 1 time and at most 3 times.
+//!
+//! In the above example, 2 passwords are valid. The middle password, cdefg, is not; it contains no instances of b, but needs at least 1. The first and third passwords are valid: they contain one a or nine c, both within the limits of their respective policies.
+//!
+//! How many passwords are valid according to their policies?
+
+use aoc_runner_derive::{aoc, aoc_generator};
+use regex::Regex;
+
+#[derive(Debug, PartialEq)]
+struct Policy {
+    min: usize,
+    max: usize,
+    letter: String,
+    password: String,
+}
+
+#[aoc_generator(day2)]
+fn parse(input: &str) -> Vec<Policy> {
+    let re = Regex::new(r"(\d+)-(\d+) (\w): (.*)").expect("Failed to compile regex");
+    input
+        .split('\n')
+        .filter(|line| re.is_match(line))
+        .map(|line| {
+            let caps = re.captures(line).expect("Failed to match pattern");
+            Policy {
+                min: caps.get(1).unwrap().as_str().parse().unwrap(),
+                max: caps.get(2).unwrap().as_str().parse().unwrap(),
+                letter: caps.get(3).unwrap().as_str().to_string(),
+                password: caps.get(4).unwrap().as_str().to_string(),
+            }
+        })
+        .collect()
+}
+
+fn is_valid_policy(p: &Policy) -> bool {
+    let c = p.password.matches(&p.letter).count();
+    p.min <= c && c <= p.max
+}
+
+#[aoc(day2, part1)]
+fn valid_policy_count(policies: &[Policy]) -> usize {
+    policies.iter().filter(|p| is_valid_policy(p)).count()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INPUT: &'static str = r#"
+1-3 a: abcde
+1-3 b: cdefg
+2-9 c: ccccccccc
+"#;
+    #[test]
+    fn parse_policies() {
+        assert_eq!(
+            parse(INPUT),
+            vec![
+                Policy {
+                    min: 1,
+                    max: 3,
+                    letter: "a".to_string(),
+                    password: "abcde".to_string(),
+                },
+                Policy {
+                    min: 1,
+                    max: 3,
+                    letter: "b".to_string(),
+                    password: "cdefg".to_string(),
+                },
+                Policy {
+                    min: 2,
+                    max: 9,
+                    letter: "c".to_string(),
+                    password: "ccccccccc".to_string(),
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn validate_count() {
+        assert_eq!(valid_policy_count(&parse(INPUT)), 2);
+    }
+}

2020/src/lib.rs

@@ -1,4 +1,5 @@
 mod day1;
+mod day2;
 
 use aoc_runner_derive::aoc_lib;