output formatting

src/day01.rs

@@ -3,8 +3,8 @@ use std::fs::read_to_string;
 
 pub fn day_main() {
     let input = read_to_string("input/day01.txt").unwrap();
-    println!("part1: {}", part1(&input));
-    println!("part2: {}", part2(&input));
+    println!(" part1: {}", part1(&input));
+    println!(" part2: {}", part2(&input));
 }
 
 type Int = i32;

src/day02.rs

@@ -4,8 +4,8 @@ use itertools::Itertools;
 
 pub fn day_main() {
     let input = read_to_string("input/day02.txt").unwrap();
-    println!("part1: {}", part1(&input));
-    println!("part2: {}", part2(&input));
+    println!(" part1: {}", part1(&input));
+    println!(" part2: {}", part2(&input));
 }
 
 fn part1(input: &str) -> usize {

src/day03.rs

@@ -1,77 +1,43 @@
-use itertools::Itertools;
 use std::fs::read_to_string;
 
 pub fn day_main() {
     let input = read_to_string("input/day03.txt").unwrap();
     let input = input.trim();
-    println!("part1: {}", part1(&input));
-    println!("part2: {}", part2(&input));
+    println!(" part1: {}", part1(input));
+    println!(" part2: {}", part2(input));
 }
 
 type RiddleResult = i64;
 
 fn part1(input: &str) -> RiddleResult {
-    let r = regex::Regex::new(r"mul\(\d{1,3},\d{1,3}\)").unwrap();
+    let r = regex::Regex::new(r"mul\((\d{1,3}),(\d{1,3})\)").unwrap();
     r.captures_iter(input)
         .map(|c| {
-            let s = c.get(0).unwrap().as_str();
-            println!("{s}");
-            let x = s.strip_prefix("mul(").unwrap().strip_suffix(")").unwrap();
-            let (a, b) = x.split_once(',').unwrap();
-            let a: i64 = a.parse().unwrap();
-            let b: i64 = b.parse().unwrap();
+            let a: i64 = c.get(1).unwrap().as_str().parse().unwrap();
+            let b: i64 = c.get(2).unwrap().as_str().parse().unwrap();
             a * b
         })
         .sum()
 }
 
-enum Statement {
-    Enable,
-    Disable,
-    Number(i64),
-}
-
 fn part2(input: &str) -> RiddleResult {
-    let r = regex::Regex::new(r"do\(\)|don't\(\)|mul\(\d{1,3},\d{1,3}\)").unwrap();
-    let statements = r
-        .captures_iter(input)
-        .map(|c| {
+    let r = regex::Regex::new(r"do\(\)|don't\(\)|mul\((\d{1,3}),(\d{1,3})\)").unwrap();
+    r.captures_iter(input)
+        // (enabled, result): initially enabled; sum up the result over all enabled multiplications
+        .fold((true, 0), |(enabled, result), c| {
             let s = c.get(0).unwrap().as_str();
-            println!("{s}");
 
             match s {
-                "do()" => Statement::Enable,
-                "don't()" => Statement::Disable,
+                "do()" => (true, result),
+                "don't()" => (false, result),
                 _ => {
-                    let x = s.strip_prefix("mul(").unwrap().strip_suffix(")").unwrap();
-                    let (a, b) = x.split_once(',').unwrap();
-                    let a: i64 = a.parse().unwrap();
-                    let b: i64 = b.parse().unwrap();
-                    Statement::Number(a * b)
+                    let a: i64 = c.get(1).unwrap().as_str().parse().unwrap();
+                    let b: i64 = c.get(2).unwrap().as_str().parse().unwrap();
+                    (enabled, result + if enabled { a * b } else { 0 })
                 }
             }
         })
-        .collect_vec();
-
-    let mut enabled = true;
-    let mut result = 0;
-    for f in statements {
-        match f {
-            Statement::Enable => {
-                enabled = true;
-            }
-            Statement::Disable => {
-                enabled = false;
-            }
-            Statement::Number(i) => {
-                if enabled {
-                    result += i
-                }
-            }
-        }
-    }
-
-    result
+        .1
 }
 
 #[cfg(test)]