सम्भावनाएँ - आप कितनी ऊँचाई पर जा सकते हैं?

Question

मैंने पहले एक प्रश्न पूछा था कि एक संभावना को जल्दी और सही तरीके से कैसे गणना करें। हालाँकि, जाहिर है यह बहुत आसान था क्योंकि एक बंद फॉर्म समाधान दिया गया था! यहाँ एक और अधिक कठिन संस्करण है।

यह कार्य वास्तव में एक संभावना की गणना करने के कोड लिखने के बारे में है और जल्दी से । आउटपुट एक सटीक संभाव्यता होना चाहिए जो कि इसके सबसे कम रूप में एक अंश के रूप में लिखा गया हो। वह यह है कि उत्पादन कभी नहीं 4/8बल्कि होना चाहिए 1/2।

कुछ सकारात्मक पूर्णांक के लिए n, लंबाई के 1s और -1s के समान रूप से यादृच्छिक स्ट्रिंग पर विचार nकरें और इसे कॉल करें। अब Aस्वयं की एक प्रति के लिए सहमति दें । A[1] = A[n+1]अगर यह 1 से अनुक्रमण है, A[2] = A[n+2]और इसी तरह। Aअब लंबाई है 2n। अब लंबाई के दूसरे यादृच्छिक स्ट्रिंग पर भी विचार करें nजिनके पहले nमान -1, 0 या 1 हैं, प्रायिकता के साथ 1 / 4,1 / 2, 1/4 प्रत्येक और इसे बी कहते हैं।

अब अलग के Bसाथ के आंतरिक उत्पाद पर विचार करें ।A[1+j,...,n+j]j =0,1,2,...

उदाहरण के लिए, विचार करें n=3। संभावित मान हैं Aऔर Bहो सकता है A = [-1,1,1,-1,...]और B=[0,1,-1]। इस मामले में पहले दो आंतरिक उत्पाद हैं 0और 2।

कार्य

प्रत्येक के लिए , आपके कोड के jसाथ शुरू j=1, इस संभावना को आउटपुट करना चाहिए कि सभी पहले j+1आंतरिक उत्पाद हर के लिए शून्य हैं n=j,...,50।

मार्टिन ब्युटनर द्वारा निर्मित तालिका की नकल करना j=1हमारे लिए निम्न नमूना परिणाम है।

n   P(n)
1   1/2
2   3/8
3   7/32
4   89/512
5   269/2048
6   903/8192
7   3035/32768
8   169801/2097152

स्कोर

आपका स्कोर jमेरे कंप्यूटर पर आपका कोड 1 मिनट में सबसे बड़ा है । थोड़ा स्पष्ट करने के लिए, प्रत्येक jको एक मिनट मिलता है। ध्यान दें कि पिछले लिंक किए गए प्रश्न में डायनामिक प्रोग्रामिंग कोड आसानी से ऐसा करेगा j=1।

टाई ब्रेकर

यदि दो प्रविष्टियों को समान jस्कोर मिलता है, तो जीतने वाली प्रविष्टि वह होगी जो उसके लिए nमेरी मशीन पर एक मिनट में उच्चतम हो जाती है j। यदि इस कसौटी पर भी दो सर्वश्रेष्ठ प्रविष्टियाँ समान हैं तो विजेता सबसे पहले प्रस्तुत किया गया उत्तर होगा।

भाषा और पुस्तकालय

आप किसी भी स्वतंत्र रूप से उपलब्ध भाषा और अपनी पसंद की लाइब्रेरी का उपयोग कर सकते हैं। मुझे आपका कोड चलाने में सक्षम होना चाहिए ताकि कृपया अपने कोड को लिनक्स में चलाने / संकलित करने के लिए एक पूर्ण विवरण शामिल करें यदि संभव हो तो।

मेरी मशीन मेरी मशीन पर टाइमिंग चलाई जाएगी। यह एक मानक ubuntu एक AMD FX-8350 आठ-कोर प्रोसेसर पर स्थापित है। इसका मतलब यह भी है कि मुझे आपका कोड चलाने में सक्षम होना चाहिए।

