nikkuss/AOC2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more work on part 2

Browse Source
This commit is contained in:
Nikkuss
2025-12-07 08:29:46 +00:00
parent 2eeb9e23a8
commit 365c33eddd
2 changed files with 81 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/day05.rs
View File

@@ -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}");

181
src/day05.rs
View File

@@ -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 {
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,
}
Ok(Self { ranges, data })
}
}
impl RangeList {
pub fn in_range(&self, v: &usize) -> Option<usize> {
self.ranges
.into_iter()
.position(|(_, (start, end))| v >= &start && v <= &end)
pub fn in_range2<'a>(ranges: &'a [(usize, usize)], v: &'a usize) -> Option<&'a (usize, usize)> {
ranges.iter().find(|(start, end)| v >= start && v <= end)
}
pub fn in_range_except(&self, v: &usize, range: (&usize, &usize)) -> Option<usize> {
self.ranges.into_iter().position(|(_, (start, end))| {
pub fn in_range_except2<'a>(
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();
println!("{:#?}", old_ranges);
let mut ranges = Vec::new();
let mut fuck = old_ranges.iter_mut();
for (int, (start, end)) in fuck {
let mut ranges = self.ranges.clone();
let mut index = 0;
while index < ranges.len() {
let Some((start, end)) = ranges.get(index) else {
break;
};
let (start, end) = (*start, *end);
println!("START -- {start}-{end}");
let has_start = fuck.in_range_except(&start, (&start, &end));
// let has_end = self
// .in_range_except(end, (start, end))
// .map(|v| self.ranges[v]);
// println!("{}-{} in {:?}-{:?}", start, end, has_start, has_end);
// match (has_start, has_end) {
// (None, None) => {
// let none = (*start, *end);
// println!("none: {none:?}");
// ranges.push(none);
// }
// (Some((_, range)), None) => {
// let none = (range, *end);
// println!("sn: {none:?}");
// ranges.push(none);
// }
// (None, Some((range, _))) => {
// let none = (*start, range);
// println!("ns: {none:?}");
// ranges.push(none);
// }
// // (Some((_, range_start)), Some((range_end, _))) => {
// // let none = (range_start.min(*start), range_end.max(*end));
// // println!("ss: {none:?}");
// // ranges.push(none);
// // }
// _ => {}
// }
let has_start = Self::in_range_except2(&ranges, &start, (&start, &end)).copied();
let has_end = Self::in_range_except2(&ranges, &end, (&start, &end)).copied();
println!("{has_start:?}-{has_end:?}");
let mut reset = false;
match (has_start, has_end) {
(Some(new_start), None) if new_start.0 != start => {
ranges.remove(index);
ranges.insert(0, (new_start.0, end));
reset = true;
}
(None, Some(new_end)) if new_end.1 != end => {
ranges.remove(index);
ranges.insert(0, (start, new_end.1));
reset = true;
}
(Some(new_start), Some(new_end)) if new_start != new_end => {
let new = (new_start.0, new_end.1);
if new != (start, end) {
ranges.remove(index);
ranges.insert(0, new);
reset = true;
}
}
(Some(new_start), Some(new_end)) if new_start == new_end => {
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 {
total += end - start;
for (start, end) in &ranges {
let v = end - start + 1;
println!("{start}-{end} => {v}");
total += v;
}
Ok(total as u64)
}