Trước đây tôi đã hỏi một câu hỏi về cách tính xác suất nhanh chóng và chính xác. Tuy nhiên, rõ ràng là quá dễ dàng khi một giải pháp dạng kín được đưa ra! Đây là một phiên bản khó hơn.

Nhiệm vụ này là về viết mã để tính xác suất chính xác và nhanh chóng . Đầu ra phải là một xác suất chính xác được viết dưới dạng phân số ở dạng giảm nhất. Đó là nó không bao giờ nên đầu ra 4/8mà là 1/2.

Đối với một số nguyên dương n, hãy xem xét một chuỗi ngẫu nhiên đồng nhất có độ dài 1s và -1 nvà gọi nó là A. Bây giờ nối với Amột bản sao của chính nó. Đó là A[1] = A[n+1]nếu lập chỉ mục từ 1, A[2] = A[n+2]v.v. Abây giờ có chiều dài 2n. Bây giờ cũng xem xét một chuỗi độ dài ngẫu nhiên thứ hai ncó ncác giá trị đầu tiên là -1, 0 hoặc 1 với xác suất 1 / 4,1 / 2, 1/4 mỗi và gọi nó là B.

Bây giờ hãy xem xét các sản phẩm bên trong Bvới A[1+j,...,n+j]cho khác nhau j =0,1,2,....

Ví dụ, xem xét n=3. Các giá trị có thể cho Avà Bcó thể là A = [-1,1,1,-1,...]và B=[0,1,-1]. Trong trường hợp này, hai sản phẩm đầu tiên bên trong là 0và 2.

Bài tập

Đối với mỗi j, bắt đầu bằng j=1, mã của bạn sẽ đưa ra xác suất rằng tất cả các j+1sản phẩm bên trong đầu tiên đều bằng không cho mỗi n=j,...,50.

Sao chép bảng do Martin Büttner sản xuất để j=1chúng tôi có kết quả mẫu sau.

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

Ghi bàn

Điểm của bạn là lớn nhất jmà mã của bạn hoàn thành sau 1 phút trên máy tính của tôi. Để làm rõ một chút, mỗi người jđược một phút. Lưu ý rằng mã lập trình động trong câu hỏi được liên kết trước đó sẽ thực hiện điều này một cách dễ dàng j=1.

Máy cắt cà vạt

Nếu hai mục có cùng jsố điểm thì mục thắng sẽ là mục đạt được mức cao nhất ntrong một phút trên máy của tôi cho điều đó j. Nếu hai mục tốt nhất bằng nhau trên tiêu chí này thì người chiến thắng sẽ là câu trả lời được gửi đầu tiên.

Ngôn ngữ và thư viện

Bạn có thể sử dụng bất kỳ ngôn ngữ và thư viện có sẵn miễn phí nào bạn muốn. Tôi phải có khả năng chạy mã của bạn, vì vậy vui lòng bao gồm một lời giải thích đầy đủ về cách chạy / biên dịch mã của bạn trong linux nếu có thể.

Máy của tôi Thời gian sẽ được chạy trên máy của tôi. Đây là bản cài đặt Ubuntu tiêu chuẩn trên Bộ xử lý tám lõi AMD FX-8350. Điều này cũng có nghĩa là tôi cần để có thể chạy mã của bạn.

Giành chiến thắng

• j=2trong Python của Mitch Schwartz.
• j=2trong Python bởi frageum. Hiện tại mục nhập nhanh nhất.

Con trăn 2, j = 2

Tôi đã cố gắng tìm một loại 'dạng đóng' cho j = 2. Có lẽ tôi có thể tạo ra một hình ảnh MathJax về nó, mặc dù nó sẽ thực sự xấu xí với tất cả các chỉ số đang thay đổi. Tôi đã viết mã không tối ưu hóa này chỉ để kiểm tra công thức. Mất khoảng 1 giây để hoàn thành. Các kết quả phù hợp với mã của 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)

Hãy xem xét một chuỗi trong đó thành viên thứ i là enếu A [i] == A [i + 1] hoặc nnếu A [i]! = A [i + 1]. itrong chương trình là số ns. Nếu ilà chẵn, chuỗi phải bắt đầu và kết thúc bằng e. Nếu ilà số lẻ, chuỗi phải bắt đầu và kết thúc bằng n. Trình tự được phân loại thêm theo số lần chạy của es hoặc s liên tiếp n. Có j+ 1 của cái này và jcái kia.

Khi ý tưởng đi bộ ngẫu nhiên được mở rộng tới 3 kích thước, có một vấn đề đáng tiếc rằng có 4 hướng tốt để đi bộ trong (một cho mỗi người trong số ee, en, ne, hoặc nn) có nghĩa là họ không phụ thuộc tuyến tính. Vì vậy, kchỉ số tính tổng số bước được thực hiện theo một trong các hướng (1, 1, 1). Sau đó, sẽ có một số bước chính xác phải thực hiện theo 3 hướng khác để hủy bỏ nó.

P (n, p) đưa ra số lượng phân vùng được sắp xếp của n đối tượng thành các phần p. W (l, d) đưa ra số cách cho một bước đi ngẫu nhiên lđể di chuyển một khoảng cách chính xác d. Như trước đây có 1 cơ hội để di chuyển sang trái, 1 cơ hội để di chuyển sang phải và 2 cơ hội để ở lại.

Con trăn, j = 2

Phương pháp lập trình động cho câu trả lờij = 1 của tôi cho câu hỏi trước không cần nhiều sửa đổi để hoạt động cao hơn , nhưng bị chậm một cách nhanh chóng. Bảng để tham khảo: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

Và mã:

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

Ở đây chúng ta đang theo dõi hai yếu tố đầu tiên của A, hai yếu tố cuối cùng của B(nơi b2là yếu tố cuối cùng), và các sản phẩm bên trong (A[:n], B), (A[1:n], B[:-1])và (A[2:n], B[:-2]).