Use RangeInclusive instead, and get second star

src/bin/p04.rs

@@ -1,16 +1,28 @@
-#![feature(iterator_try_collect, iter_collect_into)]
+#![feature(iterator_try_collect)]
 
 use std::fs;
 use std::io::{self, BufRead};
-use std::ops::Range;
+use std::ops::RangeInclusive;
 use std::str::FromStr;
 
 #[derive(Debug)]
-struct WorkRange(Range<u32>);
+struct WorkRange(RangeInclusive<u32>);
 
 impl WorkRange {
+    #[allow(dead_code)]
+    fn init(start: u32, end: u32) -> Self {
+        WorkRange(start..=end)
+    }
+
     fn fully_contains(&self, other: &Self) -> bool {
-        self.0.start <= other.0.start && self.0.end >= other.0.end
+        self.0.contains(other.0.start()) && self.0.contains(other.0.end())
+    }
+
+    fn overlaps(&self, other: &Self) -> bool {
+        self.0.contains(other.0.start())
+            || self.0.contains(other.0.end())
+            || other.0.contains(self.0.start())
+            || other.0.contains(self.0.end())
     }
 }
 
@@ -19,7 +31,7 @@ impl FromStr for WorkRange {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let spl: Vec<u32> = s.split('-').map(|n| n.parse()).try_collect()?;
-        Ok(WorkRange(spl[0]..spl[1]))
+        Ok(WorkRange(spl[0]..=spl[1]))
     }
 }
 
@@ -60,4 +72,25 @@ fn part1(pairs: &[ElfPair]) {
     println!("num containing: {}", sum);
 }
 
-fn part2(_pairs: &[ElfPair]) {}
+fn part2(pairs: &[ElfPair]) {
+    let sum = pairs
+        .iter()
+        .filter(|ElfPair(l, r)| l.overlaps(r) || r.overlaps(l))
+        .count();
+    println!("num overlapping: {}", sum);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn range_overlaps() {
+        assert!(!WorkRange::init(2, 4).overlaps(&WorkRange::init(6, 8)));
+        assert!(!WorkRange::init(2, 3).overlaps(&WorkRange::init(4, 5)));
+        assert!(WorkRange::init(5, 7).overlaps(&WorkRange::init(7, 9)));
+        assert!(WorkRange::init(2, 8).overlaps(&WorkRange::init(3, 7)));
+        assert!(WorkRange::init(6, 6).overlaps(&WorkRange::init(4, 6)));
+        assert!(WorkRange::init(2, 6).overlaps(&WorkRange::init(4, 8)));
+    }
+}