空白の1インデックスシーケンスから始めます。

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

n ^番目のステップでは、a（n）がシーケンスのn ^番目のエントリである場合、最初の残りの空白から始まる1より大きい整数ですべてのa（n）空白を埋めます。

最初のステップの後：

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

1より大きい最初の整数は2であるため、a（1）は2でなければならないことに注意してください。

2番目のステップでは、すべてのa（2）ブランクを埋めます。a（2）が2でなければならないことは明らかです。

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

3番目のステップでは、すべての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,_,...

4番目のステップでは、すべての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です。バイト単位の最短回答が優先されます。標準の抜け穴が適用されます。

Haskell、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)

メインループを開始する前に、シーケンスtoの最初の2つの要素の初期化を実行し2ます。（p[0]= *(p + 0)= *p。）これにより、k、...

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

...また、の巧妙な初期化kを行い、iがより小さいかどうかをテストし、そう2でkあれば開始値を修正します。内側のループもここから始まり、各ステップでこれまでのシーケンス全体を繰り返します。

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())))

Haskell、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対応する2つの式のいずれかを確認し、評価することを本当に望んでいます。ただし、両方の式はを使用しますdiv i(f j)。ガード内のバインドは、両側に適用されません。私の知る限り、ガードは他のガードに「分配」することはできません。letそしてwhere長すぎます。そのため、lastガードが変数をバインドする間、コードは2つの式のいずれかを選択するために使用します。あー

理想的には、使用したいdivModの両方のためdivとはmod使用されているが、(d,m)<-divMod ...長い式です。代わりに、modがゼロでないかどうかをハックしてチェックします。div値に除数を値が元の値ます。

0%j=2Haskellは短絡している場合場合は必要ないでしょうdiv 0、それはありません、。は.pred、インデックスが1の入力をインデックスが0の入力に変換し-1ます。そうでない場合は、どこでも修正が行われます。

JavaScript（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バイト

-1バイトについてShaggyが提案

これはで呼び出す必要があります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));
}

Java 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番目の値が入力されるまで継続的に入力します。

変数を2つint追加するの,nではなく、それぞれが4バイトのスペースを必要とするため、できるだけ多くの宣言を削減するために、上部で変数を事前宣言します。

上j「番目の反復計算の、多数の『ブランク』一つはスキップしなければならないがに等しいa[j]（空白の場合、又は2）。最初に埋めなければならない空白がpositionにあるk場合 k * a[j]、「ステップ」（s）が得られることがわかります。