提高 codility 的代码性能

Question

today i heard about this website called codility where a user can give various programming test to check their code's performance.

When I started, they presented me with this sample test,

Task description 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); } 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).

The question was pretty straight forward and it took me like 2 minutes to write the solution, which is following,

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

        int p = 0;
        while (X < Y){
            p++;
            X = X + D;
        }
    return p;
    }
}

However, the test result shows that the performance of my code is just 20% and I scored just 55% ,

Here is the link to result, https://codility.com/demo/results/demo66WP2H-K25/

That was so simple code, where I have just used a single while loop, how could it possibly be make much faster?

Answer 1

Basic math:

X + nD >= Y
nD >= Y - X
n >= (Y - X) / D

The minimum value for n will be the result of rounding up the division of (Y - X) by D.

Big O analysis for this operation:

• Complexity: O(1). It's a difference, a division and a round up
• Worst-case space complexity is O(1): you can have at most 3 more variables:
  • Difference for Y - X, let's assign this into Z.
  • Division between Z by D, let's assign this into E.
  • Rounding E up, let's assign this into R (from result).

Answer 2

Java(One Line), Correctness 100%, Performance 100%, Task score 100%

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

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

Answer 3

class Solution {
  public int solution(int x, int y, int d) {
    return (y - x + d - 1) / d;
  }
}

Answer 4

class Solution {
    public int solution(int x, int y, int d) {
        // write your code in Java SE 8
        System.out.println("this is a debug message"+(y-x)%d);
        if((y-x)%d == 0)
            return ((y-x)/d);
        else
            return (((y-x)/d)+1);
    }
}

Answer 5

C# got 100 out of 100 points

using System;
// you can also use other imports, for example:
// using System.Collections.Generic;

// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");

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

        int Len= Y-X;
        if (Len%D==0)
        {
            return Len/D;
        }
        else
        {
            return (Len/D)+1;
        }
    }
}

Answer 6

Here is the 100% total score Python solution :

