이전 에 확률을 빠르고 정확하게 계산하는 방법에 대한 질문 을했습니다. 그러나 폐쇄 형 솔루션이 제공되어 너무 쉬웠습니다! 더 어려운 버전이 있습니다.

이 작업은 확률을 정확 하고 신속하게 계산하기위한 코드 작성에 관한 것입니다 . 결과는 가장 축소 된 형태로 분수로 쓰여진 정확한 확률이어야합니다. 즉, 출력 4/8하지 말고 오히려 출력해야합니다 1/2.

양의 정수의 경우 n, 길이가 1과 -1 인 균일하게 임의의 문자열을 고려하여 nA라고 부르십시오. 이제 A자체 사본으로 연결하십시오 . 즉 A[1] = A[n+1]색인 경우 1, A[2] = A[n+2]등등. A이제 길이가 2n있습니다. 이제 n첫 번째 n값이 각각 1 / 4,1 / 2, 1/4 인 -1, 0 또는 1 인 길이 의 두 번째 임의의 문자열을 고려하여 B라고 부릅니다.

이제 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내부 제품이 모두 0 일 확률을 출력해야 합니다 n=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 분 안에 코드가 완료 되는 최대 점수입니다 . 조금 명확히하기 위해 각각 j1 분이 걸립니다. 앞의 링크 된 질문에서 다이나믹 프로그래밍 코드는이 작업을 쉽게 수행 할 수 있습니다 j=1.

타이 브레이커

두 항목이 같은 j점수를 얻는 경우 당첨 된 항목은 n내 컴퓨터에서 1 분 동안 최고 점수를 얻은 항목이됩니다 j. 이 기준에서 두 개의 최고 출품작이 동일한 경우 승자가 먼저 제출 된 답변이됩니다.

언어와 라이브러리

원하는 언어와 라이브러리를 자유롭게 사용할 수 있습니다. 코드를 실행할 수 있어야하므로 가능한 경우 리눅스에서 코드를 실행 / 컴파일하는 방법에 대한 자세한 설명을 포함하십시오.

내 컴퓨터 타이밍이 내 컴퓨터에서 실행됩니다. 이것은 AMD FX-8350 8 코어 프로세서에 표준 우분투 설치입니다. 이것은 또한 코드를 실행할 수 있어야 함을 의미합니다.

수상작

• j=2에서 파이썬 미치 슈워츠.
• j=2에서 파이썬 feersum에 의해. 현재 가장 빠른 항목입니다.

파이썬 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)

i 번째 구성원이 eA [i] == A [i + 1]이거나 nA [i]! = A [i + 1] 인 시퀀스를 고려하십시오 . i프로그램에서 ns 의 수입니다 . 경우 i짝수, 시퀀스에서 시작하고 끝나야합니다 e. 경우 i홀수, 순서는 시작하고 끝나야합니다 n. 시퀀스는 연속적인 es 또는 ns 의 런 수로 더 분류됩니다 . j하나와 j다른 하나의 +1 이 있습니다 .

랜덤 거리 아이디어는 3 개 차원으로 확장하는 경우, 걷기 4 개 개의 가능한 방향으로 (각각의 하나가 있다는 불행한 문제가 ee, en, ne, 또는 nn어떤 수단)가 선형으로 의존하지 않는다. 따라서 k인덱스는 방향 (1, 1, 1) 중 하나에서 수행 된 단계 수를 합산합니다. 그런 다음 취소하기 위해 다른 3 가지 방향으로 수행해야하는 정확한 단계가 있습니다.

P (n, p)는 n 개의 객체를 순서대로 p 개의 부분으로 나눕니다. W (l, d)는 임의의 l단계를 따라 거리를 정확히 이동하는 방법의 수를 나타 d냅니다. 이전과 마찬가지로 왼쪽으로 1 번, 오른쪽으로 1 번, 2 번은 그대로 유지됩니다.

파이썬, 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]).