···

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
 
       
pub type ReindeerState {

     

       
21
       
-
       
  ReindeerState(km: Int, action: Action, time_until_change: Int)

     

       
22
       
-
       
}

     

       
23
       
-
       


     

       
24
       
-
       
pub type RunState =

     

       
25
       
-
       
  dict.Dict(String, ReindeerState)

     

       
26
       
-
       


     

       
27
       
-
       
pub type ReindeerStatePoints {

     

       
28
       
-
       
  ReindeerStatePoints(

     

       
29
       
-
       
    points: Int,

     

       
30
       
-
       
    km: Int,

     

       
31
       
-
       
    action: Action,

     

       
32
       
-
       
    time_until_change: Int,

     

       
33
       
-
       
  )

     

       
34
       
 
       
}

     

       
35
       
 
       


     

       
36
       
 
       
pub type LeadKm {

     

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

     

       
38
       
 
       
}

     

       
39
       
 
       


     

       
40
       
-
       
pub type RunStatePoints {

     

       
41
       
-
       
  RunStatePoints(lead_km: LeadKm, state: Dict(String, ReindeerStatePoints))

     

       
42
       
 
       
}

     

       
43
       
 
       


     

       
44
       
 
       
pub fn to_int(number_string) {

     
···

       
51
       
 
       
  case sec > 0 {

     

       
52
       
 
       
    False -> state

     

       
53
       
 
       
    True -> {

     

       
54
       
-
       
      reindeers

     

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

     

       
56
       
-
       
        let Reindeer(name, speed, run, rest) = reindeer

     

       
57
       
-
       
        let ReindeerState(km, action, time_until_change) =

     

       
58
       
-
       
          state

     

       
59
       
-
       
          |> dict.get(reindeer.name)

     

       
60
       
-
       
          |> result.unwrap(ReindeerState(0, Run, run))

     

       
61
       
-
       


     

       
62
       
-
       
        let km = case action {

     

       
63
       
-
       
          Run -> km + speed

     

       
64
       
-
       
          Rest -> km

     

       
65
       
-
       
        }

     

       
66
       
-
       
        case time_until_change, action {

     

       
67
       
-
       
          1, Run -> ReindeerState(km, Rest, rest)

     

       
68
       
-
       
          1, Rest -> ReindeerState(km, Run, run)

     

       
69
       
-
       
          _, _ -> ReindeerState(km, action, time_until_change - 1)

     

       
70
       
-
       
        }

     

       
71
       
-
       
        |> dict.insert(state, name, _)

     

       
72
       
-
       
      })

     

       
73
       
-
       
      |> do_calculate_run_state(reindeers, sec - 1)

     

       
74
       
-
       
    }

     

       
75
       
-
       
  }

     

       
76
       
-
       
}

     

       
77
       
-
       


     

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

     

       
79
       
-
       
  do_calculate_run_state(dict.new(), reindeers, sec)

     

       
80
       
-
       
}

     

       
81
       
-
       


     

       
82
       
-
       
pub fn get_winner_km(state: RunState) {

     

       
83
       
-
       
  state

     

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

     

       
85
       
-
       
    case state.km > winner {

     

       
86
       
-
       
      True -> state.km

     

       
87
       
-
       
      False -> winner

     

       
88
       
-
       
    }

     

       
89
       
-
       
  })

     

       
90
       
-
       
}

     

       
91
       
-
       


     

       
92
       
-
       
pub fn do_calculate_run_state_pt2(

     

       
93
       
-
       
  state: RunStatePoints,

     

       
94
       
-
       
  reindeers: List(Reindeer),

     

       
95
       
-
       
  sec,

     

       
96
       
-
       
) {

     

       
97
       
-
       
  case sec > 0 {

     

       
98
       
-
       
    False -> state

     

       
99
       
-
       
    True -> {

     

       
100
       
-
       
      let RunStatePoints(LeadKm(_, leads), state) =

     

       
101
       
 
       
        reindeers

     

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

     

       
103
       
-
       
          let RunStatePoints(lead_km, state) = s

     

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

     

       
105
       
-
       
          let ReindeerStatePoints(points, km, action, time_until_change) =

     

       
106
       
 
       
            state

     

       
107
       
 
       
            |> dict.get(reindeer.name)

     

       
108
       
-
       
            |> result.unwrap(ReindeerStatePoints(0, 0, Run, run))

     

       
109
       
 
       


     

       
110
       
 
       
          let km = case action {

     

       
111
       
 
       
            Run -> km + speed

     
···

       
113
       
 
       
          }

     

       
114
       
 
       
          let state =

     

       
115
       
 
       
            case time_until_change, action {

     

       
116
       
-
       
              1, Run -> ReindeerStatePoints(points, km, Rest, rest)

     

       
117
       
-
       
              1, Rest -> ReindeerStatePoints(points, km, Run, run)

     

       
118
       
-
       
              _, _ ->

     

       
119
       
-
       
                ReindeerStatePoints(points, km, action, time_until_change - 1)

     

       
120
       
 
       
            }

     

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

     

       
122
       
 
       


     
···

       
126
       
 
       
            Lt -> lead_km

     

       
127
       
 
       
          }

     

       
128
       
 
       


     

       
129
       
-
       
          RunStatePoints(lead_km, state)

     

       
130
       
 
       
        })

     

       
