2024 day-3 as answered

2024/day-3/Cargo.toml

@@ -15,6 +15,7 @@ log.workspace = true
 error-stack.workspace = true
 thiserror.workspace = true
 dhat.workspace = true
+regex.workspace = true
 
 [dev-dependencies]
 test-log.workspace = true

2024/day-3/src/part1.rs

@@ -2,6 +2,7 @@
 
 use error_stack::Result;
 use thiserror::Error;
+use regex::Regex;
 
 // day-3
 #[derive(Debug, Error)]
@@ -10,21 +11,22 @@ pub enum Day3Part1Error{
     ParseError,
 }
 
-pub fn part1 (_input: &str) -> Result<String, Day3Part1Error> {
-    Ok("Not Finished".to_string())
+pub fn part1 (input: &str) -> Result<String, Day3Part1Error> {
+    let re = Regex::new(r"mul\((\d{1,3}),(\d{1,3})\)").unwrap();
+    Ok(re.captures_iter(input).map(|x| &x[1].parse::<i64>().unwrap() * &x[2].parse::<i64>().unwrap()).sum::<i64>().to_string())
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
 
-    const INPUT: &str = "";
+    const INPUT: &str = "xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))";
 
     #[test_log::test]
     #[test_log(default_log_filter = "trace")]
     fn part1_works() {
         let result = part1(INPUT).unwrap();
-        assert_eq!(result, "Not Finished".to_string());
+        assert_eq!(result, "161".to_string());
     }
 }
 

2024/day-3/src/part2.rs

@@ -1,6 +1,7 @@
 #![warn(clippy::all, clippy::pedantic)]
 
 use error_stack::Result;
+use regex::Regex;
 use thiserror::Error;
 
 // day-3
@@ -10,21 +11,68 @@ pub enum Day3Part2Error{
     ParseError,
 }
 
-pub fn part2 (_input: &str) -> Result<String, Day3Part2Error> {
-    Ok("Not Finished".to_string())
+pub fn part2 (input: &str) -> Result<String, Day3Part2Error> {
+    let do_re = Regex::new(r"do\(\)").unwrap();
+    let dos = do_re.find_iter(input).map(|x| (x.start(),x.end())).collect::<Vec<_>>();
+    let dont_re = Regex::new(r"don't\(\)").unwrap();
+    let donts = dont_re.find_iter(input).map(|x| (x.start(),x.end())).collect::<Vec<_>>();
+
+    let mut dos_index = 0;
+    let mut donts_index = 0;
+    let mut white_list = true;
+    let mut blackout_ranges = Vec::new();
+    let mut blacklist_start = 0;
+    while dos_index < dos.len() && donts_index < donts.len(){
+        if white_list {
+            if dos[dos_index].1 < donts[donts_index].0 {
+                //currently whitelisted so dos are no-ops
+                dos_index +=1;
+            } else {
+                blacklist_start = donts[donts_index].0;
+                white_list = false;
+            }
+        } else {
+            if donts[donts_index].1 < dos[dos_index].0 {
+                //in a black list so donts are no-ops
+                donts_index +=1;
+            } else {
+                blackout_ranges.push(blacklist_start..dos[dos_index].1);
+                blacklist_start = 0;
+                white_list = true;
+            }
+        }
+    }
+    if donts_index < donts.len()  {
+        blackout_ranges.push(donts[donts_index].0..input.len());
+
+    } else if dos_index < dos.len() {
+        if blacklist_start  != 0 {
+            blackout_ranges.push(blacklist_start..dos[dos_index].1);
+        }
+    }
+    let re = Regex::new(r"mul\((\d{1,3}),(\d{1,3})\)").unwrap();
+    let mut sum = 0;
+    for mult_match in re.find_iter(input){
+        if blackout_ranges.iter().any(|x| x.contains(&mult_match.start())) {
+            continue;
+        }
+        let values = re.captures(mult_match.as_str()).unwrap();
+        sum += &values[1].parse::<i64>().unwrap() * &values[2].parse::<i64>().unwrap();
+    }
+    Ok(sum.to_string())
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
 
-    const INPUT: &str = "";
+    const INPUT: &str = "xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))";
 
     #[test_log::test]
     #[test_log(default_log_filter = "trace")]
     fn part2_works() {
         let result = part2(INPUT).unwrap();
-        assert_eq!(result, "Not Finished".to_string());
+        assert_eq!(result, "48".to_string());
     }
 }