A000330 - OEIS

Aufgabe

Ihre Aufgabe ist einfach: Generieren Sie eine Sequenz, bei der ider Wert für diese Position bei gegebenem Index die Summe der Quadrate von 0bis zu iwo ist i >= 0.

Beispiel:

Input: 0
Output: 0           (0^2)

Input: 4
Output: 30          (0^2 + 1^2 + 2^2 + 3^2 + 4^2)

Input: 5
Output: 55          (0^2 + 1^2 + 2^2 + 3^2 + 4^2 + 5^2)

Spezifikation:

• Sie können keine Eingabe vornehmen und die Sequenz auf unbestimmte Zeit ausgeben.
• Sie können Ndas NthElement der Sequenz eingeben und ausgeben .
• Sie können Ndie ersten NElemente der Sequenz eingeben und ausgeben .

Gelee , 3 Bytes

R²S

Probieren Sie es online!

FGITW

Erläuterung

R²S  Main Link
R    Generate Range
 ²   Square (each term)
  S  Sum

Python 2 , 22 Bytes

lambda n:n*~n*~(n*2)/6

Probieren Sie es online!

Dies verwendet die geschlossene Formel n * (n + 1) * (2 * n + 1) / 6 . Der Code führt die folgenden Vorgänge aus:

• Multipliziert n mit ( n*):

  • Das bitweise Komplement von n ( ~n), was im Wesentlichen -1-n bedeutet .
  • Und durch das bitweise Komplement von 2n ( *~(n*2)), was -1-2n bedeutet .

• Dividiert durch 6 ( /6).

Python 2 , 27 Bytes

f=lambda n:n and f(n-1)+n*n

Probieren Sie es online!

_{1 Byte dank Rod und 1 dank GB gespeichert .}

MATL , 3 Bytes

:Us

... oder sie?

Probieren Sie es online!

Erläuterung

:    % Implicit input n. Push range [1 2 ... n]
U    % Square, element-wise
s    % Sum of array. Implicit display

JavaScript (ES6), 16 Byte

n=>n*(n+++n)*n/6

Demo

let f =

n=>n*(n+++n)*n/6

for(n = 0; n < 10; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Wie?

Der Ausdruck n+++nwird als n++ + n⁽¹⁾ analysiert . Nicht, dass es wirklich darauf ankommt, denn das n + ++nwürde auch in diesem Fall funktionieren.

Deshalb:

n*(n+++n)*n/6 =
n * (n + (n + 1)) * (n + 1) / 6 =
n * (2 * n + 1) * (n + 1) / 6

die auswertet , um sum (k = 0 ... n) (K²) .

_{(1) Dies kann überprüft werden, indem getan wird n='2';console.log(n+++n), was die ganze Zahl ergibt 5, wohingegen n + ++ndie Zeichenfolge ergeben würde '23'.}

05AB1E , 3 Bytes

ÝnO

Probieren Sie es online!

Erläuterung

  O    # sum of
 n     # squares of
Ý      # range [0 ... input]

Brain-Flak , 36 Bytes

({<(({}[()])())>{({})({}[()])}{}}{})

Probieren Sie es online!

# Main algorithm
(                                  )  # Push the sum of:
                {({})({}[()])}{}      #   The square of:
 {                              }     #     0 to i 

# Stuff for the loop
  <(({}[()])())>                      # Push i-1, i without counting it in the sum
                                 {}   # Pop the counter (0)

Brain-Flak , 34 Bytes

({(({}[()])()){({}[()])({})}{}}{})

Probieren Sie es online!

Wie funktioniert es?

Anfangs hatte ich die gleiche Idee wie Riley ^1, aber es fühlte sich falsch an, einen Nuller zu verwenden. Das habe ich dann gemerkt

{({}[()])({})}{}

Berechnet n ² - n.

Warum? Nun, wir wissen es

{({})({}[()])}{}

Berechnet n ² und schleift n-mal. Das heißt, wenn wir die Reihenfolge der beiden Schübe ändern, erhöhen wir die Summe jedes Mal um n + (n-1) und erhöhen die Summe jedes Mal um (n-1) + (n-1). Dies verringert das Ergebnis um eins pro Schleife, wodurch unser Ergebnis n ² - n wird. Auf der obersten Ebene hebt dieses -n das durch den Push erzeugte n auf, den wir auf Null gesetzt haben, wodurch die Notwendigkeit eines Nullstellers verringert und uns zwei Bytes erspart wurden.

Brain-Flak , 36 Bytes

({({})(({}[()])){({})({}[()])}{}}{})

Probieren Sie es online!

Hier ist eine andere Lösung, es ist nicht so golfen, aber es ist ziemlich seltsam, also dachte ich, ich würde es als Herausforderung belassen, herauszufinden, wie es funktioniert.

Wenn Sie nicht auf Brain-Flak stehen, aber dennoch die Herausforderung suchen, ist dies eine Summe.

^{1: Ich habe mir eine Lösung ausgedacht, bevor ich mir die Antworten hier angesehen habe. Also hier kein Plagiat.}

Schale , 3 Bytes

ṁ□ḣ

Probieren Sie es online!

Ohm v2 , 3 Bytes

#²Σ

Probieren Sie es online!

Erläuterung

#    Range
 ²   Square
  Σ  Sum

Japt , 3 Bytes

ô²x

Probieren Sie es hier aus.

-1 danke an Shaggy .

Erläuterung:

ò²x 
ô²  Map square on [0..input]
  x Sum

Brain-Flak , 46 Bytes

{(({})[()])}{}{({({})({}[()])}{}<>)<>}<>({{}})

Probieren Sie es online!

CJam , 10 Bytes

ri),{_*+}*

