Daha önce bir olasılığın hızlı ve doğru bir şekilde nasıl hesaplanacağına dair bir soru sordum . Ancak, kapalı bir form çözümü verildiği için çok kolay oldu! İşte daha zor bir versiyon.

Bu görev, bir olasılığı tam ve hızlı bir şekilde hesaplamak için kod yazmakla ilgilidir . Çıktı, en düşük biçimde kesir olarak yazılan kesin bir olasılık olmalıdır. Asla çıktı almamalı, daha 4/8doğrusu 1/2.

Bazı pozitif tamsayılar için n, 1s ve -1s uzunlukta eşit rastgele bir dize düşünün ve A olarak nadlandırın.A kendi kopyasını . Yani A[1] = A[n+1]endeksleme eğer 1'den, A[2] = A[n+2]vb. Aşimdi uzunluğu var 2n. Şimdi n, ilk ndeğerleri her biri 1 / 4,1 / 2, 1/4 olasılıkla -1, 0 veya 1 olan ikinci bir rastgele uzunluk dizesini düşünün ve B olarak adlandırın.

Şimdi iç ürünü incelemek Bile A[1+j,...,n+j]farklı için j =0,1,2,....

Örneğin, düşünün n=3. İçin olası değerler AveB olabilir A = [-1,1,1,-1,...]ve B=[0,1,-1]. Bu durumda ilk iki iç ürün 0ve şeklindedir 2.

Görev

Her biri için j , j=1kodunuzla başlayarak , tüm ilk j+1iç ürünlerin her biri için sıfır olma olasılığını çıkarmalıdır n=j,...,50.

Martin Büttner tarafından üretilen masanın j=1 aşağıdaki örnek sonuçlara sahibiz.

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

Puan

Puanınız jkodunuzun bilgisayarımdaki 1 dakika içinde tamamladığı en büyük puan . Biraz açıklığa kavuşturmak için, her birij biri bir dakika alır. Önceki bağlantılı sorudaki dinamik programlama kodunun bunu kolayca yapacağını unutmayın j=1.

Kravat kırıcı

İki giriş aynı jpuanı alırsa, kazanan giriş bunun için nmakinemde bir dakika içinde en yüksek olan giriş olacaktır .j . En iyi iki giriş de bu kritere eşitse, kazanan ilk önce cevap olacaktır.

Diller ve kütüphaneler

Ücretsiz olarak istediğiniz dil ve kütüphaneleri kullanabilirsiniz. Kodunuzu çalıştırmak mümkün olmalıdır bu yüzden mümkün olduğunca linux kodunu çalıştırmak / derlemek için tam bir açıklama ekleyin.

Makinem zamanlamaları benim makinede işletilecek. Bu, AMD FX-8350 Sekiz Çekirdekli İşlemciye standart bir ubuntu yüklemesidir. Bu ayrıca kodunuzu çalıştırabilmem gerektiği anlamına gelir.

Kazanan katılımlar

• j=2içinde Python Mitch Schwartz tarafından.
• j=2içinde Python feersum tarafından. Şu anda en hızlı giriş.

Python 2, j = 2

J = 2 için bir tür 'kapalı form' bulmaya çalıştım. Belki de bir MathJax görüntüsü yapabilirim, ancak tüm indekslerle uğraşmak gerçekten çirkin olurdu. Bu optimize edilmemiş kodu sadece formülü test etmek için yazdım. Tamamlanması yaklaşık 1 saniye sürer. Sonuçlar Mitch Schwartz'ın koduyla eşleşir.

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)

eİ elemanının A [i] == A [i + 1] veya nA [i]! = A [i + 1] olduğu bir dizi düşünün . iprogramda ns sayısıdır . Eşitse i, dizi ile başlamalı ve bitmelidir e. Eğer igarip, sıra başlar ve sona ermelidir n. Sekanslar ayrıca ardışık es veya ns'nin çalışma sayısına göre sınıflandırılır . jBirinin ve diğerinin + 1'i var j.

Rastgele yürüme fikri 3 boyutlara uzatıldığında, yürümeye 4 olası yönü (her biri için bir tane talihsiz bir sorunu vardır ee, en, neya da nnbu aracı) bunlar doğrusal bağımlı değildir. Böylecek yönlerde (1, 1, 1) birinde atılan adımların sayısı üzerinden endeks özetliyor. Ardından, iptal etmek için diğer 3 yönde atılması gereken tam bir adım olacaktır.

P (n, p) n nesnenin p parçalarına sıralı bölüm sayısını verir. W (l, d) l, tam olarak bir mesafe katetmek için rastgele bir basamak yürüyüşü için yol sayısını verir d. Daha önce olduğu gibi 1 sola hareket etme şansı var, 1 sağa hareket etme şansı var ve 2 tane kalmaya devam ediyor.

Python, j = 2

İçin dinamik programlama yaklaşımı j = 1benim de cevap önceki soruya üzeri için çalışmalarına birçok değişiklikler gerekmez j, ama yavaş hızla alır. Referans tablosu:

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

Ve kod:

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()

Burada ilk iki elemanlarının tam tutuyor A, son iki element B(burada b2son öğedir) ve iç ürünleri (A[:n], B), (A[1:n], B[:-1])ve (A[2:n], B[:-2]).