(Thử thách được lấy từ một trò chơi nhiều người chơi (clash of code) tạiodingame.com )

Các thách thức

Tìm thuật ngữ thứ n của chuỗi sau: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...hoặc, để làm cho nó rõ ràng hơn,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

Chuỗi được tạo thành từ các phạm vi nối từ 1 đến x , bắt đầu từ 1, cho đến vô tận.

Quy tắc / IO

Đầu vào và đầu ra có thể ở bất kỳ định dạng nào, miễn là có thể phân biệt được. Đầu vào có thể được lấy từ bất kỳ nguồn thích hợp nào: STDIN, tệp, v.v ...

Đầu vào có thể là 0- hoặc 1 - được lập chỉ mục và chỉ mục được chọn phải được đề cập trong bài viết.

Bạn sẽ phải xử lý ít nhất lên tới 255 kết quả (có nghĩa là đầu vào tối đa 0 chỉ mục là 32640). Bất cứ điều gì trên đó phải được xử lý, nếu ngôn ngữ của bạn hỗ trợ nó.

Đây là code-golfsố byte ngắn nhất sẽ thắng!

Các trường hợp thử nghiệm (lập chỉ mục dựa trên 0)

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

05AB1E , 5 byte

Chương trình được lập chỉ mục 0, mã:

ÌLL¹è

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Haskell , 27 26 byte

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

Hãy thử trực tuyến!

Cảm ơn @DanD. cho -1 byte!

