वर्ग पिरामिड संख्याएँ

28

A000330 - OEIS

कार्य

आपका कार्य सरल है, एक अनुक्रम उत्पन्न करते हैं, जो कि सूचकांक दिया जाता है i, उस स्थिति पर मूल्य जहां 0तक के वर्गों का योग है ।ii >= 0

उदाहरण:

Input: 0
Output: 0           (0^2)

Input: 4
Output: 30          (0^2 + 1^2 + 2^2 + 3^2 + 4^2)

Input: 5
Output: 55          (0^2 + 1^2 + 2^2 + 3^2 + 4^2 + 5^2)

विशिष्टता:

  • आप कोई इनपुट नहीं ले सकते हैं और अनुक्रम को अनिश्चित काल तक आउटपुट कर सकते हैं;
  • आप इनपुट ले सकते हैं Nऔर Nthअनुक्रम के तत्व को आउटपुट कर सकते हैं ;
  • आप इनपुट ले सकते हैं Nऔर Nअनुक्रम के पहले तत्वों को आउटपुट कर सकते हैं ।
code-golf  number  sequence  arithmetic 
— फेलिप नारदी बतिस्ता
स्रोत
2
OEIS से मज़ा अवलोकन: इस अनुक्रम में दो बिल्कुल सही वर्ग हैं: f(1) == 1 * 1 (1)और f(24) == 70 * 70 (4900)।
— डीजेमेकमहेम
क्या हम अनुक्रम शुरू कर सकते हैं f(1) = 1?
— एमिग्ना
@Emigna क्षमा करें, लेकिन नहीं, आपको शुरू करने की आवश्यकता है f(0) = 0। मैंने कहा है कि कुछ जवाब जो उस आवश्यकता को विफल कर रहे हैं
— फेलिप नारदी बतिस्ता
f(0) = 0आवश्यकता मेरी समाधान के :( कुछ बर्बाद कर दिया
— Ataco

जवाबों:

22

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

lambda n:n*~n*~(n*2)/6

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

यह बंद-फॉर्मूला फॉर्म n * (n + 1) * (2 * n + 1) / 6 का उपयोग करता है । कोड निम्न कार्य करता है:

  • एन द्वारा गुणा ( n*):

    • N ( ~n) का बिटवाइज पूरक , जिसका अनिवार्य रूप से अर्थ है -1-n ।
    • और के बिटवाइस पूरक द्वारा 2 एन ( *~(n*2)) के बिटवाइज , जिसका अर्थ है -1-2 एन ।

  • 6 से विभाजित ( /6)।

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

f=lambda n:n and f(n-1)+n*n

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

रॉड के लिए 1 बाइट धन्यवाद और 1 जीबी के लिए धन्यवाद ।

— श्री Xcoder
स्रोत
1
यह बहुत चालाक है!
— स्कीलर
14

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

n=>n*(n+++n)*n/6

डेमो

कोड स्निपेट दिखाएं

कैसे?

अभिव्यक्ति (1) केn+++n रूप में पार्स की जाती है । ऐसा नहीं है कि यह वास्तव में मायने रखता है क्योंकि इस मामले में भी काम करेगा।n++ + nn + ++n

इसलिए:

n*(n+++n)*n/6 =
n * (n + (n + 1)) * (n + 1) / 6 =
n * (2 * n + 1) * (n + 1) / 6

जो योग का मूल्यांकन करता है (k = 0 ... n) (k । ) ।

(1) यह सत्यापित करके किया जा सकता है n='2';console.log(n+++n)जो पूर्णांक देता है 5, जबकि n + ++nस्ट्रिंग देगा '23'।

— Arnauld
स्रोत
6

ब्रेन-फ्लैक , 36 बाइट्स

({<(({}[()])())>{({})({}[()])}{}}{})

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

# Main algorithm
(                                  )  # Push the sum of:
                {({})({}[()])}{}      #   The square of:
 {                              }     #     0 to i 

# Stuff for the loop
  <(({}[()])())>                      # Push i-1, i without counting it in the sum
                                 {}   # Pop the counter (0)
— रिले
स्रोत
अच्छी तरह से किया! :) मैं के साथ आया था ({<(({}))>{({})({}[()])}{}<({}[()])>})38 के लिए
— DJMcMayhem
— गेहूं जादूगर
6