def solution(X, Y, D):
    # write your code in Python 3.6
    s = (Y-X)/D
    return int(-(-s // 1))

Answer 7

Here's Scala solution:

def solution(X: Int, Y: Int, D: Int): Int = {

    //divide distance (Y-X) with fixed jump distance. If there is reminder then add 1 to result to
    // cover that part with one jump

    val jumps  =   (Y-X) / D  + (if(((Y-X) % D) >0 ) 1 else 0)

    jumps

  }

Performance: https://codility.com/demo/results/trainingTQS547-ZQW/

Answer 8

Here is a solution that brings the test performance to 100%

class Solution {
    public int solution(int X, int Y, int D) {
        if (X >= Y) return 0;

        if (D == 0) return -1;

        int minJump = 0;

        if ((Y - X) % D == 0) {
            minJump = (Y - X) / D;
        } else minJump= (Y - X) / D +1;

        return minJump;
    }
}

Answer 9

JavaScript solution 100/100

function solution (x,y,d) {
    if ((y-x) % d === 0) {
        return (y-x)/d;
    } else {
        return Math.ceil((y-x)/d);
    }
}

Answer 10

Javascript solution, 100/100, and shorter than the existing answer:

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

Answer 11

Using Java perfect code

100 score code in Java

public int solution(int X, int Y, int D) {

if(X<0 && Y<0) return 0;

  if(X==Y)
          return 0;

     if((Y-X)%D==0)
         return (Y-X)/D;
     else
         return (((Y-X)/D)+1);  

}

Answer 12

this is corrected code using java giving 91% pass

int solution(int A[]) {

        int len = A.length;
        if (len == 2) {
            return Math.abs(A[1] - A[0]);
        }
        int[] sumArray = new int[A.length];
        int sum = 0;
        for (int j = 0; j < A.length; j++) {
            sum = sum + A[j];
            sumArray[j] = sum;
        }
        int min = Integer.MAX_VALUE;
        for (int j = 0; j < sumArray.length; j++) {
            int difference = Math.abs(sum - 2 * sumArray[j]);
            // System.out.println(difference);
            if (difference < min)
                min = difference;
        }
        return min;
    }

Answer 13

This is my solution with 100% (C#):

       int result = 0;
        if (y <= x || d == 0)
        {
            result = 0;
        }
        else
        {
            result = (y - x + d - 1) / d;

        }

        return result;

Answer 14

Here is my solution in PHP, 100% performance.

   function solution($X, $Y, $D) {
       return (int)ceil(($Y-$X)/$D); //ceils returns a float and so we cast (int)
   }

Answer 15

YX gives you the actual distance object has to be travel ,if that distance is directly divsible by object jump(D) then ans will be (sum/D) if some decimal value is there then we have to add 1 more into it ie(sum/D)+1

    int  sum=Y-X;
    if(X!=Y && X<Y){
    if(sum%D==0){
        return (int )(sum/D);
    }
    else{
        return ((int)(sum/D)+1);
    }}
    else{
        return 0;
    }

Answer 16

I like all the rest of the solutions, especially "(y - x + d - 1) / d". That was awesome. This is what I came up with.

public int solution(int X, int Y, int D) {
        if (X == Y || X > Y || D == 0) {
            return 0;
        }

        int total = (Y - X) / D;
        int left = (Y - X) - (D * total);

        if (left > 0) {
            total++;
        }

        return total;
    }

Answer 17

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(X, Y, D) {
  let jumps = 0

  //If 0 -> 100 with 2 step
  // Answer would be 100/2 = 50
  //If 10 -> 100 with 2 step
  //Answer would be (100 - 10) / 2 = 45
  jumps = Math.ceil((Y - X) / D)
  return jumps
}

Answer 18

swift solution 100% PASS - O(1) complexity

import Foundation
import Glibc

public func solution(_ X : Int, _ Y : Int, _ D : Int) -> Int {

if X == Y {
    return 0
}

var jumps = (Y-X)/D

if jumps * D + X < Y {
    jumps += 1
}

return jumps

}

Answer 19

import math


def solution(X, Y, D):
    if (X >= Y): return 0

    if (D == 0): return -1

    minJump = 0

    #if ((Y - X) % D == 0):
    minJump = math.ceil((Y - X) / D)
    #else: 
        #minJump = math.ceil((Y - X) / D) +1

    return minJump

Answer 20

This solution worked for me in Java 11:

public int solution(int X, int Y, int D) {
    return X == Y ? 0 : (Y - X - 1) / D + 1;
}

Correctness 100%, Performance 100%, Task score 100%

@Test
void solution() {
    assertThat(task1.solution(0, 0, 30)).isEqualTo(0);
    assertThat(task1.solution(10, 10, 10)).isEqualTo(0);
    assertThat(task1.solution(10, 10, 30)).isEqualTo(0);
    assertThat(task1.solution(10, 30, 30)).isEqualTo(1);
    assertThat(task1.solution(10, 40, 30)).isEqualTo(1);
    assertThat(task1.solution(10, 45, 30)).isEqualTo(2);
    assertThat(task1.solution(10, 70, 30)).isEqualTo(2);
    assertThat(task1.solution(10, 75, 30)).isEqualTo(3);
    assertThat(task1.solution(10, 80, 30)).isEqualTo(3);
    assertThat(task1.solution(10, 85, 30)).isEqualTo(3);
    assertThat(task1.solution(10, 100, 30)).isEqualTo(3);
    assertThat(task1.solution(10, 101, 30)).isEqualTo(4);
    assertThat(task1.solution(10, 105, 30)).isEqualTo(4);
    assertThat(task1.solution(10, 110, 30)).isEqualTo(4);
}

Answer 21

Here is the JS implementation

function frogJumbs(x, y, d) {
    if ((y - x) % d == 0) {
        return Math.floor((y - x) / d);
    }
    return Math.floor((y - x) / d + 1);
}
console.log(frogJumbs(0, 150, 30));

Answer 22

100% C# solution:

public int solution(int X, int Y, int D)
{
  var result = Math.Ceiling((double)(Y - X) / D);
  return Convert.ToInt32(result);
}

It divides the total distance by length of a jump and rounds up the result. It came after multiple attempts and some web searches.

Answer 23

Here is the solution in Python giving a score of 100 on Codility:

import math
return math.ceil((Y-X)/D)