Sherlock und Counting werden nicht von HackerRank akzeptiert

Question

Dies ist in Bezug auf das Problem Sherlock And Counting. https://www.hackerrank.com/challenges/sherlock-and-counting

Ich habe Diffchecker verwendet, um Tausende von Ergebnissen, die mein Code produziert hat, mit den Ergebnissen zu vergleichen, die ich mit meinen Hackos gekauft habe. Sie sind gleich! Mein Code ist fehlerhaft, obwohl meine Ergebnisse die gleichen sind wie bei den Hackos.

Ich habe den Diffchecker-Link entfernt, weil er zu groß ist und die Registerkarte einfriert, aber ich habe die ersten 2000 Ergebnisse getestet und meine Ergebnisse sind die gleichen wie die mit den Hackos gekauften Ergebnisse. Einfach gesagt, kann ich nicht verstehen, warum Hackerrank meinen Code nicht akzeptiert? Sie können versuchen, diesen Code einzugeben und bemerken, dass Sie tatsächlich die gleichen Ergebnisse wie die Testfälle erhalten (mit den Hackos gekauft), aber irgendwie akzeptiert es es nicht?

import java.io.*; 
import java.util.*; 
import java.math.*; 

public class Solution { 

    public static void main(String[] args) { 
     /* Enter your code here. Read input from STDIN. Print output to STDOUT. 
     Your class should be named Solution. */ 
     Scanner in = new Scanner(System.in); 
     int testcases = in.nextInt(); 
     /* Each individual test case */ 
     for(int index = 0; index < testcases; ++index) 
     { 
      long N = in.nextLong(); 
      long K = in.nextLong(); 
      /* Notice that we require i < N and i to be a positive integer. 
      This is impossible if N == 1. Therefore, a simple test solves 
      a big issue. */ 
      if(N <= 1){ 
       System.out.println(0); 
      } 
      /* Test if discriminant is negative. If it is, the number of 
      integers is N - 1 because every number fits under the graph. */ 
      else if(N*N - 4*N*K < 0) 
      { 
       System.out.println(N - 1); 
      } 
      /* Notice if the discriminant is zero, then necessarily 
      N = 4 * K. In an alternate form, the quadratic will be 
      written as i^2 - Ni + N^2/4, also recognized as (i - N/2)^2. 
      Therefore, the answer is N - 2. */ 
      else if (N*N - 4*N*K == 0) 
      { 
       System.out.println(N - 1); 
      } 
      /* Test if discriminant is positive. If it is, the number of 
      integers depends on the locus of solutions. */ 
      else if(N*N - 4*N*K > 0) 
      { 
       long solnOne = (long) (N + Math.sqrt(N*N - 4*N*K))/2; 
       long solnTwo = (long) (N - Math.sqrt(N*N - 4*N*K))/2; 
       if(solnOne > solnTwo){ 
        long temp = solnOne; 
        solnOne = solnTwo; 
        solnTwo = temp; 
       } 
       long LeftBound = (long) solnOne; 
       long RightBound = (long) solnTwo + 1; 

       /* Now there may be possibilities such that the left solution 
       is less than one and/or the right solution is greater than or equal 
       to the bound. We must account for these possibilities. */ 

       /* Here, both bounds are unacceptable. Therefore, there is no 
       solution. */ 
       if(LeftBound < 1 && RightBound >= N) 
       { 
        System.out.println(0); 
       } 
       /* Here, only the right bound is acceptable. */ 
       else if(LeftBound < 1) 
       { 
        System.out.println(N - RightBound); 
       } 
       /* Here, only the left bound is acceptable. */ 
       else if(RightBound >= N) 
       { 
        System.out.println(LeftBound); 
       } 
       /* Both bounds are allowed! */ 
       else 
       { 
        System.out.println(N - RightBound + LeftBound); 
       } 
      } 
     } 

    } 
} 

Answer 1

Versuchen Sie N=9, K=2. Ihre Antwort ist 5.
Gültige Werte sind i = [1, 2, 3, 6, 7, 8], also echte Antwort ist 6.

Zuerst ist Ihre solnOne immer >=solnTwo. Flip sie und Ihre if(solnOne > solnTwo) wird nie wahr sein.

Zweitens, die Besetzung longschneidet die Werte ab. Deshalb tun Sie solnTwo + 1, aber wenn solnTwo ist genau gleich 6, wird die + 1 das als ein gültiger Wert vermissen. Außerdem werden longvor gebt, die durch 2 dividiert werden. Hoppla!

Stattdessen nicht Guss-long:

double solnOne = (N - Math.sqrt(N*N - 4*N*K))/2; 
double solnTwo = (N + Math.sqrt(N*N - 4*N*K))/2; 
long LeftBound = (long) Math.floor(solnOne); 
long RightBound = (long) Math.ceil(solnTwo); 

Da auch HackerRank Sie können eine Zeitüberschreitung, Leistung zählt, so JIT zu helfen, berechnen N*N - 4*N*K nur einmal und speichern Sie in einer Variablen. Gleiches gilt für Math.sqrt(N*N - 4*N*K), da sqrt() relativ langsam ist.

Für Ihre eigenen Tests sollten Sie alles, beginnend von if(N <= 1){, in eine static long calc(long N, long K) Methode verschieben. Dann könnten Sie Komponententests dagegen schreiben.