Inilah urutan yang saya bicarakan:

{1, 4, 5, 9, 10, 11, 16, 17, 18, 19, 25, 26, 27...}

Mulai dari 1, simpan 1, jatuhkan 2 berikutnya, simpan 2 berikutnya, jatuhkan 3, simpan 3 dan seterusnya. Ya, ini juga ada di OEIS (A064801) !

Tantangan

Diberikan bilangan bulat n>0, temukan suku ke-9 dari urutan di atas

Uji Kasus

Input -> Output       
1->1  
22->49  
333->683
4444->8908
12345->24747

Ini adalah kode golf sehingga jawaban tersingkat dalam byte menang! Semoga berhasil!

Java (OpenJDK 8) , 45 44 byte

n->{int i=0;for(;++i<n;n-=i);return~-n+i*i;}

Cobalah online!

-1 byte terima kasih kepada @Nevay

Setelah menatap ini sebentar, saya perhatikan sebuah pola. Setiap kali kita menjatuhkan nangka, angka berikutnya dalam urutan adalah kuadrat sempurna. Melihat ini, saya secara mental memecah urutan menjadi potongan-potongan nyaman: [[1],[4,5],[9,10,11],...]Pada dasarnya, ipotongan dimulai dengan i*i, dan beralih ke atas untuk ielemen.

Untuk menemukan nnomor th dalam urutan ini, kami ingin mencari yang mana potongan nomor itu, dan kemudian posisi mana dalam potongan yang ditempati. Kami kurangi jumlah selisih kami idari nsampai nkurang dari i(yang memberi kita potongan kami), dan kemudian hanya menambahkan n-1untuk i*imendapatkan yang benar positiondi chunk tersebut.

Contoh:

n = 8
n > 1? Yes, n = n - 1 = 7
n > 2? Yes, n = n - 2 = 5
n > 3? Yes, n = n - 3 = 2
n > 4? No, result is 4 * 4 + 2 - 1 = 17

Haskell, 48 43 41 byte

