( codingame.com 의 멀티 플레이어 게임 (코드 충돌)에서 얻은 도전 )

도전

찾기 n은 다음과 같은 순서의 번째 임기를 : 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...또는, 그것이 더 분명하게,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

순서는 1 부터 시작하여 1부터 무한 까지 연결 범위로 구성됩니다.

규칙 / IO

입력과 출력은 구별 할 수있는 한 어떤 형식이든 가능합니다. STDIN, 파일 등 적절한 소스에서 입력을 가져올 수 있습니다.

입력은 0 또는 1 인덱싱 될 수 있으며 선택한 인덱싱 은 게시물에서 언급 해야합니다 .

최소한 255 개의 결과까지 처리해야 합니다 (0으로 색인화 된 최대 입력은 32640을 의미 함). 언어가 지원하는 경우 그 이상을 처리해야합니다.

이것은 code-golf가장 짧은 바이트 수가이기는 것입니다!

테스트 사례 (0 기반 색인 작성)

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

05AB1E , 5 바이트

이 프로그램은 0 인덱스 코드입니다.

ÌLL¹è

설명:

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

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

하스켈 , 27 26 바이트

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

온라인으로 사용해보십시오!

감사합니다 @ DanD. -1 바이트!

이것은 익명 함수이며 무한 시퀀스를 생성하고 n그것 의 -th 요소를 반환 [[1..k]| k<-[1..]]하면 무한한 목록을 생성합니다 : [[1],[1,2],[1,2,3],[1,2,3,4],...]. 다음을 연결하기 위해 우리가 쓸 수 [z|k<-[1..],z<-[1..k]]있는 어떤 결과를 [1,1,2,1,2,3,1,2,3,4,...]최종적으로 (...!!)입력 받아 n(무의미 표기) 및 반환 n번째 용어 (0 기반).

자바 스크립트, 29 28 바이트

Arnauld 덕분에 -1 바이트!

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

OEIS에서 찾은 0 인덱스 재귀 수식을 사용합니다.

예상대로 1 개의 인수를 사용하여 호출하면 두 번째의 기본값 m은입니다 undefined. 그러나, -~undefined1을 반환 m = 1하면 인수 목록에 명시 적없이 재귀 롤링을 얻을 수 있습니다 (@Arnauld 감사합니다!)

테스트 스 니펫 :

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

또는 동일한 바이트 수에 대해 다음과 같이 카레 함수를 사용할 수 있습니다.

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

이것을 호출 할 수 있습니다 f(5)()-함수를 반환합니다 . 이 메타 포스트에 설명 된 것처럼 호출되면 결과를 반환합니다 .

젤리 , 5 바이트, 1 인덱싱

RRF³ị

온라인으로 사용해보십시오!

설명:

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

옥타브, 39 바이트

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

1 기반 인덱스

설명:

이 순서를 고려하십시오.

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

하위 시퀀스의 요소 수를 세면

1   2        3          4               5         

삼각 숫자에 가우스 공식을 사용 하면 z에 대한 공식을 만들 수 있습니다.

z=n*(n+1)/2

그것이 우리가 n에 대해 풀면 2 차 방정식입니다.

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

온라인으로 사용해보십시오!

하스켈, 25 24 바이트

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

사용 예 : ((!!)$[1..]>>= \x->[1..x]) 10-> 1. 온라인으로 사용해보십시오! .

익명의 make-a-list-to-1--1-x 함수 \x->[1..x](내장 된 enumFromTo 11 바이트 더 긴 함수 )를 무한 목록 [1..]에 매핑하고 결과 목록을 단일 목록으로 연결합니다. !!n 번째 요소를 선택합니다.

1 바이트의 @flawr 덕분입니다.

옥타브 , 39 바이트

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

온라인으로 사용해보십시오!

이것은 다른 접근법을 사용합니다.

