2025 day 2.

.zed/settings.json

@@ -0,0 +1,5 @@
+{
+  "file_types": {
+    "Plain Text": ["**/data/input", "**/data/example*"],
+  },
+}

2025/01/src/part2/mod.rs

@@ -18,6 +18,7 @@ pub fn run(input: &str) -> usize {
     }
     count
 }
+
 #[cfg(test)]
 mod test {
     use super::*;

2025/02/.gitignore

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

2025/02/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "y2025d02"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+quickcheck = "1"
+quickcheck_macros = "1"
+generic-tests = "0"
+lazy-regex = "3"

2025/02/data/example1

@@ -0,0 +1 @@
+11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124

2025/02/data/input

@@ -0,0 +1 @@
+16100064-16192119,2117697596-2117933551,1-21,9999936269-10000072423,1770-2452,389429-427594,46633-66991,877764826-877930156,880869-991984,18943-26512,7216-9427,825-1162,581490-647864,2736-3909,39327886-39455605,430759-454012,1178-1741,219779-244138,77641-97923,1975994465-1976192503,3486612-3602532,277-378,418-690,74704280-74781349,3915-5717,665312-740273,69386294-69487574,2176846-2268755,26-45,372340114-372408052,7996502103-7996658803,7762107-7787125,48-64,4432420-4462711,130854-178173,87-115,244511-360206,69-86

2025/02/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");

2025/02/src/invalid_id.rs

@@ -0,0 +1,39 @@
+const DIVISORS_OF: [&'static [u32]; 19] = [
+    &[1],
+    &[1, 2],
+    &[1, 3],
+    &[1, 2, 4],
+    &[1, 5],
+    &[1, 2, 3, 6],
+    &[1, 7],
+    &[1, 2, 4, 8],
+    &[1, 3, 9],
+    &[1, 2, 5, 10],
+    &[1, 11],
+    &[1, 2, 3, 4, 6, 12],
+    &[1, 13],
+    &[1, 2, 7, 14],
+    &[1, 3, 5, 15],
+    &[1, 2, 4, 8, 16],
+    &[1, 17],
+    &[1, 2, 9, 18],
+    &[1, 19],
+];
+
+fn ones(digits: u32) -> u64 {
+    (10u64.pow(digits - 1) - 1) / 9 * 10 + 1
+}
+
+pub fn has_repeated_digits(n: u64, repeats: u32) -> bool {
+    let digits = n.ilog10() + 1;
+    if !digits.is_multiple_of(repeats) {
+        return false;
+    }
+    n.is_multiple_of(ones(digits) / ones(digits / repeats))
+}
+
+pub fn is_repeated(n: u64) -> bool {
+    DIVISORS_OF[n.ilog10() as usize][1..]
+        .into_iter()
+        .any(|&repeats| has_repeated_digits(n, repeats))
+}

2025/02/src/main.rs

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

2025/02/src/part1/mod.rs

@@ -0,0 +1,41 @@
+use crate::invalid_id::has_repeated_digits;
+use crate::puzzle::Puzzle;
+
+fn sum_of_invalid_ids_in(it: impl Iterator<Item = u64>) -> u64 {
+    it.filter(|&n| has_repeated_digits(n, 2)).sum()
+}
+
+pub fn run(input: &str) -> u64 {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    puzzle
+        .ranges
+        .iter()
+        .cloned()
+        .map(sum_of_invalid_ids_in)
+        .sum()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_sum_of_invalid_ids_in_range() {
+        assert_eq!(sum_of_invalid_ids_in(11..=22), 33);
+        assert_eq!(sum_of_invalid_ids_in(95..=115), 99);
+        assert_eq!(sum_of_invalid_ids_in(998..=1012), 1010);
+        assert_eq!(sum_of_invalid_ids_in(1188511880..=1188511890), 1188511885);
+        assert_eq!(sum_of_invalid_ids_in(222220..=222224), 222222);
+        assert_eq!(sum_of_invalid_ids_in(1698522..=1698528), 0);
+        assert_eq!(sum_of_invalid_ids_in(446443..=446449), 446446);
+        assert_eq!(sum_of_invalid_ids_in(38593856..=38593862), 38593859);
+        assert_eq!(sum_of_invalid_ids_in(565653..=565659), 0);
+        assert_eq!(sum_of_invalid_ids_in(824824821..=824824827), 0);
+        assert_eq!(sum_of_invalid_ids_in(2121212118..=2121212124), 0);
+    }
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(crate::data::EXAMPLE1), 1227775554);
+    }
+}

2025/02/src/part2/mod.rs

@@ -0,0 +1,41 @@
+use crate::invalid_id::is_repeated;
+use crate::puzzle::Puzzle;
+
+fn sum_of_invalid_ids_in(it: impl Iterator<Item = u64>) -> u64 {
+    it.filter(|&n| is_repeated(n)).sum()
+}
+
+pub fn run(input: &str) -> u64 {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    puzzle
+        .ranges
+        .iter()
+        .cloned()
+        .map(sum_of_invalid_ids_in)
+        .sum()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_sum_of_invalid_ids_in_range() {
+        assert_eq!(sum_of_invalid_ids_in(11..=22), 33);
+        assert_eq!(sum_of_invalid_ids_in(95..=115), 210);
+        assert_eq!(sum_of_invalid_ids_in(998..=1012), 2009);
+        assert_eq!(sum_of_invalid_ids_in(1188511880..=1188511890), 1188511885);
+        assert_eq!(sum_of_invalid_ids_in(222220..=222224), 222222);
+        assert_eq!(sum_of_invalid_ids_in(1698522..=1698528), 0);
+        assert_eq!(sum_of_invalid_ids_in(446443..=446449), 446446);
+        assert_eq!(sum_of_invalid_ids_in(38593856..=38593862), 38593859);
+        assert_eq!(sum_of_invalid_ids_in(565653..=565659), 565656);
+        assert_eq!(sum_of_invalid_ids_in(824824821..=824824827), 824824824);
+        assert_eq!(sum_of_invalid_ids_in(2121212118..=2121212124), 2121212121);
+    }
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(crate::data::EXAMPLE1), 4174379265);
+    }
+}

2025/02/src/puzzle.rs

@@ -0,0 +1,32 @@
+use lazy_regex::regex_captures;
+
+type Range = std::ops::RangeInclusive<u64>;
+
+#[derive(Debug)]
+pub struct Puzzle {
+    pub ranges: Vec<Range>,
+}
+
+#[derive(Debug)]
+pub struct ParseError();
+
+impl From<std::num::ParseIntError> for ParseError {
+    fn from(_value: std::num::ParseIntError) -> Self {
+        Self()
+    }
+}
+
+fn parse_range(s: &str) -> Result<Range, ParseError> {
+    let (_, start, end) = regex_captures!(r#"(\d+)-(\d+)"#, s).ok_or(ParseError())?;
+    Ok((start.parse()?)..=(end.parse()?))
+}
+
+impl std::str::FromStr for Puzzle {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Puzzle {
+            ranges: s.split(',').map(parse_range).collect::<Result<_, _>>()?,
+        })
+    }
+}