Esta é a minha primeira pergunta sobre código de golfe, e uma pergunta muito simples, por isso peço desculpas antecipadamente por ter quebrado as diretrizes da comunidade.

A tarefa é imprimir, em ordem crescente, todos os números primos menores que um milhão. O formato de saída deve ser um número por linha de saída.

O objetivo, como na maioria dos envios de código de golfe, é minimizar o tamanho do código. A otimização para o tempo de execução também é um bônus, mas é um objetivo secundário.

Mathematica , 17 24

Apenas para comparação:

Prime@Range@78498

Como observado em um comentário, falhei em fornecer um número primo por linha; correção:

Column@Prime@Range@78498

Python 3, 46 bytes

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

No momento em que o loop chega ao teste k, ele iterativamente calculou o fatorial ao quadrado P=(k-1)!^2. Se kfor primo, não aparecerá no produto 1 * 2 * ... * (k-1), portanto não é um fator de P. Mas, se for composto, todos os seus principais fatores são menores e, portanto, no produto. A quadratura só é realmente necessária para parar k=4de ser falsamente chamada de primo.

Mais fortemente, segue-se do teorema de Wilson que quando ké primo, P%ké igual 1. Embora apenas precisemos que seja diferente de zero aqui, é útil, em geral, que P%kseja uma variável indicadora de se ké primo.

C, 61 caracteres

Quase exatamente o mesmo que este (a questão também é quase exatamente a mesma).

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

MATLAB (16) (12)

Infelizmente, isso gera uma única linha:

primes(1000000)

mas isso é resolvido por uma simples transposição de matriz:

primes(1000000)'

e posso recortar alguns caracteres usando notação exponencial (como sugerido nos comentários):

primes(1e6)'

Bash (37 caracteres)

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

(60 caracteres)

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

no meu computador (CPU de 2,0 GHz, 2 GB de RAM) leva 14 segundos.

J, 21 caracteres

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

que pode ser reduzido para

1[\p:i.78498

se você souber quantos números primos existem abaixo de 1000000.

PowerShell, 47 44 bytes

Muito lento, mas o mais curto que consegui.

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

PowerShell, 123 bytes

Isso é muito mais rápido; longe de ser o ideal, mas um bom compromisso entre eficiência e brevidade.

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

Como saeedn não vai agir de acordo com minha sugestão - que é mais curta e mais rápida que a abordagem dele -, pensei em postar minha própria resposta:

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

Como funciona

seq 1e6

lista todos os números inteiros positivos até 1.000.000.

factor

fatores-los um por um. Para os dez primeiros, a saída é a seguinte:

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'

altera a linha inteira ($0 ) para o produto do segundo campo (o primeiro fator primo) e a negação lógica do terceiro campo ( 1se for um fator primo ou menos, 0caso contrário).

Isso substitui as linhas correspondentes aos números primos pelo próprio número e todas as outras linhas pelos zeros. Como o awk imprime apenas valores reais, apenas o número principal será impresso.

Ruby 50 41

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

Bash, 37

Golf mais, se eu puder ...

A maior parte disso está tentando analisar factoro formato de saída estranho.

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

Leva 5,7 ou mais segundos para concluir na minha máquina.

(Aconteceu que o meu post foi o primeiro a ir para a segunda página de respostas, então ninguém vai vê-lo ...)

Solução antiga

Isso é mais longo e mais lento (leva 10 segundos).

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

Python 3.x: 66 caracteres

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

Solução mais eficiente: 87 caracteres

Baseado na peneira de Eratóstenes.

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

Meu intérprete teve problemas de memória, mas funciona em teoria.

Perl, 49 bytes

Expressão regular kung fu :)

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

Versão não destruída:

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

Nem sequer fez 10% de progresso enquanto digito este post!

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

Julia, 11

primes(10^6)

Parece que os ins internos estão recebendo votos positivos, e eu precisava de mais palavras para obter respostas mais longas.

J (15 ou 9)

Eu não posso acreditar nessa batida do Mathematica (mesmo que seja apenas um por 2 caracteres)

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

Ou:

p:i.78498

gs2, 5 bytes

Codificado no CP437:

∟)◄lT

1C 29empurra um milhão, 11 6Cé primos abaixo, 54é mostra linhas.

GolfScript, 22/20 (20/19) bytes

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

