Encuentra la diferencia entre el cuadrado de las sumas y la suma de los cuadrados.

Esta es la representación matemática:

$\left(\sum n\right)^2-\sum n^2$

Su programa / método debe tomar dos entradas, estos son sus límites inferior y superior del rango, e incluyen. Los límites serán enteros enteros por encima de 0.

Su programa / método debe devolver la respuesta.

Puede usar la base que desee, pero indique en su respuesta qué base ha utilizado.

Caso de prueba (Base 10)

5,9      970
91,123   12087152
1,10     2640

Este es el código de golf habitual, por lo que cuanto más corta sea la respuesta, mejor.

Python 2, 43 bytes

f=lambda a,b,s=0:b/a and 2*a*s+f(a+1,b,s+a)

Pruébalo en Ideone .

Cómo funciona

Llame a la función definida en la especificación g (a, b) . Tenemos eso

Defina la función f (x, y, s) de forma recursiva de la siguiente manera.

Al aplicar la relación de recurrencia de f (a, b, 0) un total de b - a veces, podemos mostrar eso.

Esta es la función f de la implementación. Mientrasb/a devuelve un número entero distinto de cero, andse ejecuta el siguiente código , implementando así la definición recursiva de f .

Una vez que b/allega a 0 , tenemos que b> a y la lambda devuelve False = 0 , implementando así el caso base de la definición de f .

MATL , 9 bytes

&:&*XRssE

Pruébalo en línea!

Explicación

&:   % Inclusive range between the two implicit inputs
&*   % Matrix of all pair-wise products
XR   % Upper triangular part of matrix, without the diagonal
ss   % Sum of all elements of the matrix
E    % Multiply by 2. Implicit display

Ejemplo

Estos son los resultados parciales de cada línea para entradas 5y 9:

1. &:

   5 6 7 8 9
   

2. &:&*

   25 30 35 40 45
   30 36 42 48 54
   35 42 49 56 63
   40 48 56 64 72
   45 54 63 72 81
   

3. &:&*XR

   0 30 35 40 45
   0  0 42 48 54
   0  0  0 56 63
   0  0  0  0 72
   0  0  0  0  0
   

4. &:&*XRss

   485
   

5. &:&*XRssE

   970
   

Jalea, 9 8 bytes

rµS²_²S$

Pruébalo en línea!

r         inclusive range from first input to second input
 µ        pass the range to a new monadic chain
  S       the sum
   ²      squared
    _     minus...
     ²S$  the squares summed

¡Gracias a FryAmTheEggman por un byte!

Python 2, 45 bytes

lambda a,b:(a+~b)*(a-b)*(3*(a+b)**2+a-b-2)/12

Solución de formulario cerrado: no es la más corta, pero pensé que valdría la pena publicarla de todos modos.

Explicación

Vamos a p(n)ser el n º número piramidal cuadrado , y de t(n)ser el n º número triangular . Entonces, para n sobre el rango a , ..., b :

• ∑n = t(b)-t(a-1), y
• ∑n² = p(b) - p(a-1)
• Entonces (∑n) ²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

Esta expresión se reduce a la del código.

05AB1E, 8 bytes

ŸDOnsnO-

Explained

ŸD       # range from a to b, duplicate
  On     # sum and square first range
    s    # swap top 2 elements
     nO  # square and sum 2nd range
       - # take difference

Try it online

Mathematica, 21 bytes

