Znajdź różnicę między kwadratem sum a sumą kwadratów.

To matematyczne przedstawienie:

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

Twój program / metoda powinna przyjmować dwa dane wejściowe, są to dolne i górne granice zakresu i są włącznie. Limity będą pełnymi liczbami całkowitymi powyżej 0.

Twój program / metoda powinna zwrócić odpowiedź.

Możesz użyć dowolnej bazy, którą chcesz, ale w odpowiedzi podaj, której bazy użyłeś.

Walizka testowa (podstawa 10)

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

Jest to zwykle kod-golf, więc im krótsza odpowiedź, tym lepiej.

Python 2, 43 bajty

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

Przetestuj na Ideone .

Jak to działa

Wywołaj funkcję zdefiniowaną w specyfikacji g (a, b) . Mamy to

Zdefiniuj rekurencyjnie funkcję f (x, y, s) w następujący sposób.

Stosując relację powtarzalności f (a, b, 0) w sumie b - a , możemy to pokazać.

To jest funkcja f implementacji. Podczas gdy b/azwraca niezerową liczbę całkowitą, andwykonywany jest następujący kod , implementując w ten sposób rekurencyjną definicję f .

Gdy b/aosiągnie wartość 0 , mamy b> a, a lambda zwraca False = 0 , implementując w ten sposób podstawowy przypadek definicji f .

MATL , 9 bajtów

&:&*XRssE

Wypróbuj online!

Wyjaśnienie

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

Przykład

Są to częściowe wyniki każdego wiersza dla danych wejściowych 5i 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
   

Galaretka, 9 8 bajtów

rµS²_²S$

Wypróbuj 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

Dzięki FryAmTheEggman za bajt!

Python 2, 45 bajtów

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

Rozwiązanie w formie zamkniętej - nie najkrótsze, ale pomyślałem, że i tak warto je opublikować.

Wyjaśnienie

Pozwolić p(n)być n th kwadratowy liczby piramidalnej , a t(n)być n th Liczba trójkątna . Następnie dla n powyżej zakresu a , ..., b :

• =n = t(b)-t(a-1)i
• ²n² = p(b) - p(a-1)
• Więc (∑n) ²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

To wyrażenie ogranicza się do tego w kodzie.

05AB1E, 8 bajtów

ŸDOnsnO-

Wyjaśnił

Ÿ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

Wypróbuj online

Mathematica, 21 bajtów

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

Funkcja bez nazwy, która bierze dwa argumenty i zwraca różnicę. Stosowanie:

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

Są tutaj trzy małe (i dość standardowe) sztuczki golfowe:

• ##reprezentuje oba argumenty jednocześnie, dzięki czemu możemy użyć zapisu prefiksu dla Range. Range@##jest skrótem, dla Range[##]którego rozszerza się Range[a, b]i daje nam zakres obejmujący zgodnie z wymaganiami.
• Trsłuży do śledzenia, ale użycie go na wektorze po prostu sumuje ten wektor, oszczędzając trzy bajty Total.
• x.xjest produktem kropkowym, co pozwala zaoszczędzić cztery bajty Tr[x^2].

Labirynt , 28 24 bajtów

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

Wypróbuj online!

Wyjaśnienie

Ponieważ pętle są zwykle drogie w Labiryncie, pomyślałem, że wyraźna formuła powinna być najkrótsza, ponieważ może być wyrażona jako kod liniowy.

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

Wskaźnik instrukcji następnie uderza w ślepy zaułek i musi się odwrócić. Gdy napotka teraz /, próbuje podzielić przez zero (ponieważ spód stosu jest domyślnie wypełniony zerami), co powoduje zakończenie programu.

Haskell, 34 bajty

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

Przykład użycia: 91 # 123-> 12087152.

Nic do wyjaśnienia.

Matlab, 30 29 28 bajtów

Wykorzystanie pomysłu Suever normdaje nam 2 bajty mniej

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

Stara (prosta) wersja:

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

Oktawa, 27 23 bajtów

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

Tworzy anonimową funkcję o nazwie, ansktóra akceptuje dwa dane wejściowe:ans(lower, upper)

Demo online

Wyjaśnienie