Đây là một hàm ẩn danh, tạo ra chuỗi vô hạn, chỉ trả về nphần tử -th của nó: [[1..k]| k<-[1..]]tạo ra một danh sách vô hạn của danh sách : [[1],[1,2],[1,2,3],[1,2,3,4],...]. Để ghép nối chúng, chúng ta có thể viết [z|k<-[1..],z<-[1..k]]kết quả nào [1,1,2,1,2,3,1,2,3,4,...]và cuối cùng (...!!)chấp nhận đầu vào n(ký hiệu vô nghĩa) và trả về nthuật ngữ thứ ((dựa trên 0).

JavaScript, 29 28 byte

-1 byte nhờ Arnauld!

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

Sử dụng công thức đệ quy 0 chỉ mục được tìm thấy trên OEIS.

Khi được gọi với 1 đối số như mong đợi, giá trị mặc định của giây msẽ là undefined. Tuy nhiên, -~undefinedtrả về 1, cho phép chúng ta có được phép đệ quy mà không có phần rõ ràng m = 1trong danh sách đối số (cảm ơn @Arnauld!)

Đoạn kiểm tra:

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

Ngoài ra, với cùng một số byte, chúng ta có thể có một hàm được uốn như vậy:

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

Bạn có thể gọi hàm này bằng f(5)()- nó trả về một hàm, khi được gọi sẽ trả về kết quả, như được mô tả trong bài đăng meta này .

Jelly , 5 byte, 1 chỉ mục

RRF³ị

Hãy thử trực tuyến!

Giải trình:

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

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

1- chỉ số dựa trên

Giải trình:

Hãy xem xét trình tự này:

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

nếu chúng ta đếm số phần tử của các phần sau chúng ta có

1   2        3          4               5         

vì vậy sử dụng công thức Gauss cho số tam giác, chúng ta có thể tạo thành một công thức cho z:

z=n*(n+1)/2

đó là một phương trình bậc hai nếu chúng ta giải nó cho n chúng ta có

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

Dùng thử trực tuyến!

Haskell, 25 24 byte

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

Ví dụ sử dụng: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Hãy thử trực tuyến! .

Ánh xạ hàm tạo danh sách ẩn danh từ 1 đến x \x->[1..x](ẩn tích hợp enumFromTo 1dài hơn một byte) vào danh sách vô hạn [1..]và ghép các danh sách kết quả thành một danh sách. !!chọn phần tử thứ n.

Cảm ơn @flawr cho một byte.

Octave , 39 byte

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

Hãy thử trực tuyến!

Điều này sử dụng một phương pháp thay thế.

Ví dụ: n=1điều này A=triu(v'+0*v)tạo ra ma trận

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

Khi loại bỏ tất cả các phần tử 0 và nối thêm các cột bằng cách A(A>0)chúng ta nhận được chuỗi:

1   1  2  1  2  3  1  2  3  4

Sau đó, nó chỉ là một vấn đề của nthuật ngữ thứ ba của chuỗi đó.

Python , 39 36 byte

-3 byte nhờ Dennis!

Một lambda đệ quy sử dụng lập chỉ mục dựa trên 1.

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

Hãy thử trực tuyến!

Chúng tôi theo dõi kích thước "tăng" hiện tại bằng cách sử dụng m. Nếu nnhỏ hơn hoặc bằng m, nó phù hợp với "mức tăng" hiện tại, và vì vậy chúng tôi trả lại nó. Tuy nhiên, nếu nó lớn hơn m, chúng ta sẽ mloại bỏ nó, hơn là thêm 1 vào mvà gọi hàm đệ quy (chuyển sang mức tăng tiếp theo).

R, 25 byte

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

Chỉ số này dựa trên 1.

Bình thường , 6 5 byte

Lưu 1 byte nhờ @TheBikingviking!

@s._S

Điều này sử dụng lập chỉ mục dựa trên 0.

Hãy thử trực tuyến!

Giải trình

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

Toán học, 27 24 byte

Cảm ơn @MartinEnder cho 3 byte!

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

1 chỉ mục. Điều này ném lỗi mà an toàn để bỏ qua.

Giải trình

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

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

Lấy đầu vào (dựa trên 0) và xuất ra dưới dạng giá trị byte.

Bạn có thể kiểm tra nó ở đây.

Đầu vào yêu cầu một \số thập phân trước (ví dụ:\10 cho 10). Nếu đầu ra là một ký tự ASCII có thể in, bạn sẽ thấy nó. Nếu không, nhấn xem bộ nhớ -> kết xuất cuối cùng. Giá trị được in là trong ô thứ 3 (ô số 2).

Giải trình:

Ô 0 (INPUT): là đầu vào và giảm 1 của tôi mỗi lần qua vòng lặp.

Ô 1 (RESET): tăng thêm 1 mỗi lần bằng với HẠN. Để làm điều này, mỗi lần qua vòng lặp, chúng ta thêm 1 và nếu chúng không bằng nhau, chúng ta trừ đi 1.

Ô 2 (HẠN): tăng thêm 1 mỗi vòng lặp và được đặt thành 0 nếu khớp với RESET. Để làm điều này, tôi chỉ sao chép lại giá trị từ GIỜ nếu ô này không bằng RESET.

Ô 3 (THIẾT BỊ): được sử dụng để kiểm tra xem RESET và TERM có bằng nhau không.

Ô 4 (GIỮ): được sử dụng để sao chép các giá trị của RESET và TATE trở lại sau khi kiểm tra bằng.

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

OmSsQ@

Hãy thử nó ở đây!

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

Chỉ số 0.

R, 43 41 byte

Chỉnh sửa: Tìm thấy cách tiếp cận đệ quy ngắn hơn bằng cách sử dụng A002262 + 1 (0 được lập chỉ mục):

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

Phiên bản cũ:

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

Công thức 1 chỉ mục từ OEIS.

Perl 6 , 21 byte

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

Chỉ số 0. Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

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

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

Chỉ số 0. Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

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

Cả hai giải pháp này đều ngắn như của JungHawn Min , nhưng chúng là những cách tiếp cận thay thế, đó là điều tôi đoán. Cả hai đều là các hàm không tên lấy đầu vào số nguyên dương (1 chỉ mục) và trả về số nguyên dương.

Toán học, 30 byte

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

Một công thức toán học thực tế cho chức năng này! Made dễ đọc hơn (một phần bằng cách dịch các ký tự 3-byte ⌈, √và ⌉):

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

Ceiling[Sqrt[2 * #] - 1/2]cho chúng tôi biết danh sách phụ nào mà đầu vào đề cập đến, từ đó chúng tôi trừ đi một danh sách để cho chúng tôi biết danh sách phụ nào kết thúc trước khi chúng tôi nhận được đầu vào; sau đó ((#^2 + #) / 2 &)tính toán có bao nhiêu phần tử xảy ra trong tất cả các danh sách con trước phần mà chúng ta quan tâm, chúng ta trừ đi phần đầu vào #để có câu trả lời. (Một số người sẽ chú ý đến công thức quen thuộc (#^2 + #) / 2cho #số tam giác thứ; Ceiling[Sqrt[2 * #] - 1/2]về cơ bản là hàm nghịch đảo.)

Toán học, 32 byte

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

Giải pháp đệ quy, về cơ bản giống như trong câu trả lời của Billywob và những người khác.

Brain-Flak , 46 byte

Không có chỉ mục

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

Hãy thử trực tuyến!

Ngăn xếp sạch, 48 byte

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

Hãy thử trực tuyến!

Giải trình

Đây là một phiên bản sửa đổi của chức năng modulo . Thay vì sử dụng một số không đổi làm ước số, nó sẽ tăng số chia cho mỗi lần số chia được trừ khỏi nó (một lần cho mỗi lần lặp vòng lặp bên ngoài).

Mã chú thích

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

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

Phương pháp đệ quy 0 chỉ mục với công thức được cung cấp trong OEIS :

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

Hãy thử nó ở đây.

Câu trả lời cũ ( 85 56 byte):

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

Đã sử dụng công thức 0 chỉ mục khác được cung cấp trong OEIS :

hạn thứ n là n - m*(m+1)/2 + 1, ở đâu m = floor((sqrt(8*n+1) - 1) / 2).

Hãy thử nó ở đây.

Perl , 30 byte

29 byte mã + -pcờ.

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

Hãy thử trực tuyến!

MATL, 8 byte

:"@:]vG)

Giải pháp này sử dụng lập chỉ mục dựa trên 1

Dùng thử tại MATL Online

Giải trình

        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 byte, 1 chỉ mục

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

Giải trình:

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

Cách tiếp cận thú vị hơn một chút, nhưng dài hơn 10 byte:

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

Chương trình này liên tục tính toán tổng số các số trong khung này và tất cả các số trước đó ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...). Khi bộ đếm đó vượt quá chỉ số tìm kiếm N, sau đó trả về X từ dấu ngoặc hiện tại, trong đó X là N trừ đi số tiền trước đó của bộ đếm.

Ruby, 30 byte

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

Lập chỉ mục 1

R, 37 byte

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

Lấy đầu vào từ nvà tạo chuỗi cho nchuỗi đầu tiên . Điều này làm cho nó hơi kém hiệu quả ở đầu vào cao hơn, nhưng nó sẽ ổn. Sau đó, nó trả về nmục thứ-1, được lập chỉ mục 1.

Sử dụng một chút thủ thuật rất hay bằng cách bắt đầu ra khỏi chuỗi với T, đó là TRUEhoặc 1theo mặc định.

C11, 48 byte

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

Hãy thử trực tuyến!

Cũng hoạt động trong C ++ và Java.

Một thay thế cho cùng một số byte:

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

Brainfuck, 141 byte

Tôi biết rằng tôi đã quá muộn cho tiền thưởng, nhưng tôi chỉ muốn xem thuật toán mà tôi nghĩ sẽ có bao nhiêu byte.

Chương trình này là không có chỉ mục.

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

Dùng thử trực tuyến

• Chọn Bộ nhớ động (vô hạn) hoặc nó sẽ không hoạt động
• Để kiểm tra giá trị đầu vào> 255, thay đổi kích thước ô (Bits) thành 16 hoặc 32 .
• Trình thông dịch giải thích làm thế nào để cung cấp đầu vào. Đối với đầu vào thập phân sử dụng \5cho đầu vào của 5.
  • Giá trị thập phân tối đa bạn có thể kiểm tra đầu vào là \999
  • Đầu vào hex có thể tăng kích thước ô.

Giải trình:

Điều này cho thấy chương trình được chia nhỏ theo từng bước, hiển thị những gì xảy ra cho đầu vào của 5. #được đặt trong các vị trí kết xuất bộ nhớ lý tưởng cho trình thông dịch.

Bạn có thể sẽ muốn sử dụng hộp kiểm Dump Memory tại char:# nếu chạy phiên bản này. Điều này sẽ xóa bộ nhớ khi nhấn #, cho phép bạn xem giá trị trên băng trong trường hợp đó là ký tự không thể in được hoặc để xem điều gì xảy ra ở bất kỳ bước nào bạn muốn. Ô mà con trỏ đang bật sẽ được in đậm.

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

Dùng thử trực tuyến

• Chọn Bộ nhớ động (vô hạn) hoặc nó sẽ không hoạt động
• Bộ nhớ kết xuất tại char: #

Ghi chú:

• Để chạy cái này trên một trình thông dịch khác không cho phép di chuyển sang bên trái của ô bắt đầu (đó là lý do tại sao tôi sử dụng Bộ nhớ động), hãy đặt một loạt các >từ đầu. Số lượng yêu cầu có thể thay đổi tùy thuộc vào giá trị đầu vào, nhưng là O (1).

tinylisp (thay thế), 90 byte (0-index)

(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

Hoặc, không cạnh tranh (sử dụng một tính năng đã được cam kết sau khi thử thách này được đăng), 80 byte :

(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

Dòng đầu tiên xác định hàm trợ giúp rvà dòng thứ hai là hàm không tên, nhận nvà trả về số hạng thứ n của chuỗi. Tôi đã chỉ định đây là một lần gửi thay thế bởi vì tự động thay thế hoàn thành dấu ngoặc đơn ở cuối mỗi dòng, không chỉ ở cuối chương trình. Với những cảnh báo đó, đây là phiên bản được sửa đổi để hoạt động tại Dùng thử trực tuyến và đây là phiên bản không được chạy theo các đầu vào từ 0 đến 54.

Giải trình

Tôi sẽ sử dụng phiên bản không cấu hình ở đây. Sự khác biệt duy nhất là phiên bản chính thức phải thực hiện phép cộng như hai phép trừ.

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

Không phải là giải pháp C ngắn nhất, nhưng nó có giá trị chạy trong thời gian không đổi (không có vòng lặp, chỉ là toán học). Nó sử dụng lập chỉ mục dựa trên zero:

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

Ung dung:

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
}

Kiểm tra với:

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

Đối với một người mới bắt đầu thì không sao, tôi nghĩ vậy :).

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

hoặc cách định dạng

#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 byte, lập chỉ mục dựa trên 0

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

Hãy thử chương trình dc trực tuyến!

Giải trình:

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

Đỉnh của ngăn xếp hiện giữ chỉ số k của số tam giác lớn nhất là <= 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.

Chương trình dc này có thể được chuyển đổi thành tập lệnh bash có kích thước cạnh tranh:

Tiện ích Bash + Unix, 28 byte, lập chỉ mục dựa trên 0

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

Hãy thử chương trình bash trực tuyến!

C, 81 44 byte

phương pháp lặp thẳng, 0 được lập chỉ mục, và với một số xoa bóp nhẹ nhàng;

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

Hãy thử trực tuyến!