commit 990d41ba6a212bdee2b8dac1527853b1ddd56cab · aylac.top/advent_of_code

+9 -10
2025/1/gleam/src/main.gleam
···

       19
       19
        
           |> list.map(fn(l) {

     

       20
       20
        
             case l {

     

       21
       21
        
               "R" <> turn -> turn |> int.parse |> result.unwrap(0)

     

       22
       22
       -
               "L" <> turn -> 0 - { turn |> int.parse |> result.unwrap(0) }

     

       22
       22
       +
               "L" <> turn -> -{ turn |> int.parse |> result.unwrap(0) }

     

       23
       23
        
               _ -> panic as "bad input"

     

       24
       24
        
             }

     

       25
       25
        
           })

     
···

       43
       43
        
           input

     

       44
       44
        
           |> list.fold(RotationState(50, 0), fn(acc, v) {

     

       45
       45
        
             let raw_new_number = acc.number + v

     

       46
       46
       -
             let new_number = int.modulo(raw_new_number, 100) |> result.unwrap(0)

     

       47
       47
       -
             let times_it_went_zero = {

     

       48
       48
       -
               let value = int.absolute_value(raw_new_number / 100)

     

       49
       49
       -
               case acc.number != 0, raw_new_number > 0 {

     

       50
       50
       -
                 True, False -> value + 1

     

       51
       51
       -
                 _, _ -> value

     

       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 {

     

       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
       +
                 True -> raw_zeroes + 1

     

       52
       52
       +
                 False -> raw_zeroes

     

       52
       53
        
               }

     

       53
       53
       -
             }

     

       54
       54
       -
             RotationState(new_number, acc.zeroes + times_it_went_zero)

     

       54
       54
       +
             RotationState(int.modulo(raw_new_number, 100) |> result.unwrap(0), zeroes)

     

       55
       55
        
           })

     

       56
       56
       -
       

     

       57
       56
        
         part2.zeroes

     

       58
       57
        
         |> int.to_string

     

       59
       58
        
         |> io.println