概率-您能走多高?


10

我之前曾问过一个问题,该如何快速准确地计算概率。但是,显然,提供封闭式解决方案太容易了!这是一个更困难的版本。

这项任务是关于编写代码以准确,快速地计算概率。输出应该是精确的概率,以最简化的形式写为分数。那是它永远不应该输出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.

现在考虑不同的Bwith 的内积。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+1内积为零的概率n=j,...,50

复制MartinBü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中运行/编译代码的完整说明。

我的机器时间将在我的机器上运行。这是在AMD FX-8350八核处理器上的标准ubuntu安装。这也意味着我需要能够运行您的代码。

获奖作品

  • j=2在Mitch Schwartz的Python中
  • j=2由feersum 在Python中编写。目前最快的进入。

如果问题仍然不清楚,请告诉我,以便我快速解决。

2
到目前为止,您是我最喜欢的提问者。再说一遍,我确实需要精确而快速地计算值。
primo 2015年

@primo谢谢!这是否意味着我们可以期待在RPython中得到答案?:)

您能否将这个问题与另一个问题区分开来?
kirbyfan64sos

@ kirbyfan64sos另一个基本上只与j = 1相同。

Answers:


3

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)

考虑一个序列,e如果A [i] == A [i + 1]或nA [i]!= A [i + 1] ,则第i个成员为。i在程序中是ns 的数量。如果i是偶数,则序列必须以开头并以结尾e。如果i为奇数,则序列必须以开头和结尾n。序列按连续es或ns 的游程数进一步分类。有j一个,j另一个为+1 。

当随机游动思想扩展到3米的尺寸,还有一个不幸的问题有4个可能的方向行走在(每个的eeenne,或nn),这意味着它们不是线性相关的。因此,该k索引求和了沿方向(1、1、1)采取的步数。然后,必须在其他3个方向上采取确切的步骤数才能取消它。

P(n,p)给出n个对象分成p个部分的有序分区的数量。W(l,d)给出了随机走步l以精确地行驶距离的方法d。和以前一样,有1次机会向左移动,有1次机会向右移动,还有2次保持不变。


谢谢!该公式的图像非常好。

谢谢你的解释。您使它看起来很简单!我刚刚看到您的评论,说您可以解决j=3。这将是惊人的!

3

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


....仅剩21.20秒到达N_MAX
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.