हाइपरक्यूब तत्व

Question

एक फ़ंक्शन या प्रोग्राम लिखें जो एन-डायमेंशनल हाइपरक्यूब के प्रत्येक प्रकार के तत्व (वर्टेक्स, एज, फेस आदि) की संख्या को आउटपुट करता है।

एक उदाहरण के रूप में, 3 आयामी क्यूब में 1 सेल (यानी 1 3-आयामी क्यूब), 6 चेहरे (यानी 6 2-आयामी क्यूब्स), 12 किनारों (यानी 12 2-आयामी क्यूब्स) और 8 कोने (यानी 8 0-आयामी) होते हैं। क्यूब्स)।

हाइपरक्यूब तत्वों के बारे में अधिक विवरण यहां पाया जा सकता है

आप निम्नलिखित OEIS अनुक्रम पर भी नज़र डाल सकते हैं ।

इनपुट

आपका कोड इनपुट के रूप में ले जाएगा (एसटीडीआईएन या एक फ़ंक्शन पैरामीटर या इसी तरह की चीजों के माध्यम से) एक पूर्णांक 0 या उससे अधिक है, जो हाइपरक्यूब का आयाम है।

आपके कोड को सैद्धांतिक रूप से किसी भी इनपुट> = 0 के लिए काम करना है, स्मृति और समय के मुद्दों की उपेक्षा करना (यानी, गति और संभावित स्टैक ओवरफ्लो आपके उत्तर के लिए कोई समस्या नहीं है यदि इनपुट बड़ा है)। परीक्षण मामलों के रूप में दिए गए इनपुट 12 से ऊपर नहीं होंगे।

उत्पादन

आप "उच्चतम आयाम" तत्व से शुरू होने वाले हाइपरक्यूब के सभी तत्वों की सूची को फिर से खोल देंगे। उदाहरण के लिए, एक घन (इनपुट = 3) के लिए, आप सूची [1,6,12,8](1 सेल, 6 चेहरे, 12 किनारों, 8 कोने) का उत्पादन करेंगे।

आउटपुट में सूची का प्रारूप अपेक्षाकृत मुक्त है, जब तक कि यह सूची जैसा दिखता है।

आप परिणाम को STDOUT में आउटपुट कर सकते हैं या इसे किसी फ़ंक्शन से वापस कर सकते हैं।

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

Input = 0
Output = [1]

Input = 1
Output = [1,2]

Input = 3
Output = [1,6,12,8]

Input = 10
Output = [1, 20, 180, 960, 3360, 8064, 13440, 15360, 11520, 5120, 1024]

Input = 12
Output = [1, 24, 264, 1760, 7920, 25344, 59136, 101376, 126720, 112640, 67584, 24576, 4096]

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

Answer 1

सामौ , 8 5 बाइट्स

डेनिस की बदौलत 3 बाइट्स बचाए ।

▌2\$ⁿ

हेक्स डंप (समाउ CP737 एन्कोडिंग का उपयोग करता है):

dd 32 2f 24 fc

स्पष्टीकरण:

▌        read a number
 2\      push the array [1 2]
   $     swap
    ⁿ    take the convolution power

दो वैक्टरों को समझाना दो बहुपदों को गुणा करने के बराबर है । इसी तरह, n-वें कनवल्शन पॉवर को लेना बहुपद की n-th पॉवर लेने के बराबर है।

Answer 2

जे, 13 बाइट्स

