···

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

     

       
26
       
 
       
}

     

       
27
       
 
       


     

       
28
       
-
       
pub type RunState {

     

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

     

       
30
       
-
       
}

     

       
31
       
 
       


     

       
32
       
 
       
pub fn to_int(number_string) {

     

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

     
···

       
39
       
 
       
  case sec > 0 {

     

       
40
       
 
       
    False -> state

     

       
41
       
 
       
    True -> {

     

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

     

       
43
       
 
       
        reindeers

     

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

     

       
45
       
-
       
          let RunState(lead_km, state) = s

     

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

     

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

     

       
48
       
 
       
            state

     
···

       
61
       
 
       
            }

     

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

     

       
63
       
 
       


     

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

     

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

     

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

     

       
67
       
-
       
            Lt -> lead_km

     

       
68
       
 
       
          }

     

       
69
       
 
       


     

       
70
       
-
       
          RunState(lead_km, state)

     

       
71
       
 
       
        })

     

       
72
       
 
       


     

       
73
       
-
       
      let state =

     

       
74
       
-
       
        leads

     

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

     

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

     

       
77
       
-
       
            state

     

       
78
       
-
       
            |> dict.get(reindeer_name)

     

       
79
       
 
       
          state

     

       
80
       
-
       
          |> dict.insert(

     

       
81
       
-
       
            reindeer_name,

     

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

     

       
83
       
-
       
          )

     

       
84
       
-
       
        })

     

       
85
       
-
       


     

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

     

       
87
       
 
       
      |> do_calculate_run_state(reindeers, sec - 1)

     

       
88
       
 
       
    }

     

       
89
       
 
       
  }

     

       
90
       
 
       
}

     

       
91
       
 
       


     

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

     

       
93
       
-
       
  do_calculate_run_state(

     

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

     

       
95
       
-
       
    reindeers,

     

       
96
       
-
       
    sec,

     

       
97
       
-
       
  )

     

       
98
       
 
       
}

     

       
99
       
 
       


     

       
100
       
 
       
pub fn get_winner_km(state: RunState) {

     

       
101
       
-
       
  state.state

     

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

     

       
103
       
 
       
    case state.km > winner {

     

       
104
       
 
       
      True -> state.km

     
···

       
108
       
 
       
}

     

       
109
       
 
       


     

       
110
       
 
       
pub fn get_winner_points(state: RunState) {

     

       
111
       
-
       
  state.state

     

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

     

       
113
       
 
       
    case state.points > winner {

     

       
114
       
 
       
      True -> state.points

     

···

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

     

       
26
       
 
       
}

     

       
27
       
 
       


     

       
28
       
+
       
pub type RunState =

     

       
29
       
+
       
  Dict(String, ReindeerState)

     

       
0
       
 
       

     

       
30
       
 
       


     

       
31
       
 
       
pub fn to_int(number_string) {

     

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

     
···

       
38
       
 
       
  case sec > 0 {

     

       
39
       
 
       
    False -> state

     

       
40
       
 
       
    True -> {

     

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

     

       
42
       
 
       
        reindeers

     

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

     

       
44
       
+
       
          let #(lead, state) = s

     

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

     

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

     

       
47
       
 
       
            state

     
···

       
60
       
 
       
            }

     

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

     

       
62
       
 
       


     

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

     

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

     

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

     

       
66
       
+
       
            Lt -> lead

     

       
67
       
 
       
          }

     

       
68
       
 
       


     

       
69
       
+
       
          #(lead, state)

     

       
70
       
 
       
        })

     

       
71
       
 
       


     

       
72
       
+
       
      leads

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
75
       
 
       
          state

     

       
76
       
+
       
          |> dict.get(reindeer_name)

     

       
77
       
+
       
        state

     

       
78
       
+
       
        |> dict.insert(

     

       
79
       
+
       
          reindeer_name,

     

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

     

       
81
       
+
       
        )

     

       
82
       
+
       
      })

     

       
83
       
 
       
      |> do_calculate_run_state(reindeers, sec - 1)

     

       
84
       
 
       
    }

     

       
85
       
 
       
  }

     

       
86
       
 
       
}

     

       
87
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
90
       
 
       
}

     

       
91
       
 
       


     

       
92
       
 
       
pub fn get_winner_km(state: RunState) {

     

       
93
       
+
       
  state

     

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

     

       
95
       
 
       
    case state.km > winner {

     

       
96
       
 
       
      True -> state.km

     
···

       
100
       
 
       
}

     

       
101
       
 
       


     

       
102
       
 
       
pub fn get_winner_points(state: RunState) {

     

       
103
       
+
       
  state

     

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

     

       
105
       
 
       
    case state.points > winner {

     

       
106
       
 
       
      True -> state.points