Toplamların karesi ile karelerin toplamı arasındaki farkı bulun.

Bu matematiksel temsildir:

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

Programınız / yönteminiz iki girdi almalıdır, bunlar aralığın alt ve üst sınırlarınızdır ve bunlar kapsayıcıdır. Sınırlar, 0'dan büyük tam sayılar olacaktır.

Programınız / yönteminiz cevabı geri göndermelidir.

İstediğiniz tabanı kullanabilirsiniz, ancak cevabınızı kullanarak hangi üssü kullandığınızı belirtin.

Test çantası (10 numaralı taban)

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

Bu normal kod golfüdür, bu yüzden cevap ne kadar kısa olursa o kadar iyidir.

Python 2, 43 bayt

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

İdeone üzerinde test et .

Nasıl çalışır

Spesifikasyonda g (a, b) tanımlanan fonksiyonu çağırın . Bizde var

Fonksiyon tanımlama f (x, y, s) yinelemeli olarak izler.

F (a, b, 0) nüksetme ilişkisini toplam b - a kez uygulayarak bunu gösterebiliriz.

Bu, uygulamanın f işlevidir . Birlikte b/adöner sıfır olmayan bir tamsayı, kod şunları andböylece yinelemeli tanımı uygulama, yürütülür f .

Bir kez b/aulaşır 0 , o sahip bir b> ve lambda döner 0 = False böylece tanımının temel durum uygulanması, f .

MATL , 9 bayt

&:&*XRssE

Çevrimiçi deneyin!

açıklama

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

Örnek

Bunlar girdiler için her bir satırın kısmi sonuçlarıdır 5ve 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
   

Jöle, 9 8 bayt

rµS²_²S$

Çevrimiçi deneyin!

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'a bir bayt için teşekkürler !

Python 2,45 bayt

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

Kapalı form çözümü - en kısa sürede değil, yine de göndermeye değer olacağını düşündüm.

açıklama

Izin p(n)olmak N inci kare piramit sayısı ve t(n)olmak N inci üçgen sayısı . Sonra, a , ..., b aralığındaki n için :

• =n = t(b)-t(a-1), ve
• ²n² = p(b) - p(a-1)
• Yani ((n) ²-²n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

Bu ifade koddakilere indirgenir.

05AB1E, 8 bayt

ŸDOnsnO-

Açıklaması

Ÿ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

Çevrimiçi deneyin

Mathematica, 21 bayt

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

İki argüman alan ve farkı döndüren adsız bir işlev. Kullanımı:

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

Burada üç küçük (ve oldukça standart) golf oyunu var:

• ##her iki argümanı aynı anda gösterir, böylece önek notasyonunu kullanabiliriz Range. Range@##Gerçeğe göre Range[##]genişleyen Range[a, b]ve bize kapsayıcı bir aralık veren kısaca.
• Triçindir iz ama bir vektör üzerinde kullanmaya basitçe içinde üç bayt tasarrufu, yani vektör özetliyor Total.
• x.xdört bayttan tasarruf sağlayan nokta ürünüdür Tr[x^2].

Labirent , 28 24 bayt

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

Çevrimiçi deneyin!

açıklama

Labyrinth'te döngüler pahalı olma eğiliminde olduğundan, açık formülün doğrusal kod olarak ifade edilebileceği için en kısa olması gerektiğini düşündüm.

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

Talimat işaretçisi daha sonra bir çıkmaza isabet eder ve geri dönmesi gerekir. Şimdi karşılaştığında /, sıfıra bölmeye çalışır (yığının dibi tam olarak sıfırlarla doludur), bu da programı sonlandırır.

Haskell, 34 bayt

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

Kullanım örneği: 91 # 123-> 12087152.

Açıklayacak bir şey yok.

Matlab, 30 29 28 bayt

Suever'in fikrini kullanmak normbize 2 bayt daha az verir

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

Eski (basit) sürüm:

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

Octave, 27 23 bayt

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

ansİki girişi kabul eden adsız bir işlev oluşturur :ans(lower, upper)

Çevrimiçi Demo

açıklama

Bir satır vektörü oluşturur xiçin y(dahil) ve depolar içinde z. Daha sonra tüm elemanları kullanarak sumtoplayıp kareleriz ( ^2). Karelerin toplamını hesaplamak için, satır-vektör ile transpozisyon arasında matris çarpımı yaparız. Bu, her bir elemanı etkili bir şekilde kareler ve sonucu özetler. Sonra ikisini çıkardık.

Java, 84 77 karakter, 84 77 bayt

Martin Ender ve FryAmTheEggMan nedeniyle 7 bayt daha küçük, teşekkür ederim.

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

Orijinal gönderideki üç test durumunun kullanılması: 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;
}

