37

वर्ग और योगों के वर्ग के बीच का अंतर ज्ञात कीजिए।

यह गणितीय प्रतिनिधित्व है:

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

आपके प्रोग्राम / विधि को दो इनपुट लेने चाहिए, ये आपके रेंज की निचली और ऊपरी सीमाएं हैं, और समावेशी हैं। सीमाएँ पूर्ण पूर्णांक 0 से ऊपर होंगी।

आपके कार्यक्रम / विधि का उत्तर वापस आ जाना चाहिए।

आप जिस भी आधार का उपयोग करना चाहें, कर सकते हैं, लेकिन कृपया अपने उत्तर में बताएं कि आपने किस आधार का उपयोग किया है।

टेस्ट केस (बेस 10)

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

यह सामान्य कोड-गोल्फ है, इसलिए उत्तर जितना छोटा होगा उतना बेहतर होगा।

— जॉर्ज
स्रोत

11

यह महसूस करने में मुझे कुछ समय लगा कि इनपुट एक सीमा का समापन बिंदु था।

— ब्रैड गिलबर्ट 14

@ ब्रैडगिलबर्ट 2 मिल्स ने स्पष्टता के लिए संपादन किया

— जॉर्ज

यह दिखने में जितना आसान है?

— बिल्ली

@ आप क्या मतलब है? हाँ गणित सरल अलेव सामान है। लेकिन यह सब कैसे आप इसे गोल्फ के लिए नीचे है

— जॉर्ज

@george सवाल और कई जवाब यह बहुत काम की तरह दिखते हैं, लेकिन यह नहीं है

— बिल्ली

23

पायथन 2, 43 बाइट्स

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

Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

विनिर्देश जी (ए, बी) में परिभाषित फ़ंक्शन को कॉल करें । हमारे पास वह है

फ़ंक्शन को परिभाषित करें f (x, y, s) पुनरावर्ती रूप से निम्नानुसार।

एफ (ए, बी, 0) के पुनरावृत्ति संबंध को कुल मिलाकर - एक बार, हम दिखा सकते हैं।

इस समारोह है च कार्यान्वयन की। b/aगैर-शून्य पूर्णांक रिटर्न करते समय , निम्नलिखित कोड andको निष्पादित किया जाता है, इस प्रकार एफ की पुनरावर्ती परिभाषा को लागू किया जाता है ।

एक बार 0b/a तक पहुंचने के बाद , हमारे पास b> a और लैम्ब्डा झूठी = 0 रिटर्न करता है , इस प्रकार f की परिभाषा के आधार मामले को लागू करता है ।

— डेनिस
स्रोत

आह ठीक है। क्या आप अपने तरीके की व्याख्या कर सकते हैं?

— जॉर्ज

मैं करूंगा, लेकिन मैं वर्तमान में इसे थोड़ा और अधिक करने की कोशिश कर रहा हूं।

— डेनिस

सूत्र के लिए धन्यवाद। मुझे लगता है कि मैंने इसे कभी नहीं देखा क्योंकि हम स्कूल में इस तरह की श्रृंखलाओं को शामिल नहीं करते हैं। हालांकि बहुत दिलचस्प!

— जॉर्ज

2

@george मैंने स्पष्टीकरण समाप्त कर दिया है।

— डेनिस

हमें दुनिया में कुछ और बताना चाहिए कि कैसे परिभाषित करने का विचार आपके दिमाग में आया! प्रेरणा! मुझे सही मायने में दिलचस्पी है।

— मूसा अल-परेशानी

15

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:

&:
```
5 6 7 8 9
```

&:&*

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

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

&:&*XRss
```
485
```
&:&*XRssE
```
970
```

— लुइस मेंडो
स्रोत

7

मुझे वास्तव में आंशिक परिणाम देखना पसंद है। वे वास्तव में कार्यक्रम को समझने में मदद करते हैं। उन्हें शामिल करने के लिए धन्यवाद!

— दानामेन

10

जेली, ९ by बाइट्स

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 को धन्यवाद !

— Doorknob
स्रोत

3

एक बार के लिए, जेली वास्तव में बहुत पठनीय है।

— एडम

