web-dev-qa-db-de.com

Was ist der beste Algorithmus, um zu überprüfen, ob eine Zahl eine Primzahl ist?

Nur ein Beispiel für das, wonach ich suche: Ich könnte jede ungerade Zahl mit ein bisschen darstellen, z. für den angegebenen Zahlenbereich (1, 10] beginnt bei 3:

1110

Das folgende Wörterbuch kann mehr gequetscht werden? Ich könnte mit einiger Arbeit ein Vielfaches von Fünffach beseitigen, aber Zahlen, die mit 1, 3, 7 oder 9 enden, müssen im Array von Bits vorhanden sein. Hoffe das würde klären, was ich will.

Ich suche den besten Algorithmus, um zu überprüfen, ob eine Zahl eine Primzahl ist, d. H. Eine boolesche Funktion:

bool isprime(number);

Ich würde gerne den besten Algorithmus kennen, um diese Funktionalität zu implementieren. Natürlich gibt es eine Datenstruktur, die ich abfragen könnte. I Definiere den besten Algorithmus , um den Algorithmus zu sein, der eine Datenstruktur mit dem geringsten Speicherverbrauch für den Bereich (1, N] erzeugt, wobei N eine Konstante ist.

130
AraK

Es gibt viele Möglichkeiten, den Primality-Test durchzuführen.

Es gibt nicht wirklich eine Datenstruktur, die Sie abfragen können. Wenn Sie viele Zahlen zum Testen haben, sollten Sie wahrscheinlich einen probabilistischen Test durchführen, da diese schneller sind, und anschließend einen deterministischen Test durchführen, um sicherzustellen, dass die Zahl Primzahlen ist.

Sie sollten wissen, dass die Mathematik hinter den schnellsten Algorithmen nichts für schwache Nerven ist.

68
Ben S

Der schnellste Algorithmus für allgemeine Primentests ist AKS . Der Wikipedia-Artikel beschreibt es ausführlich und verlinkt auf das Originalpapier.

Wenn Sie große Zahlen finden möchten, schauen Sie sich Primzahlen an, die spezielle Formen wie Mersenne Primes haben.

Der Algorithmus, den ich normalerweise implementiere (leicht verständlich und Code), lautet wie folgt (in 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

Es ist eine Variante des klassischen Algorithmus O(sqrt(N)). Es verwendet die Tatsache, dass ein Prim (außer 2 und 3) die Form 6k - 1 oder 6k + 1 hat und nur Teiler dieser Form betrachtet.

Manchmal, wenn ich wirklich Geschwindigkeit und der Bereich ist begrenzt möchte, implementiere ich einen Pseudo-Primertest basierend auf Fermats kleinem Theorem . Wenn ich wirklich mehr Geschwindigkeit will (d. H. Vermeiden O(sqrt(N)) Algorithmus insgesamt), berechne ich die falsch positiven Werte (siehe Carmichael numbers) vor und stelle eine binäre Suche vor. Dies ist bei weitem der schnellste Test, den ich je implementiert habe. Der einzige Nachteil ist, dass die Reichweite begrenzt ist.

188
Alexandru

Die beste Methode ist meiner Meinung nach, das zu verwenden, was vorher gegangen ist.

Es gibt Listen der ersten N-Primzahlen im Internet, wobei N sich auf mindestens fünfzig Millionen erstreckt. Laden Sie die Dateien herunter und verwenden Sie sie. Sie ist wahrscheinlich viel schneller als jede andere Methode, die Sie sich vorstellen.

Wenn Sie einen Algorithmus für die Erstellung Ihrer eigenen Primzahlen wünschen, bietet Wikipedia alle möglichen nützlichen Informationen zu Primzahlen hier , einschließlich Links zu den verschiedenen Methoden, und Primentests hier , beide auf Wahrscheinlichkeit basierend und schnell-deterministische Methoden.

Es sollte ein gemeinsames Bestreben gegeben werden, die ersten Milliarden (oder sogar noch mehr) Primzahlen zu finden und sie irgendwo im Netz veröffentlichen zu lassen, damit die Leute diesen Job immer und immer wieder beenden können und ... :-)

24
paxdiablo
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

https://en.wikipedia.org/wiki/AKS_primality_test

8
saurabh kumar