예를 들어 n=1이것은 A=triu(v'+0*v)행렬을 만듭니다

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

모든 0 요소를 제거하고 열을 추가 A(A>0)하면 시퀀스가 ​​나타납니다.

1   1  2  1  2  3  1  2  3  4

그렇다면 그것은 n그 순서 의- 번째 항을 빼는 것 입니다.

파이썬 , 39 36 바이트

Dennis 덕분에 -3 바이트!

1 기반 인덱싱을 사용하는 재귀 람다.

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

온라인으로 사용해보십시오!

우리는를 사용하여 현재의“라이즈”크기를 추적합니다 m. 경우 n보다 작거나 같음 m, 현재의 "상승"에 들어가고, 우리는 그것을 반환 할 수 있도록. 그러나이 값이보다 크면 1을 더하고 함수를 재귀 적으로 호출하는 것보다 m빼 m냅니다 m(다음 상승으로 이동).

R, 25 바이트

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

인덱스는 1부터 시작합니다.

Pyth , 6 5 바이트

@TheBikingviking 덕분에 1 바이트가 절약 되었습니다!

@s._S

0 기반 인덱싱을 사용합니다.

온라인으로 사용해보십시오!

설명

@          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 바이트

3 바이트 주셔서 @MartinEnder 감사합니다!

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

1- 색인. 무시해도 안전한 오류가 발생합니다.

설명

((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 바이트

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

입력 (0 기반)을 가져 와서 바이트 값으로 출력합니다.

여기서 테스트 할 수 있습니다 .

입력 \앞에 10 진수 가 필요 합니다 (예 : \1010). 출력이 인쇄 가능한 ASCII 문자 인 경우 표시됩니다. 그렇지 않으면 뷰 메모리-> 최종 덤프를 누르십시오. 인쇄 된 값은 세 번째 셀 (셀 번호 2)에 있습니다.

설명:

셀 0 (입력) : 입력이며 루프를 통해 매번 1 씩 감소합니다.

셀 1 (리셋) : TERM과 같을 때마다 1 씩 증가합니다. 이를 위해 루프를 통과 할 때마다 1을 더하고 같지 않으면 1을 뺍니다.

셀 2 (TERM) : 루프마다 1 씩 증가하고 RESET과 일치하면 0으로 설정됩니다. 이를 위해이 셀이 RESET과 같지 않은 경우에만 HOLD에서 값을 다시 복사합니다.

셀 3 (EQUAL) : RESET과 TERM이 같은지 확인하는 데 사용됩니다.

Cell 4 (HOLD) : 등호 점검 후 RESET 및 TERM 값을 다시 복사하는 데 사용됩니다.

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

파이크, 6 바이트

OmSsQ@

여기 사용해보십시오!

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

인덱스가 0입니다.

R, 43 41 바이트

편집 : A002262 + 1 (0 인덱스) 을 사용하여 더 짧은 재귀 접근법을 찾았습니다 .

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

구 버전:

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

OEIS의 1- 인덱스 공식.

펄 6 , 21 바이트

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

인덱스가 0입니다. 온라인으로 사용해보십시오!

작동 방식 :

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

펄 6 , 21 바이트

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

인덱스가 0입니다. 온라인으로 사용해보십시오!

작동 방식 :

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

이 솔루션들 중 어느 것도 JungHawn Min 's 만큼 짧지는 않지만 대체 접근 방식입니다. 둘 다 (1 인덱스) 양의 정수 입력을 받아 양의 정수를 반환하는 명명되지 않은 함수입니다.

Mathematica, 30 바이트

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

이 함수의 실제 수학 공식! (3 바이트 문자를 변환하여 부분적으로 더 읽기 제작 ⌈, √및 ⌉) :

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

Ceiling[Sqrt[2 * #] - 1/2]입력이 참조하는 하위 목록을 알려줍니다. 입력에서 빼기 전에 어느 하위 목록이 끝나는지를 알려줍니다. 그런 다음 ((#^2 + #) / 2 &)관심있는 항목보다 먼저 모든 하위 목록에서 발생하는 요소 수 를 계산하여 입력에서 빼서 #답변을 얻습니다. ( 삼각 숫자에 (#^2 + #) / 2대해 친숙한 공식 이있는 사람도 있습니다. 본질적으로 역함수입니다.)#Ceiling[Sqrt[2 * #] - 1/2]

수학, 32 바이트

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

재귀 솔루션, 기본적으로 Billywob의 답변 및 기타와 동일합니다.

Brain-Flak , 46 바이트

제로 인덱스

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

온라인으로 사용해보십시오!

스택 클린, 48 바이트

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

온라인으로 사용해보십시오!

설명

이것은 모듈로 함수 의 수정 된 버전입니다 . 제수로 상수를 사용하는 대신, 제수를 빼는 때마다 (외부 루프 반복마다 한 번씩) 제수를 증가시킵니다.

주석이 달린 코드

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

자바 8, 85 73 55 바이트

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

OEIS에 제공된 공식을 사용한 0 인덱스 재귀 접근법 :

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

여기에서 시도하십시오.

이전 답변 ( 85 56 바이트) :

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

OEIS에 제공된 다른 0 인덱스 수식을 사용했습니다 .

n 번째 용어는 n - m*(m+1)/2 + 1, 여기서 m = floor((sqrt(8*n+1) - 1) / 2).

여기에서 시도하십시오.

펄 , 30 바이트

29 바이트의 코드 + -p플래그

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

온라인으로 사용해보십시오!

MATL, 8 바이트

:"@:]vG)

이 솔루션은 1 기반 인덱싱을 사용합니다.

MATL Online 에서 사용해보십시오

설명

        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 바이트, 1 색인

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

설명:

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

약간 더 흥미로운 접근 방법이지만 10 바이트 더 길다 :

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

이 프로그램은이 대괄호와 모든 이전 숫자의 총 수 ()를 지속적으로 계산합니다 1 at loop 1, 3 at loop 2, 6 at loop 3 .... 해당 카운터가 구한 인덱스 N을 초과하면 현재 브래킷에서 X를 반환합니다. 여기서 X는 N에서 카운터의 이전 양을 뺀 값입니다.

루비, 30 바이트

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

1 기반 인덱싱

R, 37 바이트

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

에서 입력을 받아서 n첫 번째 n시퀀스 의 시퀀스를 만듭니다 . 이것은 높은 입력에서 다소 비효율적이지만 괜찮을 것입니다. 그런 다음 n-색인 된-번째 항목 을 리턴합니다 .

T로 TRUE또는 1기본적으로 시퀀스를 시작하여 멋진 작은 트릭을 사용합니다 .

C11, 48 바이트

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

온라인으로 사용해보십시오!

C ++ 및 Java에서도 작동합니다.

동일한 바이트 수에 대한 대안 :

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

brainfuck, 141 바이트

나는 현상금에 너무 늦었다는 것을 알고 있지만, 내가 생각한 알고리즘이 몇 바이트인지 알고 싶었습니다.

이 프로그램은 인덱스가 0입니다.

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

온라인으로 사용해보십시오

• 동적 (무한) 메모리를 선택 하면 작동하지 않습니다
• 테스트 입력 값> 255변경 셀 크기 (비트) 을 16 또는 32 .
• 통역사는 입력 방법을 설명합니다. 대한 소수점 입력 사용 \5의 입력 5.
  • 입력을 테스트 할 수있는 최대 10 진수 값은 \999
  • 16 진수 입력은 셀 크기만큼 높아질 수 있습니다.

설명:

이것은 프로그램이 단계적으로 나뉘어져 있으며의 입력에 대해 발생하는 것을 보여줍니다 5. #인터프리터를위한 이상적인 메모리 덤프 위치에 배치됩니다.

이 버전을 실행하는 경우 char : Dump Memory# 확인란을 사용하려고 할 것입니다 . 이렇게하면을 칠 때 메모리가 덤프되어 #인쇄 할 수없는 문자 인 경우 테이프의 값을 보거나 원하는 단계에서 어떤 일이 발생하는지 확인할 수 있습니다. 포인터가있는 셀은 굵게 표시됩니다.

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

온라인으로 사용해보십시오

• 동적 (무한) 메모리를 선택 하면 작동하지 않습니다
• char에서 덤프 메모리 : #

노트:

• 시작 셀의 왼쪽으로 이동하는 것을 허용하지 않는 다른 인터프리터 (동적 메모리를 사용하는 이유)에서 이것을 실행 >하려면 시작에 무리를 두십시오 . 필요한 숫자는 입력 값에 따라 달라질 수 있지만 O (1)입니다.

tinylisp (repl), 90 바이트 (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

또는 경쟁이 아닌 (이 챌린지가 게시 된 후 커밋 된 기능 사용) 80 바이트 :

(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

첫 번째 줄은 도우미 함수를 정의 r하고 두 번째 줄은 n시퀀스의 n 번째 항 을 가져 와서 반환 하는 명명되지 않은 함수입니다 . repl은 프로그램의 끝이 아닌 모든 줄의 끝에서 괄호를 자동 완성하기 때문에 이것을 repl 제출로 지정했습니다. 이러한 경고를 통해 Try it online 에서 작동하도록 수정 된 버전이 있으며 0에서 54까지의 입력에 대해 실행 되지 않은 버전이 있습니다.

설명

여기서는 경쟁이 아닌 버전을 사용하겠습니다. 유일한 차이점은 공식 버전은 더하기를 두 개의 빼기로 구현해야한다는 것입니다.

(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 바이트

가장 짧은 C 솔루션은 아니지만 일정한 시간 (루프가 아니라 수학)으로 실행하는 장점이 있습니다. 0부터 시작하는 인덱싱을 사용합니다.

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

언 골프 드 :

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
}

다음을 사용하여 테스트하십시오.

#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 바이트

초보자에게는 괜찮습니다. :)

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

또는 형식화 된 방법

#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 바이트, 0 기반 인덱싱

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

온라인 DC 프로그램을 사용해보십시오!

설명:

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

스택의 상단에는 이제 <= n 인 가장 큰 삼각형 수의 인덱스 k가 있습니다.

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.

이 dc 프로그램은 경쟁력있는 크기의 bash 스크립트로 변환 할 수 있습니다.

Bash + Unix 유틸리티, 28 바이트, 0 기반 색인

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

bash 프로그램을 온라인으로 사용해보십시오!

C, 81 44 바이트

직선 반복 방법, 0 인덱스 및 약간의 마사지;

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

온라인으로 사용해보십시오!