Schreiben Sie ein Programm oder eine Funktion, die die ersten 10000 primindexierten Primzahlen ausgibt / zurückgibt.

Wenn wir die n- ^te Primzahl nennen p(n), lautet diese Liste

3, 5, 11, 17, 31, 41, 59 ... 1366661

da

p(p(1)) = p(2) = 3
p(p(2)) = p(3) = 5
p(p(3)) = p(5) = 11
p(p(4)) = p(7) = 17
...
p(p(10000)) = p(104729) = 1366661

Standardlücken sind verboten, und Standardausgabemethoden sind zulässig. Sie können mit einem vollständigen Programm, einer benannten Funktion oder einer anonymen Funktion antworten.

MATLAB / Octave, 25 Bytes

p=primes(2e6)
p(p(1:1e4))

Einfacher geht es nicht.

Python, 72 Bytes

P=p=1;l=[]
while p<82e5/6:l+=P%p*[p];P*=p*p;p+=1
for x in l:print l[x-1]

Dies endet mit einem "Listenindex außerhalb des Bereichs", nachdem die 10000-Nummern gedruckt wurden, was standardmäßig zulässig ist .

Verwendet die Wilsonsche Theorem-Methode , um eine Liste lder Primzahlen bis zur 10000sten Primzahl zu erstellen. Dann werden die Primzahlen mit den Positionen in der Liste gedruckt, die für die Nullindizierung um 1 verschoben wurden, bis nach der 10000. Primzahl-ten Primzahl keine Grenzen mehr vorhanden sind.

Zweckmßigerweise die Obergrenze 1366661kann abgeschätzt werden , wie 82e5/6die ist 1366666.6666666667, ein Zeichen zu speichern.

Ich hätte gerne eine Einzelschleifenmethode, bei der Primzahlen gedruckt werden, wenn wir sie hinzufügen, aber sie scheint länger zu sein.

P=p=1;l=[]
while p<104730:
 l+=P%p*[p]
 if len(l)in P%p*l:print p
 P*=p*p;p+=1

J, 11 Bytes

p:<:p:i.1e4

Gibt die Primzahlen im Format aus

3 5 11 17 31 41 59 67 83 109 127 ...

Erläuterung

        1e4  Fancy name for 10000
      i.     Integers from 0 to 9999
    p:       Index into primes: this gives 2 3 5 7 11 ...
  <:         Decrement each prime (J arrays are 0-based)
p:           Index into primes again

Mathematica, 26 25 23 Bytes

Prime@Prime@Range@1*^4&

Reine Funktion, die die Liste zurückgibt.

Haskell, 65 Bytes

p=[x|x<-[2..],all((>0).mod x)[2..x-1]]
f=take 10000$map((0:p)!!)p

Ausgänge: [3,5,11,17,31,41,59,67,83,109,127.....<five hours later>...,1366661]

Nicht sehr schnell. So funktioniert es: pist die unendliche Liste der Primzahlen (naiv überprüft man alle mod x ys auf y in [2..x-1]). Nehmen Sie die ersten 10000Elemente der Liste, die Sie erhalten, wenn 0:p!!(get nth element of p) zugeordnet ist p. Ich muss die Liste der Primzahlen, aus denen ich die Elemente nehme, anpassen, indem ich eine Zahl (-> 0:) voranstelle , da die Indexfunktion ( !!) auf Null basiert.

PARI / GP, 25 Bytes

apply(prime,primes(10^4))

AWK - 129 Bytes

... oookay ... zu lang, um Punkte für Kompaktheit zu gewinnen ... aber vielleicht kann es etwas Ehre für die Geschwindigkeit gewinnen?

Die xDatei:

BEGIN{n=2;i=0;while(n<1366662){if(n in L){p=L[n];del L[n]}else{P[p=n]=++i;if(i in P)print n}j=n+p;while(j in L)j=j+p;L[j]=p;n++}}

Laufen:

