blocks|key|142309|text|基本数学：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142310|X+%2B+nD+>=+Y
nD+>=+Y+-+X
n+>=+(Y+-+X)+/+D|code-block|syntax|javascript|142311|N的最小值将是(Y+-+X)除以D的四舍五入的结果。|142312|此操作的大O分析：|142313|142314|复杂度:+O(1)。这是一个差，一个除法和一个四舍五入，最坏情况下的空间复杂度是O(1)：你最多只能有3个变量：，Y-+X的差值，让我们把这个赋给Z。，|unordered-list-item|142315|，Z除以D，我们把这个赋给E。|142316|向上舍入E，让我们把这个赋给R(从result).|142317|到R|142318|​|142319|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|N|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|N|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Basic math:

<pre><code>X + nD &gt;= Y
nD &gt;= Y - X
n &gt;= (Y - X) / D
</code></pre>

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:

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

blocks|key|143623|text|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"%2B(y-x)%25d);
++++++++if((y-x)%25d+==+0)
++++++++++++return+((y-x)/d);
++++++++else
++++++++++++return+(((y-x)/d)%2B1);
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|143624|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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);
 }
}
</code></pre>

blocks|key|2927644|text|JavaScript解决方案100/100|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2927645|function+solution+(x,y,d)+{
++++if+((y-x)+%25+d+===+0)+{
++++++++return+(y-x)/d;
++++}+else+{
++++++++return+Math.ceil((y-x)/d);
++++}
}|code-block|syntax|javascript|2927646|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

JavaScript solution 100/100

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

blocks|key|142325|text|以下是Scala的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142326|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++%2B+(if(((Y-X)+%25+D)+>0+)+1+else+0)

++++jumps

++}|code-block|syntax|javascript|142327|性能：https://codility.com/demo/results/trainingTQS547-ZQW/|offset|length|142328|entityMap|0|LINK|mutability|MUTABLE|url|https://codility.com/demo/results/trainingTQS547-ZQW/^0|0|0|3|1H|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Here's Scala solution:

<pre><code>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) &gt;0 ) 1 else 0)

 jumps

 }
</code></pre>

Performance: <a href="https://codility.com/demo/results/trainingTQS547-ZQW/" rel="nofollow">https://codility.com/demo/results/trainingTQS547-ZQW/</a>

blocks|key|2714905|text|C#满分100分，得了100分|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2714906|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%25D==0)
++++++++{
++++++++++++return+Len/D;
++++++++}
++++++++else
++++++++{
++++++++++++return+(Len/D)%2B1;
++++++++}
++++}
}|code-block|syntax|javascript|2714907|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

C# got 100 out of 100 points

<pre><code>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;
 }
 }
}
</code></pre>

blocks|key|140034|text|class+Solution+{
++public+int+solution(int+x,+int+y,+int+d)+{
++++return+(y+-+x+%2B+d+-+1)+/+d;
++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|140035|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|2927683|text|Java(一行)，正确率100%25，性能100%25，任务分数100%25|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2927684|//+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);
++++}
}|code-block|syntax|javascript|2927685|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

<pre><code>// 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);
 }
}
</code></pre>

blocks|key|140040|text|Javascript解决方案，100/100，比现有答案更短：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|140041|function+solution(Y,+Y,+D)+{
+return+Math.ceil((Y+-+X)+/+D);
}|code-block|syntax|javascript|140042|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

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

blocks|key|2714956|text|这是使用java更正的代码，通过率为91%25。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2714957|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%2B%2B)+{
++++++++++++sum+=+sum+%2B+A[j];
++++++++++++sumArray[j]+=+sum;
++++++++}
++++++++int+min+=+Integer.MAX_VALUE;
++++++++for+(int+j+=+0;+j+<+sumArray.length;+j%2B%2B)+{
++++++++++++int+difference+=+Math.abs(sum+-+2+*+sumArray[j]);
++++++++++++//+System.out.println(difference);
++++++++++++if+(difference+<+min)
++++++++++++++++min+=+difference;
++++++++}
++++++++return+min;
++++}|code-block|syntax|javascript|2714958|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

this is corrected code using java giving 91% pass

