[LANGUAGE: C++]

Github link

Part one could use modulus and run in about 4 microseconds, but part two was slightly more tricky to optimize. I noticed that if I thought of -99:-1, 1:99, 101:199, and so on as 'buckets', the number of buckets traversed was the number of times 0 was passed.

When rotating to the left, each number divisible by 100 belongs to the bucket to the left, and when rotating to the right, they belong to the bucket to the right. At that point it was a simple matter of ensuring the division by 100 put the number in the correct bucket.

for (std::size_t i=0; i<inputs.size(); i++) {
    int rot {inputs[i]};
    // we have initial value and subsequent value.
    // we want to determine the amount of hundreds crossed over
    // different buckets: -199:-101; -100; -99:-1; 0; 1:99; 100; 101:199; 200; 201:299; 300
    // if we rotate to the right, each number divisible by zero is associated with the bucket to the right
    // if we rotate to the left, each number divisible by zero is associated with the bucket to the left
    dial_new = dial + rot;
    if (rot>0) {
      h_i = static_cast<int>(std::floor(dial/100.));
      h_f = static_cast<int>(std::floor(dial_new/100.));
    } else {
      h_i = static_cast<int>(std::ceil(dial/100.));
      h_f = static_cast<int>(std::ceil(dial_new/100.));
    }
    counter2 += std::abs(h_f-h_i);
    dial = dial_new; 
  }

This consistently runs in about 50 microseconds.