(Wyzwanie wzięte z gry wieloosobowej (zderzenie kodu) na codingame.com )

Wyzwanie

Znajdź n- ty termin z następującej sekwencji: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...lub, aby było to bardziej oczywiste,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

Sekwencja składa się z połączonych zakresów od 1 do x , zaczynając od 1, aż do nieskończoności.

Zasady / IO

Dane wejściowe i wyjściowe mogą być w dowolnym formacie, o ile jest to możliwe do odróżnienia. Dane wejściowe można pobrać z dowolnego odpowiedniego źródła: STDIN, plik itp.

Dane wejściowe mogą być indeksowane 0 lub 1, a wybrane indeksowanie musi być wymienione w poście.

Będziesz musiał obsłużyć co najmniej do wyniku 255 włącznie (co oznacza, że ​​maksymalne wejście indeksowane 0 to 32640). Wszystko, co musi zostać rozwiązane, jeśli Twój język to obsługuje.

To jest code-golftak, że wygrywa najkrótsza liczba bajtów!

Przypadki testowe (indeksowanie 0)

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

05AB1E , 5 bajtów

Program jest indeksowany 0, kod:

ÌLL¹è

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Haskell , 27 26 bajtów

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

Wypróbuj online!

Dzięki @DanD. dla -1 bajtów!

Jest to anonimowa funkcja, tworząc nieskończoną sekwencję tylko zwrócenie nich -tego elementu: [[1..k]| k<-[1..]]produkuje nieskończoną listę listy: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Aby je połączyć, możemy napisać, [z|k<-[1..],z<-[1..k]]które wynikają [1,1,2,1,2,3,1,2,3,4,...]i ostatecznie (...!!)akceptują dane wejściowe n(notacja bezcelowa) i zwracają n-ty termin (na podstawie 0).

JavaScript, 29 28 bajtów

-1 bajt dzięki Arnauld!

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

Wykorzystuje rekurencyjną formułę 0 indeksowaną znalezioną w OEIS.

Gdy zostanie wywołany z 1 argumentem zgodnie z oczekiwaniami, domyślną wartością drugiego m, będzie undefined. Jednakże -~undefined, zwraca 1, co pozwala nam uzyskać rekursji toczenia bez wyraźnego m = 1w liście argumentów (dzięki @Arnauld!)

Fragment testowy:

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

Alternatywnie, dla tej samej liczby bajtów, możemy mieć funkcję curry taką jak:

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

Możesz to wywołać za pomocą f(5)()- zwraca funkcję, która po wywołaniu zwraca wynik, jak opisano w tym meta-postie .

Galaretka , 5 bajtów, indeksowana 1

RRF³ị

Wypróbuj online!

Wyjaśnienie:

                                      (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 ...] 
                                                ^

Oktawa, 39 bajtów

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

Indeks 1-

Wyjaśnienie:

Rozważ tę sekwencję:

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

jeśli policzymy liczbę elementów podsekwencji mamy

1   2        3          4               5         

więc za pomocą wzoru Gaussa na liczbę trójkątną możemy utworzyć wzór na z:

z=n*(n+1)/2

jest to równanie kwadratowe, jeśli rozwiążemy je dla n mamy

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

Wypróbuj online!

Haskell, 25 24 bajtów

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

Przykład użycia: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Wypróbuj online! .

Mapuje anonimową funkcję make-a-list-from-1-to-x \x->[1..x](wbudowany enumFromTo 1jest o jeden bajt dłużej) na nieskończoną listę [1..]i łączy wynikowe listy w jedną listę. !!wybiera n-ty element.

Dzięki @flawr za jeden bajt.

Oktawa , 39 bajtów

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

Wypróbuj online!

To wykorzystuje alternatywne podejście.