प्रविष्टियां जीतना

• j=2मिच श्वार्ट्ज द्वारा पायथन में ।
• j=2में अजगर feersum द्वारा। वर्तमान में सबसे तेज प्रविष्टि है।

Comments

यदि प्रश्न किसी भी तरह से अस्पष्ट है, तो कृपया मुझे बताएं ताकि मैं इसे जल्दी से ठीक कर सकूं।

आप अब तक मेरे पसंदीदा प्रश्न पूछने वाले हैं। तो फिर, मैं बिल्कुल और जल्दी कंप्यूटिंग मूल्यों के लिए एक बात है ।

— प्रिमो

@primo धन्यवाद! क्या इसका मतलब है कि हम आरपीथॉन में जवाब की उम्मीद कर सकते हैं? :)

क्या आप इस प्रश्न और दूसरे के बीच अंतर कर सकते हैं?

— kirbyfan64sos

@ kirbyfan64sos अन्य केवल अनिवार्य रूप से `j = 1` के लिए एक ही सवाल है।

Answer 1

पायथन 2, जे = 2

मैंने j = 2 के लिए एक प्रकार का 'क्लोज्ड फॉर्म' खोजने की कोशिश की। शायद मैं इसकी एक MathJax छवि बना सकता था, हालांकि यह सभी सूचकांक के साथ वास्तव में बदसूरत होगा। मैंने सूत्र को जांचने के लिए ही इस अडॉप्टेड कोड को लिखा था। इसे पूरा होने में 1 सेकंड का समय लगता है। परिणाम मिच श्वार्ट्ज के कोड के साथ मेल खाते हैं।

ch = lambda n, k: n>=k>=0 and fac[n]/fac[k]/fac[n-k]
W = lambda l, d: ch(2*l, l+d)
P = lambda n, p: n==0 or ch(n-1, p-1)
ir = lambda a,b: xrange(a,b+1)

N = 50
fac = [1]
for i in ir(1,4*N): fac += [i * fac[-1]]

for n in ir(2, N):
    s = 0
    for i in ir(0,n+1):
     for j in ir(0,min(i,n+1-i)):
      for k in ir(0,n+i%2-i-j):
       t=(2-(k==0))*W(n+i%2-i-j,k)*W(i-(j+i%2),k)*W(j,k)**2*P(i,j+i%2)*P(n+1-i,j+1-i%2)
       s+=t
    denp = 3 * n - 1
    while denp and not s&1: denp -= 1; s>>=1
    print n, '%d/%d'%(s,1<<denp)

एक अनुक्रम पर विचार करें जहां ith सदस्य eयदि A [i] == A [i + 1] या nयदि A [i]! = A [i + 1] है। iकार्यक्रम में ns की संख्या है । यदि iहै भी, तो अनुक्रम को इसके साथ शुरू और समाप्त होना चाहिए e। यदि iविषम है, तो अनुक्रम को शुरू और समाप्त होना चाहिए n। अनुक्रम को लगातार eएस या nएस के रन की संख्या से वर्गीकृत किया जाता है । कर रहे हैं j+ 1 एक के और jअन्य की।

जब यादृच्छिक की पैदल दूरी पर विचार 3 आयामों के लिए बढ़ा दिया गया है, वहाँ एक दुर्भाग्यपूर्ण समस्या में चलने के लिए 4 संभव दिशाओं (से प्रत्येक के लिए एक देखते हैं कि है ee, en, ne, या nnजो साधन) वे रैखिक रूप से निर्भर नहीं हैं। इसलिए kइंडेक्स एक दिशाओं (1, 1, 1) में उठाए गए कदमों की संख्या पर आधारित है। फिर एक सटीक संख्या में कदम होंगे जो इसे रद्द करने के लिए अन्य 3 दिशाओं में उठाए जाने चाहिए।

