这是我正在谈论的顺序：

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

从1开始，保持1，下降下一个2，保持下一个2，下降3，保持3，依此类推。是的，它也在OEIS（A064801）上！

挑战

给定一个整数n>0，找到上述序列的第n项

测试用例

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

这是代码高尔夫球，所以最短答案以字节为单位！祝好运！

Java（OpenJDK 8），45 44字节

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

在线尝试！

-1字节感谢@Nevay

凝视了一段时间之后，我注意到了一种模式。每次我们删除n数字时，序列中的下一个数字都是一个完美的正方形。看到这一点，我就在头脑中将序列分解为方便的块：[[1],[4,5],[9,10,11],...]基本上，i第一个块以开头i*i，并向上迭代i元素。

为了找到n此序列中的第一个数字，我们要首先找到该数字位于哪个块中，然后找到它在该块中的哪个位置。我们减去我们的增量数i从n之前n的不到i（这为我们提供了我们的块），然后简单地添加n-1到i*i获得正确position的块。

例：

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字节

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

4个额外字节用于基于1的索引，而不是基于0的索引。不必要的限制，恕我直言。

在线尝试！

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个字节

1个字节，感谢Xcoder先生。

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

在线尝试！

非常快的数字

果冻，8字节

Ḷ+²µ€Ẏ⁸ị

在线尝试！

Haskell，33个字节

匿名函数。用于((!!)$0:do n<-[1..];[n^2..n^2+n-1]) 1

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

在线尝试！

• 将序列构造为无限列表，然后使用对其进行索引!!。的0:是从基于1-O-对索引来调整伪元件。
• 该范围[n^2..n^2+n-1]构造一个无间隙的子序列，从带数字的平方开始n并包含n数字。
• 该do符号将所有的构造范围连接起来n>=1。

Python 3，46个字节

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

在线尝试！

Perl 6、43字节

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

测试一下

展开：

{  # 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}...*) 产生：

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

TeX，166个字节

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

用法

\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字节

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

在线尝试！

我使用这样的事实：每个三角形数字加一个，结果就是一个平方数。

例如：三角数为0、1、3、6、10 ...因此，对于1,2、4、7、11 ...，我们依次观察到1，4，9，9，16，25 ... 。

如果索引在这些已知数字之间，则序列中的元素仅前进1。例如，要计算10的结果，我们取7（作为三角数加1），取结果（16）并加10-7 = 3。因此，16 + 3 = 19。

05AB1E，12个字节

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

在线尝试！

cQuents，27个字节

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

在线尝试！

目前有Leaky的Python答案端口，但我认为有更好的方法。

迅捷 3，72字节

我的Python解决方案的端口。

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

测试套件。

C＃（单声道），164字节

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

在线尝试！

Mathematica，37个字节

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

说明

Range@#+#^2-1&

Function它取一个正整数#并返回#序列中连续数字的游程。

...~Array~#

生成所有此类运行直至输入的列表 #

Flatten[...][[#]]

Flattens结果列表并返回#th元素。

Perl 5，33 +1（-p）= 34字节

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

在线尝试！

Tampio，310个 308字节

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

用法：4:n uni计算为9。

说明：

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

从标准库：

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

JavaScript（ES6），33个字节

递归解受Xanderhall的观察启发。

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

试试吧

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个字节

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

在线尝试！

Mathematica，82个字节

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

Python，40个字节

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

在线尝试！

优化Leaky Nun的表情。

Python，41字节

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

在线尝试！

递归表达式。

Javascript（ES6）100 98字节

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}

这样做的速度很快，所以我敢打赌，还有很多改进的余地，只有基本的循环和计数器。

视网膜，27字节

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

在线尝试！@LeakyNun的Python答案的端口。第一阶段和最后阶段只是无聊的十进制⇔一元转换。第二阶段是这样的：((^1|1\2)+)是一个三角数字匹配器；$1是匹配的三角数，$2而是其索引。后端1装置它最大三角形号码匹配比输入严格少，从而导致比Python的循环正好一个更少的迭代，这意味着$1相当于a-i和$2到i-1和它们的和a-1或~-a根据需要。（$&只是防止从结果中删除匹配项。）请注意，对于1没有匹配项的输入，输出与输入完全相同。如果您不正常，可以使用^((^1|1\2)*)1 在这种情况下也要匹配。

MATL，12字节

:"@U@:q+]vG)

在线尝试！

说明

:        % 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个字节

在这里使用@Xanderhall的算法

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

在线尝试！

PHP，48 42 37 + 1字节

从Leaky Nun的答案移植

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

与管道一起运行-F或在线尝试。

直接方法，42 + 1字节 （从Leaky Nun的其他答案移植而来）

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

-nR在上面的TiO中有或没有注释的情况下作为管道运行。

较旧的迭代解决方案，48 + 1字节

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