commit 1c36b88f9b8b07bf0d39908071e3e251b592714d · aylac.top/advent_of_code

+6 -1

2015/18/rust/src/main.rs

···

       1
       1
        
       use std::mem::swap;

     

       2
       2
        
       

     

       3
       3
       -
       fn generations(times: u32, mut world: Vec<u8>, size: usize, stuck: bool) -> Vec<u8> {

     

       3
       3
       +
       fn generations(

     

       4
       4
       +
           times: u32,

     

       5
       5
       +
           mut world: Vec<u8>,

     

       6
       6
       +
           size: usize,

     

       7
       7
       +
           stuck: bool,

     

       8
       8
       +
       ) -> Vec<u8> {

     

       4
       9
        
           let pos = |x, y| y * (size + 2) + x;

     

       5
       10
        
       

     

       6
       11
        
           let sizep = size + 1;

+2 -1

2015/2/rust/src/main.rs

···

       1
       1
        
       use itertools::Itertools;

     

       2
       2
        
       

     

       3
       3
        
       fn main() {

     

       4
       4
       -
           let input = std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       4
       4
       +
           let input =

     

       5
       5
       +
               std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       5
       6
        
           let input = input

     

       6
       7
        
               .trim()

     

       7
       8
        
               .split("\n")

+2 -1

2015/4/rust/src/main.rs

···

       21
       21
        
       }

     

       22
       22
        
       

     

       23
       23
        
       fn main() {

     

       24
       24
       -
           let input = std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       24
       24
       +
           let input =

     

       25
       25
       +
               std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       25
       26
        
           let input = input.trim();

     

       26
       27
        
       

     

       27
       28
        
           let res = find(input, 5);

+3 -1

2025/1/rust/src/main.rs

···

       43
       43
        
                       turn,

     

       44
       44
        
                       // if it is below zero before being moduloed and the original number itself wasn't zero it means that it did touch zero but the division thing wouldn't count it, so we give this extra support.

     

       45
       45
        
                       // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

       46
       46
       -
                       zeroes: acc.zeroes + raw_zeroes + (acc.turn != 0 && raw_turn <= 0) as i32,

     

       46
       46
       +
                       zeroes: acc.zeroes

     

       47
       47
       +
                           + raw_zeroes

     

       48
       48
       +
                           + (acc.turn != 0 && raw_turn <= 0) as i32,

     

       47
       49
        
                   }

     

       48
       50
        
               },

     

       49
       51
        
           );

+6 -4

2025/2/rust/src/main.rs

···

       23
       23
        
               })

     

       24
       24
        
               .collect();

     

       25
       25
        
       

     

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

     

       26
       26
       +
           let powers_of_ten: Vec<u64> =

     

       27
       27
       +
               (0..=MAX_LENGTH as u32).map(|i| 10_u64.pow(i)).collect();

     

       27
       28
        
       

     

       28
       29
        
           let [invalid_part_1, invalid_part_2] = {

     

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

     
···

       31
       32
        
       

     

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

     

       33
       34
        
                   // 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()

     

       35
       35
       +
                   for combination in *powers_of_ten.get(len - 1).unwrap_or(&1)

     

       36
       36
       +
                       ..*powers_of_ten.get(len).unwrap()

     

       36
       37
        
                   {

     

       37
       38
        
                       let mut number = 0;

     

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

     

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

     

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

     

       41
       41
       +
                           number += combination

     

       42
       42
       +
                               * powers_of_ten.get((len * repeat) as usize).unwrap();

     

       41
       43
        
                           if repeat > 0 {

     

       42
       44
        
                               part_2.insert(number);

     

       43
       45
        
                           }

+5 -5

2025/3/rust/src/main.rs

···

       4
       4
        
           input.iter().fold(0, |acc, bank| {

     

       5
       5
        
               let bank_len = bank.len();

     

       6
       6
        
               let (n, _) = (0..digits).rfold((0, 0), |(number, bank_index), i| {

     

       7
       7
       -
                   let (loc, max) = bank[bank_index..bank_len - i].iter().enumerate().fold(

     

       8
       8
       -
                       (0_usize, &0_u64),

     

       9
       9
       -
                       |(maxi, max), (i, n)| {

     

       7
       7
       +
                   let (loc, max) = bank[bank_index..bank_len - i]

     

       8
       8
       +
                       .iter()

     

       9
       9
       +
                       .enumerate()

     

       10
       10
       +
                       .fold((0_usize, &0_u64), |(maxi, max), (i, n)| {

     

       10
       11
        
                           if n > max { (i, n) } else { (maxi, max) }

     

       11
       11
       -
                       },

     

       12
       12
       -
                   );

     

       12
       12
       +
                       });

     

       13
       13
        
       

     

       14
       14
        
                   ((number * 10) + max, bank_index + loc + 1)

     

       15
       15
        
               });

+2

rustfmt.toml

···

       1
       1
       +
       edition = "2024"

     

       2
       2
       +
       max_width = 80