<pre><code>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 &lt; A.length; j++) {
 sum = sum + A[j];
 sumArray[j] = sum;
 }
 int min = Integer.MAX_VALUE;
 for (int j = 0; j &lt; sumArray.length; j++) {
 int difference = Math.abs(sum - 2 * sumArray[j]);
 // System.out.println(difference);
 if (difference &lt; min)
 min = difference;
 }
 return min;
 }
</code></pre>

blocks|key|2927734|text|这是我的100%25+(C#)的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2927735|+++++++int+result+=+0;
++++++++if+(y+<=+x+%7C%7C+d+==+0)
++++++++{
++++++++++++result+=+0;
++++++++}
++++++++else
++++++++{
++++++++++++result+=+(y+-+x+%2B+d+-+1)+/+d;

++++++++}

++++++++return+result;|code-block|syntax|javascript|2927736|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

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

 }

 return result;
</code></pre>

blocks|key|141312|text|这是我的PHP解决方案，100%25的性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|141313|+++function+solution($X,+$Y,+$D)+{
+++++++return+(int)ceil(($Y-$X)/$D);+//ceils+returns+a+float+and+so+we+cast+(int)
+++}|code-block|syntax|javascript|141314|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my solution in PHP, 100% performance. 

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

blocks|key|142382|text|Y-X给出了物体必须移动的实际距离，如果这个距离可以通过物体跳跃(D)直接预测，那么ans将是(sum/D)如果有一些十进制值，那么我们必须再加1，即(sum/D)%2B1|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142383|++++int++sum=Y-X;
++++if(X!=Y+&&+X<Y){
++++if(sum%25D==0){
++++++++return+(int+)(sum/D);
++++}
++++else{
++++++++return+((int)(sum/D)%2B1);
++++}}
++++else{
++++++++return+0;
++++}|code-block|syntax|javascript|142384|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Y-X 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 i.e(sum/D)+1

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

blocks|key|142404|text|我喜欢所有其他的解决方案，特别是"(y+-x%2Bd-+1)+/+d“。真是太棒了。这就是我想出来的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142405|public+int+solution(int+X,+int+Y,+int+D)+{
++++++++if+(X+==+Y+%7C%7C+X+>+Y+%7C%7C+D+==+0)+{
++++++++++++return+0;
++++++++}

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

++++++++if+(left+>+0)+{
++++++++++++total%2B%2B;
++++++++}

++++++++return+total;
++++}|code-block|syntax|javascript|142406|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

<pre><code>public int solution(int X, int Y, int D) {
 if (X == Y || X &gt; Y || D == 0) {
 return 0;
 }

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

 if (left &gt; 0) {
 total++;
 }

 return total;
 }
</code></pre>

blocks|key|2715038|text|这是一个将测试性能提高到100%25的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2715039|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)+%25+D+==+0)+{
++++++++++++minJump+=+(Y+-+X)+/+D;
++++++++}+else+minJump=+(Y+-+X)+/+D+%2B1;

++++++++return+minJump;
++++}
}|code-block|syntax|javascript|2715040|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

<pre><code>class Solution {
 public int solution(int X, int Y, int D) {
 if (X &gt;= 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;
 }
}
</code></pre>

blocks|key|142408|text|//+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
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|142409|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// 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 -&gt; 100 with 2 step
 // Answer would be 100/2 = 50
 //If 10 -&gt; 100 with 2 step
 //Answer would be (100 - 10) / 2 = 45
 jumps = Math.ceil((Y - X) / D)
 return jumps
}
</code></pre>

blocks|key|142424|text|swift解决方案100%25+PASS+-+O(1)复杂度|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142425|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+%2B+X+<+Y+{
++++jumps+%2B=+1
}

return+jumps

}|code-block|syntax|javascript|142426|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

swift solution 100% PASS - O(1) complexity

<pre><code>import Foundation
import Glibc

public func solution(_ X : Int, _ Y : Int, _ D : Int) -&gt; Int {

if X == Y {
 return 0
}

var jumps = (Y-X)/D

if jumps * D + X &lt; Y {
 jumps += 1
}

return jumps

}
</code></pre>

