Déterminer si un nombre est premier
J'ai parcouru beaucoup de code sur ce sujet, mais la plupart produisent des nombres premiers jusqu'au nombre entré. Cependant, j'ai besoin d'un code qui vérifie uniquement si le numéro d'entrée indiqué est premier.
Voici ce que j'ai pu écrire, mais ça ne marche pas:
void primenumber(int number)
{
if(number%2!=0)
cout<<"Number is prime:"<<endl;
else
cout<<"number is NOt prime"<<endl;
}
Je vous serais reconnaissant si quelqu'un pouvait me donner des conseils sur la façon de faire fonctionner cela correctement.
Mettre à jour
Je l'ai modifié pour vérifier tous les numéros d'une boucle for.
void primenumber(int number)
{
for(int i=1; i<number; i++)
{
if(number%i!=0)
cout<<"Number is prime:"<<endl;
else
cout<<"number is NOt prime"<<endl;
}
}
Vous devez faire un peu plus de vérification. À l'heure actuelle, vous ne faites que vérifier si le nombre est divisible par 2. Faites de même pour 2, 3, 4, 5, 6, ... jusqu'à number. Astuce: utilisez une boucle loop .
Après avoir résolu ce problème, essayez de rechercher des optimisations ..___ Astuce: il vous suffit de vérifier tous les nombres jusqu'à la racine carrée du nombre.
bool isPrime(int number){
if(number < 2) return false;
if(number == 2) return true;
if(number % 2 == 0) return false;
for(int i=3; (i*i)<=number; i+=2){
if(number % i == 0 ) return false;
}
return true;
}
Ma propre fonction IsPrime (), écrite et basée sur la variante déterministe du célèbre algorithme de Rabin-Miller, combinée à un forçage brute par paliers optimisé, vous offrant l'une des fonctions de test principales les plus rapides du marché.
__int64 power(int a, int n, int mod)
{
__int64 power=a,result=1;
while(n)
{
if(n&1)
result=(result*power)%mod;
power=(power*power)%mod;
n>>=1;
}
return result;
}
bool witness(int a, int n)
{
int t,u,i;
__int64 prev,curr;
u=n/2;
t=1;
while(!(u&1))
{
u/=2;
++t;
}
prev=power(a,u,n);
for(i=1;i<=t;++i)
{
curr=(prev*prev)%n;
if((curr==1)&&(prev!=1)&&(prev!=n-1))
return true;
prev=curr;
}
if(curr!=1)
return true;
return false;
}
inline bool IsPrime( int number )
{
if ( ( (!(number & 1)) && number != 2 ) || (number < 2) || (number % 3 == 0 && number != 3) )
return (false);
if(number<1373653)
{
for( int k = 1; 36*k*k-12*k < number;++k)
if ( (number % (6*k+1) == 0) || (number % (6*k-1) == 0) )
return (false);
return true;
}
if(number < 9080191)
{
if(witness(31,number)) return false;
if(witness(73,number)) return false;
return true;
}
if(witness(2,number)) return false;
if(witness(7,number)) return false;
if(witness(61,number)) return false;
return true;
/*WARNING: Algorithm deterministic only for numbers < 4,759,123,141 (unsigned int's max is 4294967296)
if n < 1,373,653, it is enough to test a = 2 and 3.
if n < 9,080,191, it is enough to test a = 31 and 73.
if n < 4,759,123,141, it is enough to test a = 2, 7, and 61.
if n < 2,152,302,898,747, it is enough to test a = 2, 3, 5, 7, and 11.
if n < 3,474,749,660,383, it is enough to test a = 2, 3, 5, 7, 11, and 13.
if n < 341,550,071,728,321, it is enough to test a = 2, 3, 5, 7, 11, 13, and 17.*/
}
Pour l'utiliser, copiez et collez le code dans la partie supérieure de votre programme. Appelez-le et il retourne une valeur BOOL, true ou false.
if(IsPrime(number))
{
cout << "It's prime";
}
else
{
cout<<"It's composite";
}
Si vous rencontrez un problème lors de la compilation avec "__int64", remplacez-le par "long". Il compile bien sous VS2008 et VS2010.
Comment cela fonctionne: Il y a trois parties à la fonction. Une partie vérifie s'il s'agit de l'une des rares exceptions (nombres négatifs, 1) et intercepte l'exécution du programme.
La deuxième partie commence si le nombre est inférieur à 1373653, qui est théoriquement le numéro où l'algorithme de Rabin Miller battra ma fonction de force brute optimisée. Vient ensuite deux niveaux de Rabin Miller, conçus pour minimiser le nombre de témoins nécessaires. Comme la plupart des nombres que vous allez tester sont inférieurs à 4 milliards, l'algorithme probabiliste de Rabin-Miller peut être rendu déterministe en vérifiant les témoins 2, 7 et 61. Si vous devez dépasser le plafond de 4 milliards, vous aurez besoin d'une grande bibliothèque numérique et appliquez une modification de module ou de décalage de bits à la fonction power ().
Si vous insistez sur une méthode de force brute, voici juste ma fonction optimisée IsPrime () de force brute:
inline bool IsPrime( int number )
{
if ( ( (!(number & 1)) && number != 2 ) || (number < 2) || (number % 3 == 0 && number != 3) )
return (false);
for( int k = 1; 36*k*k-12*k < number;++k)
if ( (number % (6*k+1) == 0) || (number % (6*k-1) == 0) )
return (false);
return true;
}
}
Mode de fonctionnement de cette pièce de force brute: Tous les nombres premiers (sauf 2 et 3) peuvent être exprimés sous la forme 6k + 1 ou 6k-1, où k est un nombre entier positif. Ce code utilise ce fait et teste tous les nombres sous la forme de 6k + 1 ou 6k-1 de moins que la racine carrée du nombre en question. Cette pièce est intégrée à la fonction IsPrime () la plus grande (la fonction indiquée en premier).
Si vous avez besoin de trouver tous les nombres premiers inférieurs à un nombre, recherchez tous les nombres premiers inférieurs à 1000, examinez le tamis d'Eratosthène. Un autre de mes favoris.
En guise de remarque supplémentaire, j'aimerais beaucoup que quiconque mette en œuvre l'algorithme Eliptical Curve Method, désireux de voir que celui-ci soit implémenté en C++ depuis un certain temps maintenant, j'ai perdu mon implémentation. Théoriquement, c'est même plus rapide que l'algorithme déterministe de Rabin Miller que j'ai mis en place, bien que je ne sois pas sûr que ce soit le cas pour les nombres inférieurs à 4 milliards.
Je suppose que prendre sqrt et lancer foreach de 2 à sqrt + 1 si (input% number! = 0) renvoie false; Une fois que vous avez atteint sqrt + 1, vous pouvez être sûr que son nombre premier.
bool check_prime(int num) {
for (int i = num - 1; i > 1; i--) {
if ((num % i) == 0)
return false;
}
return true;
}
vérifie si un nombre est un nombre premier
C++
bool isPrime(int number){
if (number != 2){
if (number < 2 || number % 2 == 0) {
return false;
}
for(int i=3; (i*i)<=number; i+=2){
if(number % i == 0 ){
return false;
}
}
}
return true;
}
Javascript
function isPrime(number)
{
if (number !== 2) {
if (number < 2 || number % 2 === 0) {
return false;
}
for (var i=3; (i*i)<=number; i+=2)
{
if (number % 2 === 0){
return false;
}
}
}
return true;
}
Python
def isPrime(number):
if (number != 2):
if (number < 2 or number % 2 == 0):
return False
i = 3
while (i*i) <= number:
if(number % i == 0 ):
return False;
i += 2
return True;
Si vous connaissez la plage des entrées (ce que vous faites depuis que votre fonction prend une int), vous pouvez précalculer une table de nombres premiers inférieure ou égale à la racine carrée de l'entrée max (2 ^ 31-1 dans ce cas), puis testez la divisibilité par chaque nombre premier de la table inférieure ou égale à la racine carrée du nombre donné.
Je suis le même algorithme mais une implémentation différente qui boucle en boucle avec sqrt (n) à l’étape 2 uniquement des nombres impairs, car je vérifie que si elle est divisible par 2 ou 2 * k, elle est fausse. Voici mon code
public class PrimeTest {
public static boolean isPrime(int i) {
if (i < 2) {
return false;
} else if (i % 2 == 0 && i != 2) {
return false;
} else {
for (int j = 3; j <= Math.sqrt(i); j = j + 2) {
if (i % j == 0) {
return false;
}
}
return true;
}
}
/**
* @param args
*/
public static void main(String[] args) {
for (int i = 1; i < 100; i++) {
if (isPrime(i)) {
System.out.println(i);
}
}
}
}
Si vous êtes paresseux et que vous avez beaucoup de RAM, créez un tamis d’Ératosthène , qui est pratiquement un tableau géant à partir duquel vous avez lancé tous les nombres qui ne sont pas au premier plan. À partir de ce moment-là, chaque test de probabilité sera très rapide ..__ La limite supérieure de cette solution pour des résultats rapides est la quantité de RAM dont vous disposez. La limite supérieure de cette solution pour des résultats très rapides est la capacité de votre disque dur.
Utilisez les mathématiques d’abord pour trouver la racine carrée du nombre, puis pour commencer la boucle jusqu’à ce que le nombre se termine après l’enracinement carré . pas un nombre premier sinon premier . Voici le code
bool is_Prime(int n)
{
int square_root = sqrt(n); // use math.h
int toggle = 1;
for(int i = 2; i <= square_root; i++)
{
if(n%i==0)
{
toggle = 0;
break;
}
}
if(toggle)
return true;
else
return false;
}
Ce code vérifie uniquement si le nombre est divisible par deux. Pour qu'un nombre soit premier, il ne doit pas être divisible par tous les entiers inférieurs à lui-même. Cela peut être implémenté naïvement en vérifiant s'il est divisible par tous les entiers inférieurs à floor(sqrt(n)) dans une boucle. Si vous êtes intéressé, il existe un certain nombre de algorithmes beaucoup plus rapides existants.
Quelqu'un d'en haut avait le suivant.
bool check_prime(int num) {
for (int i = num - 1; i > 1; i--) {
if ((num % i) == 0)
return false;
}
return true;
}
Cela a surtout fonctionné. Je viens de le tester dans Visual Studio 2017. Il dirait que tout élément inférieur à 2 est également premier (donc 1, 0, -1, etc.)
Voici une légère modification pour corriger cela.
bool check_prime(int number)
{
if (number > 1)
{
for (int i = number - 1; i > 1; i--)
{
if ((number % i) == 0)
return false;
}
return true;
}
return false;
}
C’est un moyen rapide et efficace:
bool isPrimeNumber(int n) {
int divider = 2;
while (n % divider != 0) {
divider++;
}
if (n == divider) {
return true;
}
else {
return false;
}
}
Il commencera par trouver un nombre divisible de n, commençant par 2. Dès qu'il en trouvera un, si ce nombre est égal à n, alors c'est premier , sinon ce n'est pas le cas.
J'ai utilisé cette idée pour déterminer si le numéro est premier ou non:
#include <conio.h>
#include <iostream>
using namespace std;
int main() {
int x, a;
cout << "Enter The No. :";
cin >> x;
int prime(unsigned int);
a = prime(x);
if (a == 1)
cout << "It Is A Prime No." << endl;
else
if (a == 0)
cout << "It Is Composite No." << endl;
getch();
}
int prime(unsigned int x) {
if (x == 1) {
cout << "It Is Neither Prime Nor Composite";
return 2;
}
if (x == 2 || x == 3 || x == 5 || x == 7)
return 1;
if (x % 2 != 0 && x % 3 != 0 && x % 5 != 0 && x % 7 != 0)
return 1;
else
return 0;
}
Si n est 2, c'est premier.
Si n est 1, ce n'est pas premier.
Si n est pair, ce n'est pas premier.
Si n est impair, supérieur à 2, nous devons vérifier tous les nombres impairs 3..sqrt (n) +1, si l’un de ces nombres peut diviser n, n n’est pas premier, sinon n est premier.
Pour de meilleures performances, je recommande un tamis d'eratosthenes.
Voici l'exemple de code:
bool is_prime(int n) { if (n == 2) return true; if (n == 1 || n % 2 == 0) return false; for (int i = 3; i*i < n+1; i += 2) { if (n % i == 0) return false; } return true; }
Je suis venu avec ceci:
int counter = 0;
bool checkPrime(int x) {
for (int y = x; y > 0; y--){
if (x%y == 0) {
counter++;
}
}
if (counter == 2) {
counter = 0; //resets counter for next input
return true; //if its only divisible by two numbers (itself and one) its a prime
}
else counter = 0;
return false;
}
//simple function to determine if a number is a prime number
//to state if it is a prime number
#include <iostream>
using namespace std;
int isPrime(int x); //functioned defined after int main()
int main()
{
int y;
cout<<"enter value"<<endl;
cin>>y;
isPrime(y);
return 0;
} //end of main function
//-------------function
int isPrime(int x)
{
int counter =0;
cout<<"factors of "<<x<<" are "<<"\n\n"; //print factors of the number
for (int i =0; i<=x; i++)
{
for (int j =0; j<=x; j++)
{
if (i * j == x) //check if the number has multiples;
{
cout<<i<<" , "; //output provided for the reader to see the
// muliples
++counter; //counts the number of factors
}
}
}
cout<<"\n\n";
if(counter>2)
{
cout<<"value is not a prime number"<<"\n\n";
}
if(counter<=2)
{
cout<<"value is a prime number"<<endl;
}
}
Il existe plusieurs approches différentes à ce problème.
La méthode "Naive": Essayez tous les nombres (impairs) jusqu’à la (racine) du nombre.
Méthode améliorée "naïve": N'essayez que tous les 6n ± 1.
Tests probabilistes: Miller-Rabin, Solovay-Strasse, etc.
L'approche qui vous convient dépend de ce que vous faites avec le prime.
Vous devriez au moins lire sur Test de primalité .
// PrimeDef.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include<iostream>
#include<stdlib.h>
using namespace std;
const char PRIME = 176;
const char NO_PRIME = 178;
const int LAST_VALUE = 2000;
bool isPrimeNumber( int value )
{
if( !( value / 2 ) ) return false;
for( int i = 1; ++i <= value / 2; )
if( 0 == value % i ) return false;
return true;
}
int main( int argc, char *argv[ ] )
{
char mark;
for( int i = -1, count = 1; ++i < LAST_VALUE; count++ )
{
mark = NO_PRIME;
if( isPrimeNumber( i ) ) mark = PRIME;
cout << mark;
if(i > 0 && !( count % 50 ) ) cout << endl;
}
return 0;
}
