A000330 - OEIS

Tâche

Votre tâche est simple, générez une séquence qui, étant donné l'index i, la valeur à cette position est la somme des carrés de 0jusqu'à ioù i >= 0.

Exemple:

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)

Spécification:

• Vous ne pouvez prendre aucune entrée et sortir la séquence indéfiniment;
• Vous pouvez entrer Net sortir l' Nthélément de la séquence;
• Vous pouvez entrer Net sortir les premiers Néléments de la séquence.

Gelée , 3 octets

R²S

Essayez-le en ligne!

FGITW

Explication

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

Python 2 , 22 octets

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

Essayez-le en ligne!

Il utilise la formule fermée n * (n + 1) * (2 * n + 1) / 6 . Le code effectue les opérations suivantes:

• Multiplie n par ( n*):

  • Le complément au niveau du bit de n ( ~n), ce qui signifie essentiellement -1-n .
  • Et par le complément au niveau du bit de 2n ( *~(n*2)), ce qui signifie -1-2n .

• Divise par 6 ( /6).

Python 2 , 27 octets

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

Essayez-le en ligne!

_{Enregistré 1 octet grâce à Rod et 1 grâce à GB .}

MATL , 3 octets

:Us

... ou eux?

Essayez-le en ligne!

Explication

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

JavaScript (ES6), 16 octets

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

Démo

let f =

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

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

Comment?

L'expression n+++nest analysée comme n++ + n⁽¹⁾ . Ce n'est pas vraiment important car n + ++ncela fonctionnerait également dans ce cas.

Par conséquent:

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

qui évalue à additionner (k = 0 ... n) (k²) .

_{(1) Cela peut être vérifié en faisant n='2';console.log(n+++n)ce qui donne l'entier 5, alors n + ++nque donnerait la chaîne '23'.}

05AB1E , 3 octets

ÝnO

Essayez-le en ligne!

Explication

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

Brain-Flak , 36 octets

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

Essayez-le en ligne!

# 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 octets

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

Essayez-le en ligne!

Comment ça marche?

Au départ, j'avais la même idée que Riley ^1, mais je me sentais mal d'utiliser un zéro. J'ai alors réalisé que

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

Calcule n ² - n.

Pourquoi? Eh bien, nous savons

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

Calcule n ² et boucle n fois. Cela signifie que si nous inversons l'ordre des deux poussées, nous passons de l'augmentation de la somme de n + (n-1) à chaque fois à l'augmentation de la somme de (n-1) + (n-1) à chaque fois. Cela diminuera le résultat d'une par boucle, faisant ainsi notre résultat n ² - n. Au niveau supérieur, ce -n s'annule avec le n généré par la poussée que nous étions en train de mettre à zéro, réduisant ainsi le besoin d'un zéro et nous économisant deux octets.

Brain-Flak , 36 octets

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

Essayez-le en ligne!

Voici une autre solution, ce n'est pas aussi golfique mais c'est assez étrange alors j'ai pensé que je laisserais comme un défi de comprendre comment cela fonctionne.

Si vous n'êtes pas dans Brain-Flak mais que vous voulez toujours le défi ici, c'est comme une sommation.

^{1: J'ai trouvé ma solution avant de regarder les réponses ici. Donc pas de plagiat ici.}

Husk , 3 octets

ṁ□ḣ

Essayez-le en ligne!

Ohm v2 , 3 octets

#²Σ

Essayez-le en ligne!

Explication

#    Range
 ²   Square
  Σ  Sum

Japt , 3 octets

ô²x

Essayez-le ici.

-1 merci à Shaggy .

Explication:

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

Brain-Flak , 46 octets

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

Essayez-le en ligne!

CJam , 10 octets

ri),{_*+}*

Essayez-le en ligne!

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 octets

Tr[Range@#^2]&

Essayez-le en ligne!

En fait , 3 octets

R;*

Essayez-le en ligne!

Prend N en entrée et sort le Ne élément de la séquence.

Explication:

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

APL (Dyalog) , 7 5 octets

2 octets économisés grâce à @Mego

+.×⍨⍳

Essayez-le en ligne!

Comment?

⍳ - intervalle

+.× - produit scalaire

⍨ - avec lui-même

R, 17 octets

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

Assez simple, il profite du fait que ^(exponentiation) est vectorisé dans R .

CJam , 9 octets

ri),_.*:+

Essayez-le en ligne!

Explication

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.

Alternativement:

ri),2f#:+

Cela place chaque élément en correspondance 2#au lieu d'utiliser des produits par paire. Et juste pour le plaisir, une autre alternative qui devient inexacte pour les grandes entrées car elle utilise l'arithmétique à virgule flottante:

ri),:mh2#

Julia , 16 ans 14 octets

2 octets enregistrés grâce à @MartinEnder

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

Essayez-le en ligne!

Comment?

(x=1:n)crée une gamme de 1à net attribue à x, ⋅produit scalaire avec x.

Labyrinthe , 11 octets

:!\
+ :
*:#

Essayez-le en ligne!

Imprime la séquence indéfiniment.

Explication

Le pointeur d'instruction continue de tourner autour du carré de code encore et encore:

:!\    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 octets

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

Essayez-le en ligne!

Mon code est un peu triste ):

Calcule 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 octets

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

En utilisant la formule fermée n * (n + 1) * (2n + 1) / 6 .

Essayez-le en ligne!

Befunge , 38 octets

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

À l'aide d'une boucle.

Essayez-le en ligne!

Haskell, 20 octets

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

Essayez-le en ligne!

Excel, 19 octets

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

Hexagonie , 23 octets

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

Essayez-le en ligne!

Explication

Déplié:

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

C'est vraiment juste un programme linéaire avec la /redirection utilisée. Le code linéaire est:

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

Qui calcule n (n + 1) (2n + 1) / 6 . Il utilise les bords de mémoire suivants:

Où le point mémoire (MP) commence sur le bord étiqueté n , pointant vers le nord.

?   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.

En théorie, il pourrait être possible d'adapter ce programme à la longueur de côté 3, car /ils ne sont pas nécessaires pour le calcul, ils :peuvent être réutilisés pour terminer le programme, et certains '"=+*{peuvent également être réutilisables, ce qui porte le nombre de commandes inférieures à 19 (le maximum pour la longueur latérale 3). Je doute qu'il soit possible de trouver une telle solution à la main, s'il en existe une.

> <> , 15 13 11 octets

Enregistré 2 octets grâce à Pas un arbre

0:n:l1-:*+!

Essayez-le en ligne!

Sort la séquence indéfiniment.

Pyth , 7 5 octets grâce à Steven H

s^R2h

Explication:

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

Ma première solution

sm*ddUh

Essayez-le en ligne!

Explication:

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 octets

𝐈ᛦ𝐬

Cela aurait pu être un défi pour montrer les blocs de nombres polygonaux de Neim, mais apparemment pas.

Essayez-le en ligne!

Oasis , 4 octets

nk+0

Essayez-le en ligne!

Explication

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

Brachylog , 5 octets

⟦^₂ᵐ+

Essayez-le en ligne!

Explication

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

Gaia , 3 octets

s¦Σ

Essayez-le en ligne!