Trouver le plus grand nombre premier qui reste un nombre premier après la suppression des chiffres

Plus à /math/33094/deleting-any-digit-yields-a-prime-is-there-a-name-for-this la question suivante est posée. Combien de nombres premiers y a-t-il qui restent premiers après avoir supprimé l'un de ses chiffres? Par exemple, 719c'est une prime que vous obtenez 71, 19et 79. Bien que cette question ne soit pas résolue, je pensais que cela constituait un joli défi de codage.

Tâche. Donnez le plus grand nombre premier que vous pouvez trouver qui reste un nombre premier après avoir supprimé l'un de ses chiffres. Vous devez également fournir le code qui le trouve.

But. La valeur de la prime que vous donnez.

Vous pouvez utiliser n'importe quel langage de programmation et bibliothèques que vous aimez tant qu'ils sont gratuits.

Pour commencer, 99444901133c'est la plus grande donnée sur la page liée.

Limite de temps. J'accepterai la plus grande réponse correcte donnée exactement une semaine après la première bonne réponse plus grande que celle 99444901133donnée dans une réponse.

Des scores jusqu'à présent.

Python (primo)

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

J (randomra) (Cette réponse a commencé le minuteur d'une semaine le 21 février 2013.)

222223333333

274 chiffres

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

Cela a pris environ 20 heures de temps CPU à trouver et environ 2 minutes par prime à prouver. En revanche, la solution à 84 chiffres peut être trouvée en environ 3 minutes.

84 chiffres

444444444444444444444444444444444444444444444444441111111113333333333333333333333333

77777777999999999999999777777777 (32 chiffres)
66666666666666622222222222222333 (32 chiffres)
647777777777777777777777777 (27 chiffres)
44444441333333333333 (20 chiffres)
999996677777777777 (18 chiffres)
167777777777777 (15 chiffres)

Je recommande cet outil si vous souhaitez confirmer la primauté: l'applet ECM de D. Alpern

Utiliser également une approche repdigit, qui semble être l'approche la plus susceptible de trouver de grandes valeurs. Le script suivant ignore algorithmiquement la plupart des nombres ou des troncatures, ce qui entraînera des multiples de 2, 3, 5 et maintenant 11 c / o PeterTaylor (sa contribution a augmenté l'efficacité d'environ 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.pypeut être trouvé ici: http://codepad.org/KtXsydxK
Alternativement, vous pouvez également utiliser la gmpy.is_primefonction: GMPY Project

Quelques petites améliorations de vitesse en raison du profilage. Le contrôle de primalité pour le plus long des quatre candidats a été déplacé à la fin, xrangeremplace rangeet longremplace intles transtypages de type. intsemble avoir une surcharge inutile si l'expression évaluée aboutit à a long.

Règles de divisibilité

Soit N un entier positif de la forme a ... ab ... bc ... c , où a , b et c sont des chiffres répétés.

Par 2 et 5
- Pour éviter la divisibilité par 2 et 5 , c peut ne pas être dans l'ensemble [0, 2, 4, 5, 6, 8] . De plus, si b est membre de cet ensemble, la longueur de c ne peut être inférieure à 2.

Par 3
- Si N = 1 (mod 3) , alors N ne peut contenir aucun de [1, 4, 7] , car la suppression de l'un d'eux entraînerait trivialement un multiple de 3 . De même pour N = 2 (mod 3) et [2, 5, 8] . Cette implémentation utilise une forme légèrement affaiblie de ceci: si N contient l'un de [1, 4, 7] , il ne peut contenir aucun de [2, 5, 8] , et vice versa. De plus, N peut ne pas être composé uniquement de [0, 3, 6, 9] . Il s'agit en grande partie d'une déclaration équivalente, mais elle permet certains cas triviaux, par exemple a , b et cchacun étant répété un multiple de 3 fois.

Par 11
- Comme le note Peter Taylor , si N est de la forme aabbcc ... xxyyzz , c'est-à-dire qu'il n'est composé que de chiffres répétés un nombre pair de fois, il est divisible par 11 : a0b0c ... x0y0z . Cette observation élimine la moitié de l'espace de recherche. Si N est de longueur impaire, alors la longueur de a , b et c doit également être impaire (réduction de 75% de l'espace de recherche), et si N est de longueur paire, alors un seul de a , b ou c peut être pair en longueur (réduction de 25% de l'espace de recherche).
- Conjecture: si abc est un multiple de 11 , par exemple 407 , alors toutes les répétitions impaires de a , b et c seront également des multiples de 11 . Cela sort du champ d'application de la règle de divisibilité par 11 ci-dessus ; en fait, seules les répétitions impaires font partie de celles qui sont explicitement autorisées. Je n'ai pas de preuve pour cela, mais les tests systématiques n'ont pas pu trouver de contre-exemple. Comparez: 444077777 , 44444000777 , 44444440000077777777777 , etc. N'importe qui peut se sentir libre de prouver ou d'infirmer cette conjecture. aditsu a depuis démontré que c'était correct.

Autres formes

2 séries de chiffres répétés
Les nombres de la forme que randomra recherchait, a ... ab ... b , semblent être beaucoup plus rares. Il n'y a que 7 solutions de moins de 10 ¹⁷⁰⁰ , dont la plus grande est de 12 chiffres.

4 séries de chiffres répétés
Les nombres de cette forme, a ... ab ... bc ... cd ... d , semblent être plus densément répartis que ceux que je cherchais. Il existe 69 solutions de moins de 10 ¹⁰⁰ , contre 32 en utilisant 3 ensembles de chiffres répétés. Ceux entre 10 ¹¹ et 10 ¹⁰⁰ sont les suivants:

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

Il existe un simple argument heuristique expliquant pourquoi cela devrait être le cas. Pour chaque longueur numérique, il existe un certain nombre d'ensembles répétés (c'est-à-dire 3 ensembles répétés, ou 4 ensembles répétés, etc.) pour lesquels le nombre attendu de solutions sera le plus élevé. La transition se produit lorsque le nombre de solutions supplémentaires possibles, pris sous forme de rapport, l'emporte sur la probabilité que le nombre supplémentaire à vérifier soit premier. Étant donné la nature exponentielle des possibilités de vérification et la nature logarithmique de la distribution des nombres premiers, cela se produit relativement rapidement.

