提高代码性能

Question

今天我听说这个名为codility的网站，用户可以通过各种编程测试来检查代码的性能。

当我开始时，他们向我展示了这个样本测试，

  

任务描述一只小青蛙想要到达另一边   路。青蛙目前位于X位置，想要到达   一个大于或等于Y的位置。小青蛙总是跳起来   固定距离，D。计算小的跳跃次数   青蛙必须达到目标。

     

写一个函数：   class Solution { public int solution(int X, int Y, int D); }   如果给定三个整数X，Y和D，则返回从位置X到等于或大于Y的位置的最小跳跃次数。

     

例如，   给定：
  X = 10
  Y = 85
  D = 30函数应返回3，   因为青蛙的定位如下：

     第一次跳后，   位置10 + 30 = 40

     

第二次跳跃后，位置10 + 30 + 30 = 70

     

在第三次跳跃后，位置10 + 30 + 30 + 30 = 100

     

假设：X，Y和D是

范围内的整数      

[1..1,000,000,000]; X≤Y。复杂性：预期的最坏情况时间

     

复杂性是O（1）;预期的最坏情况空间复杂度为O（1）。

这个问题非常简单，我花了2分钟时间编写了解决方案，紧随其后，

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

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

但是，测试结果显示我的代码的效果仅为20%而我的评分仅为55%，

以下是结果的链接https://codility.com/demo/results/demo66WP2H-K25/

这是如此简单的代码，我刚刚使用了一个while循环，它怎么可能更快？

Answer 1

基础数学：

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

n的最小值是将（Y - X）除以D的结果。

此操作的大O分析：

• 复杂性：O（1）。这是一个区别，一个分工和一个整理
• 最坏情况下的空间复杂度为O（1）：最多可以有3个变量：
  • Y - X的差异，让我们将其分配给Z。
  • 在Z之间划分D，让我们将其分配给E。
  • 向上舍入E，让我们将其分配到R（从结果中）。

Answer 2

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 3

List

Answer 4

Java（一行），正确性100％，性能100％，任务分数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 5

这是Scala解决方案：

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

  }

效果：https://codility.com/demo/results/trainingTQS547-ZQW/

Answer 6

C＃得到100分中的100分

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 7

这是总分100％的Python解决方案：

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

Answer 8

这是一种使测试性能达到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

这里是JS实现

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 10

这个解决方案在 Java 11 中对我有用：

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

正确率 100%，性能 100%，任务得分 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 11

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 12

快速解决方案100％通过-O（1）复杂度

$user = $this->input->post('username', TRUE);

$this->session->set_userdata('username', $username);

Answer 13

// 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 14

我喜欢所有其他解决方案，特别是“（y-x + d-1）/ d”。这太棒了。这就是我想出的。

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 15

YX给出了对象必须移动的实际距离，如果该距离可以直接由对象jump（D）整除，则ans将是（sum / D），如果有某个十进制值，则必须再加1即（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

这是我的PHP解决方案，性能100％。

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

Answer 17

这是我使用100％（C＃）的解决方案：

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

        }

        return result;

Answer 18

这是使用91％通过率的Java纠正的代码

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 19

Javascript解决方案，100/100，比现有答案更短：

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

Answer 20

JavaScript解决方案100/100

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