Boş, 1 indeksli bir diziyle başlayalım:

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

N, ^inci aşaması, bir (n) n, kalan ilk boşluğun, başlayan tam sayı 1 'den büyük boşlukları her bir (n) girip ^inci sırayla girişi.

İlk adımdan sonra:

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

1'den büyük ilk tamsayı 2 olduğundan, (1) 'in 2 olması gerektiğini unutmayın.

İkinci adımda, her bir (2) boşluğu dolduruyoruz. Bir (2) nin 2 olması gerektiği açıktır.

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

Üçüncü adımda, her bir (3) boşluğu dolduruyoruz. Diziden bir (3) = 3.

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

Dördüncü adımda her bir (4) boşluğu dolduruyoruz. Diziden bir (4) = 2.

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

Sonunda:

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

Görev

N göz önüne alındığında, N dönüş ^inci dizisinin elemanı.

Dizinin ilk 10.000.000 terimi burada bulunabilir .

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır. Standart boşluklar uygulanır.

Haskell , 80 67 bayt

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

Çevrimiçi deneyin!

Haskell, sonsuz bir listeyi kendisi açısından tanımlamak için mükemmel bir dildir.

C, 123 bayt

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];}

Çevrimiçi deneyin!

Bakış

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

Dizinin ilk n elemanlarını saklamak için bir n tamsayı dizisi atayın . Bu hardcodes olarak güvenli bir çoğu durumda varsayım ve kesinlikle biridir, ben kod golf bağlamında yapmaya hazırım. :)sizeof(int)4

i=0,j,k;

Bunların hepsi sayıcıdır: iattığımız adımın dizini jiçin, boş alanları arayan diziyi dolaşmak ve kkaç boş alanın görüldüğünü saymak için.

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

Ana çevremize başlamadan önce, dizinin ilk iki elemanının başlangıcında gizlice gireriz 2. ( p[0]= *(p + 0)= *p.) Bu kolsa da, sayımı atar ama ...

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

... ayrıca , daha düşük olup kolmadığını görmek için yapılan sınamaların başlangıç ​​değerlerini yapıyoruz ve başlangıç ​​değerlerini düzeltiyoruz . İç döngü burada da başlar ve her adımda şimdiye kadarki tüm sekans boyunca yinelenir.i2k

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

Bu çizgi gerçekten bazı açıklamaları kullanabilirdi. Bunu şu şekilde genişletebiliriz:

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

kısa devre yaparak ve sonra De Morgan yasalarına ve 0C’de sahte olduğu gerçeğine göre :

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

Bu esasen şöyle ifade eder: "eğer bu alan boşsa, artış k. Eğer kdaha önce basamak boyutunun bir katı ise, aşağıdaki ifadeyi çalıştırın." Bu nedenle, her adım boyutu öğesinde açıklamayı çalıştırıyoruz , bu da tam olarak dizilimin nasıl tanımlandığıdır. İfadenin kendisi basittir; Tüm bu oluşturmak olduğunu mu 2, 3, 4, ....

n=p[n-1];}

Zor-getiri-olmadan-a-dönüş kullanma eserler bu gcc, ilk son elemanı "return" n olur dizisi, terimler n inci terim.

Pyth, 29 bayt

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

Çevrimiçi deneyin

Nasıl çalışır

Listeleri kandırmak yerine, basit bir özyinelemeli formül kullanır.

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 bayt

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

Çevrimiçi deneyin!

Temelde Anders Kaseorg'un Pyth cevabıyla aynı yöntemi ortaya koyan özyinelemeli bir aritmetik çözüm .

Bu kod siğillerle kaplıdır - golf oynayabilecek gibi görünen çirkin parçalar, ama nasıl olduğunu görmedim.

Bu işlev i%jgerçekten mod i(f j)>0karşılık gelen iki ifadeden birinin olup olmadığını kontrol etmek için bir koruyucu kullanmak istiyor . Ancak, her iki ifade de kullanır div i(f j). Bir muhafızda bunu bağlamak her iki taraf için de geçerli olmayacak. Bildiğim kadarıyla, diğer gardiyanlara "dağıtmak" için bir güvenlik oluşturulamıyor. letve whereçok uzun. Bu nedenle, kod lastdeğişkeni bağlarken, iki ifadeden birini seçmek için kullanılır. Ugh.

İdeal kullandığımız ediyorum divModhem çünkü divve modkullanılır, ancak (d,m)<-divMod ...uzun bir ifadesidir. Bunun yerine div, bölen değer zamanlarının asıl değerin altına düşüp düşmediğini görerek modun sıfırdan kontrol edildiğini görmüyoruz .

0%j=2Haskell kısa devre durumunda dava ihtiyaç olmazdı div 0öyle değil ki. .predDönüştürür 1 endeksli girişi sıfıra endeksli, ya da başka olacaktır -1her düzeltmeler.

JavaScript (ES6), 98 93 91 bayt

Sonuç elde edilir edilmez duran bir özyinelemeli işlev.

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

Alternatif sürüm, 90 bayt

Shaggy tarafından -1 bayt için önerildi

Bu bir ile çağrılmalıdır f(n)(). Metadaki karşılık gelen posta şu anda olumlu bir puan vermesine rağmen , bu sözdizimi görünüşte tartışmalıdır.

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

gösteri

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 bayt

(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];}

Lambda ifadesi.

Bir tamsayı dizisi oluşturur ve nth değeri doldurulana kadar sürekli olarak doldurur.

Değişkenlerin en üstte önceden bildirilmesi, mümkün olduğunca çok sayıda bildirimin azaltılması için her biri 2 olan inteklemeye karşılık 4 baytlık alana mal eder ,n.

Açık j'inci yineleme hesaplama sayısı, 'boşlukları' bir atlamaya sahip eşittir a[j](boş ise, ya da 2). Doldurmamız gereken ilk boş alan konumdaysa k, k * a[j]bize 'basamağı' ( s) verir.