Trabalhando com números primos prováveis ??BigInteger do Java

Question

Quero imprimir todos os números primos entre dois números. Este é meu código:

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 é executado com 1 10 a saída é:

2
3
5
7
11
13
17
19
23

Por que não parar em 7?

Answer 1

Porque seu programa diz tempos de execução (1-9) não param abaixo de 10. Em vez de seu loop você provavelmente quer:

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

Veja a diferença? Seu começa em 1 e pára em 9 (menos do que 10), a impressão de um número em cada iteração. As paragens acima quando o número é maior do que o limite superior.

Answer 2

Você tem que definir a executar, onde (i <10), para não parar quando o valor de um nobre é maior do que 10

Answer 3

Você está incrementando i por um de cada vez, por isso vai a correr a partir i = 1 até i = 10 (9 vezes). se você quer que ele pare set mais cedo I = intermediária.

Answer 4

Você está contando i de lowerASInt para upperAsInt. Você está contando i de 1 a 10. Os incrementos declaração i++ i com 1 (um).

Assim, o loop lê: enquanto i é inferior a 10, imprima uma i prime e incremento com 1.

Então, você vai obter os 9 primeiros resultados.

Answer 5

Isso funciona se você usar 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);

Por favor, não use paralelo () para o fluxo acima, uma vez que irá diminuir o desempenho. Como uma regra de ouro por favor não paralelizar fluxo se você tem Stream.iterate () ou Stream.limit () em seu código. Uma referência simples em meus shows vm a versão paralela é 4 vezes mais lento que o iterativo