Aşağıdaki sırayı düşünün:

0 1 3 2 5 4 8 6 7 12 9 10 11 17 13 14 15 16 23 ...

Desensiz görünüyor, değil mi? İşte böyle. İle başlayarak , ile başlayan tamsayıları 0atlayın . Bu dizideki bir sonraki sayı. Ardından, "atlandı" ve henüz artan sırada görülmeyen sayıları ekleyin. Ardından, eklenen son sayıyı artırın ve atlayın. Bu modeli tekrarlayın.nn1n

Mesela, ulaştığımızda 11, biz varız n=5. Biz artırmaz nolmak n=6kadar atlamak, 17ekleme ardından, 13 14 15 16bu henüz görülmemiş beri. Bir sonraki sıçramamız n=7, yani dizideki bir sonraki eleman 23.

Meydan okuma

Giriş Verilen xçıkış, xbu sekansın inci terimi, birinci xdizinin terimler veya dizi bakımından sonsuz listesini oluşturmak. 0- veya 1-endeksleme seçebilirsiniz.

G / Ç ve Kurallar

• Giriş ve çıkış herhangi bir uygun yöntemle verilebilir .
• Giriş ve çıktının, dilinizin yerel sayı türüne uygun olduğu varsayılabilir.
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine döndürebilirsiniz.
• Standart boşluklar yasaktır.
• Bu kod golfüdür, bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

JavaScript (ES7), 41 bayt

0 dizinli dizinin n. Terimini döndürür .

n=>(d=(n--*8-23)**.5)%1?n:'121'[n]^n-~d/2

Çevrimiçi deneyin!

Nasıl?

Ana kasa: $n > 3$

Dizinin ilk dört terimi özeldir, bu yüzden şimdilik bunları bir kenara bırakalım.

İçin , böyle sekans görünüyor:$n > 3$

 n  | [4] 5 [6] 7 8 [ 9] 10 11 12 [13] 14 15 16 17 [18] 19 20 21 22 23 [24] 25 26 27 ...
----+------------------------------------------------------------------------------------
a(n)| [5] 4 [8] 6 7 [12]  9 10 11 [17] 13 14 15 16 [23] 18 19 20 21 22 [30] 24 25 26 ...
----+------------------------------------------------------------------------------------
 k  |  2  -  3  - -   4   -  -  -   5   -  -  -  -   6   -  -  -  -  -   7   -  -  - ...

Aslında iki araya sokulmuş alt sekans olduğunu fark edebiliriz:

• Çoğu değer, sadece sahip olduğumuz alt sekansına aittir :$A$

  $$A(n) = n - 1$$

• Diğer bazı değerler , endeksleri aritmetik sekansı 3, 3, 4, 6, 9, 13, 18, 24 ... takip eden ve sahip olduğumuz sekansına (yukarıdaki şemadaki parantezlerle vurgulanmıştır) aittir :$B$

  $$B(n,k) = n + k - 1$$

  burada , ana sekanstaki indeks ve k , alt sekans B'deki indekstir .$n$$k$$B$

Ana sekanstaki indeksleri şu şekilde verilir:$B$

Verilen , ana sırayla gelen terimi ait olduğunu biliyoruz B ise n kuadratik denklemi arasında bir tamsayıdır çözüm:$n$$B$$n$

kimin ayrımı:

ve pozitif çözümü:

Biz bekliyoruz bir tamsayı olmak. Bu nedenle test:$\sqrt{\Delta}$

(d = (n-- * 8 - 23) ** .5) % 1

Özel durumlar: $0 \le n \le 3$

For , ayırt edici negatif ve onun karekök sonuçlarını alarak NaN . için $n < 3$ , ayırt edici olduğu 1. . Bu nedenle, dizinin bu ilk dört teriminin B alt dizisine ait olduğu düşünülmektedir.$n = 3$$1$$B$

Standart n - ~ d / 2 formülümüzü uygularsak , şunu elde ederiz:

onun yerine:

Bu yüzden bu sonuçları sırasıyla 1.$0,1,2\text{ and }1$

Kabuk , 12 bayt

Θṁṙ_1C+ḣ2tNN

Çevrimiçi deneyin!

Sonsuz bir liste olarak çıktılar. İşte ilk yazdıran bir sürümüdür N .

açıklama

Θṁṙ_1C + ḣ2tNN - Tam program. Giriş almaz, STDOUT'a çıkış verir.
         tN - 2'den başlayarak sonsuz doğal sayı listesini oluşturun.
      + ḣ2 - Ve buna [1, 2] ekleyin. Verimler [1,2,2,3,4,5,6,7,8,9,10,11, ...].
     CN - Sonsuz pozitif tam sayı listesini bu parçalara ayırın
               boyutları. Verimler [[1], [2,3], [4,5], [6,7,8], [9,10,11,12], ...].
 ṁ - Daha sonra sonuçları haritalayın ve düzeltin.
  ṙ_1 - Her birini 1 birim sağa döndürün.
               Verim [1,3,2,5,4,8,6,7,12,9,10,11, ...]
