Bu benim ilk kod golf sorumu ve bu konuda çok basit bir soru, bu yüzden herhangi bir topluluk kurallarını ihlal etmiş olsam, şimdiden özür dilerim.

Görev artan sırayla tüm asal sayıları bir milyondan daha az basmaktır. Çıktı formatı, çıktı satırı başına bir sayı olmalıdır.

Amaç, çoğu kod golf başvurusunda olduğu gibi, kod boyutunu en aza indirmektir. Çalışma zamanı için optimizasyon da bir bonus, ancak ikincil bir amaçtır.

Mathematica , 17 24

Sadece karşılaştırma için:

Prime@Range@78498

Bir yorumda belirtildiği gibi, her satırda bir asal sayı sağlamadım; düzeltme:

Column@Prime@Range@78498

Python 3, 46 bayt

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

Döngü sınamaya ulaştığında k, kare-faktörü yinelemeli olarak hesaplamıştır P=(k-1)!^2. Eğer kasal, o zaman üründe görünmüyor 1 * 2 * ... * (k-1), bu yüzden bir faktör değil P. Ancak, eğer kompozit ise, tüm asal faktörleri üründe daha küçüktür. Kare alma sadece k=4sahte olarak asal olarak adlandırılmaması için gereklidir .

Daha da kuvvetli, Wilson'un Teoreminden sonra kasal olduğunda P%keşittir demektir 1. Burada sadece sıfır olmadığına rağmen, genel olarak asal P%kolup olmadığına dair bir gösterge değişkeni olması faydalıdır k.

C, 61 karakter

Neredeyse tam olarak bu aynı (soru da tamamen aynıdır).

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

MATLAB (16) (12)

Ne yazık ki, bu tek bir satırda çıkıyor:

primes(1000000)

ama bu basit bir matris devrik tarafından çözülür:

primes(1000000)'

ve bazı karakterleri üstel gösterim kullanarak (yorumlarda önerildiği şekilde) kesebilirim:

primes(1e6)'

Bash (37 karakter)

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

(60 karakter)

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

bilgisayarımda (2.0 GHz işlemci, 2 GB ram) 14 saniye sürüyor.

J, 21 karakter

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

kısaltılabilir

1[\p:i.78498

1000000'ün altında kaç tane primer olduğunu biliyorsanız.

PowerShell, 47 44 bayt

Çok yavaş, ama bulabildiğim en kısa sürede.

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

PowerShell, 123 bayt

Bu çok daha hızlı; optimal olmaktan uzak, ancak verimlilik ve kısalık arasında iyi bir uzlaşma.

 $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

Yakut 34

require'prime';p Prime.take 78498

Bash, 30 bayt

Yana saeedn onun yaklaşımından daha kısa ve daha hızlı olduğunu - - benim öneri harekete geçmez Ben kendi yanıt sonrası düşündüm:

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

Nasıl çalışır

seq 1e6

1.000.000'a kadar tüm pozitif tamsayıları listeler.

factor

tek tek onları faktörler. İlk on için, çıktı aşağıdaki gibidir:

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

En sonunda,

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

çizginin tamamını ( $0) ikinci alanın ürününe (ilk ana faktör) ve üçüncü alanın mantıksal olumsuzluğuna ( 1eğer bir ana faktör ya da daha azsa 0) değiştirir.

Bu, asal sayılara karşılık gelen satırları, sayının kendisiyle ve diğer tüm satırları sıfırlarla değiştirir. Awk yalnızca truthy değerleri yazdırdığından, yalnızca asal sayı yazdırılır.

Ruby 50 41

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

Bash, 37

Daha çok golf oynayabilirsem ...

Bunun çoğu factorgarip çıktı biçimini ayrıştırmaya çalışıyor .

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

Makinemde tamamlanması 5.7 saniye sürüyor.

(Sadece bu oldu benim konu en birinci ... cevapların ikinci sayfasında gitmek, bu yüzden kimse bunu görecek)

Eski çözüm

Bu daha uzun ve daha yavaş (10 saniye sürer).

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

Python 3.x: 66 karakter

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

Daha verimli çözüm: 87 karakter

Eratostenlerin Eleklerine Göre.

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

Tercümanım hafıza problemleriyle karşılaştı, ama teoride çalışıyor.

Perl, 49 bayt

Düzenli ifade kung fu :)

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

Ungolfed versiyonu:

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

Bu yazıyı yazarken bile% 10 ilerleme kaydetmedi!

Regex'in kaynağı: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

Julia, 11

primes(10^6)

Görünüşe göre yerleşik ins upvotes, artı daha uzun cevaplar için daha fazla kelime gerekiyordu.

J (15 veya 9)

Bu Mathematica'yı yendiğine inanamıyorum ( 2 karakterlik bir single olsa bile )

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

Veya:

p:i.78498

gs2, 5 bayt

CP437'de kodlanmış:

∟)◄lT

1C 29bir milyonu zorlar 11 6C, asalları aşağıdadır, 54şov çizgileridir.

GolfScript, 22/20 (20/19) bayt

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

Hız pahasına, kod iki bayt daha kısa yapılabilir:

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

