गेंदों को डिब्बे में डालने के तरीकों की संख्या की गणना करें

Question

इस कार्य में आपको विषम संख्या में सफेद गेंदें और समान संख्या में काली गेंदें दी जाती हैं। कार्य गेंदों को डिब्बे में डालने के सभी तरीकों को गिनना है ताकि प्रत्येक बिन में प्रत्येक रंग की एक विषम संख्या हो।

उदाहरण के लिए, मान लें कि हमारे पास 3 सफेद गेंदें हैं। विभिन्न तरीके हैं:

(wwwbbb)
(wb)(wb)(wb)

दो अलग-अलग संभावनाओं के लिए।

अगर हमारे पास 5 सफ़ेद गेंदें हैं तो विभिन्न तरीके हैं:

(wwwwwbbbbb)
(wwwbbb)(wb)(wb)
(wwwb)(wbbb)(wb)
(wb)(wb)(wb)(wb)(wb)

आप इनपुट को ले सकते हैं, जो कि एक एकल पूर्णांक है, किसी भी तरह से आप चाहें। आउटपुट सिर्फ एक पूर्णांक है।

आपका कोड पर्याप्त तेज़ होना चाहिए ताकि आपने इसे 11 सफेद गेंदों के लिए पूरा देखा हो।

आप किसी भी भाषा या पुस्तकालय का उपयोग कर सकते हैं जो आपको पसंद है।

Comments

कृपया स्पष्ट करें, क्या हमारा आउटपुट विभिन्न तरीकों की संख्या हो सकता है? यही है, आउटपुट के रूप में एक एकल संख्या?

— orlp

मुझे लगता है कि यह math.stackexchange.com/questions/2736933/… से है। आपको इसका हवाला देना चाहिए @Lembik

— qwr

मुझे लगता है कि आपको गति मानदंड से बाहर निकालना चाहिए या इसे अधिक विशिष्ट बनाना चाहिए। "बहुत तेजी से" बहुत अस्पष्ट है।

— डायलन

आप जानते हैं कि PPCG उपयोगकर्ता काफी पागल हैं कि वे सुपर कंप्यूटर का उपयोग करने के लिए पैसे खर्च करने के बजाय इसे 1 और बाइट लेने के बजाय 11 के लिए गणना करेंगे? तो उनका पैसा क्यों बर्बाद कर रहे हो? :)

— user202729

(टिप्पणी: यह एक जटिल सूत्र के साथ कुशलतापूर्वक पी फ़ंक्शन की गणना करना संभव है । इस फ़ंक्शन की गणना करना भी संभव हो सकता है, एक उपयुक्त सूत्र के साथ।)

— user202729

Answer 1

परी / जीपी, 81 बाइट्स

p=polcoeff;f(n)=p(p(prod(i=1,n,prod(j=1,n,1+(valuation(i/j,2)==0)*x^i*y^j)),n),n)

अधिक दक्षता के लिए, के 1+साथ बदलें 1+O(x^(n+1))+O(y^(n+1))+(पहला Oकार्यकाल पहले से ही पहले से ही बहुत मदद करता है)।

इसे ऑनलाइन आज़माएं! (पहले 86 बाइट संस्करण बेवजह पारेंस की एक जोड़ी के साथ और p=संक्षिप्त नाम के बिना )

पुराना संस्करण, 90 बाइट्स

f(n)=polcoeff(polcoeff(taylor(1/prod(i=0,n,prod(j=0,n,1-x^(2*i+1)*y^(2*j+1))),x,n+1),n),n)

कम्प्यूटिंग f(11)को एक बड़े स्टैक आकार की आवश्यकता होती है, त्रुटि संदेश आपको बताएगा कि इसे कैसे बढ़ाया जाए। यह दो को बदलने के लिए और अधिक कुशल (लेकिन कम golfy) है nकि करने के लिए दूसरा तर्क के रूप में प्रकट prodसाथ (n-1)/2।

Comments

मेरे लिए 13 तक काम करता है!

मुझे लगता है कि संस्करण का उपयोग करने के साथ है (n-1)/2?

— क्रिश्चियन सेवर्स

हाँ, अच्छी बात है।

रुचि से, क्या आपको लगता है कि f (500) की गणना करना संभव है?

F (500) = 21462172450475656565823588442604868476223315183681404 पर गणना करने में कुछ मिनट लगते हैं

