···

       
6
       
 
       
import simplifile as file

     

       
7
       
 
       


     

       
8
       
 
       
pub type RotationState {

     

       
9
       
-
       
  RotationState(number: Int, zeroes: Int)

     

       
10
       
 
       
}

     

       
11
       
 
       


     

       
12
       
 
       
pub fn main() {

     
···

       
28
       
 
       
    input

     

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

     

       
30
       
 
       
      let new_number =

     

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

     

       
32
       
 
       
        |> result.unwrap(0)

     

       
33
       
 
       
      RotationState(new_number, case new_number {

     

       
34
       
 
       
        0 -> acc.zeroes + 1

     
···

       
42
       
 
       
  let part2 =

     

       
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 acc.number != 0 && raw_new_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
       
-
       
          // of course, there is no need to deal with a negative to positive situation because the acc number will never be negative!!!

     

       
52
       
 
       
          True -> raw_zeroes + 1

     

       
53
       
 
       
          False -> raw_zeroes

     

       
54
       
 
       
        }

     

···

       
6
       
 
       
import simplifile as file

     

       
7
       
 
       


     

       
8
       
 
       
pub type RotationState {

     

       
9
       
+
       
  RotationState(turn: Int, zeroes: Int)

     

       
10
       
 
       
}

     

       
11
       
 
       


     

       
12
       
 
       
pub fn main() {

     
···

       
28
       
 
       
    input

     

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

     

       
30
       
 
       
      let new_number =

     

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

     

       
32
       
 
       
        |> result.unwrap(0)

     

       
33
       
 
       
      RotationState(new_number, case new_number {

     

       
34
       
 
       
        0 -> acc.zeroes + 1

     
···

       
42
       
 
       
  let part2 =

     

       
43
       
 
       
    input

     

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

     

       
45
       
+
       
      let raw_new_number = acc.turn + v

     

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

     

       
47
       
 
       
      let zeroes =

     

       
48
       
 
       
        acc.zeroes

     

       
49
       
+
       
        + case acc.turn != 0 && raw_new_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
       
+
       
          // of course, there is no need to deal with a negative to positive situation because the turn will never be negative!!!

     

       
52
       
 
       
          True -> raw_zeroes + 1

     

       
53
       
 
       
          False -> raw_zeroes

     

       
54
       
 
       
        }

     

···

       
41
       
 
       
            let raw_zeroes = (raw_turn / 100).abs();

     

       
42
       
 
       
            State {

     

       
43
       
 
       
                turn,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
44
       
 
       
                zeroes: acc.zeroes + raw_zeroes + (acc.turn != 0 && raw_turn <= 0) as i32,

     

       
45
       
 
       
            }

     

       
46
       
 
       
        },

     

···

       
41
       
 
       
            let raw_zeroes = (raw_turn / 100).abs();

     

       
42
       
 
       
            State {

     

       
43
       
 
       
                turn,

     

       
44
       
+
       
                // 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.

     

       
45
       
+
       
                // of course, there is no need to deal with a negative to positive situation because the turn will never be negative!!!

     

       
46
       
 
       
                zeroes: acc.zeroes + raw_zeroes + (acc.turn != 0 && raw_turn <= 0) as i32,

     

       
47
       
 
       
            }

     

       
48
       
 
       
        },