C’est ma première question, très simple, et je m’excuse d’avance si j’ai enfreint les directives de la communauté.

La tâche consiste à imprimer, par ordre croissant, tous les nombres premiers inférieurs à un million. Le format de sortie doit être un nombre par ligne de sortie.

Comme avec la plupart des soumissions de codes de golf, l'objectif est de minimiser la taille du code. L'optimisation pour l'exécution est également un bonus, mais est un objectif secondaire.

Mathematica , 17 24

Juste pour comparaison:

Prime@Range@78498

Comme indiqué dans un commentaire, j’ai omis de fournir un nombre premier par ligne; correction:

Column@Prime@Range@78498

Python 3, 46 octets

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

Au moment où la boucle atteint le test k, elle a calculé de manière itérative le facteur carré P=(k-1)!^2. Si kprime est alors, il n'apparaît pas dans le produit 1 * 2 * ... * (k-1), donc ce n'est pas un facteur de P. Mais, si c'est composite, tous ses facteurs premiers sont plus petits et donc dans le produit. La quadrature n'est en réalité nécessaire que pour ne k=4pas s'appeler faussement premier.

Plus fortement, il découle du théorème de Wilson que quand kest premier, P%kégal 1. Bien que nous ayons seulement besoin que ce soit non nul ici, il est utile en général d’ P%kêtre une variable indicatrice pour savoir si kprime.

C, 61 caractères

Presque exactement le même que celui-ci (la question est presque aussi identique).

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

MATLAB (16) (12)

Malheureusement, cette sortie sur une seule ligne:

primes(1000000)

mais cela se résout par une simple matrice transposée:

primes(1000000)'

et je peux couper certains caractères en utilisant la notation exponentielle (comme suggéré dans les commentaires):

primes(1e6)'

Bash (37 caractères)

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

(60 caractères)

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

sur mon ordinateur (2,0 GHz, 2 Go de RAM) prend 14 secondes.

J, 21 caractères

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

qui peut être raccourci à

1[\p:i.78498

Si vous savez combien de nombres premiers sont inférieurs à 1000000.

PowerShell, 47 à 44 octets

Très lent, mais le plus court possible.

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

PowerShell, 123 octets

C'est beaucoup plus rapide. loin d'être optimal, mais un bon compromis entre efficacité et brièveté.

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

Étant donné que saeedn ne veut pas agir sur ma suggestion - qui est à la fois plus court et plus rapide que son approche - je pensais que je poste ma propre réponse:

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

Comment ça fonctionne

seq 1e6

liste tous les entiers positifs jusqu’à 1.000.000.

factor

les facteurs un par un. Pour les dix premiers, le résultat est le suivant:

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

Finalement,

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

change la ligne entière ( $0) en le produit du deuxième champ (le premier facteur premier) et la négation logique du troisième champ ( 1s'il s'agit d'un facteur premier ou moins, 0sinon).

Ceci remplace les lignes correspondant aux nombres premiers par le nombre lui-même et toutes les autres lignes par des zéros. Puisque awk n’imprime que les valeurs de vérité, seul le nombre premier sera imprimé.

Ruby 50 41

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

Bash, 37 ans

Je jouerai plus au golf, si je peux ...

La plupart de ceci essaie d'analyser factorle format de sortie peu commode.

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

Prend environ 5,7 secondes sur ma machine.

(Il se trouve que mon message a été le premier à figurer sur la deuxième page de réponses, alors personne ne le verra ...)

Ancienne solution

C'est plus long et plus lent (prend 10 secondes).

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

Python 3.x: 66 caractères

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

Solution plus efficace: 87 caractères

Basé sur le tamis d'Eratosthène.

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 ans

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

APL, 15

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

Mon interprète a eu des problèmes de mémoire, mais cela fonctionne en théorie.

Perl, 49 octets

Expression régulière kung fu :)

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

Version non-golfée:

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

Il n'a même pas fait 10% de progrès pendant que je tape ce post!

Source pour l'expression régulière: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

Julia, 11 ans

primes(10^6)

Il semble que les utilisateurs intégrés obtiennent des votes positifs. De plus, j'avais besoin de plus de mots pour une réponse plus longue.

J (15 ou 9)

Je n'arrive pas à croire que Mathematica a battu (même s'il ne s'agit que d' un single avec 2 caractères)

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

Ou:

p:i.78498

gs2, 5 octets

Encodé dans CP437:

∟)◄lT

1C 29pousse un million, 11 6Cest des nombres premiers en dessous, 54est montrer des lignes.

GolfScript, 22/20 (20/19) octets

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

Au prix de la vitesse, le code peut être raccourci de deux octets:

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