131
       
 
       


     

       
132
       
 
       
      let state =

     

       
133
       
 
       
        leads

     

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

     

       
135
       
-
       
          let assert Ok(ReindeerStatePoints(

     

       
136
       
-
       
            points,

     

       
137
       
-
       
            km,

     

       
138
       
-
       
            action,

     

       
139
       
-
       
            time_until_change,

     

       
140
       
-
       
          )) =

     

       
141
       
 
       
            state

     

       
142
       
 
       
            |> dict.get(reindeer_name)

     

       
143
       
 
       
          state

     

       
144
       
 
       
          |> dict.insert(

     

       
145
       
 
       
            reindeer_name,

     

       
146
       
-
       
            ReindeerStatePoints(points + 1, km, action, time_until_change),

     

       
147
       
 
       
          )

     

       
148
       
 
       
        })

     

       
149
       
 
       


     

       
150
       
-
       
      RunStatePoints(LeadKm(0, set.new()), state)

     

       
151
       
-
       
      |> do_calculate_run_state_pt2(reindeers, sec - 1)

     

       
152
       
 
       
    }

     

       
153
       
 
       
  }

     

       
154
       
 
       
}

     

       
155
       
 
       


     

       
156
       
-
       
pub fn calculate_run_state_pt2(reindeers: List(Reindeer), sec: Int) {

     

       
157
       
-
       
  do_calculate_run_state_pt2(

     

       
158
       
-
       
    RunStatePoints(LeadKm(0, set.new()), dict.new()),

     

       
159
       
 
       
    reindeers,

     

       
160
       
 
       
    sec,

     

       
161
       
 
       
  )

     

       
162
       
 
       
}

     

       
163
       
 
       


     

       
164
       
-
       
pub fn get_winner_points(state: RunStatePoints) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
165
       
 
       
  state.state

     

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

     

       
167
       
 
       
    case state.points > winner {

     
···

       
196
       
 
       


     

       
197
       
 
       
  "Part 2" |> io.println

     

       
198
       
 
       
  reindeer

     

       
199
       
-
       
  |> calculate_run_state_pt2(2503)

     

       
200
       
 
       
  |> get_winner_points

     

       
201
       
 
       
  |> int.to_string

     

       
202
       
 
       
  |> io.println

     

···

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
 
       
pub type ReindeerState {

     

       
21
       
+
       
  ReindeerState(points: Int, km: Int, action: Action, time_until_change: Int)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
22
       
 
       
}

     

       
23
       
 
       


     

       
24
       
 
       
pub type LeadKm {

     

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

     
···

       
39
       
 
       
  case sec > 0 {

     

       
40
       
 
       
    False -> state

     

       
41
       
 
       
    True -> {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
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

     

       
49
       
 
       
            |> dict.get(reindeer.name)

     

       
50
       
+
       
            |> result.unwrap(ReindeerState(0, 0, Run, run))

     

       
51
       
 
       


     

       
52
       
 
       
          let km = case action {

     

       
53
       
 
       
            Run -> km + speed

     
···

       
55
       
 
       
          }

     

       
56
       
 
       
          let state =

     

       
57
       
 
       
            case time_until_change, action {

     

       
58
       
+
       
              1, Run -> ReindeerState(points, km, Rest, rest)

     

       
59
       
+
       
              1, Rest -> ReindeerState(points, km, Run, run)

     

       
60
       
+
       
              _, _ -> ReindeerState(points, km, action, time_until_change - 1)

     

       
0
       
 
       

     

       
61
       
 
       
            }

     

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

     

       
63
       
 
       


     
···

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
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

     

       
105
       
+
       
      False -> winner

     

       
106
       
+
       
    }

     

       
107
       
+
       
  })

     

       
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 {

     
···

       
142
       
 
       


     

       
143
       
 
       
  "Part 2" |> io.println

     

       
144
       
 
       
  reindeer

     

       
145
       
+
       
  |> calculate_run_state(2503)

     

       
146
       
 
       
  |> get_winner_points

     

       
147
       
 
       
  |> int.to_string

     

       
148
       
 
       
  |> io.println