Naturellement, car bool isprime(number)il y aurait une structure de données que je pourrais interroger.
Je définis le meilleur algorithme , celui 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.
Juste un exemple de ce que je recherche: je pourrais représenter chaque nombre impair avec un bit, par exemple pour la plage de nombres donnée (1, 10], commence à 3:1110

Le dictionnaire suivant peut être pressé davantage, non? Je pourrais éliminer les multiples de cinq avec un peu de travail, mais les nombres qui se terminent par 1, 3, 7 ou 9 doivent être là dans le tableau de bits.

Comment résoudre le problème?

Il existe de nombreuses façons de faire le test de primalité .

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 le suivre avec 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 en détail et propose des liens vers l'article original.

Si vous voulez trouver de grands nombres, regardez dans les nombres premiers qui ont des formes spéciales comme les 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' O(sqrt(N))algorithme classique . Il utilise le fait qu'un nombre premier (sauf 2 et 3) est de forme 6k - 1ou 6k + 1et ne regarde que les diviseurs de cette forme.

Parfois, si je veux vraiment de la vitesse et que la portée est limitée , j'implémente un test pseudo-premier basé sur le petit théorème de Fermat . Si je veux vraiment plus de vitesse (c'est-à-dire éviter complètement l'algorithme O (sqrt (N))), je pré-calcule les faux positifs (voir les nombres de Carmichael ) et fais une recherche binaire. C'est de loin le test le plus rapide que j'ai jamais mis en œuvre, le seul inconvénient est que la portée est limitée.

La meilleure méthode, à mon avis, est d'utiliser ce qui s'est passé avant.

Il existe des listes des premiers Nnombres premiers sur Internet avec Nau moins cinquante millions . Téléchargez les fichiers et utilisez-les, cela sera probablement beaucoup plus rapide que toute autre méthode que vous proposerez.

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 primaires ici , à la fois des méthodes basées sur les probabilités et des méthodes déterministes rapides.

Il devrait y avoir un effort concerté pour trouver le premier milliard (ou même plus) de nombres premiers et les publier sur le net quelque part afin que les gens puissent arrêter de faire ce 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;
}

ceci est juste une implémentation c ++ de l' algorithme AKS ci-dessus

J'ai comparé l'efficacité des suggestions les plus populaires pour déterminer si un nombre est premier. J'ai utilisé python 3.6dessus ubuntu 17.10; J'ai testé avec des nombres allant jusqu'à 100.000 (vous pouvez tester avec 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), montrant que les dernières fonctions ne se développent pas aussi vite que la première lors de l'augmentation des nombres.

Et dans le deuxième graphique, nous pouvons voir que dans le cas des nombres premiers, le temps augmente régulièrement, mais les nombres non premiers ne croissent pas si vite dans le temps (car la plupart d'entre eux peuvent être éliminés tôt).

Voici les fonctions que j'ai utilisées:

1. cette réponse et cette réponse ont 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))
   

2. 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 True
   

3. Cette réponse comprenait une version avec une forboucle:

   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 True
   

4. Et j'ai mélangé quelques idées des autres réponses en 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

En exécutant 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)(nombres 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()

Selon wikipedia, le tamis d'Eratosthène est complexe O(n * (log n) * (log log n))et nécessite de la O(n)mémoire - c'est donc un très bon point de départ si vous ne testez pas des nombres particulièrement importants.

On peut utiliser sympy .

import sympy

sympy.ntheory.primetest.isprime(33393939393929292929292911111111)

True

De la documentation sympy. La première étape consiste à rechercher des facteurs triviaux qui, s'ils sont trouvés, permettent un retour rapide. Ensuite, si le tamis est assez grand, utilisez la recherche de bissection sur le tamis. Pour les petits nombres, un ensemble de tests déterministes de Miller-Rabin sont effectués avec des bases connues pour ne pas avoir de contre-exemples dans leur plage. Enfin, si le nombre est supérieur à 2 ^ 64, un test BPSW fort est effectué. Bien qu'il s'agisse d'un premier test probable et que nous pensons qu'il existe des contre-exemples, il n'y a pas de contre-exemples connus

Dans 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 divisible uniquement par lui-même et 1. Ex: 2,3,5,7 ...

1) si a <2: si "a" est inférieur à 2 ce n'est pas un nombre premier.

2) elif a! = 2 et a% 2 == 0: si "a" est divisible par 2 alors ce n'est certainement pas un 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) return all (a% i for i in range (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, la sortie 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 devons seulement vérifier jusqu'à 4 pour dire que ce n'est pas un nombre premier.

