add day 7

day07/src/main.rs

@@ -0,0 +1,119 @@
+use itertools::Itertools;
+
+#[cfg(debug_assertions)]
+const INPUT: &str = "example.txt";
+#[cfg(not(debug_assertions))]
+const INPUT: &str = "input.txt";
+
+fn main() {
+    let binding = std::fs::read_to_string(INPUT).unwrap();
+    let data: Vec<_> = binding.lines().map(Address::parse).collect();
+
+    part1(&data);
+    part2(&data);
+}
+
+fn part1(addresses: &[Address]) {
+    let result = addresses.iter().filter(|a| a.supports_tls()).count();
+    println!("{result}");
+}
+
+fn part2(addresses: &[Address]) {
+    let result = addresses.iter().filter(|a| a.supports_ssl()).count();
+    println!("{result}");
+}
+
+#[derive(Debug)]
+struct Address<'a> {
+    supernets: Vec<&'a str>,
+    hypernets: Vec<&'a str>,
+}
+
+impl<'a> Address<'a> {
+    fn supports_tls(&self) -> bool {
+        self.supernets.iter().any(|s| contains_like_abba(s))
+            && self.hypernets.iter().all(|h| !contains_like_abba(h))
+    }
+
+    fn supports_ssl(&self) -> bool {
+        for aba in self.supernets.iter().flat_map(|s| find_like_aba(s)) {
+            if self
+                .hypernets
+                .iter()
+                .any(|h| contains_like_bab(h.to_string(), &aba))
+            {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    fn parse(s: &'a str) -> Self {
+        let mut supernets = Vec::new();
+        let mut hypernets = Vec::new();
+
+        for (i, part) in s.split(&['[', ']']).enumerate() {
+            if i % 2 == 0 {
+                supernets.push(part);
+            } else {
+                hypernets.push(part);
+            }
+        }
+
+        Self {
+            supernets,
+            hypernets,
+        }
+    }
+}
+
+fn find_like_aba(s: &str) -> Vec<String> {
+    let mut result = vec![];
+    for (a, b, c) in s.chars().tuple_windows() {
+        if a == c && a != b {
+            result.push(format!("{a}{b}{c}"));
+        }
+    }
+    result
+}
+
+fn contains_like_bab(s: String, aba: &str) -> bool {
+    let mut chars = aba.chars();
+    let a = chars.next().unwrap();
+    let b = chars.next().unwrap();
+
+    for (x, y, z) in s.chars().tuple_windows() {
+        if x == b && y == a && z == b {
+            return true;
+        }
+    }
+    false
+}
+
+fn contains_like_abba(s: &str) -> bool {
+    for (a, b, c, d) in s.chars().tuple_windows() {
+        if a == d && b == c && a != b {
+            return true;
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::contains_like_abba;
+
+    #[test]
+    fn abba() {
+        assert!(contains_like_abba("abba"));
+        assert!(!contains_like_abba("abcd"));
+        assert!(!contains_like_abba("aaaa"));
+        assert!(!contains_like_abba("aaaaaa"));
+        assert!(contains_like_abba("aaabba"));
+        assert!(!contains_like_abba("qrst"));
+        assert!(!contains_like_abba("tyui"));
+        assert!(contains_like_abba("ioxxoj"));
+        assert!(!contains_like_abba("zxcvbn"));
+    }
+}