Imaginez énumérer les éléments des losanges qui se développent [1],[1,3,1],[1,3,5,3,1],…(uniquement des nombres impairs tels qu'ils s'alignent bien). Cela ressemblerait à ceci, notez que vous commencez toujours à énumérer avec 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)   …

Maintenant, si vous commencez à additionner les colonnes ( [1],[2],[1,3,5],[4],[5],[2,6,10],…), vous obtenez la séquence losange . Ce sont les 100 premiers éléments de ladite séquence:

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

Vous êtes libre de choisir l'une de ces trois méthodes d'entrée / sortie (vous n'aurez pas besoin de gérer des entrées invalides):

• Étant donné un entier n, sortir le n ème élément de cette séquence (indexé 0 ou 1, votre choix)
• Étant donné un nombre entier n de sortie n premiers éléments de cette séquence
• Imprimer / renvoyer la séquence indéfiniment

Cas de test

Veuillez vous référer aux 100 premiers termes ci-dessus, voici quelques exemples plus grands (indexés 1):

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

Bonhomme de neige , 72 octets

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

Il s'agit d'un sous-programme qui prend une entrée indexée 1 et renvoie la sortie correspondante via le permavar +.

Essayez-le en ligne!

((        // 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
))

Cela utilise essentiellement le même algorithme que la réponse de M. Xcoder - la seule différence est qu'ici, nous ne générons que les colonnes du losange dont nous avons besoin, qui est le plafond (sqrt (n)) e. Pour illustrer pourquoi cela fonctionne, voici les entrées qui correspondent à chaque losange:

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

Notez que la colonne de gauche correspond exactement au plafond de la racine carrée de chaque élément de la colonne de droite. Pour obtenir l'indice basé sur 1 à partir d'ici, il suffit de soustraire le carré de l'indice du losange précédent.

Gelée , 10 octets

Ḥ€€’ŒBFị@×

Essayez-le en ligne!

Un programme complet / lien monadique renvoyant le N ème terme (indexé 1).

J'ai remarqué que chaque somme est l'index de cette colonne dans la liste globale des colonnes (l'entrée elle-même) multipliée par l'index de cette colonne dans le losange correspondant, donc pas besoin de générer réellement les lignes.

Comment?

Ḥ €€ 'ŒBFị @ × ~ Programme complet. J'appellerai l'entrée N.

  € ~ Pour chaque entier X dans la plage [1, N].
Ḥ € ~ Doublez chaque entier dans la plage [1, X].
   '~ Décrémenter (soustraire 1).
    ŒB ~ Bounce (élément par élément). Palindromisez chacun.
      F ~ Aplatir.
       ị @ ~ Récupère l'élément à l'index N de notre liste.
         × ~ Multipliez par N.

JavaScript (ES7), 42 41 octets

1 octet enregistré grâce à @ovs

0 indexé. Expression de forme fermée dérivée de A004737 .

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

Cas de test

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 octets

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

Essayez-le en ligne!

Explication

Nous commençons par lire le numéro d'élément à base unique, n , à partir de stdin, et enregistrer un doublon.
Ensuite, nous déterminons dans quel losange nous nous trouvons, en comptant un entier, r , jusqu'à r*r >= n.
La colonne décalée par rapport au côté droit du losange, c , est r*r - n.
Pour obtenir ce décalage réfléchi autour de l'axe central, nous vérifions si c >= r.
Et si c'est le cas, alors le c réfléchi devient r*2 - 2 - c.
Une fois que nous avons le c réfléchi , la somme de la colonne est simple (c*2 + 1) * n.

APL (Dyalog) , 18 octets

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

Essayez-le en ligne!

Gelée , 8 octets

_.ạ²€ṂḤ×

Essayez-le en ligne!

Comment ça fonctionne

_.ạ²€ṂḤ×  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.