एन-वें बेल नंबर को आउटपुट करें

13

एक बेल संख्या ( OEIS A000110 ) तरीके n लेबल (विशिष्ट) तत्वों का एक सेट विभाजन की संख्या है। 0 बेल नंबर को 1 के रूप में परिभाषित किया गया है।

आइए कुछ उदाहरण देखें (मैं विभाजन के लिए सबसेट और ब्रेसिज़ को चिह्नित करने के लिए कोष्ठक का उपयोग करता हूं):

1: {1}
2: {[1,2]}, {[1],[2]}
3: {[1,2,3]}, {[1,2],[3]}, {[1,3],[2]}, {[2,3],[1]}, {[1],[2],[3]}

बेल नंबर की गणना करने के कई तरीके हैं , और आप उनमें से किसी का उपयोग करने के लिए स्वतंत्र हैं। एक तरह से यहाँ वर्णित किया जाएगा:

बेल संख्याओं की गणना करने का सबसे आसान तरीका द्विपदीय गुणांकों के लिए पास्कल के त्रिकोण के समान एक त्रिकोण का उपयोग करना है। बेल नंबर त्रिकोण के किनारों पर दिखाई देते हैं। 1 से शुरू होकर, त्रिभुज में प्रत्येक नई पंक्ति का निर्माण पहली प्रविष्टि के रूप में पिछली पंक्ति में अंतिम प्रविष्टि लेकर किया जाता है, और फिर प्रत्येक नई प्रविष्टि को इसके बाएं पड़ोसी और इसके ऊपरी बाएं पड़ोसी में सेट किया जाता है:

1
1    2
2    3    5
5    7   10   15
15  20   27   37   52

आप 0-इंडेक्सिंग या 1-इंडेक्सिंग का उपयोग कर सकते हैं। यदि आप 0-इंडेक्सिंग का उपयोग करते हैं, तो 3आउटपुट का एक इनपुट होना चाहिए 5, लेकिन 2यदि आप 1-इंडेक्सिंग का उपयोग करते हैं तो आउटपुट करना चाहिए ।

आपका प्रोग्राम 15 वीं बेल नंबर तक काम करना चाहिए, आउटपुट करना 1382958545। सिद्धांत रूप में, आपका कार्यक्रम बड़ी संख्या (दूसरे शब्दों में, समाधान को हार्डकोड नहीं) करने में सक्षम होना चाहिए। EDIT: आपको 0 (अनुक्रमणिका के लिए) या 1 (1-अनुक्रमण के लिए) के इनपुट को संभालने की आवश्यकता नहीं है क्योंकि यह त्रिभुज विधि द्वारा गणना नहीं है।

परीक्षण के मामले (0-अनुक्रमण मानते हुए):

0 ->  1 (OPTIONAL)
1 ->  1 
2 ->  2 
3 ->  5 
4 ->  15 
5 ->  52 
6 ->  203 
7 ->  877 
8 ->  4140 
9 ->  21147 
10 -> 115975 
11 -> 678570 
12 -> 4213597 
13 -> 27644437 
14 -> 190899322 
15 -> 1382958545

बिल्ट-इन मेथड (जैसे कि बेल्बी [एन] वोल्फ्रैम लैंग्वेज में) का उपयोग करने वाले उत्तर जो सीधे बेल नंबर का उत्पादन करते हैं, गैर-प्रतिस्पर्धी होंगे।

सबसे छोटा कोड (बाइट्स में) जीतता है।

code-golf  math 
— धांधली
स्रोत
यदि आप 0-इंडेक्सिंग का उपयोग करते हैं, तो इनपुट का 3आउटपुट होना चाहिए5 यह 15सही होगा? और 1-इंडेक्सिंग के साथ यह आउटपुट होगा5
— लुईस मेन्डो
इसके पीछे तर्क 0-इंडेक्स के रूप में 0 वें नंबर की संख्या को 0-इंडेक्सिंग में और इंडेक्स 1 को 1-इंडेक्सिंग में गिना जाता था। आपका रास्ता अधिक स्पष्ट हो सकता है, लेकिन मौजूदा उत्तर उसी तरह काम करते हैं, इसलिए मैं इसे अब नहीं बदल सकता। मैं बस कुछ ही घंटे पहले इस साइट में शामिल हो गए
— धांधली
लेकिन आप कहते हैं कि 1-इंडेक्सिंग के साथ, इनपुट 3आउटपुट होना चाहिए 2। फिर 11-इंडेक्सिंग के साथ इनपुट क्या देगा ?
— लुइस मेंडो
1 -> 1, 2 -> 1, 3 -> 2 (0, 1, और 2 बेल नंबर के अनुसार) 0 के विपरीत -> 1, 1 - 1 - 2,> - 2 शायद मैं गलत का उपयोग कर रहा हूँ शब्दावली
— धांधली
मुझे लगता है कि मैंने इसे पा लिया है। आपके उदाहरण तालिका और आउटपुट में पहले 1 गायब है, जिसने मुझे भ्रमित किया
— लुईस मेन्डो