क्या मैं इसे अपने उत्तर के लिए कांटा कर सकता हूं?

— लीक नून

@LeakyNun का क्या मतलब है?

— दरवाज़े

यह ।

— लीक नून

6

अच्छी बालियां: S ear_²S

— थॉमस वेलर

10

पायथन 2, 45 बाइट्स

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

बंद किए गए फॉर्म सॉल्यूशन - सबसे छोटा नहीं, लेकिन मुझे लगा कि यह वैसे भी पोस्ट करने लायक होगा।

व्याख्या

आज्ञा देना p(n)हो n वें वर्ग पिरामिड संख्या , और t(n)हो सकता है n वें त्रिकोणीय संख्या । फिर, एन रेंज के लिए ए , ..., बी :

Andn = t(b)-t(a-1), और
²n² = p(b) - p(a-1)
तो (²n) ²-∑n (t(b)-t(a-1))² - (p(b) - p(a-1))। = ।

कोड में यह अभिव्यक्ति कम हो जाती है।

— Sp3000
स्रोत

यदि संभव हो तो हाय आप अपने समीकरण की व्याख्या कर सकते हैं। मेरा अजगर संस्करण 16 बाइट्स लंबा है और मैं यह नहीं जान सकता कि आपने अपना समीकरण कैसे बनाया है

— जॉर्ज

1

@george आज्ञा देना p(n)हो nवें वर्ग पिरामिड संख्या , और t(n)हो nवें त्रिकोणीय संख्या । फिर यह एक सरलीकृत संस्करण है (t(b)-t(a-1))^2 - (p(b) - p(a-1))।

— मार्टिन एंडर

@MartinEnder तो वह सटीक सूत्र है जिसका मैंने उपयोग किया है, लेकिन Sp3000 ने इसे इस तरह से सरल बनाया है कि मैं इसे समझ नहीं पा रहा हूं। मेरी पाइथन लिपि है: (b * - ~ ba * ~ -a) ** 2 / 4- (b * - ~ b * (2 * b + 1) -a * ~ -a * (2 * a-1) ) / 6 यदि वह किसी काम का हो। मैंने

— जार्ज

@ घेरा कभी-कभी, इस तरह की समस्याओं के साथ, वुल्फराम प्राप्त करने का सबसे आसान तरीका है । थकाऊ भाग करने के लिए अल्फा , फिर यह सुनिश्चित करने के लिए दोहरी जांच कि यह सही है। सच कहूँ तो, मुझे नहीं लगता कि मैं (a-b-1)कारक (b*(b+1)*(2b+1)-a*(a-1)*(2a-1))/6को अपने दम पर खींच सकता था ।

— Sp3000

@ Sp3000 यह करने का एक शानदार तरीका है। मैं कोशिश करूँगा कि भविष्य में

— जॉर्ज

6

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

इसे ऑनलाइन आज़माएं

— Emigna
स्रोत

क्या 05AB1E जेली का ROT13 संस्करण है? स्थानापन्न r itute, µ by D, S by O,, by n, _ by s और $ by -।

— थॉमस वेलर

4

@ थोमसवेलर: वे वास्तव में काफी अलग हैं। कुछ "फ़ंक्शंस" के बीच एक आम ऑफसेट सबसे अधिक संयोग है। जेली चैनिंग फ़ंक्शंस (afaik) के बारे में एक मौन भाषा है, जबकि 05AB1E एक स्टैक आधारित भाषा है।

— इमीना

6

गणितज्ञ, 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]।

— मार्टिन एंडर
स्रोत

चाहेंगे Varianceमदद करता है?

— लीक नून

@LeakyNun मैं नहीं देखता कि कैसे, क्योंकि दो शब्दों में से Varianceएक को nऔर दूसरे द्वारा विभाजित किया गया है n^2और मुझे उन अलग-अलग पूर्ववत करने का एक आसान तरीका नहीं दिखता है।

— मार्टिन एंडर

1

Tr@#^2-#.#&@*Rangeकेवल 18 बाइट्स है।

— मिशा लावरोव

@ मिशालवॉव नीट! इसे एक अलग उत्तर देने के लिए स्वतंत्र महसूस करें। :)

