Merge pull request #6 from nerdatmath/push-xznymrplpkqu

Push xznymrplpkqu

Author: nerdatmath

2023/09/.gitignore

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

2023/09/Cargo.toml

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

2023/09/data/example1

@@ -0,0 +1,3 @@
+0 3 6 9 12 15
+1 3 6 10 15 21
+10 13 16 21 30 45

2023/09/data/input

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

2023/09/src/data.rs

@@ -0,0 +1,55 @@
+use std::{num::ParseIntError, str::FromStr};
+
+#[derive(Debug)]
+pub struct ParseError;
+
+impl From<ParseIntError> for ParseError {
+    fn from(_value: ParseIntError) -> Self {
+        Self
+    }
+}
+
+#[derive(Debug)]
+pub struct History(pub Box<[i64]>);
+
+impl FromStr for History {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(
+            s.split_ascii_whitespace()
+                .map(|s| s.parse())
+                .collect::<Result<_, _>>()?,
+        ))
+    }
+}
+
+impl History {
+    pub fn next_value(&self) -> i64 {
+        if self.0.len() <= 1 {
+            return 0;
+        }
+        let diffs = History(self.0.windows(2).map(|s| s[1] - s[0]).collect());
+        self.0[self.0.len() - 1] + diffs.next_value()
+    }
+
+    pub fn prev_value(&self) -> i64 {
+        if self.0.len() <= 1 {
+            return 0;
+        }
+        let diffs = History(self.0.windows(2).map(|s| s[1] - s[0]).collect());
+        self.0[0] - diffs.prev_value()
+    }
+}
+
+#[test]
+fn next_value() {
+    let h = History(Box::new([0, 3, 6, 9, 12, 15]));
+    assert_eq!(h.next_value(), 18);
+}
+
+#[test]
+fn prev_value() {
+    let h = History(Box::new([10, 13, 16, 21, 30, 45]));
+    assert_eq!(h.prev_value(), 5);
+}

2023/09/src/history.rs

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

2023/09/src/main.rs

@@ -0,0 +1,17 @@
+use crate::puzzle::Puzzle;
+
+pub fn run(input: &str) -> i64 {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    puzzle.histories.iter().map(|h| h.next_value()).sum()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::data::EXAMPLE1;
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(EXAMPLE1), 114);
+    }
+}

2023/09/src/part1/mod.rs

@@ -0,0 +1,21 @@
+use crate::puzzle::Puzzle;
+
+pub fn run(input: &str) -> i64 {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    puzzle
+        .histories
+        .iter()
+        .map(|h| h.prev_value())
+        .sum()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::data::EXAMPLE1;
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(EXAMPLE1), 2);
+    }
+}

2023/09/src/part2/mod.rs

@@ -0,0 +1,27 @@
+use std::str::FromStr;
+
+use crate::history::History;
+
+#[derive(Debug)]
+pub struct ParseError;
+
+impl From<<History as FromStr>::Err> for ParseError {
+    fn from(_value: <History as FromStr>::Err) -> Self {
+        Self
+    }
+}
+
+#[derive(Debug)]
+pub struct Puzzle {
+    pub histories: Box<[History]>,
+}
+
+impl FromStr for Puzzle {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self {
+            histories: s.lines().map(|s| s.parse()).collect::<Result<_, _>>()?,
+        })
+    }
+}