Add day5

2024/day5/src/main.rs

@@ -0,0 +1,70 @@
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::fs;
+use std::time::Instant;
+
+fn main() {
+    let input = fs::read_to_string("input.txt").expect("Failed to read input file");
+    let (rules_str, updates_str) = input.split_once("\n\n").unwrap();
+
+    let rules: Vec<&str> = rules_str.split_whitespace().collect::<Vec<&str>>();
+    let updates: Vec<&str> = updates_str.split_whitespace().collect::<Vec<&str>>();
+
+    let mut table: HashMap<&str, Vec<&str>> = HashMap::new();
+    for r in rules {
+        let parts = r.split('|').collect::<Vec<&str>>();
+        if parts.len() == 2 {
+            table.entry(parts[0]).or_default().push(parts[1]);
+        }
+    }
+
+    let start = Instant::now();
+    let (solution1, solution2) = puzzle1_2(&updates, &table);
+    let end = Instant::now() - start;
+
+    println!("Solution 1: {}", solution1);
+    println!("Solution 2: {}", solution2);
+    println!("Time: {}", end.as_micros());
+}
+
+fn puzzle1_2(updates: &[&str], table: &HashMap<&str, Vec<&str>>) -> (i32, i32) {
+    let mut counter1 = 0;
+    let mut counter2 = 0;
+
+    for update in updates {
+        let ud = update.split(',').collect::<Vec<&str>>();
+
+        let mut repair = false;
+        for (i, u) in ud.iter().enumerate() {
+            if let Some(dependencies) = table.get(*u) {
+                if dependencies.iter().any(|k| ud[..i].contains(k)) {
+                    counter2 += repair_update(&ud, table);
+                    repair = true;
+                    break;
+                }
+            }
+        }
+        if !repair {
+            counter1 += ud[ud.len() / 2].parse::<i32>().unwrap_or(0);
+        }
+    }
+    (counter1, counter2)
+}
+
+fn repair_update(ud: &[&str], table: &HashMap<&str, Vec<&str>>) -> i32 {
+    let mut new_ud = Vec::new();
+
+    for u in ud {
+        let mut counter = new_ud.len();
+        while let Some(dependencies) = table.get(u) {
+            if dependencies.iter().any(|k| new_ud[..counter].contains(k)) {
+                counter -= 1;
+            } else {
+                break;
+            }
+        }
+        new_ud.insert(counter, u);
+    }
+
+    new_ud[new_ud.len() / 2].parse::<i32>().unwrap_or(0)
+}