जवाबों:

2

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

ṖµṀcæ.߀‘

यह सूत्र का उपयोग करता है

सूत्र

जब भी n <2 को बंद किया जाता है ।

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

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

ṖµṀcæ.߀‘  Main link. Argument: n

Ṗ          Pop; yield A := [1, ..., n-1].
 µ         Begin a new, monadic chain with argument A.
  Ṁ        Maximum; yield n-1.
   c       Combinatons; compute (n-1)C(k) for each k in A.
      ߀   Recursively map the main link over A.
    æ.     Take the dot product of the results to both sides.
        ‘  Increment; add 1 to the result.
— डेनिस
स्रोत
8

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

f=(n,a=[b=1])=>n--?f(n,[b,...a.map(e=>b+=e)]):b
f=(n,a=[b=1])=>--n?f(n,[b,...a.map(e=>b+=e)]):b

पहला 0-अनुक्रमित है, दूसरा 1-अनुक्रमित है।

— नील
स्रोत
5

आर , 31 बाइट्स

sum(gmp::Stirling2.all(scan()))

दूसरी तरह के सूत्र की स्टर्लिंग संख्या का उपयोग करता है और उन संख्याओं को gmp पैकेज के साथ गणना करता है ; स्टडिन से पढ़ता है और एक बड़े पूर्णांक के रूप में मान लौटाता है; 0 के लिए विफल; 1 अनुक्रमित।

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

जेली , 14 12 11 बाइट्स

ṫ0;⁸+\
1Ç¡Ḣ

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

डायनामिक इनपुट के¡ साथ जेली के मजबूत बिंदुओं को बिल्कुल हिट नहीं किया ,Ṫ हमेशा सरणी को संशोधित करने और एक पूर्ववर्ती परमाणु (एक-बाइट ;@या रिवर्स- ṭ) की कमी ।

— PurkkaKoodari
स्रोत
3

CJam (19 बाइट्स)

Xa{X\{X+:X}%+}qi*0=

ऑनलाइन डेमो

विच्छेदन

Xa         e# Start with an array [1]
{          e# Repeat...
  X\       e#   Put a copy of X under the current row
  {X+:X}%  e#   Map over x in row: push (X+=x)
  +        e#   Prepend that copy of last element of the previous row to get the next row
}
qi*        e# ... input() times
0=         e# Select the first element
— पीटर टेलर
स्रोत
3

MATL , 14 बाइट्स

:dtEw1Zh1Ze/Yo

इनपुट 0-आधारित है। इसे ऑनलाइन आज़माएं!

व्याख्या

यह सूत्र का उपयोग करता है

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

जहाँ p F q ( a 1 , ..., a p ; b 1 , ..., b q ; x ) सामान्यीकृत हाइपरजोमेट्रिक फ़ंक्शन है ।

:      % Implictly input n. Push array [1 2 ... n]
d      % Consecutive differences: array [1 ... 1] (n-1 entries)
tE     % Duplicate, multiply by 2: array [2 ... 2] (n-1 entries)
w      % Swap
1      % Push 1
Zh     % Hypergeometric function
1Ze    % Push number e
/      % Divide
Yo     % Round (to prevent numerical precision issues). Implicitly display
— लुइस मेंडो
स्रोत
3

पायथन , 42 बाइट्स

f=lambda n,k=0:n<1or k*f(n-1,k)+f(n-1,k+1)

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

पुनरावर्ती सूत्र nतत्वों को विभाजन में रखने से आता है । बदले में प्रत्येक तत्व के लिए, हम यह तय करते हैं कि इसे जगह दें:

  • मौजूदा विभाजन में, जिनमें से kविकल्प हैं
  • एक नया विभाजन शुरू करने के लिए, जो kभविष्य के तत्वों के लिए विकल्पों की संख्या को बढ़ाता है

