120 lines
2.8 KiB
Rust
120 lines
2.8 KiB
Rust
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"));
|
|
}
|
|
}
|