rust 2024 03: remove regex and redo

3 files changed, 53 insertions, 79 deletions

diff --git a/2024/03/rust/Cargo.lock b/2024/03/rust/Cargo.lock
index 705a257..a7a6f57 100644
--- a/2024/03/rust/Cargo.lock
+++ b/2024/03/rust/Cargo.lock
@@ -3,52 +3,5 @@
 version = 4
 
 [[package]]
-name = "aho-corasick"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
-dependencies = [
- "memchr",
-]
-
-[[package]]
 name = "aoc_2024-03"
 version = "0.1.0"
-dependencies = [
- "regex",
-]
-
-[[package]]
-name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-
-[[package]]
-name = "regex"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
diff --git a/2024/03/rust/Cargo.toml b/2024/03/rust/Cargo.toml
index ba499a8..97ec307 100644
--- a/2024/03/rust/Cargo.toml
+++ b/2024/03/rust/Cargo.toml
@@ -2,6 +2,3 @@
 name = "aoc_2024-03"
 version = "0.1.0"
 edition = "2021"
-
-[dependencies]
-regex = "1.11.1"
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()
-}