— मार्टिन एंडर

5

भूलभुलैया , 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.                      [ | ]

इंस्ट्रक्शन पॉइंटर फिर एक डेड एंड हिट करता है और उसे चारों ओर मोड़ना होता है। जब यह अब सामना /करता है तो यह शून्य से एक विभाजन का प्रयास करता है (चूंकि स्टैक के निचले हिस्से को स्पष्ट रूप से शून्य से भरा होता है), जो कार्यक्रम को समाप्त करता है।

— मार्टिन एंडर
स्रोत

4

हास्केल, 34 बाइट्स

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

प्रयोग उदाहरण: 91 # 123-> 12087152।

समझाने के लिए कुछ नहीं।

— nimi
स्रोत

3

मतलाब, 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)

— pajonk
स्रोत

3

ऑक्टेव, 27 23 बाइट्स

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

एक अनाम फ़ंक्शन बनाता है जिसका नाम ansदो इनपुट स्वीकार करता है:ans(lower, upper)

ऑनलाइन डेमो

व्याख्या

से एक पंक्ति वेक्टर बनाता xकरने के लिए y(सम्मिलित) और दुकानों में z। हम तब सभी तत्वों का उपयोग करते हैं sumऔर इसे वर्ग ( ^2) करते हैं। वर्गों की राशि की गणना करने के लिए, हम पंक्ति-वेक्टर के बीच मैट्रिक्स गुणन करते हैं और इसे स्थानांतरित करते हैं। यह प्रभावी रूप से प्रत्येक तत्व को वर्ग करेगा और परिणाम को योग करेगा। हम फिर दोनों को घटाते हैं।

— Suever
स्रोत

3

जावा, 84 77 अक्षर, 84 77 बाइट्स

मार्टिन एंडर और 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;}

मूल पोस्ट में तीन परीक्षण मामलों का उपयोग करना: 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;
}

प्रक्रिया काफी आत्म-व्याख्यात्मक है। मैंने रकमों के वर्ग और वर्गों के योग का प्रतिनिधित्व करने के लिए दो चर घोषित किए और उन्हें बार-बार संवर्धित किया। अंत में, मैं गणना किए गए अंतर को वापस करता हूं।

— मारियो इशाक
स्रोत

PPCG में आपका स्वागत है! आप शायद उस ++पर डालकर एक बाइट बचा सकते हैं f+=b*b++(ताकि आप forखाली के तीसरे स्लॉट को छोड़ सकें ) और आपको eइसे वापस करने से पहले स्क्वायर करने की आवश्यकता नहीं है (यानी बस करो return e*e-f)।

— मार्टिन एंडर

वास्तव में forखाली के तीसरे स्लॉट को छोड़ने के बजाय , f+=b*b++वहां स्थानांतरित करें , ताकि आप अर्धविराम और ब्रेसिज़ दोनों को बचा सकें।

— मार्टिन एंडर

ग्रेट कैच @MartinEnder, शुक्रिया :)

— मारियो इशाक

इसके अलावा मार्टिन के दिमाग में क्या था, यह थोड़ा छोटा लगता है।

— FryAmTheEggman

1

जाहिर है, मेरी अंतिम टिप्पणी गलत थी। यह वास्तव में जावा व्याकरण का एक विशेष हिस्सा है: के लिए अंतिम कथन वास्तव में एक विशेष प्रकार का बयान है, जिसे एक बयान अभिव्यक्ति सूची कहा जाता है। इस विशेष कथन में अल्पविराम द्वारा शामिल किए गए एक से अधिक कथन हो सकते हैं। 14.14.1 देखें (आपको स्वयं वहां नेविगेट करना होगा, मुझे भाषा विनिर्देश का अधिक सटीक लिंक बनाने का कोई तरीका नहीं मिल सकता है)।

— FryAmTheEggman

3

जावास्क्रिप्ट (ईएस 6), 46 बाइट्स

f=(x,y,s=0,p=0)=>x<=y?f(x+1,y,s+x,p+x*x):s*s-p

— वाशिंगटन गाइड्स
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 50 37 बाइट्स

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