n#l=[l..l+n]++(n+1)#(l+2*n+3)
((0:0#1)!!)

4 byte tambahan untuk pengindeksan berbasis 1 dan bukan berbasis 0. Pembatasan yang tidak perlu, IMHO.

Cobalah online!

n#l             -- n is one less than the number of element to keep/drop and
                -- l the next number where the keep starts
   [l..l+n]     -- keep (n+1) numbers starting at l
   ++           -- and append a recursive call
   (n+1)#       -- where n is incremented by 1 and
      (l+2*n+3) -- l skips the elements to keep & drop

0#1             -- start with n=1 and l=0 and
 0:             -- prepend a dummy value to shift from 0 to 1-based index
    !!          -- pick the i-th element from the list 

Python 3 , 47 46 byte

1 byte terima kasih kepada Tn. Xcoder.

def f(n):a=round((2*n)**.5);return~-n+a*-~a//2

Cobalah online!

SANGAT cepat untuk angka yang lebih tinggi

Jelly , 8 byte

Ḷ+²µ€Ẏ⁸ị

Cobalah online!

Haskell , 33 byte

Fungsi anonim. Digunakan sebagai((!!)$0:do n<-[1..];[n^2..n^2+n-1]) 1

(!!)$0:do n<-[1..];[n^2..n^2+n-1]

Cobalah online!

• Bangun urutan sebagai daftar tanpa batas, lalu indekskan ke dalamnya !!. Ini 0:adalah elemen dummy untuk menyesuaikan dari pengindeksan berbasis 0 ke 1.
• Rentang ini [n^2..n^2+n-1]membangun urutan tanpa celah, dimulai dengan kuadrat ndan berisi nangka.
• The donotasi merangkai rentang dibangun untuk semua n>=1.

Python 3 , 46 byte

f=lambda x,y=0,z=0:y<x and f(x,y+z,z+1)or~-y+x

Cobalah online!

Perl 6 , 43 byte

{(1..*).rotor({++$=>++$+1}...*).flat[$_-1]}

Menguji

Diperluas:

{  # bare block lambda with implicit parameter ｢$_｣

  ( 1 .. * )                  # range starting from 1

  .rotor(                     # break it into chunks

    { ++$  =>  ++$ + 1} ... * # infinite Seq of increasing pairs
    #   1  =>    1 + 1    ==>   1 => 2 ( grab 1 skip 2 )
    #   2  =>    2 + 1    ==>   2 => 3
    #   3  =>    3 + 1    ==>   3 => 4
    # ...  =>  ... + 1

  ).flat\                     # reduce the sequence of lists to a flat sequence
  [ $_ - 1 ]                  # index into the sequence
                              # (adjusting to 0-based index)
}

(1..*).rotor({++$=>++$+1}...*) menghasilkan:

(
 (1,),
 (4, 5),
 (9, 10, 11),
 (16, 17, 18, 19),
 (25, 26, 27, 28, 29),
 ...
).Seq

TeX, 166 byte

\newcommand{\f}[1]{\count0=0\count1=0\loop\advance\count0 by\the\count1\advance\count1 by1\ifnum\count0<#1\repeat\advance\count0 by#1\advance\count0 by-1
\the\count0}

Pemakaian

\documentclass[12pt,a4paper]{article}
\begin{document}
\newcommand{\f}[1]{\count0=0\count1=0\loop\advance\count0 by\the\count1\advance\count1 by1\ifnum\count0<#1\repeat\advance\count0 by#1\advance\count0 by-1
\the\count0}

\f{1}

\f{22}

\f{333}

\f{4444}

\f{12345}
\end{document}

Javascript, 43 38 byte

n=>eval("for(r=1;n>r;)n-=r++;r*r+n-1")

Cobalah online!

Saya menggunakan fakta, bahwa untuk setiap angka segitiga ditambah satu, hasilnya adalah angka kuadrat.

Sebagai contoh: angka segitiga adalah 0, 1, 3, 6, 10 ... jadi untuk 1, 2, 4, 7, 11 ... kita amati 1, 4, 9, 16, 25 ... dalam urutan kita .

Jika indeks berada di antara angka-angka yang diketahui ini, elemen dari urutan kami hanya naik satu saja. Misalnya, untuk menghitung hasil untuk 10, kita ambil 7 (sebagai angka segitiga ditambah satu), ambil hasilnya (16) dan tambahkan 10-7 = 3. Dengan demikian, 16 + 3 = 19.

05AB1E , 12 byte

LεÝÁćn+}˜¹<è

Cobalah online!

cQuents , 27 byte

#R(2B)^.5)|1:b~-B+A*-b~A//2

Cobalah online!

Saat ini port jawaban Python Leaky , saya pikir ada cara yang lebih baik.

Swift 3 , 72 byte

Port solusi Python saya .

func f(_ x:Int,_ y:Int=0,_ z:Int=0)->Int{return y<x ?f(x,y+z,z+1):y+x-1}

Test Suite.

C # (Mono) , 164 byte

using System.Linq;n=>{var a=new int[1]{1}.ToList();for(int i=1,m;a.Count<n;a.AddRange(new int[++i*2].Select((_,d)=>m+d+1).Skip(i).Take(i)))m=a.Max();return a[n-1];}

Cobalah online!

Mathematica, 37 byte

Flatten[Range@#+#^2-1&~Array~#][[#]]&

Penjelasan

Range@#+#^2-1&

Functionyang mengambil bilangan bulat positif #dan mengembalikan #urutan angka berurutan.

...~Array~#

Menghasilkan daftar semua jalan tersebut hingga input #

Flatten[...][[#]]

Flattensdaftar yang dihasilkan dan mengembalikan #elemen th.

Perl 5 , 33 + 1 (-p) = 34 byte

$\+=$.--?1:2+($.=++$s)while$_--}{

Cobalah online!

Tampio , 310 308 byte

n:n uni on n unena 1:lle
a unena k:lle on a vuona k:lla vähennettynä a:sta ja k
a vuona nollalla ja k on a
a vuona k:lla vähennettynä nollasta ja k on a
a vuona b:n seuraajalla ja k on yhteenlaskun kutsuttuna k:n kerrottuna 2:lla arvolla ja k:n vähennettynä a:sta arvolla unena k:n seuraajalle seuraaja

Penggunaan: 4:n unidievaluasi menjadi 9.

Penjelasan:

n:n uni on n unena 1:lle
uni(n)  =  n `uni` 1

a unena k:lle on  a vuona  k:lla vähennettynä a:sta ja k
a `uni` k     =  (a `vuo` (k     `vähennetty` a)    )  k

 a vuona nollalla ja k on a
(a `vuo` 0        )  k =  a

 a vuona  k:lla vähennettynä nollasta ja k on a
(a `vuo` (k     `vähennetty` 0)       )  k =  a

 a vuona  b:n seuraajalla ja k on
(a `vuo` (b   + 1)        )  k =

 yhteenlaskun kutsuttuna k:n kerrottuna 2:lla arvolla
(yhteenlasku            (k   *          2     )

 ja k:n vähennettynä a:sta arvolla unena  k:n seuraajalle seuraaja
((  k   `vähennetty` a     )       `uni` (k   + 1)   )  ) + 1

Dari perpustakaan standar:

a `vähennetty` b = b - a
yhteenlasku a b  = a + b

JavaScript (ES6), 33 byte

Solusi rekursif yang terinspirasi oleh pengamatan Xanderhall .

f=(n,x=1)=>n<x?n+x*x-1:f(n-x,++x)

Cobalah

o.innerText=(
f=(n,x=1)=>n<x?n+x*x-1:f(n-x,++x)
)(i.value=12345);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

Python 3 , 50 byte

def f(n):
 a=i=0
 while a<n:a+=i;i+=1
 return~-a+n

Cobalah online!

Mathematica, 82 byte

Complement[Range[3#],Array[#+⌊((r=Sqrt[1+8#])-1)/2⌋⌊(r+1)/2⌋/2&,3#]][[#]]&

Python , 40 byte

lambda n:(round((2*n)**.5)+.5)**2//2+n-1

Cobalah online!

Mengoptimalkan ekspresi Leaky Nun .

Python , 41 byte

f=lambda n,k=1:n*(n<=k)or-~f(n-k,k+1)+2*k

Cobalah online!

Ekspresi rekursif.

Javascript (ES6) 100 98 Bytes

var k=n=>{var s=[],i=1,c=1,j;while(s.length<n){for(j=i;j<i+c;j++){s.push(j)}i+=c*2+1;c++}return s}

Jenis melakukan ini dengan cepat, jadi saya yakin ada banyak ruang untuk perbaikan, hanya loop dan counter dasar.

Retina , 27 byte

.+
$*
((^1|1\2)+)1
$1$2$&
1

Cobalah online! Port dari jawaban Python @ LeakyNun. Tahap pertama dan terakhir hanya membosankan konversi desimal ⇔ unary. Tahap kedua berfungsi seperti ini: ((^1|1\2)+)adalah pencocokan angka segitiga; $1adalah angka segitiga yang cocok sedangkan $2indeksnya. Trailing1 artinya cocok dengan angka segitiga terbesar yang benar-benar kurang dari input, sehingga menghasilkan iterasi tepat satu lebih sedikit dari loop Python, yang berarti $1setara dengan a-idan $2untuk i-1dan jumlah mereka a-1atau cocok dengan dalam kasus itu juga.~-a sesuai kebutuhan. ($& hanya mencegah kecocokan agar tidak dihapus dari hasil.) Perhatikan bahwa untuk input yang 1tidak cocok terjadi dan hasilnya sama dengan input. Jika Anda sesat Anda bisa menggunakan^((^1|1\2)*)1

MATL , 12 byte

:"@U@:q+]vG)

Cobalah online!

Penjelasan

:        % Push range [1 2 ... n], where n is implicit input
"        % For each k in that range
  @U     %   Push k^2
  @:     %   Push range [1 2 ... k]
  q      %   Subtract 1: gives [0 1 ... k-1]
  +      %   Add: gives [k^2 k^2+1 ... k^2+k-1]
]        % End
v        % Concatenate all numbers into a column vector
G)       % Get n-th entry. Implicitly display

C (gcc) , 38 byte

Menggunakan algoritma @ Xanderhall di sini

i;f(n){for(i=0;++i<n;n-=i);n=n-1+i*i;}

Cobalah online!

PHP, 48 42 37 + 1 byte

porting dari jawaban Leaky Nun

while($argn>$a+=$i++);echo$a+~-$argn;

Jalankan sebagai pipa dengan -Fatau coba online .

pendekatan langsung, 42 +1 byte (porting dari jawaban Leaky Nun lainnya )

<?=($a=(2*$argn)**.5+.5|0)*-~$a/2+~-$argn;

Jalankan sebagai pipa dengan -nRatau batalkan komentar di atas TiO.

solusi iteratif yang lebih lama, 48 +1 byte

for(;$argn--;$n++)$c++>$z&&$n+=++$z+$c=1;echo$n;