Extract "fold_decimal" method to slice utils

Author: maneatingape

src/util/slice.rs

@@ -9,7 +9,13 @@
 //! Uses [Heap's algorithm](https://en.wikipedia.org/wiki/Heap%27s_algorithm) for efficiency,
 //! modifying the slice in place.
 //!
+//! [`fold_decimal`]
+//!
+//! Accumulates a slice of digits from 0 to 9 inclusive into a single integer.
+//!
 //! [`permutations`]: SliceOps::permutations
+//! [`fold_decimal`]: SliceOps2::fold_decimal
+use super::integer::*;
 
 pub trait SliceOps<T> {
     fn permutations(self, callback: impl FnMut(&[T]));
@@ -40,3 +46,15 @@ impl<T> SliceOps<T> for &mut [T] {
         }
     }
 }
+
+pub trait SliceOps2<T: Integer<T>> {
+    /// Folds a slice of digits into an integer.
+    fn fold_decimal(self) -> T;
+}
+
+impl<T: Integer<T>> SliceOps2<T> for &[T] {
+    #[inline]
+    fn fold_decimal(self) -> T {
+        self.iter().fold(T::ZERO, |acc, &b| T::TEN * acc + b)
+    }
+}

src/year2019/day04.rs

@@ -4,6 +4,7 @@
 //! These numbers become rapidly less dense as the password value increases and there
 //! are only 3003 total of these numbers with 6 digits.
 use crate::util::parse::*;
+use crate::util::slice::*;
 
 pub fn parse(input: &str) -> Vec<u32> {
     input.iter_unsigned().collect()
@@ -83,7 +84,7 @@ fn passwords(input: &[u32], predicate: impl Fn(bool, bool, bool, bool, bool) ->
         }
 
         // Convert number to `u32`.
-        n = digits.iter().fold(0, |acc, d| 10 * acc + d);
+        n = digits.fold_decimal();
     }
 
     count

src/year2019/day16.rs

@@ -75,8 +75,8 @@
 //! [grows rather large]: https://oeis.org/A017763/b017763.txt
 //! [Lucas's theorem]: https://en.wikipedia.org/wiki/Lucas%27s_theorem
 //! [Chinese remainder theorem]: https://en.wikipedia.org/wiki/Chinese_remainder_theorem
-use crate::util::integer::*;
 use crate::util::parse::*;
+use crate::util::slice::*;
 
 /// Lookup table for first five rows of
 /// [Pascal's triangle](https://en.wikipedia.org/wiki/Pascal%27s_triangle).
@@ -135,12 +135,12 @@ pub fn part1(input: &[u8]) -> i32 {
         (current, next) = (next, current);
     }
 
-    fold_number(&current[..8])
+    current[..8].fold_decimal()
 }
 
 pub fn part2(input: &[u8]) -> usize {
     let digits: Vec<_> = input.iter().copied().map(usize::from).collect();
-    let start = fold_number(&digits[..7]);
+    let start = digits[..7].fold_decimal();
 
     // This approach will only work if the index is in the second half of the input.
     let size = digits.len();
@@ -160,7 +160,7 @@ pub fn part2(input: &[u8]) -> usize {
     }
 
     result.iter_mut().for_each(|r| *r %= 10);
-    fold_number(&result)
+    result.fold_decimal()
 }
 
 /// Computes C(n, k) % 2
@@ -215,9 +215,3 @@ fn bimonial_mod_5(mut n: usize, mut k: usize) -> usize {
 fn binomial_mod_10(n: usize, k: usize) -> usize {
     5 * binomial_mod_2(n, k) + 6 * bimonial_mod_5(n, k)
 }
-
-/// Folds a slice of digits into an integer.
-#[inline]
-fn fold_number<T: Integer<T>>(slice: &[T]) -> T {
-    slice.iter().fold(T::ZERO, |acc, &b| T::TEN * acc + b)
-}

src/year2021/day08.rs

@@ -27,6 +27,7 @@
 //! * Add the occurences of each scrambled segment for each digit after the `|` symbol, then
 //!   lookup the total and map directly to the unscrambled digit.
 use crate::util::iter::*;
+use crate::util::slice::*;
 
 type Input = Vec<[u32; 4]>;
 
@@ -39,7 +40,7 @@ pub fn part1(input: &Input) -> usize {
 }
 
 pub fn part2(input: &Input) -> u32 {
-    input.iter().map(|digits| digits.iter().fold(0, |acc, d| 10 * acc + d)).sum()
+    input.iter().map(|digits| digits.fold_decimal()).sum()
 }
 
 fn descramble(line: &str) -> [u32; 4] {