Codility Frog Jump - Count minimal number of jumps from position X to Y Here is a question I tried from the Codility train website:


  A small frog wants to get to the other side of the road. The frog is
  currently located at position X and wants to get to a position greater
  than or equal to Y. The small frog always jumps a fixed distance, D.
  Count the minimal number of jumps that the small frog must perform to
  reach its target.
  
  Write a function:

class Solution { public int solution(int X, int Y, int D); }

  
  that, given three integers X, Y and D, returns the minimal number of
  jumps from position X to a position equal to or greater than Y.
  
  For example, given:
  
  X = 10   Y = 85   D = 30
  
  the function should return 3, because the frog will be positioned as
  follows: after the first jump, at position 10 + 30 = 40 after the
  second jump, at position 10 + 30 + 30 = 70 after the third jump, at
  position 10 + 30 + 30 + 30 = 100

Assume that:
X, Y and D are integers within the range [1..1,000,000,000];
X ≤ Y.
Complexity:
expected worst-case time complexity is O(1);
expected worst-case space complexity is O(1).



This is the solution I gave which fetched me 50% and time complexity of O(Y-X). Can anyone please suggest a better solution?

class Solution {
//X=start, Y=end, D=distance for code clarity
public int solution(int start, int end, int distance) {

// write your code in Java SE 7
int progress = start;
int count=0;
while(progress&lt;end) {
progress=progress+distance;
count++;
}
return count;
}
}
You don't need a loop for this, there is a mathematical solution:


If y - x is divisible by d, then it takes (y - x) / d jumps
If y - x is not divisible by d, then it takes (y - x) / d + 1 jumps


In other words:

if ((y - x) % d == 0) {
    return (y - x) / d;
}
return (y - x) / d + 1;


Or the somewhat less readable but more compact:

return (y - x) / d + ((y - x) % d == 0 ? 0 : 1);