Tr[x=Range@##]^2-x.x&

Una función sin nombre que toma dos argumentos y devuelve la diferencia. Uso:

Tr[x=Range@##]^2-x.x&[91, 123]
(* 12087152 *)

Aquí hay tres trucos de golf pequeños (y bastante estándar):

• ##representa ambos argumentos a la vez, por lo que podemos usar la notación de prefijo para Range. Range@##es una abreviatura para la Range[##]que se expande Range[a, b]y nos brinda un rango inclusivo según sea necesario.
• Tres para rastrear, pero usarlo en un vector simplemente suma ese vector, ahorrando tres bytes Total.
• x.xes un producto de punto que ahorra cuatro bytes Tr[x^2].

Labyrinth, 28 24 bytes

?:?:}+=-:(:(#{:**+**#2/!

Try it online!

Explanation

Since loops tend to be expensive in Labyrinth, I figured the explicit formula should be shortest, as it can be expressed as linear code.

Cmd Explanation                 Stacks [ Main | Aux ]
?   Read M.                     [ M | ]
:   Duplicate.                  [ M M | ]
?   Read N.                     [ M M N | ]
:   Duplicate.                  [ M M N N | ]
}   Move copy to aux.           [ M M N | N ]
+   Add.                        [ M (M+N) | N ]
=   Swap tops of stacks.        [ M N | (M+N) ]
-   Subtract.                   [ (M-N) | (M+N) ]
:   Duplicate.                  [ (M-N) (M-N) | (M+N) ]
(   Decrement.                  [ (M-N) (M-N-1) | (M+N) ]
:   Duplicate.                  [ (M-N) (M-N-1) (M-N-1) | (M+N) ]
(   Decrement.                  [ (M-N) (M-N-1) (M-N-2) | (M+N) ]
#   Push stack depth.           [ (M-N) (M-N-1) (M-N-2) 3 | (M+N) ]
{   Pull (M+N) over from aux.   [ (M-N) (M-N-1) (M-N-2) 3 (M+N) | ]
:   Duplicate.                  [ (M-N) (M-N-1) (M-N-2) 3 (M+N) (M+N) | ]
*   Multiply.                   [ (M-N) (M-N-1) (M-N-2) 3 ((M+N)^2) | ]
*   Multiply.                   [ (M-N) (M-N-1) (M-N-2) (3*(M+N)^2) | ]
+   Add.                        [ (M-N) (M-N-1) (3*(M+N)^2 + M - N - 2) | ]
*   Multiply.                   [ (M-N) ((M-N-1)*(3*(M+N)^2 + M - N - 2)) | ]
*   Multiply.                   [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) | ]
#   Push stack depth.           [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) 1 | ]
2   Multiply by 10, add 2.      [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) 12 | ]
/   Divide.                     [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)/12) | ]
!   Print.                      [ | ]

El puntero de instrucciones llega a un callejón sin salida y tiene que darse la vuelta. Cuando ahora se encuentra /, intenta una división por cero (ya que la parte inferior de la pila está implícitamente llena de ceros), lo que termina el programa.

Haskell, 34 bytes

a#b=sum[a..b]^2-sum(map(^2)[a..b])

Ejemplo de uso: 91 # 123->12087152.

Nada que explicar

Matlab, 30 29 28 bytes

Usar la idea de Suever normnos da 2 bytes menos

@(x,y)sum(x:y)^2-norm(x:y)^2

Versión antigua (simple):

@(x,y)sum(x:y)^2-sum((x:y).^2)

Octava, 27 23 bytes

@(x,y)sum(z=x:y)^2-z*z'

Crea una función anónima llamada ansque acepta dos entradas:ans(lower, upper)

Demo en línea

Explicación

Crea un vector de fila de xa y(inclusive) y lo almacena en z. Luego sumamos todos los elementos usando sumy lo elevamos al cuadrado ( ^2). Para calcular la suma de los cuadrados, realizamos una multiplicación matricial entre el vector fila y su transposición. Esto cuadrará efectivamente cada elemento y resumirá el resultado. Luego restamos los dos.

Java, 84 77 caracteres, 84 77 bytes

7 bytes más pequeños debido a Martin Ender y FryAmTheEggMan, gracias.

public int a(int b,int c){int e=0,f=0;for(;b<=c;e+=b,f+=b*b++);return e*e-f;}

Usando los tres casos de prueba en la publicación original: http://ideone.com/q9MZSZ

Sin golf:

public int g(int b, int c) {
    int e = 0, f = 0;
    for (; b <= c; e += b, f += b * b++);
    return e*e-f;
}

El proceso se explica por sí mismo. Declaré dos variables para representar el cuadrado de las sumas y la suma de los cuadrados y las incrementé repetidamente de manera apropiada. Finalmente, devuelvo la diferencia calculada.

JavaScript (ES6), 46 bytes

f=(x,y,s=0,p=0)=>x<=y?f(x+1,y,s+x,p+x*x):s*s-p

JavaScript (ES6), 50 37 bytes

f=(n,m,s=0)=>n>m?0:2*n*s+f(n+1,m,n+s)

Ahora es un puerto de la solución Python de @ Dennis ♦.

Factor, 48 bytes

[ [a,b] [ [ sq ] map sum ] [ sum sq ] bi - abs ]

Una función anónima.

[ 
  [a,b] ! a range from a to b 
  [ 
    [ sq ] map sum ! anonymous function: map sq over the range and sum the result 
  ] 
  [ sum sq ] ! the same thing, in reverse order
  bi - abs   ! apply both anon funcs to the range, subtract them and abs the result
]

Haskell, 36 bytes

m#n=sum[2*i*j|i<-[m..n],j<-[i+1..n]]

λ> m # n = sum [ 2*i*j | i <- [m..n], j <- [i+1..n] ]
λ> 5 # 9
970
λ> 91 # 123
12087152
λ> 1 # 10
2640

Tenga en cuenta que

Perl 6,  36 32  31 bytes

{([+] $_=@_[0]..@_[1])²-[+] $_»²}
{([+] $_=$^a..$^b)²-[+] $_»²}
{[+]($_=$^a..$^b)²-[+] $_»²}

Test it

Explanation:

{ # bare block with placeholder parameters $a and $b

  [+](# reduce with &infix:<+>
      # create a range, and store it in $_
      $_ = $^a .. $^b
  )²
  -
  [+] # reduce with &infix:<+>
    # square each element of $_ ( possibly in parallel )
    $_»²
}

Test:

#! /usr/bin/env perl6
use v6.c;
use Test;

my @tests = (
  (5,9) => 970,
  (91,123) => 12087152,
  (1,10) => 2640,
);

plan +@tests;

my &diff-sq-of-sum = {[+]($_=$^a..$^b)²-[+] $_»²}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is diff-sq-of-sum(|@input), $expected, .gist
}

