Найти наибольшее простое число, которое все еще является простым после удаления цифры

По адресу /math/33094/deleting-any-digit-yields-a-prime-is-there-a-name-for-this задается следующий вопрос. Сколько простых чисел осталось простыми после удаления одной из ее цифр? Например 719, такой простой, как вы получаете 71, 19и 79. Пока этот вопрос не решен, я подумал, что это хороший вызов для программирования.

Задача. Дайте наибольшее простое число, которое вы можете найти, и оно останется простым после удаления любой из его цифр. Вы также должны предоставить код, который его находит.

Гол. Значение простого вы даете.

Вы можете использовать любой язык программирования и библиотеки, которые вам нравятся, если они бесплатны.

Для начала, 99444901133это самая большая информация на связанной странице.

Лимит времени. Я приму самый большой правильный ответ, данный ровно через неделю после первого правильного ответа, который больше, чем 99444901133приведенный в ответе.

Результаты пока что.

Python (primo)

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

J (randomra) (Этот ответ запустил недельный таймер 21 февраля 2013 года.)

222223333333

274 цифры

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

Это заняло около 20 часов процессорного времени, чтобы найти, и около 2 минут на простое, чтобы доказать. Напротив, решение из 84 цифр можно найти примерно за 3 минуты.

84 цифры

444444444444444444444444444444444444444444444444441111111113333333333333333333333333

77777777999999999999999777777777 (32 цифры)
66666666666666622222222222222333 (32 цифры)
647777777777777777777777777 (27 цифр)
44444441333333333333 (20 цифр)
999996677777777777 (18 цифр)
167 (15 цифр) 1677

Я рекомендую этот инструмент, если вы хотите подтвердить первичность: апплет D. Alpern's ECM

Также используется подход repdigit, который, по-видимому, является подходом, который наиболее вероятно находит большие значения. Следующий скрипт алгоритмически пропускает большинство чисел или усечений, что приведет к кратности 2, 3, 5 и теперь 11 c / o 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, 6, 8] . Кроме того, если b является членом этого набора, длина c может быть не менее 2.

По 3
- если N = 1 (мод 3) , то N может не содержать ни одного из [1, 4, 7] , так как удаление любого из них тривиально приведет к кратному 3 . Аналогично для N = 2 (мод 3) и [2, 5, 8] . Эта реализация использует слегка ослабленную форму этого: если N содержит один из [1, 4, 7] , он может не содержать ни одного из [2, 5, 8] , и наоборот. Кроме того, N может состоять не только из [0, 3, 6, 9] . Это в значительной степени эквивалентное утверждение, но оно допускает некоторые тривиальные случаи, например a , b и cкаждый повторяется кратно 3 раза.

К 11
- как отмечает ПитерТейлор , если 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 набора повторяющихся цифр.
Номера вида, который преследовал рандома , a ... ab ... b , кажутся гораздо более редкими. Есть только 7 решений менее 10 ¹⁷⁰⁰ , самое большое из которых имеет длину 12 цифр.

4 набора повторяющихся цифр.
Номера этой формы, a ... ab ... bc ... cd ... d , кажутся более плотно распределенными, чем те, которые я искал. Есть 69 решений менее 10 ¹⁰⁰ , по сравнению с 32 с использованием 3 наборов повторяющихся цифр. Те между 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 цифр)

Здесь я искал только aa..aabb..bb формат до 100 цифр. Только другие хиты 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 ограничен целыми числами <= 2^53.

Поскольку это Javascript, браузер будет жаловаться, если мы не выпустим поток выполнения для обновления пользовательского интерфейса, в результате я решил отследить, в каком месте находится алгоритм в пользовательском интерфейсе.

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

Была опубликована ссылка на анализ проблемы, но я подумал, что в ней не хватает нескольких вещей. Давайте посмотрим на числа m цифр, состоящих из k последовательностей из 1 или более одинаковых цифр. Было показано, что если мы разбиваем цифры на группы {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 цифр, разбитых на k последовательностей, по крайней мере, 1 цифра. Существует (m - k + 1) более (k - 1) способов выбора длин этих последовательностей, что составляет около (m - 1,5k + 2) ^ (k - 1) / (k - 1) !. Есть 2 или 4 варианта для самой младшей цифры, всего шесть. Есть шесть вариантов выбора других цифр, кроме 36/7 вариантов выбора для старшей цифры; общая сумма составляет (6/7) * 6 ^ k. Есть 2 ^ k способа выбрать, является ли длина последовательности четной или нечетной; k + 1 из них исключено, потому что ни один или только один нечетны; мы умножаем количество выборов на (1 - (k + 1) / 2 ^ k), что составляет 1/4 при k = 2, 1/2 при k = 3, 11/16 при k = 4 и т. д. Число цифр из набора {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 / ln N. Вероятность случайного числа из m цифр составляет около 1 / (m ln 10). Однако цифры здесь не случайны. Все они были выбраны так, чтобы не делиться на 2, 3 или 5. 8 из любых 30 последовательных целых чисел не делятся на 2, 3 или 5. Следовательно, вероятность быть простым числом равна (30/8) / (млн. д. 10) или около 1,6286 / м.

Ожидаемое количество решений составляет около

(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 число снова уменьшается.