구체적으로 Conway의 PRIMEGAME 입니다.

이것은 John H. Conway가 14 개의 합리적인 숫자 시퀀스를 사용하여 소수를 생성하기 위해 고안 한 알고리즘입니다.

 A   B   C   D   E   F   G   H   I   J   K   L   M   N
17  78  19  23  29  77  95  77   1  11  13  15  15  55
--  --  --  --  --  --  --  --  --  --  --  --  --  --
91  85  51  38  33  29  23  19  17  13  11  14   2   1

예를 들어, F는 분수 77/29입니다.

알고리즘이 소수를 찾는 방법은 다음과 같습니다. 숫자로 시작하여, 2곱하면 정수를 생성하는 순서의 첫 번째 항목을 찾으십시오. 여기입니다 M, 15/2생산하는 15. 그런 다음 해당 integer 15에 대해 곱할 때 정수를 생성하는 시퀀스의 첫 번째 항목을 찾으십시오. 그것이 마지막을 나타내는 N, 또는 입니다. 해당 순서를 기록하십시오. (여러분 사이에서이 말은 FRACTRAN 프로그램 으로 인식 될 수 있습니다 .)55/1825

반복이 끝나면 다음과 같은 결과가 나타납니다.

2, 15, 825, 725, 1925, 2275, 425, 390, 330, 290, 770, 910, 170, 156, 132, 116, 308, 364, 68, 4 ...

마지막으로 나열된 항목은 4또는 2^2입니다. 2이 알고리즘으로 생성 된 첫 소수 ( 지수)를보십시오! 결국 순서는 다음과 같습니다.

2 ... 2^2 ... 2^3 ... 2^5 ... 2^7 ... etc.

따라서 소수를 산출합니다. 이다 OEIS A007542 .

도전

n0 또는 1 인덱싱 된 ( 입력 한) 입력 번호가 주어지면 n이 시퀀스 의 첫 번째 숫자를 출력 n하거나이 시퀀스의 숫자를 출력하십시오 .

예

아래 예제는 n인덱스가없는 0 번째 항을 출력합니다 .

 n   output
 5   2275
19   4
40   408

규칙

• 해당되는 경우 입력 / 출력이 해당 언어의 기본 정수 유형에 적합하다고 가정 할 수 있습니다.
• 입력 및 출력은 편리한 방법 으로 제공 할 수 있습니다 .
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

Python 3 , 173165153145144144135135127126125108107104 바이트

