···

       
5
       
 
       
import gleam/string

     

       
6
       
 
       
import simplifile as file

     

       
7
       
 
       


     

       
8
       
-
       
pub type Direction {

     

       
9
       
-
       
  Left

     

       
10
       
-
       
  Right

     

       
11
       
-
       
}

     

       
12
       
-
       


     

       
13
       
-
       
pub type InputEntry {

     

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

     

       
15
       
-
       
}

     

       
16
       
-
       


     

       
17
       
 
       
pub type RotationState {

     

       
18
       
 
       
  RotationState(number: Int, zeroes: Int)

     

       
19
       
 
       
}

     
···

       
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)

     

       
32
       
 
       
        _ -> panic as "bad input"

     

       
33
       
 
       
      }

     

       
34
       
-
       
      InputEntry(direction, turn |> int.parse |> result.unwrap(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

     

       
53
       
-
       
          + case new_number {

     

       
54
       
-
       
          0 -> 1

     

       
55
       
-
       
          _ -> 0

     

       
56
       
-
       
        },

     

       
57
       
-
       
      )

     

       
58
       
 
       
    })

     

       
59
       
-
       


     

       
60
       
 
       
  part1.zeroes

     

       
61
       
 
       
  |> int.to_string

     

       
62
       
 
       
  |> io.println

     
···

       
64
       
 
       
  let part2 =

     

       
65
       
 
       
    input

     

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

     

       
67
       
-
       
      let raw_new_number =

     

       
68
       
-
       
        acc.number

     

       
69
       
-
       
        + case v.direction {

     

       
70
       
-
       
          Right -> v.turn

     

       
71
       
-
       
          Left -> -v.turn

     

       
0
       
 
       

     

       
0
       
 
       

     

       
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)

     

       
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)

     

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

     

       
79
       
-
       
          case i % 100 {

     

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

     

       
81
       
-
       
            _ -> acc2

     

       
82
       
-
       
          }

     

       
83
       
-
       
        })

     

       
84
       
 
       
      RotationState(new_number, acc.zeroes + times_it_went_zero)

     

       
85
       
 
       
    })

     

       
86
       
 
       


     

···

       
5
       
 
       
import gleam/string

     

       
6
       
 
       
import simplifile as file

     

       
7
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       
pub type RotationState {

     

       
9
       
 
       
  RotationState(number: Int, zeroes: Int)

     

       
10
       
 
       
}

     
···

       
17
       
 
       
    |> string.trim

     

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

     

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

     

       
20
       
+
       
      case l {

     

       
21
       
+
       
        "R" <> turn -> turn |> int.parse |> result.unwrap(0)

     

       
22
       
+
       
        "L" <> turn -> 0 - { turn |> int.parse |> result.unwrap(0) }

     

       
23
       
 
       
        _ -> panic as "bad input"

     

       
24
       
 
       
      }

     

       
0
       
 
       

     

       
25
       
 
       
    })

     

       
26
       
 
       


     

       
27
       
 
       
  let part1 =

     

       
28
       
 
       
    input

     

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

     

       
30
       
 
       
      let new_number =

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       
        |> result.unwrap(0)

     

       
33
       
+
       
      RotationState(new_number, case new_number {

     

       
34
       
+
       
        0 -> acc.zeroes + 1

     

       
35
       
+
       
        _ -> acc.zeroes

     

       
36
       
+
       
      })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
37
       
 
       
    })

     

       
0
       
 
       

     

       
38
       
 
       
  part1.zeroes

     

       
39
       
 
       
  |> int.to_string

     

       
40
       
 
       
  |> io.println

     
···

       
42
       
 
       
  let part2 =

     

       
43
       
 
       
    input

     

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

     

       
45
       
+
       
      let raw_new_number = acc.number + v

     

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

     

       
47
       
+
       
      let times_it_went_zero = {

     

       
48
       
+
       
        let value = int.absolute_value(raw_new_number / 100)

     

       
49
       
+
       
        case acc.number != 0, raw_new_number > 0 {

     

       
50
       
+
       
          True, False -> value + 1

     

       
51
       
+
       
          _, _ -> value

     

       
52
       
 
       
        }

     

       
53
       
+
       
      }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
54
       
 
       
      RotationState(new_number, acc.zeroes + times_it_went_zero)

     

       
55
       
 
       
    })

     

       
56