Aquí está la secuencia de la que estoy hablando:

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

A partir de 1, mantenga 1, suelte los siguientes 2, mantenga los siguientes 2, suelte 3, mantenga 3 y así sucesivamente. Sí, ¡también está en OEIS (A064801) !

El reto

Dado un entero n>0, encuentre el enésimo término de la secuencia anterior

Casos de prueba

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

Este es el código de golf, por lo que gana la respuesta más corta en bytes. ¡Buena suerte!

Java (OpenJDK 8) , 45 44 bytes

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

Pruébalo en línea!

-1 byte gracias a @Nevay

Después de mirar esto por un tiempo, noté un patrón. Cada vez que soltamos nnúmeros, el siguiente número en la secuencia es un cuadrado perfecto. Al ver esto, rompí mentalmente la secuencia en trozos convenientes: [[1],[4,5],[9,10,11],...]Básicamente, el itrozo th comienza con i*i, e itera hacia arriba para los ielementos.

Para encontrar el nnúmero th en esta secuencia, queremos encontrar primero en qué parte se encuentra el número y luego en qué posición ocupa la parte. Restamos nuestro número de incrementos ide nhasta nes menor que i(lo que nos da nuestra trozo), y luego simplemente se añade n-1a i*iconseguir la correcta positionen el trozo.

Ejemplo:

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 bytes

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

4 bytes adicionales para indexación basada en 1 en lugar de basada en 0. Una restricción innecesaria, en mi humilde opinión.

Pruébalo en línea!

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 bytes

1 byte gracias al Sr. Xcoder.

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

Pruébalo en línea!

MUY rápido para números más altos

Jalea , 8 bytes

Ḷ+²µ€Ẏ⁸ị

Pruébalo en línea!

Haskell , 33 bytes

Una función anónima. Usar como((!!)$0:do n<-[1..];[n^2..n^2+n-1]) 1

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

Pruébalo en línea!

• Construye la secuencia como una lista infinita, luego la indexa con !!. El 0:es un elemento ficticio para ajustar la indexación basada en 0 a 1.
• El rango [n^2..n^2+n-1]construye una subsecuencia sin espacios, comenzando con el cuadrado de ny que contiene nnúmeros.
• La donotación concatena los rangos construidos para todos n>=1.

Python 3 , 46 bytes

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

Pruébalo en línea!

Perl 6 , 43 bytes

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

Pruébalo

Expandido:

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

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

TeX, 166 bytes

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

Uso

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

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

Pruébalo en línea!

Uso el hecho de que para cada número triangular más uno, el resultado es un número cuadrado.

Como ejemplo: los números triangulares son 0, 1, 3, 6, 10 ... así que para 1, 2, 4, 7, 11 ... observamos 1, 4, 9, 16, 25 ... en nuestra secuencia .

Si el índice está en algún lugar entre estos números conocidos, los elementos de nuestra secuencia solo avanzan en uno. Por ejemplo, para calcular el resultado de 10, tomamos 7 (como un número triangular más uno), tomamos el resultado (16) y sumamos 10-7 = 3. Por lo tanto, 16 + 3 = 19.

05AB1E , 12 bytes

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

Pruébalo en línea!

cQuents , 27 bytes

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

Pruébalo en línea!

Actualmente un puerto de la respuesta Python de Leaky , creo que hay una mejor manera.

Swift 3 , 72 bytes

Puerto de mi solución Python .

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

Banco de pruebas.

C # (Mono) , 164 bytes

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

Pruébalo en línea!

Mathematica, 37 bytes

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

Explicación

Range@#+#^2-1&

Functionque toma un entero positivo #y devuelve la serie de #números consecutivos en la secuencia.

...~Array~#

Produce la lista de todas esas ejecuciones hasta la entrada #

Flatten[...][[#]]

Flattensla lista resultante y devuelve el #elemento th.

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

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

Pruébalo en línea!

Tampio , 310 308 bytes

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

Uso: 4:n unievalúa a 9.

Explicación:

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

De la biblioteca estándar:

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

JavaScript (ES6), 33 bytes

Solución recursiva inspirada en las observaciones de Xanderhall .

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

Intentalo

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 bytes

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

Pruébalo en línea!

Mathematica, 82 bytes

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

Python , 40 bytes

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

Pruébalo en línea!

Optimizando la expresión de Leaky Nun .

Python , 41 bytes

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

Pruébalo en línea!

Expresión recursiva

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}

Lo hice rápido, así que apuesto a que hay mucho margen de mejora, solo bucles y contadores básicos.

Retina , 27 bytes

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

Pruébalo en línea! Puerto de la respuesta Python de @ LeakyNun. La primera y la última etapa son simplemente aburridas decimales conversion conversión unaria. La segunda etapa funciona así: ((^1|1\2)+)es un emparejador de números triangulares; $1es el número triangular coincidente mientras que $2es su índice. Los arrastran 1medios que coincide con el mayor número triangular estrictamente menor que la de entrada, lo que resulta en exactamente una iteración menos que el bucle de Python, lo que significa que $1es equivalente a a-iy $2a igualar en ese caso también.i-1 y su suma es a-1o~-a según sea necesario. ($& solo evita que la coincidencia se elimine del resultado). Tenga en cuenta que para una entrada de 1no coincidencia ocurre y la salida es simplemente la misma que la entrada. Si fueras perverso, podrías usar^((^1|1\2)*)1

MATL , 12 bytes

:"@U@:q+]vG)

Pruébalo en línea!

Explicación

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

Usando el algoritmo de @ Xanderhall aquí

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

Pruébalo en línea!

PHP, 48 42 37 + 1 bytes

portado de la respuesta de Leaky Nun

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

Ejecutar como tubería -Fo probarlo en línea .

enfoque directo, 42 + 1 bytes (portado de la otra respuesta de Leaky Nun )

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

Ejecutar como tubería con -nRo sin comentarios en TiO anterior.

solución iterativa anterior, 48 + 1 bytes

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