Use iterators instead of explicit indexing

230 byte overhead is worth it to avoid conversions and potential
indexing errors

2022/src/common.rs

@@ -1,6 +1,7 @@
 //! Common helper utilities to all days
 
 use anyhow::Result;
+use nom::combinator::map;
 use nom::error::ErrorKind;
 use nom::error::ParseError;
 use nom::Finish;
@@ -93,6 +94,17 @@ where
     }
 }
 
+/// Add an index to repeated successful invocations of the embedded parser.
+pub fn enumerate<I, O, E>(f: impl Parser<I, O, E>) -> impl FnMut(I) -> IResult<I, (usize, O), E> {
+    let mut index = 0usize;
+
+    map(f, move |v| {
+        let res = (index, v);
+        index += 1;
+        res
+    })
+}
+
 /// Return the minimum and maximum of two unordered variables
 pub fn minmax<T>(a: T, b: T) -> (T, T)
 where

2022/src/day05.rs

@@ -16,17 +16,16 @@ use nom::sequence::terminated;
 use nom::sequence::tuple;
 use nom::IResult;
 
+use crate::common::enumerate;
 use crate::common::parse_input;
 
 type Move = (usize, usize, usize);
 type OwnedStacks = Vec<Vec<u8>>;
 
 fn parse_row<'a>(input: &'a [u8], stacks: &mut OwnedStacks) -> IResult<&'a [u8], ()> {
-    let mut index = 0usize;
-
     // Forgive me for this crime
     fold_many1(
-        terminated(
+        enumerate(terminated(
             alt((
                 // Parse a delimited value into a Some(content)
                 map(delimited(tag("["), take(1usize), tag("]")), |v: &[u8]| {
@@ -36,9 +35,9 @@ fn parse_row<'a>(input: &'a [u8], stacks: &mut OwnedStacks) -> IResult<&'a [u8],
                 map(tag("   "), |_| None),
             )),
             opt(tag(" ")),
-        ),
+        )),
         || (),
-        move |_, c| {
+        move |_, (index, c)| {
             if let Some(b) = c {
                 if stacks.len() <= index {
                     stacks.resize_with(index + 1, Vec::new);
@@ -46,8 +45,6 @@ fn parse_row<'a>(input: &'a [u8], stacks: &mut OwnedStacks) -> IResult<&'a [u8],
 
                 stacks[index].push(b)
             }
-
-            index += 1;
         },
     )(input)
 }

2022/src/day06.rs

@@ -1,29 +1,27 @@
 use anyhow::Result;
 
 fn find_first(input: &[u8], unique: usize) -> Result<usize> {
-    #[inline]
-    const fn index(c: u8) -> usize {
-        (c - b'a') as usize
-    }
-    let mut seen = [false; 26];
+    let mut seen = [false; 256];
+
+    let mut tail_it = input.iter();
 
     let mut first = 0;
 
     // Loop invariant: input[first..last] contains only unique characters
     for (last, &c) in input.iter().enumerate() {
-        if seen[index(c)] {
-            while input[first] != c {
-                seen[index(input[first])] = false;
-                first += 1;
-            }
-            first += 1;
+        if seen[c as usize] {
+            first += (&mut tail_it)
+                .take_while(|&&b| b != c)
+                .map(|&b| seen[b as usize] = false)
+                .count()
+                + 1; // +1 because take_while doesn't return the first element that didn't satisfy the condition, while we do need to count it
         } else {
             // New unique character found: input[first..=last] contains unique characters
             if last - first + 1 == unique {
-                return Ok(first + unique);
+                return Ok(last + 1);
             }
 
-            seen[index(c)] = true;
+            seen[c as usize] = true;
         }
     }