···

       
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
       
 
       
      }

     

       
25
       
 
       
    })

     
···

       
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

     

       
0
       
 
       

     

       
52
       
 
       
        }

     

       
53
       
-
       
      }

     

       
54
       
-
       
      RotationState(new_number, acc.zeroes + times_it_went_zero)

     

       
55
       
 
       
    })

     

       
56
       
-
       


     

       
57
       
 
       
  part2.zeroes

     

       
58
       
 
       
  |> int.to_string

     

       
59
       
 
       
  |> io.println

     

···

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

     

       
20
       
 
       
      case l {

     

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

     

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

     

       
23
       
 
       
        _ -> panic as "bad input"

     

       
24
       
 
       
      }

     

       
25
       
 
       
    })

     
···

       
43
       
 
       
    input

     

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

     

       
45
       
 
       
      let raw_new_number = acc.number + v

     

       
46
       
+
       
      let raw_zeroes = int.absolute_value(raw_new_number / 100)

     

       
47
       
+
       
      let zeroes =

     

       
48
       
+
       
        acc.zeroes

     

       
49
       
+
       
        + case raw_new_number <= 0 && acc.number != 0 {

     

       
50
       
+
       
          // if it is below zero before being moduloed and the original number itself wasn't zero it means that it did touch zero but the division thing wouldn't count it, so we give this extra support

     

       
51
       
+
       
          True -> raw_zeroes + 1

     

       
52
       
+
       
          False -> raw_zeroes

     

       
53
       
 
       
        }

     

       
54
       
+
       
      RotationState(int.modulo(raw_new_number, 100) |> result.unwrap(0), zeroes)

     

       
0
       
 
       

     

       
55
       
 
       
    })

     

       
0
       
 
       

     

       
56
       
 
       
  part2.zeroes

     

       
57
       
 
       
  |> int.to_string

     

       
58
       
 
       
  |> io.println