1..3
ok 1 - (5 9) => 970
ok 2 - (91 123) => 12087152
ok 3 - (1 10) => 2640

Brachylog, 24 bytes

:efL:{:2^.}a+S,L+:2^:S-.

Expects the 2 numbers in Input as a list, e.g. [91:123].

Explanation

:efL                     Find the list L of all integers in the range given in Input
    :{:2^.}a             Apply squaring to each element of that list
            +S,          Unify S with the sum of the elements of that list
               L+:2^     Sum the elements of L, then square the result
                    :S-. Unify the Output with that number minus S

APL, 23 20 bytes

-/+/¨2*⍨{(+/⍵)⍵}⎕..⎕

Funciona en NARS2000.

MATL, 11 bytes

&:ts2^w2^s-

Pruébalo en línea!

Explicación:

&:           #Create a range from the input
  t          #Duplicate it
   s2^       #Sum it and square it
      w      #swap the two ranges
       2^s   #Square it and sum it
          -  #Take the difference

Pyth, 11 bytes

s*M-F#^}FQ2

Pruébalo en línea!

s*M-F#^}FQ2
       }FQ    Compute the range
      ^   2   Generate all pairs
   -F#        Remove those pairs who have identical elements
 *M           Product of all pairs
s             Sum.

Japt, 10 bytes

õV
x²aUx ²

Intentalo

CJam, 17 bytes

q~),>_:+2#\2f#:+-

Pruébalo aquí.

Explicación

q~       e# Read and evaluate input, dumping M and N on the stack.
),       e# Increment, create range [0 1 ... N].
>        e# Discard first M elements, yielding [M M+1 ... N].
_        e# Duplicate.
:+2#     e# Sum and square.
\2f#:+   e# Swap with other copy. Square and sum.
-        e# Subtract.