अब @ डेनिस के अजगर समाधान का एक बंदरगाह।

— नील
स्रोत

कोशिश करेंn=>m=>eval(`for(s=t=0;n<=m;t+=n++)s+=n*n;t*t-s`)

— मामा फन रोल

@MamaFunRoll दूसरी ओर, मैं डेनिस के अजगर समाधान को चित्रित करने की कोशिश कर सकता हूं ...

— नील

3

फैक्टर, 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
]

— बिल्ली
स्रोत

3

हास्केल, 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

ध्यान दें कि

{(\sum_{k = m}^{n} k)}^{2} - \sum_{k = m}^{n} k^{2} = \dots = \sum_{k_{1} = m}^{n} \sum_{k_{2} = m k_{2} \neq k_{1}}^{n} k_{1} k_{2} = \sum_{k_{1} = m}^{n} \sum_{k_{2} = k_{1} + 1}^{n} 2 k_{1} k_{2}

$\left( \sum_{k=m}^n k \right)^2 - \sum_{k=m}^n k^2 = \cdots = \sum_{k_1=m}^n \sum_{k_2=m\\ k_2 \neq k_1}^n k_1 k_2 = \sum_{k_1=m}^n \sum_{k_2=k_1+1}^n 2 \,k_1 k_2$

— रोड्रिगो डी अजेवेडो
स्रोत

1

तुम आसपास के parens की जरूरत नहीं है i+1।

— गेहूं जादूगर

2

इसके अलावा अगर आप हास्केल और हास्केल गोल्फ से बात करना चाहते हैं तो आप हमसे चैट रूम में जुड़ सकते हैं ।

— गेहूं जादूगर

3

पर्ल 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

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

एक बाइट को असाइनमेंट और एव्रीडिंग परेंस को आगे बढ़ाते हुए बचाएं:{$_=$^a..$^b;.sum²-[+] $_»²}

— Phil H

1

25 बाइट्स:{.sum²-[+] $_»²}o&[..]

— nwellnhof

2

ब्रेकीलॉग , 24 बाइट्स

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

इनपुट में एक सूची के रूप में 2 नंबर की उम्मीद है, जैसे [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

— Fatalize
स्रोत

2

एपीएल, 23 20 बाइट्स

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

NARS2000 में काम करता है।

— एडम
स्रोत

2

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

— DJMcMayhem
स्रोत

2

अजगर, 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.

— लीक नन
स्रोत

फिल्टर का अच्छा उपयोग। हालांकि इस कार्य के लिए पहले से ही एक बिल्ड-इन है:s*M.P}FQ2

— जेक्यूब

2

जाप, 10 बाइट्स

õV
x²aUx ²

कोशिश करो

— झबरा
स्रोत

1

सीजेएम, 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*{)-},::*:+

— मार्टिन एंडर
स्रोत

1

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। आउटपुट को पाइप लाइन पर छोड़ दिया जाता है और मुद्रण को निहित किया जाता है।

