Merge pull request #7 from nerdatmath/push-trnwkzruuspv

Push trnwkzruuspv

Author: nerdatmath

2023/11/.gitignore

@@ -0,0 +1 @@
+/target

2023/11/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "y2023d11"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0.100"
+itertools.workspace = true

2023/11/data/example1

@@ -0,0 +1 @@
+0 1 10 99 999

2023/11/data/example2

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

2023/11/data/input

@@ -0,0 +1 @@
+3935565 31753 437818 7697 5 38 0 123

2023/11/src/data.rs

@@ -0,0 +1,8 @@
+#[cfg(test)]
+pub const EXAMPLE1: &'static str = include_str!("../data/example1");
+
+#[cfg(test)]
+pub const EXAMPLE2: &'static str = include_str!("../data/example2");
+
+#[allow(unused)]
+pub const INPUT: &'static str = include_str!("../data/input");

2023/11/src/main.rs

@@ -0,0 +1,11 @@
+mod data;
+mod part1;
+mod part2;
+mod puzzle;
+mod stone;
+
+fn main() {
+    use data::INPUT;
+    println!("Part 1: {}", part1::run(INPUT));
+    println!("Part 2: {}", part2::run(INPUT));
+}

2023/11/src/part1/mod.rs

@@ -0,0 +1,44 @@
+use crate::*;
+use puzzle::Puzzle;
+use stone::Stone;
+
+type Stones = Vec<Stone>;
+
+pub fn blink(stones: &Stones) -> Stones {
+    stones.into_iter().flat_map(Stone::blink).collect()
+}
+
+pub fn run(input: &str) -> usize {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    let mut stones = puzzle.0;
+    for _ in 0..25 {
+        stones = blink(&stones);
+    }
+    stones.len()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use anyhow::Result;
+    use data::EXAMPLE1;
+    use data::EXAMPLE2;
+
+    #[test]
+    fn test_blink() -> Result<()> {
+        let puzzle: Puzzle = EXAMPLE1.parse()?;
+        assert_eq!(
+            blink(&puzzle.0),
+            [1, 2024, 1, 0, 9, 9, 2021976]
+                .into_iter()
+                .map(Stone)
+                .collect::<Stones>()
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(EXAMPLE2), 55312);
+    }
+}

2023/11/src/part2/mod.rs

@@ -0,0 +1,48 @@
+use crate::*;
+use itertools::Itertools;
+use puzzle::Puzzle;
+use std::collections::HashMap;
+use stone::Stone;
+
+type Stones = HashMap<Stone, usize>;
+
+fn blink(stones: &Stones) -> Stones {
+    stones
+        .iter()
+        .flat_map(|(&stone, &count)| stone.blink().into_iter().map(move |stone| (stone, count)))
+        .into_grouping_map()
+        .sum()
+}
+
+pub fn run(input: &str) -> usize {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    let mut stones: Stones = puzzle.0.iter().map(|&stone| (stone, 1usize)).collect();
+    for _ in 0..75 {
+        stones = blink(&stones);
+    }
+    stones.into_iter().map(|(_, count)| count).sum()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use anyhow::Result;
+    use data::EXAMPLE1;
+
+    #[test]
+    fn test_blink() -> Result<()> {
+        let puzzle: Puzzle = EXAMPLE1.parse()?;
+        let stones: Stones = puzzle.0.iter().copied().counts();
+        assert_eq!(
+            blink(&stones),
+            Stones::from([
+                (Stone(1), 2),
+                (Stone(2024), 1),
+                (Stone(0), 1),
+                (Stone(9), 2),
+                (Stone(2021976), 1)
+            ])
+        );
+        Ok(())
+    }
+}

2023/11/src/puzzle.rs

@@ -0,0 +1,19 @@
+use crate::*;
+use anyhow::Result;
+use std::str::FromStr;
+use stone::Stone;
+
+#[derive(Debug)]
+pub struct Puzzle(pub Vec<Stone>);
+
+impl FromStr for Puzzle {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        Ok(Puzzle(
+            s.split(' ')
+                .map(|s| Ok(Stone(s.parse()?)))
+                .collect::<Result<_>>()?,
+        ))
+    }
+}