Laut Wikipedia hat das Sieb des Eratosthenes hat Komplexität O(n * (log n) * (log log n)) und erfordert O(n) Speicher - es ist also ein ziemlich guter Ort, um zu starten, wenn Sie nicht auf besonders große Zahlen testen.

6
matt b

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

Erläuterung: Eine Primzahl ist eine Zahl, die nur durch sie teilbar ist und 1. Bsp: 2,3,5,7 ...

1) wenn a <2: wenn "a" kleiner als 2 ist, ist dies keine Primzahl.

2) Elif a! = 2 und a% 2 == 0: Wenn "a" durch 2 teilbar ist, ist es definitiv keine Primzahl. Aber wenn a = 2 ist, wollen wir das nicht bewerten, da es eine Primzahl ist. Daher ist die Bedingung a! = 2

3) gebe all (a% i für i im Bereich (3, int (a 0,5) +1)) zurück: ** Zuerst schaue, was all () in Python tut. Ab 3 teilen wir "a" bis zur Quadratwurzel (a ** 0,5). Wenn "a" teilbar ist, ist die Ausgabe "False". Warum die Quadratwurzel? Sagen wir a = 16. Die Quadratwurzel von 16 = 4. Wir müssen nicht bis 15 auswerten. Wir müssen nur bis 4 überprüfen, um zu sagen, dass es keine Primzahl ist. 

Extra: Eine Schleife zum Finden aller Primzahlen innerhalb eines Bereichs.

for i in range(1,100):
    if is_prime(i):
        print("{} is a prime number".format(i))
4
Deep grewal

Man kann sympy verwenden. 

import sympy

sympy.ntheory.primetest.isprime(33393939393929292929292911111111)

True

Aus sympy docs. Der erste Schritt ist die Suche nach unbedeutenden Faktoren, die, wenn sie gefunden werden, eine schnelle Rückkehr ermöglichen. Wenn das Sieb groß genug ist, führen Sie als Nächstes die Sektionssuche auf dem Sieb aus. Für kleine Zahlen wird eine Reihe von deterministischen Miller-Rabin-Tests mit Basen durchgeführt, von denen bekannt ist, dass sie keine Gegenbeispiele in ihrem Bereich haben. Wenn die Anzahl größer als 2 ^ 64 ist, wird ein starker BPSW-Test durchgeführt. Obwohl dies ein wahrscheinlicher Primärtest ist und wir glauben, dass Gegenbeispiele existieren, gibt es keine bekannten Gegenbeispiele.

3
LetzerWille

Viel zu spät zur Party, aber hoffe das hilft. Dies ist relevant, wenn Sie nach großen Primzahlen suchen:

Um große ungerade Zahlen zu testen, müssen Sie den Fermat-Test und/oder den Miller-Rabin-Test verwenden.

Diese Tests verwenden eine modulare Exponentiation, die recht teuer ist. Für die n-Bit-Exponentiation benötigen Sie mindestens n big int-Multiplikation und n big int divison. Dies bedeutet, dass die Komplexität der modularen Exponentiation O (n³) ist.

Bevor Sie die großen Geschütze einsetzen, müssen Sie einige Testabteilungen durchführen. Aber machen Sie es nicht naiv, es gibt einen Weg, sie schnell zu machen ... multiplizieren Sie zuerst so viele Primzahlen, wie viele in die Wörter passen, die Sie für die großen Ganzzahlen verwenden. Wenn Sie 32-Bit-Wörter verwenden, multiplizieren Sie 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 29 = 3234846615 und berechnen Sie den größten gemeinsamen Teiler mit der Zahl, die Sie mit dem Euklidischen Algorithmus testen. Nach dem ersten Schritt wird die Anzahl unter die Word-Größe reduziert und der Algorithmus fortgesetzt, ohne vollständige Ganzzahldivisionen durchzuführen. Wenn die GCD! = 1 ist, bedeutet dies, dass einer der Primes, die Sie multipliziert haben, die Zahl dividiert, so dass Sie einen Beweis haben, dass es kein Prim ist. Dann weiter mit 31 * 37 * 41 * 43 * 47 = 95041567 und so weiter.

Wenn Sie mehrere hundert (oder tausend) Primzahlen auf diese Weise getestet haben, können Sie 40 Runden des Miller-Rabin-Tests durchführen, um zu bestätigen, dass die Zahl Primzahl ist. Nach 40 Runden können Sie sicher sein, dass die Zahl Primzahl ist nicht (es ist wahrscheinlicher, dass Ihre Hardware ausfällt ...). 