Tworzy wektor wiersza od xdo y(włącznie) i zapisuje go w z. Następnie sumujemy wszystkie elementy za pomocą sumi kwadrat (it ^2). Aby obliczyć sumę kwadratów, wykonujemy mnożenie macierzy między wektorem wiersza a jego transpozycją. To skutecznie wyrówna każdy element i zsumuje wynik. Następnie odejmujemy dwa.

Java, 84 77 znaków, 84 77 bajtów

7 bajtów mniejszych dzięki Martinowi Enderowi i FryAmTheEggMan, dziękuję.

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

Wykorzystując trzy przypadki testowe w oryginalnym poście: http://ideone.com/q9MZSZ

Nie golfowany:

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

Proces jest dość oczywisty. Zadeklarowałem dwie zmienne do reprezentowania kwadratu sum i sumy kwadratów i wielokrotnie odpowiednio je zwiększałem. Na koniec zwracam obliczoną różnicę.

JavaScript (ES6), 46 bajtów

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 bajtów

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

Teraz port rozwiązania Python @ Dennis ♦.

Współczynnik, 48 bajtów

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

Anonimowa funkcja.

[ 
  [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 bajtów

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

Zauważ, że

Perl 6 ,  36 32  31 bajtów

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

Sprawdź to

Wyjaśnienie:

{ # 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 bajty

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

Oczekuje 2 liczb na wejściu jako listy, np [91:123].

Wyjaśnienie

: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 bajtów

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

Działa w NARS2000.

MATL, 11 bajtów

&:ts2^w2^s-

Wypróbuj online!

Wyjaśnienie:

&:           #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 bajtów

s*M-F#^}FQ2

Wypróbuj 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 bajtów

õV
x²aUx ²

Spróbuj

CJam, 17 bajtów

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

Sprawdź to tutaj.

Wyjaśnienie

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.

Alternatywnie można po prostu zsumować iloczyny wszystkich odrębnych par (w zasadzie pomnożenie kwadratu sumy i usunięcie kwadratów), ale jest to bajt dłuższy:

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

PowerShell v2 +, 47 bajtów

Dwie odmiany

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

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

W obu przypadkach generujemy zasięg z ..operatorem, przesyłając go do pętli |%{...}. Każdą iterację kumulujemy $oi $pjako sumę lub sumę kwadratów. Następnie obliczamy kwadrat sum za pomocą $o*$oi odejmujemy $p. Dane wyjściowe pozostają w potoku, a drukowanie jest niejawne.

JavaScript (ES6), 67 bajtów

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

Pakiet testowy

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 bajtów

Odpowiedź Galaretki Portu Doorknob .

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

Stosowanie

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

Gdzie >>jest STDIN, <<jest STDOUT i xsłuży do zwiększonej precyzji.

Pyke, 11 bajtów

h1:Ds]MXXs-

Wypróbuj tutaj!

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

Julia, 25 bajtów

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

Jest to funkcja, która akceptuje dwie liczby całkowite i zwraca tablicę liczb całkowitych 1x1.

Podejście jest proste: zbuduj a UnitRangez punktów końcowych ai bwywołaj go x, a następnie zsumuj x, wyprostuj i odejmij jego normę, która jest obliczana jako transpose(x) * x.

Wypróbuj online! (obejmuje wszystkie przypadki testowe)

TI-BASIC, 19 bajtów

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

randIntNoRepdostaje zasięg (potasowane). Reszta jest dość oczywista.

Po 52 bajty

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

Jest to anonimowa funkcja, która pobiera dwie liczby ze stosu i pozostawia jedną liczbę.

Wyjaśnienie:

{
    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 bajtów

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)

Definiuje funkcję (prawdopodobnie e(x,y)), która oblicza pożądaną różnicę.
a(x)oblicza sumę liczb naturalnych między 0i x.
b(x)oblicza sumę kwadratów liczb naturalnych między 0i x.
c(x,y)najpierw oblicza sumę liczb naturalnych między xi y, a następnie kwadraty tej sumy.
d(x,y)oblicza sumę kwadratów między b(x)i b(y).
Ostatni wiersz definiuje funkcję wielu zmiennych, która kończy obliczenia. Funkcja ma automatycznie przypisaną nazwę, oszczędzając kilka bajtów.