ค้นหาความแตกต่างระหว่างผลรวมของกำลังสองกับผลรวมของกำลังสอง

นี่คือการแสดงทางคณิตศาสตร์:

$\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

มันทำงานอย่างไร

เรียกใช้ฟังก์ชันที่กำหนดไว้ในข้อกำหนดกรัม (A, B) เรามีสิ่งนั้น

กำหนดฟังก์ชั่นf (x, y, s)ซ้ำดังนี้

โดยการใช้ความสัมพันธ์ที่เกิดซ้ำของf (a, b, 0)รวมb - aครั้งเราสามารถแสดงให้เห็นว่า

นี่คือฟังก์ชันfของการนำไปใช้ ในขณะที่b/aผลตอบแทนที่ไม่ใช่ศูนย์จำนวนเต็มต่อไปนี้รหัสandจะถูกดำเนินการดังนั้นการดำเนินการตามคำนิยาม recursive ของฉ

เมื่อb/aถึง0เรามีที่ข> aและผลตอบแทนแลมบ์ดาเท็จ = 0ดังนั้นการดำเนินการกรณีฐานของความหมายของฉ

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 TH จำนวนเสี้ยมตารางและt(n)เป็นn TH จำนวนรูปสามเหลี่ยม จากนั้นสำหรับ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

ลองออนไลน์

Mathematica ขนาด 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.xTr[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 # 12312087152

ไม่มีอะไรจะอธิบาย

Matlab, 30 29 28 ไบต์

การใช้ความคิดของ Suever normทำให้เรามีข้อมูลน้อยลง 2 ไบต์

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

รุ่นเก่า (ง่าย):

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

Octave, 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 ไบต์เนื่องจาก Martin Ender และ 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

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;
}

กระบวนการนี้ค่อนข้างอธิบายตนเอง ฉันได้ประกาศตัวแปรสองตัวเพื่อเป็นตัวแทนของผลรวมของกำลังสองและผลรวมของกำลังสอง ในที่สุดฉันกลับความแตกต่างที่คำนวณได้

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 ไบต์

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

ทดสอบมัน

คำอธิบาย:

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

ทดสอบ:

#! /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 ไบต์

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

คาดว่าตัวเลขทั้งสองในอินพุตเป็นรายการเช่น [91:123]หมายเลขในการป้อนข้อมูลเป็นรายการเช่น

คำอธิบาย

: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 ไบต์

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

ทำงานใน NARS2000

MATL 11 ไบต์

&:ts2^w2^s-

ลองออนไลน์!

คำอธิบาย:

&:           #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 ไบต์

s*M-F#^}FQ2

ลองออนไลน์!

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 ไบต์

õV
x²aUx ²

ลองมัน

CJam, 17 ไบต์

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

ทดสอบที่นี่

คำอธิบาย

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.

อีกวิธีหนึ่งเราสามารถรวมผลคูณของคู่ที่แตกต่างกันทั้งหมด (โดยทั่วไปแล้วจะคูณกำลังสองของผลรวมและลบกำลังสอง) แต่นั่นก็เป็นจำนวนไบต์ที่ยาวกว่า:

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

PowerShell v2 +, 47 ไบต์

สองรูปแบบ

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

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

ในทั้งสองกรณีที่เรากำลังสร้างช่วงที่มีผู้ประกอบการที่ท่อห่วง.. |%{...}การวนซ้ำแต่ละครั้งเราจะสะสม$oและ$pเป็นผลรวมหรือผลบวกกำลังสอง จากนั้นเราจะคำนวณผลรวมของตารางที่มีและลบ$o*$o $pเอาท์พุทที่เหลืออยู่ในท่อและการพิมพ์เป็นนัย

JavaScript (ES6), 67 ไบต์

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

ชุดทดสอบ

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 ไบต์

ท่าเรือDoorknob เป็นคำตอบวุ้น

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

การใช้

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

>>STDIN อยู่ที่ไหน<<STDOUT และxเพื่อความแม่นยำที่เพิ่มขึ้น

Pyke 11 ไบต์

h1:Ds]MXXs-

ลองที่นี่!

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

Julia, 25 ไบต์

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

นี่คือฟังก์ชั่นที่ยอมรับสองจำนวนเต็มและส่งกลับอาร์เรย์จำนวนเต็ม 1x1

วิธีการง่ายๆคือ: คอนสตรัคUnitRangeจากจุดสิ้นสุดaและbและเรียกมันว่าxแล้วสรุปสแควร์มันและลบบรรทัดฐานซึ่งคำนวณเป็นxtranspose(x) * x

ลองออนไลน์! (รวมถึงกรณีทดสอบทั้งหมด)

TI-BASIC, 19 ไบต์

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

randIntNoRepรับช่วง (สับ) ที่เหลือเป็นคำอธิบายที่ค่อนข้างดี

Fith , 52 ไบต์

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

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อซึ่งใช้ตัวเลขสองตัวบนสแต็กและปล่อยให้เป็นตัวเลขเดียว

คำอธิบาย:

{
    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 ไบต์

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)

กำหนดฟังก์ชั่น (อาจe(x,y)) ที่คำนวณความแตกต่างที่ต้องการ
a(x)คำนวณผลรวมของตัวเลขธรรมชาติระหว่างและ0 คำนวณผลรวมของกำลังสองของจำนวนธรรมชาติระหว่างและ ก่อนอื่นให้คำนวณผลรวมของจำนวนธรรมชาติระหว่างและจากนั้นกำลังสองรวมกัน คำนวณผลรวมของสี่เหลี่ยมระหว่างและ บรรทัดสุดท้ายกำหนดฟังก์ชั่นหลายตัวแปรที่เสร็จสิ้นการคำนวณ ฟังก์ชั่นจะถูกกำหนดชื่อโดยอัตโนมัติโดยบันทึกสองสามไบต์x
b(x)0x
c(x,y)xy
d(x,y)b(x)b(y)