Знайдіть різницю між квадратом сум і сумою квадратів.

Це математичне подання:

$\left(\sum n\right)^2-\sum n^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> a, і лямбда повертає False = 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)буде п - го квадратного пірамідального числа , а t(n)бути п е трикутним числом . Тоді для n за діапазон a , ..., b :

• ∑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

Спробуйте в Інтернеті

Математика, 21 байт

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

Безіменна функція, яка бере два аргументи і повертає різницю. Використання:

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

Тут є три невеликі (і досить стандартні) прийоми з гольфу:

• ##представляє обидва аргументи одразу, так що ми можемо використовувати позначення префікса для Range. Range@##це стенограма, для Range[##]якої розширюється Range[a, b]і надає нам інклюзивний діапазон у міру необхідності.
• Trє для сліду, але використовувати його у векторному просто підсумовує цей вектор, економлячи три байти Total.
• x.xє точковим продуктом, економивши чотири байти 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.                      [ | ]

Потім вказівник інструкції потрапляє в глухий кут і повинен повернутися. Коли він зараз стикається, /він намагається розділити на нуль (оскільки нижня частина стека неявно заповнена нулями), що завершує програму.

Хаскелл, 34 байти

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

Приклад використання: 91 # 123-> 12087152.

Нічого пояснити.

Матлаб, 30 29 28 байт

Використання ідеї Сьювера normдає нам на 2 байти менше

@(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'

Створюється анонімна функція, названа ansяка приймає два входи:ans(lower, upper)

Демонстрація в Інтернеті

Пояснення

Створює вектор рядка від xдо y(включно) і зберігає його в z. Потім підсумовуємо всі елементи, використовуючи sumі квадратуємо його ( ^2). Для обчислення суми квадратів ми виконуємо матричне множення між рядком-вектором і його переміщуємо. Це ефективно квадратизує кожен елемент і підводить результат. Потім віднімаємо два.

Java, 84 77 символів, 84 77 байт

На 7 байт менше завдяки Мартіну Ендеру та FryAmTheEggMan, дякую.

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

Використання трьох тестових випадків у оригінальній публікації: 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;
}

Процес досить зрозумілий. Я оголосив дві змінні для відображення квадрата сум і суми квадратів і кілька разів їх збільшував відповідно. Нарешті, я повертаю обчислену різницю.

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)

Тепер порт рішення Python @ Dennis ♦.

Фактор, 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.