2
Calmarius

Ich habe die Effizienz der beliebtesten Vorschläge verglichen, um festzustellen, ob eine Zahl Primzahl ist. Ich habe python 3.6 für ubuntu 17.10 verwendet; Ich habe mit Zahlen bis zu 100.000 getestet (Sie können mit meinem Code unten auch größere Zahlen testen).

Diese erste Darstellung vergleicht die Funktionen (die weiter unten in meiner Antwort erläutert werden) und zeigt, dass die letzten Funktionen beim Erhöhen der Zahlen nicht so schnell wachsen wie die ersten.

 plot1

In der zweiten Darstellung können wir sehen, dass bei Primzahlen die Zeit stetig wächst, während Nichtprimzahlen nicht so schnell wachsen (da die meisten von ihnen frühzeitig eliminiert werden können).

 plot2

Hier sind die Funktionen, die ich verwendet habe:

  1. diese Antwort und diese Antwort schlug ein Konstrukt mit all() vor:

    def is_prime_1(n):
        return n > 1 and all(n % i for i in range(2, int(math.sqrt(n)) + 1))
    
  2. Diese Antwort verwendete eine Art while-Schleife:

    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. Diese Antwort enthielt eine Version mit einer for-Schleife:

    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. Und ich habe ein paar Ideen aus den anderen Antworten in eine neue gemischt:

    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
    

Hier ist mein Skript, um die Varianten zu vergleichen:

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

Beim Ausführen der Funktion compare_functions(n=10**5) (Zahlen bis zu 100.000) erhalte ich diese Ausgabe:

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

Dann führe ich die Funktion compare_functions(n=10**6) (Zahlen bis zu 1.000.000) aus und erhalte folgende Ausgabe:

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

Ich habe das folgende Skript verwendet, um die Ergebnisse zu zeichnen:

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()
2
Ralf

bester Algorithmus für Primes Zahl 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
    }
1

In Python:

def is_prime(n):
    return not any(n % p == 0 for p in range(2, int(math.sqrt(n)) + 1))

Eine direktere Konvertierung vom mathematischen Formalismus in Python würde all (n% p! = 0 ...) verwenden, dies erfordert jedoch eine strikte Bewertung aller Werte von p. Die Version not any kann vorzeitig beendet werden, wenn ein True-Wert gefunden wird.

1
Vlad Bezden

Bei großen Zahlen kann nicht einfach geprüft werden, ob die Kandidatennummer N durch keine der Zahlen kleiner als sqrt (N) teilbar ist. Es gibt viel mehr skalierbare Tests, wie zum Beispiel den Miller-Rabin-Primalitätstest . Nachfolgend haben Sie eine Implementierung in 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

Sie können es verwenden, um große Primzahlen zu finden:

x = 10000000000000000000000000000000000000000000000000000000000000000000000000000
for e in range(1000):
    if is_prime(x + e):
        print('%d is a prime!' % (x + e))
        break

# 10000000000000000000000000000000000000000000000000000000000000000000000000133 is a prime!

Wenn Sie zufällige Ganzzahlen testen, möchten Sie wahrscheinlich zuerst testen, ob die Kandidatennummer durch eine der Primzahlen teilbar ist, die kleiner als 1000 ist, bevor Sie Miller-Rabin anrufen. Dies hilft Ihnen, offensichtliche Nicht-Primzahlen wie 10444344345 herauszufiltern.

1
Piotr Dabkowski

Python 3:

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

Ich habe eine Prim-Funktion, die bis (2 ^ 61) -1 hier funktioniert:

from math import sqrt
def isprime(num): num > 1 and return all(num % x for x in range(2, int(sqrt(num)+1)))

Erklärung:

Die all()-Funktion kann folgendermaßen neu definiert werden:

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

Die all()-Funktion durchläuft lediglich eine Reihe von Boolern/Zahlen und gibt False zurück, wenn 0 oder False angezeigt wird.

Die sqrt()-Funktion führt nur die Quadratwurzel einer Zahl aus.

Zum Beispiel:

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

Der num % x-Teil gibt den rest von num/x zurück.

Schließlich bedeutet range(2, int(sqrt(num))), dass eine list erstellt wird, die bei 2 beginnt und bei int(sqrt(num)+1) endet.

Weitere Informationen zum Sortiment finden Sie auf dieser Website !