ब्रेन-फ्लैक , 34 बाइट्स

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

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

यह कैसे काम करता है?

शुरू में मुझे रिले 1 जैसा ही विचार आया था लेकिन एक शून्य का उपयोग करना गलत लगा। मुझे तब अहसास हुआ

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

गणना करना n २ - एन की ।

क्यूं कर? वैसे हम जानते हैं

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

एन 2 और छोरों एन बार गणना करता है । इसका मतलब है कि अगर हम हर बार n (n-1) + (n-1) + (n-1) बढ़ाकर हर बार दो पुश के क्रम को बदलते हैं तो हम n + (n-1) से बढ़ाते हैं। यह प्रति लूप में परिणाम में कमी करेगा, इस प्रकार हमारा परिणाम n 2 - n होगा। शीर्ष स्तर पर यह एक n धक्का के साथ उत्पन्न n के साथ रद्द करता है कि हम एक शून्य की आवश्यकता को कम करने और हमें दो बाइट्स बचा रहे थे।

ब्रेन-फ्लैक , 36 बाइट्स

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

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

यहाँ एक और उपाय है, यह गोल्फ के रूप में नहीं है, लेकिन यह बहुत अजीब है इसलिए मैंने सोचा कि मैं इसे एक चुनौती के रूप में छोड़ दूंगा कि यह कैसे काम करता है।

यदि आप ब्रेन-फ्लैक में नहीं हैं, लेकिन आप अभी भी यहाँ चुनौती चाहते हैं तो यह एक योग के रूप में है।

चित्र

1: इससे पहले कि मैं यहाँ के उत्तरों को देखूँ, मैं अपने समाधान के साथ आ गया। तो यहाँ कोई चोरी नहीं।

— गेहूं का जादूगर
स्रोत
मुझे पता था कि ऐसा करने का एक तरीका होना चाहिए, और मुझे लग रहा था कि आप इसके लिए गणित का पता लगाने वाले होंगे।
— रिले
2

ब्रेन-फ्लैक , 46 बाइट्स

{(({})[()])}{}{({({})({}[()])}{}<>)<>}<>({{}})

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

— HyperNeutrino
स्रोत
— रिले
@ रिले ऊह अच्छा :)
— हाइपरनेट्रिनो
वैकल्पिक स्टैक पर वर्ग को धक्का देने के बजाय, आप इसे सीधे मूल्यांकन करके और इसे धक्का नहीं देकर जोड़ सकते हैं, फिर इसके बजाय पूरे लूप को धक्का दे सकते हैं। यह आपकी दूसरी छमाही को बदल देता है ({{({})({}[()])}{}}{}), और आपको 10 बाइट्स बचाता है। (कि में भावना, पिंग मुझे नहीं आता, तो तीसरे ढेर )
— DJMcMayhem
2

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

ri),{_*+}*

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

ri            e# Input integer n
  )           e# Add 1
   ,          e# Range [0 1 ... n]
    {   }*    e# Fold (reduce)
     _        e# Duplicate
      *       e# Multiply
       +      e# Add
— लुइस मेंडो
स्रोत
कैसे ri),_.*:+या ri),2f#:+?
— मार्टिन एंडर
@ अच्छा विचार! मुझे लगता है कि आपको इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए
— लुइस मेंडो
2

आर, 17 बाइट्स

sum((0:scan())^2)

बहुत सीधा है, यह इस तथ्य से लाभ उठाता है कि ^(घातांक) को आर में वेक्टर किया जाता है ।