किसी भी तरह nसे तत्वों की शेष संख्या घट जाती है। तो, हमारे पास पुनरावर्ती सूत्र है f(n,k)=k*f(n-1,k)+f(n-1,k+1)और f(0,k)=1, f(n,0)n-वें बेल नंबर के साथ।

— XNOR
स्रोत
2

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

s=lambda n,k:n*k and k*s(n-1,k)+s(n-1,k-1)or n==k
B=lambda n:sum(s(n,k)for k in range(n+1))

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

B (n) की गणना दूसरे प्रकार के स्टर्लिंग संख्या के योग के रूप में की जाती है।

— चास ब्राउन
स्रोत
यह एक अच्छा उपाय है। ध्यान दें कि दूसरी तरह की स्टर्लिंग संख्याओं के लिए बिल्ट का उपयोग करके बेल संख्याओं की गणना करने की अनुमति दी जाएगी (यदि मैथेमेटिका या इसी तरह का उपयोग करके)
— धांधली
आप सीधे दो बाइट्स की परिभाषा में बचा सकते हैं s: चूंकि पुनरावर्ती कॉल हमेशा कम करते हैं nऔर kआपके द्वारा *kपहले कार्यकाल में कोई विभाजन नहीं खो सकता है ।
— पीटर टेलर
या आप पूरे पंक्तियों पर काम करते हुए एक भेड़ के बच्चे को चपटा करके एक गुच्छा बचा सकते हैं:B=lambda n,r=[1,0]:n and B(n-1,[k*r[k]+r[k-1]for k in range(len(r))]+[0])or sum(r)
— पीटर टेलर
जैसा कि आपका कार्य Bपुनरावर्ती नहीं है और यह आपका अंतिम उत्तर है, आप 2 बाइट बचाने के B=लिए छोड़ सकते हैं
— फेलिप नारदी बतिस्ता
2

MATLAB, 128 103 बाइट्स

function q(z)
r(1,1)=1;for x=2:z
r(x,1)=r(x-1,x-1);for y=2:x
r(x,y)=r(x,y-1)+r(x-1,y-1);end
end
r(z,z)

सुंदर आत्म व्याख्यात्मक। एक पंक्ति के अंत में एक अर्धविराम को छोड़ना परिणाम को प्रिंट करता है।

लुइस मेंडो की बदौलत 25 बाइट बच गईं।

— धांधली
स्रोत
2

ओम , 15 बाइट्स

2°M^┼ⁿ^!/Σ;αê/≈

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

Dobinski के फ़ोरमला का उपयोग करता है (यहां तक ​​कि B (0) yay के लिए भी काम करता है )।

व्याख्या

2°M^┼ⁿ^!/Σ;αê/≈
2°        ;     # Push 100
  M             # Do 100 times...
   ^             # Push index of current iteration
    ┼ⁿ           # Take that to the power of the user input
      ^!         # Push index factorial
        /        # Divide
         Σ       # Sum stack together
           αê   # Push e (2.718...)
             /  # Divide
              ≈ # Round to nearest integer (Srsly why doesn't 05AB1E have this???)
— Datboi
स्रोत
2

पायथन (79 बाइट्स)

B=lambda n,r=[1]:n and B(n-1,[r[-1]+sum(r[:i])for i in range(len(r)+1)])or r[0]

पायथन 2 में ऑनलाइन डेमो , लेकिन यह पायथन 3 में भी काम करता है।

यह एक गोल्फ लूप के लिए एक पुनरावर्ती लंबोदा का उपयोग करके ऐटकेन के त्रिकोण का निर्माण करता है।

— पीटर टेलर
स्रोत
1

जे, 17 बाइट्स

0{]_1&({+/\@,])1:

त्रिभुज गणना पद्धति का उपयोग करता है।

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

व्याख्या