P (n, p) n ऑब्जेक्ट्स के आदेशित विभाजन की संख्या को p भागों में देता है। W (l, d) lबिल्कुल दूरी की यात्रा करने के लिए कदमों के एक यादृच्छिक चलने के लिए कई तरीके देता है d। जैसा कि पहले बाएं स्थानांतरित करने का 1 मौका है, 1 सही चलने का मौका है और 2 रहने के लिए है।

Comments

धन्यवाद! सूत्र की एक छवि वास्तव में बहुत अच्छी होगी।

विवरण के लिए आपका धन्यवाद। आप इसे सरल देखो! मैंने अभी आपकी टिप्पणी देखी कि आप इसका समाधान कर सकते हैं j=3। वह अद्भुत होगा!

Answer 2

अजगर, जे = २

पिछले प्रश्न के j = 1मेरे उत्तर के लिए गतिशील प्रोग्रामिंग दृष्टिकोण को उच्चतर के लिए काम करने के लिए कई संशोधनों की आवश्यकता नहीं है j, लेकिन जल्दी से धीमा हो जाता है। संदर्भ के लिए तालिका:

n   p(n)

2   3/8
3   11/64
4   71/512
5   323/4096
6   501/8192
7   2927/65536
8   76519/2097152
9   490655/16777216
10  207313/8388608

और कोड:

from time import*
from fractions import*
from collections import*

def main():
    N_MAX=50

    T=time()

    n=2
    Y=defaultdict(lambda:0)
    numer=0

    for a1 in [1]:
        for b1 in (1,0):
            for a2 in (1,-1):
                for b2 in (1,0,0,-1):
                    if not a1*b1+a2*b2 and not a2*b1+a1*b2:
                        numer+=1
                    Y[(a1,a2,b1,b2,a1*b1+a2*b2,a2*b1,0)]+=1

    thresh=N_MAX-1

    while time() <= T+60:
        print('%d %s'%(n,Fraction(numer,8**n/4)))

        if thresh<2:
            print('reached N_MAX with %.2f seconds remaining'%(T+60-time()))
            return

        n+=1
        X=Y
        Y=defaultdict(lambda:0)
        numer=0

        for a1,a2,b1,b2,s,t,u in X:
            if not ( abs(s)<thresh and abs(t)<thresh+1 and abs(u)<thresh+2 ):
                continue

            c=X[(a1,a2,b1,b2,s,t,u)]

            # 1,1

            if not s+1 and not t+b2+a1 and not u+b1+a1*b2+a2: numer+=c
            Y[(a1,a2,b2,1,s+1,t+b2,u+b1)]+=c

            # -1,1

            if not s-1 and not t-b2+a1 and not u-b1+a1*b2+a2: numer+=c
            Y[(a1,a2,b2,1,s-1,t-b2,u-b1)]+=c

            # 1,-1

            if not s-1 and not t+b2-a1 and not u+b1+a1*b2-a2: numer+=c
            Y[(a1,a2,b2,-1,s-1,t+b2,u+b1)]+=c

            # -1,-1

            if not s+1 and not t-b2-a1 and not u-b1+a1*b2-a2: numer+=c
            Y[(a1,a2,b2,-1,s+1,t-b2,u-b1)]+=c

            # 1,0

            c+=c

            if not s and not t+b2 and not u+b1+a1*b2: numer+=c
            Y[(a1,a2,b2,0,s,t+b2,u+b1)]+=c

            # -1,0

            if not s and not t-b2 and not u-b1+a1*b2: numer+=c
            Y[(a1,a2,b2,0,s,t-b2,u-b1)]+=c

        thresh-=1

main()

यहाँ हम के पहले दो तत्वों का ट्रैक रख रहे हैं A, के अंतिम दो तत्वों B(जहां b2पिछले तत्व है), और के भीतर उत्पादों (A[:n], B), (A[1:n], B[:-1]), और (A[2:n], B[:-2])।

Comments

.... 21.20 सेकंड के साथ N_MAX तक पहुंच गया