A000330 - OEIS

Tarea

Su tarea es simple, generar una secuencia que, dado el índice i, el valor en esa posición es la suma de cuadrados desde 0hasta idonde i >= 0.

Ejemplo:

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)

Especificación:

• No puede realizar ninguna entrada y salida de la secuencia indefinidamente;
• Puede tomar entrada Ny salida del Nthelemento de la secuencia;
• Puede tomar entrada Ny salida los primeros Nelementos de la secuencia.

Jalea , 3 bytes

R²S

Pruébalo en línea!

FGITW

Explicación

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

Python 2 , 22 bytes

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

Pruébalo en línea!

Utiliza la fórmula de forma cerrada n * (n + 1) * (2 * n + 1) / 6 . El código realiza las siguientes operaciones:

• Multiplica n por ( n*):

  • El complemento bit a bit de n ( ~n), que esencialmente significa -1-n .
  • Y por el complemento bit a bit de 2n ( *~(n*2)), que significa -1-2n .

• Se divide por 6 ( /6).

Python 2 , 27 bytes

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

Pruébalo en línea!

_{Guardado 1 byte gracias a Rod y 1 gracias a GB .}

MATL , 3 bytes

:Us

... o ellos?

Pruébalo en línea!

Explicación

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

JavaScript (ES6), 16 bytes

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

Manifestación

let f =

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

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

¿Cómo?

La expresión n+++nse analiza como n++ + n⁽¹⁾ . No es que realmente importe porque n + ++ntambién funcionaría en este caso.

Por lo tanto:

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

que se evalúa como suma (k = 0 ... n) (k²) .

_{(1) Esto se puede verificar haciendo lo n='2';console.log(n+++n)que da el número entero 5, mientras n + ++nque daría la cadena '23'.}

05AB1E , 3 bytes

ÝnO

Pruébalo en línea!

Explicación

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

Brain-Flak , 36 bytes

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

Pruébalo en línea!

# 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

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

Pruébalo en línea!

¿Como funciona?

Inicialmente tuve la misma idea que Riley ^1, pero me sentí mal al usar un cero. Entonces me di cuenta de que

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

Calcula n ² - n.

¿Por qué? Bueno sabemos

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

Calcula n ² y repite n veces. Eso significa que si cambiamos el orden de los dos impulsos, pasamos de aumentar la suma en n + (n-1) cada vez a aumentar la suma en (n-1) + (n-1) cada vez. Esto disminuirá el resultado en uno por ciclo, haciendo que nuestro resultado sea n ² - n. En el nivel superior, esto -n se cancela con la n generada por el impulso que estábamos poniendo a cero aliviando la necesidad de un cero y ahorrándonos dos bytes.

Brain-Flak , 36 bytes

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

Pruébalo en línea!

Aquí hay otra solución, no es tan elegante, pero es bastante extraño, así que pensé que lo dejaría como un desafío para descubrir cómo funciona.

Si no te gusta Brain-Flak pero aún quieres el desafío aquí, es como un resumen.

^{1: Se me ocurrió mi solución antes de mirar las respuestas aquí. Así que no hay plagio aquí.}

Casco , 3 bytes

ṁ□ḣ

Pruébalo en línea!

Ohm v2 , 3 bytes

#²Σ

Pruébalo en línea!

Explicación

#    Range
 ²   Square
  Σ  Sum

Japt , 3 bytes

ô²x

Pruébalo aquí

-1 gracias a Shaggy .

Explicación:

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

Brain-Flak , 46 bytes

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

Pruébalo en línea!

CJam , 10 bytes

ri),{_*+}*

Pruébalo en línea!

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 bytes

Tr[Range@#^2]&

Pruébalo en línea!

En realidad , 3 bytes

R;*

Pruébalo en línea!

Toma Ncomo entrada y da salida alN elemento th en la secuencia.

Explicación:

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

APL (Dyalog) , 7 5 bytes

2 bytes guardados gracias a @Mego

+.×⍨⍳

Pruébalo en línea!

¿Cómo?

⍳ - distancia

+.× - producto de punto

⍨ - consigo mismo

R, 17 bytes

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

Bastante sencillo, que se aprovecha del hecho de que ^(exponenciación) está vectorizada en R .

CJam , 9 bytes

ri),_.*:+

Pruébalo en línea!

Explicación

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.

Alternativamente:

ri),2f#:+

Esto cuadra cada elemento mediante mapeo en 2#lugar de usar productos por pares. Y solo por diversión, otra alternativa que se vuelve imprecisa para entradas grandes porque usa aritmética de punto flotante:

ri),:mh2#

Julia , 16 14 bytes

2 bytes guardados gracias a @MartinEnder

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

Pruébalo en línea!

¿Cómo?

(x=1:n)crea una serie de 1a ny asignar a x, ⋅dot producto con x.

Laberinto , 11 bytes

:!\
+ :
*:#

Pruébalo en línea!

Imprime la secuencia indefinidamente.

Explicación

El puntero de instrucciones sigue corriendo alrededor del cuadrado de código una y otra vez:

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

Pruébalo en línea!

Mi código es un poco triste ):

Computa 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/.@

Usando la fórmula de forma cerrada n * (n + 1) * (2n + 1) / 6 .

Pruébalo en línea!

Befunge , 38 bytes

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

Usando un bucle.

Pruébalo en línea!

Haskell, 20 bytes

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

Pruébalo en línea!

Excel, 19 bytes

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

Hexagonía , 23 bytes.

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

Pruébalo en línea!

Explicación

Desplegado:

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

Esto es realmente solo un programa lineal con el /utilizado para alguna redirección. El código lineal es:

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

Que calcula n (n + 1) (2n + 1) / 6 . Utiliza los siguientes bordes de memoria:

Donde el punto de memoria (MP) comienza en el borde con la etiqueta n , apuntando hacia el norte.

?   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 teoría, podría ser posible ajustar este programa en la longitud lateral 3, ya que /no son necesarios para el cálculo, :pueden reutilizarse para terminar el programa, y ​​algunos de ellos también '"=+*{pueden ser reutilizables, lo que aumenta el número de comandos por debajo de 19 (el máximo para la longitud lateral 3). Sin embargo, dudo que sea posible encontrar una solución a mano, si es que existe.

> <> , 15 13 11 bytes

Guardado 2 bytes gracias a No es un árbol

0:n:l1-:*+!

Pruébalo en línea!

Emite la secuencia indefinidamente.

Pyth , 7 5 bytes gracias a Steven H

s^R2h

Explicación:

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

Mi primera solucion

sm*ddUh

Pruébalo en línea!

Explicación:

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

𝐈ᛦ𝐬

Esto podría haber sido un desafío para mostrar los números poligonales incorporados de Neim, pero aparentemente no.

Pruébalo en línea!

Oasis , 4 bytes

nk+0

Pruébalo en línea!

Explicación

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

Brachylog , 5 bytes

⟦^₂ᵐ+

Pruébalo en línea!

Explicación

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

Gaia , 3 bytes

s¦Σ

Pruébalo en línea!