私が話しているシーケンスは次のとおりです。

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

オンラインでお試しください！

@Nevayのおかげで-1バイト

しばらくこれを見つめた後、私はパターンに気づきました。n数字をドロップするたびに、シーケンスの次の数字は完全な正方形になります。これを見て、私は精神的にシーケンスを便利なチャンクに分割しました：[[1],[4,5],[9,10,11],...]基本的に、ithチャンクはで始まりi*i、i要素に対して上向きに反復します。

nこのシーケンスのth番号を見つけるために、最初に番号がどのチャンクにあるかを見つけ、次にそれが占めるチャンク内の位置を見つけたいです。私たちは、インクリメント数を引く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)!!)

0ベースではなく1ベースのインデックス作成用に4バイト追加。不必要な制限、私見。

オンラインでお試しください！

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バイト

Xcoder氏のおかげで1バイト。

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:0-に1ベースのインデックスから調整するためのダミー素子です。
• 範囲[n^2..n^2+n-1]は、2乗から始まり、数字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")

オンラインでお試しください！

私は、各三角形の数に1を足したものに対して、結果は平方数になるという事実を使用します。

例として、三角形の数は0、1、3、6、10 ...であるため、1、2、4、7、11 ...の場合、シーケンスで1、4、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回答の移植版ですが、もっと良い方法があると思います。

Swift 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$_--}{

オンラインでお試しください！

タンピオ、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回答のポート。最初と最後の段階は退屈な10進数⇔単項変換です。2番目の段階は次のように((^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´sの回答から移植

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;