(Tantangan diambil dari game multi-pemain (clash of code) di codingame.com )

Tantangan

Temukan istilah ke- n dari urutan berikut: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...atau, untuk membuatnya lebih jelas,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

Urutannya terdiri dari rentang gabungan dari 1 hingga x , mulai dari 1, hingga tak terhingga.

Aturan / IO

Input dan output bisa dalam format apa saja, asalkan bisa dibedakan. Masukan dapat diambil dari sumber yang sesuai: STDIN, file, dll ...

Input dapat 0 atau 1 diindeks, dan pengindeksan yang dipilih harus disebutkan dalam posting.

Anda harus menangani setidaknya hingga hasil 255 inklusif (artinya input maksimum 0-diindeks adalah 32640). Apapun yang harus ditangani, jika bahasa Anda mendukungnya.

Ini adalah code-golfhitungan byte terpendek yang menang!

Uji kasus (pengindeksan berbasis 0)

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

05AB1E , 5 byte

Program ini 0-diindeks, kode:

ÌLL¹è

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

Haskell , 27 26 byte

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

Cobalah online!

Terima kasih @DanD. untuk -1 byte!

Ini adalah fungsi anonim, menciptakan urutan yang tak terbatas sebuah hanya mengembalikan nunsur -th daripadanya: [[1..k]| k<-[1..]]menghasilkan daftar tak terbatas daftar: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Untuk menggabungkan ini, kita dapat menulis [z|k<-[1..],z<-[1..k]]yang menghasilkan [1,1,2,1,2,3,1,2,3,4,...]dan akhirnya (...!!)menerima input n(notasi tanpa titik) dan mengembalikan nistilah -th (berbasis 0).

JavaScript, 29 28 byte

-1 byte terima kasih kepada Arnauld!

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

Menggunakan rumus rekursif 0-diindeks yang ditemukan di OEIS.

Ketika dipanggil dengan 1 argumen seperti yang diharapkan, nilai default dari argumen kedua, madalah undefined. Namun, -~undefinedmengembalikan 1, yang memungkinkan kita untuk mendapatkan rekursi bergulir tanpa eksplisit m = 1dalam daftar argumen (terima kasih @Arnauld!)

Cuplikan uji:

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

Atau, untuk jumlah byte yang sama, kita dapat memiliki fungsi kari seperti:

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

Anda dapat memanggil ini dengan f(5)()- ia mengembalikan fungsi, yang ketika dipanggil, mengembalikan hasilnya, seperti yang dijelaskan dalam posting meta ini .

Jelly , 5 byte, 1-diindeks

RRF³ị

Cobalah online!

Penjelasan:

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

Oktaf, 39 byte

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

1- indeks berbasis

Penjelasan:

Pertimbangkan urutan ini:

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

jika kita menghitung jumlah elemen dari urutan yang kita miliki

1   2        3          4               5         

jadi dengan menggunakan rumus Gauss untuk bilangan segitiga kita bisa membentuk rumus untuk z:

z=n*(n+1)/2

itu adalah persamaan kuadrat jika kita menyelesaikannya untuk n yang kita miliki

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

Cobalah secara Online!

Haskell, 25 24 byte

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

Contoh penggunaan: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Cobalah online! .

Memetakan fungsi make-a-list-from-1-to-x anonim \x->[1..x](built-in enumFromTo 1lebih lama satu byte) ke daftar tak terbatas [1..]dan menggabungkan daftar yang dihasilkan ke dalam satu daftar. !!mengambil elemen ke-n.

Terima kasih kepada @ flawr untuk satu byte.

Oktaf , 39 byte

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

Cobalah online!

Ini menggunakan pendekatan alternatif.

