이것은 첫 번째 코드 골프 질문이며 매우 간단한 질문이므로 커뮤니티 지침을 위반했을 경우 미리 사과드립니다.

이 작업은 백만 미만의 모든 소수를 오름차순으로 인쇄하는 것입니다. 출력 형식은 출력 라인 당 하나의 숫자 여야합니다.

대부분의 코드 골프 제출과 마찬가지로 목표는 코드 크기를 최소화하는 것입니다. 런타임 최적화도 보너스이지만 보조 목표입니다.

매스 매 티카 , 17 24

비교를 위해 :

Prime@Range@78498

의견에서 언급했듯이 나는 한 줄에 하나의 소수를 제공하지 못했습니다. 보정:

Column@Prime@Range@78498

파이썬 3, 46 바이트

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

루프가 테스트 k에 도달 할 때까지 반복적으로 제곱 인자를 계산했습니다 P=(k-1)!^2. k소수 인 경우 제품에 나타나지 1 * 2 * ... * (k-1)않으므로의 요인이 아닙니다 P. 그러나 복합 재료라면 제품의 모든 주요 요소가 더 작습니다. 제곱은 실제로 k=4소위 소수라고 불릴 필요가 없습니다 .

더 강력하게, 그것은 윌슨의 정리에 따르면 k소수 일 때 P%k와 같다 1. 여기서는 0이 아닌 것만 필요하지만 일반적으로 소수 P%k인지 여부를 나타내는 지표 변수 인 것이 유용합니다 k.

C, 61 자

거의 정확히 같은 이 하나 (질문도 거의 동일하다).

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

MATLAB (16) (12)

불행히도 이것은 한 줄로 출력됩니다.

primes(1000000)

그러나 이것은 간단한 매트릭스 전치로 해결됩니다.

primes(1000000)'

그리고 주석에서 제안한 것처럼 지수 표기법을 사용하여 일부 문자를 잘라낼 수 있습니다.

primes(1e6)'

배쉬 (37 자)

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

(60 자)

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

내 컴퓨터 (2.0GHz CPU, 2GB 램)에서 14 초가 걸립니다.

J, 21 자

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

단축 될 수있는

1[\p:i.78498

소수가 몇 개인 지 알면 1000000 미만입니다.

PowerShell, 47 44 바이트

매우 느리지 만, 가장 짧은 것은 생각해 낼 수 있습니다.

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

PowerShell, 123 바이트

이것은 훨씬 빠릅니다. 최적과는 거리가 멀지 만 효율성과 간결함 사이의 좋은 절충안입니다.

 $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

루비 34

require'prime';p Prime.take 78498

배쉬, 30 바이트

saeedn 은 그의 제안보다 짧고 빠른 내 제안에 따라 행동하지 않기 때문에 본인의 답변을 게시 할 것이라고 생각했습니다.

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

작동 원리

seq 1e6

최대 1,000,000까지 모든 양의 정수를 나열합니다.

factor

그것들을 하나씩 팩터링합니다. 처음 10 개의 출력은 다음과 같습니다.

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

드디어,

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

전체 행 ( $0)을 두 번째 필드의 곱 (첫 번째 소인수)과 세 번째 필드의 논리적 부정으로 변경합니다 ( 1하나의 소인수 이하인 0경우).

이것은 소수에 해당하는 줄을 숫자로 바꾸고 다른 모든 줄은 0으로 바꿉니다. awk는 정확한 값만 인쇄하므로 소수만 인쇄됩니다.

루비 50 41

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

배쉬, 37

내가 할 수 있다면 더 골프를 할 것인가 ...

이것의 대부분은 factor어색한 출력 형식 을 구문 분석하려고 합니다.

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

내 컴퓨터에서 완료하는 데 5.7 초 정도 걸립니다.

(방금 내 게시물이 두 번째 답변 페이지로 이동 한 첫 번째 사람이므로 아무도 그것을 보지 않을 것입니다 ...)

오래된 솔루션

더 길고 느립니다 (10 초 소요).

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

파이썬 3.x : 66 자

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

보다 효율적인 솔루션 : 87 자

에라토스테네스의 체를 기반으로합니다.

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)

하스켈, 51

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

APL, 15

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

통역사가 메모리 문제를 겪었지만 이론 상으로는 효과가 있습니다.

펄, 49 바이트

정규식 쿵푸 :)

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

언 골프 버전 :

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

이 게시물을 입력하는 동안 10 % 향상되지 않았습니다!

정규식 소스 : http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

줄리아, 11

primes(10^6)

빌트인이 공감하는 것처럼 보이며 더 긴 답변을 위해 더 많은 단어가 필요했습니다.

J (15 또는 9)

나는이 (그냥 경우에도 티카를 이길 믿을 수 없어 하나의 2 개 문자로)

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

또는:

p:i.78498

gs2, 5 바이트

CP437로 인코딩 :

∟)◄lT

1C 29백만을 밀어 내고, 11 6C아래는 소수이며, 54쇼 라인입니다.

GolfScript, 22/20 (20/19) 바이트

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