À custa da velocidade, o código pode ser reduzido em dois bytes:

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

Se o formato de saída especificado na pergunta editada for desconsiderado (que é o que muitas das respostas existentes fazem), dois bytes podem ser salvos na versão rápida e um na versão lenta:

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

Isso imprimirá um LF adicional após os primos da versão rápida e os primos como uma matriz do lento.

Como funciona

Ambas as versões são implementações da peneira de Eratóstenes .

A versão rápida faz o seguinte:

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

2. Conjunto N = A[0] e imprimir N.

3. Colete todos os N-ésimos elementos de | dentro C. Estes são os múltiplos de N.

4. Set A = A - C.

5. Se Anão estiver vazio, volte para 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.

A versão lenta funciona de maneira semelhante, mas, em vez de remover sucessivamente múltiplos do mínimo de "A" (que é sempre primo), remove múltiplos de todos os números inteiros positivos abaixo de 1.000.000.

Competitividade

Na ausência de funções matemáticas embutidas para fatorar ou verificar a primalidade, todas as soluções GolfScript serão muito grandes ou muito ineficientes.

Embora ainda esteja longe de ser eficiente, acho que atingi uma proporção decente de velocidade / tamanho. No momento da submissão, essa abordagem parece ser a mais curta entre as que não usam nenhum dos embutidos mencionados acima. Eu digo parece que não tenho ideia de como algumas das respostas funcionam ...

Comparei todas as quatro soluções GolfScript enviadas: w0lf (divisão de teste), minha outra resposta (teorema de Wilson) e as duas respostas. Estes foram os resultados:

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 caracteres

⍸0π⍳1e6

Golfscript 26 25 24

Editar (salvou mais um caractere graças a Peter Taylor):

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

Código antigo:

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

Este código tem apenas valor teórico, pois é incrivelmente lento e ineficiente. Eu acho que pode levar horas para correr.

Se você deseja testá-lo, tente, por exemplo, apenas os números primos de até 100:

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

CJam - 11

1e6,{mp},N*

1e6,- matriz de 0 ... 999999
{mp},- selecione números primos
N*- junte-se a novas linhas

GolfScript, 25 (24) bytes

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

Se o formato de saída especificado na pergunta editada for desconsiderado, um byte poderá ser salvo:

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

Isso imprimirá os números primos como uma matriz (como muitas outras soluções) em vez de uma por linha.

Como funciona

A idéia geral é usar o teorema de Wilson , que afirma que n > 1 é primo se e somente 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.

Benchmarks

Mais rápido que a divisão experimental, mas mais lento que a peneira de Eratóstenes. Veja minha outra resposta .

Java, 110 bytes

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

Usando a divisão unária através do regex como um teste de primalidade.

C, 91 88 85 82 81 80 76 72 caracteres

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

O algoritmo é terrivelmente ineficiente, mas, como estamos praticando golfe de código, isso não deve importar.

Mathematica 25

Supondo que você não saiba o número de primos menor que 10 ^ 6:

Prime@Range@PrimePi[10^6]

J, 16 caracteres

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

Sem o requisito de formato de saída, isso pode ser reduzido para 13 caracteres:

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

1]\ apenas pega a matriz de primos de classificação 1, transforma-a em uma matriz de classificação 2 e coloca cada primo em sua própria linha - e, assim, o formato de saída padrão do intérprete transforma a lista de uma linha em um primo por linha.

(#~ f) yé basicamente filter, onde fretorna um booleano para cada elemento em y. i.1e6é o intervalo de números inteiros [0,1000000) e 1&p:é uma função booleana que retorna 1 para números primos.

R, 45 43 caracteres

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

Para cada número x de 2 a 1e6, basta imprimi-lo se o número de x mod 2 a x iguais a 0 for menor que 2.

Bash (433643)

Minha tentativa (não tão inteligente) foi usar o fator para fatorar o produto.

factor ${PRODUCT}

Infelizmente, com grandes números, o produto é obviamente enorme. Também levou mais de 12 horas para ser executado. Decidi publicá-lo porque achei que era único.

Aqui está o código completo.

Se fosse primos com menos de seis anos, seria razoável.

  factor 30

Oh, bem, eu tentei.

C #, 70

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

Você não verá muito aqui por muito tempo ...