From 64acaacb6fc13007a8c399e95e2984422f1496ca Mon Sep 17 00:00:00 2001
From: mhsn <mail@mhsn.net>
Date: Sun, 17 Aug 2025 17:00:55 +0100
Subject: rust 2024 03: remove regex and redo

---
 2024/03/rust/src/main.rs | 82 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 53 insertions(+), 29 deletions(-)

(limited to '2024/03/rust/src')

diff --git a/2024/03/rust/src/main.rs b/2024/03/rust/src/main.rs
index c2a1a55..b268463 100644
--- a/2024/03/rust/src/main.rs
+++ b/2024/03/rust/src/main.rs
@@ -1,44 +1,68 @@
-use regex::{Captures, Regex};
 use std::io::{self, Read};
 
+#[derive(Debug)]
+enum Instruction {
+    Do,
+    Dont,
+    Mul(u64, u64),
+}
+
+impl From<&Instruction> for u64 {
+    fn from(val: &Instruction) -> Self {
+        match val {
+            Instruction::Mul(x, y) => x * y,
+            _ => 0,
+        }
+    }
+}
+
 fn main() -> io::Result<()> {
     let mut program = String::new();
     io::stdin().read_to_string(&mut program)?;
 
-    let re = Regex::new(r"mul\((\d{1,3}),(\d{1,3})\)").unwrap();
-
-    let silver: u64 = re
-        .captures_iter(&program)
-        .map(self::execute_mul_capture)
-        .sum();
+    let instrs = (0..program.len())
+        .filter_map(|idx| {
+            let next = &program[idx..];
+            if next.starts_with("do()") {
+                Some(Instruction::Do)
+            } else if next.starts_with("don't()") {
+                Some(Instruction::Dont)
+            } else if next.starts_with("mul(") {
+                let mut first = 0;
+                let mut curr = 0;
 
-    let gold_re = Regex::new(r"(mul)\(\d{1,3},\d{1,3}\)|(do)\(\)|(don't)\(\)").unwrap();
-
-    let mut captures = gold_re.captures_iter(&program).map(|c| c.extract::<1>());
-
-    let mut gold: u64 = 0;
-    while let Some((func, [name])) = captures.next() {
-        match name {
-            "mul" => gold += execute_mul_capture(re.captures(func).unwrap()),
-            "do" => (),
-            "don't" => {
-                while let Some((_, [n])) = captures.next() {
-                    if n == "do" {
-                        break;
-                    }
+                for ch in next.bytes().skip(4) {
+                    match (ch, curr) {
+                        ((b'0'..=b'9'), _) => curr = curr * 10 + (ch - b'0') as u64,
+                        (_, 0) => return None,
+                        (b',', _) => {
+                            first = curr;
+                            curr = 0;
+                        }
+                        (b')', _) => {
+                            return Some(Instruction::Mul(first, curr));
+                        }
+                        _ => return None,
+                    };
                 }
+                None
+            } else {
+                None
             }
-            _ => unreachable!(),
-        }
-    }
+        })
+        .collect::<Vec<_>>();
 
+    let silver: u64 = instrs.iter().map(u64::from).sum();
+    let (gold, _) = instrs
+        .iter()
+        .fold((0 as u64, true), |(acc, on), instr| match (instr, on) {
+            (Instruction::Do, _) => (acc, true),
+            (Instruction::Dont, _) => (acc, false),
+            (Instruction::Mul(_, _), true) => (acc + u64::from(instr), true),
+            _ => (acc, on),
+        });
     println!("silver: {silver}");
     println!("gold: {gold}");
 
     return Ok(());
 }
-
-fn execute_mul_capture(captures: Captures) -> u64 {
-    let (_, [x, y]) = captures.extract();
-    x.parse::<u64>().unwrap() * y.parse::<u64>().unwrap()
-}
-- 
cgit v1.2.3