Dies ist meine erste Code-Golf-Frage, und zwar eine sehr einfache. Deshalb entschuldige ich mich im Voraus, wenn ich möglicherweise gegen Community-Richtlinien verstoßen habe.

Die Aufgabe besteht darin, alle Primzahlen unter einer Million in aufsteigender Reihenfolge auszudrucken. Das Ausgabeformat sollte eine Zahl pro Ausgabezeile sein.

Das Ziel ist, wie bei den meisten Code-Golf-Einsendungen, die Minimierung der Codegröße. Die Optimierung für die Laufzeit ist ebenfalls ein Bonus, aber ein sekundäres Ziel.

Mathematica , 17, 24

Nur zum Vergleich:

Prime@Range@78498

Wie in einem Kommentar erwähnt, konnte ich keine Primzahl pro Zeile angeben. Korrektur:

Column@Prime@Range@78498

Python 3, 46 Bytes

k=P=1
while k<1e6:P%k and print(k);P*=k*k;k+=1

Bis die Schleife den Test erreicht k, hat sie die quadrierte Fakultät iterativ berechnet P=(k-1)!^2. Wenn kprime ist, erscheint es nicht im Produkt 1 * 2 * ... * (k-1), also ist es kein Faktor von P. Aber wenn es zusammengesetzt ist, sind alle seine Primfaktoren kleiner und so im Produkt. Das Quadrieren wird eigentlich nur benötigt, um nicht k=4fälschlicherweise als Primzahl bezeichnet zu werden.

Stärker folgt aus dem Satz von Wilson, dass, wenn kPrimzahl ist, P%kgleich ist 1. Obwohl wir nur brauchen, dass es hier nicht Null ist, ist es im Allgemeinen nützlich, dass P%kes eine Indikatorvariable dafür ist, ob kes eine Primzahl ist.

C 61 Zeichen

Fast genau das gleiche wie dieses (die Frage ist auch fast genau das gleiche).

n=2;main(m){n<1e6&&main(m<2?printf("%d\n",n),n:n%m?m-1:n++);}

MATLAB (16) (12)

Leider wird dies in einer einzigen Zeile ausgegeben:

primes(1000000)

Dies wird jedoch durch eine einfache Matrixtransponierung gelöst:

primes(1000000)'

und ich kann einige Zeichen mit Exponentialschreibweise ausschneiden (wie in den Kommentaren vorgeschlagen):

primes(1e6)'

Bash (37 Zeichen)

seq 2 1e6|factor|sed 's/.*: //g;/ /d'

(60 Zeichen)

seq 2 1000000|factor|sed -e 's/[0-9]*: //g' -e '/^.* .*$/ d'

auf meinem Computer (2,0 GHz CPU, 2 GB RAM) dauert 14 Sekunden.

J, 21 Zeichen

