2023 day 6.

Author: nerdatmath

2023/06/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "y2023d06"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+lazy-regex = "3.4.1"

2023/06/data/example1

@@ -0,0 +1,2 @@
+Time:      7  15   30
+Distance:  9  40  200

2023/06/data/input

@@ -0,0 +1,2 @@
+Time:        53     91     67     68
+Distance:   250   1330   1081   1025

2023/06/src/data.rs

@@ -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/06/src/main.rs

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

2023/06/src/part1/mod.rs

@@ -0,0 +1,17 @@
+use crate::puzzle::Puzzle;
+
+pub fn run(input: &str) -> u64 {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    puzzle.races.into_iter().map(|race| race.ways()).product()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::data::EXAMPLE1;
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(EXAMPLE1), 288);
+    }
+}

2023/06/src/part2/mod.rs

@@ -0,0 +1,21 @@
+use crate::puzzle::Puzzle;
+
+pub fn run(input: &str) -> u64 {
+    let puzzle: Puzzle = input
+        .replace(' ', "")
+        .replace(':', ": ")
+        .parse()
+        .expect("parse failed");
+    puzzle.races.into_iter().map(|race| race.ways()).product()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::data::EXAMPLE1;
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(EXAMPLE1), 71503);
+    }
+}

2023/06/src/puzzle.rs

@@ -0,0 +1,103 @@
+use std::{iter::zip, str::FromStr};
+
+use lazy_regex::regex_captures;
+
+#[derive(Debug)]
+pub struct Puzzle {
+    pub races: Vec<Race>,
+}
+
+#[derive(Debug)]
+pub struct Race {
+    pub time: u64,
+    pub distance: u64,
+}
+
+impl Race {
+    pub fn ways(&self) -> u64 {
+        let q = ceil_sqrt(self.time * self.time - 4 * self.distance);
+        q - ((self.time ^ q ^ 1) & 1)
+    }
+}
+
+#[test]
+fn test_race_ways() {
+    assert_eq!(
+        Race {
+            time: 7,
+            distance: 9,
+        }
+        .ways(),
+        4
+    );
+    assert_eq!(
+        Race {
+            time: 15,
+            distance: 40,
+        }
+        .ways(),
+        8
+    );
+    assert_eq!(
+        Race {
+            time: 30,
+            distance: 200,
+        }
+        .ways(),
+        9
+    );
+    assert_eq!(
+        Race {
+            time: 71530,
+            distance: 940200,
+        }
+        .ways(),
+        71503
+    );
+}
+
+fn ceil_sqrt(n: u64) -> u64 {
+    return (n - 1).isqrt() + 1;
+}
+
+#[test]
+fn test_ceil_sqrt() {
+    for i in 0u64..5 {
+        for n in i.pow(2) + 1..=(i + 1).pow(2) {
+            assert_eq!(ceil_sqrt(n), i + 1);
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParseError;
+
+impl FromStr for Puzzle {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (_, time, distance) = regex_captures!(
+            r#"Time:\s+(\d+(?:\s+\d+)*)\nDistance:\s+(\d+(?:\s+\d+)*)"#,
+            s
+        )
+        .ok_or(ParseError)?;
+        let times: Vec<u64> = time
+            .split_ascii_whitespace()
+            .map(|s| s.parse())
+            .collect::<Result<_, _>>()
+            .map_err(|_| ParseError)?;
+        let distances: Vec<u64> = distance
+            .split_ascii_whitespace()
+            .map(|s| s.parse())
+            .collect::<Result<_, _>>()
+            .map_err(|_| ParseError)?;
+        if times.len() != distances.len() {
+            return Err(ParseError);
+        }
+        Ok(Puzzle {
+            races: zip(times, distances)
+                .map(|(time, distance)| Race { time, distance })
+                .collect(),
+        })
+    }
+}