more work on part 2

src/bin/day05.rs

@@ -3,7 +3,7 @@ use color_eyre::Report;
 
 fn main() -> Result<(), Report> {
     color_eyre::install()?;
-    let data = day05::data("inputs/day05example.txt")?;
+    let data = day05::data("inputs/day05.txt")?;
     let code1 = day05::part1(&data)?;
     let code2 = day05::part2(&data)?;
     println!("code1: {code1}");

src/day05.rs

@@ -4,7 +4,7 @@ use color_eyre::{
 };
 use std::{
     cell::RefCell,
-    collections::BTreeMap,
+    collections::{BTreeMap, VecDeque},
     fs::File,
     io::{self, BufRead, BufReader, Lines},
     iter::Enumerate,
@@ -12,52 +12,10 @@ use std::{
 };
 #[derive(Debug)]
 pub struct RangeList {
-    ranges: RangeIter,
+    ranges: Vec<(usize, usize)>,
     data: Vec<usize>,
 }
 
-#[derive(Debug, Clone)]
-pub struct RangeIter {
-    inner: Vec<(usize, usize)>,
-}
-#[derive(Debug)]
-pub struct MutRangeIterInner {
-    inner: Rc<RefCell<Vec<(usize, usize)>>>,
-    index: usize,
-}
-
-impl<'a> Iterator for MutRangeIterInner {
-    type Item = (usize, (usize, usize));
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(item) = self.get(self.index) {
-            return Some((self.index, item));
-        }
-        None
-    }
-}
-
-impl MutRangeIterInner {
-    fn get(&self, index: usize) -> Option<(usize, usize)> {
-        self.inner.borrow().get(index).map(|v| *v)
-    }
-    fn in_range_except(&self, v: &usize, range: (&usize, &usize)) -> Option<(usize, usize)> {
-        self.inner
-            .borrow()
-            .iter()
-            .find(|(start, end)| {
-                // println!(
-                //     "2: {start:02}-{end:02} {range:?} {} {}",
-                //     !(start != range.0 && end != range.1),
-                //     v >= start && v <= end
-                // );
-
-                (v >= start && v <= end) && !(start == range.0 && end == range.1)
-            })
-            .map(|v| *v)
-    }
-}
-
 impl<R: BufRead> TryFrom<Lines<R>> for RangeList {
     type Error = Report;
     fn try_from(value: Lines<R>) -> Result<Self, Self::Error> {
@@ -84,30 +42,36 @@ impl<R: BufRead> TryFrom<Lines<R>> for RangeList {
                 _ => {}
             }
         }
-        Ok(Self {
+        Ok(Self { ranges, data })
-            ranges: RangeIter { inner: ranges },
-            data,
-        })
-    }
-}
-
-impl RangeIter {
-    pub fn iter_mut(&mut self) -> MutRangeIterInner {
-        MutRangeIterInner {
-            inner: Rc::new(RefCell::new(self.inner.clone())),
-            index: 0,
-        }
     }
 }
 
 impl RangeList {
-    pub fn in_range(&self, v: &usize) -> Option<usize> {
+    pub fn in_range2<'a>(ranges: &'a [(usize, usize)], v: &'a usize) -> Option<&'a (usize, usize)> {
-        self.ranges
+        ranges.iter().find(|(start, end)| v >= start && v <= end)
-            .into_iter()
-            .position(|(_, (start, end))| v >= &start && v <= &end)
     }
-    pub fn in_range_except(&self, v: &usize, range: (&usize, &usize)) -> Option<usize> {
+    pub fn in_range_except2<'a>(
-        self.ranges.into_iter().position(|(_, (start, end))| {
+        ranges: &'a [(usize, usize)],
+        v: &'a usize,
+        range: (&'a usize, &'a usize),
+    ) -> Option<&'a (usize, usize)> {
+        ranges.iter().find(|(start, end)| {
+            // println!(
+            //     "2: {start:02}-{end:02} {range:?} {} {}",
+            //     !(start != range.0 && end != range.1),
+            //     v >= start && v <= end
+            // );
+
+            (v >= start && v <= end) && !(start == range.0 && end == range.1)
+        })
+    }
+    pub fn in_range(&self, v: &usize) -> Option<&(usize, usize)> {
+        self.ranges
+            .iter()
+            .find(|(start, end)| v >= start && v <= end)
+    }
+    pub fn in_range_except(&self, v: &usize, range: (&usize, &usize)) -> Option<&(usize, usize)> {
+        self.ranges.iter().find(|(start, end)| {
             // println!(
             //     "2: {start:02}-{end:02} {range:?} {} {}",
             //     !(start != range.0 && end != range.1),
@@ -118,43 +82,58 @@ impl RangeList {
         })
     }
     pub fn dedup_ranges(&self) -> Vec<(usize, usize)> {
-        let mut old_ranges = self.ranges.clone();
+        let mut ranges = self.ranges.clone();
-        println!("{:#?}", old_ranges);
+        let mut index = 0;
-        let mut ranges = Vec::new();
+        while index < ranges.len() {
-        let mut fuck = old_ranges.iter_mut();
+            let Some((start, end)) = ranges.get(index) else {
-        for (int, (start, end)) in fuck {
+                break;
+            };
+            let (start, end) = (*start, *end);
+
             println!("START -- {start}-{end}");
-            let has_start = fuck.in_range_except(&start, (&start, &end));
+            let has_start = Self::in_range_except2(&ranges, &start, (&start, &end)).copied();
-            // let has_end = self
+            let has_end = Self::in_range_except2(&ranges, &end, (&start, &end)).copied();
-            //     .in_range_except(end, (start, end))
+            println!("{has_start:?}-{has_end:?}");
-            //     .map(|v| self.ranges[v]);
+            let mut reset = false;
-            // println!("{}-{} in {:?}-{:?}", start, end, has_start, has_end);
+            match (has_start, has_end) {
-            // match (has_start, has_end) {
+                (Some(new_start), None) if new_start.0 != start => {
-            //     (None, None) => {
+                    ranges.remove(index);
-            //         let none = (*start, *end);
+                    ranges.insert(0, (new_start.0, end));
-            //         println!("none: {none:?}");
+                    reset = true;
-            //         ranges.push(none);
+                }
-            //     }
+                (None, Some(new_end)) if new_end.1 != end => {
-            //     (Some((_, range)), None) => {
+                    ranges.remove(index);
-            //         let none = (range, *end);
+                    ranges.insert(0, (start, new_end.1));
-            //         println!("sn: {none:?}");
+                    reset = true;
-            //         ranges.push(none);
+                }
-            //     }
+                (Some(new_start), Some(new_end)) if new_start != new_end => {
-            //     (None, Some((range, _))) => {
+                    let new = (new_start.0, new_end.1);
-            //         let none = (*start, range);
+                    if new != (start, end) {
-            //         println!("ns: {none:?}");
+                        ranges.remove(index);
-            //         ranges.push(none);
+                        ranges.insert(0, new);
-            //     }
+                        reset = true;
-            //     // (Some((_, range_start)), Some((range_end, _))) => {
+                    }
-            //     //     let none = (range_start.min(*start), range_end.max(*end));
+                }
-            //     //     println!("ss: {none:?}");
+                (Some(new_start), Some(new_end)) if new_start == new_end => {
-            //     //     ranges.push(none);
+                    ranges.remove(index);
-            //     // }
+                    reset = true;
-            //     _ => {}
+                }
-            // }
+                (None, None) => {}
+                _ => {
+                    panic!("unhandled")
+                }
+            }
+            if reset {
+                index = 0;
+            } else {
+                index += 1;
+            }
+            println!("END -- {start}-{end} -- {ranges:?}");
         }
+
         println!("{ranges:?}");
 
+        ranges.sort();
         ranges
     }
 }
@@ -169,15 +148,15 @@ pub fn part1(data: &RangeList) -> Result<u64, Report> {
 
 pub fn part2(data: &RangeList) -> Result<u64, Report> {
     let mut data = RangeList {
-        ranges: vec![(3, 5), (5, 8), (3, 4)],
+        ranges: vec![(1, 2), (3, 5), (10, 14), (16, 20), (12, 18)],
         data: Vec::new(),
     };
     let ranges = data.dedup_ranges();
-    // data.ranges = ranges;
-    // data.dedup_ranges();
     let mut total = 0;
-    for (start, end) in &data.ranges {
+    for (start, end) in &ranges {
-        total += end - start;
+        let v = end - start + 1;
+        println!("{start}-{end} => {v}");
+        total += v;
     }
     Ok(total as u64)
 }