$ awk -f x | nl | tail
  9991  1365913
  9992  1365983
  9993  1366019
  9994  1366187
  9995  1366327
  9996  1366433
  9997  1366483
  9998  1366531
  9999  1366609
 10000  1366661

Lesbar:

BEGIN {
        n=2
        i=0
        while( n<1366662 ) {
                if( n in L ) {
                        p=L[n]
                        del L[n]
                } else {
                        P[p=n]=++i
                        if( i in P ) print n
                }
                j=n+p
                while( j in L ) j=j+p
                L[j]=p
                n++
        }
}

Das Programm berechnet einen Strom von Primzahlen, indem es Lals "Zahlenband" gefundene Primzahlen verwendet, die herumspringen, um Ldie nahegelegenen Zahlen zu kennzeichnen, von denen bereits bekannt ist, dass sie einen Divisor haben. Diese springenden Primzahlen rücken vor, während das "Zahlenband" Lvon Anfang an Nummer für Nummer abgeschnitten wird.

Wenn der Bandkopf L[n]leer ist, ist kein (Haupt-) Teiler bekannt.

L[n]Halten eines Wertes bedeutet, dass dieser Wert eine Primzahl ist und bekanntermaßen dividiert n.

Also haben wir entweder einen Primteiler oder einen neuen Prim gefunden. Dann wird diese Primzahl L[n+m*p]auf dem Band, das als leer befunden wurde, auf die nächste vorgerückt .

Dies ist wie das Sieb des Eratosthenes "durch eine Kleinsche Flasche gezogen". Sie handeln immer am Bandanfang. Anstatt mehrere Primzahlen durch das Band zu schießen, verwenden Sie die bereits gefundenen Primzahlen als Cursor, die um mehrere Abstände ihres eigenen Werts vom Band wegspringen, bis eine freie Position gefunden wird.

Während die äußere Schleife eine Primzahl oder keine Primzahl pro Schleife erzeugt, werden die gefundenen Primzahlen gezählt und Pals Schlüssel gespeichert . Der Wert dieses Paars (Schlüssel, Wert) ist für den Programmablauf nicht relevant.

Wenn ihr Schlüssel izu sein in geschieht Pbereits ( i in P), haben wir eine erstklassige der p (p (i)) zu züchten.

Laufen:

$ time awk -f x.awk | wc -l
10000

real    0m3.675s
user    0m3.612s
sys     0m0.052s

Beachten Sie, dass dieser Code keine externen vorberechneten Primetabellen verwendet.

Die Zeit, die auf meinem guten alten Thinkpad T60 vergangen ist, ist meines Erachtens verdient, schnell genannt zu werden.

Getestet mit mawkund gawkauf Debian8 / AMD64

CJam, 19

3D#{mp},_1e4<:(\f=p

Sie können es online ausprobieren , benötigen jedoch etwas Geduld: p

Für den Datensatz ist die letzte Nummer 1366661.

Perl, 55 Bytes

use ntheory':all';forprimes{print nth_prime$_,$/}104729

Uses @DanaJ ‚s - Math::Prime::UtilModul für Perl (mit dem Pragma geladen ntheory). Erhalten Sie es mit:

cpan install Math::Prime::Util
cpan install Math::Prime::Util::GMP

05AB1E, 7 Bytes (nicht konkurrierend)

Code:

4°L<Ø<Ø

Probieren Sie es online! , beachte, dass ich das 4in ein geändert habe 2. Wenn Sie viel Zeit haben, können Sie das 2Zurück zu ändern 4, dies wird jedoch viel Zeit in Anspruch nehmen . Ich muss den Algorithmus dafür beschleunigen.

Erläuterung:

4°       # Push 10000 (10 ^ 4)
  L      # Create the list [1 ... 10000]
   <     # Decrement on every element, [0 ... 9999]
    Ø    # Compute the nth prime
     <   # Decrement on every element
      Ø  # Compute the nth prime