查找最大素数，该最大素数在删除数字后仍然是素数

在/math/33094/deleting-any-digit-yields-a-prime-is-there-a-name-for-this上，提出以下问题。删除任何一位数字后，剩下多少个素数？例如719，您得到了这样的素数71，19而79。尽管这个问题尚未解决，但我认为这是一个不错的编码挑战。

任务。 给出最大的质数，您可以在删除其任何一位后找到仍为质数的质数。您还应该提供找到它的代码。

得分了。您提供的素数的价值。

您可以使用任何免费的编程语言和库。

首先，要99444901133在链接页面上给出最大的内容。

时限。在第一个正确答案大于答案中给出的最大正确答案一周后，我将接受最大的正确99444901133答案。

分数到目前为止。

Python（原始）

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

J（随机）（此答案从2013年2月21日开始为期一周的计时器。）

222223333333

274个数字

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

查找大约需要20个小时的CPU时间，而每个素数大约需要2分钟才能证明。相反，可以在3分钟左右找到84位解决方案。

84个数字

444444444444444444444444444444444444444444444444441111111113333333333333333333333333

77777777999999999999999777777777（32位数）
66666666666666622222222222222333（32个位数）
647777777777777777777777777（27位）
44444441333333333333（20位）
999996677777777777（18位）
167777777777777（15位）

如果您想确认素数，我建议使用此工具：D. Alpern的ECM Applet

还使用repdigit方法，这似乎是最有可能找到较大值的方法。下面的脚本算法跳过大多数数字或截短，这将导致的倍数2，3，5，现在11的C /ö PeterTaylor（他的贡献约50％提高效率）。

from my_math import is_prime

sets = [
 (set('147'), set('0147369'), set('1379')),
 (set('369'), set('147'), set('1379')),
 (set('369'), set('0369'), set('17')),
 (set('258'), set('0258369'), set('39')),
 (set('369'), set('258'), set('39'))]

div2or5 = set('024568')

for n in range(3, 100):
 for sa, sb, sc in sets:
  for a in sa:
   for b in sb-set([a]):
    bm1 = int(b in div2or5)
    for c in sc-set([b]):
     if int(a+b+c)%11 == 0: continue
     for na in xrange(1, n-1, 1+(n&1)):
      eb = n - na
      for nb in xrange(1, eb-bm1, 1+(~eb&1)):
       nc = eb - nb
       if not is_prime(long(a*(na-1) + b*nb + c*nc)):
        continue
       if not is_prime(long(a*na + b*(nb-1) + c*nc)):
        continue
       if not is_prime(long(a*na + b*nb + c*(nc-1))):
        continue
       if not is_prime(long(a*na + b*nb + c*nc)):
        continue
       print a*na + b*nb + c*nc

my_math.py可以在这里找到：http : //codepad.org/KtXsydxK
或者，您也可以使用以下gmpy.is_prime功能：GMPY Project

概要分析后，速度有所改善。四个候选对象中最长的素数检查已移至末尾，xrange替换range并long替换int类型强制转换。int如果所评估的表达式产生一个long。

可除性规则

令N为a ... ab ... bc ... c形式的正整数，其中a，b和c为重复数字。

2和5-
为了避免被2和5整除，c可能不在集合[0，2，4，5，5，6，8]中。此外，如果b是该集合的成员，则c的长度不得小于2。

乘3-
如果N = 1（mod 3），则N可能不包含[ 1，4，7 ]中的任何一个，因为删除其中的任何一个都将导致3的整数倍。同样对于N = 2（mod 3）和[ 2，5，8 ]。此实现使用以下形式的弱化形式：如果N包含[1，4，7]之一，则它可能不包含[2，5，8]中的任何一个，反之亦然。另外，N可能不仅仅由[0，3，6，9]组成。这基本上是一个等效的语句，但是它确实允许一些琐碎的情况，例如a，b和c每次重复3次。