0{]_1&({+/\@,])1:  Input: integer n
               1:  The constant 1
  ]                Identity function, get n
   _1&(       )    Call this verb with a fixed left argument of -1 n times
                   on itself starting with a right argument [1]
             ]       Get right argument
       {             Select at index -1 (the last item)
            ,        Join
        +/\@         Find the cumulative sums
0{                 Select at index 0 (the first item)
— मील की दूरी पर
स्रोत
1

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

from math import*
f=lambda n:ceil(sum(k**n/e/factorial(k)for k in range(2*n)))

मैंने गणना के लिए एक अलग मार्ग का प्रयास करने और जाने का फैसला किया। यह डोबिंस्की के सूत्र का उपयोग करता है, 0-अनुक्रमित, 0 के लिए काम नहीं करता है।

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

— C मैकआवॉय
स्रोत
1
जैसा कि आपका कार्य fपुनरावर्ती नहीं है, आप छोड़ सकते हैं f=और 2 बाइट्स बचा
— फेलिप नारदी बतिस्ता
1

पायथन 3 , 68 60 बाइट्स

त्रिकोण का सरल पुनरावर्ती निर्माण, लेकिन यह व्यावहारिक उद्देश्यों के लिए बेतहाशा अक्षम है। 15 वीं बेल नंबर तक की गणना से TIO समय-समय पर समाप्त हो जाता है, लेकिन यह मेरी मशीन पर काम करता है।

यह 1-इंडेक्सिंग का उपयोग करता है, और True1 के बजाय रिटर्न करता है।

f=lambda r,c=0:r<1or c<1and f(r-1,r-1)or f(r-1,c-1)+f(r,c-1)

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

8 बाइट बचाने के लिए @FelipeNardiBatista को धन्यवाद!

— चेस वोगेली
स्रोत
60 बाइट्स । संख्या (0,1) के बजाय बूलियन्स वापस आना अजगर में स्वीकार्य है
— फेलिप नारदी बतिस्ता
1

PHP , 72 बाइट्स

पुनरावर्ती कार्य 1-अनुक्रमित 

function f($r,$c=0){return$r?$c?f($r-1,$c-1)+f($r,$c-1):f($r-1,$r-2):1;}

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

PHP , 86 बाइट्स

0 अनुक्रमित 

for(;$r++<$argn;)for($c=~0;++$c<$r;)$l=$t[$r][$c]=$c?$l+$t[$r-1][$c-1]:($l?:1);echo$l;

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

PHP , 89 बाइट्स

पुनरावर्ती कार्य 0-अनुक्रमित 

function f($r,$s=NULL){$c=$s??$r-1;return$r>1?$c?f($r-1,$c-1)+f($r,$c-1):f($r-1,$r-2):1;}

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

— जार्ग हुल्सरमन
स्रोत
1

ऐलिस , 22 बाइट्स

/oi
\1@/t&wq]&w.q,+k2:

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

यह त्रिभुज विधि का उपयोग करता है। N = 0 के लिए, यह इसके बजाय B (1) की गणना करता है, जो आसानी से B (0) के बराबर है।

व्याख्या

यह उन कार्यक्रमों के लिए एक मानक टेम्प्लेट है जो ऑर्डिनल मोड में इनपुट लेते हैं, इसे कार्डिनल मोड में संसाधित करते हैं, और परिणाम को ऑर्डिनल मोड में आउटपुट करते हैं। एक 1इनपुट के नीचे ढेर पर है कि मूल्य डाल करने के लिए टेम्पलेट में जोड़ा गया है।

कार्यक्रम त्रिभुज की प्रत्येक पंक्ति की गणना करने के लिए स्टैक को एक विस्तारित गोलाकार कतार के रूप में उपयोग करता है। पहले के प्रत्येक पुनरावृत्ति के दौरान, स्टैक के नीचे एक निहित शून्य एक स्पष्ट शून्य हो जाता है।

1     Append 1 to the implicit empty string on top of the stack
i     Get input n
t&w   Repeat outer loop that many times (push return address n-1 times)
q     Get tape position (initially zero)
]     Move right on tape
&w    On iteration k, push this return address k-1 times
      The following inner loop is run once for each entry in the next row
.     Duplicate top of stack (the last number calculated so far)
q,    Move the entry k spaces down to the top of the stack: this is the appropriate entry
      in the previous row, or (usually) an implicit zero if we're in the first column
+     Add these two numbers
k     Return to pushed address: this statement serves as the end of two loops simultaneously
2:    Divide by two: see below
o     Output as string
@     Terminate

पहली पुनरावृत्ति शून्य के एक प्रारंभिक स्टैक गहराई को प्रभावी ढंग से मानती है, स्टैक के शीर्ष पर आवश्यक 1 के बावजूद। नतीजतन, 1 छोर खुद को जोड़ा जा रहा है, और पूरे त्रिकोण को 2 से गुणा किया जाता है। अंतिम परिणाम को 2 से विभाजित करने से सही उत्तर मिलता है।

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