속도를 희생시키면서 코드를 2 바이트 더 짧게 만들 수 있습니다.

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

편집 된 질문에 지정된 출력 형식이 무시되는 경우 (기존 답변 중 다수가 수행하는 작업) 고속 버전으로 2 바이트를 저장하고 느린 버전으로 1 바이트를 저장할 수 있습니다.

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

이렇게하면 빠른 버전의 프라임 뒤에 추가 LF가 인쇄되고 느린 버전의 프라임이 배열로 인쇄됩니다.

작동 원리

두 버전 모두 Eratosthenes 의 체 구현입니다 .

빠른 버전은 다음을 수행합니다.

1. A = [ 2 3 4 … 999,999 ]및을 설정하십시오 | = [ 0 1 2 … 999,999 ].

2. 설정 N = A[0]하고 인쇄하십시오 N.

3. 매주 N 번째 요소를 수집 |에서 C. 이것들은의 배수입니다 N.

4. 설정하십시오 A = A - C.

5. 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.

느린 버전은 비슷한 방식으로 작동하지만 최소 "A"(항상 소수)의 배수를 연속적으로 제거하는 대신 1,000,000 미만의 모든 양의 정수의 배수를 제거합니다.

경쟁력

기본 성을 인수 분해하거나 확인할 수있는 내장 수학 함수가없는 경우 모든 GolfScript 솔루션은 매우 크거나 비효율적입니다.

여전히 효율적이지는 않지만 적절한 크기 대 속도 비율을 달성했다고 생각합니다. 제출 당시이 방법은 위에서 언급 한 내장 기능을 사용하지 않는 방법 중 가장 짧은 것 같습니다. 내가 말할 것 같다 내가 몇 가지 답변이 어떻게 작동하는지 아무 생각이 없기 때문에 ...

제출 된 4 가지 GolfScript 솔루션 ( w0lf 's (시험판)), 다른 답변 (Wilson 's theorem) 및이 답변 중 두 가지를 모두 벤치마킹했습니다 . 결과는 다음과 같습니다.

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 자

⍸0π⍳1e6

골프 스크립트 26 25 24

편집 (Peter Taylor 덕분에 하나 이상의 문자를 저장했습니다) :

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

오래된 코드 :

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

이 코드는 매우 느리고 비효율적이기 때문에 이론적 인 가치 만 있습니다. 나는 실행하는 데 몇 시간이 걸릴 수 있다고 생각합니다.

테스트하려면 예를 들어 최대 100까지의 소수만 시도하십시오.

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

CJam-11

1e6,{mp},N*

1e6,-0 ... 999999의 배열
{mp},-소수를 선택하십시오
N*-개행과 결합

GolfScript, 25 (24) 바이트

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

편집 된 질문에 지정된 출력 형식을 무시하면 1 바이트를 저장할 수 있습니다.

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

이렇게하면 프라임이 한 줄에 하나씩이 아닌 다른 솔루션과 마찬가지로 배열로 인쇄됩니다.

작동 원리

일반적인 아이디어는 Wilson의 정리 를 사용 하는 것인데, 이는 n > 1이 다음과 같은 경우에만 소수 임을 나타냅니다.

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

벤치 마크

시험 분할보다 빠르지 만 에라토스테네스의 체보다 느립니다. 내 다른 답변을 참조하십시오 .

자바, 110 바이트

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

정규성 테스트를 통해 정규 표현식을 통한 단항 나누기 사용.

C, 91 88 85 82 81 80 76 72 자

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

알고리즘은 매우 비효율적이지만 우리는 중요하지 않은 코드 골프를 수행하기 때문에.

매스 매 티카 25

10 ^ 6 미만의 소수를 모르는 경우 :

Prime@Range@PrimePi[10^6]

J, 16 자

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

출력 형식 요구 사항이 없으면 13 자로 줄일 수 있습니다 .

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

1]\ 1 열의 소수 배열을 가져와 2 열의 배열로 바꾸고 각 소수를 자체 행에 놓으십시오. 따라서 인터프리터의 기본 출력 형식은 한 행 목록을 한 행당 하나의 소수로 변환합니다.

(#~ f) y은 기본적으로 filter이며 여기서 f각 요소의 부울을 반환합니다 y. i.1e6정수 범위 [0,1000000)이며 1&p:소수에 대해 1을 반환하는 부울 함수입니다.

R, 45 43 자

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

x에서 2에서 1e6까지의 각 x에 대해, 0과 동일한 x mod 2에서 x의 수가 2보다 작은 경우 간단히 출력하십시오.

배쉬 (433643)

내 (그렇지 않은 영리한) 시도는 factor를 사용하여 제품을 인수하는 것입니다.

factor ${PRODUCT}

불행히도 많은 수의 제품은 물론 거대합니다. 달리는 데 12 시간이 걸렸습니다. 나는 그것이 독특하다고 생각했기 때문에 게시하기로 결정했습니다.

전체 코드는 다음과 같습니다.

6 세 미만의 소수라면 합리적입니다.

  factor 30

잘 했어.

C #, 70

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

오랜 시간 동안 여기서 많이 보지 않을 것입니다 ...