Na przykład n=1ta A=triu(v'+0*v)tworzy macierz

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

Po usunięciu wszystkich elementów zerowych i dołączeniu kolumn A(A>0)otrzymujemy sekwencję:

1   1  2  1  2  3  1  2  3  4

Zatem jest to tylko kwestia odciągnięcia n-tego terminu tej sekwencji.

Python , 39 36 bajtów

-3 bajty dzięki Dennisowi!

Rekurencyjna lambda, która wykorzystuje indeksowanie 1.

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

Wypróbuj online!

Śledzimy aktualny rozmiar „wzrostu” za pomocą m. Jeśli njest mniejszy lub równy m, mieści się w bieżącym „wzroście”, więc zwracamy go. Jeśli jednak jest większy niż m, modejmujemy go, niż dodajemy 1 do mi wywołujemy funkcję rekurencyjnie (przechodząc do następnego wzrostu).

R, 25 bajtów

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

Indeks jest oparty na 1.

Pyth , 6 5 bajtów

1 bajt zapisany dzięki @TheBikingviking!

@s._S

Korzysta z indeksowania opartego na 0.

Wypróbuj online!

Wyjaśnienie

@          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 bajtów

Dzięki @MartinEnder za 3 bajty!

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

1-indeksowany. To powoduje błędy, które można bezpiecznie zignorować.

Wyjaśnienie

((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 bajtów

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

Pobiera dane wejściowe (oparte na 0) i dane wyjściowe jako wartości bajtów.

Możesz to przetestować tutaj.

Wprowadzanie wymaga \liczb przed dziesiętnych (np. \10Dla 10). Jeśli wynik jest drukowalnym znakiem ASCII, powinieneś go zobaczyć. W przeciwnym razie wciśnij pamięć widoku -> ostatni zrzut. Wydrukowana wartość znajduje się w trzeciej komórce (komórka nr 2).

Wyjaśnienie:

Komórka 0 (WEJŚCIE): jest wejściem i jest zmniejszana za każdym razem przez moją pętlę.

Komórka 1 (RESET): zwiększa się o 1 za każdym razem, gdy jest równa TERM. Aby to zrobić, za każdym razem przez pętlę dodajemy 1, a jeśli nie są równe, odejmujemy 1.

Komórka 2 (TERM): zwiększa się o 1 w każdej pętli i jest ustawiona na 0, jeśli pasuje do RESET. Aby to zrobić, kopiuję wartość z HOLD tylko wtedy, gdy komórka nie jest równa RESET.

Komórka 3 (RÓWNA): służy do sprawdzenia, czy RESET i TERM są równe.

Komórka 4 (HOLD): służy do kopiowania wartości RESET i TERM z powrotem po sprawdzeniu równości.

,>+<              # 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 bajtów

OmSsQ@

Wypróbuj tutaj!

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

0-indeksowane.

R, 43 41 bajtów

Edycja: Znaleziono krótsze podejście rekurencyjne za pomocą A002262 + 1 (zindeksowane 0):

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

Stara wersja:

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

1-indeksowana formuła OEIS.

Perl 6 , 21 bajtów

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

0-indeksowane. Wypróbuj online!

Jak to działa:

{                 }  # 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 bajtów

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

0-indeksowane. Wypróbuj online!

Jak to działa:

{                   }  # 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.

Żadne z tych rozwiązań nie jest tak krótkie jak JungHawn Min , ale są to alternatywne podejścia, co wydaje mi się. Obie są nienazwanymi funkcjami przyjmującymi dodatnią liczbę całkowitą (indeksowaną 1) i zwracającą liczbę całkowitą dodatnią.

Mathematica, 30 bajtów

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

Rzeczywisty wzór matematyczny dla tej funkcji! Bardziej czytelne (częściowo tłumacząc znaki 3-bajtowych ⌈, √i ⌉):

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

Ceiling[Sqrt[2 * #] - 1/2]mówi nam, do której podlisty odnosi się dane wejściowe, od której odejmujemy jedną, aby powiedzieć nam, która podlista kończy się, zanim dojdziemy do danych wejściowych; następnie ((#^2 + #) / 2 &)oblicza, ile elementów występuje na wszystkich podlistach przed tym, na którym nam zależy, które odejmujemy od danych wejściowych, #aby uzyskać odpowiedź. (Niektórzy zauważą znaną formułę (#^2 + #) / 2dla #trzeciej liczby trójkątnej; Ceiling[Sqrt[2 * #] - 1/2]jest to w zasadzie funkcja odwrotna).

Mathematica, 32 bajty

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

Rozwiązanie rekurencyjne, w zasadzie takie samo jak w odpowiedzi Billywoba i innych.

Brain-Flak , 46 bajtów

Zero indeksowane

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

Wypróbuj online!

Stack Clean, 48 bajtów

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

Wypróbuj online!

Wyjaśnienie

To jest zmodyfikowana wersja funkcji modulo . Zamiast używać stałej liczby jako dzielnika, zwiększa on dzielnik za każdym razem, gdy dzielnik jest odejmowany (raz na iterację w pętli zewnętrznej).

Kod z adnotacjami

(<>())       # 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 bajtów

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

Podejście rekurencyjne z indeksowaniem 0 i wzorem podanym w OEIS :

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

Wypróbuj tutaj.

Stara odpowiedź ( 85 56 bajtów):

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

Zastosowano inną formułę 0 indeksowaną podaną w OEIS :

n-ty termin to n - m*(m+1)/2 + 1, gdzie m = floor((sqrt(8*n+1) - 1) / 2).

Wypróbuj tutaj.

Perl , 30 bajtów

29 bajtów kodu + -pflaga.

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

Wypróbuj online!

MATL, 8 bajtów

:"@:]vG)

To rozwiązanie wykorzystuje indeksowanie 1

Wypróbuj w MATL Online

Wyjaśnienie

        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 bajtów, 1-indeksowany

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

Wyjaśnienie:

:      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.

Nieco bardziej interesujące podejście, ale o 10 bajtów dłuższe:

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

Ten program stale oblicza całkowitą liczbę liczb w tym przedziale i we wszystkich poprzednich ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...). Gdy licznik przekroczy poszukiwany indeks N, zwróć X z bieżącego przedziału, gdzie X to N minus poprzednia wartość licznika.

Rubinowy, 30 bajtów

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

Indeksowanie 1

R, 37 bajtów

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

Pobiera dane wejściowe z ni tworzy sekwencję dla pierwszych nsekwencji. To sprawia, że ​​jest nieco nieefektywne przy wyższych wejściach, ale powinno być w porządku. Następnie zwraca n-ty wpis, 1-indeksowany.

Używa małej sztuczki, rozpoczynając sekwencję od T, która jest TRUElub 1domyślnie.

C11, 48 bajtów

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

Wypróbuj online!

Działa również w C ++ i Javie.

Alternatywa dla tej samej liczby bajtów:

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

pieprzenie mózgu, 141 bajtów

Wiem, że spóźniłem się na nagrodę, ale chciałem tylko zobaczyć, ile bajtów algorytm, o którym myślałem, ostatecznie się skończy.

Ten program jest indeksowany na zero.

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

Wypróbuj online

• Wybierz Pamięć dynamiczna (nieskończona) , w przeciwnym razie nie będzie działać
• Aby przetestować wartości wejściowe> 255, zmień Rozmiar komórki (Bity) na 16 lub 32 .
• Tłumacz wyjaśnia, w jaki sposób udzielać informacji. Dla dziesiętnych wejściowego użytku \5na wejściu 5.
  • Maksymalna wartość dziesiętna, za pomocą której można testować dane wejściowe, to \999
  • Dane szesnastkowe mogą przekraczać wielkość komórki.

Wyjaśnienie:

To pokazuje program podzielony na etapy, pokazujący, co dzieje się na wejściu 5. #są umieszczane w idealnych lokalizacjach zrzutu pamięci dla tłumacza.

Prawdopodobnie będziesz chciał użyć pola wyboru Dump Memory at char:# jeśli uruchamiasz tę wersję. Spowoduje to zrzucenie pamięci po uderzeniu #, co pozwoli zobaczyć wartość na taśmie w przypadku, gdy jest to znak, którego nie można wydrukować, lub zobaczyć, co stanie się na dowolnym etapie. Komórka, na której znajduje się wskaźnik, będzie pogrubiona.

,>+<                       (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

Wypróbuj online

• Wybierz Pamięć dynamiczna (nieskończona) , w przeciwnym razie nie będzie działać
• Zrzut pamięci w char: #

Uwagi:

• Aby uruchomić to na innym tłumaczu, który nie pozwala na przejście na lewo od komórki początkowej (dlatego używam pamięci dynamicznej), włóż kilka >na początku. Wymagana liczba może się różnić w zależności od wartości wejściowej, ale wynosi O (1).

tinylisp (repl), 90 bajtów (indeksowane 0)

(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

Lub niekonkurencyjny (przy użyciu funkcji, która została zatwierdzona po opublikowaniu tego wyzwania), 80 bajtów :

(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

Pierwsza linia definiuje funkcję pomocniczą r, a druga linia jest nienazwaną funkcją, która przyjmuje ni zwraca n-ty termin sekwencji. Podałem to jako przesłanie repliki, ponieważ repl automatycznie uzupełnia nawiasy na końcu każdego wiersza, a nie tylko na końcu programu. Z tymi zastrzeżeniami, oto wersja zmodyfikowana do pracy w Try it online , a tutaj wersja bez golfa działa na wejściach od 0 do 54.

Wyjaśnienie

Użyję tutaj niekonkurencyjnej wersji. Jedyną różnicą jest to, że oficjalna wersja musi implementować dodawanie jako dwa odejmowania.

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

Nie jest to najkrótsze rozwiązanie C, ale ma tę zaletę, że działa w stałym czasie (bez pętli, tylko matematyka). Używa indeksowania zerowego:

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

Nie golfowany:

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
}

Testuj z:

#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 bajty

Myślę, że dla początkującego jest w porządku :).

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

lub sformatowany sposób

#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 bajtów, indeksowanie 0

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

Wypróbuj program DC online!

Wyjaśnienie:

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

Na górze stosu znajduje się teraz indeks k największej liczby trójkątnej, która wynosi <= n.

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.

Ten program DC można przekonwertować na konkurencyjny skrypt bash:

Narzędzia Bash + Unix, 28 bajtów, indeksowanie 0

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

Wypróbuj program bash online!

C, 81 44 bajtów

prosta metoda iteracyjna, zindeksowana 0 i z delikatnym masowaniem;

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

Wypróbuj online!