Trova la differenza tra il quadrato delle somme e la somma dei quadrati.

Questa è la rappresentazione matematica:

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

Il programma / metodo dovrebbe prendere due input, questi sono i limiti inferiore e superiore dell'intervallo e sono inclusivi. I limiti saranno numeri interi superiori a 0.

Il tuo programma / metodo dovrebbe restituire la risposta.

Puoi usare qualunque base tu voglia, ma per favore specifica nella tua risposta quale base hai usato.

Test case (Base 10)

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

Questo è il solito code-golf, quindi più corta è la risposta, meglio è.

Python 2, 43 byte

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

Provalo su Ideone .

Come funziona

Chiamare la funzione definita nella specifica g (a, b) . Abbiamo quello

Definire la funzione f (x, y, s) in modo ricorsivo come segue.

Applicando la relazione di ricorrenza di f (a, b, 0) per un totale di b - a volte, possiamo dimostrarlo.

Questa è la funzione f dell'implementazione. Mentre b/arestituisce un numero intero diverso da zero, andviene eseguito il codice seguente , implementando così la definizione ricorsiva di f .

Una volta b/araggiunto 0 , abbiamo che b> a e lambda restituisce False = 0 , implementando così il caso base della definizione di f .

MATL , 9 byte

&:&*XRssE

Provalo online!

Spiegazione

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

Esempio

Questi sono i risultati parziali di ogni riga per input 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
   

Gelatina, 9 8 byte

rµS²_²S$

Provalo 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

Grazie a FryAmTheEggman per un byte!

Python 2, 45 byte

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

Soluzione a forma chiusa - non la più breve, ma ho pensato che valesse la pena pubblicare comunque.

Spiegazione

Lasciate p(n)essere il n esimo numero piramidale quadrato , e t(n)il n esimo numero triangolare . Quindi, per n nell'intervallo a , ..., b :

• ∑n = t(b)-t(a-1), e
• ∑n² = p(b) - p(a-1)
• Quindi (∑n) ²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

Questa espressione si riduce a quella nel codice.

05AB1E, 8 byte

ŸDOnsnO-

spiegato

Ÿ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

Provalo online

Mathematica, 21 byte

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

Una funzione senza nome che accetta due argomenti e restituisce la differenza. Uso:

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

Ci sono tre piccoli (e abbastanza standard) trucchi per il golf qui:

• ##rappresenta entrambi gli argomenti contemporaneamente, in modo che possiamo usare la notazione con prefisso per Range. Range@##è una scorciatoia per la Range[##]quale si espande Range[a, b]e ci fornisce una gamma inclusiva come richiesto.
• Trè per tracciare ma usarlo su un vettore somma semplicemente quel vettore, salvando tre byte sopra Total.
• x.xè un prodotto punto, con un risparmio di quattro byte Tr[x^2].

Labyrinth , 28 24 byte

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

Provalo online!

Spiegazione

Dato che i loop tendono ad essere costosi in Labyrinth, ho pensato che la formula esplicita dovrebbe essere la più breve, in quanto può essere espressa come codice lineare.

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

Il puntatore dell'istruzione quindi colpisce un vicolo cieco e deve girarsi. Quando ora incontra /, tenta una divisione per zero (poiché il fondo dello stack è implicitamente riempito di zeri), che termina il programma.

Haskell, 34 byte

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

Esempio di utilizzo: 91 # 123-> 12087152.

Niente da spiegare.

Matlab, 30 29 28 byte

L'uso dell'idea di Suever normci dà 2 byte in meno

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

Vecchia versione (semplice):

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

Ottava, 27 23 byte

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

Crea una funzione anonima denominata ansche accetta due input:ans(lower, upper)

Demo online

Spiegazione

Crea un vettore di riga da xa y(incluso) e lo memorizza in z. Sommiamo quindi tutti gli elementi usando sume lo quadriamo ( ^2). Per calcolare la somma dei quadrati, eseguiamo la moltiplicazione di matrici tra il vettore riga e la sua trasposizione. Questo quadrerà efficacemente ogni elemento e riassumerà il risultato. Quindi sottraggiamo i due.

Java, 84 77 caratteri, 84 77 byte

7 byte più piccoli grazie a Martin Ender e FryAmTheEggMan, grazie.

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

Utilizzando i tre casi di test nel post originale: 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;
}

Il processo è abbastanza autoesplicativo. Ho dichiarato due variabili per rappresentare il quadrato delle somme e la somma dei quadrati e le ho ripetutamente incrementate in modo appropriato. Infine, restituisco la differenza calcolata.

JavaScript (ES6), 46 byte

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 byte

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

Ora un port della soluzione Python di @ Dennis ♦.

Fattore, 48 byte

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

Una funzione anonima.

[ 
  [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 byte

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

Nota che

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

Works in NARS2000.

MATL, 11 bytes

&:ts2^w2^s-

Try it online!

Explanation:

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

Try it 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.

Japt, 10 bytes

õV
x²aUx ²

Try it

CJam, 17 bytes

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

Test it here.

Explanation

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.

Alternatively, one can just sum the products of all distinct pairs (basically multiplying out the square of the sum, and removing squares), but that's a byte longer:

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

PowerShell v2+, 47 bytes

Two variations

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

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

In both cases we're generating a range with the .. operator, piping that to a loop |%{...}. Each iteration, we're accumulating $o and $p as either the sum or the sum-of-squares. We then calculate the square-of-sums with $o*$o and subtract $p. Output is left on the pipeline and printing is implicit.

JavaScript (ES6), 67 bytes

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

Test Suite

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

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

Usage

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

Where >> is STDIN, << is STDOUT, and x is for extended precision.

Pyke, 11 bytes

h1:Ds]MXXs-

Try it here!

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.

Try it online! (includes all test cases)

TI-BASIC, 19 bytes

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

randIntNoRep gets the range (shuffled). The rest is pretty self explanatory.

Fith, 52 bytes

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

This is an anonymous function that takes the two numbers on the stack and leaves a single number.

Explanation:

{
    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)

Defines a function (probably e(x,y)) that computes the desired difference.
a(x) calculates the sum of natural numbers between 0 and x.
b(x) calculates the sum of the squares of the natural numbers between 0 and x.
c(x,y) first computes the sum of the natural numbers between x and y, then squares that sum.
d(x,y) calculates the sum of squares between b(x) and b(y).
The last line defines a multi-variable function that finishes the calculation. The function is automatically assigned a name, saving a few bytes.