合計の平方と平方の合計の差を見つけます。

これは数学的な表現です。

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

プログラム/メソッドは、2つの入力を取る必要があります。これらは、範囲の下限と上限であり、包括的です。制限は0より大きい整数全体です。

プログラム/メソッドが答えを返すはずです。

どのベースを使用しても構いませんが、使用したベースを回答に明記してください。

テストケース（ベース10）

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

これは通常のコードゴルフですので、答えは短いほど良いです。

Python 2、43バイト

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

Ideoneでテストします。

使い方

仕様g（a、b）で定義されている関数を呼び出します。私たちはそれを持っています

次のように関数f（x、y、s）を再帰的に定義します。

f（a、b、0）の再帰関係を合計b-a回適用すると、それを示すことができます。

これは実装の関数fです。b/aゼロ以外の整数を返しますが、次のコードandが実行され、fの再帰的な定義が実装されます。

一旦b/a到達0、我々は持っているB>及びラムダ戻り0 =偽をこうしての定義の基本ケース実装、Fを。

MATL、9バイト

&:&*XRssE

オンラインでお試しください！

説明

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

例

これらは、入力5および各行の部分的な結果です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
   

ゼリー、9 8バイト

rµS²_²S$

オンラインでお試しください！

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

おかげで FryAmTheEggmanにます！

Python 2、45バイト

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

クローズドフォームソリューション-最短ではありませんが、とにかく投稿する価値があると思いました。

説明

させるp(n)ことのn番目の四角錐数、およびt(n)なるN番目の三角数。次に、範囲a、...、bのn に対して：

• ∑n = t(b)-t(a-1)、および
• ∑n² = p(b) - p(a-1)
• （∑n）²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1))。

この式は、コード内の式に還元されます。

05AB1E、8バイト

ŸDOnsnO-

説明した

Ÿ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

オンラインで試す

Mathematica、21バイト

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

2つの引数を取り、差を返す名前のない関数。使用法：

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

ここには3つの小さな（そしてかなり標準的な）ゴルフトリックがあります。

• ##は両方の引数を一度に表すため、のプレフィックス表記を使用できますRange。Range@##は省略形でRange[##]ありRange[a, b]、必要に応じて拡張され、包括的な範囲が提供されます。
• Trはトレース用ですが、ベクトルでそれを使用すると、単純にそのベクトルが合計され、3バイト節約されTotalます。
• x.xは内積で、で4バイトを節約しますTr[x^2]。

ラビリンス、28 24バイト

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

オンラインでお試しください！

説明

ループはラビリンスでは高価になる傾向があるため、線形コードとして表現できるため、明示的な式は最短である必要があると考えました。

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

命令ポインタは行き止まりにぶつかり、向きを変えなければなりません。これに遭遇/すると、ゼロによる除算を試み（スタックの下部が暗黙的にゼロで埋められるため）、プログラムを終了します。

Haskell、34バイト

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

使用例：91 # 123->12087152。

説明するものはありません。

Matlab、30 29 28バイト

Sueverのアイデアを使用すると、norm2バイト少なくなります

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

古い（単純な）バージョン：

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

オクターブ、27 23バイト

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

ans2つの入力を受け入れるという名前の匿名関数を作成します。ans(lower, upper)

オンラインデモ

説明

xtoからy（含む）の行ベクトルを作成し、に保存しzます。次に、それを使用してすべての要素を合計し、sumそれを二乗します（^2）。平方和を計算するために、行ベクトルと転置の間で行列乗算を実行します。これにより、各要素が効果的に二乗され、結果が合計されます。次に、2つを減算します。

Java、84 77文字、84 77バイト

Martin EnderとFryAmTheEggManにより7バイト小さくなりました。ありがとうございます。

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

元の投稿の3つのテストケースを使用：http : //ideone.com/q9MZSZ

ゴルフをしていない：

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

プロセスはかなり自明です。合計の平方と平方の合計を表す2つの変数を宣言し、それらを適切に繰り返しインクリメントしました。最後に、計算された差を返します。

JavaScript（ES6）、46バイト

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バイト

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

@ Dennis♦のPythonソリューションの移植版になりました。

ファクター、48バイト

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

匿名関数。

[ 
  [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バイト

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

ご了承ください

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.