— फ़्रेडरिक
स्रोत
1
(x=0:scan())%*%xएक बाइट से छोटा है, लेकिन मेरा मानना ​​है कि आपको catआउटपुट प्राप्त करने की आवश्यकता है ।
— ग्यूसेप
@Giuseppe मैंने अभी इसकी कोशिश की है और आपका कोड बिना काम करता है cat, यह 1x1 मैट्रिक्स को आउटपुट करता है ।
— रुई बरदास
@ रुईरदास वर्तमान मेटा सर्वसम्मति है कि catइसके लिए एक पूर्ण कार्यक्रम के रूप में अर्हता प्राप्त करना आवश्यक है। यदि आप इसे बदलना चाहते हैं, तो इस प्रश्न का उत्तर दें और साइट पर अन्य आर लोगों के बीच कुछ कर्षण प्राप्त करें।
— ग्यूसेप
2

CJam , 9 बाइट्स

ri),_.*:+

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

व्याख्या

ri        e# Read input and convert to integer N.
  ),      e# Get range [0 1 2 ... N].
    _     e# Duplicate.
     .*   e# Pairwise products, giving [0 1 4 ... N^2].
       :+ e# Sum.

वैकल्पिक रूप से:

ri),2f#:+

यह 2#युग्मक उत्पादों का उपयोग करने के बजाय मानचित्रण द्वारा प्रत्येक तत्व को वर्गित करता है। और बस एक और विकल्प के लिए जो बड़े इनपुट के लिए गलत हो जाता है क्योंकि यह फ्लोटिंग-पॉइंट अंकगणित का उपयोग करता है:

ri),:mh2#
— मार्टिन एंडर
स्रोत
2

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

:!\
+ :
*:#

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

अनुक्रम को अनिश्चित काल के लिए प्रिंट करता है।

व्याख्या

निर्देश सूचक बस बार-बार कोड के वर्ग के आसपास चलता रहता है:

:!\    Duplicate the last result (initially zero), print it and a linefeed.
:      Duplicate the result again, which increases the stack depth.
#      Push the stack depth (used as a counter variable).
:*     Square it.
+      Add it to the running total.
— मार्टिन एंडर
स्रोत
2

क्यूबिक्स , 15 बाइट्स

Iu):^\+*p*6u@O,

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

मेरा कोड थोड़ा दुखद है ):

गणना करता है n*(n+1)*(2n+1)/6

    I u
    ) :
^ \ + * p * 6 u
@ O , . . . . .
    . .
    . .


^Iu : read in input, u-turn
    : stack  n
:)\ : dup, increment, go right..oh, hey, it cheered up!
    : stack: n, n+1
+   : sum
    : stack: n, n+1, 2*n+1
*   : multiply
    : stack: n, n+1, 2*n+1, (n+1)*(2*n+1)
p   : move bottom of stack to top
    : stack: n+1, 2*n+1, (n+1)*(2*n+1), n
*   : multiply
6   : push 6
u   : right u-turn
,   : divide
O   : output
@   : terminate

— ग्यूसेप
स्रोत
2

हेक्सागोनी , 23 बाइट्स

