commit b56be8f084ee26049b071567633b09f623d9cc35 · aylac.top/advent_of_code

+16 -46
2025/1/gleam/src/main.gleam
···

       5
       5
        
       import gleam/string

     

       6
       6
        
       import simplifile as file

     

       7
       7
        
       

     

       8
       8
       -
       pub type Direction {

     

       9
       9
       -
         Left

     

       10
       10
       -
         Right

     

       11
       11
       -
       }

     

       12
       12
       -
       

     

       13
       13
       -
       pub type InputEntry {

     

       14
       14
       -
         InputEntry(direction: Direction, turn: Int)

     

       15
       15
       -
       }

     

       16
       16
       -
       

     

       17
       8
        
       pub type RotationState {

     

       18
       9
        
         RotationState(number: Int, zeroes: Int)

     

       19
       10
        
       }

     
···

       26
       17
        
           |> string.trim

     

       27
       18
        
           |> string.split("\n")

     

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

     

       29
       29
       -
             let #(direction, turn) = case l {

     

       30
       30
       -
               "R" <> turn -> #(Right, turn)

     

       31
       31
       -
               "L" <> turn -> #(Left, turn)

     

       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) }

     

       32
       23
        
               _ -> panic as "bad input"

     

       33
       24
        
             }

     

       34
       34
       -
             InputEntry(direction, turn |> int.parse |> result.unwrap(0))

     

       35
       25
        
           })

     

       36
       26
        
       

     

       37
       27
        
         let part1 =

     

       38
       28
        
           input

     

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

     

       40
       30
        
             let new_number =

     

       41
       41
       -
               int.modulo(

     

       42
       42
       -
                 acc.number

     

       43
       43
       -
                   + case v.direction {

     

       44
       44
       -
                   Right -> v.turn

     

       45
       45
       -
                   Left -> -v.turn

     

       46
       46
       -
                 },

     

       47
       47
       -
                 100,

     

       48
       48
       -
               )

     

       31
       31
       +
               int.modulo(acc.number + v, 100)

     

       49
       32
        
               |> result.unwrap(0)

     

       50
       50
       -
             RotationState(

     

       51
       51
       -
               new_number,

     

       52
       52
       -
               acc.zeroes

     

       53
       53
       -
                 + case new_number {

     

       54
       54
       -
                 0 -> 1

     

       55
       55
       -
                 _ -> 0

     

       56
       56
       -
               },

     

       57
       57
       -
             )

     

       33
       33
       +
             RotationState(new_number, case new_number {

     

       34
       34
       +
               0 -> acc.zeroes + 1

     

       35
       35
       +
               _ -> acc.zeroes

     

       36
       36
       +
             })

     

       58
       37
        
           })

     

       59
       59
       -
       

     

       60
       38
        
         part1.zeroes

     

       61
       39
        
         |> int.to_string

     

       62
       40
        
         |> io.println

     
···

       64
       42
        
         let part2 =

     

       65
       43
        
           input

     

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

     

       67
       67
       -
             let raw_new_number =

     

       68
       68
       -
               acc.number

     

       69
       69
       -
               + case v.direction {

     

       70
       70
       -
                 Right -> v.turn

     

       71
       71
       -
                 Left -> -v.turn

     

       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

     

       72
       52
        
               }

     

       73
       73
       -
             // took too long to remember that abs isn't this im so fucking stupid

     

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

     

       75
       75
       -
             // dumbest fuck in the world??? theres gotta be a mathy way of doing this

     

       76
       76
       -
             let times_it_went_zero =

     

       77
       77
       -
               list.range(acc.number, raw_new_number)

     

       78
       78
       -
               |> list.fold(0, fn(acc2, i) {

     

       79
       79
       -
                 case i % 100 {

     

       80
       80
       -
                   0 if i != acc.number -> acc2 + 1

     

       81
       81
       -
                   _ -> acc2

     

       82
       82
       -
                 }

     

       83
       83
       -
               })

     

       53
       53
       +
             }

     

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

     

       85
       55
        
           })

     

       86
       56