chore: cleanup (of sorts)

Author: clechasseur

aoclp/src/functional.rs

@@ -1,10 +1,10 @@
-pub trait PredHelper<T, U> {
+pub trait ConsumingPredHelper<T, U> {
     fn with_ref(self) -> impl Fn(&T) -> U
     where
         T: Clone;
 }
 
-impl<F, T, U> PredHelper<T, U> for F
+impl<F, T, U> ConsumingPredHelper<T, U> for F
 where
     F: Fn(T) -> U,
 {
@@ -15,3 +15,16 @@ where
         move |x| self(x.clone())
     }
 }
+
+pub trait ByRefPredHelper<T, U> {
+    fn without_ref(self) -> impl Fn(T) -> U;
+}
+
+impl<F, T, U> ByRefPredHelper<T, U> for F
+where
+    F: Fn(&T) -> U,
+{
+    fn without_ref(self) -> impl Fn(T) -> U {
+        move |x| self(&x)
+    }
+}

aoclp/src/solvers_impl/input.rs

@@ -94,13 +94,7 @@ impl<'a> Input<'a> {
         T: FromStr,
         <T as FromStr>::Err: std::fmt::Debug,
     {
-        String::try_from(self)?
-            .lines()
-            .map(|line| {
-                line.parse()
-                    .map_err(|e| anyhow!("failed to parse \"{line}\": {e:?}"))
-            })
-            .collect()
+        Self::parse_many(String::try_from(self)?.lines())
     }
 
     pub fn safe_into_many<T>(self) -> Vec<T>
@@ -117,22 +111,15 @@ impl<'a> Input<'a> {
         <T as FromStr>::Err: std::fmt::Debug,
     {
         let separators = self.separators;
-        String::try_from(self)?
-            .lines()
-            .map(|line| {
-                let (a, b) = line
-                    .split(separators)
-                    .filter(|value| !value.is_empty())
-                    .collect_tuple()
-                    .ok_or(anyhow!("invalid number of elements in \"{line}\""))?;
-                Ok((
-                    a.parse()
-                        .map_err(|e| anyhow!("failed to parse \"{a}\": {e:?}"))?,
-                    b.parse()
-                        .map_err(|e| anyhow!("failed to parse \"{b}\": {e:?}"))?,
-                ))
+        let vecs = Self::parse_many_vecs(String::try_from(self)?.lines(), separators)?;
+
+        Ok(vecs
+            .into_iter()
+            .map(|v| {
+                let (a, b) = v.into_iter().collect_tuple().unwrap();
+                (a, b)
             })
-            .collect()
+            .collect())
     }
 
     pub fn safe_into_many_pairs<T>(self) -> Vec<(T, T)>
@@ -160,6 +147,31 @@ impl<'a> Input<'a> {
         self.into_many_vecs().unwrap()
     }
 
+    pub fn into_many_of_two_types<T, U>(self) -> crate::Result<(Vec<T>, Vec<U>)>
+    where
+        T: FromStr,
+        U: FromStr,
+        <T as FromStr>::Err: std::fmt::Debug,
+        <U as FromStr>::Err: std::fmt::Debug,
+    {
+        let data: String = self.try_into()?;
+
+        let first = Self::parse_many(data.lines().take_while(|line| !line.is_empty()))?;
+        let second = Self::parse_many(data.lines().skip_while(|line| !line.is_empty()).skip(1))?;
+
+        Ok((first, second))
+    }
+
+    pub fn safe_into_many_of_two_types<T, U>(self) -> (Vec<T>, Vec<U>)
+    where
+        T: FromStr,
+        U: FromStr,
+        <T as FromStr>::Err: std::fmt::Debug,
+        <U as FromStr>::Err: std::fmt::Debug,
+    {
+        self.into_many_of_two_types().unwrap()
+    }
+
     #[allow(clippy::type_complexity)]
     pub fn into_many_vecs_of_two_types<T, U>(self) -> crate::Result<(Vec<Vec<T>>, Vec<Vec<U>>)>
     where
@@ -224,6 +236,23 @@ impl<'a> Input<'a> {
         self.into_terrain().unwrap()
     }
 
+    fn parse_many<T, L, S>(lines: L) -> crate::Result<Vec<T>>
+    where
+        T: FromStr,
+        <T as FromStr>::Err: std::fmt::Debug,
+        L: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        lines
+            .into_iter()
+            .map(|line| {
+                let line = line.as_ref();
+                line.parse()
+                    .map_err(|e| anyhow!("failed to parse \"{line}\": {e:?}"))
+            })
+            .collect()
+    }
+
     fn parse_many_vecs<T, L, S>(lines: L, separators: &[char]) -> crate::Result<Vec<Vec<T>>>
     where
         T: FromStr,
@@ -300,6 +329,19 @@ where
     Input::year(year).day(day).safe_get().safe_into_one_vec()
 }
 
+pub fn safe_get_input_as_many_of_two_types<T, U>(year: i32, day: u32) -> (Vec<T>, Vec<U>)
+where
+    T: FromStr,
+    U: FromStr,
+    <T as FromStr>::Err: std::fmt::Debug,
+    <U as FromStr>::Err: std::fmt::Debug,
+{
+    Input::year(year)
+        .day(day)
+        .safe_get()
+        .safe_into_many_of_two_types()
+}
+
 pub fn safe_get_input_as_many_vecs_of_two_types<T, U>(
     year: i32,
     day: u32,

aoclp_solutions/src/y2025/day_02.rs

@@ -1,7 +1,7 @@
 use std::ops::RangeInclusive;
 use std::str::FromStr;
 
-use aoclp::functional::PredHelper;
+use aoclp::functional::ConsumingPredHelper;
 use aoclp::num::Integer;
 use aoclp::solvers_impl::input::safe_get_input_as_one_vec;
 use itertools::Itertools;
@@ -85,6 +85,7 @@ impl IntoIterator for IdRange {
     }
 }
 
+// noinspection DuplicatedCode
 impl FromStr for IdRange {
     type Err = aoclp::Error;
 

aoclp_solutions/src/y2025/day_05.rs

@@ -1,8 +1,9 @@
 use std::cmp::{max, min};
-use std::ops::RangeInclusive;
+use std::ops::{Deref, RangeInclusive};
 use std::str::FromStr;
 
-use aoclp::solvers_impl::input::safe_get_input_as_many_vecs_of_two_types;
+use aoclp::functional::ByRefPredHelper;
+use aoclp::solvers_impl::input::safe_get_input_as_many_of_two_types;
 use itertools::Itertools;
 
 pub fn part_1() -> usize {
@@ -17,30 +18,36 @@ pub fn part_2() -> usize {
     let (fresh_ids, _) = input();
     fresh_ids
         .into_iter()
-        .map(|r| r.0)
         .sorted_by(|a, b| a.start().cmp(b.start()).then(a.end().cmp(b.end())))
         .fold(Vec::new(), |mut acc, r| {
             match acc.last() {
                 None => acc.push(r),
-                Some(prev) if prev.end() < r.start() => acc.push(r),
+                Some(prev) if (prev.end() + 1) < *r.start() => acc.push(r),
                 Some(prev) => {
                     let from = *min(prev.start(), r.start());
                     let to = *max(prev.end(), r.end());
                     acc.pop();
-                    acc.push(from..=to);
+                    acc.push(IdRange(from..=to));
                 },
             }
 
             acc
         })
         .into_iter()
-        .map(|r| r.count())
+        .map(IdRange::len.without_ref())
         .sum()
 }
 
 #[derive(Debug, Clone)]
 struct IdRange(RangeInclusive<usize>);
 
+impl IdRange {
+    pub fn len(&self) -> usize {
+        self.end() - self.start() + 1
+    }
+}
+
+// noinspection DuplicatedCode
 impl FromStr for IdRange {
     type Err = aoclp::Error;
 
@@ -50,16 +57,14 @@ impl FromStr for IdRange {
     }
 }
 
+impl Deref for IdRange {
+    type Target = RangeInclusive<usize>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 fn input() -> (Vec<IdRange>, Vec<usize>) {
-    let (fresh_ids, available_ids) = safe_get_input_as_many_vecs_of_two_types(2025, 5);
-    (
-        fresh_ids
-            .into_iter()
-            .map(|v| v.into_iter().next().unwrap())
-            .collect_vec(),
-        available_ids
-            .into_iter()
-            .map(|v| v.into_iter().next().unwrap())
-            .collect_vec(),
-    )
+    safe_get_input_as_many_of_two_types(2025, 5)
 }