commit 35c21e5418209af19c0eeb008aabdbd7f23847ca · aylac.top/advent_of_code

+27 -11
2025/2/rust/src/main.rs
···

       1
       1
       +
       use std::collections::HashSet;

     

       2
       2
       +
       

     

       1
       3
        
       struct Range {

     

       2
       4
        
           start: u64,

     

       3
       5
        
           end: u64,

     

       4
       6
        
       }

     

       7
       7
       +
       

     

       8
       8
       +
       const MAX_LENGTH: usize = 10;

     

       5
       9
        
       

     

       6
       10
        
       fn main() {

     

       7
       11
        
           let input: Vec<Range> = include_str!("../../input.txt")

     
···

       19
       23
        
               })

     

       20
       24
        
               .collect();

     

       21
       25
        
       

     

       22
       22
       -
           let powers_of_ten: Vec<u64> = (0..10).map(|i| 10_u64.pow(i)).collect();

     

       26
       26
       +
           let powers_of_ten: Vec<u64> = (0..=MAX_LENGTH as u32).map(|i| 10_u64.pow(i)).collect();

     

       23
       27
        
       

     

       24
       28
        
           let part_1 = input.iter().fold(0_u64, |acc, v| {

     

       25
       29
        
               (v.start..=v.end).fold(acc, |acc, n| {

     
···

       39
       43
        
           });

     

       40
       44
        
           println!("{}", part_1);

     

       41
       45
        
       

     

       46
       46
       +
           let mut part_2_invalid: HashSet<u64> = HashSet::new();

     

       47
       47
       +
           for len in 1..=MAX_LENGTH / 2 {

     

       48
       48
       +
               // 1-9, 10-99, 100-999, 100000-999999

     

       49
       49
       +
               for combination in

     

       50
       50
       +
                   *powers_of_ten.get(len - 1).unwrap_or(&1)..*powers_of_ten.get(len).unwrap()

     

       51
       51
       +
               {

     

       52
       52
       +
                   let mut number = 0;

     

       53
       53
       +
                   // 0 is just the number (9), 1 is one repetition (99)

     

       54
       54
       +
                   for repeat in 0..MAX_LENGTH / len {

     

       55
       55
       +
                       number += combination * powers_of_ten.get((len * repeat) as usize).unwrap();

     

       56
       56
       +
                       if repeat > 0 {

     

       57
       57
       +
                           part_2_invalid.insert(number);

     

       58
       58
       +
                       }

     

       59
       59
       +
                   }

     

       60
       60
       +
               }

     

       61
       61
       +
           }

     

       62
       62
       +
           let part_2_invalid = part_2_invalid;

     

       63
       63
       +
       

     

       42
       64
        
           let part_2 = input.iter().fold(0_u64, |acc, v| {

     

       43
       43
       -
               (v.start..=v.end).fold(acc, |acc, n| {

     

       44
       44
       -
                   if n <= 10 {

     

       65
       65
       +
               (v.start..=v.end).fold(acc, |acc, num| {

     

       66
       66
       +
                   if num <= 10 {

     

       45
       67
        
                       return acc;

     

       46
       68
        
                   }

     

       47
       47
       -
                   let len = (n.ilog10() + 1) as usize;

     

       48
       48
       -
                   match (1..=len / 2).rfind(|clen| {

     

       49
       49
       -
                       let num = n % powers_of_ten.get(*clen).unwrap();

     

       50
       50
       -
                       let res = (0..len / clen)

     

       51
       51
       -
                           .fold(0, |acc, i| acc + num * powers_of_ten.get(i * clen).unwrap());

     

       52
       52
       -
                       res == n

     

       53
       53
       -
                   }) {

     

       54
       54
       -
                       Some(_) => acc + n,

     

       69
       69
       +
                   match part_2_invalid.get(&num) {

     

       70
       70
       +
                       Some(_) => acc + num,

     

       55
       71
        
                       _ => acc,

     

       56
       72
        
                   }

     

       57
       73
        
               })