ก่อนหน้านี้ฉันถามคำถามเกี่ยวกับวิธีคำนวณความน่าจะเป็นได้อย่างรวดเร็วและแม่นยำ อย่างไรก็ตามเห็นได้ชัดว่ามันง่ายเกินไปที่จะให้โซลูชันแบบปิด! นี่คือรุ่นที่ยากขึ้น

งานนี้เป็นเรื่องเกี่ยวกับการเขียนโค้ดเพื่อคำนวณความน่าจะเป็นตรงและรวดเร็ว ผลลัพธ์ควรเป็นความน่าจะเป็นที่แม่นยำที่เขียนเป็นเศษส่วนในรูปแบบที่ลดลงมากที่สุด นั่นคือไม่ควรเอาท์พุท4/8แต่จะดี1/2กว่า

สำหรับจำนวนเต็มบวกnพิจารณาสตริงสุ่มอย่างสม่ำเสมอของ 1s และ -1s ของความยาวnและเรียกมันว่า A ตอนนี้เชื่อมต่อกับ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

ตอนนี้พิจารณาสินค้าด้านในของBที่มีแตกต่างกันA[1+j,...,n+j]j =0,1,2,...

n=3ตัวอย่างเช่นพิจารณา ค่าที่เป็นไปได้AและBอาจจะเป็นและA = [-1,1,1,-1,...] B=[0,1,-1]ในกรณีนี้เป็นครั้งแรกผลิตภัณฑ์ชั้นสองเป็นและ02

งาน

สำหรับแต่ละjเริ่มต้นด้วยj=1รหัสของคุณควรส่งออกน่าจะเป็นที่ทุกคนแรกผลิตภัณฑ์ภายในเป็นศูนย์สำหรับทุกj+1n=j,...,50

คัดลอกตารางที่ผลิตโดย Martin Büttnerเพราะ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หากผลงานที่ดีที่สุดสองรายการเท่ากันในเกณฑ์นี้เช่นกันผู้ชนะจะได้รับคำตอบก่อน

ภาษาและห้องสมุด

คุณสามารถใช้ภาษาและไลบรารี่ที่คุณต้องการได้ฟรี ฉันจะต้องสามารถเรียกใช้รหัสของคุณดังนั้นโปรดรวมคำอธิบายแบบเต็มสำหรับวิธีการเรียกใช้ / รวบรวมรหัสของคุณใน linux ถ้าเป็นไปได้ทั้งหมด

My Machineเวลาของฉันจะทำงานบนเครื่องของฉัน นี่คือการติดตั้ง Ubuntu มาตรฐานบนโปรเซสเซอร์ AMD FX-8350 Eight-Core นี่ก็หมายความว่าฉันต้องสามารถเรียกใช้รหัสของคุณได้

รายการที่ชนะ

• j=2ในPythonโดย Mitch Schwartz
• j=2ในPythonโดย feersum ขณะนี้รายการที่เร็วที่สุด

Python 2, j = 2

ฉันพยายามค้นหา 'แบบฟอร์มปิด' สำหรับ j = 2 บางทีฉันอาจสร้างภาพ MathJax ของมันแม้ว่ามันจะน่าเกลียดจริง ๆ กับดัชนีที่เล่นซอ ฉันเขียนโค้ดที่ไม่ได้เพิ่มประสิทธิภาพนี้เพื่อทดสอบสูตรเท่านั้น ใช้เวลาประมาณ 1 วินาทีจึงจะเสร็จสมบูรณ์ ผลลัพธ์ตรงกับรหัสของ Mitch Schwartz

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ลำดับจะถูกจัดประเภทเพิ่มเติมตามจำนวนการรันของes หรือns ที่ติดกัน มี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 เพื่ออยู่ต่อ

Python, j = 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])