Extra: Une boucle pour 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))

Python 3:

def is_prime(a):
    return a > 1 and all(a % i for i in range(2, int(a**0.5) + 1))

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). Il existe des tests beaucoup plus évolutifs, tels que le test de primalité de Miller-Rabin . Ci-dessous, vous avez l'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 tester si le nombre candidat est divisible par l'un des nombres premiers inférieurs à, disons 1000, avant d'appeler Miller-Rabin. Cela vous aidera à filtrer les non-nombres premiers évidents tels que 10444344345.

Beaucoup trop tard pour la fête, mais j'espère que cela vous aidera. Ceci est pertinent si vous recherchez de gros nombres premiers:

Pour tester de grands nombres impairs, vous devez utiliser le test de Fermat et / ou le test de Miller-Rabin.

Ces tests utilisent l'exponentiation modulaire qui est assez coûteuse, pour l' nexponentiation des bits, vous avez besoin d'au moins une ngrande multiplication int et une ngrande division 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. Commencez par multiplier autant de nombres premiers ensemble 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 du mot et continuez l'algorithme sans effectuer de grandes divisions entières complètes. Si le GCD! = 1, cela signifie que l'un des nombres premiers que vous avez multipliés ensemble divise le nombre, vous avez donc une preuve qu'il n'est pas premier. Continuez ensuite avec 31 * 37 * 41 * 43 * 47 = 95041567, et ainsi de suite.

Une fois que vous avez testé plusieurs centaines (ou milliers) de nombres premiers de cette façon, vous pouvez faire 40 tours de test de Miller-Rabin pour confirmer que le nombre est premier, après 40 tours, vous pouvez être certain que le nombre est premier, il n'y a que 2 ^ -80 chances qu'il soit non (il est plus probable que votre matériel fonctionne mal ...).

J'ai une fonction principale qui fonctionne jusqu'à (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 all()fonction peut être redéfinie à ceci:

def all(variables):
    for element in variables:
        if not element: return False
    return True

La all()fonction passe simplement par une série de booléens / nombres et retourne Falsesi elle voit 0 ou False.

La sqrt()fonction fait simplement la racine carrée d'un nombre.

Par exemple:

>>> from math import sqrt
>>> sqrt(9)
>>> 3
>>> sqrt(100)
>>> 10

La num % xpartie renvoie le reste de num / x.

Enfin, cela 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, jetez un œil sur ce site !

La num > 1partie vérifie simplement si la variable numest plus grande que 1, car 1 et 0 ne sont pas considérés comme des nombres premiers.

J'espère que cela a aidé :)

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 vers Python utiliserait tout (n% p! = 0 ...) , mais cela nécessite une évaluation stricte de toutes les valeurs de p. La version not any peut se terminer prématurément si une valeur True est trouvée.

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
    }

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

Un nombre premier est un nombre qui n'est divisible que par 1 et lui-même. Tous les autres nombres sont appelés composites .

Le moyen le plus simple, pour trouver un nombre premier, est de vérifier si le nombre d'entrée 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 numberpar tous les nombres entiers de 1 à sa valeur. Si ce nombre peut être divisé également non seulement par un et lui-même, c'est un nombre composé.

La valeur initiale de la variable idoit être 2 car les nombres premiers et composés peuvent être divisés par 1.

    for (let i = 2; i < number; i++)

Alors ic'est moins que numberpour la même raison. Les nombres premiers et composés peuvent être divisés par eux-mêmes. Il n'y a donc aucune raison de le vérifier.

Ensuite, nous vérifions si la variable peut être divisée uniformément en utilisant l'opérateur reste.

    if (number % i === 0) {
        return false;
    }

Si le reste est égal à zéro, cela signifie qu'il numberpeut être divisé de manière égale, étant donc un nombre composé et renvoyant false.

Si le nombre entré ne remplit pas la condition, cela signifie qu'il s'agit d'un nombre premier et la fonction renvoie vrai.

Laissez-moi vous suggérer la solution parfaite pour les entiers 64 bits. Désolé d'utiliser C #. Vous ne l'avez pas déjà spécifié comme python dans votre premier message. J'espère que vous pourrez trouver une fonction modPow simple et l'analyser facilement.

public static bool IsPrime(ulong number)
{
    return number == 2 
        ? true 
        : (BigInterger.ModPow(2, number, number) == 2 
            ? (number & 1 != 0 && BinarySearchInA001567(number) == false) 
            : false)
}

