fixed day06 test

src/day06/mod.rs

@@ -5,8 +5,8 @@ pub mod part06b;
 mod tests {
     use crate::day06::{part06a, part06b};
 
-    const PUZZLE: &str = "123 328  51 64
- 45 64  387 23
+    const PUZZLE: &str = "123 328  51 64 
+ 45 64  387 23 
   6 98  215 314
 *   +   *   +  ";
 
@@ -19,4 +19,4 @@ mod tests {
     fn part06b() {
         assert_eq!(part06b::solve(PUZZLE.to_string()), 3263827);
     }
-}
+}

src/day06/part06b.rs

@@ -1,45 +1,59 @@
-use itertools::Itertools;
+struct ZipAll<I> {
+    iters: Vec<I>,
+}
+
+impl<I> Iterator for ZipAll<I>
+where
+    I: Iterator,
+{
+    type Item = Vec<I::Item>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut out = Vec::with_capacity(self.iters.len());
+
+        for it in &mut self.iters {
+            out.push(it.next()?); // return None if any iterator ends
+        }
+
+        Some(out)
+    }
+}
+
 
 pub fn solve(puzzle: String) -> u64 {
     let mut solution: u64 = 0;
 
-    puzzle
+    let lines = puzzle
         .lines()
         .map(|line| line.chars())
-        .tuple_windows::<(_, _, _, _, _)>()
-        .for_each(|(a, b, c, d, op)| {
-            let mut operator: char = ' ';
-            let mut temp: u64 = 0;
-            a
-                .zip(b)
-                .zip(c)
-                .zip(d)
-                .zip(op)
-                .map(|((((a, b), c), d), op)| {
-                    let mut value: u64 = 0;
-                    [a, b, c, d]
-                        .iter()
-                        .filter(|c| **c != ' ')
-                        .for_each(|c| {value = value * 10 + (*c as u8 - b'0') as u64});
-                    (value, op)
-                })
-                .for_each(|(value, op)| {
-                    if op != ' ' {
-                        operator = op;
-                        solution += temp;
-                        temp = if op == '*' {1} else {0};
-                    }
-                    if value == 0 { return }
-                    match operator {
-                        '+' => temp += value,
-                        '*' => temp *= value,
-                        _ => unreachable!(),
-                    }
-                });
-            solution += temp;
-        });
+        .collect::<Vec<_>>();
 
-    solution
+    let mut operator: char = ' ';
+    let mut temp: u64 = 0;
+    ZipAll { iters: lines }
+        .map(|col| {
+            let mut value: u64 = 0;
+            col[..col.len() - 1]
+                .iter()
+                .filter(|c| **c != ' ')
+                .for_each(|c| {value = value * 10 + (*c as u8 - b'0') as u64});
+            (value, *col.last().unwrap())
+            })
+        .for_each(|(value, op)| {
+            if op != ' ' {
+                operator = op;
+                solution += temp;
+                temp = if op == '*' {1} else {0};
+            }
+            if value == 0 { return }
+            match operator {
+                '+' => temp += value,
+                '*' => temp *= value,
+                _ => unreachable!(),
+            }
+            });
+
+    solution + temp
 }