— AdmBorkBork
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 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)`)

स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत

1

जे, 29 बाइट्स

पोर्ट ऑफ डोरकनॉब के जेली उत्तर ।

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

प्रयोग

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

जहाँ >>STDIN है, <<STDOUT है, और xविस्तारित परिशुद्धता के लिए है।

— लीक नन
स्रोत

1

पाइके, 11 बाइट्स

h1:Ds]MXXs-

यहाँ यह कोशिश करो!

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

— नीला
स्रोत

1

जूलिया, 25 बाइट्स

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

यह एक फ़ंक्शन है जो दो पूर्णांकों को स्वीकार करता है और 1x1 पूर्णांक सरणी देता है।

दृष्टिकोण सरल है: एक का निर्माण UnitRangeअंतिम बिंदु से aऔर bऔर इसे कहते xहै, तो योग x, यह वर्ग है, और अपने आदर्श है, जो के रूप में गणना की जाती है घटाना transpose(x) * x।

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले शामिल हैं)

— एलेक्स ए।
स्रोत

1

a\b=-(x=a:b)'x+sum(x)^2कुछ बाइट्स बचाता है।

— डेनिस

1

TI-BASIC, 19 बाइट्स

Prompt N,M
randIntNoRep(N,M
sum(Ans)²-sum(Ans²

randIntNoRepसीमा हो जाती है (फेरबदल)। बाकी बहुत आत्म व्याख्यात्मक है।

— कोनोर ओ ब्रायन
स्रोत

1

फेथ , 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
}

— bkul
स्रोत

1

अगर आपको पोस्टफिक्स, पॉइंट-फ्री और स्टैक-आधारित फंक्शनल प्रोगामिंग पसंद है, तो आप फैक्टर को पसंद कर सकते हैं : D

— cat

1

जप, 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)बीच प्राकृतिक संख्याओं के योग की गणना करता है । के बीच और प्राकृतिक संख्या के वर्गों की राशि की गणना करता है । पहले प्राकृतिक संख्याओं के बीच के योग की गणना करता है , और फिर उस राशि का वर्ग। के बीच वर्गों के योग की गणना करता है और । अंतिम पंक्ति एक बहु-चर फ़ंक्शन को परिभाषित करती है जो गणना को पूरा करती है। फ़ंक्शन को स्वचालित रूप से एक नाम सौंपा गया है, कुछ बाइट्स को बचाते हुए।0x
b(x)0x
c(x,y)xy
d(x,y)b(x)b(y)

— जो
स्रोत

नमस्ते, मैं इस फ़ंक्शन को कैसे परिभाषित करूं? मैं geogebra.org/classic#cas पर इनपुट का पता लगाने में सक्षम था , लेकिन अंतिम फ़ंक्शन को खोजने या कॉल करने के तरीके का पता नहीं लगा सका।

— सूंदर -

@ सूंदर: अंतिम पंक्ति एक्स और वाई में एक अभिव्यक्ति है। हम e(x,y)=इसे एक नाम देने के लिए तैयार हो सकते हैं , लेकिन बाइट्स बचाने के लिए, हम यहाँ नहीं हैं। जियो स्वतः ही एक नाम (शायद ई, क्योंकि यह अगले उपलब्ध पत्र है) प्रदान करता है। मेरे पास अभी पर्यावरण उपलब्ध नहीं है, लेकिन मैं CAS फलक का उपयोग नहीं करूंगा। बीजगणित फलक और इनपुट बार को सही काम करना चाहिए। (जब से मैंने GGb का ऑनलाइन उपयोग किया है, तब से कुछ समय हो गया है; मेरी मानसिक छवि पुरानी हो सकती है।)

— जो

योग के वर्ग का अंतर

पायथन 2, 43 बाइट्स

यह काम किस प्रकार करता है

MATL , 9 बाइट्स

व्याख्या

उदाहरण

जेली, ९ by बाइट्स

पायथन 2, 45 बाइट्स

व्याख्या

05AB1E, 8 बाइट्स

गणितज्ञ, 21 बाइट्स

भूलभुलैया , 28 24 बाइट्स

व्याख्या

हास्केल, 34 बाइट्स

मतलाब, 30 29 28 बाइट्स

ऑक्टेव, 27 23 बाइट्स

जावा, 84 77 अक्षर, 84 77 बाइट्स

जावास्क्रिप्ट (ईएस 6), 46 बाइट्स

जावास्क्रिप्ट (ईएस 6), 50 37 बाइट्स

फैक्टर, 48 बाइट्स

हास्केल, 36 बाइट्स

पर्ल 6 , 36 32 31 बाइट्स

स्पष्टीकरण:

परीक्षा:

ब्रेकीलॉग , 24 बाइट्स

व्याख्या

एपीएल, 23 20 बाइट्स

MATL, 11 बाइट्स

अजगर, 11 बाइट्स

जाप, 10 बाइट्स

सीजेएम, 17 बाइट्स

व्याख्या

PowerShell v2 +, 47 बाइट्स

जावास्क्रिप्ट (ईएस 6), 67 बाइट्स

परीक्षण सूट

जे, 29 बाइट्स

प्रयोग

पाइके, 11 बाइट्स

जूलिया, 25 बाइट्स

TI-BASIC, 19 बाइट्स

फेथ , 52 बाइट्स

जप, 91 बाइट्स