Θ - Başına 0. Verim [0,1,3,2,5,4,8,6,7,12,9,10,11, ...]

Haskell , 43 bayt

0:1:3:2:5!3
a!n=a:[a-n+2..a-1]++(a+n)!(n+1)

Çevrimiçi deneyin!

Sonsuz bir liste tanımlar:

  0:1:3:2:(5!3)
≡ 0:1:3:2:5:4:(8!4)
≡ 0:1:3:2:5:4:8:6:7:(12!5)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:(17!6)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:17:13:14:15:16:(23!7) …

Jöle , 15 bayt

+‘ɼṪRṙ-œ|@
0Ç¡ḣ

Bu, n verildiğinde , dizinin ilk n öğesini basan tam bir programdır .

Çevrimiçi deneyin!

Nasıl çalışır

0Ç¡ḣ        Main link. Argument: n

0           Set the return value to 0.
 Ç¡         Call the helper link n times, first with argument 0, then n-1 times
            with the previous return value as argument.
   ḣ        Head; extract the first n items of the last return value.


+‘ɼṪRṙ-œ|@  Helper link. Argument: A (array)

 ‘ɼ         Increment the value in the register (initially 0) and yield it.
+           Add that value to all items in the sequence.
   Ṫ        Tail; extract the last item.
    R       Range; map k to [1, .., k].
     ṙ-     Rotate -1 units to the left, yielding [k, 1, ..., k-1].
       œ|@  Perform multiset union of A and the previous return value.

C (gcc), 73 67 64 bayt

t,d;f(x){for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);t=x<4?x^x/2:x-1;}

Çevrimiçi deneyin!

f0 indeksli alan ve sekanstaki th sayısını nüreten bir işlevi tanımlar n.

Sekansı aşağıdaki gibi analiz edebiliriz:

f(n)  = n   where n = 0, 1

f(2)  = 3   // 2 and 3 are swapped
f(3)  = 2

f(4)  = 5   // (+2,+3)
f(6)  = 8   // (+3,+4)
f(9)  = 12  // (+4,+5)
f(13) = 17  // (...)
...

f(n)  = n-1 // for all cases not yet covered

İlk önce orta bölümü ele alıyoruz:

for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);

Soldaki argümanların (4, 6, 9, 13, ...) bir kalıbı izlediğini unutmayın: önce iki ekleyin, sonra üç ekleyin, sonra dört ekleyin, vb. Biz başlayacak t=4ve eklenti darttırılarak döngünün her tekrarında (2 başlar)d işleminde.

Döngünün gövdesi daha ilginç. 4 ila 5, 6 ila 8, 9 ila 12, vb. Eşlemek istediğimizi unutmayın; bu sadece ekleyen d-1eğer xolduğunu t. Ancak, bu mantık son durumdan önce gelir, bu f(n) = n - 1yüzden sonunda 1 çıkaracağımızı biliyoruz. Bu nedenle, dif x == t( x-t||(x+=d)) öğesini ekleyebiliriz . Ancak biz de bu hemen sonra döngünün patlak gerekir - biz eklemek böylece o kadar dalmak için saçma görünümlü d+=x+=d, hep yapacak d<xkoşul başarısız.

Bu, ilk dört değer dışındaki her şeyi kapsar. İkili olarak onlara baktığımızda:

00 -> 00
01 -> 01
10 -> 11
11 -> 10

Bu yüzden, eğer son biti çevirmek istiyoruz 2 <= x < 4. Bu ile yapılır x^x/2. x/2ikinci en küçük anlamlı biti verir, bu yüzden orijinal sayı ile XORing değeri sayı 2 veya 3 ise son biti çevirir.

Jöle ,  13  10 bayt

-3 Dennis sayesinde (2 toplam birikim kurulumundan ve son bir düşüşten tasarruf etmek için 0 endeksleme kullanın)

Ḷ»2Äi+_>2$

Bir tamsayıyı, kabul bir monadik bağlantı 0 -indexed n bir tamsayı, döner, a (n)

Çevrimiçi deneyin! Veya bir test takımına bakın

Perl 5 ile-pl 70 bayt,

$"="|";push@f,$;=$f[-1]+$-++,grep!/^(@f|$;)$/,0..$;for 0..$_;$_=$f[$_]

Çevrimiçi deneyin!

MATL , 22 bayt

1y:"t0)@+h5M:yX-h]qw:)

nDizinin ilk terimlerini çıktılar .

Çevrimiçi deneyin!

açıklama