Alternativamente, uno puede sumar los productos de todos los pares distintos (básicamente multiplicando el cuadrado de la suma y eliminando los cuadrados), pero eso es un byte más largo:

q~),>2m*{)-},::*:+

PowerShell v2 +, 47 bytes

Dos variaciones

param($n,$m)$n..$m|%{$o+=$_;$p+=$_*$_};$o*$o-$p

$args-join'..'|iex|%{$o+=$_;$p+=$_*$_};$o*$o-$p

En ambos casos, estamos generando un rango con el ..operador, canalizándolo a un bucle |%{...}. Cada iteración, estamos acumulando $oy $pcomo la suma o la suma de los cuadrados. Luego calculamos el cuadrado de las sumas con $o*$oy restamos $p. La salida se deja en la tubería y la impresión es implícita.

JavaScript (ES6), 67 bytes

a=>b=>([s=q=0,...Array(b-a)].map((_,i)=>q+=(s+=(n=i+a),n*n)),s*s-q)

Banco de pruebas

f=a=>b=>([s=q=0,...Array(b-a)].map((_,i)=>q+=(s+=(n=i+a),n*n)),s*s-q)
e=s=>`${s} => ${eval(s[0])}` // template tag format for tests
console.log(e`f(5)(9)`)
console.log(e`f(91)(123)`)
console.log(e`f(1)(10)`)

J, 29 bytes

Port of Doorknob's Jelly respuesta .

[:(+/@(^&2)-~2^~+/)[}.[:i.1+]

Uso

>> f = [:(+/@(^&2)-~2^~+/)[}.[:i.1+]
>> 91 f 123x
<< 12087152

Donde >>está STDIN, <<es STDOUT y xes para una precisión extendida.

Pyke, 11 bytes

h1:Ds]MXXs-

Pruébalo aquí!

h1:         - inclusive_range(input)
   Ds]      -     [^, sum(^)]
      MX    -    deep_map(^, <--**2)
         s  -   ^[1] = sum(^[1])
          - -  ^[0]-^[1]

Julia, 25 bytes

f(a,b,x=a:b)=sum(x)^2-x'x

This is a function that accepts two integers and returns a 1x1 integer array.

The approach is simple: Construct a UnitRange from the endpoints a and b and call it x, then sum x, square it, and subtract its norm, which is computed as transpose(x) * x.

Pruébalo en línea! (incluye todos los casos de prueba)

TI-BASIC, 19 bytes

Prompt N,M
randIntNoRep(N,M
sum(Ans)2-sum(Ans2

randIntNoRepobtiene el rango (barajado). El resto es bastante autoexplicativo.

Fith , 52 bytes

{ 1 + range dup sum 2 pow swap { 2 pow } map sum - }

Esta es una función anónima que toma los dos números en la pila y deja un solo número.

Explicación:

{
    1 + range dup      2 ranges from a to b inclusive
    sum 2 pow          Sum one and square it
    swap               Bring a fresh range to the top
    { 2 pow } map sum  Square every element and sum the list
    -                  Subtract
}

GeoGebra, 91 bytes

a(x)=(x²+x)/2
b(x)=x³/3+x²/2+x/6
c(x,y)=(a(y)-a(x))²
d(x,y)=b(y)-b(x)
c(x-1,y)-d(x-1,y)

Define una función (probablemente e(x,y)) que calcula la diferencia deseada.
a(x)calcula la suma de números naturales entre 0y x.
b(x)calcula la suma de los cuadrados de los números naturales entre 0y x.
c(x,y)primero calcula la suma de los números naturales entre xy y, luego cuadra esa suma.
d(x,y)calcula la suma de cuadrados entre b(x)y b(y).
La última línea define una función multivariable que finaliza el cálculo. A la función se le asigna automáticamente un nombre, guardando unos pocos bytes.