Imagina enumerar los elementos de rombo que crecen [1],[1,3,1],[1,3,5,3,1],…(solo números impares para que se alineen bien). Esto se vería de la siguiente manera, tenga en cuenta que siempre comienza a enumerar con 1:

                   01
       1        02 03 04
 1   2 3 4   05 06 07 08 09          …
       5        10 11 12
                   13
(1) (1,3,1)    (1,3,5,3,1)    (1,3,5,7,5,3,1)   …

Ahora, si comienzas a sumar las columnas ( [1],[2],[1,3,5],[4],[5],[2,6,10],…), obtienes la secuencia de rombos . Estos son los primeros 100 elementos de dicha secuencia:

1,2,9,4,5,18,35,24,9,10,33,60,91,70,45,16,17,54,95,140,189,154,115,72,25,26,81,140,203,270,341,288,231,170,105,36,37,114,195,280,369,462,559,484,405,322,235,144,49,50,153,260,371,486,605,728,855,754,649,540,427,310,189,64,65,198,335,476,621,770,923,1080,1241,1110,975,836,693,546,395,240,81,82,249,420,595,774,957,1144,1335,1530,1729,1564,1395,1222,1045,864,679,490,297,100

IO

Usted es libre de elegir uno de estos tres métodos de entrada / salida (no necesitará manejar entradas no válidas):

• Dado un número entero n de salida del n -ésimo elemento en esa secuencia (0- o 1-indexada, su elección)
• Dado un número entero n salida primeros n elementos de esa secuencia
• Imprime / devuelve la secuencia indefinidamente

Casos de prueba

Consulte los primeros 100 términos anteriores, aquí hay algunos ejemplos más grandes (1 indexado):

101 -> 101
443 -> 1329
1000 -> 49000    
1984 -> 164672
2017 -> 34289
2018 -> 30270
3000 -> 153000

Muñeco de nieve , 72 bytes

((}1vn2nD#`nPnCdU!*2nM1`nR:#nSNaB#`nS2nMNdE;aM|#NdE2nP+#`nSNdE`|aA#nM*))

Esta es una subrutina que toma una entrada indexada y devuelve la salida correspondiente a través del permavar +.

Pruébalo en línea!

((        // begin subroutine
 }        // we'll only need 3 variables - b, e, g
 1vn2nD   // b = 0.5
 #`       // retrieve input and swap, now b = input and e = 0.5
 nP       // power, resulting in b=sqrt(input)
 nC       // ceiling - this gives the index i of the rhombus we want
 dU!*     // keep a copy of i in the permavar ! for later use
 2nM1`nR  // generate the range [1, 2i)
 :        // map the following block over the range...
  #nS     // subtract i, resulting in e.g. [-3 -2 -1 0 1 2 3] for i=4
  NaB     // absolute value - [3 2 1 0 1 2 3]
  #`nS    // subtract from i, giving [1 2 3 4 3 2 1]
  2nMNdE  // double and decrement, [1 3 5 7 5 3 1]
 ;aM      // map
 |        // shove the rhombus columns into g
 #NdE2nP  // b = (i-2)^2
 +#`      // move b into e and replace it with the original input
 nSNdE    // subtract the two and decrement, giving input-(i-2)^2-1
 `|aA     // this is the index into the rhombus columns that we want
 #nM*     // multiply by the original input and return
))

Utiliza básicamente el mismo algoritmo que la respuesta del Sr. Xcoder: la única diferencia es que aquí solo generamos las columnas del rombo que necesitamos, que es el ceil (sqrt (n)) th one. Para ilustrar por qué esto funciona, aquí están las entradas que corresponden a cada rombo:

rhombus #   inputs
1           1
2           2 3 4
3           5 6 7 8 9
4           10 11 12 13 14 15 16
...

Tenga en cuenta que la columna izquierda corresponde exactamente al techo de la raíz cuadrada de cada elemento en la columna derecha. Para obtener el índice basado en 1 desde aquí, simplemente restamos el cuadrado del índice del rombo anterior.

Jalea , 10 bytes

Ḥ€€’ŒBFị@×

Pruébalo en línea!

Un enlace completo programa / monádico devolver el N º plazo (1 indexados).

Noté que cada suma es el índice de esa columna en la lista general de columnas (la entrada en sí) multiplicada por el índice de esa columna en el Rhombus correspondiente, por lo que no es necesario generar las filas.

¿Cómo?

Ḥ €€ 'ŒBFị @ × ~ Programa completo. Llamaré a la entrada N.

  € ~ Para cada entero X en el rango [1, N].
Ḥ € ~ Duplique cada número entero en el rango [1, X].
   '~ Decremento (resta 1).
    ŒB ~ Bounce (elemento-sabio). Palindromizar cada uno.
      F ~ Acoplar.
       ị @ ~ Obtenga el elemento en el índice N de nuestra lista.
         × ~ Multiplicar por N.

JavaScript (ES7), 42 41 bytes

Guardado 1 byte gracias a @ovs

0 indexado. Una expresión de forma cerrada derivada de A004737 .

n=>((k=n**.5|0)-Math.abs(n+k*~k))*2*++n+n

Casos de prueba

let f =

n=>((k=n**.5|0)-Math.abs(n+k*~k))*2*++n+n

console.log(f(101-1))  // 101
console.log(f(443-1))  // 1329
console.log(f(1000-1)) // 49000    
console.log(f(1984-1)) // 164672
console.log(f(2017-1)) // 34289
console.log(f(2018-1)) // 30270
console.log(f(3000-1)) // 153000

Befunge, 62 60 bytes

&:1>:00p:*`|
00:-\*:g00:<>2-\-0v!`\g
*.@v+1<g00:<^*2g00_2*1+

Pruébalo en línea!

Explicación

Comenzamos leyendo el número de elemento basado en uno, n , de stdin, y guardando un duplicado.
Luego determinamos en qué rombo estamos, contando un número entero, r , hasta r*r >= n.
La columna desplazada desde el lado derecho del rombo, c , es r*r - n.
Para obtener ese desplazamiento reflejado alrededor del eje central, verificamos si c >= r.
Y si es así, entonces la c reflejada se convierte r*2 - 2 - c.
Una vez que tenemos la c reflejada , la suma de la columna es simplemente (c*2 + 1) * n.

APL (Dyalog) , 18 bytes

{⍵×2×⌊/|⍵-.5+×⍨⍳⍵}

Pruébalo en línea!

Jalea , 8 bytes

_.ạ²€ṂḤ×

Pruébalo en línea!

Cómo funciona

_.ạ²€ṂḤ×  Main link. Argument: n

_.        Subtract 0.5; yield (n - 0.5).
   ²€     Square each; yield [1², 2², ..., n²].
  ạ       Take the absolute differences of (n - 0.5) and each of the squares.
     Ṃ    Take the minimum.
      Ḥ   Unhalve; double the minimum.
       ×  Multiply the result by n.