Programm vereinfachen

[javarex]

Hallo,

ich bin gerade dabei auf Codewars einige Übungsaufgaben zu bearbeiten. Die letzte Aufgabe bestand darin, eine Methode zu schreiben, die zwei Grenzwerte entgegennimmt und ermittelt, welches das erste Paar an Primzahlen innerhalb des durch diese Grenzwerte bestimmten Intervalls ist, dass eine als Parameter übergebene Primzahllücke aufweist.

Zum Beispiel soll die Methode gap(2, 3, 50) das Array [3,5] ausgeben, da [3,5], das erste Primzahlpaar zwischen 3 und 50 ist, dessen Differenz zwischen der größeren und der kleineren Primzahl 2 ist.

Ich habe nun folgendes Programm entwickelt:

    public static long[] gap(int g, long m, long n) {
        long[] result = new long[2];
        long[] numbers = new long[(int) (n - m + 1)];
        long[] prims = new long[numbers.length];
        int prim = 0;
        boolean primnumber = true;
        
        
        for (int i = 0; i < numbers.length; i++, m++) {
            numbers[i] = m;
        }

        for (int i = 0; i < numbers.length; i++) {
            for (int j = 2; j <= numbers[i] / 2; j++) {
                if (numbers[i] == 2 || numbers[i] % j == 0) {
                    primnumber=false;
                }
            }
            if (primnumber) {
                prims[prim] = numbers[i];
                prim++;
            }
            primnumber=true;
        }

    for (int i = 1;i<prims.length;i++)
    {
            if (prims[i] - prims[i - 1] == g) {
                result[0] = prims[i - 1];
                result[1] = prims[i];
                return result;
            }
        }

    return null;
}

Dieses Programm funktioniert, wie ich durch Tests festgestellt habe. Allerdings kann ich es auf codewars nicht hochladen, da mir angezeigt wird, dass die Programmlaufzeit mit 16000ms zu lang ist.

Ich wäre deshalb sehr dankbar, wenn mir jemand einen Hinweis gibt, wie sich dieses Programm beschleunigen lässt.

 

[httpdigest]

import static java.util.stream.IntStream.*;
import java.util.Arrays;
import java.util.Objects;
import java.util.function.IntFunction;
public class PrimeGap {
  public static int[] gap(int gapSize, int from, int to) {
    java.util.BitSet sieve = new java.util.BitSet(to);
    return
      rangeClosed(2, to)
     .filter(i -> !sieve.get(i))
     .peek(i -> iterate(i, j -> j + i)
               .takeWhile(j -> j <= to)
               .forEach(j -> sieve.set(j)))
     .filter(i -> i >= from && i <= to)
     .mapToObj(new IntFunction<int[]>() {
       int prev = 2;
       public int[] apply(int v) {
         int p = prev;
         prev = v;
         return v - p == gapSize ? new int[] { p, v } : null;
       }
     })
     .filter(Objects::nonNull)
     .findFirst()
     .get();
  }
  public static void main(String[] args) {
    System.out.println(Arrays.toString(gap(4, 30000, 5000000)));
  }
}

 

[javarex]

Vielen Dank für deine Hilfe.
In Eclipse funktioniert das bei mir einwandfrei. Bei Codewars kommt allerdings folgende Fehlermeldung:

./src/main/java/GapInPrimes.java:8: error: cannot find symbol
java.util.BitSet sieve = new java.util.BitSet(to);
^
symbol: variable to
location: class GapInPrimes
./src/main/java/GapInPrimes.java:21: error: cannot find symbol
return v - p == gapSize ? new int[] { p, v } : null;
^
symbol: variable gapSize
./src/main/java/GapInPrimes.java:10: error: cannot find symbol
rangeClosed(2, to)
^
symbol: variable to
location: class GapInPrimes
./src/main/java/GapInPrimes.java:13: error: cannot find symbol
.takeWhile(j -> j <= to)
^
symbol: variable to
location: class GapInPrimes
./src/main/java/GapInPrimes.java:15: error: cannot find symbol
.filter(i -> i >= from && i <= to)
^
symbol: variable from
location: class GapInPrimes
./src/main/java/GapInPrimes.java:15: error: cannot find symbol
.filter(i -> i >= from && i <= to)
^
symbol: variable to
location: class GapInPrimes
6 errors

 

[mihe7]

Schreib den Code einfach um.

 

[javarex]

Schreib den Code einfach um.

Wie soll das gehen?

 

[mihe7]

Indem Du den Sieb des Erastosthenes halt nicht mit Streams und BitSets schreibst, sondern mit Schleifen und Arrays.