सम वर्ग अंतर


15

पहले दस प्राकृतिक संख्या के वर्गों का योग है, 12+22++102=385

पहले दस प्राकृतिक संख्याओं के योग का वर्ग है,

(1+2++10)2=552=3025

इसलिए पहले दस प्राकृतिक संख्याओं के वर्ग और योग के वर्ग के बीच का अंतर है

3025-385=2640

किसी दिए गए इनपुट n के लिए, पहले n प्राकृतिक संख्याओं के वर्ग और योग के वर्ग के बीच का अंतर ज्ञात कीजिए।

परीक्षण के मामलों

1       => 0
2       => 4
3       => 22
10      => 2640
24      => 85100
100     => 25164150

इस चुनौती को पहली बार प्रोजेक्ट Euler # 6 पर घोषित किया गया था ।

जीत का मानदंड

  • नकारात्मक या शून्य इनपुट के साथ व्यवहार क्या होना चाहिए, इसके बारे में कोई नियम नहीं हैं।

  • सबसे छोटा जवाब जीत जाता है।


4
इस चुनौती के लिए एक जीत की कसौटी (जैसे कोड गोल्फ)
dylnan

2
यह इस प्रश्न का एक सबसेट है
caird coinheringaahing

1
अनुक्रम 0 अनुक्रमित किया जा सकता है? यानी प्राकृतिक संख्या तक n?
जो राजा


3
@ इनिग्मा मुझे वास्तव में यह नहीं लगता कि यह लक्ष्य का एक डुप्लिकेट है क्योंकि यहाँ कई उत्तर आसानी से उस के उत्तर होने के लिए पोर्ट नहीं करते हैं, इसलिए यह कुछ जोड़ता है।
जोनाथन एलन

जवाबों:


10

जेली ,  5  4 बाइट्स

Ḋ²ḋṖ

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

कैसे?

कार्यान्वयन i=2n(i2(i1)) ...

Ḋ²ḋṖ - Link: non-negative integer, n
Ḋ    - dequeue (implicit range)       [2,3,4,5,...,n]
 ²   - square (vectorises)            [4,9,16,25,...,n*n]
   Ṗ - pop (implicit range)           [1,2,3,4,...,n-1]
  ḋ  - dot product                    4*1+9*2+16*3+25*4+...+n*n*(n-1)

8

पायथन 3 ,  28  27 बाइट्स

-1 एक्सनोर के लिए धन्यवाद

lambda n:(n**3-n)*(n/4+1/6)

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

औजार n(n-1)(n+1)(3n+2)/12


पायथन 2,  29  28 बाइट्स:lambda n:(n**3-n)*(3*n+2)/12


1
आप के साथ एक बाइट दाढ़ी कर सकते हैं n*~-n**2*या (n**3-n)*
xnor

8

एपीएल (डायलॉग यूनिकोड) , 10 बाइट्स

1⊥⍳×⍳×1-⍨⍳

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

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

1⊥⍳×⍳×1-⍨⍳
  ⍳×⍳×1-⍨⍳  Compute (x^3 - x^2) for 1..n
1          Sum

इस तथ्य का उपयोग करता है कि "राशि का वर्ग" "क्यूब्स के योग" के बराबर है।


मेरे लिए 1⍨⍳ × ⍳ × 1-; एक फ़ंक्शन नहीं है; मैंने 1⍨⍳ × ⍳ × 1-for10 की कोशिश की और मेरे लिए संकलन नहीं ...
RosLuP

1
@RosLuP आपको इसे पहले एक वैरिएबल में असाइन करना होगा (जैसा कि मैंने TIO लिंक में किया था) या इसे कोष्ठक की एक जोड़ी के अंदर लपेटें, जैसे (1⊥⍳×⍳×1-⍨⍳)10
बब्बलर

7

TI-Basic (TI-83 श्रृंखला), 12 11 बाइट्स