乘以11-
正如PeterTaylor所指出的那样，如果N的形式为aabbcc ... xxyyzz，即它仅由重复偶数次的数字组成，则可以被11整除：a0b0c ... x0y0z。这种观察消除了一半的搜索空间。如果N的长度为奇数，则a，b和c的长度也必须全部为奇数（缩小75％的搜索空间），如果N的长度为偶数，则a，b或c的其中一个可能只有偶数。长度（减少25％的搜索空间）。
- 猜想：如果abc是11的倍数，例如407，则a，b和c的所有奇数重复也将是11的倍数。这不属于上述11分法的范围；实际上，在明确允许的重复中只有奇数重复。我没有证据，但是系统测试无法找到反例。比较：444077777，44444000777，44444440000077777777777等任何人都可以随意证明或反驳这一猜想。 此后，aditsu已证明这是正确的。

其他形式

2组重复的数字randomra追求
的形式的数字a ... ab ... b似乎少得多。只有7个解决方案小于10 ¹⁷⁰⁰，最大为12位数字。

4组重复的数字
这种形式的数字a ... ab ... bc ... cd ... d似乎比我要搜索的数字分布得更密集。有69个解决方案少于10 ¹⁰⁰，而使用3组重复数字的解决方案少于32个。介于10 ¹¹和10 ¹⁰⁰之间的值如下：

190000007777
700000011119
955666663333
47444444441111
66666622222399
280000000033333
1111333333334999
1111333333377779
1199999999900111
3355555666999999
2222233333000099
55555922222222233333
444444440004449999999
3366666633333333377777
3333333333999888883333
4441111113333333333311111
2222222293333333333333999999
999999999339999999977777777777
22222226666666222222222299999999
333333333333333333339944444444444999999999
559999999999933333333333339999999999999999
3333333333333333333111111111111666666666611111
11111111333330000000000000111111111111111111111
777777777770000000000000000000033333339999999999999999999999999
3333333333333333333333333333333333333333333333336666666977777777777777
666666666666666666611111113333337777777777777777777777777777777777777777
3333333333333333333888889999999999999999999999999999999999999999999999999933333333

对于为什么要这样，有一个简单的启发式论证。对于每个数字长度，存在许多重复集（即3个重复集或4个重复集等），其预期解决方案数将是最高的。当其他可能的解决方案的数量（以比率表示）大于要检查的其他数量为质数的概率时，就会发生转换。考虑到检查可能性的指数性质以及素数分布的对数性质，这种情况相对较快地发生。

例如，如果我们想找到一个300位的解决方案，那么检查4组重复的数字将比3组更容易产生解决方案，而5组仍然更有可能。但是，凭借我可以使用的计算能力，要找到一个比100位数字大4套的解决方案超出了我的能力，更不用说5或6了。

222223333333（12位数字）

在这里，我只搜索了最多100位数字的aa..aabb..bb格式。只有其他匹配是23 37 53 73 113 311。

J代码（清理）（对不起，没有解释）：

