Questa è la mia prima domanda sul golf del codice, e molto semplice, quindi mi scuso in anticipo se potrei aver infranto qualsiasi linea guida della comunità.

Il compito è di stampare, in ordine crescente, tutti i numeri primi meno di un milione. Il formato di output dovrebbe essere un numero per riga di output.

Lo scopo, come per la maggior parte degli invii di golf di codice, è di ridurre al minimo le dimensioni del codice. Anche l'ottimizzazione per il runtime è un vantaggio, ma è un obiettivo secondario.

Mathematica , 17 24

Solo per confronto:

Prime@Range@78498

Come notato in un commento, non sono riuscito a fornire un numero primo per riga; correzione:

Column@Prime@Range@78498

Python 3, 46 byte

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

Quando il ciclo raggiunge il test k, ha iterativamente calcolato il fattoriale quadrato P=(k-1)!^2. Se kè primo, allora non appare nel prodotto 1 * 2 * ... * (k-1), quindi non è un fattore di P. Ma, se è composto, tutti i suoi fattori primi sono più piccoli e quindi nel prodotto. La quadratura è effettivamente necessaria solo per k=4evitare di essere falsamente chiamata primo.

Più fortemente, dal teorema di Wilson segue che quando kè primo è P%kuguale 1. Anche se qui abbiamo solo bisogno che sia diverso da zero, è utile in generale che P%ksia una variabile indicatore per stabilire se kè primo.

C, 61 caratteri

Quasi esattamente uguale a questo (la domanda è quasi esattamente la stessa).

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

MATLAB (16) (12)

Sfortunatamente, questo emette su una sola riga:

primes(1000000)

ma questo è risolto da una semplice trasposizione matriciale:

primes(1000000)'

e posso ritagliare alcuni caratteri usando la notazione esponenziale (come suggerito nei commenti):

primes(1e6)'

Bash (37 caratteri)

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

(60 caratteri)

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

sul mio computer (2,0 GHz cpu, 2 GB di RAM) richiede 14 secondi.

J, 21 caratteri

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

che può essere abbreviato in

1[\p:i.78498

se sai quanti numeri primi sono inferiori a 1000000.

PowerShell, 47 44 byte

Molto lento, ma il più breve che potessi inventare.

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

PowerShell, 123 byte

Questo è molto più veloce; tutt'altro che ottimale, ma un buon compromesso tra efficienza e brevità.

 $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

Ruby 34

require'prime';p Prime.take 78498

Bash, 30 byte

Dato che saeedn non agirà in base al mio suggerimento - che è sia più breve che più veloce del suo approccio - ho pensato di pubblicare la mia risposta:

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

Come funziona

seq 1e6

elenca tutti i numeri interi positivi fino a 1.000.000.

factor

li fattori uno per uno. Per i primi dieci, l'output è il seguente:

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

Finalmente,

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

cambia l'intera riga ( $0) nel prodotto del secondo campo (il primo fattore primo) e la negazione logica del terzo campo ( 1se è un fattore primo o inferiore, 0altrimenti).

Questo sostituisce le linee corrispondenti ai numeri primi con il numero stesso e tutte le altre linee con zeri. Poiché awk stampa solo i valori di verità, verrà stampato solo il numero primo.

Ruby 50 41

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

Bash, 37

Golferà di più, se posso ...

La maggior parte di questi sta cercando di analizzare factoril formato di output scomodo.

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

Ci vogliono circa 5,7 secondi per completare sulla mia macchina.

(È appena successo che il mio post è stato il primo ad andare nella seconda pagina di risposte, quindi nessuno lo vedrà ...)

Vecchia soluzione

Questo è più lungo e più lento (richiede 10 secondi).

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

Python 3.x: 66 caratteri

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

Soluzione più efficiente: 87 caratteri

Basato sul setaccio di Eratostene.

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

Il mio interprete ha riscontrato problemi di memoria, ma funziona in teoria.

Perl, 49 byte

Espressione regolare kung fu :)

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

Versione non golfata:

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

Non ho nemmeno fatto progressi del 10% mentre scrivo questo post!

Fonte per il regex: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

Julia, 11

primes(10^6)

Sembra che i built-in ottengano voti, inoltre ho bisogno di più parole per una risposta più lunga.

J (15 o 9)

Non posso credere a questo battito di Mathematica (anche se è solo un singolo da 2 caratteri)

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

O:

p:i.78498

gs2, 5 byte

Codificato in CP437:

∟)◄lT

1C 29spinge un milione, 11 6Cè numeri primi in basso, 54è linee di spettacolo.

GolfScript, 22/20 (20/19) byte

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

A scapito della velocità, il codice può essere ridotto di due byte:

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