Untuk misalnya n=1ini A=triu(v'+0*v)menciptakan matriks

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

Saat menghapus semua elemen nol dan menambahkan kolom dengan A(A>0)kita mendapatkan urutannya:

1   1  2  1  2  3  1  2  3  4

Maka itu hanya masalah mengurangkan nistilah ke - 4 dari urutan itu.

Python , 39 36 byte

-3 byte terima kasih kepada Dennis!

Lambda rekursif yang menggunakan pengindeksan berbasis 1.

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

Cobalah online!

Kami melacak ukuran "naik" saat ini menggunakan m. Jika nlebih kecil dari atau sama dengan m, itu cocok dengan "kenaikan" saat ini, jadi kami mengembalikannya. Namun, jika lebih besar dari m, kita ambil mdarinya, lalu tambahkan 1 ke mdan panggil fungsi secara rekursif (beralih ke kenaikan berikutnya).

R, 25 byte

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

Indeks ini berbasis 1.

Pyth , 6 5 byte

1 byte disimpan berkat @TheBikingviking!

@s._S

Ini menggunakan pengindeksan berbasis 0.

Cobalah online!

Penjelasan

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

Terima kasih @MartinEnder selama 3 byte!

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

1-diindeks. Ini melempar kesalahan yang aman untuk diabaikan.

Penjelasan

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

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

Mengambil input (berbasis 0) dan output sebagai nilai byte.

Anda bisa mengujinya di sini.

Input membutuhkan \angka desimal sebelum (misalnya \10untuk 10). Jika outputnya adalah karakter ASCII yang dapat dicetak, Anda harus melihatnya. Jika tidak, tekan memori tampilan -> dump akhir. Nilai yang dicetak ada di sel ke-3 (nomor sel 2).

Penjelasan:

Sel 0 (INPUT): adalah input dan dikurangi 1 saya setiap kali melalui loop.

Sel 1 (RESET): bertambah 1 setiap kali sama dengan TERM. Untuk melakukan ini, setiap kali melalui loop kita menambahkan 1 dan jika mereka tidak sama kita kurangi 1.

Sel 2 (JANGKA): bertambah 1 setiap loop dan diatur ke 0 jika cocok dengan RESET. Untuk melakukan ini, saya hanya menyalin nilai kembali dari HOLD jika sel ini tidak sama dengan RESET.

Sel 3 (EQUAL): digunakan untuk memeriksa apakah RESET dan TERM sama.

Sel 4 (TAHAN): digunakan untuk menyalin nilai RESET dan JANGKA kembali setelah pemeriksaan sama dengan.

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

Coba di sini!

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

Diindeks 0.

R, 43 41 byte

Sunting: Menemukan pendekatan rekursif yang lebih pendek dengan menggunakan A002262 +1 (0 diindeks):

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

Versi lama:

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

Formula 1-diindeks dari OEIS.

Perl 6 , 21 byte

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

Diindeks 0. Cobalah online!

Bagaimana itu bekerja:

{                 }  # 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[$_]}

Diindeks 0. Cobalah online!

Bagaimana itu bekerja:

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

Tak satu pun dari solusi ini sesingkat JungHawn Min , tetapi mereka pendekatan alternatif, yang merupakan sesuatu yang saya kira. Keduanya adalah fungsi yang tidak disebutkan namanya yang mengambil input integer positif (1-diindeks) dan mengembalikan integer positif.

Mathematica, 30 byte

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

Rumus matematika aktual untuk fungsi ini! Dibuat lebih mudah dibaca (sebagian oleh menerjemahkan karakter 3-byte ⌈, √dan ⌉):

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

Ceiling[Sqrt[2 * #] - 1/2]memberi tahu kami sublist mana yang dirujuk oleh input, dari mana kami mengurangi satu untuk memberi tahu kami sublist mana yang berakhir sebelum kita sampai pada input; kemudian ((#^2 + #) / 2 &)menghitung berapa banyak elemen yang muncul di semua sublists sebelum yang kita pedulikan, yang kita kurangi dari input #untuk mendapatkan jawaban kita. (Beberapa akan melihat rumus yang sudah dikenal (#^2 + #) / 2untuk angka #segitiga th; Ceiling[Sqrt[2 * #] - 1/2]pada dasarnya adalah fungsi terbalik.)

Mathematica, 32 byte

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

Solusi rekursif, pada dasarnya sama dengan jawaban Billywob dan lainnya.

Brain-Flak , 46 byte

Nol diindeks

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

Cobalah online!

Stack Clean, 48 byte

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

Cobalah online!

Penjelasan

Ini adalah versi modifikasi dari fungsi modulo . Alih-alih menggunakan angka konstan sebagai pembagi itu menambah pembagi untuk setiap kali pembagi dikurangi dari itu (sekali per per loop luar iterasi).

Kode Beranotasi

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

Pendekatan rekursif terindeks 0 dengan formula yang disediakan dalam OEIS :

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

Coba di sini.

Jawaban lama ( 85 56 byte):

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

Menggunakan rumus lain yang diindeks 0 yang disediakan dalam OEIS :

Istilah ke-n adalah n - m*(m+1)/2 + 1, di mana m = floor((sqrt(8*n+1) - 1) / 2).

Coba di sini.

Perl , 30 byte

29 byte kode + -pbendera.

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

Cobalah online!

MATL, 8 byte

:"@:]vG)

Solusi ini menggunakan pengindeksan berbasis 1

Cobalah di MATL Online

Penjelasan

        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-diindeks

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

Penjelasan:

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

Pendekatan yang sedikit lebih menarik, tetapi 10 byte lebih lama:

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

Program ini terus menerus menghitung jumlah total angka dalam braket ini dan semua yang sebelumnya ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...). Ketika penghitung itu melebihi indeks yang dicari N, maka kembalilah X dari braket saat ini, di mana X adalah N dikurangi jumlah penghitung sebelumnya.

Ruby, 30 byte

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

Pengindeksan berbasis 1

R, 37 byte

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

Mengambil input dari n, dan membuat urutan untuk nurutan pertama . Ini membuatnya agak tidak efisien pada input yang lebih tinggi, tetapi harus baik-baik saja. Kemudian mengembalikan nentri -th, 1-diindeks.

Menggunakan trik kecil yang menyenangkan dengan memulai urutan dengan T, yang merupakan TRUEatau 1secara default.

C11, 48 byte

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

Cobalah online!

Juga berfungsi di C ++ dan Java.

Alternatif untuk jumlah byte yang sama:

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

brainfuck, 141 byte

Saya tahu saya terlambat untuk mendapatkan hadiah, tetapi saya hanya ingin melihat berapa banyak algoritma yang saya pikir akan berakhir.

Program ini tidak diindeks.

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

Cobalah online

• Pilih Memori Dinamis (tak terbatas) , atau tidak akan berfungsi
• Untuk menguji nilai input> 255, ubah Ukuran sel (Bit) menjadi 16 atau 32 .
• Penerjemah menjelaskan cara memberi masukan. Untuk input input desimal digunakan \5untuk input5 .
  • Nilai desimal maksimum yang dapat Anda uji input adalah \999
  • Input hex bisa setinggi ukuran sel.

Penjelasan:

Ini menunjukkan program dipecah secara bertahap, menunjukkan apa yang terjadi untuk input 5. #ditempatkan di lokasi dump memori yang ideal untuk juru bahasa.

Anda mungkin ingin menggunakan kotak centang Dump Memory at char:# jika menjalankan versi ini. Ini akan membuang memori pada saat memukul #, memungkinkan Anda untuk melihat nilai pada rekaman jika itu adalah karakter yang tidak diinginkan, atau untuk melihat apa yang terjadi pada langkah apa pun yang Anda inginkan. Sel yang digunakan pointer akan dicetak tebal.

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

Cobalah online

• Pilih Memori Dinamis (tak terbatas) , atau tidak akan berfungsi
• Memori Dump di char: #

Catatan:

• Untuk menjalankan ini pada juru bahasa lain yang tidak memungkinkan untuk bergerak ke kiri sel mulai (itu sebabnya saya menggunakan Memori Dinamis), masukkan banyak >di awal. Jumlah yang diperlukan dapat bervariasi tergantung pada nilai input, tetapi O (1).

tinylisp (repl), 90 byte (0-diindeks)

(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

Atau, non-bersaing (menggunakan fitur yang dilakukan setelah tantangan ini diposting), 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

Baris pertama mendefinisikan fungsi pembantu r, dan baris kedua adalah fungsi tanpa nama yang mengambil ndan mengembalikan suku ke-n dari urutan tersebut. Saya telah menetapkan ini sebagai pengiriman repl karena autocompletes tersebut mengisi tanda kurung di akhir setiap baris, bukan hanya di akhir program. Dengan peringatan itu, berikut adalah versi yang dimodifikasi untuk berfungsi di Coba online , dan inilah versi yang tidak diklik berjalan terhadap input 0 hingga 54.

Penjelasan

Saya akan menggunakan versi yang tidak bersaing di sini. Satu-satunya perbedaan adalah bahwa versi resmi harus menerapkan penambahan sebagai dua pengurangan.

(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

Bukan solusi C terpendek, tetapi memiliki manfaat berjalan dalam waktu yang konstan (tidak ada loop, hanya matematika). Ini menggunakan pengindeksan berbasis nol:

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

Tidak Disatukan:

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
}

Uji dengan:

#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

Untuk pemula tidak apa-apa, saya pikir :).

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

atau cara yang diformat

#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, pengindeksan berbasis 0

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

Coba program dc online!

Penjelasan:

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

Bagian atas tumpukan sekarang memegang indeks k dari angka segitiga terbesar yaitu <= 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.

Program dc ini dapat dikonversi menjadi skrip bash berukuran kompetitif:

Utilitas Bash + Unix, 28 byte, pengindeksan berbasis 0

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

Coba program bash online!

C, 81 44 byte

metode iteratif lurus, 0 diindeks, dan dengan pijatan lembut;

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

Cobalah online!