빈 1 인덱스 순서로 시작합니다.

_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,...

n ^번째 단계에서는 첫 번째 나머지 빈에서 시작하여 1보다 큰 정수로 모든 a (n) 빈칸을 채 웁니다. 여기서 a (n)은 시퀀스 의 n ^번째 항목입니다.

첫 단계 후 :

2,_,3,_,4,_,5,_,6,_,7,_,8,_,9,_,10,_,11,_,12,_,13,_,...

1보다 큰 첫 번째 정수가 2이므로 a (1)은 2 여야합니다.

두 번째 단계에서는 모든 a (2) 공백을 채 웁니다. a (2)는 2 여야합니다.

2,2,3,_,4,3,5,_,6,4,7,_,8,5,9,_,10,6,11,_,12,7,13,_,...

세 번째 단계에서는 모든 a (3) 공백을 채 웁니다. 시퀀스에서 a (3) = 3입니다.

2,2,3,2,4,3,5,_,6,4,7,_,8,5,9,3,10,6,11,_,12,7,13,_,...

네 번째 단계에서는 모든 a (4) 공백을 채 웁니다. 시퀀스에서 a (4) = 2입니다.

2,2,3,2,4,3,5,2,6,4,7,_,8,5,9,3,10,6,11,3,12,7,13,_,...

결국:

2,2,3,2,4,3,5,2,6,4,7,2,8,5,9,3,10,6,11,3,12,7,13,2,...

태스크

n이 주어지면 시퀀스 의 n ^번째 요소를 반환합니다 .

시퀀스의 처음 10,000,000 개의 용어는 여기 에서 찾을 수 있습니다 .

이것은 code-golf 입니다. 바이트 단위의 최단 답변이 이깁니다. 표준 허점이 적용됩니다.

하스켈 , 80 67 바이트

g~(a:b)|let k!l=k:take(a-1)l++(k+1)!drop(a-1)l=2!g b
m=g m
(!!)$0:m

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

Haskell은 그 자체로 무한 목록을 정의하기에 완벽한 언어입니다.

C, 123 바이트

f(n){int*p=calloc(n,4),i=0,j,k;for(*p=p[1]=2;i<n;++i)for(j=0,k=i/2?0:2-i;j<n;++j)p[j]||k++%p[i]||(p[j]=k/p[i]+2);n=p[n-1];}

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

연습

f(n){int*p=calloc(n,4),

시퀀스 의 처음 n 개 요소 를 저장하려면 n 개의 정수 배열을 할당 하십시오. 이것은 하드 코딩 으로 대부분의 경우 안전한 가정이며 확실히 코드 골프와 관련하여 기꺼이 만듭니다. :)sizeof(int)4

i=0,j,k;

이것들은 모두 카운터입니다 : i우리가 진행중인 단계의 색인을 j위해, 빈 공간을 찾는 시퀀스를 반복하고, k얼마나 많은 빈 공간이 보 였는지 계산합니다.

for(*p=p[1]=2;i<n;++i)

메인 루프를 시작하기 전에 시퀀스의 처음 두 요소를로 초기화합니다 2. ( p[0]= *(p + 0)= *p.) k그러나에 대한 카운트를 버립니다 .

for(j=0,k=i/2?0:2-i;j<n;++j)

... 또한 은폐 초기화를 수행합니다.이 초기화 는 미만 k인지 확인 하고 시작 값을 수정합니다 . 내부 루프도 여기에서 시작되어 각 단계에서 지금까지 전체 시퀀스를 반복합니다.i2k

p[j]||k++%p[i]||(p[j]=k/p[i]+2);

이 줄은 실제로 일부 설명을 사용할 수 있습니다. 이것을 다음과 같이 확장 할 수 있습니다.

if (!(p[j] || ((k++) % p[i]))) {
    p[j] = k / p[i] + 2;
}

단락, 그리고 De Morgan의 법칙과 0C에서 허위 사실에 의해 :

if (p[j] == 0 && ((k++) % p[i]) == 0) {
    p[j] = k / p[i] + 2;
}

"이 공간이 비어 있으면 증가 k합니다. k이전에 여러 단계 크기의 경우 다음 명령문을 실행하십시오." 따라서 모든 단계 크기 요소 에 대해 명령문을 실행하는데 , 이는 시퀀스가 ​​설명되는 방식과 정확히 같습니다. 진술 자체는 간단하다. 모두가 생성됩니다 않습니다 2, 3, 4, ...