Si, par exemple, nous voulions trouver une solution à 300 chiffres, la vérification de 4 ensembles de chiffres répétés serait beaucoup plus susceptible de produire une solution que 3 ensembles, et 5 ensembles seraient plus probables encore. Cependant, avec la puissance de calcul dont je dispose, trouver une solution beaucoup plus grande que 100 chiffres avec 4 jeux serait en dehors de ma capacité, encore moins 5 ou 6.

222223333333 (12 chiffres)

Ici, je n'ai recherché que le format aa..aabb..bb jusqu'à 100 chiffres. Seuls les autres résultats sont 23 37 53 73 113 311.

Code J (nettoyé) (désolé, aucune explication):

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

Éditer: Quelqu'un a déjà fait une analyse plus approfondie que moi ici.

Pas une solution mais une estimation approximative du nombre de solutions à n chiffres.

Génération de code J

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

Javascript (Brute Force)

N'a pas encore trouvé un nombre plus élevé

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

Sans bibliothèque bigint, javascript est limité aux entiers <= 2^53.

Comme il s'agit de Javascript, le navigateur se plaindra si nous ne libérons pas le fil d'exécution pour que l'interface utilisateur soit mise à jour.En conséquence, j'ai décidé de suivre où l'algorithme se trouve dans sa progression dans l'interface utilisateur.

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

Un lien vers une analyse du problème a été publié, mais je pensais qu'il manquait quelques éléments. Regardons le nombre de m chiffres, composé de k séquences de 1 ou plusieurs chiffres identiques. Il a été démontré que si nous divisons les chiffres en groupes {0, 3, 6, 9}, {1, 4, 7} et {2, 5, 8}, une solution ne peut pas contenir de chiffres du deuxième et du troisième groupe , et il doit contenir 3n + 2 chiffres de l'un de ces groupes. Au moins deux des k séquences doivent avoir un nombre impair de chiffres. Sur les chiffres {1, 4, 7} seuls 1 et 7 peuvent être le chiffre le plus bas. Aucun des {2, 5, 8} ne peut être le chiffre le plus bas. Il y a donc soit quatre (1, 3, 7, 9) ou deux (3, 9) choix pour le chiffre le plus bas,

Combien y a-t-il de candidats? Nous avons m chiffres divisés en k séquences d'au moins 1 chiffre. Il existe (m - k + 1) plus de (k - 1) façons de choisir les longueurs de ces séquences, soit environ (m - 1,5k + 2) ^ (k - 1) / (k - 1) !. Il y a 2 ou 4 choix pour le chiffre le plus bas, six au total. Il y a six choix pour les autres chiffres, sauf 36/7 choix pour le chiffre le plus élevé; le total est (6/7) * 6 ^ k. Il existe 2 ^ k façons de choisir si la longueur d'une séquence est paire ou impaire; k + 1 d'entre eux sont exclus car aucun ou un seul n'est impair; nous multiplions le nombre de choix par (1 - (k + 1) / 2 ^ k), qui est 1/4 lorsque k = 2, 1/2 lorsque k = 3, 11/16 lorsque k = 4 etc. Le nombre des chiffres de l'ensemble {1, 4, 7} ou {2, 5, 8} doivent être 3n + 2, donc le nombre de choix est divisé par 3.

En multipliant tous ces chiffres, le nombre de candidats est

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

ou

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

Le candidat lui-même et les k nombres qui sont créés en supprimant un chiffre doivent tous être des nombres premiers. La probabilité qu'un entier aléatoire autour de N soit premier est d'environ 1 / ln N. La probabilité d'un nombre aléatoire de m chiffres est d'environ 1 / (m ln 10). Cependant, les chiffres ici ne sont pas aléatoires. Ils ont tous été choisis pour ne pas être divisibles par 2, 3 ou 5. 8 des 30 entiers consécutifs ne sont pas divisibles par 2, 3 ou 5. Par conséquent, la probabilité d'être un nombre premier est (30/8) / (m ln 10) soit environ 1,6286 / m.

Le nombre attendu de solutions est d’environ

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

ou pour grand m environ

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

Pour k = 2, 3, 4, ... on obtient ce qui suit:

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

À partir de k = 10, le nombre diminue à nouveau.