blocks|key|140181|text|以下是Python100%25总分的解决方案|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|140182|def+solution(X,+Y,+D):
++++#+write+your+code+in+Python+3.6
++++s+=+(Y-X)/D
++++return+int(-(-s+//+1))|code-block|syntax|javascript|140183|entityMap^0|G|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Here is the 100% total score Python solution:
<pre><code>def solution(X, Y, D):
 # write your code in Python 3.6
 s = (Y-X)/D
 return int(-(-s // 1))
</code></pre>

blocks|key|2715081|text|import+math


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

++++if+(D+==+0):+return+-1

++++minJump+=+0

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

++++return+minJump|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2715082|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import math


def solution(X, Y, D):
 if (X &gt;= 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
</code></pre>

blocks|key|142434|text|这个解决方案适用于我在Java+11中的工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142435|public+int+solution(int+X,+int+Y,+int+D)+{
++++return+X+==+Y+?+0+:+(Y+-+X+-+1)+/+D+%2B+1;
}|code-block|syntax|javascript|142436|准确率100%25，性能100%25，任务分数100%25|142437|@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);
}|142438|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This solution worked for me in Java 11:
<pre><code>public int solution(int X, int Y, int D) {
 return X == Y ? 0 : (Y - X - 1) / D + 1;
}
</code></pre>
Correctness 100%, Performance 100%, Task score 100%
<pre><code>@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);
}
</code></pre>

blocks|key|142440|text|下面是JS实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142441|function+frogJumbs(x,+y,+d)+{
++++if+((y+-+x)+%25+d+==+0)+{
++++++++return+Math.floor((y+-+x)+/+d);
++++}
++++return+Math.floor((y+-+x)+/+d+%2B+1);
}
console.log(frogJumbs(0,+150,+30));|code-block|syntax|javascript|142442|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the JS implementation
<pre><code>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));
</code></pre>

blocks|key|2927876|text|100%25+C#解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2927877|public+int+solution(int+X,+int+Y,+int+D)
{
++var+result+=+Math.Ceiling((double)(Y+-+X)+/+D);
++return+Convert.ToInt32(result);
}|code-block|syntax|javascript|2927878|它将总距离除以跳跃的长度，对结果进行四舍五入()。它是在多次尝试和一些网络搜索之后出现的。|offset|length|style|BOLD|2927879|entityMap^0|0|0|D|A|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

100% C# solution:
<pre><code>public int solution(int X, int Y, int D)
{
 var result = Math.Ceiling((double)(Y - X) / D);
 return Convert.ToInt32(result);
}
</code></pre>
It divides the total distance by length of a jump and rounds up the result. It came after multiple attempts and some web searches.

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,

<blockquote>
 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: 
 <code>class Solution { public int solution(int X, int Y, int D); }</code> 
 that, given three integers <code>X</code>, <code>Y</code> and <code>D</code>, returns the minimal number of jumps from position <code>X</code> to a position equal to or greater than <code>Y</code>. 
 
 For example,
 given: 
 <code>X = 10</code> 
 <code>Y = 85</code> 
 <code>D = 30</code> the function should return <code>3</code>,
 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).
</blockquote>

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

<pre><code>class Solution {
 public int solution(int X, int Y, int D) {

 int p = 0;
 while (X &lt; Y){
 p++;
 X = X + D;
 }
 return p;
 }
}
</code></pre>

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

<img src="https://i.stack.imgur.com/joYef.png" alt="enter image description here">

Here is the link to result, <a href="https://codility.com/demo/results/demo66WP2H-K25/" rel="noreferrer">https://codility.com/demo/results/demo66WP2H-K25/</a>

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

increasing code performance of codility

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

今天我听说了一个叫做codility的网站，用户可以在这个网站上进行各种编程测试来检查他们代码的性能。当我开始的时候，他们给了我这个样本测试，任务描述一只小青蛙想要到路的另一边。青蛙当前位于位置X，并且希望到达大于或等于Y的位置。小青蛙总是跳跃固定的距离，D。计算小青蛙为了到达目标而必须执行的最小跳跃次数。编写一个函数...

问提高代码性的代码性能
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问提高代码性的代码性能EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问提高代码性的代码性能
EN