n=p[n-1];}

로 작동하는 까다로운 반환 반환을 사용하여 시퀀스에서 gcc첫 번째 n 항의 마지막 요소를 "반환"합니다 . 이는 n 번째 항입니다.

Pyth, 29 바이트

M?tH?eJ.DtHg1GghG-tHhJ+2hJ2g1

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

작동 원리

목록으로 장난하는 대신 일반 재귀 수식을 사용합니다.

M                                def g(G, H):
 ?tH                                 if H - 1:
      J.DtHg1G                           J = divmod(H - 1, g(1, G))
    ?e                                   if J[-1]:
              ghG-tHhJ                       return g(G + 1, H - 1 - J[0])
                                         else:
                      +2hJ                   return 2 + J[0]
                                     else:
                          2              return 2
                           g1Q   print(g(1, eval(input())))

하스켈 , 67 바이트

0%j=2
i%j|d<-div i$f j=last$d+2:[(i-d-1)%(j+1)|d*f j<i]
f=(%1).pred

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

Anders Kaseorg의 Pyth answer 와 기본적으로 동일한 방법으로 밝혀진 재귀 산술 솔루션 .

이 코드는 사마귀로 덮여 있는데, 골치 아픈 부분은 골치 아픈 것처럼 보이지만 그 방법을 보지 못했습니다.

이 함수는 i%j실제로 mod i(f j)>0두 가드 중 하나 를 확인 하고 평가 하기 위해 가드를 사용하려고합니다 . 그러나 두 표현식 모두를 사용 div i(f j)합니다. 가드에 바인딩하면 양쪽에 적용되지 않습니다. 내가 아는 한, 경비원은 다른 경비원에게 "분배"하도록 만들 수 없습니다. let그리고 where너무 깁니다. 따라서 코드는 last가드가 변수를 바인딩하는 동안 두 표현식 중 하나를 선택 하는 데 사용 합니다. 어.

and 는 divMod모두 사용되지만 긴 표현 이기 때문에 이상적으로 사용 합니다. 대신 값의 제곱 이 원래 값보다 떨어지는 지 확인하여 모드를 hackily 검사 합니다.divmod(d,m)<-divMod ...div

0%j=2하스켈은 단락 경우 케이스는 필요하지 않을 것입니다 div 0그것을하지 않는. 이 .pred변환은 1- 인덱스 입력을 0- 인덱싱으로 변환합니다 -1.

자바 스크립트 (ES6), 98 93 91 바이트

결과가 나 오자마자 멈추는 재귀 함수.

f=(n,p,a=[...Array(n)])=>a[n-1]||f(n,-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

대체 버전, 90 바이트

Shaggy에서 -1 바이트 권장

로 호출해야합니다 f(n)(). 메타 의 해당 게시물이 현재 긍정적 인 점수를 주지만이 구문은 분명히 논쟁의 여지가 있습니다.

n=>g=(p,a=[...Array(n)])=>a[n-1]||g(-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

데모

f=(n,p,a=[...Array(n)])=>a[n-1]||f(n,-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

for(n = 1; n <= 50; n++) {
  console.log('a[' + n + '] = ' + f(n));
}

자바 8, 124 바이트

(i)->{int j=1,a[]=new int[i+1],k,s,n;for(;a[i]<2;){for(k=0,n=2;a[++k]>0;);for(s=a[j++]|2*k;k<=i;k+=s)a[k]=n++;}return a[i];}

람다 식.

정수 배열을 작성하고 n 번째 값이 채워질 때까지 계속 배열합니다.

가능한 한 많은 선언을 줄이기 위해 맨 위에 변수를 미리 선언 int하면 ,n2 를 추가 하는 대신 4 바이트의 공간 이 필요합니다.

켜짐 j번째의 반복 계산의 횟수 "공백"하나 건너 갖는다는 동일하다 a[j](빈 경우, 또는 2). 그것은 우리가 입력해야하는 첫 번째 빈 공간이 위치에있을 경우 밖으로 작동 k, k * a[j]우리에게 '단계'를 제공합니다 ( s).