Encontre a diferença entre o quadrado da soma e a soma dos quadrados.

Esta é a representação matemática:

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

Seu programa / método deve receber duas entradas, esses são os limites inferior e superior da faixa e são inclusivos. Os limites serão inteiros inteiros acima de 0.

Seu programa / método deve retornar a resposta.

Você pode usar qualquer base que desejar, mas indique em sua resposta qual base você usou.

Caso de teste (Base 10)

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

Este é o código-golfe habitual, portanto, quanto menor a resposta, melhor.

Python 2, 43 bytes

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

Teste em Ideone .

Como funciona

Chame a função definida na especificação g (a, b) . Nós temos isso

Defina a função f (x, y, s) recursivamente da seguinte maneira.

Aplicando a relação de recorrência de f (a, b, 0) um total de b - a vezes, podemos mostrar isso.

Essa é a função f da implementação. Enquanto b/aretorna um número inteiro diferente de zero, o código a seguir andé executado, implementando a definição recursiva de f .

Uma vez que b/aatinge 0 , temos que b> a e os lambda retorna Falso = 0 , implementando assim o caso base da definição de f .

MATL , 9 bytes

&:&*XRssE

Experimente online!

Explicação

&:   % 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

Exemplo

Estes são os resultados parciais de cada linha para entradas 5e 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
   

Geléia, 9 8 bytes

rµS²_²S$

Experimente online!

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

Obrigado a FryAmTheEggman por um byte!

Python 2, 45 bytes

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

Solução de formulário fechado - não a mais curta, mas achei que valeria a pena postar de qualquer maneira.

Explicação

Vamos p(n)ser o n º número piramidal quadrado , e t(n)ser o n º número triangular . Então, para n acima do intervalo a , ..., b :

• =n = t(b)-t(a-1)e
• ∑n² = p(b) - p(a-1)
• Então (∑n) ²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

Essa expressão se reduz à do código.

05AB1E, 8 bytes

ŸDOnsnO-

Explicado

Ÿ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

Experimente online

Mathematica, 21 bytes

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

Uma função sem nome, recebendo dois argumentos e retornando a diferença. Uso:

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

Há três pequenos truques de golfe (e bastante padrão) aqui:

• ##representa os dois argumentos de uma só vez, para que possamos usar a notação de prefixo para Range. Range@##é uma abreviação para a Range[##]qual se expande Range[a, b]e nos fornece um intervalo inclusivo, conforme necessário.
• Tré para rastreamento, mas usá-lo em um vetor simplesmente soma esse vetor, economizando três bytes Total.
• x.xé um produto escalar, economizando quatro bytes Tr[x^2].

Labirinto , 28 24 bytes

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

Experimente online!

Explicação

Como os loops tendem a ser caros no Labirinto, imaginei que a fórmula explícita deveria ser mais curta, pois pode ser expressa como código linear.

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.                      [ | ]

O ponteiro de instruções atinge um beco sem saída e precisa se virar. Quando encontra agora /, tenta uma divisão por zero (uma vez que a parte inferior da pilha está implicitamente preenchida com zeros), que finaliza o programa.

Haskell, 34 bytes

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

Exemplo de uso: 91 # 123-> 12087152.

Nada a explicar.

Matlab, 30 29 28 bytes

Usar a idéia de Suever normnos dá 2 bytes a menos

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

Versão antiga (simples):

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

Oitava, 27 23 bytes

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

Cria uma função anônima chamada ansque aceita duas entradas:ans(lower, upper)

Demo Online

Explicação

Cria um vetor de linha de xpara y(inclusive) e o armazena z. Em seguida, somamos todos os elementos usando sume o usamos ao quadrado ( ^2). Para calcular a soma dos quadrados, realizamos a multiplicação de matrizes entre o vetor de linha e sua transposição. Isso efetivamente quadrará cada elemento e resumirá o resultado. Subtraímos os dois.

Java, 84 77 caracteres, 84 77 bytes

7 bytes menor devido a Martin Ender e FryAmTheEggMan, obrigado.

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 os três casos de teste na postagem original: http://ideone.com/q9MZSZ

Ungolfed:

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

Processo é bastante auto-explicativo. Declarei duas variáveis ​​para representar o quadrado das somas e a soma dos quadrados e as incrementei repetidamente de forma apropriada. Finalmente, retorno a diferença 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)

Agora, um porto da solução Python de @ Dennis ♦.

Fator, 48 bytes

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

Uma função 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

Observe que

Perl 6 ,  36 32  31 bytes

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

Teste-o

Explicação:

{ # 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 )
    $_»²
}

Teste:

#! /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

Braquilog , 24 bytes

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

Espera os 2 números em Entrada como uma lista, por exemplo [91:123].

Explicação

: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*⍨{(+/⍵)⍵}⎕..⎕

Trabalha em NARS2000.

MATL, 11 bytes

&:ts2^w2^s-

Experimente online!

Explicação:

&:           #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

Pitão, 11 bytes

s*M-F#^}FQ2

Experimente online!

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.

Japonês, 10 bytes

õV
x²aUx ²

Tente

CJam, 17 bytes

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

Teste aqui.

Explicação

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.

Como alternativa, pode-se somar os produtos de todos os pares distintos (basicamente multiplicando o quadrado da soma e removendo os quadrados), mas isso é um byte mais longo:

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

PowerShell v2 +, 47 bytes

Duas variações

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

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

Nos dois casos, estamos gerando um intervalo com o ..operador, canalizando isso para um loop |%{...}. A cada iteração, estamos acumulando $oe $pcomo a soma ou a soma dos quadrados. Em seguida, calculamos o quadrado das somas com $o*$oe subtraímos $p. A saída é deixada no pipeline e a impressão está 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)

Suíte de teste

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

Resposta da Geléia do Porto da Maçaneta .

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

Uso

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

Onde >>está STDIN, <<está STDOUT e xé para maior precisão.

Pyke, 11 bytes

h1:Ds]MXXs-

Experimente aqui!

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

Essa é uma função que aceita dois números inteiros e retorna uma matriz inteira 1x1.

A abordagem é simples: construa a UnitRangepartir dos pontos finais ae bchame-a x, depois some x, quadrada e subtraia sua norma, que é calculada como transpose(x) * x.

Experimente online! (inclui todos os casos de teste)

TI-BASIC, 19 bytes

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

randIntNoRepobtém o intervalo (embaralhado). O resto é bastante auto-explicativo.

Quinto , 52 bytes

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

Essa é uma função anônima que pega os dois números na pilha e deixa um único número.

Explicação:

{
    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 uma função (provavelmente e(x,y)) que calcula a diferença desejada.
a(x)calcula a soma dos números naturais entre 0e x.
b(x)calcula a soma dos quadrados dos números naturais entre 0e x.
c(x,y)primeiro calcula a soma dos números naturais entre xe y, em seguida, esquadrinha essa soma.
d(x,y)calcula a soma dos quadrados entre b(x)e b(y).
A última linha define uma função multivariável que termina o cálculo. A função recebe um nome automaticamente, economizando alguns bytes.