a=.>,{,~<>:i.100
b=.>,{,~<i.10
num=.".@(1&":)@#~
p=.(*/"1@:((1&p:)@num) (]-"1(0,=@i.@#)))"1 1
]res=./:~~.,b (p#num)"1 1/ a

编辑：有人已经比我在这里进行了更深入的分析。

不是解决方案，而是对n位解决方案数量的粗略估计。

生成J代码

   ops=: 'title ','Estimated number of solutions by digits',';xcaption ','digits',';ycaption ','log10 #'
   ops plot 10^.((%^.)%(2&(%~)@^.@(%&10))^(10&^.))(10&^(2+i.100))

Javascript（蛮力）

尚未找到更高的数量

http://jsfiddle.net/79FDr/4/

如果没有bigint库，则javascript仅限于integers <= 2^53。

由于使用的是Javascript，因此浏览器会抱怨如果我们不释放要更新的UI的执行线程，结果，我决定跟踪算法在UI中的位置。

function isPrime(n){
    return n==2||(n>1&&n%2!=0&&(function(){
        for(var i=3,max=Math.sqrt(n);i<=max;i+=2)if(n%i==0)return false;
        return true;
    })());
};

var o=$("#o"), m=Math.pow(2,53),S=$("#s");

(function loop(n){
    var s = n.toString(),t,p=true,i=l=s.length,h={};
    if(isPrime(n)){
        while(--i){
            t=s.substring(0,i-1) + s.substring(i,l); // cut out a digit
            if(!h[t]){   // keep a hash of numbers tested so we don't end up testing 
                h[t]=1;  // the same number multiple times
                if(!isPrime(+t)){p=false;break;}
            }
        }
        if(p)
            o.append($("<span>"+n+"</span>"));
    }
    S.text(n);
    if(n+2 < m)setTimeout(function(){
        loop(n+2);
    },1);
})(99444901133);

已发布问题分析链接，但我认为它缺少一些内容。让我们看一下由1个或多个相同数字的k个序列组成的m个数字。结果表明，如果我们将数字分成{0，3，6，9}，{1，4，7}和{2，5，8}组，则解决方案不能同时包含第二和第三组的数字，并且必须包含这些组之一中的3n + 2位数字。k个序列中的至少两个必须具有奇数个数字。在数字{1，4，7}中，只有1和7是最低的数字。{2，5，8}中的任何一个都不可以是最低的数字。因此，最低位数有四个（1、3、7、9）或两个（3、9）选项，

有几位候选人？我们有m个数字，分成至少1个数字的k个序列。有（m-k + 1）种以上（k-1）种方法来选择这些序列的长度，大约为（m-1.5k + 2）^（k-1）/（k-1）!。最低位数有2或4个选择，总共6个。除最高数字的36/7选择外，其他数字有六个选择。总数为（6/7）* 6 ^ k。有2k种方法可以选择序列的长度是偶数还是奇数。因为没有一个或只有一个奇数，所以排除了k + 1个；我们将选择的数量乘以（1-（k + 1）/ 2 ^ k），当k = 2时为1/4，当k = 3时为1/2，当k = 4时为11/16，等等。集合{1，4，7}或{2，5，8}中的位数必须为3n + 2，因此选择数除以3。

将所有这些数字相乘得到的候选人数为

(m - 1.5k + 2)^(k - 1) / (k - 1)! * (6/7) * 6^k * (1 - (k + 1) / 2^k) / 3

要么

(m - 1.5k + 2)^(k - 1) / (k - 1)! * (2/7) * 6^k * (1 - (k + 1) / 2^k)

候选者本身和通过删除数字创建的k个数必须全部为质数。N附近的随机整数是质数的概率约为1 / lnN。m位随机数的概率约为1 /（m ln 10）。但是，这里的数字不是随机的。它们全部被选为不能被2、3或5整除。在任何30个连续整数中，有8个不能被2、3或5整除。因此，成为素数的概率为（30/8）/ （m ln 10）或约1.6286 / m。

预期的解决方案数量约为

(m - 1.5k + 2)^(k - 1) / (k - 1)! * (2/7) * 6^k * (1 - (k + 1) / 2^k) * (1.6286 / m)^(k + 1)

或大约

(1 - (1.5k - 2) / m)^(k - 1) / (k - 1)! * 0.465 * 9.772^k * (1 - (k + 1) / 2^k) / m^2

对于k = 2，3，4，...，我们得到以下结果：

k = 2: 11.1 * (1 - 1/m) / m^2
k = 3: 108 * (1 - 2.5/m)^2 / m^2 
k = 4: 486 * (1 - 4/m)^3 / m^2


k = 10: 10,065 * (1 - 13/m)^9 / m^2

从k = 10开始，数字再次变小。