Bahsettiğim sıra:

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

1'den başlayarak, 1'i saklayın, sonraki 2'yi bırakın, sonraki 2'yi tutun, 3'ü bırakın, 3'ü koruyun vb. Evet, OEIS'de (A064801) de var!

Meydan okuma

Bir tamsayı verildiğinde n>0, yukarıdaki dizinin n. Terimini bulun

Test Durumları

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

Bu kod golf yani bayt en kısa cevap kazanır! İyi şanslar!

Java (OpenJDK 8) , 45 44 bayt

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

Çevrimiçi deneyin!

@Nevay sayesinde -1 bayt

Bir süre buna baktıktan sonra bir desen fark ettim. nSayıları her düşürdüğümüzde , dizideki bir sonraki sayı mükemmel bir karedir. Bunu görünce, diziyi zihinsel olarak uygun parçalara ayırdım: [[1],[4,5],[9,10,11],...]Temel olarak, ithunk yığın ile başlar i*ive ielemanlar için yukarı doğru tekrarlar .

Bulmak için nbu sırayla inci numarayı, biz numarası işgal yığın hangi pozisyon daha sonra olduğunu ve hangi öbek ilk bulmak istiyorum. Bizim artım sayısını çıkartıp igelen nkadar nazdır i(bize bir yığın veren) ve daha sonra basitçe eklemek n-1için i*idoğru olsun positionöbekte.

Örnek:

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 bayt

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

0 tabanlı yerine 1 tabanlı dizine ekleme için 4 bayt. Gereksiz bir kısıtlama, IMHO.

Çevrimiçi deneyin!

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 bayt

Bay Xcoder'a 1 bayt teşekkürler.

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

Çevrimiçi deneyin!

Daha yüksek rakamlar için ÇOK hızlı

Jöle , 8 bayt

Ḷ+²µ€Ẏ⁸ị

Çevrimiçi deneyin!

Haskell , 33 bayt

Anonim bir işlev. Farklı kullan((!!)$0:do n<-[1..];[n^2..n^2+n-1]) 1

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

Çevrimiçi deneyin!

• Diziyi sonsuz bir liste olarak yapılandırır, ardından ile dizine ekler !!. 0:0- 1 tabanlı bir endekslemesini ayarlamak için bir kukla elemanıdır.
• Aralık [n^2..n^2+n-1], sayıların karesinden başlayıp sayı niçeren boşluklar olmadan bir alt çizgi oluşturur n.
• doGösterim için tüm inşa aralıkları birleştirir n>=1.

Python 3 , 46 bayt

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

Çevrimiçi deneyin!

Perl 6 , 43 bayt

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

Dene

Expanded:

{  # 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}...*) üretir:

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

TeX, 166 bayt

\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}

kullanım

\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 bayt

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

Çevrimiçi deneyin!

Her üçgen sayısı artı bir için sonucun kare bir sayı olduğu gerçeğini kullanıyorum .

Örnek olarak: üçgen sayılar 0, 1, 3, 6, 10 ... yani 1, 2, 4, 7, 11 ... için sırayla 1, 4, 9, 16, 25 ... gözlemliyoruz .

Dizin bu bilinen sayılar arasında bir yerdeyse, dizimizin elemanları sadece bir tane ilerler. Örneğin, 10 için sonucu hesaplamak için 7 (üçgen sayı artı bir olarak) alırız, sonucu alırız (16) ve 10-7 = 3 ekleriz. Böylece, 16 + 3 = 19.

05AB1E , 12 bayt

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

Çevrimiçi deneyin!

cQuents , 27 bayt

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

Çevrimiçi deneyin!

Şu anda Leaky'nin Python cevabının bir limanı, sanırım daha iyi bir yol var.

Swift 3 , 72 bayt

Python çözümümün limanı .

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

Test odası.

C # (Mono) , 164 bayt

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

Çevrimiçi deneyin!

Mathematica, 37 bayt

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

açıklama

Range@#+#^2-1&

Functionpozitif bir tamsayı alır #ve# ve dizideki ardışık sayıların .

...~Array~#

Girdiye kadar olan tüm bu tür çalışmaların listesini üretir #

Flatten[...][[#]]

Flattensortaya çıkan liste ve #th öğesini döndürür .

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

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

Çevrimiçi deneyin!

Tampio , 310 308 bayt

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

Kullanımı: olarak 4:n unideğerlendirir 9.

Açıklama:

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

Standart kütüphaneden:

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

JavaScript (ES6), 33 bayt

Xanderhall'ın gözlemlerinden esinlenen özyinelemeli çözüm .

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

Dene

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 bayt

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

Çevrimiçi deneyin!

Mathematica, 82 bayt

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

Python , 40 bayt

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

Çevrimiçi deneyin!

Leaky Nun'ün ifadesini optimize etme .

Python , 41 bayt

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

Çevrimiçi deneyin!

Özyinelemeli ifade.

Javascript (ES6) 100 98 Bayt

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}

Bu tür hızlı yaptı, bu yüzden sadece temel döngüler ve sayaçlar, iyileştirme için çok yer var eminim.

Retina , 27 bayt

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

Çevrimiçi deneyin! Bağlantı noktası @ LeakyNun Python cevap. İlk ve son aşamalar sıkıcı ondalık-dönüşümdür. İkinci aşama şu şekilde çalışır: ((^1|1\2)+)üçgen sayı eşleştiricisidir; indeksi $1ise eşleşen üçgen sayıdır $2. Arka 1vasıtaların, yani bu şekilde Python döngüsünden daha tam bir az yineleme sonuçlanan kesin az girdi daha büyük üçgen numara ile aynı $1eşdeğerdir a-ive $2için i-1ve bunların toplamı a-1ya da ~-agerektiği gibi. ( $&sadece eşleşmenin sonuçtan silinmesini önler.) 1Eşleştirme yapılmayan bir girdi için ve çıktının girdiyle aynı olduğunu unutmayın. Eğer sapık olsaydın,^((^1|1\2)*)1 bu durumda da eşleşecek.

MATL , 12 bayt

:"@U@:q+]vG)

Çevrimiçi deneyin!

açıklama

:        % 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 bayt

@ Xanderhall'ın algoritmasını burada kullanmak

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

Çevrimiçi deneyin!

PHP, 48 42 37 + 1 bayt

Leaky Nun'in cevabından taşındı

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

Pipo ile çalıştırın -Fveya çevrimiçi deneyin .

doğrudan yaklaşım, 42 + 1 bayt ( Leaky Nun'in diğer cevabından alınmıştır )

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

İle boru olarak çalıştır -nRYukarıdaki TiO veya ondan çıkma .

eski yinelemeli çözüm, 48 + 1 bayt

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