Düzenlenen soruda belirtilen çıktı formatı göz ardı edilirse (mevcut cevapların çoğu budur), hızlı sürümde iki bayt kaydedilebilir ve yavaş olana bir tanesi kaydedilebilir:

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

Bu, hızlı sürüm için hazırlayıcılardan sonra ek bir LF yazdıracak ve hazırlıkları yavaş olan için bir dizi olarak yazacaktır.

Nasıl çalışır

Her iki versiyon da , Eratosthenes elek uygulamalarıdır .

Hızlı versiyon aşağıdakileri yapar:

1. Set A = [ 2 3 4 … 999,999 ]ve | = [ 0 1 2 … 999,999 ].

2. Ayarla N = A[0]ve yazdır N.

3. Her n'ninci elemanı toplamak |içinde C. Bunlar katları N.

4. Set A = A - C.

5. ABoş değilse , 2'ye geri dönün.

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.

Yavaş versiyon benzer şekilde çalışır, ancak “A” minimum katlarını (her zaman asal olan) art arda kaldırmak yerine, 1.000.000'in altındaki tüm pozitif tamsayıların katlarını kaldırır.

Rekabet

İlkelliği çarpanlara ayırmak ya da kontrol etmek için herhangi bir yerleşik matematiksel işlev yoksa, tüm GolfScript çözümleri ya çok büyük ya da çok verimsiz olacaktır.

Hala verimli olmaktan uzak olsa da, iyi bir hız / boyut oranına ulaştığımı düşünüyorum. Sunulduğu tarihte, bu yaklaşım, yukarıda belirtilen yerleşiklerin hiçbirini kullanmayanların en kısa olduğu görülmektedir. Diyorum görünüyor ben bazı yanıtlar nasıl çalıştığını hiçbir fikrim yok çünkü ...

Gönderilen dört GolfScript çözümünün hepsini kıyaslamıştım: w0lf's (deneme bölümü), diğer cevabım (Wilson teoremi) ve bu cevabın ikisi. Sonuçlar bunlardı:

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 karakter

⍸0π⍳1e6

Golf Betiği 26 25 24

Düzenleme (Peter Taylor sayesinde bir karakter daha kaydetti):

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

Eski kod:

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

Bu kod, inanılmaz derecede yavaş ve verimsiz olduğu için yalnızca teorik değere sahiptir. Çalıştırmanın saatler alabileceğini düşünüyorum.

Test etmek istiyorsanız, örneğin sadece 100'e kadar olan astarları deneyin:

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

CJam - 11

1e6,{mp},N*

1e6,- 0 ... 999999 dizisi
{mp},- asal sayıları seç
N*- yeni satırlara katıl

GolfScript, 25 (24) bayt

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

Düzenlenen soruda belirtilen çıktı formatı göz ardı edilirse, bir bayt kaydedilebilir:

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

Bu, astarları, her satırda bir diziden ziyade bir dizi olarak (diğer birçok çözümde olduğu gibi) basacaktır.

Nasıl çalışır

Genel düşünce kullanmaktır Wilson'un teoremini belirtiyor, n > 1 asal ve ancak eğer

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

Deneyler

Deneme bölümünden daha hızlı, ancak Eratosthenes'in eleklerinden daha yavaş. Diğer cevabımı gör .

Java, 110 bayt

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

İlkellik testi olarak regex aracılığıyla unary bölmeyi kullanma.

C, 91 88 85 82 81 80 76 72 karakter

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

Algoritma son derece verimsiz, ancak önemli olmaması gereken kod-golf yaptığımızdan.

Mathematica 25

Asıl sayıyı 10 ^ 6'dan az bilmediğinizi varsayarsak:

Prime@Range@PrimePi[10^6]

J, 16 karakter

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

Çıkış formatı gereksinimi olmadan, bu 13 karaktere düşürülebilir :

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

1]\ sadece bir priming dizisi rütbesini alır, onu bir rütbe 2 dizisine çevirir ve her bir üssü kendi satırına koyar - ve böylece tercümanın varsayılan çıktı biçimi, bir satır listesini her satır için bir üsse dönüştürür.

(#~ f) ytemelde filter, fiçindeki her öğe için bir boole döndürür y. i.1e6tamsayıların aralığıdır (0,1000000) ve primerler 1&p:için 1 döndüren bir boolean işlevdir.

R, 45 43 karakter

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

2'den 1e6'ya kadar olan her x sayısı için, yalnızca x'e eşit olan x mod 2 - x sayısı 2'den küçükse, çıktı verin.

Bash (433643)

Benim (o kadar akıllıca olmayan) denemem, ürünü etkilemek için faktör kullanmaktı.

factor ${PRODUCT}

Ne yazık ki, büyük sayılarla ürün elbette çok büyük. Ayrıca çalıştırmak için 12 saatten fazla sürdü. Yine de göndermeye karar verdim çünkü eşsiz olduğunu düşündüm.

İşte tam kod.

Altı yaşın altındaki asal sayılırsa makul olur.

  factor 30

Oh, denedim.

C #, 70

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

Uzun süredir burada çok fazla görmeyeceksin ...