Süreç oldukça açıklayıcıdır. Toplamların karesini ve karelerin toplamını temsil etmek için iki değişken ilan ettim ve bunları tekrar tekrar arttırdım. Sonunda, hesaplanan farkı iade ediyorum.

JavaScript (ES6), 46 bayt

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 bayt

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

Şimdi @ Dennis ♦ nin Python çözümünün bir limanı.

Faktör, 48 bayt

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

Anonim bir işlev.

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

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

Bunu not et

Perl 6 ,  36 32  31 bayt

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

Dene

Açıklama:

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

Ölçek:

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

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

Girdi'deki 2 sayıyı liste olarak bekler, örn [91:123].

açıklama

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

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

NARS2000'de çalışır.

MATL, 11 bayt

&:ts2^w2^s-

Çevrimiçi deneyin!

Açıklama:

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

s*M-F#^}FQ2

Çevrimiçi deneyin!

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 bayt

õV
x²aUx ²

Dene

CJam, 17 bayt

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

Burada test et.

açıklama

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.

Alternatif olarak, bir kişi tüm farklı çiftlerin ürünlerini toplayabilir (temelde toplamın karesini çarparak kareleri kaldırarak), ancak bu bir bayt daha uzun:

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

PowerShell v2 +, 47 bayt

İki varyasyon

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

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

Her iki durumda da ..operatörle birlikte bir aralık oluşturuyoruz, bunu bir döngüye bağlıyoruz |%{...}. Her yinelemede, biriktirdik $ove $ptoplam ya da kareler toplamı olarak. Daha sonra toplamları karesi ile hesaplar $o*$ove çıkarırız $p. Çıkış, boru hattında bırakılır ve yazdırma gizlidir.

JavaScript (ES6), 67 bayt

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

Test odası

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 bayt

Doorknob Limanı'nın Jöle cevabı .

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

kullanım

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

>>STDIN nerede , <<STDOUT ve xdaha fazla hassasiyet için.

Pyke, 11 bayt

h1:Ds]MXXs-

Burada dene!

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

Julia, 25 bayt

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

Bu, iki tam sayıyı kabul eden ve 1x1 tam sayı dizisini döndüren bir işlevdir.

Yaklaşım basit: Bir Construct UnitRangeuç noktalarından ave bve diyoruz x, o zaman özetlemek x, karesini ve olarak hesaplanır onun normunu, çıkarma transpose(x) * x.

Çevrimiçi deneyin! (tüm test durumlarını içerir)

TI-BASIC, 19 bayt

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

randIntNoReparalığı alır (karıştırılır). Gerisi oldukça açıklayıcı.

Fith , 52 bayt

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

Bu, yığın üzerinde iki sayı alan ve tek bir sayı bırakan anonim bir işlevdir.

Açıklama:

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

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)İstenen farkı hesaplayan bir işlev (muhtemelen ) tanımlar . ve
a(x)arasındaki doğal sayıların toplamını hesaplar . ve arasındaki doğal sayıların karelerinin toplamını hesaplar . ilk önce ve arasındaki doğal sayıların toplamını hesaplar , ardından toplamı kareler. ve arasındaki karelerin toplamını hesaplar . Son satır, hesaplamayı bitiren çok değişkenli bir fonksiyonu tanımlar. Fonksiyona otomatik olarak bir isim atanır ve birkaç bayt kaydedilir.0x
b(x)0x
c(x,y)xy
d(x,y)b(x)b(y)