commit a43fafba615241b667ef280c97d75072a079703b · aylac.top/advent_of_code

+31 -32
2025/2/rust/src/main.rs
···

       25
       25
        
       

     

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

     

       27
       27
        
       

     

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

     

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

     

       30
       30
       -
                   if n <= 10 {

     

       31
       31
       -
                       return acc;

     

       28
       28
       +
           let [invalid_part_1, invalid_part_2] = {

     

       29
       29
       +
               let mut part_1: HashSet<u64> = HashSet::new();

     

       30
       30
       +
               let mut part_2: HashSet<u64> = HashSet::new();

     

       31
       31
       +
       

     

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

     

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

     

       34
       34
       +
                   for combination in

     

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

     

       36
       36
       +
                   {

     

       37
       37
       +
                       let mut number = 0;

     

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

     

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

     

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

     

       41
       41
       +
                           if repeat > 0 {

     

       42
       42
       +
                               part_2.insert(number);

     

       43
       43
       +
                           }

     

       44
       44
       +
                           if repeat == 1 {

     

       45
       45
       +
                               part_1.insert(number);

     

       46
       46
       +
                           }

     

       47
       47
       +
                       }

     

       32
       48
        
                   }

     

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

     

       34
       34
       -
                   if len % 2 == 1 {

     

       35
       35
       -
                       return acc;

     

       36
       36
       -
                   }

     

       37
       37
       -
                   let pow = powers_of_ten.get(len / 2).unwrap();

     

       38
       38
       -
                   if n / pow == n % pow {

     

       39
       39
       -
                       return acc + n;

     

       40
       40
       -
                   }

     

       49
       49
       +
               }

     

       50
       50
       +
       

     

       51
       51
       +
               [part_1, part_2]

     

       52
       52
       +
           };

     

       53
       53
       +
       

     

       54
       54
       +
           let part_1 = invalid_part_1.iter().fold(0, |acc, number| {

     

       55
       55
       +
               if input.iter().any(|r| *number >= r.start && *number <= r.end) {

     

       56
       56
       +
                   acc + number

     

       57
       57
       +
               } else {

     

       41
       58
        
                   acc

     

       42
       42
       -
               })

     

       59
       59
       +
               }

     

       43
       60
        
           });

     

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

     

       45
       62
        
       

     

       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
       -
       

     

       64
       64
       -
           let part_2 = part_2_invalid.iter().fold(0, |acc, number| {

     

       63
       63
       +
           let part_2 = invalid_part_2.iter().fold(0, |acc, number| {

     

       65
       64
        
               if input.iter().any(|r| *number >= r.start && *number <= r.end) {

     

       66
       65
        
                   acc + number

     

       67
       66
        
               } else {