sum(Ans² nCr 2/{2,3Ans

इम्प्लिमेंट्स (n22)(12+13n)। इसमें इनपुट लेता हैAns: उदाहरण के लिए,10:prgmXइनपुट के लिए परिणाम की गणना करने केलिए चलाएं10


का अच्छा उपयोग nCr!
लिन

6

ब्रेन-फ्लैक , 74 72 68 64 बाइट्स

((([{}])){({}())}{})([{({}())({})}{}]{(({}())){({})({}())}{}}{})

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

बहुत आसान तरीका यह मुश्किल बदलाव की एक जोड़ी के साथ कर रहा है। उम्मीद है कि किसी को इसे और भी छोटा बनाने के लिए कुछ और तरकीबें मिलेंगी।



5

चारकोल , 12 10 बाइट्स

IΣEN×ιX⊕ι²

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: (1nx)2=1nx3 तो (1nx)21nx2=1n(x3x2)=1n(x1)x2=0n1x(x+1)2

   N        Input number
  E         Map over implicit range i.e. 0 .. n - 1
        ι   Current value
       ⊕    Incremented
         ²  Literal 2
      X     Power
     ι      Current value
    ×       Multiply
 Σ          Sum
I           Cast to string
            Implicitly print


4

Japt -x, 9 8 5 4 बाइट

õ²í*

कोशिश करो


व्याख्या

õ        :Range [1,input]
 ²       :Square each
  í      :Interleave with 0-based indices
   *     :Reduce each pair by multiplication
         :Implicit output of the sum of the resulting array


3

एपीएल (डायलॉग) , 16 बाइट्स

((×⍨+/)-(+/×⍨))⍳

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

 (×⍨+/)            The square  self) of the sum (+ fold)
       -           minus
        (+/×⍨)     the sum of the square
(             )⍳   of [1, 2,  input].

(+/×⍨)टिप के1⊥×⍨ अनुसार ।
शाम

1
एक और बाइट को अंदर रखकर बचाया जा सकता है(×⍨1⊥⍳)-⍳+.×⍳
क्रिक्सी लिथोस

3

मेथेमेटिका, 21 17 बाइट्स

-4 बाइट्स एलेफाल्फा के लिए धन्यवाद ।

(3#+2)(#^3-#)/12&

शुद्ध कार्य। एक पूर्णांक को इनपुट के रूप में लेता है और एक पूर्णांक को आउटपुट के रूप में देता है। बस बहुपद को लागू करता है, क्योंकि Sums, Ranges, Trs, आदि बहुत सारे बाइट्स लेते हैं।



@alephalpha धन्यवाद!
लीजनमोनमल 978

केवल बहुपद का मूल्यांकन किए बिना वहां पहुंचना संभव है: #.(#^2-#)&@*Rangeएक और सामान्य समाधान को लागू करता है। (लेकिन यह भी 17 बाइट्स है।) और हम 18 बाइट्स में भोले एल्गोरिदम को लागू कर सकते हैं Tr@#^2-#.#&@*Range:।
मिशा लावरोव



3

05AB1E , 8 बाइट्स

ÝDOnsnO-

स्पष्टीकरण:

ÝDOnsnO-     //Full program
Ý            //Push [0..a] where a is implicit input
 D           //Duplicate top of stack
  On         //Push sum, then square it
    s        //Swap top two elements of stack
     nO      //Square each element, then push sum
       -     //Difference (implicitly printed)

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


LDnOsOn- मेरा पहला प्रयास भी था।
मैजिक ऑक्टोपस Urn

3

सी, सी ++, 46 40 37 बाइट्स (# डेफिन), 50 47 46 बाइट्स (फ़ंक्शन)

-1 बाइट Zacharý को धन्यवाद

-11 बाइट्स सीटिंगकैट के लिए धन्यवाद

मैक्रो संस्करण:

#define F(n)n*n*~n*~n/4+n*~n*(n-~n)/6

फ़ंक्शन संस्करण:

int f(int n){return~n*n*n*~n/4+n*~n*(n-~n)/6;}

Thoses लाइनें, थ्रू 2 फॉर्मूले पर आधारित होती हैं:

1 और n = के बीच संख्याओं का योग n*(n+1)/2
योग बीच वर्गों का योगn*(n+1)*(2n+1)/6

तो उत्तर पाने का सूत्र मात्र है (n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6

और अब बाइट काउंट को "ऑप्टिमाइज़" करने के लिए, हम कोष्ठक को तोड़ते हैं और सामान को चारों ओर घुमाते हैं, करते हैं जबकि परीक्षण हमेशा उसी परिणाम को देता है

(n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6 => n*(n+1)/2*n*(n+1)/2 - n*(n+1)*(2n+1)/6 => n*(n+1)*n*(n+1)/4 - n*(n+1)*(2n+1)/6

पैटर्न पर ध्यान दें p = n*n+1 = n*n+n, इसलिए फ़ंक्शन में, हम एक और चर घोषित करते हैंint p = n*n+n और यह देता है:

p*p/4 - p*(2n+1)/6

के लिए p*(p/4-(2*n+1)/6)और इसलिएn*(n+1)*(n*(n+1)/4 - (2n+1)/6) , यह आधे समय ही काम करता है, और मैं संदिग्ध पूर्णांक विभाजन कारण (होने के लिए f(3)24 के बजाय 22 दे,f(24) 85100 के बजाय 85,200 दे रही है, तो हम कर सकते हैं खंड करना मैक्रो के सूत्र नहीं कि जिस तरह से है, भले ही गणितीय यह है वही।

मैक्रो प्रतिस्थापन के कारण मैक्रो और फ़ंक्शन दोनों संस्करण यहां हैं:

एफ (3) 3*3*(3+1)*(3+1)/4-3*(3+1)*(2*3+1)/6 = 22
एफ (5-2) देता है5-2*5-2*(5-2+1)*(5-2+1)/4-5-2*(5-2+1)*(2*5-2+1)/6 = -30

और ऑपरेटर पूर्वता के साथ गड़बड़ करता है। फ़ंक्शन संस्करण में यह समस्या नहीं है


1
आप सभी के साथ की जगह बाइट्स की लागत पर मैक्रोज़ के साथ समस्या को ठीक कर सकते हैं । इसके अलावा, => परवाह किए बिना।n(n)F(n) nF(n)n
ज़ाचरी

इसे पुनर्व्यवस्थित return p*p/4-p*(n-~n)/6करना संभव है return(p/4-(n-~n)/6)*p
Zacharý

@ Zacharý नहीं, यह मुझे इनपुट "3" के लिए 22 के बजाय कभी-कभी 24 की तरह खराब परिणाम देता है, या इनपुट "24" के लिए 85100 के बजाय 85200। मुझे पूर्णांक विभाजन पर संदेह है कि इसका कारण क्या है
HatsuPointerKun

ऊ, हमेशा उस बारे में भूल जाओ।
21


2

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

sm**hdh

इसे यहाँ ऑनलाइन आज़माएँ

नील के उत्तर में सूत्र का उपयोग करता है ।

sm**hdhddQ   Implicit: Q=eval(input())
             Trailing ddQ inferred
 m       Q   Map [0-Q) as d, using:
    hd         Increment d
   *  hd       Multiply the above with another copy
  *     d      Multiply the above by d
s            Sum, implicit print 



2

05AB1E , 6 बाइट्स

LnDƶαO

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

व्याख्या

L         # push range [1 ... input]
 n        # square each
  D       # duplicate
   ƶ      # lift, multiply each by its 1-based index
    α     # element-wise absolute difference
     O    # sum

एक ही बाइट गिनती में कुछ अन्य संस्करण:

L<ān*O
Ln.āPO
L¦nā*O




2

क्लोजर , 58 बाइट्स

(fn[s](-(Math/pow(reduce + s)2)(reduce +(map #(* % %)s))))

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


संपादित करें: मैंने प्रश्न को गलत समझा

क्लोजर , 55 , 35 बाइट्स

#(* %(+ 1 %)(- % 1)(+(* 3 %)2)1/12)

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


1
इसे ठीक करने के लिए धन्यवाद। और आपकी अंतिम प्रविष्टि के संबंध में सिर्फ एक सिर है, इससे (apply +छोटा है (reduce +
1

@Carcigenicate धन्यवाद!
TheGreatGeek

1
क्या आप परीक्षण के मामलों में से एक को चलाने के लिए अपने परमिटलिंक को संपादित कर सकते हैं? वैसे भी, मैं उन लोगों की मदद नहीं करता जो क्लोजर नहीं जानते हैं।
डेनिस


1

एपीएल (एनएआरएस), 13 चार्ट, 26 बाइट्स

{+/⍵×⍵×⍵-1}∘⍳

सूत्र Sum'w = 1..n 'का उपयोग (डब्ल्यू डब्ल्यू (डब्ल्यू -1)) संभव मैं लिखा ही कुछ अन्य ने लिखा है + या - के रूप में "1⊥⍳ × ⍳ × ⍳ -1"; परीक्षा:

  g←{+/⍵×⍵×⍵-1}∘⍳
  g 0
0
  g 1
0
  g 2
4
  g 3
22
  g 10
2640


1

QBASIC, 45 44 बाइट्स

शुद्ध गणित जा रहा है 1 बाइट बचाता है!

INPUT n
?n^2*(n+1)*(n+1)/4-n*(n+1)*(2*n+1)/6

ऑनलाइन कोशिश करो!


पिछला, लूप-आधारित उत्तर

INPUT n
FOR q=1TO n
a=a+q^2
b=b+q
NEXT
?b^2-a

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

ध्यान दें कि REPL थोड़ा अधिक विस्तारित है क्योंकि दुभाषिया अन्यथा विफल रहता है।


1

JAEL , 13 10 बाइट्स

#&àĝ&oȦ

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

स्पष्टीकरण (स्वचालित रूप से उत्पन्न):

./jael --explain '#&àĝ&oȦ'
ORIGINAL CODE:  #&àĝ&oȦ

EXPANDING EXPLANATION:
à => `a
ĝ => ^g
Ȧ => .a!

EXPANDED CODE:  #&`a^g&o.a!

COMPLETED CODE: #&`a^g&o.a!,

#          ,            repeat (p1) times:
 &                              push number of iterations of this loop
  `                             push 1
   a                            push p1 + p2
    ^                           push 2
     g                          push p2 ^ p1
      &                         push number of iterations of this loop
       o                        push p1 * p2
        .                       push the value under the tape head
         a                      push p1 + p2
          !                     write p1 to the tapehead
            ␄           print machine state

1

05AB1E , 6 बाइट्स

LDOšnÆ

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

स्पष्टीकरण:

           # implicit input (example: 3)
L          # range ([1, 2, 3])
 DOš       # prepend the sum ([6, 1, 2, 3])
    n      # square each ([36, 1, 4, 9])
     Æ     # reduce by subtraction (22)
           # implicit output

Æअक्सर उपयोगी नहीं है, लेकिन यह चमकने का समय है। यह भोले LOnILnO-को पूरे दो बाइट्स से मारता है ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.