f=lambda n:2>>n*2or[f(n-1)*t//d for t,d in zip(b"NM_M\r7",b"[U3&!\r")if f(n-1)*t%d<1][0]

온라인으로 사용해보십시오!

• Jonathan Frech 덕분에 -30 바이트!
• Lynn 덕분에 -3 바이트!

2>>n*2인 2을 위해 n==0와 0달리.

float를 반환 할 수 있으면 103 바이트 입니다.

FRACTRAN , 99 바이트

17/2821 78/2635 19/1581 23/1178 29/1023 77/899 95/713 77/589 1/527 11/403 13/341 15/434 15/62 55/31

온라인으로 사용해보십시오!

프로그램은 2*31^n입력으로 사용되며 초기 상태로 사용됩니다.

원래 FRACTRAN 프로그램의 모든 분수는 31 (첫 번째 미사용 프라임 레지스터)로 나뉘어 프로그램이 n 번째 반복에서 중지됩니다.

젤리 , 49 43 바이트

ד×NŒçøM_M¢¿ÆÐÐ7‘“[U3&!øçŒ×Æ¿Ç£¢‘:@xḍɗḢ
2Ç¡

온라인으로 사용해보십시오!

• 마일로 인해 -6 바이트

파이썬 3 , 107 바이트

f=lambda n,k=2:n and f(n-1,[k*a//b for a,b in zip(b"NM_M\r7",b"[U3&!\r")if k*a%b<1][0])or k

온라인으로 사용해보십시오!

zip인쇄 할 수없는 low-ASCII 문자를 포함하는 두 개의 바이트 열을 사용 하여 분수 목록을 인코딩합니다 .

경우 n제로, 우리는 인수를 반환 k; 그렇지 않으면 새로운 매개 변수로 되풀이됩니다. 우리의 새로운 k것은 목록의 k*a//b일부 분수 (a, b)에 해당하는 첫 번째 값 k*a//b이므로 정수 k*a%b<1입니다.

MATL , 50 바이트

Hi:"'0m26<l~l *,..V'31-*'{uSFA=731-+."!'32-&\w~)1)

온라인으로 사용해보십시오!

J , 116110 바이트

g=.3 :0
((1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x)([:({.@I.@(=<.){[)*)])^:y 2
)

온라인으로 사용해보십시오!

0- 인덱싱; n 번째 숫자를 반환

동사를 암묵적으로 만들어서 일부 바이트를 절약 할 수는 있지만 만드는 데 문제가 있습니다. ^: 작업 있습니다.

설명:

J 는 NrD 형식의 유리수를 나타냅니다. 여기서 N은 분자이고 D는 분모 17r91 78r85 19r51 23r38...입니다.

1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x base-96 숫자를 목록으로 변환하고 두 목록을 구분하여 분수 목록을 구성합니다.

   1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x
17r91 78r85 19r51 23r38 29r33 77r29 95r23 77r19 1r17 11r13 13r11 15r14 15r2 55

2 2로 시작

^:y왼쪽 n시간 에 동사를 반복하십시오 (y는 함수의 인수입니다)

] 올바른 인수 (2에서 시작한 다음 각 반복의 결과를 사용함)

* 분수의 목록에 올바른 인수를 곱하십시오

(=<.) 결과는 정수입니다 (각 숫자를 바닥과 비교하십시오)

{.@I.@정수 I.중 첫 번째 인덱스 를 찾습니다.{.

{[ 색인을 사용하여 숫자를 검색합니다.

05AB1E ,  44  43 바이트

0 인덱스

2sF•Ë₁ǝßÌ?ƒ¥"h2ÔδD‡béαA5À>,•тв2ä`Š*s‰ʒθ_}нн

온라인으로 사용해보십시오!

설명

2                                             # initialize stack with 2
 sF                                           # input times do:
   •Ë₁ǝßÌ?ƒ¥"h2ÔδD‡béαA5À>,•                  # push a base-255 compressed large number
                            тв                # convert to a list of base-100 digits
                              2ä`             # split in 2 parts to stack
                                 Š            # move denominators to bottom of stack
                                  *           # multiply the last result by the numerators
                                   s‰         # divmod with denominators
                                     ʒθ_}     # filter, keep only those with mod result 0
                                         нн   # get the div result

큰 숫자는 17781923297795770111131515559185513833292319171311140201

Pari / GP , 121 바이트

n->a=2;for(i=1,n,a=[x|x<-a*[17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55],x\1==x][1]);a

온라인으로 사용해보십시오!

자바 스크립트 (Node.js) , 106 95 바이트

• @Arnauld와 @Neil 덕분에 11 바이트 감소

(n,N=2,I=13,B=Buffer(`[U3&!\rNM_M\r7`))=>n--?f(n,N/B.find(x=>N%x<!!++I)*B[I]):N

온라인으로 사용해보십시오!

레티 나 213 바이트

K`17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶2
\d+
*
"$+"+`((_+)/(_+)¶(.+¶)*)(\3)+$
$1$#5*$2
r`_\G

온라인으로 사용해보십시오! 설명:

K`17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶2

입력을 모든 분수의 목록과 초기 정수로 교체하십시오.

\d+
*

모든 것을 단항으로 변환하십시오.

"$+"+`

원래 입력에 의해 주어진 횟수만큼 대체를 반복하십시오.

((_+)/(_+)¶(.+¶)*)(\3)+$

정수를 균등하게 나누는 분모를 찾으십시오.

$1$#5*$2

정수에 분자를 곱한 나눗셈 결과로 바꾸십시오.

r`_\G

정수를 10 진수로 변환하고 결과를 출력하십시오.

첨부 , 81 바이트

Nest<~{Find[Integral,_*&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]},2~>

온라인으로 사용해보십시오! 출력 분획 예를 들어, 입력 (1)을 통해 5반환2275/1 . 이것은 앞에 2 바이트를 더하여 고정시킬 수 있습니다N@프로그램 하여 .

설명

이것은 Nest 미리 정의 된 두 개의 인수 로 커리되는 커리 함수입니다 .

{Find[Integral,_*&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]}

과 2 . 이 마지막 인수는 단순히 초기 시드이며이 함수에 전달되는 인수는 지정된 함수를 중첩하는 반복 횟수입니다.

다음은 PRIMEGAME를 인코딩하는 데 사용됩니다.

&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]

이것은 다음과 같이 평가됩니다.

A> "0zmt2R6E<@l<~6l2 0*,,*.-.!V "
"0zmt2R6E<@l<~6l2 0*,,*.-.!V "
A> Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "
[48, 122, 109, 116, 50, 82, 54, 69, 60, 64, 108, 60, 126, 54, 108, 50, 32, 48, 42, 44, 44, 42, 46, 45, 46, 33, 86, 32]
A> Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31
[17, 91, 78, 85, 19, 51, 23, 38, 29, 33, 77, 29, 95, 23, 77, 19, 1, 17, 11, 13, 13, 11, 15, 14, 15, 2, 55, 1]
A> Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]
 17 91
 78 85
 19 51
 23 38
 29 33
 77 29
 95 23
 77 19
  1 17
 11 13
 13 11
 15 14
 15  2
 55  1
A> &`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]
[(17/91), (78/85), (19/51), (23/38), (29/33), (77/29), (95/23), (77/19), (1/17), (11/13), (13/11), (15/14), (15/2), (55/1)]

G설명 에서이 표현을 로 바꾸자 . 첫 번째 기능은 다음과 같습니다.

{Find[Integral,_*G]}

이는 _함수에 대한 입력 인 FRACTRAN 코드 over의 단일 반복을 수행 합니다. 이 FindS 자 Integral부재 배열 (정수 하나) _*G의 입력이고, _각 부재를 곱 G.Nest주어진 횟수만큼이 변환을 적용하기 만하면됩니다.

첨부, 42 바이트

$langs이 과제에서 영감을 얻은 라이브러리의 일부를 구현 했으므로이 섹션을 경쟁이 아닌 것으로 표시합니다.

Needs[$langs]2&FRACTRAN_EXAMPLES.prime.run

이것은 단순히 FRACTRAN_EXAMPLES내가 가진 목록을 쿼리합니다 . 각 예제는 FractranExample내장 FRACTRAN함수 를 호출 하는 인스턴스 입니다. prime예는 콘웨이의 PRIMEGAME입니다.

F # (모노) , 215 바이트

let q m=
 let rec i x y=
  if y=m then x 
  else[17;91;78;85;19;51;23;38;29;33;77;29;95;23;77;19;1;17;11;13;13;11;15;14;15;2;55;1]|>List.chunkBySize 2|>List.find(fun[n;d]->x*n%d=0)|>fun[n;d]->i(x*n/d)(y+1)   
 i 2 0

온라인으로 사용해보십시오!

PHP, 183 바이트 ( "php"태그가있는 189)

골프 :

$t=2;for(;@$i++<$argv[1];){foreach([17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55/1]as$n){$a=$t*$n;if(preg_match('/^\d+$/',$a)){$t=$a;break;}}}echo$t;

언 골프 드 :

<?php 
$t=2;
for(;@$i++<$argv[1];){
    foreach([17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55/1] as $n){
        $a=$t*$n;
        if(preg_match('/^\d+$/',$a)){
            $t=$a;break;
        }
    }
}
echo $t;

온라인으로 사용해보십시오!