Tìm sự khác biệt giữa bình phương của tổng và tổng bình phương.

Đây là biểu diễn toán học:

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

Chương trình / phương pháp của bạn nên có hai đầu vào, đây là các giới hạn dưới và trên của phạm vi và được bao gồm. Giới hạn sẽ là toàn bộ số nguyên trên 0.

Chương trình / phương pháp của bạn sẽ trả về câu trả lời.

Bạn có thể sử dụng bất cứ cơ sở nào bạn muốn, nhưng vui lòng nêu trong câu trả lời của bạn về cơ sở bạn đã sử dụng.

Trường hợp thử nghiệm (Cơ sở 10)

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

Đây là golf-code thông thường, vì vậy câu trả lời càng ngắn càng tốt.

Python 2, 43 byte

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

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Gọi hàm được định nghĩa trong đặc tả g (a, b) . Chúng tôi có điều đó

Xác định hàm f (x, y, s) đệ quy như sau.

Bằng cách áp dụng mối quan hệ lặp lại của f (a, b, 0) tổng cộng b - một lần, chúng ta có thể chỉ ra điều đó.

Đây là chức năng f của việc thực hiện. Trong khi b/atrả về một số nguyên khác không, mã sau andđược thực thi, do đó thực hiện định nghĩa đệ quy của f .

Khi b/ađạt đến 0 , chúng ta có b> a và lambda trả về Sai = 0 , do đó thực hiện trường hợp cơ sở của định nghĩa f .

MATL , 9 byte

&:&*XRssE

Hãy thử trực tuyến!

Giải trình

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

Thí dụ

Đây là kết quả một phần của từng dòng cho đầu vào 5và 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
   

Thạch, 9 8 byte

rµS²_²S$

Hãy thử trực tuyến!

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

Cảm ơn FryAmTheEggman cho một byte!

Python 2, 45 byte

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

Giải pháp dạng đóng - không phải là ngắn nhất, nhưng tôi nghĩ dù sao nó cũng đáng để đăng.

Giải trình

Gọi p(n)là số hình chóp vuông thứ n , và là số tam giác thứ n . Sau đó, với n trên phạm vi a , ..., b :t(n)

• ∑n = t(b)-t(a-1), và
• ∑n² = p(b) - p(a-1)
• Vậy (n) ² - ²n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

Biểu thức này giảm đến đó trong mã.

05AB1E, 8 byte

ŸDOnsnO-

Giải thích

Ÿ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

Dùng thử trực tuyến

Toán học, 21 byte

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

Một hàm không tên lấy hai đối số và trả về sự khác biệt. Sử dụng:

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

Có ba thủ thuật đánh gôn nhỏ (và khá chuẩn) ở đây:

• ##đại diện cho cả hai đối số cùng một lúc, để chúng ta có thể sử dụng ký hiệu tiền tố cho Range. Range@##là tốc ký Range[##]mà mở rộng Range[a, b]và cung cấp cho chúng tôi một phạm vi bao gồm theo yêu cầu.
• Trlà để theo dõi nhưng sử dụng nó trên một vectơ chỉ đơn giản là tính tổng vectơ đó, tiết kiệm được ba byte Total.
• x.xlà một sản phẩm chấm, tiết kiệm bốn byte trên Tr[x^2].

Mê cung , 28 24 byte

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

Hãy thử trực tuyến!

Giải trình

Vì các vòng lặp có xu hướng đắt tiền trong Labyrinth, tôi cho rằng công thức rõ ràng nên ngắn nhất, vì nó có thể được biểu thị dưới dạng mã tuyến tính.

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

Con trỏ lệnh sau đó đi vào ngõ cụt và phải quay lại. Khi nó gặp /nó, nó cố gắng chia cho 0 (vì đáy của ngăn xếp được chứa đầy các số không), điều này chấm dứt chương trình.

Haskell, 34 byte

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

Ví dụ sử dụng: 91 # 123-> 12087152.

Không có gì để giải thích.

Matlab, 30 29 28 byte

Sử dụng ý tưởng của Suever normmang lại cho chúng tôi ít hơn 2 byte

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

Phiên bản cũ (đơn giản):

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

Octave, 27 23 byte

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

Tạo một hàm ẩn danh có tên anschấp nhận hai đầu vào:ans(lower, upper)

Demo trực tuyến

