Finden Sie die Differenz zwischen dem Quadrat der Summen und der Summe der Quadrate.

Dies ist die mathematische Darstellung:

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

Ihr Programm / Ihre Methode sollte zwei Eingaben annehmen, dies sind Ihre unteren und oberen Grenzen des Bereichs und sind inklusive. Limits sind ganze Zahlen über 0.

Ihr Programm / Ihre Methode sollte die Antwort zurückgeben.

Sie können jede Basis verwenden, die Sie möchten, aber geben Sie in Ihrer Antwort an, welche Basis Sie verwendet haben.

Testfall (Basis 10)

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

Dies ist übliches Code-Golf. Je kürzer die Antwort, desto besser.

Python 2, 43 Bytes

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

Teste es auf Ideone .

Wie es funktioniert

Rufen Sie die in der Spezifikation g (a, b) definierte Funktion auf . Wir haben das

Definieren Sie die Funktion f (x, y, s) rekursiv wie folgt.

Indem wir die Wiederholungsrelation von f (a, b, 0) insgesamt b - a mal anwenden , können wir das zeigen.

Dies ist die Funktion f der Implementierung. Während b/aeine Ganzzahl ungleich Null zurückgegeben wird, wird der folgende Code andausgeführt, wodurch die rekursive Definition von f implementiert wird .

Einmal b/aerreicht 0 , haben wir , dass b> ein und die Lambda - Renditen Falsch = 0 , so dass der Basisfalles der Definition der Umsetzung f .

MATL , 9 Bytes

&:&*XRssE

Probieren Sie es online!

Erläuterung

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

Beispiel

Dies sind die Teilergebnisse jeder Zeile für Eingaben 5und 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
   

Gelee, 9 8 Bytes

rµS²_²S$

Probieren Sie es 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

Danke an FryAmTheEggman für ein Byte!

Python 2, 45 Bytes

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

Closed-Form-Lösung - nicht die kürzeste, aber ich dachte, es lohnt sich trotzdem, sie zu veröffentlichen.

Erläuterung

Sei p(n)die n- te quadratische Pyramidenzahl und t(n)sei die n- te dreieckige Zahl . Dann gilt für n über den Bereich a , ..., b :

• ∑n = t(b)-t(a-1)und
• ∑n² = p(b) - p(a-1)
• Also (∑n) ²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

Dieser Ausdruck reduziert sich auf den im Code.

05AB1E, 8 Bytes

ŸDOnsnO-

Erklärt

Ÿ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

Probieren Sie es online aus

Mathematica, 21 Bytes

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

Eine unbenannte Funktion, die zwei Argumente verwendet und die Differenz zurückgibt. Verwendung:

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

Hier gibt es drei kleine (und ziemlich übliche) Golf-Tricks:

• ##repräsentiert beide Argumente gleichzeitig, so dass wir die Präfixnotation für verwenden können Range. Range@##ist eine Abkürzung, Range[##]die erweitert wird Range[a, b]und uns je nach Bedarf ein umfassendes Angebot bietet.
• Trist für die Verfolgung, aber wenn Sie es für einen Vektor verwenden, addieren Sie einfach diesen Vektor und sparen Sie drei Bytes mehr Total.
• x.xist ein Skalarprodukt, bei dem vier Bytes eingespart werden Tr[x^2].

Labyrinth , 28 24 Bytes

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

Probieren Sie es online!

Erläuterung

Da Schleifen im Labyrinth oft teuer sind, sollte die explizite Formel die kürzeste sein, da sie als linearer Code ausgedrückt werden kann.

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

Der Befehlszeiger stößt dann auf eine Sackgasse und muss sich umdrehen. Wenn es nun auf etwas stößt /, versucht es eine Division durch Null (da der Boden des Stapels implizit mit Nullen gefüllt ist), wodurch das Programm beendet wird.

Haskell, 34 Bytes

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

Anwendungsbeispiel: 91 # 123-> 12087152.

Nichts zu erklären.

Matlab, 30 29 28 Bytes

Die Verwendung von Suevers Idee von normergibt 2 Bytes weniger

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

Alte (einfache) Version:

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

Oktave, 27 23 Bytes

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

