Dag 11 aoc done, ik vind dp stom

advent_of_code/2024/11/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/11/input.txt

@@ -0,0 +1 @@
+6563348 67 395 0 6 4425 89567 739318

advent_of_code/2024/11/src/main.rs

@@ -0,0 +1,121 @@
+use std::collections::HashMap;
+
+fn parse(input: &str) -> Vec<u64> {
+    input
+        .split_whitespace()
+        .map(|stone| stone.parse().unwrap())
+        .collect()
+}
+
+fn solve_1(input: &str) -> usize {
+    let stones = parse(input);
+    let mut current_stones = stones.clone();
+
+    // I know, this is very naive
+    for _ in 0..25 {
+        let mut new_stones = vec![];
+
+        for stone in current_stones {
+            if let 0 = stone {
+                new_stones.push(1);
+            } else {
+                let ss = stone.to_string();
+
+                if ss.len() % 2 == 0 {
+                    let (front, back) = ss.split_at(ss.len() / 2);
+                    new_stones.push(front.parse().unwrap());
+                    new_stones.push(back.parse().unwrap());
+                } else {
+                    new_stones.push(stone * 2024);
+                }
+            }
+        }
+        current_stones = new_stones;
+    }
+
+    current_stones.len()
+}
+
+fn solve_2(input: &str) -> u64 {
+    let stones = parse(input);
+
+    // Now for the dynamic programming version
+    let mut dp: HashMap<u64, u64> = HashMap::new();
+    for stone in stones {
+        dp.insert(stone, 1);
+    }
+
+    for _ in 0..75 {
+        let mut new_dp: HashMap<u64, u64> = HashMap::new();
+        for (stone, cnt) in dp.into_iter() {
+            let ss = stone.to_string();
+            if stone == 0 {
+                match new_dp.get_mut(&1) {
+                    None => {
+                        new_dp.insert(1, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                };
+            } else if ss.len() % 2 == 0 {
+                let (front, back) = ss.split_at(ss.len() / 2);
+                let front = front.parse::<u64>().unwrap();
+                let back = back.parse::<u64>().unwrap();
+
+                match new_dp.get_mut(&front) {
+                    None => {
+                        new_dp.insert(front, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                }
+                match new_dp.get_mut(&back) {
+                    None => {
+                        new_dp.insert(back, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                }
+            } else {
+                let new_stone = 2024 * stone;
+                match new_dp.get_mut(&new_stone) {
+                    None => {
+                        new_dp.insert(new_stone, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                }
+            }
+        }
+
+        dp = new_dp;
+    }
+
+    dp.values().sum()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!(
+        "The number of stones after blinking 25 times is {}",
+        result_1
+    );
+
+    let result_2 = solve_2(input);
+    println!(
+        "After blinking 75 times, the number of stones is {}",
+        result_2
+    );
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 55312);
+    }
+}

advent_of_code/2024/11/test.txt

@@ -0,0 +1 @@
+125 17