commit 06a183c334afc564d1ba88a3e46094e0ef9c60f6 · aylac.top/advent_of_code

+22 -30
2015/14/gleam/src/main.gleam
···

       25
       25
        
         LeadKm(km: Int, leads: Set(String))

     

       26
       26
        
       }

     

       27
       27
        
       

     

       28
       28
       -
       pub type RunState {

     

       29
       29
       -
         RunState(lead_km: LeadKm, state: Dict(String, ReindeerState))

     

       30
       30
       -
       }

     

       28
       28
       +
       pub type RunState =

     

       29
       29
       +
         Dict(String, ReindeerState)

     

       31
       30
        
       

     

       32
       31
        
       pub fn to_int(number_string) {

     

       33
       32
        
         let assert Ok(number) = number_string |> int.base_parse(10)

     
···

       39
       38
        
         case sec > 0 {

     

       40
       39
        
           False -> state

     

       41
       40
        
           True -> {

     

       42
       42
       -
             let RunState(LeadKm(_, leads), state) =

     

       41
       41
       +
             let #(LeadKm(_, leads), state) =

     

       43
       42
        
               reindeers

     

       44
       44
       -
               |> list.fold(state, fn(s, reindeer) {

     

       45
       45
       -
                 let RunState(lead_km, state) = s

     

       43
       43
       +
               |> list.fold(#(LeadKm(0, set.new()), state), fn(s, reindeer) {

     

       44
       44
       +
                 let #(lead, state) = s

     

       46
       45
        
                 let Reindeer(name, speed, run, rest) = reindeer

     

       47
       46
        
                 let ReindeerState(points, km, action, time_until_change) =

     

       48
       47
        
                   state

     
···

       61
       60
        
                   }

     

       62
       61
        
                   |> dict.insert(state, name, _)

     

       63
       62
        
       

     

       64
       64
       -
                 let lead_km = case int.compare(km, lead_km.km) {

     

       65
       65
       -
                   Eq -> LeadKm(km, lead_km.leads |> set.insert(name))

     

       63
       63
       +
                 let lead = case int.compare(km, lead.km) {

     

       64
       64
       +
                   Eq -> LeadKm(km, lead.leads |> set.insert(name))

     

       66
       65
        
                   Gt -> LeadKm(km, set.new() |> set.insert(name))

     

       67
       67
       -
                   Lt -> lead_km

     

       66
       66
       +
                   Lt -> lead

     

       68
       67
        
                 }

     

       69
       68
        
       

     

       70
       70
       -
                 RunState(lead_km, state)

     

       69
       69
       +
                 #(lead, state)

     

       71
       70
        
               })

     

       72
       71
        
       

     

       73
       73
       -
             let state =

     

       74
       74
       -
               leads

     

       75
       75
       -
               |> set.fold(state, fn(state, reindeer_name) {

     

       76
       76
       -
                 let assert Ok(ReindeerState(points, km, action, time_until_change)) =

     

       77
       77
       -
                   state

     

       78
       78
       -
                   |> dict.get(reindeer_name)

     

       72
       72
       +
             leads

     

       73
       73
       +
             |> set.fold(state, fn(state, reindeer_name) {

     

       74
       74
       +
               let assert Ok(ReindeerState(points, km, action, time_until_change)) =

     

       79
       75
        
                 state

     

       80
       80
       -
                 |> dict.insert(

     

       81
       81
       -
                   reindeer_name,

     

       82
       82
       -
                   ReindeerState(points + 1, km, action, time_until_change),

     

       83
       83
       -
                 )

     

       84
       84
       -
               })

     

       85
       85
       -
       

     

       86
       86
       -
             RunState(LeadKm(0, set.new()), state)

     

       76
       76
       +
                 |> dict.get(reindeer_name)

     

       77
       77
       +
               state

     

       78
       78
       +
               |> dict.insert(

     

       79
       79
       +
                 reindeer_name,

     

       80
       80
       +
                 ReindeerState(points + 1, km, action, time_until_change),

     

       81
       81
       +
               )

     

       82
       82
       +
             })

     

       87
       83
        
             |> do_calculate_run_state(reindeers, sec - 1)

     

       88
       84
        
           }

     

       89
       85
        
         }

     

       90
       86
        
       }

     

       91
       87
        
       

     

       92
       88
        
       pub fn calculate_run_state(reindeers: List(Reindeer), sec: Int) {

     

       93
       93
       -
         do_calculate_run_state(

     

       94
       94
       -
           RunState(LeadKm(0, set.new()), dict.new()),

     

       95
       95
       -
           reindeers,

     

       96
       96
       -
           sec,

     

       97
       97
       -
         )

     

       89
       89
       +
         do_calculate_run_state(dict.new(), reindeers, sec)

     

       98
       90
        
       }

     

       99
       91
        
       

     

       100
       92
        
       pub fn get_winner_km(state: RunState) {

     

       101
       101
       -
         state.state

     

       93
       93
       +
         state

     

       102
       94
        
         |> dict.fold(0, fn(winner, _, state) {

     

       103
       95
        
           case state.km > winner {

     

       104
       96
        
             True -> state.km

     
···

       108
       100
        
       }

     

       109
       101
        
       

     

       110
       102
        
       pub fn get_winner_points(state: RunState) {

     

       111
       111
       -
         state.state

     

       103
       103
       +
         state

     

       112
       104
        
         |> dict.fold(0, fn(winner, _, state) {

     

       113
       105
        
           case state.points > winner {

     

       114
       106
        
             True -> state.points