Si le format de sortie spécifié dans la question modifiée n'est pas pris en compte (ce que font beaucoup de réponses existantes), deux octets peuvent être enregistrés dans la version rapide et un dans la version lente:

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

Cela imprimera un LF supplémentaire après les nombres premiers pour la version rapide et les nombres premiers comme un tableau pour la version lente.

Comment ça fonctionne

Les deux versions sont des implémentations du tamis d'Eratosthène .

La version rapide fait ce qui suit:

1. Définir A = [ 2 3 4 … 999,999 ]et | = [ 0 1 2 … 999,999 ].

2. Définir N = A[0]et imprimer N.

3. Recueillir tous les N-ième élément de |dans C. Ce sont les multiples de N.

4. Ensemble A = A - C.

5. Si Anon vide, retournez à 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 version lente fonctionne de la même manière, mais au lieu de supprimer successivement les multiples du minimum de «A» (toujours premier), elle supprime les multiples de tous les entiers positifs inférieurs à 1 000 000.

Compétitivité

En l'absence de fonctions mathématiques intégrées permettant de factoriser ou de vérifier la primalité, toutes les solutions GolfScript seront très volumineuses ou très inefficaces.

Bien que loin d'être efficace, je pense avoir atteint un rapport vitesse / taille décent. Au moment de sa présentation, cette approche semble être la plus courte parmi celles qui n’utilisent aucun des éléments incorporés susmentionnés. Je dis semble parce que je ne sais pas du tout comment certaines des réponses fonctionnent ...

J'ai comparé les quatre solutions GolfScript présentées: w0lf (division d'essai), mon autre réponse (théorème de Wilson) et les deux de cette réponse. Ce sont les résultats:

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 caractères

⍸0π⍳1e6

Golfscript 26 25 24

Edit (enregistré un caractère supplémentaire grâce à Peter Taylor):

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

Ancien code:

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

Ce code n'a qu'une valeur théorique, car il est incroyablement lent et inefficace. Je pense que cela pourrait prendre des heures à courir.

Si vous souhaitez le tester, essayez par exemple uniquement les nombres premiers allant jusqu'à 100:

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

CJam - 11

1e6,{mp},N*

1e6,- tableau de 0 ... 999999
{mp},- certains nombres premiers
N*- rejoindre les nouvelles lignes

GolfScript, 25 (24) octets

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

Si le format de sortie spécifié dans la question modifiée n'est pas pris en compte, un octet peut être enregistré:

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

Cela imprimera les nombres premiers sous forme de tableau (comme le font de nombreuses autres solutions) plutôt qu’un par ligne.

Comment ça fonctionne

L'idée générale est d'utiliser le théorème de Wilson , qui stipule que n > 1 est premier si et seulement si

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

Des repères

Plus rapide que la division d'essai, mais plus lent que le tamis d'Eratosthenes. Voir mon autre réponse .

Java, 110 octets

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

Utilisation de la division unaire par regex comme test de primalité.

C, 91 88 85 82 81 80 76 72 caractères

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

L'algorithme est terriblement inefficace, mais puisque nous faisons du golf-code, cela ne devrait pas avoir d'importance.

Mathematica 25

En supposant que vous ne connaissiez pas le nombre de nombres premiers inférieurs à 10 ^ 6:

Prime@Range@PrimePi[10^6]

J, 16 caractères

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

Sans l'exigence de format de sortie, cela peut être réduit à 13 caractères:

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

1]\ prend juste le tableau de rang 1 de nombres premiers, le transforme en tableau de rang 2 et met chaque nombre premier sur sa propre ligne - et ainsi le format de sortie par défaut de l'interprète transforme la liste d'une ligne en un nombre premier par ligne.

(#~ f) yest fondamentalement filter, où fretourne un booléen pour chaque élément de y. i.1e6est la plage d'entiers [0,1000000), et 1&p:est une fonction booléenne qui renvoie 1 pour les nombres premiers.

R, 45 43 caractères

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

Pour chaque nombre x compris entre 2 et 1e6, indiquez-le simplement si le nombre de x mod 2 à x égal à 0 est inférieur à 2.

Bash (433643)

Ma tentative (pas si intelligente) consistait à utiliser facteur pour factoriser le produit.

factor ${PRODUCT}

Malheureusement, avec de grands nombres, le produit est bien sûr énorme. Il a également fallu plus de 12 heures pour courir. J'ai décidé de le poster car je pensais que c'était unique.

Voici le code complet.

S'il s'agissait de nombres premiers inférieurs à six ans, ce serait raisonnable.

  factor 30

Oh bien, j'ai essayé.

C #, 70

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

Vous ne verrez pas grand chose ici pendant très longtemps ...