Lavorare con BigInteger numeri primi probabili di Java

Question

Voglio stampare tutti i numeri primi tra due numeri. Questo è il mio codice:

package sphere;

import java.math.BigInteger;
import java.io.*;

class PrimeTest2 {
    public static void main(String args[]) throws java.lang.Exception {
        BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
        String s = r.readLine();
        String [] splitted = s.split(" ");
        BigInteger lower = new BigInteger(splitted[0]);
        BigInteger upper = new BigInteger(splitted[1]);
        int lowerAsInt = Integer.parseInt(splitted[0]);
        int upperAsInt = Integer.parseInt(splitted[1]);
        BigInteger intermediate = lower;

        for (int i=lowerAsInt; i<upperAsInt; i++) {    
            intermediate = intermediate.nextProbablePrime();
            System.out.println(intermediate);
        }
    }
}

Quando è eseguito con 1 10 l'uscita è:

2
3
5
7
11
13
17
19
23

Perché non si ferma alle 7?

Answer 1

Perché il vostro programma dice tempi di esecuzione (da 1 a 9) non si fermano al di sotto 10. Invece di loop, probabilmente si vuole:

BigIntegerupper = BigInteger.valueOf(upperAsInt);
while (intermediate.compareTo(upper) <= 0) {
  System.out.println(intermediate);
  intermediate = intermediate.nextProbablePrime();
}

Vedi la differenza? Sii dalle ore 1 e si arresta a 9 (meno di 10), la stampa di un numero su ogni iterazione. Le fermate sopra quando il numero è maggiore del limite superiore.

Answer 2

L'avete impostato per funzionare in cui (i <10), di non fermarsi quando il valore di un numero primo è superiore a 10

Answer 3

Si sono incrementando i di uno ogni volta, in modo da sta andando a correre da i = 1 fino a i = 10 (9 volte). se si vuole che si fermi insieme in precedenza i = intermedio.

Answer 4

Si contano i da lowerASInt a upperAsInt. Ti ho contano da 1 a 10. Gli incrementi dichiarazione i++ i con 1 (uno).

Quindi, il ciclo si legge: mentre i è inferiore a 10, stampare un i primo e l'incremento con 1.

Quindi, si ottengono i primi 9 risultati.

Answer 5

Questo funziona se si utilizza JDK8

 BigInteger lower=BigInteger.valueOf(1);
        BigInteger high=BigInteger.valueOf(100);
        Stream.iterate(lower, BigInteger::nextProbablePrime).limit(high.longValueExact())
                .filter(p -> p.compareTo(high) <= 0).forEach(System.out::println);

Si prega di non utilizzare in parallelo () per il flusso di cui sopra, in quanto rallenta le prestazioni. Come regola generale si prega di non parallelizzare flusso se avete Stream.iterate () o Stream.limit () nel codice. Un semplice punto di riferimento nella mia vm mostra la versione parallela è 4 volte più lento rispetto a quello iterativo