[:p.2&^;$&_.5

@ Alephalpha के PARI / GP उत्तर से प्रेरित । इसे Jjs के साथ ऑनलाइन आज़माएं ।

पृष्ठभूमि

द्विपद प्रमेय द्वारा,

इस प्रकार, इनपुट n के लिए आउटपुट में उपरोक्त बहुपद के गुणांक ठीक होते हैं।

कोड

[:p.2&^;$&_.5  Monadic verb. Argument: n

        $&_.5  Yield an array of n instances of -0.5.
    2&^        Compute 2^n.
       ;       Link the results to the left and right.
               This specifies a polynomial of n roots (all -0.5)
               with leading term 2^n.  
[:p.           Convert from roots to coefficients.

Answer 3

MATL, 8 बाइट्स

1i:"2:X+

@ Alephalpha के PARI / GP उत्तर से प्रेरित ।

इसे ऑनलाइन आज़माएं! ( Y+आधुनिक दिन MATL के लिए उपयोग करता है )

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

1        % Push 1.
 i:      % Push [1 ... input].
   "     % Begin for-each loop:
    2:   %   Push [1 2].
      X+ %   Take the convolution product of the bottom-most stack item and [1 2].

Comments

मेरा पहला MATL उत्तर।

— डेनिस

और एक उत्कृष्ट! यह ऐसा सम्मान है कि आपने इस भाषा का इस्तेमाल किया :-)

— लुइस मेंडो

सुंदर। हर कोई अब MATL बैंडवागन पर कूदना शुरू कर रहा है!

— रायरेंग - मोनिका

@rayryeng हम आपको याद करते हैं :-)

— लुइस

Answer 4

MATL , 12 बाइट्स

Q:q"H@^G@Xn*

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

व्याख्या

         % implicit: input number "n"
Q:q      % generate array[0,1,...,n]
"        % for each element "m" from that array
  H@^    % compute 2^m
  G      % push n
  @      % push m
  Xn     % compute n choose m
  *      % multiply
         % implicit: close loop and display stack contents

Answer 5

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

CoefficientList[(1+2x)^#,x]&

मेरा पहला गणितज्ञ उत्तर! यह एक शुद्ध कार्य है जो एलेफाल्फा के PARI / GP उत्तर के समान दृष्टिकोण का उपयोग करता है । हम बहुपद का निर्माण करते हैं (1+2x)^nऔर गुणांक की सूची प्राप्त करते हैं, आरोही शक्ति के क्रम में सूचीबद्ध (अर्थात स्थिर पहले)।

उदाहरण का उपयोग:

> F := CoefficientList[(1+2x)^#,x]&`
> F[10]
{1,20,180,960,3360,8064,13440,15360,11520,5120,1024}

Answer 6

एपीएल, 15 11 बाइट्स

1,(2*⍳)×⍳!⊢

यह एक मोनैडिक फ़ंक्शन ट्रेन है जो दाईं ओर पूर्णांक को स्वीकार करता है और पूर्णांक सरणी देता है।

स्पष्टीकरण, इनपुट कॉलिंग n:

        ⍳!⊢  ⍝ Get n choose m for each m from 1 to n
       ×     ⍝ Multiply elementwise by
  (2*⍳)      ⍝ 2^m for m from 1 to n
1,           ⍝ Tack 1 onto the front to cover the m=0 case

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

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

Answer 7

PARI / GP, 20 15 बाइट्स

n->Vec((x+2)^n)

Answer 8

जेली, 8 बाइट्स

0rð2*×c@

मुझे वास्तव में अपने फोन पर जेली लिखना बंद कर देना चाहिए।

0r            Helper link. Input is n, inclusive range from 0 to n. Call the result r.
  ð           Start a new, dyadic link. Input is r, n.
   2*         Vectorized 2 to the power of r
     ×c@      Vectorized multiply by n nCr r. @ switches argument order.

इसे यहाँ आज़माएँ ।

Answer 9

टीआई-बेसिक, 10 बाइट्स

3^Ansbinompdf(Ans,2/3

Comments

मुझे लगता है कि यह अधिक दिलचस्प समाधानों में से एक है। मुझे नहीं पता कि क्या मैंने कभी सोचा होगा binompdf।

— PhiNotPi 13

Answer 10

CJam ( 17 14 बाइट्स)

ri_3@#_2+@#\b`

ऑनलाइन डेमो

यह दृष्टिकोण साधारण उत्पादक फ़ंक्शन का उपयोग करता है (x + 2)^n। OEIS का उल्लेख है (2x + 1)^n, लेकिन यह प्रश्न विपरीत क्रम में गुणांक को अनुक्रमित करता है। मैं खुद को किक कर रहा हूं कि जब तक मैं अलेफाल्फा को PARI / GP उत्तर के अपडेट को नहीं देख लेता, जो ऐसा ही करता है, तो gf को उलटने के लिए नहीं सोचता।

इस उत्तर में दिलचस्प चाल यह है कि किसी भी संभावित गुणांक से अधिक के आधार पर संचालन करके बहुपद शक्ति संचालन के लिए पूर्णांक शक्तियों का उपयोग किया जाए। सामान्य तौर पर, एक बहुपद को दिया जाता है p(x)जिसके गुणांक सभी गैर-नकारात्मक पूर्णांक से कम होते हैं b, p(b)एक आधार है- bगुणांक का प्रतिनिधित्व (क्योंकि व्यक्तिगत मोनोमियल "ओवरलैप" नहीं करते हैं)। स्पष्ट रूप (x + 2)^nसे गुणांक होंगे जो सकारात्मक पूर्णांक हैं और जो योग हैं 3^n, इसलिए उनमें से प्रत्येक व्यक्तिगत रूप से कम होगा 3^n।

ri     e# Read an integer n from stdin
_3@#   e# Push 3^n to the stack
_2+    e# Duplicate and add 2, giving a base-3^n representation of x+2
@#     e# Raise to the power of n
\b`    e# Convert into a vector of base-3^n digits and format for output

---

वैकल्पिक दृष्टिकोण: 17 बाइट्स पर

1a{0X$2f*+.+}ri*`

ऑनलाइन डेमो

या

1a{0X$+_]:.+}ri*`

ऑनलाइन डेमो

दोनों पिछली पंक्ति को ऑफसेट-एंड-डबल लाइन (समान शैली में पास्कल के त्रिकोण के मानक मैनुअल निर्माण के साथ) जोड़कर काम करते हैं।

बहुपद शक्ति संचालन के लिए कार्टेशियन शक्तियों (पूर्णांक शक्तियों के विपरीत) का उपयोग कर एक "प्रत्यक्ष" दृष्टिकोण, 24 बाइट्स में आता है:

2,rim*{1b_0a*2@#+}%z1fb`

जहां नक्शा असामान्य रूप से जटिल है, वह इसके %मुकाबले छोटा है f:

2,rim*1fb_0af*2@f#.+z1fb`

Answer 11

ईएस 6, 71 बाइट्स

n=>[...Array(n+1)].fill(n).map(b=(n,i)=>!i?1:i>n?0:b(--n,i-1)*2+b(n,i))

सरल पुनरावर्ती सूत्र। प्रत्येक हाइपरक्यूब को पिछले हाइपरक्यूब 1 यूनिट को Nth आयाम के माध्यम से स्थानांतरित करके बनाया जाता है। इसका मतलब यह है कि इकाई के शुरू और अंत में एम-आयामी वस्तुओं को डुप्लिकेट किया जाता है, लेकिन एम-आयामी ऑब्जेक्ट भी एम आयाम में बदलकर एक अतिरिक्त आयाम प्राप्त करते हैं। दूसरे शब्दों में, c(n, m) = c(n - 1, m) * 2 + c(n - 1, m - 1)। (वास्तविक सबमिशन मापदंडों को उलट देता है ताकि सूत्र वांछित क्रम में आउटपुट हो।)

संक्षेप में, मुझे 6 बाइट्स बचाते हुए, पुनरावर्ती फ़ंक्शन को सही तर्क प्रदान करने की fillअनुमति देता mapहै।

Answer 12

अजगर, 10 9 बाइट्स

.<L.cQdhQ

NCr एल्गोरिथ्म का उपयोग करता है जो सभी को लगता है।

Comments

L-map एक बाइट बचाता है:.<L.cQdhQ

— isaacg

Answer 13

05AB1E , 9 बाइट्स

कोड:

WƒNoZNc*,

स्पष्टीकरण:

W          # Push input and store in Z
 ƒ         # For N in range(0, input + 1)
  No       # Compute 2**N
    ZNc    # Compute Z nCr N
       *   # Multiply
        ,  # Pop and print

CP-1252 एन्कोडिंग का उपयोग करता है।

Answer 14

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

n->[2^m*binomial(n,m)for m=0:n]

यह एक लंबोदर फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक सरणी देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

0 से इनपुट n तक प्रत्येक m के लिए , हम मूल n -dimensional हाइपरक्यूब की सीमा पर ( n - m ) -dimensional हाइपरक्यूब की संख्या की गणना करते हैं । विकिपीडिया पर सूत्र का उपयोग करना, यह केवल 2 ^मीटर * ( एन , एम ) चुनें। M = 0 का मामला n- cube को ही संदर्भित करता है, इसलिए आउटपुट इनपुट की परवाह किए बिना 1 से शुरू होता है। किनारों को m = n , कोने द्वारा m = n - 1, आदि द्वारा दिया जाता है ।

Answer 15

रूबी, रेव बी 57 बाइट्स

->n{a=[1]+[0]*n
(n*n).downto(n){|i|a[1+j=i%n]+=2*a[j]}
a}

पिछली बार केवल प्रत्येक बार सरणी के उपयोग किए गए भाग के माध्यम से स्कैन किया गया था। यह पुनरावृत्ति हर पुनरावृत्ति पर पूरे सरणी के माध्यम से स्कैन करता है। यह धीमा है, लेकिन यह बाइट्स बचाता है। 2 के काम करने के लिए 1 लूप का उपयोग करके एक और बाइट को बचाया जाता है।

रूबी, रेव ए 61 बाइट्स

->n{a=[1]+[0]*n
n.times{|i|i.downto(0){|j|a[j+1]+=2*a[j]}}
a}

एक बिंदु से शुरू होता है और पुनरावृति अगला आयाम बनाता है

प्रत्येक पुनरावृत्ति में, प्रत्येक मौजूदा तत्व आयामीता में वृद्धि करता है और इसकी मूल आयामीता के 2 नए तत्व उत्पन्न करता है। उदाहरण के लिए, क्षैतिज विमान में एक वर्ग के लिए जिसे घन बनने के लिए लंबवत रूप से बढ़ाया गया है:

1 चेहरा घन बन जाता है और 1 जोड़ी चेहरे (1 ऊपर, 1 नीचे) उत्पन्न करता है

4 किनारे चेहरे बन जाते हैं और किनारों के 4 जोड़े उत्पन्न करते हैं (4 ऊपर, 4 नीचे)

4 कोने किनारों बन जाते हैं और 4 जोड़े कोने उत्पन्न करते हैं (4 ऊपर, 4 नीचे)

परीक्षण कार्यक्रम में अपराजित

f=->n{a=[1]+[0]*n                  #make an array with the inital point and space for other dimensions
  n.times{|i|                      #iteratively expand dimension by dimension 
    i.downto(0){|j|a[j+1]+=2*a[j]} #iterating downwards (to avoid interferences) add the 2 new elements generated by each existing element.
  }
a}                                 #return the array

p f[gets.to_i]