Der num > 1-Teil prüft nur, ob die Variable num größer als 1 ist, da 1 und 0 nicht als Primzahlen betrachtet werden.

Ich hoffe das hat geholfen :) 

Eine Primzahl ist eine Zahl, die nur durch 1 und sich selbst teilbar ist. Alle anderen Zahlen heißen zusammengesetzt .

Der einfachste Weg, eine Primzahl zu finden, besteht darin, zu überprüfen, ob die eingegebene Zahl eine zusammengesetzte Zahl ist:

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

Das Programm muss den Wert von number durch alle ganzen Zahlen von 1 bis zu seinem Wert teilen. Wenn diese Zahl nicht nur durch eins, sondern auch durch sich selbst gleichmäßig geteilt werden kann, handelt es sich um eine zusammengesetzte Zahl.

Der Anfangswert der Variablen i muss 2 sein, da sowohl Primzahlen als auch zusammengesetzte Zahlen gleichmäßig durch 1 geteilt werden können.

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

Dann ist i aus dem gleichen Grund kleiner als number. Sowohl Primzahlen als auch zusammengesetzte Zahlen können gleichmäßig voneinander getrennt werden. Daher gibt es keinen Grund, dies zu überprüfen.

Dann prüfen wir, ob die Variable mit dem Restoperator gleichmäßig aufgeteilt werden kann.

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

Wenn der Rest Null ist, bedeutet dies, dass number gleichmäßig aufgeteilt werden kann, also eine zusammengesetzte Zahl ist und false zurückgibt.

Wenn die eingegebene Zahl die Bedingung nicht erfüllt, handelt es sich um eine Primzahl, und die Funktion gibt true zurück.

0
user6804120

Mit Hilfe von Java-8-Streams und Lambdas kann dies in wenigen Zeilen so implementiert werden:

public static boolean isPrime(int candidate){
        int candidateRoot = (int) Math.sqrt( (double) candidate);
        return IntStream.range(2,candidateRoot)
                .boxed().noneMatch(x -> candidate % x == 0);
    }

Die Leistung sollte nahe an O(sqrt(N)) liegen. Vielleicht findet jemand es nützlich.

0
Stefan Repcek

Eine ähnliche Idee wie der erwähnte AKS-Algorithmus

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;
}
0
Derri Leahy

Hier ist meine Antwort auf die Antwort:

def isprime(num):
    return num <= 3 or (num + 1) % 6 == 0 or (num - 1) % 6 == 0

Die Funktion gibt "True" zurück, wenn eine der folgenden Eigenschaften "True" ist. Diese Eigenschaften definieren mathematisch, was eine Primzahl ist.

  1. Die Anzahl ist kleiner oder gleich 3
  2. Die Zahl + 1 ist durch 6 teilbar
  3. Die Zahl - 1 ist durch 6 teilbar
0
Richie Bendall

Sie könnten so etwas versuchen.

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()
0
Patrick Jane

Die meisten der vorherigen Antworten sind korrekt, aber es gibt noch eine weitere Möglichkeit, eine Zahl als Primzahl zu testen. Als Auffrischung sind Primzahlen ganze Zahlen größer als 1, deren einzige Faktoren 1 und sie selbst sind. ( source )

Lösung:

Normalerweise können Sie eine Schleife erstellen und mit dem Testen Ihrer Zahl beginnen, um zu sehen, ob sie durch 1,2,3 teilbar ist ... bis zu der von Ihnen getesteten Zahl ... usw. Um die Prüfzeit jedoch zu reduzieren, können Sie Ihre Zahl durch teilen Die Hälfte des Wertes Ihrer Zahl, da eine Zahl nicht durch etwas mehr als die Hälfte ihres Wertes teilbar sein kann .. Wenn Sie 100 anzeigen möchten, können Sie eine Primzahl verwenden, die Sie bis zu 50 durchlaufen können.

Aktueller Code:

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

Um herauszufinden, ob die Zahl oder die Zahlen in einem Bereich Primzahlen sind/sind.

#!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.
0
Harsh Singh
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
0
aedry
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))
0
DKB

Wir können Java-Streams verwenden, um dies in O (sqrt (n)) zu implementieren. Beachten Sie, dass noneMatch eine shortCircuiting-Methode ist, die den Vorgang anhält, wenn er für die Ermittlung des Ergebnisses nicht erforderlich ist:

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");
0
alirezafnatica