La suma de los cuadrados de los primeros diez números naturales es, $1^2 + 2^2 + \dots + 10^2 = 385$

El cuadrado de la suma de los primeros diez números naturales es,

$(1 + 2 + ... + 10)^2 = 55^2 = 3025$

Por lo tanto, la diferencia entre la suma de los cuadrados de los primeros diez números naturales y el cuadrado de la suma es

$3025 − 385 = 2640$

Para una entrada dada n, encuentre la diferencia entre la suma de los cuadrados de los primeros n números naturales y el cuadrado de la suma.

Casos de prueba

1       => 0
2       => 4
3       => 22
10      => 2640
24      => 85100
100     => 25164150

Este desafío se anunció por primera vez en el Proyecto Euler # 6 .

Criterios ganadores

• No hay reglas sobre cuál debería ser el comportamiento con entrada negativa o cero.

• La respuesta más corta gana.

Jalea ,  5  4 bytes

Ḋ²ḋṖ

Pruébalo en línea!

¿Cómo?

Implementa $\sum_{i=2}^n{(i^2(i-1))}$ ...

Ḋ²ḋṖ - Link: non-negative integer, n
Ḋ    - dequeue (implicit range)       [2,3,4,5,...,n]
 ²   - square (vectorises)            [4,9,16,25,...,n*n]
   Ṗ - pop (implicit range)           [1,2,3,4,...,n-1]
  ḋ  - dot product                    4*1+9*2+16*3+25*4+...+n*n*(n-1)

Python 3 ,  28  27 bytes

-1 gracias a xnor

lambda n:(n**3-n)*(n/4+1/6)

Pruébalo en línea!

Implementa $n(n-1)(n+1)(3n+2)/12$

Python 2,  29  28 bytes:lambda n:(n**3-n)*(3*n+2)/12

APL (Dyalog Unicode) , 10 bytes

1⊥⍳×⍳×1-⍨⍳

Pruébalo en línea!

Cómo funciona

1⊥⍳×⍳×1-⍨⍳
  ⍳×⍳×1-⍨⍳  Compute (x^3 - x^2) for 1..n
1⊥          Sum

Utiliza el hecho de que "cuadrado de suma" es igual a "suma de cubos".

TI-Basic (serie TI-83), 12 11 bytes