Erstellt eine anonyme Funktion mit dem Namen, ansdie zwei Eingaben akzeptiert:ans(lower, upper)

Online Demo

Erläuterung

Erstellt einen Zeilenvektor von xbis y(einschließlich) und speichert ihn in z. Wir addieren dann alle Elemente mit sumund quadrieren es ( ^2). Um die Summe der Quadrate zu berechnen, führen wir eine Matrixmultiplikation zwischen dem Zeilenvektor und seiner Transponierung durch. Dies wird effektiv jedes Element quadrieren und das Ergebnis zusammenfassen. Wir subtrahieren dann die beiden.

Java, 84 77 Zeichen, 84 77 Bytes

7 Bytes kleiner dank Martin Ender und FryAmTheEggMan, danke.

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

Verwenden der drei Testfälle im Originalbeitrag: 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;
}

Der Prozess ist ziemlich selbsterklärend. Ich habe zwei Variablen deklariert, um das Quadrat der Summen und die Summe der Quadrate darzustellen, und habe sie wiederholt entsprechend inkrementiert. Schließlich gebe ich die berechnete Differenz zurück.

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 Bytes

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

Nun ein Port von @ Dennis ♦ 's Python-Lösung.

Faktor 48 Bytes

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

Eine anonyme Funktion.

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

Beachten Sie, dass

Perl 6 ,  36 32  31 Bytes

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

Probier es aus

Erläuterung:

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

Prüfung:

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

Erwartet die 2 Zahlen in Input als Liste, z [91:123].

Erläuterung

: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 bis 20 Bytes

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

Funktioniert in NARS2000.

MATL, 11 Bytes

&:ts2^w2^s-

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es 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 ²

Versuch es

CJam, 17 Bytes

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

Teste es hier.

Erläuterung

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.

Alternativ kann man einfach die Produkte aller unterschiedlichen Paare summieren (im Grunde genommen das Quadrat der Summe multiplizieren und Quadrate entfernen), aber das ist ein Byte länger:

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

PowerShell v2 +, 47 Byte

Zwei Variationen

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

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

In beiden Fällen generieren wir mit dem ..Operator einen Bereich und leiten diesen an eine Schleife weiter |%{...}. Bei jeder Iteration akkumulieren wir $ound $pentweder als Summe oder als Quadratsumme. Wir berechnen dann das Summenquadrat mit $o*$ound subtrahieren $p. Die Ausgabe bleibt in der Pipeline und das Drucken ist implizit.

JavaScript (ES6), 67 Byte

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

Antwort von Port of Doorknob's Jelly .

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

Verwendung

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

Wo >>ist STDIN, <<ist STDOUT und xist für erweiterte Präzision.

Pyke, 11 Bytes

h1:Ds]MXXs-

Probieren Sie es hier aus!

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

Dies ist eine Funktion, die zwei Ganzzahlen akzeptiert und ein 1x1-Ganzzahl-Array zurückgibt.

Der Ansatz ist einfach: Erstellen Sie eine UnitRangevon den Endpunkten aund bund es nennt x, dann summieren x, quadratisch es, und seine Norm subtrahieren, die als berechnet transpose(x) * x.

Probieren Sie es online! (beinhaltet alle Testfälle)

TI-BASIC, 19 Bytes

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

randIntNoRepRuft die Reichweite ab (gemischt). Der Rest ist ziemlich selbsterklärend.

Fünftens 52 Bytes

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

Dies ist eine anonyme Funktion, die die beiden Zahlen auf dem Stapel aufnimmt und eine einzelne Zahl hinterlässt.

Erläuterung:

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

Definiert (wahrscheinlich e(x,y)) eine Funktion , die die gewünschte Differenz berechnet.
a(x)berechnet die Summe der natürlichen Zahlen zwischen 0und x.
b(x)berechnet die Summe der Quadrate der natürlichen Zahlen zwischen 0und x.
c(x,y)Berechnet zuerst die Summe der natürlichen Zahlen zwischen xund yund quadriert dann diese Summe.
d(x,y)berechnet die Summe der Quadrate zwischen b(x)und b(y).
Die letzte Zeile definiert eine Funktion mit mehreren Variablen, die die Berechnung beendet. Der Funktion wird automatisch ein Name zugewiesen, der einige Bytes spart.