1[\p:i.(_1 p:1000000)

das kann gekürzt werden

1[\p:i.78498

Wenn Sie wissen, wie viele Primzahlen es unter 1000000 gibt.

PowerShell, 47 44 Bytes

Sehr langsam, aber das kürzeste, das ich finden konnte.

$p=2..1e6;$p|?{$n=$_;!($p-lt$_|?{!($n%$_)})}

PowerShell, 123 Byte

Das geht viel schneller; alles andere als optimal, aber ein guter Kompromiss zwischen Effizienz und Kürze.

 $p=2..1e6;$n=0
 while(1){$p=@($p[0..$n]|?{$_})+($p[($n+1)..($p.count-1)]|?{$_%$p[$n]});$n++;if($n-ge($p.count-1)){break}}
 $p

Rubin 34

require'prime';p Prime.take 78498

Bash, 30 Bytes

Da saeedn nicht auf meinen Vorschlag eingeht - der sowohl kürzer als auch schneller ist als sein Ansatz -, dachte ich, ich würde meine eigene Antwort posten:

seq 1e6|factor|awk '$0=$2*!$3'

Wie es funktioniert

seq 1e6

listet alle positiven ganzen Zahlen bis zu 1.000.000 auf.

factor

Faktoren sie eins nach dem anderen. Für die ersten zehn ist die Ausgabe wie folgt:

1:
2: 2
3: 3
4: 2 2
5: 5
6: 2 3
7: 7
8: 2 2 2
9: 3 3
10: 2 5

Endlich,

awk '$0=$2*!$3'

Ändert die gesamte Zeile ( $0) in das Produkt des zweiten Feldes (erster Primfaktor) und die logische Negation des dritten Feldes ( 1wenn das ein Primfaktor oder weniger ist, 0sonst).

Dies ersetzt Zeilen, die Primzahlen entsprechen, durch die Zahl selbst und alle anderen Zeilen durch Nullen. Da awk nur wahrheitsgemäße Werte ausgibt, werden nur Primzahlen ausgegeben.

Ruby 50 41

require'mathn'
p (2..1e6).select &:prime?

Bash, 37

Werde mehr Golf spielen, wenn ich kann ...

Das meiste versucht das factorumständliche Ausgabeformat zu analysieren .

seq 1e6|factor|grep -oP "(?<=: )\d+$"

Die Ausführung auf meinem Computer dauert ungefähr 5,7 Sekunden.

(Es ist einfach passiert, dass mein Beitrag der erste war , der auf der zweiten Seite der Antworten auftauchte, also wird es niemand sehen ...)

Alte Lösung

Dies ist länger und langsamer (dauert 10 Sekunden).

seq 1e6|factor|egrep ':.\S+$'|grep -oE '\S+$'

Python 3.x: 66 Zeichen

for k in range(2,10**6):
 if all(k%f for f in range(2,k)):print(k)

Effizientere Lösung: 87 Zeichen

Basierend auf dem Sieb des Eratosthenes.

p=[];z=range(2,10**6)
while z:f=z[0];p+=[f];z=[k for k in z if k%f]
for k in p:print(k)

Haskell, 51

mapM print [n|n<-[2..10^6],all((>0).rem n)[2..n-1]]

APL, 15

p~,p∘.×p←1↓⍳1e6

Mein Dolmetscher hatte Probleme mit dem Gedächtnis, aber es funktioniert theoretisch.

Perl, 49 Bytes

Regulärer Ausdruck Kung Fu :)

for(1..1E6){(1x$_)=~/^(11+?)\1+$/ or print"$_\n"}

Ungolfed-Version:

for(1 .. 1_000_000) { 
    (1x$_) =~ /^(11+?)\1+$/ or print "$_\n";
}

Es hat nicht einmal 10% Fortschritt gemacht, während ich diesen Beitrag schreibe!

Quelle für die Regex: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

Julia, 11

primes(10^6)

Es sieht so aus, als würden eingebaute Ins positiv bewertet, und ich brauchte mehr Worte für eine längere Antwort.

J (15 oder 9)

Ich kann diesen Beat von Mathematica nicht glauben (auch wenn es nur eine Single mit 2 Zeichen ist)

a#~1 p:a=:i.1e6

Oder:

p:i.78498

gs2, 5 bytes

In CP437 codiert:

∟)◄lT

1C 29Drückt eine Million, 11 6Cist Primzahlen unten, 54ist Linien zeigen.

GolfScript, 22/20 (20/19) Bytes

