···

       
1
       
 
       
import gleam/int

     

       
2
       
 
       
import gleam/io

     

       
3
       
 
       
import gleam/list

     

       
0
       
 
       

     

       
4
       
 
       
import gleam/string

     

       
5
       
 
       
import simplifile as file

     

       
6
       
 
       


     
···

       
25
       
 
       
    |> string.trim

     

       
26
       
 
       
    |> string.split("\n")

     

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

     

       
28
       
-
       
      let assert Ok(direction_letter) = string.first(l)

     

       
29
       
-
       
      let direction = case direction_letter {

     

       
30
       
-
       
        "R" -> Right

     

       
31
       
-
       
        "L" -> Left

     

       
32
       
 
       
        _ -> panic as "bad input"

     

       
33
       
 
       
      }

     

       
34
       
-
       
      let assert Ok(turn) = string.drop_start(l, 1) |> int.parse

     

       
35
       
-
       
      InputEntry(direction, turn)

     

       
36
       
 
       
    })

     

       
37
       
 
       


     

       
38
       
 
       
  let part1 =

     

       
39
       
 
       
    input

     

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

     

       
41
       
 
       
      let new_number =

     

       
42
       
-
       
        {

     

       
43
       
 
       
          acc.number

     

       
44
       
-
       
          + case v.direction {

     

       
45
       
 
       
            Right -> v.turn

     

       
46
       
 
       
            Left -> -v.turn

     

       
47
       
-
       
          }

     

       
48
       
-
       
        }

     

       
49
       
-
       
        % 100

     

       
0
       
 
       

     

       
50
       
 
       
      RotationState(

     

       
51
       
 
       
        new_number,

     

       
52
       
 
       
        acc.zeroes

     
···

       
71
       
 
       
          Left -> -v.turn

     

       
72
       
 
       
        }

     

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

     

       
74
       
-
       
      let new_number = raw_new_number % 100

     

       
75
       
-
       
      // this seems to be useless here but i might be a genius who put it preventively

     

       
76
       
-
       
      let new_number = case new_number > 0 {

     

       
77
       
-
       
        True -> new_number

     

       
78
       
-
       
        False -> 100 + new_number

     

       
79
       
-
       
      }

     

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

     

       
81
       
 
       
      let times_it_went_zero =

     

       
82
       
 
       
        list.range(acc.number, raw_new_number)

     

···

       
1
       
 
       
import gleam/int

     

       
2
       
 
       
import gleam/io

     

       
3
       
 
       
import gleam/list

     

       
4
       
+
       
import gleam/result

     

       
5
       
 
       
import gleam/string

     

       
6
       
 
       
import simplifile as file

     

       
7
       
 
       


     
···

       
26
       
 
       
    |> string.trim

     

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

     

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

     

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

     

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

     

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

     

       
0
       
 
       

     

       
32
       
 
       
        _ -> panic as "bad input"

     

       
33
       
 
       
      }

     

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

     

       
0
       
 
       

     

       
35
       
 
       
    })

     

       
36
       
 
       


     

       
37
       
 
       
  let part1 =

     

       
38
       
 
       
    input

     

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

     

       
40
       
 
       
      let new_number =

     

       
41
       
+
       
        int.modulo(

     

       
42
       
 
       
          acc.number

     

       
43
       
+
       
            + case v.direction {

     

       
44
       
 
       
            Right -> v.turn

     

       
45
       
 
       
            Left -> -v.turn

     

       
46
       
+
       
          },

     

       
47
       
+
       
          100,

     

       
48
       
+
       
        )

     

       
49
       
+
       
        |> result.unwrap(0)

     

       
50
       
 
       
      RotationState(

     

       
51
       
 
       
        new_number,

     

       
52
       
 
       
        acc.zeroes

     
···

       
71
       
 
       
          Left -> -v.turn

     

       
72
       
 
       
        }

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
76
       
 
       
      let times_it_went_zero =

     

       
77
       
 
       
        list.range(acc.number, raw_new_number)