Combien de nombres premiers existent?

Question

Quelque chose ne va pas avec mon code que je ne peux pas comprendre, pouvez-vous m'aider à trouver mon erreur? Je vous remercie!

/// Calculate Prime 
private static int countPrimes(int number){ 
    int count =0; 
    for(int i=1; i<=MAX_PRIME; i++) { 
     if(isPrime(i)){ 
     count++; 
     } 
    } 
    System.out.println("Exactly "+ count + " prime numbers exist between "+number + " and 1000."); 
return number; 
} 

Voici mon résultat: Exactement 180 nombres premiers existent entre 1 et 1000. Ce qui est faux et doit être 168 !!!

Answer 1

Quelle est la fonction isPrice()? est-ce une fonction de vérifier qu'un nombre entier est le nombre premier ou pas? Je pense que si vous l'avez, vous devez juste faire comme ceci:

for(int i=1; i<=MAX_PRIME; i++) { 
    if(isPrime(i)){ 
     count++ 
    } 
} 
return count; 

Answer 2

Il semble que votre paramètre implicite, nombre int, est jamais utilisé dans votre programme. Essayez ce code:

private static int countPrimes(int number){ 
    int count =0; 
    int countPrimes=0; 
    if(number<2) 
     return 0; 
    for(int i=2; i<=number; i++) { //start i=2, because you know that 1 is not a prime number. 
     for(int j=1; j<=i; j++){ 
      if(i%j==0) 
       count++;     
     } 
     if(count ==2) 
      countPrimes++;    
     count=0; 
    } 
    return number; 
} 

Ensuite, dans votre méthode de coureur, appelez:

int numOfPrimes = countPrimes(10000); 

En cela, vous pouvez modifier ce numéro que vous voulez compter jusqu'à. Dans cet exemple, il compte les nombres premiers jusqu'à 10000.

int numOfPrimes = countPrimes(100); 

Cela comptera les nombres premiers jusqu'à 100. Si vous voulez garder une trace des nombres premiers, dans votre programme, vous pouvez ajouter:

ArrayList<Integer> listOfPrimes = new ArrayList<Integer>(); 
private static int countPrimes(int number){ 
    int count =0; 
    int countPrimes=0; 
    if(number<2) 
     return 0; 
    for(int i=2; i<=number; i++) { //start i=2, because you know that 1 is not a prime number. 
     for(int j=1; j<=i; j++){ 
      if(i%j==0) 
       count++;     
     } 
     if(count ==2){ 
      countPrimes++; 
      listOfPrimes.add(i); 
     }   
     count=0; 
    } 
    return number; 
} 

pour récupérer vos chiffres que vous pourriez faire quelque chose comme ceci:

System.out.println("Exactly "+ countPrimes(number) + " prime numbers exist between "+ "1" + " and " + number + "."); 
System.out.println("These numbers are: "); 
for(int i =0; i<listOfPrimes.size();i++){ 
    System.out.println(listOfPrimes.get(i)); 
} 

Answer 3

Je pense que vous retournez une variable mal au lieu de count, et si countPrimes signifie à calco le nombre de p Rimes entre nunber et MaxPrime, alors vous devriez compter de number, comme ceci:

for (int i = number; i<=MAX_PRIME;i++) 

Answer 4

Le nombre premier peut être trouvé à l'aide « d'Eratosthène Sieve ». http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

Le programme suivant comptera le numéro. des nombres premiers étant donné la limite.

Je prends la limite = 1000.

public class CountPrime { 

public static void main(String[] args) { 

boolean[] isPrime  = null; 
int  Tprimes  = 0; 
final int UPPER_BOUND = Integer.parseInt("1000"); 

/*------------------------------------------------------+ 
| Assuming all to prime         | 
+------------------------------------------------------*/ 
isPrime = new boolean[UPPER_BOUND + 1]; 
for (int Tindex = 2; Tindex <= UPPER_BOUND; Tindex++) { 
    isPrime[Tindex] = true; 
} /*end for*/ 

/*------------------------------------------------------+ 
| Mark Non-Primes given the Upper Bound     | 
+------------------------------------------------------*/ 
for (int Tindex = 2; Tindex*Tindex <= UPPER_BOUND; Tindex++) { 
    /*------------------------------------------------------+ 
    | For any prime all the multiples are non-prime   | 
    +------------------------------------------------------*/ 
    if (isPrime[Tindex]) { 
    for (int Tver = Tindex; Tindex*Tver <= UPPER_BOUND; Tver++) { 
     isPrime[Tindex*Tver] = false; 
    } /*end for*/ 
    } /*end if*/ 
} /*end for*/ 

/*------------------------------------------------------+ 
| Now, as we are done count the total primes   | 
+------------------------------------------------------*/ 
for (int Tindex = 2; Tindex <= UPPER_BOUND; Tindex++) { 
    if (isPrime[Tindex]) { 
    Tprimes++; 
    } /*end if*/ 
} /*end for*/ 
System.out.println("Total No. of Primes[" + Tprimes + 
        "], given the limit[" + UPPER_BOUND + "]"); 
} /*END OF main*/ 

} /*END OF CountPrime*/ 

Sortie: Nombre total PRIMES [168], compte tenu de la limite [1000]