public static bool BinarySearchInA001567(ulong number)
{
    // Is number in list?
    // todo: Binary Search in A001567 (https://oeis.org/A001567) below 2 ^ 64
    // Only 2.35 Gigabytes as a text file http://www.cecm.sfu.ca/Pseudoprimes/index-2-to-64.html
}

bool isPrime(int n) {
if(n <= 3)
    return (n > 1)==0? false: true;
else if(n%2 == 0 || n%3 == 0)
    return false;

int i = 5;

while(i * i <= n){
    if(n%i == 0 || (n%(i+2) == 0))
        return false;
    i = i + 6;
}

return true;
}

pour tout nombre, les itérations minimales pour vérifier si le nombre est premier ou non peuvent aller de 2 à la racine carrée du nombre. Pour réduire encore plus les itérations, nous pouvons vérifier si le nombre est divisible par 2 ou 3 car les nombres maximum peuvent être éliminés en vérifiant si le nombre est divisible par 2 ou 3. De plus, tout nombre premier supérieur à 3 peut être exprimé par 6k +1 ou 6k-1. Ainsi, l'itération peut aller de 6k + 1 à la racine carrée du nombre.

Le plus petit souvenir? Ce n'est pas le moindre, mais c'est un pas dans la bonne direction.

class PrimeDictionary {
    BitArray bits;

    public PrimeDictionary(int n) {
        bits = new BitArray(n + 1);
        for (int i = 0; 2 * i + 3 <= n; i++) {
            bits.Set(i, CheckPrimality(2 * i + 3));
        }
    }

    public PrimeDictionary(IEnumerable<int> primes) {
        bits = new BitArray(primes.Max());
        foreach(var prime in primes.Where(p => p != 2)) {
            bits.Set((prime - 3) / 2, true);
        }
    }

    public bool IsPrime(int k) {
        if (k == 2) {
            return true;
        }
        if (k % 2 == 0) {
            return false;
        }
        return bits[(k - 3) / 2];
    }
}

Bien sûr, vous devez spécifier la définition de CheckPrimality.

Je pense que l'une des méthodes les plus rapides est ma méthode.

void prime(long long int number) {
    // Establishing Variables
    long long int i = 5;
    int w = 2;
    const long long int lim = sqrt(number);

    // Gets 2 and 3 out of the way
    if (number == 1) { cout << number << " is hard to classify. \n";  return; }
    if (number == 2) { cout << number << " is Prime. \n";  return; }
    if (number == 3) { cout << number << " is Prime. \n";  return; }

    // Tests Odd Ball Factors
    if (number % 2 == 0) { cout << number << " is not Prime. \n";  return; }
    if (number % 3 == 0) { cout << number << " is not Prime. \n";  return; }

    while (i <= lim) {
        if (number % i == 0) { cout << number << " is not Prime. \n";  return; }
        // Tests Number
        i = i + w; // Increments number
        w = 6 - i; // We already tested 2 and 3
        // So this removes testing multepules of this
    }
    cout << number << " is Prime. \n"; return;
}

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

Pour savoir si le ou les nombres d'une plage 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.

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

public static boolean isPrime(int number) {
 if(number < 2)
   return false;
 else if(number == 2 || number == 3)
        return true;
      else {
        for(int i=2;i<=number/2;i++)
           if(number%i == 0)
             return false;
           else if(i==number/2)
                return true;
      }
    return false;
}

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 façon de tester pour voir qu'un nombre est un nombre premier. Pour rappel, les 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 nombre 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 quoi que ce soit au-dessus de la moitié de sa valeur. Exemple si vous voulez voir que 100 est un nombre premier, vous pouvez parcourir jusqu'à 50.

Code réel :

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")  

Nous pouvons utiliser des flux java pour implémenter cela dans O (sqrt (n)); Considérez que noneMatch est une méthode shortCircuiting qui arrête l'opération lorsqu'elle la trouve 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");

Avec l'aide des flux Java-8 et des lambdas, il peut être implémenté comme ceci en quelques lignes:

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 le trouvera utile.

Voici mon avis sur la réponse:

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.

1. Le nombre est inférieur ou égal à 3
2. Le nombre + 1 est divisible par 6
3. Le nombre - 1 est divisible par 6

Lorsque je dois faire une vérification rapide, j'écris ce code simple basé sur la division de base entre les nombres inférieurs à la racine carrée de l'entrée.

def isprime(n):
    if n%2==0:
        return n==2
    else:
        cota = int(n**0.5)+1
        for ind in range(3,2,cota):
            if n%ind==0:
                print(ind)
                return False
        return True != n==1

isprime(22783)

• Le dernier True != n==1est d'éviter le cas n=1.