Solution to Frog-Jmp by codility

39 Replies to “Solution to Frog-Jmp by codility”

1. return (Y – X)/D + ((Y – X) % D == 0 ? 0:1)

   Reply

   • The same idea. And infeasible in Python. Anyway, thanks for your sharing.

     Reply

2. ‘my solution in vb.net….

   1 2 3 4 5 6 7 8 9

   Private Function solution(X As Integer, Y As Integer, D As Integer) As Integer         ' write your code in VB.NET 2.0         Dim i As Integer = 0         Do             i += 1             If  (X + (D * i)) > Y Then Exit Do         Loop         solution = i End Function

   Reply

   • Thanks for sharing!
     But it seems, your solution cannot pass the test.

     Reply

3. Solution in C#

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   class Solution {     public int solution(int X, int Y, int D)     {         // write your code in C# 5.0 with .NET 4.5 (Mono)         var Distance = Y - X;         if (Distance % D == 0)         {             return Distance / D;         }         else         {             return Distance / D + 1;         }     } }

   Reply

   • Please don’t take it personally, I just try to think loud…
     This is a perfect example where codility gives 100/100 points for a code, that runs perfectly, but has readability issues. Inappropriate usage of var is pretty subjective, I know. It’s really useful in many cases, but this is a typical situation where it has a negative effect on readability.
     Although I am not sure, how could such readability aspects be automatically checked.

     Reply

     • I am not a C# expert. And I do not know the negative effect of var.
       However, I hope this community be open-minded. Any technique discussion without personal attacks is welcome!

       Reply

4. Solution in JavaScript

   1 2 3 4 5 6 7 8 9 10 11

   // you can use console.log for debugging purposes, i.e. // console.log('this is a debug message'); function solution(X, Y, D) {     // write your code in JavaScript (Node.js)     var distance = Y - X;     if ((distance % D) === 0){         return distance / D;     }else{         return (parseInt(distance / D) + 1);     } }

   Reply

5. in PHP:

   1 2 3 4 5 6 7 8 9

   function solution($X, $Y, $D) {     $distance = $Y - $X;     $remain = $distance % $D;     if ($remain == 0) {         return $distance / $D;     } else {         return ($distance - $remain) / $D + 1;     } }

   Reply

6. Thank you all for sharing!

   Reply

7. Quick solution for Pascal (100%)

   1 2 3 4 5 6

   function solution(X: longint; Y: longint; D: longint): longint; begin     if ((Y - X) mod D = 0) then solution:=round((Y - X) / D)         else          solution:= ((Y - X) div D) + 1; end;

   Reply

8. These solutions are nice, but modulo is expensive. pseudo: diff := x-y, steps := diff/d, if steps*d < diff: steps++. The multiplication is cheaper than a second division.

   Reply

   • Sure, there is some space in the original solution to improve. And your suggestion is very awesome!
     PS: as long as the solution passed the test, the readability comes first, for the blog post.

     Reply

9. Why not:

   1 2 3 4 5

   def solution(X, Y, D):     n = 0     while (X + n * D) <= Y:         n += 1     return n

   Reply

   • Because it needs more computational resource. And it is not noticeably easier to understand.

     Reply

10. Your code is missing a line for no jump.

    1 2 3 4 5 6 7

    distance = Y - X         if distance % D == 0:             return distance/D         elif distance == 0:             return 0         else:             return distance/D + 1

    Reply

    • If distance is 0, distance % D is 0, and the function will return 0 / D = 0.

      Reply

11. PHP

    1 2 3

    $a = $Y-$X;     $b = ceil($a / $D);     return (int)$b;

    Reply

    • Cool! Thanks!

      Reply

12. return (int)Math.Ceiling((Y – X) / (decimal)D);
    P.S. I just saw someone posted this solution in PHP. But still… here it is in C# 🙂

    Reply

    • No problem at all. Any solution or discussion about the algorithm is welcome!

      Reply

13. Even simpler: (Y – X + D – 1)/D

    Reply

    • Very good. It’s a well-known trick to integer-divide positive num by positive divisor and round up: (num+(divisor-1))/divisor. This trick was around the time when processors were slow and compilers were dumb…

      Reply

      • Elegant!

        Reply

        • Similar but probably more random tests resistant solution:
          return – (- (Y – X) // D )
          I was inspired by https://stackoverflow.com/a/35125872

          Reply

14. 1 2 3

    def solution(X, Y, D):     distance = Y - X     return ceil(distance/D)

    Reply

    • 1 2	def solution(X, Y, D):     return(int((Y-X)/D)+ ((Y-X) % D > 0))

      Reply

15. return (Y – X + D – 1)/D;

    Reply

16. My Java solution (100%)

    1 2 3

    public int solution(int X, int Y, int D) {     return (int) Math.ceil((double) (Y - X) / D); }

    Reply

17. I put the python solution in and got int expected class float found as output

    Reply

    • Thanks for your feedback! The solution is updated, since Codility changed from Python 2.X to Python 3.X. The concept is still working well.

      Reply

18. Java solution

    1 2 3

    int solution(int X, int Y, int D) {     return (int) Math.ceil((Y - X) / (double) D); }

    Reply

19. Python Solution:

    1 2 3 4 5 6

    def solution(X, Y, D):     count = 0     while X < Y:         X += D         count += 1     return count

    Reply

    • I came up with the same solution but unfortunately it doesn’t pass the 6s time constraint

      Reply

20. Java %100 🙂

    1 2 3 4 5

    public int solution(int X, int Y, int D) {         double temp=Math.ceil((double)(Y-X)/D);         int steps= (int) temp; return steps;     }

    Reply

21. hi. I know it’s silly question. I don’t understand the program, because I am a beginner. for a first jump, The value of distance is 75, , 75%30 !=0, So 75//31 returns 2 right(remainder is 2). how it returns 3? Actually, I am confusing myself. please answer this.

    Reply

    • I do not know your input…. But my guess is that, since 75%30 !=0, we are returning “return distance//D + 1”, that is 3.

      Reply

22. For some reason, the dist mod D method and adding one didn’t work for me, broke at higher numbers and failed, so I used VB round up function aka ceiling to get 100.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14

    Private Function solution(X As Integer, Y As Integer,   D As Integer) As Integer     ' write your code in VB.NET 4.0 (Mono)     dim intjump as integer     dim dist as integer          dist = Y - X     intjump = math.ceiling(dist/D)          solution = intjump           End Function

    Analysis summary
    The solution obtained perfect score.

    Analysis
    Detected time complexity:
    O(1)

    Reply

23. What about this

    1 2	def solution(x,y,d):   return -((y - x) // -d)

    Reply