1         % Push 1
y         % Implicit input: n. Duplicate from below
":        % For each k in [1 2 ... n]
  t0)     %   Duplicate sequence so far. Get last entry, say m
  @+      %   Add k: gives m+k
  h       %   Concatenate horizontally
  5M      %   Push m+k again
  :       %   Range [1 2 ... m+k]
  y       %   Duplicate from below
  X-      %   Set difference
  h       %   Concatenate horizontally
]         % End
q         % Subtract 1, element-wise
w         % Swap. Brings original copy of n to the top
:)        % Keep the first n entries. Implicit display

Haskell , 51 bayt

0:1:do(a,b)<-zip=<<(1:)$scanl(+)3[2..];b:[a+1..b-1]

Çevrimiçi deneyin!

Lynn'in Haskell cevabından biraz daha uzun , ama farklı yaklaşım daha az ilginç olabilir.

Ruby , 73 bayt

f=->x,l,n{!l[x]&&(i=l[-1];f[x,l+[i+n]+([*(i+1...i+n)]-l),n+1])||l[0...x]}

Çevrimiçi deneyin!

Listenin ilk x sayısını döndüren özyinelemeli işlev.

QBasic, 58 bayt

DO
b=r+j
?b
r=b
FOR x=a+1TO b-1
?x
r=x
NEXT
a=b
j=j+1
LOOP

Süresiz çıktılar. Sonuçları görmek için SLEEP 1döngüye bir iç kısım eklemek veya onu LOOP WHILE b<100ya da buna benzer bir şey yapmak isteyebilirsiniz .

Bu temelde sadece spec uygular. Geri döndüğümüz sayıların her zaman en son atlanan sayı ile ondan önce atlanan sayı arasındaki sayılar olacağını gözlemleyin. Bu sınırları ave olarak saklıyoruz ve aralarındaki tüm sayıları yazdırmak biçin bir FORdöngü kullanıyoruz .

05AB1E , 14 bayt

0)sƒ¤N+LÁ«}Ùs£

Çevrimiçi deneyin!

R , 70 bayt

function(e){for(i in 1:e)F=c(setdiff((F+i):1-1,F),F[1]+i,F);rev(F)[e]}

Çevrimiçi deneyin!

• 1 endeksli
• F@JAD önerisi sayesinde sabit kullanarak -4 bayt
• @Giuseppe önerisi sayesinde listeyi tersine çeviren -5 bayt
• @JAD önerisi sayesinde döngü için gereksiz baytları kaldıran -2 bayt
• -2 kullanılarak bayt setdiffyerinex[x %in% y]

Önceki sürüm (79 bayt)

Python 2 , 123 bayt

def f(z):[s.extend([s[-1]+n]+[x for x in range(s[-1]+1,s[-1]+n)if not x in s]) for n in range(1,z)if len(s)<z];return s    

Çevrimiçi deneyin!

X girişi verildiğinde, dizinin ilk x terimini çıkar,

Python'u öğreniyorum ve bu zorluklar işleri daha ilginç kılıyor.

Düzenleme: bazı boşlukları tıraş et

Jöle , 16 bayt

RÄṬŻk²Ḋ$ṙ€-Ø.;Fḣ

Çevrimiçi deneyin!

Mevcut Jelly cevabından bir bayt daha uzun ama bu muhtemelen biraz golf olabilir. RÄṬŻk²Ḋ$belki daha kısa olabilir.

18 bayt

RÄṬŻk²Ḋ$‘ṙ€1FŻŻỤ’ḣ

Daha uzun ama farklı.

Ruby , 63 bayt

->x,n=0{n+=1while 0>d=n*n+n<=>2*x-6;[0,1,3,2][x]||[x+n,x-1][d]}

Çevrimiçi deneyin!

0 endeksli. Muhtemelen golf edilebilir.

Perl 6 , 52 bayt

(0,{((^max @_)∖@_).min.?key//(1+@_[*-1]+$++)}...*)

Çevrimiçi deneyin!

Bu, ...operatörü kullanan bir jeneratör ifadesidir . Bu önceki sekansı içinde aralıkların arar @_ile ((^max @_)∖@_).min.?key:

      @_  # prior sequence values         [0,1,3]
  max @_  # largest prior sequence value       3
 ^        # the Range 0..max @_            0,1,2
(       )∖@_  # set subtract prior seq     -0,1  -> (2=>True)
            .min  # smallest unseen value  2=>True
                .?key  # set yields pairs  2

A ?olmayan ilk değer için gereklidir .key. Boşluk bulunmazsa, $listedeki son değere n (burada değişkende) ve 0 hata ile bir tane ekler .

Python 3 , 104 bayt

def f(x):
 n=a=0
 l=list(range(x*x))
 while n<x:print(l[a+n],*l[a+2-(n<3):a+n],end=' ');a=a+n-(a>0);n+=1

Çevrimiçi deneyin!

X girişi verildiğinde, ilk x "sekansları" çıktılayın