Probieren Sie es online!

ri            e# Input integer n
  )           e# Add 1
   ,          e# Range [0 1 ... n]
    {   }*    e# Fold (reduce)
     _        e# Duplicate
      *       e# Multiply
       +      e# Add

Wolfram Language (Mathematica) , 14 Byte

Tr[Range@#^2]&

Probieren Sie es online!

Eigentlich 3 Bytes

R;*

Probieren Sie es online!

Nimmt Nals Eingabe und gibt das Ndritte Element in der Sequenz aus.

Erläuterung:

R;*
R    range(1, N+1) ([1, 2, ..., N])
 ;*  dot product with self

APL (Dyalog) , 7 5 Bytes

2 Bytes gespart dank @Mego

+.×⍨⍳

Probieren Sie es online!

Wie?

⍳ - Reichweite

+.× - Skalarprodukt

⍨ - mit sich selbst

R, 17 Bytes

sum((0:scan())^2)

Ziemlich einfach, es nutzt die Tatsache, dass ^(Potenzierung) in R vektorisiert ist .

CJam , 9 Bytes

ri),_.*:+

Probieren Sie es online!

Erläuterung

ri        e# Read input and convert to integer N.
  ),      e# Get range [0 1 2 ... N].
    _     e# Duplicate.
     .*   e# Pairwise products, giving [0 1 4 ... N^2].
       :+ e# Sum.

Alternative:

ri),2f#:+

Dies quadriert jedes Element durch Mapping, 2#anstatt paarweise Produkte zu verwenden. Und nur zum Spaß eine weitere Alternative, die bei großen Eingaben ungenau wird, weil sie Gleitkomma-Arithmetik verwendet:

ri),:mh2#

Julia , 16 14 Bytes

2 Bytes gespart dank @MartinEnder

!n=(x=1:n)⋅x

Probieren Sie es online!

Wie?

(x=1:n)Erstellt eine Reihe von 1zu nund weist zu x, ⋅dot Produkt mit x.

Labyrinth , 11 Bytes

:!\
+ :
*:#

Probieren Sie es online!

Druckt die Sequenz auf unbestimmte Zeit.

Erläuterung

Der Befehlszeiger läuft immer und immer wieder um das Quadrat des Codes:

:!\    Duplicate the last result (initially zero), print it and a linefeed.
:      Duplicate the result again, which increases the stack depth.
#      Push the stack depth (used as a counter variable).
:*     Square it.
+      Add it to the running total.

Cubix , 15 Bytes

Iu):^\+*p*6u@O,

Probieren Sie es online!

Mein Code ist ein bisschen traurig ):

Berechnet n*(n+1)*(2n+1)/6

    I u
    ) :
^ \ + * p * 6 u
@ O , . . . . .
    . .
    . .

^Iu : read in input, u-turn
    : stack  n
:)\ : dup, increment, go right..oh, hey, it cheered up!
    : stack: n, n+1
+   : sum
    : stack: n, n+1, 2*n+1
*   : multiply
    : stack: n, n+1, 2*n+1, (n+1)*(2*n+1)
p   : move bottom of stack to top
    : stack: n+1, 2*n+1, (n+1)*(2*n+1), n
