Stellen Sie sich vor, Sie zählen die Elemente der wachsenden Rauten auf [1],[1,3,1],[1,3,5,3,1],…(nur ungerade Zahlen, damit sie gut ausgerichtet sind). Dies würde wie folgt aussehen: Beachten Sie, dass Sie immer mit der Aufzählung beginnen mit 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)   …

Wenn Sie nun mit der Summierung der Spalten ( [1],[2],[1,3,5],[4],[5],[2,6,10],…) beginnen, erhalten Sie die Rautenfolge . Dies sind die ersten 100 Elemente dieser Sequenz:

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

Sie können eine dieser drei Eingabe- / Ausgabemethoden auswählen (Sie müssen keine ungültigen Eingaben verarbeiten):

• Bei einer Ganzzahl n wird das n- te Element in dieser Sequenz ausgegeben (0- oder 1-indiziert, Ihre Wahl).
• Bei einer Ganzzahl n werden zuerst n Elemente dieser Sequenz ausgegeben
• Drucken Sie die Sequenz auf unbestimmte Zeit

Testfälle

Bitte beziehen Sie sich auf die ersten 100 Begriffe oben, hier sind einige größere Beispiele (1-indexiert):

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

Schneemann , 72 Bytes

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

Dies ist eine Unterroutine, die eine 1-indizierte Eingabe verwendet und die entsprechende Ausgabe über das Permavar zurückgibt +.

Probieren Sie es online aus!

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

Dies verwendet im Grunde den gleichen Algorithmus wie die Antwort von Mr. Xcoder - der einzige Unterschied besteht darin, dass wir hier nur die Spalten der Raute generieren, die wir benötigen, nämlich die Ceil (sqrt (n)). Um zu veranschaulichen, warum dies funktioniert, sind hier die Eingaben, die jeder Raute entsprechen:

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

Beachten Sie, dass die linke Spalte genau der Decke der Quadratwurzel jedes Elements in der rechten Spalte entspricht. Um den 1-basierten Index von hier zu erhalten, subtrahieren wir einfach das Quadrat des Index der vorherigen Raute.

Gelee , 10 Bytes

Ḥ€€’ŒBFị@×

Probieren Sie es online aus!

Ein vollständiger Programm- / Monadic-Link, der den N- ten Term zurückgibt (1-indiziert).

Ich habe festgestellt, dass jede Summe der Index dieser Spalte in der Gesamtliste der Spalten (die Eingabe selbst) multipliziert mit dem Index dieser Spalte in der entsprechenden Raute ist, sodass die Zeilen nicht tatsächlich generiert werden müssen.

Wie?

Ḥ €€ 'ŒBFị @ × ~ Vollständiges Programm. Ich werde den Eingang N nennen.

  € ~ Für jede ganze Zahl X im Bereich [1, N].
Ḥ € ~ Verdoppeln Sie jede Ganzzahl im Bereich [1, X].
   '~ Dekrementieren (1 subtrahieren).
    ŒB ~ Bounce (elementweise). Palindromize jeweils.
      F ~ Abflachen.
       ị @ ~ Holen Sie sich das Element am Index N in unserer Liste.
         × ~ Mit N multiplizieren.

JavaScript (ES7), 42 41 Byte

1 Byte dank @ovs gespeichert

0-indiziert. Ein Ausdruck in geschlossener Form, abgeleitet von A004737 .

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

Testfälle

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+

Probieren Sie es online aus!

Erläuterung

Wir beginnen mit dem Lesen der einbasierten Elementnummer n aus stdin und dem Speichern eines Duplikats.
Dann bestimmen wir, in welcher Raute wir uns befinden, indem wir eine ganze Zahl r bis hochzählenr*r >= n .
Der Spaltenversatz von der rechten Seite der Raute c ist r*r - n.
Um diesen Versatz um die Mittelachse zu reflektieren, prüfen wir, ob c >= r.
Und wenn ja, dann wird das reflektierte c wird r*2 - 2 - c.
Sobald wir das reflektierte c haben , ist die Summe der Spalte einfach (c*2 + 1) * n.

APL (Dyalog) , 18 Bytes

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

Probieren Sie es online aus!

Gelee , 8 Bytes

_.ạ²€ṂḤ×

Probieren Sie es online aus!

Wie es funktioniert

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