Quel est le meilleur algorithme pour vérifier si un nombre est premier?
Juste un exemple de ce que je recherche: je pourrais représenter chaque nombre impair avec un peu, par exemple. pour la plage de nombres donnée (1, 10], commence à 3:
1110
Le dictionnaire suivant peut être compressé plus vrai? Je pourrais en déduire des multiples de cinq avec un peu de travail, mais les nombres qui se terminent par 1, 3, 7 ou 9 doivent figurer dans la matrice de bits. J'espère que cela clarifiera ce que je veux.
Je cherche le meilleur algorithme pour vérifier si un nombre est premier, c'est-à-dire une fonction booléenne:
bool isprime(number);
J'aimerais connaître le meilleur algorithme pour implémenter cette fonctionnalité. Naturellement, il y aurait une structure de données que je pourrais interroger. I définit le meilleur algorithme , pour être l'algorithme qui produit une structure de données avec la plus faible consommation de mémoire pour la plage (1, N], où N est une constante.
Il existe de nombreuses façons de faire le test primality .
Il n'y a pas vraiment de structure de données à interroger. Si vous avez beaucoup de nombres à tester, vous devriez probablement exécuter un test probabiliste car ils sont plus rapides, puis faire un test déterministe pour vous assurer que le nombre est premier.
Vous devez savoir que le calcul derrière les algorithmes les plus rapides n’est pas pour les âmes sensibles.
L'algorithme le plus rapide pour les tests principaux généraux est AKS . L'article de Wikipédia le décrit longuement et propose des liens vers le document d'origine.
Si vous voulez trouver de gros nombres, cherchez des nombres premiers ayant des formes spéciales telles que nombres premiers de Mersenne .
L'algorithme que j'implémente habituellement (facile à comprendre et à coder) est le suivant (en Python):
def isprime(n):
"""Returns True if n is prime."""
if n == 2:
return True
if n == 3:
return True
if n % 2 == 0:
return False
if n % 3 == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
return True
C'est une variante de l'algorithme O(sqrt(N)) classique. Il utilise le fait qu'un nombre premier (sauf 2 et 3) est de la forme 6k - 1 ou 6k + 1 et ne regarde que les diviseurs de cette forme.
Parfois, si je veux vraiment la vitesse et la plage est limitée, j'implémente un test de pseudo-prime basé sur le petit théorème de Fermat . Si je veux vraiment plus de vitesse (c'est-à-dire éviter O(sqrt(N)) algorithme au total), je calcule à l'avance les faux positifs (voir Carmichael numbers) et effectue une recherche binaire. C’est de loin le test le plus rapide que j’ai jamais mis en oeuvre, le seul inconvénient étant que la plage est limitée.
La meilleure méthode, à mon avis, consiste à utiliser ce qui a été fait auparavant.
Il existe des listes des premiers nombres N sur Internet avec N allant au moins cinquante millions . Téléchargez les fichiers et utilisez-les, il sera probablement beaucoup plus rapide que toute autre méthode que vous utiliserez.
Si vous voulez un algorithme réel pour créer vos propres nombres premiers, Wikipedia a toutes sortes de bonnes choses sur les nombres premiers ici , y compris des liens vers les différentes méthodes pour le faire, et des tests de prime ici , tous deux basés sur les probabilités. et méthodes déterministes rapides.
Il devrait y avoir un effort concerté pour trouver les premiers milliards (voire plus) de premiers nombres et les faire publier sur le net quelque part pour que les gens puissent cesser de faire le même travail encore et encore et ... :-)
bool isPrime(int n)
{
// Corner cases
if (n <= 1) return false;
if (n <= 3) return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n%2 == 0 || n%3 == 0) return false;
for (int i=5; i*i<=n; i=i+6)
if (n%i == 0 || n%(i+2) == 0)
return false;
return true;
}
this is just c++ implementation of above AKS algorithm
Selon wikipedia, le tamis d'Eratosthenes a une complexité O(n * (log n) * (log log n)) et nécessite O(n) mémoire - c'est donc un très bon point de départ si vous ne testez pas des nombres particulièrement grands.
En Python 3:
def is_prime(a):
if a < 2:
return False
Elif a!=2 and a % 2 == 0:
return False
else:
return all (a % i for i in range(3, int(a**0.5)+1))
Explication: Un nombre premier est un nombre uniquement divisible par lui-même et 1. Ex: 2,3,5,7 ...
1) si un <2: si "a" est inférieur à 2, il n'est pas un nombre premier.
2) Elif a! = 2 et a% 2 == 0: si "a" est divisible par 2, alors ce n'est définitivement pas un nombre premier. Mais si a = 2, nous ne voulons pas évaluer cela car il s'agit d'un nombre premier. D'où la condition a! = 2
3) renvoie tout (un% i pour i dans la plage (3, int (a 0.5) +1)): ** Regardez d'abord ce que fait la commande all () en python. À partir de 3, nous divisons "a" jusqu'à sa racine carrée (a ** 0.5). Si "a" est divisible, le résultat sera False. Pourquoi la racine carrée? Disons a = 16. La racine carrée de 16 = 4. Nous n'avons pas besoin d'évaluer jusqu'à 15. Nous avons seulement besoin de vérifier jusqu'à 4 pour dire que ce n'est pas un nombre premier.
Extra: Une boucle permettant de trouver tous les nombres premiers dans une plage.
for i in range(1,100):
if is_prime(i):
print("{} is a prime number".format(i))
On peut utiliser sympy .
import sympy
sympy.ntheory.primetest.isprime(33393939393929292929292911111111)
True
De la sympy docs. La première étape consiste à rechercher des facteurs triviaux qui, s’ils sont détectés, permettent un retour rapide. Ensuite, si le tamis est assez grand, utilisez la recherche de bissection sur le tamis. Pour les petits nombres, une série de tests déterministes Miller-Rabin sont effectués avec des bases dont on sait qu'elles n'ont aucun contre-exemple dans leur plage. Enfin, si le nombre est supérieur à 2 ^ 64, un test BPSW puissant est effectué. Bien que ce soit un test de base probable et que nous croyons qu'il existe des contre-exemples, il n'y a pas de contre-exemples connus
Bien trop tard pour la fête, mais espérons que cela aide. Ceci est pertinent si vous recherchez de gros nombres premiers:
Pour tester de grands nombres impairs, vous devez utiliser le test Fermat et/ou le test Miller-Rabin.
Ces tests utilisent une exponentiation modulaire, ce qui est assez coûteux. Pour l'exponentiation n bits, vous avez besoin d'au moins n multiplication big int et de n division big int. Ce qui signifie que la complexité de l'exponentiation modulaire est O (n³).
Donc, avant d’utiliser les gros canons, vous devez faire pas mal de divisions d’essai. Mais ne le faites pas naïvement, il existe un moyen de les faire rapidement ..__ D'abord, multipliez autant de nombres premiers que de correspondances dans les mots que vous utilisez pour les grands entiers. Si vous utilisez des mots de 32 bits, multipliez 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 29 = 3234846615 et calculez le plus grand diviseur commun avec le nombre que vous testez à l'aide de l'algorithme Euclidien. Après la première étape, le nombre est réduit en dessous de la taille de Word et continue l'algorithme sans effectuer de divisions complètes de grand entier. Si GCD! = 1, cela signifie qu'un des nombres premiers multiplié ensemble divise le nombre, ce qui donne une preuve qu'il n'est pas premier. Continuez ensuite avec 31 * 37 * 41 * 43 * 47 = 95041567, etc.
Une fois que vous avez testé plusieurs centaines (ou milliers) de nombres premiers de cette façon, vous pouvez effectuer 40 tours de test de Miller-Rabin pour confirmer que le nombre est bon, après 40 tours, vous pouvez être certain que le nombre est premier, il y a seulement 2 ^ -80 chances que ce soit non (il est plus probable que votre matériel fonctionne mal ...).
J'ai comparé l'efficacité des suggestions les plus populaires pour déterminer si un nombre est premier. J'ai utilisé python 3.6 sur ubuntu 17.10; J'ai testé avec des nombres allant jusqu'à 100 000 (vous pouvez tester des nombres plus grands en utilisant mon code ci-dessous).
Ce premier graphique compare les fonctions (qui sont expliquées plus bas dans ma réponse) et montre que les dernières fonctions ne croissent pas aussi vite que le premier lors de l’augmentation des nombres.
Et dans le deuxième graphique, nous voyons que, dans le cas des nombres premiers, le temps augmente régulièrement, mais que les nombres non premiers ne croissent pas aussi vite (car la plupart d'entre eux peuvent être éliminés rapidement).
Voici les fonctions que j'ai utilisées:
cette réponse et cette réponse a suggéré une construction utilisant
all():def is_prime_1(n): return n > 1 and all(n % i for i in range(2, int(math.sqrt(n)) + 1))Cette réponse a utilisé une sorte de boucle while:
def is_prime_2(n): if n <= 1: return False if n == 2: return True if n == 3: return True if n % 2 == 0: return False if n % 3 == 0: return False i = 5 w = 2 while i * i <= n: if n % i == 0: return False i += w w = 6 - w return TrueCette réponse incluait une version avec une boucle
for:def is_prime_3(n): if n <= 1: return False if n % 2 == 0 and n > 2: return False for i in range(3, int(math.sqrt(n)) + 1, 2): if n % i == 0: return False return TrueEt j'ai mélangé quelques idées des autres réponses dans une nouvelle:
def is_prime_4(n): if n <= 1: # negative numbers, 0 or 1 return False if n <= 3: # 2 and 3 return True if n % 2 == 0 or n % 3 == 0: return False for i in range(5, int(math.sqrt(n)) + 1, 2): if n % i == 0: return False return True
Voici mon script pour comparer les variantes:
import math
import pandas as pd
import seaborn as sns
import time
from matplotlib import pyplot as plt
def is_prime_1(n):
...
def is_prime_2(n):
...
def is_prime_3(n):
...
def is_prime_4(n):
...
default_func_list = (is_prime_1, is_prime_2, is_prime_3, is_prime_4)
def assert_equal_results(func_list=default_func_list, n):
for i in range(-2, n):
r_list = [f(i) for f in func_list]
if not all(r == r_list[0] for r in r_list):
print(i, r_list)
raise ValueError
print('all functions return the same results for integers up to {}'.format(n))
def compare_functions(func_list=default_func_list, n):
result_list = []
n_measurements = 3
for f in func_list:
for i in range(1, n + 1):
ret_list = []
t_sum = 0
for _ in range(n_measurements):
t_start = time.perf_counter()
is_prime = f(i)
t_end = time.perf_counter()
ret_list.append(is_prime)
t_sum += (t_end - t_start)
is_prime = ret_list[0]
assert all(ret == is_prime for ret in ret_list)
result_list.append((f.__name__, i, is_prime, t_sum / n_measurements))
df = pd.DataFrame(
data=result_list,
columns=['f', 'number', 'is_prime', 't_seconds'])
df['t_micro_seconds'] = df['t_seconds'].map(lambda x: round(x * 10**6, 2))
print('df.shape:', df.shape)
print()
print('', '-' * 41)
print('| {:11s} | {:11s} | {:11s} |'.format(
'is_prime', 'count', 'percent'))
df_sub1 = df[df['f'] == 'is_prime_1']
print('| {:11s} | {:11,d} | {:9.1f} % |'.format(
'all', df_sub1.shape[0], 100))
for (is_prime, count) in df_sub1['is_prime'].value_counts().iteritems():
print('| {:11s} | {:11,d} | {:9.1f} % |'.format(
str(is_prime), count, count * 100 / df_sub1.shape[0]))
print('', '-' * 41)
print()
print('', '-' * 69)
print('| {:11s} | {:11s} | {:11s} | {:11s} | {:11s} |'.format(
'f', 'is_prime', 't min (us)', 't mean (us)', 't max (us)'))
for f, df_sub1 in df.groupby(['f', ]):
col = df_sub1['t_micro_seconds']
print('|{0}|{0}|{0}|{0}|{0}|'.format('-' * 13))
print('| {:11s} | {:11s} | {:11.2f} | {:11.2f} | {:11.2f} |'.format(
f, 'all', col.min(), col.mean(), col.max()))
for is_prime, df_sub2 in df_sub1.groupby(['is_prime', ]):
col = df_sub2['t_micro_seconds']
print('| {:11s} | {:11s} | {:11.2f} | {:11.2f} | {:11.2f} |'.format(
f, str(is_prime), col.min(), col.mean(), col.max()))
print('', '-' * 69)
return df
Exécution de la fonction compare_functions(n=10**5) (nombres jusqu’à 100.000) j’obtiens cette sortie:
df.shape: (400000, 5)
-----------------------------------------
| is_prime | count | percent |
| all | 100,000 | 100.0 % |
| False | 90,408 | 90.4 % |
| True | 9,592 | 9.6 % |
-----------------------------------------
---------------------------------------------------------------------
| f | is_prime | t min (us) | t mean (us) | t max (us) |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_1 | all | 0.57 | 2.50 | 154.35 |
| is_prime_1 | False | 0.57 | 1.52 | 154.35 |
| is_prime_1 | True | 0.89 | 11.66 | 55.54 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_2 | all | 0.24 | 1.14 | 304.82 |
| is_prime_2 | False | 0.24 | 0.56 | 304.82 |
| is_prime_2 | True | 0.25 | 6.67 | 48.49 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_3 | all | 0.20 | 0.95 | 50.99 |
| is_prime_3 | False | 0.20 | 0.60 | 40.62 |
| is_prime_3 | True | 0.58 | 4.22 | 50.99 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_4 | all | 0.20 | 0.89 | 20.09 |
| is_prime_4 | False | 0.21 | 0.53 | 14.63 |
| is_prime_4 | True | 0.20 | 4.27 | 20.09 |
---------------------------------------------------------------------
Ensuite, en exécutant la fonction compare_functions(n=10**6) (numéros jusqu’à 1.000.000), j’obtiens cette sortie:
df.shape: (4000000, 5)
-----------------------------------------
| is_prime | count | percent |
| all | 1,000,000 | 100.0 % |
| False | 921,502 | 92.2 % |
| True | 78,498 | 7.8 % |
-----------------------------------------
---------------------------------------------------------------------
| f | is_prime | t min (us) | t mean (us) | t max (us) |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_1 | all | 0.51 | 5.39 | 1414.87 |
| is_prime_1 | False | 0.51 | 2.19 | 413.42 |
| is_prime_1 | True | 0.87 | 42.98 | 1414.87 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_2 | all | 0.24 | 2.65 | 612.69 |
| is_prime_2 | False | 0.24 | 0.89 | 322.81 |
| is_prime_2 | True | 0.24 | 23.27 | 612.69 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_3 | all | 0.20 | 1.93 | 67.40 |
| is_prime_3 | False | 0.20 | 0.82 | 61.39 |
| is_prime_3 | True | 0.59 | 14.97 | 67.40 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_4 | all | 0.18 | 1.88 | 332.13 |
| is_prime_4 | False | 0.20 | 0.74 | 311.94 |
| is_prime_4 | True | 0.18 | 15.23 | 332.13 |
---------------------------------------------------------------------
J'ai utilisé le script suivant pour tracer les résultats:
def plot_1(func_list=default_func_list, n):
df_orig = compare_functions(func_list=func_list, n=n)
df_filtered = df_orig[df_orig['t_micro_seconds'] <= 20]
sns.lmplot(
data=df_filtered, x='number', y='t_micro_seconds',
col='f',
# row='is_prime',
markers='.',
ci=None)
plt.ticklabel_format(style='sci', axis='x', scilimits=(3, 3))
plt.show()
meilleur algorithme pour le nombre de primes javascript
function isPrime(num) {
if (num <= 1) return false;
else if (num <= 3) return true;
else if (num % 2 == 0 || num % 3 == 0) return false;
var i = 5;
while (i * i <= num) {
if (num % i == 0 || num % (i + 2) == 0) return false;
i += 6;
}
return true
}
En Python:
def is_prime(n):
return not any(n % p == 0 for p in range(2, int(math.sqrt(n)) + 1))
Une conversion plus directe du formalisme mathématique en Python utiliserait tout (n% p! = 0 ...) , mais cela nécessite une évaluation stricte de toutes les valeurs de p. La version pas n'importe laquelle peut se terminer plus tôt si une valeur True est trouvée.
Pour les grands nombres, vous ne pouvez pas simplement vérifier naïvement si le nombre candidat N n'est divisible par aucun des nombres inférieurs à sqrt (N). Des tests beaucoup plus évolutifs sont disponibles, tels que le test de primalité Miller-Rabin . Ci-dessous vous avez une implémentation en python:
def is_prime(x):
"""Fast implementation fo Miller-Rabin primality test, guaranteed to be correct."""
import math
def get_sd(x):
"""Returns (s: int, d: int) for which x = d*2^s """
if not x: return 0, 0
s = 0
while 1:
if x % 2 == 0:
x /= 2
s += 1
else:
return s, x
if x <= 2:
return x == 2
# x - 1 = d*2^s
s, d = get_sd(x - 1)
if not s:
return False # divisible by 2!
log2x = int(math.log(x) / math.log(2)) + 1
# As long as Riemann hypothesis holds true, it is impossible
# that all the numbers below this threshold are strong liars.
# Hence the number is guaranteed to be a prime if no contradiction is found.
threshold = min(x, 2*log2x*log2x+1)
for a in range(2, threshold):
# From Fermat's little theorem if x is a prime then a^(x-1) % x == 1
# Hence the below must hold true if x is indeed a prime:
if pow(a, d, x) != 1:
for r in range(0, s):
if -pow(a, d*2**r, x) % x == 1:
break
else:
# Contradicts Fermat's little theorem, hence not a prime.
return False
# No contradiction found, hence x must be a prime.
return True
Vous pouvez l'utiliser pour trouver d'énormes nombres premiers:
x = 10000000000000000000000000000000000000000000000000000000000000000000000000000
for e in range(1000):
if is_prime(x + e):
print('%d is a prime!' % (x + e))
break
# 10000000000000000000000000000000000000000000000000000000000000000000000000133 is a prime!
Si vous testez des entiers aléatoires, vous voudrez probablement d'abord vérifier si le nombre de candidats est divisible par l'un des nombres premiers inférieurs à 1000, par exemple, avant d'appeler Miller-Rabin. Cela vous aidera à filtrer les non-nombres évidents tels que 10444344345.
Python 3:
def is_prime(a):
return a > 1 and all(a % i for i in range(2, int(a**0.5) + 1))
J'ai une fonction principale qui fonctionne jusqu'au (2 ^ 61) -1 Ici:
from math import sqrt
def isprime(num): num > 1 and return all(num % x for x in range(2, int(sqrt(num)+1)))
Explication:
La fonction all() peut être redéfinie comme suit:
def all(variables):
for element in variables:
if not element: return False
return True
La fonction all() passe simplement par une série de nombres bools/nombres et renvoie False si elle voit 0 ou False.
La fonction sqrt() est juste en train de faire le racine carrée d'un nombre.
Par exemple:
>>> from math import sqrt
>>> sqrt(9)
>>> 3
>>> sqrt(100)
>>> 10
La partie num % x renvoie le reste de num/x.
Enfin, range(2, int(sqrt(num))) signifie qu'il créera une liste qui commence à 2 et se termine à int(sqrt(num)+1)
Pour plus d'informations sur la gamme, consultez ce site web !
La partie num > 1 vérifie simplement si la variable num est supérieure à 1, car 1 et 0 ne sont pas considérés comme des nombres premiers.
J'espère que cela a aidé :)
Un nombre premier est un nombre qui n'est divisible que par 1 et lui-même. Tous les autres nombres sont appelés composite.
Le moyen le plus simple de rechercher un nombre premier consiste à vérifier si le nombre saisi est un nombre composé:
function isPrime(number) {
// Check if a number is composite
for (let i = 2; i < number; i++) {
if (number % i === 0) {
return false;
}
}
// Return true for prime numbers
return true;
}
Le programme doit diviser la valeur de number par tous les nombres entiers de 1 à la valeur. Si ce nombre peut être divisé de manière égale, non seulement par un et lui-même, il s'agit d'un nombre composé.
La valeur initiale de la variable i doit être 2, car les nombres premiers et les nombres composés peuvent être divisés également par 1.
for (let i = 2; i < number; i++)
Alors, i est inférieur à number pour la même raison. Les nombres premiers et les nombres composés peuvent être divisés de manière égale par eux-mêmes. Par conséquent, il n'y a aucune raison de le vérifier.
Ensuite, nous vérifions si la variable peut être divisée de manière égale à l’aide de l’opérateur restant.
if (number % i === 0) {
return false;
}
Si le reste est égal à zéro, cela signifie que number peut être divisé de manière égale. Il s'agit donc d'un nombre composé et renvoie la valeur false.
Si le nombre entré ne remplit pas la condition, cela signifie qu'il s'agit d'un nombre premier et que la fonction renvoie vrai.
Avec l'aide des flux Java-8 et des lambdas, il peut être implémenté de la manière suivante:
public static boolean isPrime(int candidate){
int candidateRoot = (int) Math.sqrt( (double) candidate);
return IntStream.range(2,candidateRoot)
.boxed().noneMatch(x -> candidate % x == 0);
}
Les performances doivent être proches de O(sqrt(N)) . Peut-être que quelqu'un trouve cela utile.
Idée similaire à l'algorithme AKS qui a été mentionné
public static boolean isPrime(int n) {
if(n == 2 || n == 3) return true;
if((n & 1 ) == 0 || n % 3 == 0) return false;
int limit = (int)Math.sqrt(n) + 1;
for(int i = 5, w = 2; i <= limit; i += w, w = 6 - w) {
if(n % i == 0) return false;
numChecks++;
}
return true;
}
Voici ma réponse à la question:
def isprime(num):
return num <= 3 or (num + 1) % 6 == 0 or (num - 1) % 6 == 0
La fonction retournera True si l’une des propriétés ci-dessous est True. Ces propriétés définissent mathématiquement ce qu'est un nombre premier.
- Le nombre est inférieur ou égal à 3
- Le nombre + 1 est divisible par 6
- Le nombre - 1 est divisible par 6
Vous pouvez essayer quelque chose comme ça.
def main():
try:
user_in = int(input("Enter a number to determine whether the number is prime or not: "))
except ValueError:
print()
print("You must enter a number!")
print()
return
list_range = list(range(2,user_in+1))
divisor_list = []
for number in list_range:
if user_in%number==0:
divisor_list.append(number)
if len(divisor_list) < 2:
print(user_in, "is a prime number!")
return
else:
print(user_in, "is not a prime number!")
return
main()
La plupart des réponses précédentes sont correctes, mais voici une autre méthode pour vérifier qu'un nombre est un nombre premier. Pour rappel, nombres premiers sont des nombres entiers supérieurs à 1 dont les seuls facteurs sont 1 et lui-même. ( source )
Solution:
En règle générale, vous pouvez créer une boucle et commencer à tester votre numéro pour voir s'il est divisible par 1,2,3 ... jusqu'au nombre que vous testez ... etc. mais pour réduire le temps de vérification, vous pouvez diviser votre nombre par la moitié de la valeur de votre nombre car un nombre ne peut pas être exactement divisible par un nombre supérieur à la moitié de sa valeur ..__ Exemple: si vous voulez voir 100 est un nombre premier que vous pouvez parcourir jusqu'à 50.
Code actuel:
def find_prime(number):
if(number ==1):
return False
# we are dividiing and rounding and then adding the remainder to increment !
# to cover not fully divisible value to go up forexample 23 becomes 11
stop=number//2+number%2
#loop through up to the half of the values
for item in range(2,stop):
if number%item==0:
return False
print(number)
return True
if(find_prime(3)):
print("it's a prime number !!")
else:
print("it's not a prime")
Déterminer si le nombre ou les nombres d’une plage sont/sont premiers.
#!usr/bin/python3
def prime_check(*args):
for arg in args:
if arg > 1: # prime numbers are greater than 1
for i in range(2,arg): # check for factors
if(arg % i) == 0:
print(arg,"is not Prime")
print(i,"times",arg//i,"is",arg)
break
else:
print(arg,"is Prime")
# if input number is less than
# or equal to 1, it is not prime
else:
print(arg,"is not Prime")
return
# Calling Now
prime_check(*list(range(101))) # This will check all the numbers in range 0 to 100
prime_check(#anynumber) # Put any number while calling it will check.
import math
import time
def check_prime(n):
if n == 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
from_i = 3
to_i = math.sqrt(n) + 1
for i in range(from_i, int(to_i), 2):
if n % i == 0:
return False
return True
myInp=int(input("Enter a number: "))
if myInp==1:
print("The number {} is neither a prime not composite no".format(myInp))
Elif myInp>1:
for i in range(2,myInp//2+1):
if myInp%i==0:
print("The Number {} is not a prime no".format(myInp))
print("Because",i,"times",myInp//i,"is",myInp)
break
else:
print("The Number {} is a prime no".format(myInp))
else:
print("Alas the no {} is a not a prime no".format(myInp))
Nous pouvons utiliser les flux Java pour implémenter cela en O (sqrt (n)); Considérez que noneMatch est une méthode shortCircuiting qui arrête l'opération lorsqu'elle le juge inutile pour déterminer le résultat:
Scanner in = new Scanner(System.in);
int n = in.nextInt();
System.out.println(n == 2 ? "Prime" : IntStream.rangeClosed(2, ((int)(Math.sqrt(n)) + 1)).noneMatch(a -> n % a == 0) ? "Prime" : "Not Prime");