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.

— Felipe Nardi Batista
fuente

2

Observación divertida de OEIS: esta secuencia contiene exactamente dos cuadrados perfectos: f(1) == 1 * 1 (1)y f(24) == 70 * 70 (4900).

— DJMcMayhem

¿Podemos comenzar la secuencia en f(1) = 1?

— Emigna

@Emigna lo siento pero no, debes comenzar desde f(0) = 0. He señalado que a las pocas respuestas que fallaron ese requisito

— Felipe Nardi Batista

El f(0) = 0requisito arruinó algunas de mis soluciones :(

— ATaco

4

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

— Hiperneutrino
fuente

Una alternativa más larga seríaRæ.R

— Sr. Xcoder

22

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

— Sr. Xcoder
fuente

1

¡Esto es muy inteligente!

— Skyler

14

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

— Luis Mendo
fuente

14

JavaScript (ES6), 16 bytes

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

Manifestación

Mostrar fragmento de código

let f =

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

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

Expandir fragmento

¿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'.}

— Arnauld
fuente

6

05AB1E , 3 bytes

ÝnO

Pruébalo en línea!

Explicación

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

— Emigna
fuente

6

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)

— Riley
fuente

¡Bien hecho! :) Se me ocurrió ({<(({}))>{({})({}[()])}{}<({}[()])>})por 38

— DJMcMayhem

34 bytes;)

— Wheat Wizard

6

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.

Imagen

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

— Asistente de trigo
fuente

Sabía que tenía que haber una manera de hacer esto, y tenía el presentimiento de que tú serías el que descubriría las matemáticas.

— Riley

4

Casco , 3 bytes

ṁ□ḣ

Pruébalo en línea!

— Sr. Xcoder
fuente

3

Ohm v2 , 3 bytes

#²Σ

Pruébalo en línea!

Explicación

#    Range
 ²   Square
  Σ  Sum

— Cinaski
fuente

3

Japt , 3 bytes

ô²x

Pruébalo aquí

-1 gracias a Shaggy .

Explicación:

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

— Erik el Outgolfer
fuente

3 bytes utilizando el acceso directo para p2.

— Shaggy

@FelipeNardiBatista arreglado

— Erik the Outgolfer

2

Brain-Flak , 46 bytes

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

Pruébalo en línea!

— Hiperneutrino
fuente

Una pequeña competencia amistosa :)

— Riley

@Riley Ooh nice :)

— HyperNeutrino

En lugar de empujar el cuadrado hacia la pila alternativa, puedes sumarlo directamente evaluando y no empujándolo, luego empujando todo el bucle. Esto cambia su segunda mitad ({{({})({}[()])}{}}{})y le ahorra 10 bytes. (Si eso no tiene sentido, hágame ping en la tercera pila )

— DJMcMayhem

2

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

— Luis Mendo
fuente

¿Qué tal ri),_.*:+o ri),2f#:+?

— Martin Ender

@ Martin ¡Buena idea! Creo que deberías publicarlo como una respuesta diferente

— Luis Mendo

2

Wolfram Language (Mathematica) , 14 bytes

Tr[Range@#^2]&

Pruébalo en línea!

— totalmente humano
fuente

44

#.#&@Range@#&ahorra un byte

— millas

44

#.#&@*Range.

— alephalpha

2

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

— Mego
fuente

2

APL (Dyalog) , 7 5 bytes

2 bytes guardados gracias a @Mego

+.×⍨⍳

Pruébalo en línea!

¿Cómo?

⍳ - distancia

+.× - producto de punto

⍨ - consigo mismo

— Uriel
fuente

@Uriel mi mal, pensé que ¨⍳era necesario

— Felipe Nardi Batista

2

R, 17 bytes

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

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

— Frédéric
fuente

1

(x=0:scan())%*%xes más corto por byte, pero creo que necesita un catpara obtener salida.

— Giuseppe

@Giuseppe Lo acabo de probar y su código funciona sin cat, genera una matriz 1x1.

— Rui Barradas

@RuiBarradas El meta consenso actual es que cates necesario para que esto califique como un programa completo. Si desea cambiar eso, responda esta pregunta y obtenga algo de tracción entre las otras personas R en el sitio.

— Giuseppe

2

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#

— Martin Ender
fuente

2

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.

— Uriel
fuente

2

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.

— Martin Ender
fuente

2

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

— Giuseppe
fuente

2

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!

— Cinaski
fuente

2

Haskell, 20 bytes

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

Pruébalo en línea!

— nimi
fuente

2

Excel, 19 bytes

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

— Wernisch
fuente

2

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.

— Martin Ender
fuente

2

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

— Emigna
fuente

1

14 bytes (12 + 2 para la -vbandera): ::1+:}+**6,n(¡ Pruébelo en línea! )

— No es un árbol

1

O 11 bytes (imprime para siempre, comenzando en N=1): ¡ Pruébelo en línea!

— No es un árbol

@Notatree: Muy buena idea usando l. Comprobando con OP si está bien comenzar a las 1.

— Emigna

@Notatree: Lamentablemente, no podemos comenzar en 1, pero aún guarda 2 bytes. ¡Gracias!

— Emigna

1

(Debo mencionar que obtuve la lidea de la respuesta del Laberinto de Martin Ender ).

— No es un árbol el

2

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

— Dave
fuente

¿No hay una plaza construida en Pyth?

— caird coinheringaahing

No que yo sepa ...

— Dave

No, no hay plaza Pyth incorporado. También 6 bytes

— Sr. Xcoder

1

5 bytes .

— Steven H.

Arreglable con +1 byte a cada respuesta, editaré una vez que salga del móvil.

— Dave

1

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!

— Okx
fuente

1

Oasis , 4 bytes

nk+0

Pruébalo en línea!

Explicación

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

— Emigna
fuente

1

Brachylog , 5 bytes

⟦^₂ᵐ+

Pruébalo en línea!

Explicación

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

— Fatalizar
fuente

1

Gaia , 3 bytes

s¦Σ

Pruébalo en línea!

— Sr. Xcoder
fuente

Números piramidales cuadrados

Tarea

Ejemplo:

Especificación:

Jalea , 3 bytes

Explicación

Python 2 , 22 bytes

Python 2 , 27 bytes

MATL , 3 bytes

Explicación

JavaScript (ES6), 16 bytes

Manifestación

¿Cómo?

05AB1E , 3 bytes

Brain-Flak , 36 bytes

Brain-Flak , 34 bytes

¿Como funciona?

Brain-Flak , 36 bytes

Casco , 3 bytes

Ohm v2 , 3 bytes

Japt , 3 bytes

Brain-Flak , 46 bytes

CJam , 10 bytes

Wolfram Language (Mathematica) , 14 bytes

En realidad , 3 bytes

APL (Dyalog) , 7 5 bytes

R, 17 bytes

CJam , 9 bytes

Explicación

Julia , 16 14 bytes

Laberinto , 11 bytes

Explicación

Cubix , 15 bytes

Befunge , 16 bytes

Befunge , 38 bytes

Haskell, 20 bytes

Excel, 19 bytes

Hexagonía , 23 bytes.

Explicación

> <> , 15 13 11 bytes

Pyth , 7 5 bytes gracias a Steven H

Neim , 3 bytes

Oasis , 4 bytes

Brachylog , 5 bytes

Explicación

Gaia , 3 bytes