sum(Ans² nCr 2/{2,3Ans

Implementos $\binom{n^2}{2}(\frac12 + \frac1{3n})$. Toma entradaAns: por ejemplo, ejecutar10:prgmXpara calcular el resultado para la entrada10.

Brain-Flak , 74 72 68 64 bytes

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

Pruébalo en línea!

Una forma bastante simple de hacerlo con un par de turnos difíciles. Esperemos que alguien encuentre más trucos para hacerlo aún más corto.

Carbón , 12 10 bytes

ＩΣＥＮ×ιＸ⊕ι²

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: $( \sum_1^n x )^2 = \sum_1^n x^3$ so $( \sum_1^n x )^2 - \sum_1^n x^2 = \sum_1^n (x^3 - x^2) = \sum_1^n (x - 1)x^2 = \sum_0^{n-1} x(x + 1)^2$.

   Ｎ        Input number
  Ｅ         Map over implicit range i.e. 0 .. n - 1
        ι   Current value
       ⊕    Incremented
         ²  Literal 2
      Ｘ     Power
     ι      Current value
    ×       Multiply
 Σ          Sum
Ｉ           Cast to string
            Implicitly print

Perl 6 , 22 bytes

{sum (1..$_)>>²Z*^$_}

Pruébalo en línea!

Utiliza la construcción $\sum_{i=1}^n {(i^2(i-1))}$

Japt -x, 9 8 5 4 bytes

õ²í*

Intentalo

Explicación

õ        :Range [1,input]
 ²       :Square each
  í      :Interleave with 0-based indices
   *     :Reduce each pair by multiplication
         :Implicit output of the sum of the resulting array

JavaScript, 20 bytes

f=n=>n&&n*n*--n+f(n)

Pruébalo en línea

APL (Dyalog), 17 bytes

{+/(¯1↓⍵)×1↓×⍨⍵}⍳

(Mucho más tiempo) Puerto de Jonathan Allan's Jelly respuesta.

Pruébalo en línea!

APL (Dyalog) , 16 bytes

((×⍨+/)-(+/×⍨))⍳

Pruébalo en línea!

 (×⍨+/)            The square (× self) of the sum (+ fold)
       -           minus
        (+/×⍨)     the sum of the square
(             )⍳   of [1, 2, … input].

Mathematica, 21 17 bytes

^{-4 bytes gracias a alephalpha .}

(3#+2)(#^3-#)/12&

Pura función. Toma un entero como entrada y devuelve un entero como salida. Simplemente implementa el polinomio, ya que Sums, Ranges, Trs, etc. ocupan muchos bytes.

Java (JDK) , 23 bytes

n->(3*n+2)*(n*n*n-n)/12

Pruébalo en línea!

dc , 16 bytes

?dd3^r-r3*2+*C/p

$(n^3-n)(3n+2)/12$

Pruébalo en línea!

05AB1E , 8 bytes

ÝDOnsnO-

Explicación:

ÝDOnsnO-     //Full program
Ý            //Push [0..a] where a is implicit input
 D           //Duplicate top of stack
  On         //Push sum, then square it
    s        //Swap top two elements of stack
     nO      //Square each element, then push sum
       -     //Difference (implicitly printed)

Pruébalo en línea!

C, C ++, 46 40 37 bytes (#definir), 50 47 46 bytes (función)

-1 byte gracias a Zacharý

-11 bytes gracias a ceilingcat

Versión macro:

#define F(n)n*n*~n*~n/4+n*~n*(n-~n)/6

Versión de la función:

int f(int n){return~n*n*n*~n/4+n*~n*(n-~n)/6;}

Estas líneas se basan en esas 2 fórmulas:

Suma de números entre 1 yn = n*(n+1)/2
Suma de cuadrados entre 1 y n =n*(n+1)*(2n+1)/6

Entonces la fórmula para obtener la respuesta es simplemente (n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6

Y ahora para "optimizar" el recuento de bytes, separamos los paréntesis y movemos las cosas, mientras que las pruebas siempre dan el mismo resultado

(n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6 => n*(n+1)/2*n*(n+1)/2 - n*(n+1)*(2n+1)/6 => n*(n+1)*n*(n+1)/4 - n*(n+1)*(2n+1)/6

Observe el patrón p = n*n+1 = n*n+n, por lo que en la función, declaramos otra variable int p = n*n+ny da:

p*p/4 - p*(2n+1)/6

Por p*(p/4-(2*n+1)/6)lo tanto n*(n+1)*(n*(n+1)/4 - (2n+1)/6), funciona solo la mitad del tiempo, y sospecho que la división entera es la causa ( f(3)dando 24 en lugar de 22,f(24) dando 85200 en lugar de 85100, por lo que no podemos factorizar la fórmula de la macro de esa manera, incluso si matemáticamente es lo mismo.

Tanto la versión macro como la función están aquí debido a la sustitución macro:

F (3) da 3*3*(3+1)*(3+1)/4-3*(3+1)*(2*3+1)/6 = 22
F (5-2) da5-2*5-2*(5-2+1)*(5-2+1)/4-5-2*(5-2+1)*(2*5-2+1)/6 = -30

y estropear la precedencia del operador la versión de la función no tiene este problema

JavaScript (ES6), 22 bytes

n=>n*~-n*-~n*(n/4+1/6)

Pruébalo en línea!

Pyth, 7 bytes

sm**hdh

Pruébelo en línea aquí .

Utiliza la fórmula en la respuesta de Neil .

sm**hdhddQ   Implicit: Q=eval(input())
             Trailing ddQ inferred
 m       Q   Map [0-Q) as d, using:
    hd         Increment d
   *  hd       Multiply the above with another copy
  *     d      Multiply the above by d
s            Sum, implicit print 

SNOBOL4 (CSNOBOL4) , 70 69 bytes

 N =INPUT
I X =X + N ^ 3 - N ^ 2
 N =GT(N) N - 1 :S(I)
 OUTPUT =X
END

Pruébalo en línea!

Pari / GP , 21 bytes

n->(3*n+2)*(n^3-n)/12

Pruébalo en línea!

05AB1E , 6 bytes

LnDƶαO

Pruébalo en línea!

Explicación

L         # push range [1 ... input]
 n        # square each
  D       # duplicate
   ƶ      # lift, multiply each by its 1-based index
    α     # element-wise absolute difference
     O    # sum

Algunas otras versiones con el mismo número de bytes:

L<ān*O
Ln.āPO
L¦nā*O

R , 28 bytes

x=1:scan();sum(x)^2-sum(x^2)

Pruébalo en línea!

MathGolf , 6 bytes

{î²ï*+

Pruébalo en línea!

Calcula $\sum_{k=1}^n (k^2(k-1))$

Explicación:

{       Loop (implicit) input times
 î²     1-index of loop squared
    *   Multiplied by
   ï    The 0-index of the loop
     +  And add to the running total

Clojure , 58 bytes

(fn[s](-(Math/pow(reduce + s)2)(reduce +(map #(* % %)s))))

Pruébalo en línea!

Editar: no entendí la pregunta

Clojure , 55 , 35 bytes

#(* %(+ 1 %)(- % 1)(+(* 3 %)2)1/12)

Pruébalo en línea!

cQuents , 17 15 bytes

b$)^2-c$
;$
;$$

Pruébalo en línea!

Explicación

 b$)^2-c$     First line
:             Implicit (output nth term in sequence)
 b$)          Each term in the sequence equals the second line at the current index
    ^2        squared
      -c$     minus the third line at the current index

;$            Second line - sum of integers up to n
;$$           Third line - sum of squares up to n

APL (NARS), 13 caracteres, 26 bytes

{+/⍵×⍵×⍵-1}∘⍳

use la fórmula Sum'w = 1..n '(w w (w-1)) posible escribí lo mismo que otros escribieron + o - como "1⊥⍳ × ⍳ × ⍳-1"; prueba:

  g←{+/⍵×⍵×⍵-1}∘⍳
  g 0
0
  g 1
0
  g 2
4
  g 3
22
  g 10
2640

Stax , 4 bytes

╡⌠(♠

Ejecutar y depurarlo

Para todos los kenteros positivos hasta la entrada, agregue k^2 * (k-1).

QBASIC, 45 44 bytes

¡Ir a las matemáticas puras ahorra 1 byte!

INPUT n
?n^2*(n+1)*(n+1)/4-n*(n+1)*(2*n+1)/6

Prueba ESO en línea!

Respuesta previa basada en bucle

INPUT n
FOR q=1TO n
a=a+q^2
b=b+q
NEXT
?b^2-a

Pruébalo en línea!

Tenga en cuenta que REPL está un poco más expandido porque el intérprete falla de lo contrario.

JAEL , 13 10 bytes

#&àĝ&oȦ

Pruébalo en línea!

Explicación (generada automáticamente):

./jael --explain '#&àĝ&oȦ'
ORIGINAL CODE:  #&àĝ&oȦ

EXPANDING EXPLANATION:
à => `a
ĝ => ^g
Ȧ => .a!

EXPANDED CODE:  #&`a^g&o.a!

COMPLETED CODE: #&`a^g&o.a!,

#          ,            repeat (p1) times:
 &                              push number of iterations of this loop
  `                             push 1
   a                            push p1 + p2
    ^                           push 2
     g                          push p2 ^ p1
      &                         push number of iterations of this loop
       o                        push p1 * p2
        .                       push the value under the tape head
         a                      push p1 + p2
          !                     write p1 to the tapehead
            ␄           print machine state

05AB1E , 6 bytes

LDOšnÆ

Pruébalo en línea!

Explicación:

           # implicit input (example: 3)
L          # range ([1, 2, 3])
 DOš       # prepend the sum ([6, 1, 2, 3])
    n      # square each ([36, 1, 4, 9])
     Æ     # reduce by subtraction (22)
           # implicit output

Æno es útil a menudo, pero este es el momento de brillar. Esto supera a los ingenuos LOnILnO-en dos bytes completos.