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


19

По адресу /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

9901444133(удаление одного 9) не является простым ( 7 x 1414492019). Ваш предыдущий пример был верным.
Примо

@primo Спасибо, исправлено. Это была странная моя опечатка.
motl7

1
Если есть самое большое - как показывает анализ, мне интересно, как вы могли бы найти доказательство, когда вы думаете, что нашли его.
gnibbler

1
А как насчет других баз? В базе 2 я не смог найти ничего выше 11 (2r1011), 11 также в базе 3 (3r102), 262151 в базе 4 (4r1000000013), 17 в базе 5 (5r32), 37 в базе 7 (7r52), 47 в базе 9 (9r52).
aka.nice

Ответы:


17

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 1700 , самое большое из которых имеет длину 12 цифр.

4 набора повторяющихся цифр.
Номера этой формы, a ... ab ... bc ... cd ... d , кажутся более плотно распределенными, чем те, которые я искал. Есть 69 решений менее 10 100 , по сравнению с 32 с использованием 3 наборов повторяющихся цифр. Те между 10 11 и 10 100 следующие:

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.


3
Любое решение формы d^x e^y f^zтребует, чтобы по крайней мере две длины последовательности были нечетными, чтобы избежать делимости на 11. Я не знаю, is_primeотклонят ли кратные числа 11 достаточно быстро, чтобы это явно не стоило принимать во внимание.
Питер Тейлор

Передо мной нет источника gmp, но, скорее всего, он начинается с пробного деления на небольшие простые числа. Тем не менее, (na&1)+(nb&1)+(nc&1) > 1это достаточно просто, что это должно быть быстрее. Подождите, это может привести к короткому замыканию полных ветвей! Если naчетное и nb + ncнечетное, то одно из них [nb, nc]обязательно должно быть четным, и вы можете просто перейти к следующему na.
Примо

Будьте осторожны, если вы используете gmpy.is_prime (). За пределами определенного момента он вероятностный, поэтому вам нужно проверить, что он возвращает a 2. 1означает, что это, вероятно, только премьер
gnibbler

4
Прямой и точный тест делимости на 11 состоит в том, чтобы сложить все цифры в четных позициях и вычесть все цифры в нечетных позициях (или наоборот) и проверить, является ли результат кратным 11. Как следствие (но также может быть непосредственно), вы можете уменьшить все последовательности из 2+ одинаковых цифр до 0 или 1 цифры (принимая длину последовательности% 2). 44444440000077777777777, таким образом, уменьшается до 407; 4 + 7-0 = 11. 4444444444444444444444444444444444444444444444444411444444444411111111133333333333333333333333 сокращается до 13
aditsu

1
"крепкий"! = доказано. Разница не важна для одних, решающая для других. PrimeQ в Mathematica - это вариант BPSW плюс дополнительный MR с базой 3, поэтому, конечно, это займет всего пару миллисекунд. Pari / GP проверяет 274-значный номер, используя APR-CL, примерно за 3 секунды на 5-летнем компьютере, а одноядерный ECPP с открытым исходным кодом занимает около 2 секунд. Не удивительно, что для Java это занимает больше времени, но это не имеет большого значения. У меня был мой перевод на Perl этого do BPSW на всех 4, затем доказательство на всех 4, только если они все прошли дешевые тесты.
DanaJ

5

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

Исчерпывающий поиск этой формы до 1560 цифр (и подсчет) не обнаруживает ничего большего, чем это 12-значное решение.
Примо

2

Изменить: кто-то уже сделал более глубокий анализ, чем я здесь.

Не решение, а приблизительная оценка количества n-значных решений.

Расчетное количество решений

Генерация J кода

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

Благодарю. Ось у немного сбивает с толку. Вы действительно имеете в виду 10 ^ -100 как оценочное число решений с примерно 86 цифрами?
motl7

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

1
Кто-то уже сделал более глубокий анализ, чем я.
randomra

Является ли ось Y пропорцией чисел с цифрами x, которые являются решениями? То есть количество решений, деленное на 10 ^ (# цифр)? Это не может быть число, так как это выглядит как 4, 11 и т. Д., И журнал которого почти всегда выше 1.
motl7

1

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

@Schmiddty Существуют большие библиотеки int для js, но этот метод грубой силы кажется обреченным.
motl7

1
@ motl7 Согласился, оставил его работать всю ночь, и ответов не найдено.
Шмиддти

1

Была опубликована ссылка на анализ проблемы, но я подумал, что в ней не хватает нескольких вещей. Давайте посмотрим на числа 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 число снова уменьшается.


5
Добро пожаловать в PPCG! Это отличный анализ; однако мы ищем ответы, которые будут законными ответами на вопрос. Другими словами, код. К сожалению, в нашей структуре остается мало места для постов только для комментариев, которые оставляются за комментариями постов. Однако я не хотел бы, чтобы такие тщательные усилия были отнесены к нашей куче слякоти, поэтому я хотел бы намекнуть, что если вы добавите в свой пост компьютерную программу, отвечающую требованиям конкурса, она с большей вероятностью будет сохранена. вокруг.
Джонатан Ван Матре

1
Кроме того, я настоятельно рекомендую вам посетить наши родственные сайты: math.stackexchange.com и mathoverflow.net
Джонатан Ван Матре,
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.