Travailler avec BigInteger nombres premiers probables de Java

StackOverflow https://stackoverflow.com/questions/1081133

  •  22-08-2019
  •  | 
  •  

Question

Je veux imprimer tous les nombres premiers entre deux nombres. Ceci est mon code: 

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);
        }
    }
}

Quand il est exécuté avec une 10 sortie est la suivante: 

2
3
5
7
11
13
17
19
23

Pourquoi ne pas arrêter à 7?

Était-ce utile?

La solution

Parce que votre programme dit temps d'exécution (1 à 9) ne cessent de dessous 10. Au lieu de la boucle que vous voulez sans doute: 

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

Voyez la différence? Vôtre commence à 1 et arrête à 9 (moins de 10), l'impression d'un numéro à chaque itération. Les étapes ci-dessus lorsque le nombre est supérieur à la limite supérieure.

Autres conseils

Vous l'avez configuré pour fonctionner où (i <10), de ne pas arrêter lorsque la valeur d'une prime est supérieure à 10

Vous êtes i incrémenter d'une à chaque fois, il va courir à partir de i = 1 à i = 10 (9 fois). si vous voulez arrêter ensemble plus tôt i = intermédiaire.

Vous comptez i de lowerASInt à upperAsInt. Vous i compter de 1 à 10. Les incréments de i++ instruction i avec une (1).

Ainsi, votre boucle est ainsi libellé: tandis que i est inférieur à 10, imprimer un premier i et l'incrément avec 1.

Alors, vous obtiendrez les 9 premiers résultats.

Cela fonctionne si vous utilisez 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);

S'il vous plaît ne pas utiliser en parallèle () pour le flux ci-dessus, il va ralentir les performances. En règle générale s'il vous plaît ne flux paralléliser pas si vous avez Stream.iterate () ou Stream.limit () dans votre code. Une référence simple dans ma vm montre la version parallèle est 4 fois plus lent que celui itérative

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top