Se il formato di output specificato nella domanda modificata viene ignorato (che è ciò che fanno molte delle risposte esistenti), due byte possono essere salvati nella versione veloce e uno può essere salvato in quella lenta:

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

Questo stamperà un ulteriore LF dopo i numeri primi per la versione veloce e stamperà i numeri primi come un array per quello lento.

Come funziona

Entrambe le versioni sono implementazioni del setaccio di Eratostene .

La versione veloce effettua le seguenti operazioni:

1. Imposta A = [ 2 3 4 … 999,999 ]e | = [ 0 1 2 … 999,999 ].

2. Imposta N = A[0]e stampa N.

3. Raccogli tutti gli elementi dell'N-esimo da |dentro C. Questi sono i multipli di N.

4. Set A = A - C.

5. Se Anon è vuoto, tornare a 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.

La versione lenta funziona in modo simile, ma invece di rimuovere successivamente multipli del minimo di "A" (che è sempre primo), rimuove i multipli di tutti gli interi positivi inferiori a 1.000.000.

Competitività

In assenza di funzioni matematiche integrate per la fattorizzazione o il controllo della primalità, tutte le soluzioni GolfScript saranno molto grandi o molto inefficienti.

Pur essendo tutt'altro che efficiente, penso di aver raggiunto un discreto rapporto velocità-dimensioni. Al momento della sua presentazione, questo approccio sembra essere il più breve di quelli che non utilizzano nessuno dei summenzionati incorporati. Dico sembra perché non ho idea di come funzionano alcune delle risposte ...

Ho analizzato tutte e quattro le soluzioni GolfScript presentate: w0lf (divisione di prova), l'altra mia risposta (teorema di Wilson) e le due di questa risposta. Questi erano i risultati:

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 caratteri

⍸0π⍳1e6

Golfscript 26 25 24

Modifica (salvato un altro carattere grazie a Peter Taylor):

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

Vecchio codice:

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

Questo codice ha solo un valore teorico, in quanto è incredibilmente lento e inefficiente. Penso che potrebbero volerci ore per correre.

Se desideri provarlo, prova ad esempio solo i numeri primi fino a 100:

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

CJam - 11

1e6,{mp},N*

1e6,- matrice di 0 ... 999999
{mp},- seleziona numeri primi
N*- unisciti con le nuove linee

GolfScript, 25 (24) byte

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

Se il formato di output specificato nella domanda modificata viene ignorato, è possibile salvare un byte:

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

Questo stamperà i numeri primi come un array (come fanno molte altre soluzioni) anziché uno per riga.

Come funziona

L'idea generale è di usare il teorema di Wilson , che afferma che n > 1 è il primo se e solo se

!     # 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.

benchmark

Più veloce della divisione di prova, ma più lento del setaccio di Eratostene. Vedi la mia altra risposta .

Java, 110 byte

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

Utilizzo della divisione unaria tramite regex come test di primalità.

C, 91 88 85 82 81 80 76 72 caratteri

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

L'algoritmo è terribilmente inefficiente, ma dal momento che stiamo facendo code-golf non dovrebbe importare.

Mathematica 25

Supponendo di non conoscere il numero di numeri primi inferiori a 10 ^ 6:

Prime@Range@PrimePi[10^6]

J, 16 caratteri

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

Senza il requisito del formato di output, questo può essere ridotto a 13 caratteri:

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

1]\ prende semplicemente l'array di numeri primi di rango 1, lo trasforma in un array di livello 2 e mette ciascun numero primo sulla propria riga - e quindi il formato di output predefinito dell'interprete trasforma l'elenco di una riga in un numero primo per riga.

(#~ f) yè fondamentalmente filter, dove frestituisce un valore booleano per ogni elemento in y. i.1e6è l'intervallo di numeri interi [0,1000000) ed 1&p:è una funzione booleana che restituisce 1 per i numeri primi.

R, 45 43 caratteri

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

Per ogni numero x da 2 a 1e6, è sufficiente emetterlo se il numero di x mod da 2 a x che è uguale a 0 è inferiore a 2.

Bash (433643)

Il mio (non così intelligente) tentativo era di utilizzare il fattore per fattorizzare il prodotto.

factor ${PRODUCT}

Sfortunatamente con grandi numeri il prodotto è ovviamente enorme. Ci sono volute anche più di 12 ore per l'esecuzione. Ho deciso di pubblicarlo perché pensavo fosse unico.

Ecco il codice completo.

Se fossero numeri primi sotto i sei sarebbe ragionevole.

  factor 30

Oh bene, ci ho provato.

C #, 70

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

Non vedrai molto qui per molto tempo ...