Giải trình

Tạo một vectơ hàng từ xđến y(bao gồm) và lưu trữ nó trong z. Sau đó chúng tôi tổng hợp tất cả các phần tử bằng cách sử dụng sumvà bình phương nó ( ^2). Để tính tổng các bình phương, chúng tôi thực hiện đa ma trận giữa vectơ hàng và nó chuyển vị. Điều này sẽ có hiệu quả bình phương từng yếu tố và tổng hợp kết quả. Chúng tôi sau đó trừ hai.

Java, 84 77 ký tự, 84 77 byte

7 byte nhỏ hơn do Martin Ender và FryAmTheEggMan, cảm ơn bạn.

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

Sử dụng ba trường hợp thử nghiệm trong bài viết gốc: http://ideone.com/q9MZSZ

Ung dung:

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

Quá trình khá tự giải thích. Tôi đã khai báo hai biến để biểu diễn bình phương của tổng và tổng bình phương và liên tục tăng chúng một cách thích hợp. Cuối cùng, tôi trả lại sự khác biệt được tính toán.

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)

Bây giờ là một cổng của giải pháp Python của @ Dennis ♦.

Yếu tố, 48 byte

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

Một chức năng ẩn danh.

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

Lưu ý rằng

Perl 6 ,  36 32  31 byte

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

Kiểm tra nó

Giải trình:

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

Kiểm tra:

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

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

Hy vọng 2 con số trong đầu vào như một danh sách, ví dụ [91:123].

Giải trình

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

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

Hoạt động trong NARS2000.

MATL, 11 byte

&:ts2^w2^s-

Hãy thử trực tuyến!

Giải trình:

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

Bình thường, 11 byte

s*M-F#^}FQ2

Hãy thử trực tuyến!

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 byte

õV
x²aUx ²

Thử nó

CJam, 17 byte

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

Kiểm tra nó ở đây.

Giải trình

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.

Ngoài ra, người ta chỉ có thể tính tổng các sản phẩm của tất cả các cặp riêng biệt (về cơ bản nhân ra bình phương của tổng và loại bỏ các hình vuông), nhưng đó là một byte dài hơn:

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

PowerShell v2 +, 47 byte

Hai biến thể

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

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

Trong cả hai trường hợp, chúng tôi tạo ra một phạm vi với ..toán tử, chuyển nó thành một vòng lặp |%{...}. Mỗi lần lặp, chúng tôi tích lũy $ovà $plà tổng hoặc bình phương. Sau đó, chúng tôi tính toán tổng bình phương $o*$ovà trừ $p. Đầu ra được để lại trên đường ống và in ấn là ẩn.

JavaScript (ES6), 67 byte

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

Phòng thử nghiệm

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 byte

Câu trả lời của cảng Doorknob's Jelly .

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

Sử dụng

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

Nơi >>STDIN là, <<là STDOUT, và xlà cho độ chính xác mở rộng.

Pyke, 11 byte

h1:Ds]MXXs-

Hãy thử nó ở đây!

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

Julia, 25 byte

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

Đây là hàm chấp nhận hai số nguyên và trả về mảng số nguyên 1x1.

Cách tiếp cận rất đơn giản: Xây dựng a UnitRangetừ các điểm cuối avà bgọi nó x, sau đó tính tổng x, bình phương và trừ đi định mức của nó, được tính làtranspose(x) * x .

Hãy thử trực tuyến! (bao gồm tất cả các trường hợp thử nghiệm)

TI-BASIC, 19 byte

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

randIntNoRepđược phạm vi (xáo trộn). Phần còn lại là khá tự giải thích.

Không , 52 byte

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

Đây là một hàm ẩn danh lấy hai số trên ngăn xếp và để lại một số duy nhất.

Giải trình:

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

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)

Xác định một hàm (có thể e(x,y)) tính toán sự khác biệt mong muốn.
a(x)tính tổng các số tự nhiên giữa 0và x.
b(x)tính tổng bình phương của các số tự nhiên giữa 0và x.
c(x,y)đầu tiên tính tổng các số tự nhiên giữa xvà ysau đó bình phương tổng đó.
d(x,y)tính tổng bình phương giữa b(x)và b(y).
Dòng cuối cùng xác định hàm đa biến kết thúc phép tính. Hàm được tự động gán tên, lưu một vài byte.