— क्रिश्चियन

Answer 2

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

C=lambda l,r,o=():((l,r)>=o)*l*r%2+sum(C(l-x,r-y,(x,y))for x in range(1,l,2)for y in range(1,r,2)if(x,y)>=o)

हमेशा सभी सेटों की गणना करता है, यह सुनिश्चित करता है कि हमेशा सेटों को क्रम में उत्पन्न करके डुप्लिकेट प्राप्त न करें। उचित रूप से तेजी से जब मेमो का उपयोग किया जाता है C = functoools.lru_cache(None)(C), लेकिन यह आवश्यक नहीं है n = 11।

C(num_white, num_black)अपना रिजल्ट पाने के लिए कॉल करें। पहले जोड़े n:

1: 1
3: 2
5: 4
7: 12
9: 32
11: 85
13: 217
15: 539
17: 1316
19: 3146
21: 7374

परिणाम उत्पन्न करने के लिए:

def odd_parts(l, r, o=()):
    if l % 2 == r % 2 == 1 and (l, r) >= o:
        yield [(l, r)]

    for nl in range(1, l, 2):
        for nr in range(1, r, 2):
            if (nl, nr) < o: continue
            for t in odd_parts(l - nl, r - nr, (nl, nr)):
                yield [(nl, nr)] + t

जैसे (7, 7):

[(7, 7)]
[(1, 1), (1, 1), (5, 5)]
[(1, 1), (1, 1), (1, 1), (1, 1), (3, 3)]
[(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)]
[(1, 1), (1, 1), (1, 1), (1, 3), (3, 1)]
[(1, 1), (1, 3), (5, 3)]
[(1, 1), (1, 5), (5, 1)]
[(1, 1), (3, 1), (3, 5)]
[(1, 1), (3, 3), (3, 3)]
[(1, 3), (1, 3), (5, 1)]
[(1, 3), (3, 1), (3, 3)]
[(1, 5), (3, 1), (3, 1)]

Comments

वाकई बहूत बढिया।

Answer 3

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

def f(n):
 r=range;N=n+1;a=[N*[0]for _ in r(N)];R=r(1,N,2);a[0][0]=1
 for i in R:
  for j in R:
   for k in r(N-i):
    for l in r(N-j):a[k+i][l+j]+=a[k][l]
 return a[n][n]

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

जनरेटिंग फंक्शन का सीधा कार्यान्वयन। लंबे लेकिन (कुछ हद तक) कुशल। O (n ⁴ ) समय, O (n ² ) स्मृति।

परिणामी सरणी aमें सभी आकारों के सभी परिणाम शामिल हैं n, हालांकि केवल a[n][n]लौटाया गया है।

Comments

क्या आपके कोड की गणना n के लिए भी है, ब्याज से बाहर? जैसा कि [4] [4] में है।

यह अब तक का सबसे तेज़ समाधान भी है!

@ लिम्बिक [4] [४] = ४ सफेद गेंदों और ४ काली गेंदों को डिब्बे में डालने के तरीकों की संख्या, प्रत्येक बिन में सफेद गेंदों की एक विषम संख्या और काली गेंदों की एक विषम संख्या होती है। वास्तव में रक्षा के रूप में।

— user202729

Answer 4

अजगर 2 ,168 181 बाइट्स

from itertools import*
r,p=range,product
def f(n):
 a,R=eval(`[[0]*n]*n`),r(1,n,2);a[0][0]=1
 for i,j in p(R,R):
  for k,l in p(r(n-i),r(n-j)):a[k+i][l+j]+=a[k][l]
 return a[-1][-1]

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

• User202729 के उत्तर पर आधारित है ।
• संपादित करें: इसे एक स्वतंत्र कार्य किया।
• सहेजे गए 2 बाइट्स user202729 के लिए धन्यवाद ।

Comments

यह एक स्निपेट है (माना जाता है कि nइसमें इनपुट होता है) आपको या तो जोड़ना चाहिए def f(n):या n=input()(इसे एक फंक्शन / फुल प्रोग्राम

— रिस्पांस बनाने के लिए

और ... यह पायथन 2 है, आप दो स्थानों के बजाय एक टैब का उपयोग कर सकते हैं। एक बाइट बचाता है। aहो सकता है eval(`[[0]*n]*n`)(जहां `के लिए खड़ा है repr)।

— user202729