commit 3042768f1102935ac6a35d8af5f3925ee9ca9660 · aylac.top/advent_of_code

+1 -1

2025/1/gleam/src/main.gleam

···

       46
       46
        
             let raw_zeroes = int.absolute_value(raw_new_number / 100)

     

       47
       47
        
             let zeroes =

     

       48
       48
        
               acc.zeroes

     

       49
       49
       -
               + case raw_new_number <= 0 && acc.number != 0 {

     

       49
       49
       +
               + case acc.number != 0 && raw_new_number <= 0 {

     

       50
       50
        
                 // 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.

     

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

     

       52
       52
        
                 True -> raw_zeroes + 1

2025/1/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

2025/1/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+49

2025/1/rust/src/main.rs

···

       1
       1
       +
       struct State {

     

       2
       2
       +
           turn: i32,

     

       3
       3
       +
           zeroes: i32,

     

       4
       4
       +
       }

     

       5
       5
       +
       

     

       6
       6
       +
       fn main() {

     

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

     

       8
       8
       +
               .trim()

     

       9
       9
       +
               .split("\n")

     

       10
       10
       +
               .map(|n| {

     

       11
       11
       +
                   n.replace("L", "-")

     

       12
       12
       +
                       .replace("R", "")

     

       13
       13
       +
                       .parse::<i32>()

     

       14
       14
       +
                       .expect("invalid input")

     

       15
       15
       +
               })

     

       16
       16
       +
               .collect();

     

       17
       17
       +
       

     

       18
       18
       +
           let part_1 = input.iter().fold(

     

       19
       19
       +
               State {

     

       20
       20
       +
                   turn: 50,

     

       21
       21
       +
                   zeroes: 0,

     

       22
       22
       +
               },

     

       23
       23
       +
               |acc, n| {

     

       24
       24
       +
                   let turn = (acc.turn + n).rem_euclid(100);

     

       25
       25
       +
                   State {

     

       26
       26
       +
                       turn,

     

       27
       27
       +
                       zeroes: acc.zeroes + (turn == 0) as i32,

     

       28
       28
       +
                   }

     

       29
       29
       +
               },

     

       30
       30
       +
           );

     

       31
       31
       +
           println!("{}", part_1.zeroes);

     

       32
       32
       +
       

     

       33
       33
       +
           let part_2 = input.iter().fold(

     

       34
       34
       +
               State {

     

       35
       35
       +
                   turn: 50,

     

       36
       36
       +
                   zeroes: 0,

     

       37
       37
       +
               },

     

       38
       38
       +
               |acc, n| {

     

       39
       39
       +
                   let raw_turn = acc.turn + n;

     

       40
       40
       +
                   let turn = raw_turn.rem_euclid(100);

     

       41
       41
       +
                   let raw_zeroes = (raw_turn / 100).abs();

     

       42
       42
       +
                   State {

     

       43
       43
       +
                       turn,

     

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

     

       45
       45
       +
                   }

     

       46
       46
       +
               },

     

       47
       47
       +
           );

     

       48
       48
       +
           println!("{}", part_2.zeroes);

     

       49
       49
       +
       }

+2 -2

2025/2/rust/src/main.rs

···

       21
       21
        
       

     

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

     

       23
       23
        
       

     

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

     

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

     

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

     

       26
       26
        
                   if n <= 10 {

     

       27
       27
        
                       return acc;

     
···

       39
       39
        
           });

     

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

     

       41
       41
        
       

     

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

     

       42
       42
       +
           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 {

     

       45
       45
        
                       return acc;