?'+)=:!@/*"*'6/{=+'+}/{

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

व्याख्या

सामने आया:

   ? ' + )
  = : ! @ /
 * " * ' 6 /
{ = + ' + } /
 { . . . . .
  . . . . .
   . . . .

यह वास्तव में सिर्फ एक रेखीय कार्यक्रम है जिसका /उपयोग कुछ पुनर्निर्देशन के लिए किया जाता है। रैखिक कोड है:

?'+){=+'+}*"*'6{=:!@

जो n (n + 1) (2n + 1) / 6 की गणना करता है । यह निम्नलिखित मेमोरी किनारों का उपयोग करता है:

यहाँ छवि विवरण दर्ज करें

जहाँ उत्तर की ओर इशारा करते हुए मेमोरी पॉइंट (MP) एन लेबल वाले किनारे पर शुरू होता है ।

?   Read input into edge labelled 'n'.
'   Move MP backwards onto edge labelled 'n+1'.
+   Copy 'n' into 'n+1'.
)   Increment the value (so that it actually stores the value n+1).
{=  Move MP forwards onto edge labelled 'temp' and turn around to face
    edges 'n' and 'n+1'.
+   Add 'n' and 'n+1' into edge 'temp', so that it stores the value 2n+1.
'   Move MP backwards onto edge labelled '2n+1'.
+   Copy the value 2n+1 into this edge.
}   Move MP forwards onto 'temp' again.
*   Multiply 'n' and 'n+1' into edge 'temp', so that it stores the value
    n(n+1).
"   Move MP backwards onto edge labelled 'product'.
*   Multiply 'temp' and '2n+1' into edge 'product', so that it stores the
    value n(n+1)(2n+1).
'   Move MP backwards onto edge labelled '6'.
6   Store an actual 6 there.
{=  Move MP forwards onto edge labelled 'result' and turn around, so that
    the MP faces edges 'product' and '6'.
:   Divide 'product' by '6' into 'result', so that it stores the value
    n(n+1)(2n+1)/6, i.e. the actual result.
!   Print the result.
@   Terminate the program.

सिद्धांत रूप में, इस कार्यक्रम को साइड-लेंथ 3 में फिट करना संभव हो सकता है, क्योंकि /गणना के लिए आवश्यक नहीं हैं, :कार्यक्रम को समाप्त करने के लिए पुन: उपयोग किया जा सकता है, और कुछ '"=+*{पुन: प्रयोज्य हो सकते हैं, आवश्यक की संख्या लाते हैं। 19 से नीचे कमांड (साइड-लंबाई 3 के लिए अधिकतम)। मुझे संदेह है कि इस तरह के समाधान को हाथ से ढूंढना संभव है, हालांकि, यदि कोई भी मौजूद है।

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

> <> , 15 13 11 बाइट्स

एक पेड़ के लिए धन्यवाद 2 बाइट्स सहेजे गए

0:n:l1-:*+!

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

अनुक्रम को अनिश्चित काल तक आउटपुट करता है।

— Emigna
स्रोत
1
14 बाइट्स ( -vध्वज के लिए 12 + 2 ): ::1+:}+**6,n( इसे ऑनलाइन आज़माएं! )
— पेड़ नहीं
1
या 11 बाइट्स (हमेशा के लिए प्रिंट, शुरू N=1): इसे ऑनलाइन आज़माएं!
— एक पेड़
@Notatree: बहुत अच्छा विचार का उपयोग कर l। ओपी के साथ जाँच की जा रही है अगर 1. पर शुरू करना ठीक है
— एमिग्ना
@ नोटोट्री: दुर्भाग्य से हमें 1 पर शुरू करने की अनुमति नहीं है, लेकिन यह अभी भी 2 बाइट्स बचाता है। धन्यवाद!
— एमिग्ना
1
(मुझे यह उल्लेख करना चाहिए कि मुझे lमार्टिन एंडर के भूलभुलैया उत्तर से विचार मिला ।)
— एक पेड़ नहीं
2

पायथ , 7 5 बाइट्स स्टीवन एच के लिए धन्यवाद

s^R2h

स्पष्टीकरण:

s^R2h       Full program - inputs from stdin and outputs to stdout
s           output the sum of
    h       range(input), with
 ^R2         each element squared

मेरा पहला उपाय

sm*ddUh

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

स्पष्टीकरण:

sm*ddUh    Full program - inputs from stdin and outputs to stdout
s          sum of
 m   Uh    each d in range(input)
  *dd      squared
— डेव
स्रोत
क्या पाइथ में कोई वर्ग निर्मित नहीं है?
— १
जहाँ तक मुझे पता है ...
— डेव
नहीं, कोई वर्ग निर्मित पाइथ नहीं है। इसके अलावा 6 बाइट्स
— श्री एक्सकोडर
1
— स्टीवन एच।
प्रत्येक उत्तर के लिए +1 बाइट के साथ ठीक करने योग्य, मोबाइल से उतरने के बाद मैं संपादित करूँगा।
— डेव
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.