n(6?,:|2>{(.p|%-.}do:n

Auf Kosten der Geschwindigkeit kann der Code zwei Bytes kürzer gemacht werden:

n(6?,:|2>.{|%2>-}/n*

Wenn das in der bearbeiteten Frage angegebene Ausgabeformat nicht beachtet wird (wie viele der vorhandenen Antworten), können zwei Bytes in der schnellen und eines in der langsamen Version gespeichert werden:

n(6?,:|2>{(.p|%-.}do
n(6?,:|2>.{|%2>-}/`

Dadurch wird nach den Primzahlen für die schnelle Version eine zusätzliche LF ausgegeben, und die Primzahlen werden als Array für die langsame Version gedruckt.

Wie es funktioniert

Beide Versionen sind Implementierungen des Siebs von Eratosthenes .

Die schnelle Version macht folgendes:

1. Stellen Sie A = [ 2 3 4 … 999,999 ]und ein| = [ 0 1 2 … 999,999 ] .

2. Einstellen N = A[0]und druckenN .

3. Sammle jedes N-te Element von |in C. Dies sind die Vielfachen vonN .

4. einstellen A = A - C .

5. Wenn Aes nicht leer ist, gehe zurück zu 2.

n(6?   # Push "\n".pop() ** 6 = 1,000,000.
,:|    # Push | = [ 0 1 2 … 999,999 ].
,2>    # Push A = [ 2 3 4 … 999,999 ].
{      #
  (    # Unshift the first element (“N”) of “A”.
  .p   # Print “N”.
  |%   # Collect every N-th element from “A” into a new array, starting with the first.
  -    # Take the set difference of “A” and the array from above.
  .    # Duplicate the set difference.
}do    # If the set difference is non-empty, repeat.
:n     # Store the empty string in “n”, so no final LF will get printed.

Die langsame Version funktioniert auf ähnliche Weise, aber anstatt nacheinander ein Vielfaches des Minimums von „A“ (das immer eine Primzahl ist) zu entfernen, werden ein Vielfaches aller positiven Ganzzahlen unter 1.000.000 entfernt.

Wettbewerbsfähigkeit

Ohne eingebaute mathematische Funktionen zur Faktorisierung oder Überprüfung der Primalität sind alle GolfScript-Lösungen entweder sehr umfangreich oder sehr ineffizient.

Ich bin zwar noch weit davon entfernt, effizient zu sein, aber ich denke, ich habe ein anständiges Verhältnis von Geschwindigkeit zu Größe erreicht. Zum Zeitpunkt der Übermittlung scheint dieser Ansatz der kürzeste zu sein, der keine der oben genannten integrierten Funktionen verwendet. Ich sage scheint, weil ich keine Ahnung habe, wie einige der Antworten funktionieren ...

Ich habe alle vier eingereichten GolfScript-Lösungen verglichen: w0lfs (Versuchsabteilung), meine andere Antwort (Wilsons Theorem) und die beiden dieser Antworten. Das waren die Ergebnisse:

Bound     | Trial division     | Sieve (slow)       | Wilson's theorem | Sieve (fast)
----------+--------------------+--------------------+------------------+----------------
1,000     | 2.47 s             | 0.06 s             | 0.03 s           | 0.03 s
10,000    | 246.06 s (4.1 m)   | 1.49 s             | 0.38 s           | 0.14 s
20,000    | 1006.83 s (16.8 m) | 5.22 s             | 1.41 s           | 0.38 s
100,000   | ~ 7 h (estimated)  | 104.65 (1.7 m)     | 35.20 s          | 5.82 s
1,000,000 | ~ 29 d (estimated) | 111136.97s (3.1 h) | 3695.92 s (1 h)  | 418.24 s (7 m)

NARS2000 APL, 7 Zeichen

⍸0π⍳1e6

Golfscript 26 25 24

Bearbeiten (ein weiteres Zeichen dank Peter Taylor gespeichert):

10 6?,{:x,{)x\%!},,2=},`

Alter Code:

10 6?,{.,{)\.@%!},,2=*},`

Dieser Code hat nur theoretischen Wert, da er unglaublich langsam und ineffizient ist. Ich denke, es könnte Stunden dauern, bis es läuft.

Wenn Sie es testen möchten, versuchen Sie zum Beispiel nur die Primzahlen bis 100:

10 2?,{:x,{)x\%!},,2=},`

CJam - 11

1e6,{mp},N*

1e6,- Array von 0 ... 999999
{mp},- Primzahlen auswählen
N*- mit Zeilenumbrüchen verbinden

GolfScript, 25 (24) Bytes

!10 6?,2>{.(@*.)@%!},n*\;

Wenn das in der bearbeiteten Frage angegebene Ausgabeformat nicht berücksichtigt wird, kann ein Byte gespeichert werden:

!10 6?,2>{.(@*.)@%!},`\;

Dadurch werden die Primzahlen als Array (wie bei vielen anderen Lösungen) und nicht als Array pro Zeile gedruckt.

Wie es funktioniert

Die allgemeine Idee ist, den Satz von Wilson zu verwenden , der besagt, dass n > 1 genau dann Primzahl ist, wenn

!     # Push the logical NOT of the empty string (1). This is an accumulator.
10 6? # Push 10**6 = 1,000,000.
,2>   # Push [ 2 3 4 … 999,999 ].
{     # For each “N” in this array:
  .(  # Push “N - 1”.
  @   # Rotate the accumulator on top of the stack.
  *   # Multiply it with “N - 1”. The accumulator now hold “(N - 1)!”.
  .)  # Push “(N - 1)! + 1”
  @   # Rotate “N” on top of the stack.
  %!  # Push the logical NOT of “((N - 1)! + 1) % N”.
},    # Collect all “N” for which “((N - 1)! + 1) % N == 0” in an array.
n*    # Join that array by LF.
\;    # Discard the accumulator.

Benchmarks

Schneller als die Probedivision, aber langsamer als das Sieb von Eratosthenes. Siehe meine andere Antwort .

Java, 110 Bytes

void x(){for(int i=1;i++<1e6;)System.out.print(new String(new char[i]).matches(".?|(..+?)\\1+")?"":(i+"\n"));}

Verwendung der unären Division durch Regex als Primärtest.

C, 91 88 85 82 81 80 76 72 Zeichen

main(i,j,b){for(;i++<1e6;b++&&printf("%d\n",i))for(j=2;j<i;)b=i%j++&&b;}

Der Algorithmus ist schrecklich ineffizient, aber da wir Code-Golf spielen, sollte das keine Rolle spielen.

Mathematica 25

Vorausgesetzt, Sie kennen die Anzahl der Primzahlen nicht unter 10 ^ 6:

Prime@Range@PrimePi[10^6]

J, 16 Zeichen

1]\(#~1&p:)i.1e6

Ohne die Ausgabeformatanforderung kann dies auf 13 Zeichen reduziert werden :

(#~1&p:)i.1e6

1]\ Nimmt einfach das Primzahlen-Array von Rang 1, wandelt es in ein Array von Rang 2 um und platziert jedes Primzeichen in einer eigenen Zeile. Das Standardausgabeformat des Interpreters wandelt die Liste mit einer Zeile in ein Primzeichen pro Zeile um.

(#~ f) yist im Grunde filter, wo fein Boolescher Wert für jedes Element in zurückgegeben wird y. i.1e6ist der Bereich von ganzen Zahlen [0,1000000) und 1&p:ist eine boolesche Funktion, die 1 für Primzahlen zurückgibt.

R, 45 43 Zeichen

for(i in 2:1e6)if(sum(!i%%2:i)<2)cat(i," ")

Geben Sie es für jede Zahl x von 2 bis 1e6 einfach aus, wenn die Zahl von x mod 2 bis x, die gleich 0 ist, kleiner als 2 ist.

Bash (433643)

Mein (nicht so kluger) Versuch war es, das Produkt mit Faktor zu faktorisieren.

factor ${PRODUCT}

Leider ist das Produkt bei großen Stückzahlen natürlich riesig. Es dauerte auch mehr als 12 Stunden zu laufen. Ich habe mich entschieden, es zu posten, weil ich es für einzigartig hielt.

Hier ist der vollständige Code.

Wenn es Primzahlen unter sechs wären, wäre es vernünftig.

  factor 30

Na ja, ich habe es versucht.

C #, 70

Enumerable.Range(1,1e6).Where(n=>Enumerable.Range(2,n).All(x=>x%n!=0))

Sie werden hier aber für eine lange Zeit nicht viel sehen ...