( Kodlayıcı.com'da çok oyunculu bir oyundan (kod çatışması) alınan zorluklar )

Meydan okuma

Aşağıdaki dizinin n. Terimini bulun : 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...ya da daha belirgin hale getirmek için{1}, {1,2}, {1,2,3}, {1,2,3,4}...

Dizi 1'den x'e kadar olan 1'den x'e kadar olan birleştirilmiş aralıklardan oluşur.

Kurallar / IO

Giriş ve çıkış, ayırt edilebildiği sürece herhangi bir formatta olabilir. Giriş, herhangi bir uygun kaynaktan alınabilir: STDIN, file, etc ...

Giriş 0- ya da 1-endeksli ve seçilen indeksleme olabilir gereken yazı sözü.

En az 255 dahil olmak üzere sonuç işlemeniz gerekecek (yani 0 indeksli maksimum giriş 32640'dır). Diliniz destekliyorsa, bunun üzerinde herhangi bir şey ele alınmalıdır.

Bu code-golfyüzden en kısa bayt sayısı kazanır!

Test durumları (0 tabanlı dizin oluşturma)

0 -> 1
1 -> 1
5 -> 3
10 -> 1
59 -> 5
100 -> 10
1001 -> 12

05AB1E , 5 bayt

Program 0 dizinli, kod:

ÌLL¹è

Açıklama:

Ì       # Double increment the input
 LL     # List of list on the input
   ¹è   # Get nth element

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Haskell , 27 26 bayt

([z|k<-[1..],z<-[1..k]]!!)

Çevrimiçi deneyin!

@DanD teşekkürler. -1 bayt için!

Bu sonsuz bir dizi yaratmak bir sadece dönen, anonim fonksiyonu nda inci elemanının: [[1..k]| k<-[1..]]listesinin sonsuz bir listesi üretir: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Bunları birleştirmek için [z|k<-[1..],z<-[1..k]]hangi sonucu elde ettiğini [1,1,2,1,2,3,1,2,3,4,...]ve nihayet (...!!)girdiyi kabul ettiğini yazabiliriz n(anlamsız gösterim) ve n-th terimini (0-based) döndürür .

JavaScript, 29 28 bayt

Arnauld sayesinde -1 bayt!

f=(n,m)=>n++<m?n:f(n+~m,-~m)

OEIS'te bulunan 0 indeksli özyinelemeli formülü kullanır.

Beklendiği gibi 1 argümanı ile çağrıldığında, ikincisinin varsayılan değeri m, olacaktır undefined. Ancak, argüman listesinde -~undefinedaçık bir şekilde belirtmeden özyinelemeyi döndürmemizi sağlayan 1 değerini döndürür m = 1(thanks @Arnauld!)

Test snippet'i:

f=(n,m)=>n++<m?n:f(n+~m,-~m)

let examples = [0, 1, 5, 10, 15, 1000];

examples.forEach(function log(x) {
    console.log(x, " => ", f(x))
});

Alternatif olarak, aynı bayt sayısı için, şöyle bir kıvrımlı fonksiyona sahip olabiliriz:

f=n=>m=>n++<m?n:f(n+~m)(-~m)

Bunu ile çağırabilirsiniz f(5)()- çağrıldığında sonucu bu meta gönderimde açıklandığı şekilde döndüren bir işlev döndürür .

Jöle , 5 bayt, 1 indeksli

RRF³ị

Çevrimiçi deneyin!

Açıklama:

                                      (Assume N = 4 for the examples)
R      Generate a list of 1 to N      [1, 2, 3, 4]
 R     Generate new lists for each item on the previous list, with that item as N
                                      [[1], [1,2], ...]
  F    Flatten that list              [1, 1, 2, 1, 2, 3 ...]
   ³ị  Use the input number (³) as index (ị) on the list. 
       This is one-based:             [1, 1, 2, 1, 2, 3 ...] 
                                                ^

Octave, 39 bayt

@(z)z-(n=ceil((8*z+1)^.5/2-.5))*(n-1)/2

1- tabanlı endeks

Açıklama:

Bu sırayı düşünün:

1   1   2   1   2   3   1   2   3   4   1   2   3   4   5

Ek elemanların sayısını sayarsak,

1   2        3          4               5         

Bu nedenle , üçgen sayı için Gauss formülünü kullanarak z için bir formül oluşturabiliriz:

z=n*(n+1)/2

n için çözersek bu ikinci dereceden bir denklemdir

n=(sqrt(8*z+1)-1)/2

Çevrimiçi Deneyin!

Haskell, 25 24 bayt

(!!)$[1..]>>= \x->[1..x]

Kullanım örneği: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Çevrimiçi deneyin! .

Adsız bir listeden listeye 1'den x'e işlevini \x->[1..x](yerleşik enumFromTo 1bir bayt daha uzun süredir) sonsuz listeye [1..]eşler ve elde edilen listeleri tek bir listede birleştirir. !!nth öğesini seçer.

Bir bayt için @flawr teşekkürler.

Octave , 39 bayt

@(n){v=1:n,A=triu(v'+0*v),A(A>0)(n)}{3}

Çevrimiçi deneyin!

Bu alternatif bir yaklaşım kullanır.

Örneğin n=1bu A=triu(v'+0*v)matrisi yaratır

1   1   1   1
0   2   2   2
0   0   3   3
0   0   0   4

Sıfır öğelerin tümünü kaldırırken ve sütunları eklerken A(A>0)şu sırayı alırız:

1   1  2  1  2  3  1  2  3  4

O zaman sadece nbu dizinin -th terimini çıkarmaktır.

Python , 39 36 bayt

Dennis sayesinde -3 bayt!

1 tabanlı indeksleme kullanan özyinelemeli bir lambda.

f=lambda n,m=1:n*(n<=m)or f(n-m,m+1)

Çevrimiçi deneyin!

Mevcut "yükseliş" boyutunu kullanarak izleriz m. Eğer nbu değerden küçük veya ona eşitse m, mevcut “yükselişe” uyuyor ve biz onu geri veriyoruz. Ancak, eğer daha büyükse m, ondan muzaklaşırız, 1 ekleriz mve işlevi tekrar tekrar çağırırız (bir sonraki yükselişe geçerek).

R, 25 bayt

i=scan();sequence(1:i)[i]

Endeks 1 tabanlıdır.

Pyth , 6 5 bayt

@TheBikingviking sayesinde 1 bayt kurtarıldı !

@s._S

Bu 0 tabanlı indeksleme kullanır.

Çevrimiçi deneyin!

açıklama

@          Index with implicit input into
   ._      all prefixes of
     S     1-based range of implicit input
 s         concatenated into an un-nested list

Mathematica, 27 24 bayt

3 byte için @ Martininder teşekkürler!

((r=Range)@r@#<>1)[[#]]&

1 endeksli. Bu, göz ardı edilmesi güvenli olan hataları atar.

açıklama

((r=Range)@r@#<>1)[[#]]&
  r=Range                 (* Store Range function in r *)
           r@#            (* Create list {1..n} *)
 (r      )@               (* For each element, generate {1..n} *)
              <>1         (* Join the lists and append a 1; throws errors *)
(                )[[#]]&  (* Take the nth element *)

brainf * ck, 78 bayt

,>+<[>[->>+>+<<<]>>>[-<<<+>>>]<<+[->->+<<]>[<<->>>[-<<+>>]<[-]]>[-]<<<+<-]>>+.

Girdiyi (0 tabanlı) alır ve bayt değeri olarak çıkar.

Burada test edebilirsiniz .

Giriş, \ondalık sayılardan önce gerektirir (örneğin \1010 için). Çıktı yazdırılabilir bir ASCII karakteri ise, görmeniz gerekir. Aksi takdirde, görünüm belleği -> son dökümü isabet. Yazdırılan değer 3. hücrede (hücre sayısı 2).

Açıklama:

Hücre 0 (GİRİŞ): Girdidir ve döngü boyunca her defasında 1'imi düşürür.

Hücre 1 (RESET): TERM'e eşit olduğu her seferde 1 artar. Bunu yapmak için, döngü boyunca her zaman 1 ekleriz ve eğer eşit değilse, 1'i çıkarırız.

Hücre 2 (TERM): her döngüde 1 artar ve RESET ile eşleşirse 0 olarak ayarlanır. Bunu yapmak için, bu hücre RESET'e eşit değilse, değeri yalnızca HOLD'tan geri kopyalarım.

Hücre 3 (EQUAL): RESET ve TERM'in eşit olup olmadığını kontrol etmek için kullanılır.

Hücre 4 (HOLD): RESET ve TERM değerlerini eşittir kontrolünden sonra geri kopyalamak için kullanılır.

,>+<              # get input and put a 1 in RESET
[                 # for INPUT to 0
  >[->>+>+<<<]    # copy RESET to EQUAL and HOLD
  >>>[-<<<+>>>]   # copy HOLD back into RESET
  <<+             # add 1 to TERM
  [->->+<<]       # subtract TERM from EQUAL and copy it to HOLD
  >[              # if RESET and TERM were not equal
    <<-           # subtract 1 from RESET
    >>>[-<<+>>]   # copy HOLD back to TERM
    <[-]          # zero out EQUAL
  ]               # end if
  >[-]            # zero out HOLD
  <<<+            # add 1 to RESET (this cancels out the subtraction if
                  #     RESET did not equal TERM)
  <-              # subtract 1 from INPUT
]>>+.             # end for and add 1 because the sequence resets to 1 not 0

Pyke, 6 bayt

OmSsQ@

Burada dene!

O      -    input+2
 mS    -   map(range(1,i+1), range(^))
   s   -  sum(^)
    Q@ - ^[input]

0 endeksli.

R, 43 41 bayt

Düzenleme: A002262 + 1 (0 dizinlenmiş) kullanarak daha kısa özyinelemeli bir yaklaşım bulundu :

f=function(n,m=1)`if`(n<m,n+1,f(n-m,m+1))

Eski versiyon:

n=scan();n-choose(floor((1+sqrt(8*n))/2),2)

OEIS'den 1 indeksli formül.

Perl 6 , 21 bayt

{map(|^*,^∞)[$_]+1}

0 endeksli. Çevrimiçi deneyin!

Nasıl çalışır:

{                 }  # A lambda.
         ^∞          # Range from 0 to Inf-1. (Same byte count as 0..*, but cooler.)
 map( ^*,  )         # Map each number n to the range 0..(n-1),
     |               # And slip each range into the outer list.
            [$_]     # Index the sequence with the lambda argument.
                +1   # Add 1.

Perl 6 , 21 bayt

{[\,](1..*).flat[$_]}

0 endeksli. Çevrimiçi deneyin!

Nasıl çalışır:

{                   }  # A lambda.
      1..*             # Range from 1 to infinity.
 [ ,](    )            # Fold it with the comma operator,
  \                    # and return all intermediate results, e.g. (1), (1,2), (1,2,3)...
           .flat       # Flatten the sequence.
                [$_]   # Index it with the lambda argument.

Bu çözümlerin hiçbiri JungHawn Min'inki kadar kısa değil, fakat sanırım alternatif bir yaklaşım. Her ikisi de (1-indeksli) pozitif tamsayı girişi alan ve pozitif bir tamsayı döndüren adsız işlevlerdir.

Mathematica, 30 bayt

-#^2-#&@⌈√(2#)-3/2⌉/2+#&

Bu fonksiyon için gerçek bir matematik formülü! (3 bayt karakterler çevirerek kısmen daha okunabilir yapılmış ⌈, √ve ⌉):

# - ((#^2 + #) / 2 &)[Ceiling[Sqrt[2 * #] - 3/2]] &

Ceiling[Sqrt[2 * #] - 1/2]bize girdiye girmeden önce hangi alt listenin bittiğini söylemek için hangi girdinin hangi alt listeye başvurduğunu söyler; sonra ((#^2 + #) / 2 &), önemsediğimiz listeden önce tüm alt listelerde kaç eleman olduğunu, #cevabımızı almak için girdiden çıkardığımız hesaplamaları yapar . (Bazı bilinen formül fark edecektir (#^2 + #) / 2için #inci üçgen sayısı, Ceiling[Sqrt[2 * #] - 1/2]ters fonksiyon esas olarak).

Mathematica, 32 bayt

If[#2<=#,#2,#0[#+1,#2-#]]&[1,#]&

Özyinelemeli çözüm, temelde Billywob'un cevabı ve diğerleriyle aynı.

Brain-Flak , 46 bayt

Sıfır dizinli

(<>()){(({}())[()]){({}[()])<>}{}}<>([{}()]{})

Çevrimiçi deneyin!

Yığın Temizliği, 48 bayt

(<>()){(({}())[()]){({}[()])<>}{}}{}<>([{}()]{})

Çevrimiçi deneyin!

açıklama

Bu modulo fonksiyonunun değiştirilmiş bir versiyonudur . Bölen olarak sabit bir sayı kullanmak yerine, bölen her defasında böleni artırır (dış döngü yinelemesi başına bir kez).

Açıklamalı Kod

(<>())       # Switch to the opposite stack and push 1 (the initial divisor)
{            # (outside loop) While top of stack is not 0...
  (          # Push...
    ({}())   # Push the divisor plus 1
  [()])      # ...minus one (ie push a copy of the original divisor
  {          # (inner loop) While the top of stack does not equal zero
    ({}[()]) # Decrement the top of the active stack
    <>       # Switch stacks
  }{}        # (inside loop) End loop and pop zero off the top of stack)
}            # (outside loop) End loop
<>           # Switch stacks (to the one with the divisor)
([{}()]{})   # Calculate the result

Java 8, 85 73 55 bayt

n->f(n,1)+1int f(int n,int m){return n<m?n:f(n-m,m+1);}

OEIS'te verilen formülle 0 indeksli özyinelemeli yaklaşım :

a(n) = 1 + A002262(n).
A002262 : a(n)=f(n,1)ile f(n,m) = if n<m then n else f(n-m,m+1).

Burada dene.

Eski cevap ( 85 56 bayt):

n->{int m=~-(int)Math.sqrt(8*n+1)/2;return n-m*-~m/2+1;}

Sağlanan diğer 0-endeksli formülü kullanılmış OEIS :

n-inci terimi n - m*(m+1)/2 + 1, nerede m = floor((sqrt(8*n+1) - 1) / 2).

Burada dene.

Perl , 30 bayt

29 bayt kodu + -pbayrak.

map{$\-=$c++if$c<++$\}0..$_}{

Çevrimiçi deneyin!

MATL, 8 bayt

:"@:]vG)

Bu çözüm 1 tabanlı endeksleme kullanıyor

MATL Online'da deneyin

açıklama

        Implicitly grab input (N)
:       Create an array from [1...N]
"       For each element (A) in this array...
  @:    Create an array from [1....A]
]       End for loop
v       Vertically concatenate everything on the stack
G       Explicitly grab the input again
)       And use it to index into the vertically concatenated array
        Implicitly display the result

QBIC , 21 bayt, 1 indeksli

:[a|[b|~q=a|_Xc\q=q+1

Açıklama:

:      Get 'a' from the cmd line
[a|    FOR (b = 1; b <= a; b++) This creates an outer loop from 1 to N
[b|    FOR (c = 1; c <= b; c++) This creates an iteration, yielding the 1, 12, 123 pattern
       'q' stores how many terms we've seen. It starts at 1 b default.
~q=a   if we are at the desired term (q == a)
|_Xc   Then quit, and print 'c' (the current number in the sequence)
\q=q+1 Else, increase 'q' and run again.

Biraz daha ilginç bir yaklaşım, ancak 10 bayt daha uzun:

:{~b+q>=a|_xa-b|\b=b+q┘q=q+1

Bu program sürekli olarak bu parantez içindeki toplam sayı sayısını ve tüm önceki sayıları ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...) hesaplar . Bu sayaç aranan N endeksini aştığında, geçerli parantezden X değerini döndürün; burada X, N'nin eksi sayıcıdan önceki miktarıdır.

Yakut, 30 bayt

->n{(0..n).find{|x|0>=n-=x}+n}

1 tabanlı indeksleme

R, 37 bayt

n=scan();for(i in 2:n)T=c(T,1:i);T[n]

Girdileri alır nve ilk ndiziler için diziyi oluşturur . Bu, daha yüksek girişlerde biraz verimsiz hale getirir, ancak iyi olması gerekir. Daha sonra n1 indeksli -th girişi döndürür .

Kullanımları ile diziyi kapalı başlatarak güzel küçük bir hile Tolduğunu TRUEveya 1varsayılan olarak.

C11, 48 bayt

int f(int x){int q=1;while(x>q)x-=q++;return x;}

Çevrimiçi deneyin!

Ayrıca C ++ ve Java ile de çalışır.

Aynı bayt sayısı için bir alternatif:

int f(int x){int q=0;while(x>++q)x-=q;return x;}

brainfuck, 141 bayt

Ödül için çok geç kaldığımı biliyorum, ancak sonuçta düşündüğüm algoritmanın kaç baytı olduğunu görmek istedim.

Bu program sıfır dizinli.

,>+<[[->>+>+<<<]>>[-<<+>>]<[->+>>+<<<]>[-<+>]>>+[[-<->>+<]>[-<+>]<<<<]>>[>>>]>[.[<<<]]<<<<<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>>[>>>]<<<]>[.>]

Çevrimiçi deneyin

• Dinamik (sonsuz) Belleği Seçin veya çalışmaz
• Test giriş değerleri için> 255, değiştirmek Hücre boyutu (bit) ile 16 ya da 32 .
• Tercüman nasıl giriş yapılacağını açıklar. İçin ondalık girdi kullanım \5girişi için 5.
  • Girişi test edebileceğiniz maksimum ondalık değer \999
  • Onaltılık giriş, hücre boyutu kadar yüksek olabilir.

Açıklama:

Bu programın adım adım parçalandığını ve giriş için ne olacağını gösterir 5.#tercüman için ideal hafıza boşaltma konumlarına yerleştirilir.

Muhtemelen karakter char charter bellek# onay kutusunu kullanmak isteyeceksiniz : bu sürümü çalışıyorsa. Bu isabet üzerine hafızayı boşaltacaktır #, bu da kasette değeri yazdırılamaz bir karakter olması durumunda ya da istediğiniz adımda ne olacağını görmeniz için bant üzerindeki değeri görmenize izin verecektir . İşaretçinin üzerinde bulunduğu hücre koyu renkli olacaktır.

,>+<                       (5) 1
[[->>+>+<<<]>>[-<<+>>]       5 1 (0) 5
<[->+>>+<<<]>[-<+>]>>+       5 1 0 5 (2)
[[-<->>+<]>[-<+>]<<<<] (0) 0 4 1 0 3 2 0 0
>>[>>>]                      4 1 0 3 2 0 (0) 0
                             1 1 0 (0) 2 0
>[.#[<<<]]<<<<                4 1 0 (3) 2 0 0 0
<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>> (3) 1 0 3 2 0 0 0
[>>>]<<<]>[.#>]

Tape structure:
    (cell_1 cell_2 temp), (cell_1 cell_2 temp), ...

Take Input;
If not zero:
  copy last pair to the right and add one to its cell_2
  subtract each cell_2 from each cell_1 (leaving each cell_2 intact)
  move checking from left to right: 
    If cell_1 is zero and cell_2 isn't:
      print cell_2
    Else:
      copy last cell_1 back, overwriting each previous cell_1
Else:
  right one and print result

Çevrimiçi deneyin

• Dinamik (sonsuz) Bellek Seçinveya çalışmaz
• Char'da Bellek Dökümü: #

Notlar:

• Bunu, başlangıç ​​hücresinin soluna hareket etmesine izin vermeyen başka bir tercüman üzerinde çalıştırmak için (bu yüzden Dinamik Bellek kullanıyorum), >başlangıçta bir demet koyun . Gerekli sayı giriş değerine bağlı olarak değişebilir, ancak O (1).

tinilisp (repl), 90 bayt (0 indeksli)

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(s x(s 0 1)))(r(s n 1)(s j(s 0 1))x))j
(q((n)(r n 1 1

Veya, rekabet etmeyen (bu zorluğun yayınlanmasından sonra işlenen bir özelliği kullanarak), 80 bayt :

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(a x 1))(r(s n 1)(a j 1)x))j
(q((n)(r n 1 1

İlk satır bir yardımcı işlevi tanımlar rve ikinci satır ndizinin nt terimini alan ve döndüren adsız bir işlevdir . Bunu bir repl gönderimi olarak belirledim, çünkü repl, yalnızca programın sonunda değil, her satırın sonunda parantezleri otomatik olarak tamamlar. Bu uyarılarla, işte çevrimiçi olarak çalışacak şekilde değiştirilmiş bir sürümü. 0 ile 54 arasındaki girişlere karşı çalıştırılmış .

açıklama

Burada rakip olmayan sürümü kullanacağım. Tek fark, resmi versiyonun iki çıkarma olarak ekleme yapması gerektiğidir.

(d r           Define r to be:
 (q(           A lambda function (= a list of two elements, quoted to prevent evaluation):
  (n j x)       Arguments n, j (the range counter), and x (the range limit)
  (i n          If n is truthy, i.e. nonzero:
   (i(e j x)     If counter equals limit:
    (r            Call r recursively on:
     (s n 1)       n-1
     1             counter reset to 1
     (a x 1))      limit increased by 1
    (r           Else, call r recursively on:
     (s n 1)       n-1
     (a j 1)       counter increased by 1
     x))           same limit
   j))))        Else, we're done; return the counter value

(q(            Lambda function:
 (n)            Argument n
 (r n 1 1)))    Call r with n, counter = 1, range limit = 1

C, 54 bayt

En kısa C çözümü değil, ancak sabit zamanda çalışmanın yararı var (döngüler yok, sadece matematik). Sıfır tabanlı endeksleme kullanır:

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

Ungolfed:

int f(int n) {
    int x = floor(sqrt(8*n+1)-1)/2; //calculate the number of the current subsequence (zero based)
    return 1+n-x*(x+1)/2;   //x*(x+1)/2 is the zero based index of the `1` starting the subsequence
}

Şununla test et:

#include <math.h>
#include <assert.h>
#include <stdio.h>

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

int main(){
    int i;
    for(i = 0; i < 10; i++) printf("%d ", f(i));
    printf("\n");

    assert(f(0) == 1);
    assert(f(1) == 1);
    assert(f(5) == 3);
    assert(f(10) == 1);
    assert(f(59) == 5);
    assert(f(100) == 10);
    assert(f(1001) == 12);
}

C, 103 bayt

Yeni başlayanlar için sorun değil, sanırım :).

int main(){int n,c,i,j;scanf("%d",&n);while(c<n){for(i=1;i<=j;i++){c++;if(c==n)printf("%d",i);}j++;}}

veya biçimlendirilmiş yol

#include <stdio.h>

int main() {
    int n,c,i,j;
    scanf("%d",&n);
    while(c<n) 
    {
        for(i=1;i<=j;i++)
        {
            c++;
            if(c==n) printf("%d",i);
        }
        j++;
    }
}

dc , 21 bayt, 0 tabanlı indeksleme

?d8*1+v1-2/d1+*2/-1+p

DC programını çevrimiçi olarak deneyin!

Açıklama:

?      Push input number n.
d      Duplicate n at the top of the stack.
8*1+   Replace n at the top of the stack with 8n+1.
v      Replace 8n+1 at the top of the stack with the floor of its square root.
1-2/   Subtract 1, and divide by 2 (ignoring any fractional part).

Yığının üstü şimdi <= n olan en büyük üçgen sayısının k dizinini tutuyor.

d1+*2/ Compute k(k+1)/2, which is the greatest triangular number <= n.
-      Subtract n-(the greatest triangular number <= n). The first n is on the stack in position 2, because the input number n was duplicated at the top of the stack at the very beginning of the program, and only one of the values was popped and used (until now).
1+     Add 1 because the desired sequence starts over again at 1 (not 0) at every triangular number.
p      Print the answer.

Bu dc programı, rekabetçi boyutta bir bash betiğine dönüştürülebilir:

Bash + Unix yardımcı programları, 28 bayt, 0 tabanlı dizin oluşturma

dc -e"?d8*1+v1-2/d1+*2/-1+p"

Bash programını çevrimiçi olarak deneyin!

C, 81 44 bayt

düz yinelemeli yöntem, 0 indekslenmiş ve hafif bir masajla;

m=1,c=1;f(n){for(;n--;c=c^m?c+1:!!++m);c=c;}

Çevrimiçi deneyin!