*   : multiply
6   : push 6
u   : right u-turn
,   : divide
O   : output
@   : terminate

Befunge , 16 Bytes

&::2*1+*\1+*6/.@

Verwenden Sie die geschlossene Formel n * (n + 1) * (2n + 1) / 6 .

Probieren Sie es online!

Befunge , 38 Bytes

v>::*\1-:v0+_$.@
&^ <     _\:^
>:#^_.@

Mit einer Schleife.

Probieren Sie es online!

Haskell, 20 Bytes

f 0=0
f n=n*n+f(n-1)

Probieren Sie es online!

Excel, 19 Bytes

=A1^3/3+A1^2/2+A1/6

Hexagony , 23 Bytes

?'+)=:!@/*"*'6/{=+'+}/{

Probieren Sie es online!

Erläuterung

Entfaltet:

   ? ' + )
  = : ! @ /
 * " * ' 6 /
{ = + ' + } /
 { . . . . .
  . . . . .
   . . . .

Dies ist eigentlich nur ein lineares Programm mit der /für einige Umleitungen verwendeten Funktion. Der lineare Code lautet:

?'+){=+'+}*"*'6{=:!@

Was berechnet n (n + 1) (2n + 1) / 6 . Es verwendet die folgenden Speicherflanken:

Wo der Speicherpunkt (MP) an der mit n bezeichneten Kante beginnt und nach Norden zeigt.

?   Read input into edge labelled 'n'.
'   Move MP backwards onto edge labelled 'n+1'.
+   Copy 'n' into 'n+1'.
)   Increment the value (so that it actually stores the value n+1).
{=  Move MP forwards onto edge labelled 'temp' and turn around to face
    edges 'n' and 'n+1'.
+   Add 'n' and 'n+1' into edge 'temp', so that it stores the value 2n+1.
'   Move MP backwards onto edge labelled '2n+1'.
+   Copy the value 2n+1 into this edge.
}   Move MP forwards onto 'temp' again.
*   Multiply 'n' and 'n+1' into edge 'temp', so that it stores the value
    n(n+1).
"   Move MP backwards onto edge labelled 'product'.
*   Multiply 'temp' and '2n+1' into edge 'product', so that it stores the
    value n(n+1)(2n+1).
'   Move MP backwards onto edge labelled '6'.
6   Store an actual 6 there.
{=  Move MP forwards onto edge labelled 'result' and turn around, so that
    the MP faces edges 'product' and '6'.
:   Divide 'product' by '6' into 'result', so that it stores the value
    n(n+1)(2n+1)/6, i.e. the actual result.
!   Print the result.
@   Terminate the program.

Theoretisch könnte es möglich sein, dieses Programm in die Seitenlänge 3 einzufügen, da /sie für die Berechnung nicht benötigt :werden, zum Beenden des Programms wiederverwendet werden können und einige '"=+*{davon auch wiederverwendbar sind, was die Anzahl der erforderlichen Programme mit sich bringt Befehle unter 19 (das Maximum für Seitenlänge 3). Ich bezweifle, dass es möglich ist, eine solche Lösung von Hand zu finden, wenn überhaupt eine existiert.

> <> , 15 13 11 Bytes

2 Bytes gespart dank Not a tree

0:n:l1-:*+!

Probieren Sie es online!

Gibt die Sequenz auf unbestimmte Zeit aus.

Pyth , 7 5 Bytes dank Steven H.

s^R2h

Erläuterung:

s^R2h       Full program - inputs from stdin and outputs to stdout
s           output the sum of
    h       range(input), with
 ^R2         each element squared

Meine erste Lösung

sm*ddUh

Probieren Sie es online!

Erläuterung:

sm*ddUh    Full program - inputs from stdin and outputs to stdout
s          sum of
 m   Uh    each d in range(input)
  *dd      squared

Neim , 3 Bytes

𝐈ᛦ𝐬

Es hätte eine Herausforderung sein können, Neims polygonale Zahlen zu demonstrieren, aber anscheinend nicht.

Probieren Sie es online!

Oase , 4 Bytes

nk+0

Probieren Sie es online!

Erläuterung

   0      # a(0) = 0
nk+       # a(n) = a(n-1)+n^2

Brachylog , 5 Bytes

⟦^₂ᵐ+

Probieren Sie es online!

Erläuterung

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

Gaia , 3 Bytes

s¦Σ

Probieren Sie es online!