Magnifique : un algorithme de 15 lignes sans aucune explication, ni même de rappel sur ce que sont les nombres premiers cousins... et rien ne prouve que l'algorithme donne ce que l'on veut, ni qu'il s'arrête, ni quelle est sa rapidité d'exécution.
Le meilleur, c'est que l'algorithme suppose connue la liste des nombres premiers !!
Oh... mais quand on décortique l'algorithme, c'est encore plus génial !
En fait, on part de 3 nombres $a$ valant 13, 15 et 17, et pour une raison inconnue, on cherche le plus petit facteur premier de $A=9a^2-4=(3a-2)(3a+2)$ qui ne soit pas encore dans la liste des cousins. Lorsque on en trouve un, on ajoute les nombres $3a-2$ et $3a+2$ à la liste des cousins. Enfin, on recommence en augmentant les nombres $a$ de 10.
Évidemment, c'est fait de façon bien plus compliquée que ce que je viens de dire...
Par ailleurs, dans les tests effectués, rien ne garantit que les nombres $3a-2$ et $3a+2$ soient effectivement premiers.
all_cousins=[7,11,13,17,19,23]a=[13,15,17] A=(a.^2-1)*9+5 i=7 while max(all_cousins)<100 for k=(1:length(A)) p=(A(k)+4)^0.5-2; p4=(A(k)+4)^0.5+2; if A(k)==p*p4 all_cousins(i)=p; i=i+1 all_cousins(i)=p4; i=i+1 end end a=a+10; A=(a.^2-1)*9+5; end
@lourrran : Ta remarque est particulièrement surprenante (et je doute qu’elle soit présente dans la charte du forum). Si je te suis, on ne doit écrire aucune ligne de codes sur le site : tous les langages ont leurs mots clés en anglais…
Je veux bien être bienveillant, mais là, on ne vérifie plus jamais la primalité, ni le fait que l'on ne rajoute pas des valeurs déjà inscrites, mais par contre, on vérifie une trivialité, à savoir $p\times p_4 =A(k)$ qui est toujours vérifiée !
Enfin, tu n'as toujours pas expliqué quoi que ce soit.
En particulier, pourquoi commences-tu avec autant de valeurs ? Il me semble que l'on obtient les mêmes résultats en initialisant avec :
Ma dernière version ne fonctionne pas. Ma méthode.
Soit 7 11 13 17 19 23 Les 3 premiers couples de cousins. Je mets à part 3 On commence par créer un triplet 13 15 17 On calcule pour chaque nombre du triplet
A =(a^2-1)*9+5 Où a est un nombre du triplet On teste si A est multiple et on note le nombre p sontson plus faible multiple.
Si ce multiple p n'est pas déjà dans les nombres premiers cousins, on ajoute aux nombres premiers cousins
Le couple p=(A+4)^0.5+-2 On recommence avec le triplet 23 25 27 Etc. de 10 en 10 Oui j'avoue on a besoins des nombres premiers inférieur à sqrt(A).
Soit $p$ un nombre premier relativement petit (disons plus petit que 100), mais pas égal à 2. Soit $n$ un nombre premier relativement grand (disons supérieur à 100 000) Par construction, $n$ n'est pas divisible par $p$, mais quelle est la probabilité que $n+4$ soit divisible par $p$ ? Cette proba est facile à calculer, elle vaut $1/(p-1)$ ; et donc $n+4$ ne sera pas divisible par $p$ avec une probabilité de $(p-2)/(p-1)$
Soit $(p_1,p_2 ... p_{24} )$ les nombres premiers entre $3$ et $97$ ? Quelle est la probabilité que $n+4$ ne soit divisible par aucun de ces nombres ? On peut faire une approximation, et multiplier les probabilités, on trouve alors $15.9$%
Tu me dis, j'oublie. Tu m'enseignes, je me souviens. Tu m'impliques, j'apprends. Benjamin Franklin
En tout cas dans le cas où p et p+4 sont testés premiers
J'ai vérifié que c'étaient bien des nombres premiers cousins, c'est-à-dire qu'il n'y a pas de nombres premiers entre les p et p+4 Pour p<300 ma méthode sans chercher la primalité en trouve 74 %
clear all
format('long')
prime=primes(10000000);
all_cousins=[3,7,11,13,17,19,23]
a=[13,15,17]
A=(a.^2-1)*9+5
i=7
while max(all_cousins)<1000000
for k=(1:length(A))
j=1;
while (mod(A(k),prime(j))~=0)
j=j+1;
end
if (sum((all_cousins==prime(j)))==0 & sum((prime==(A(k)+4)^0.5+2))~=0 & sum((prime==(A(k)+4)^0.5-2))~=0)
all_cousins(i)=(A(k)+4)^0.5-2;
i=i+1;
all_cousins(i)=(A(k)+4)^0.5+2;
i=i+1;
end
end
a=a+10;
A=(a.^2-1)*9+5;
end
test=ismember(all_cousins,prime);
sum(test)
l=length(all_cousins)
test2=0
for h=(2:2:length(all_cousins))
prime=primes(all_cousins(h));
if (prime(length(prime))==all_cousins(h) & prime(length(prime)-1)==all_cousins(h-1))
test2=test2+1;
end
end
test2
l/2
Si $p$ et $p+4$ sont premiers, on a 100% l'assurance que $p+2$ n'est pas premier, (sauf si les nombres sont 3,5 et 7) Forcément , un des 3 nombres $p$, $p+2$, $p+4$ est multiple de $3$.
Tu me dis, j'oublie. Tu m'enseignes, je me souviens. Tu m'impliques, j'apprends. Benjamin Franklin
clear all
all_cousins=[3,7,11,13,17,19,23]
a=[13,15,17]
A=(a.^2-1)*9+5
i=8
faux_cousins=[]
h=1
while max(all_cousins)<300000
for k=(1:length(A))
p=(A(k)+4)^0.5-2;
p4=(A(k)+4)^0.5+2;
oui = 0;
for t=(1:length(all_cousins))
if (mod(p,all_cousins(t))==0 | mod(p4,all_cousins(t))==0)
oui = 1;
break
end
end
for t=(1:length(faux_cousins))
if (mod(p,faux_cousins(t))==0 | mod(p4,faux_cousins(t))==0)
oui = 1;
break
end
end
if oui==1
faux_cousins(h)=p;
h=h+1;
faux_cousins(h)=p4;
h=h+1;
end
if (oui==0)
all_cousins(i)=p;
i=i+1;
all_cousins(i)=p4;
i=i+1;
end
end
a=a+10;
A=(a.^2-1)*9+5;
end
prime=primes(100000000);
test=ismember(all_cousins,prime)
trouve=sum(test)
l=length(all_cousins)
pourcentage=trouve/l*100
Dans le nouveau script je teste seulement les nouveaux candidats à être des nombres premiers cousins s'ils ne sont pas 0 modulo un nombre cousins ou modulo un faux cousin déjà connus S'ils le sont je les classe dans les faux cousins sinon je les mets dans les cousins.
À la fin du script je teste si tous les nombres cousins récoltés sont biens premiers.
Bonjour à toutes et tous Le programme VisualBasic ci-après donne les 5419 couples de nombres premiers consécutifs cousins en 4 minutes chrono sur mon PC.
Sub Macro1() Dim p(50000) ' p les premiers 50000 nombres premiers impairs p(1) = 3: x = p(1): n = 1 ' 3 premier nombre premier impair 10 x = x + 2 ' incrément x de 2 For i = 1 To n ' boucle de vérification de la primalité If x - p(i) * Int(x / p(i)) = 0 Then GoTo 10 ' si non premier retour à l'incrémentation Next i ' fin de boucle n = n + 1 'incrémentation de n p(n) = x 'enregistrement de p(n) premier Cells(1, 3) = n ' état d'avancement pour n Cells(1, 4) = x ' état d'avancement pour p(n) premier If n < 50000 Then GoTo 10 ' retour à l'incrémentation si moins de 50000 nombres premiers trouvés n = 0 For i = 1 To 49999 ' boucle de recherche des cousins définis comme deux nombres premiers consécutifs espacés de 4 If p(i) = p(i + 1) - 4 Then Cells(n, 1) = p(i): Cells(n, 2) = p(i + 1): n = n + 1 Next i Cells(2, 3) = n ' nombre de couples de nombres premiers cousins consécutifs (5419 pour les 50000 premiers p(i) End Sub
Compter environ 2 heures pour le premier million de nombres premiers et quelque heures si vous disposez comme moi du fichier des 120 premiers millions de nombre premiers.
clear all tic; all_cousins=[3,7,11,13,17,19,23] a=[13,15,17] A=(a.^2-1)*9+5 i=8 faux_cousins=[] h=1 while max(all_cousins)<600000 for k=(1:length(A)) p=(A(k)+4)^0.5-2; p4=(A(k)+4)^0.5+2; oui = 0; for t=(1:length(all_cousins)) if (mod(p,all_cousins(t))==0 | mod(p4,all_cousins(t))==0) oui = 1; break end end for t=(1:length(faux_cousins)) if (mod(p,faux_cousins(t))==0 | mod(p4,faux_cousins(t))==0) oui = 1; break end endif oui==1 faux_cousins(h)=p; h=h+1; faux_cousins(h)=p4; h=h+1; end if (oui==0) all_cousins(i)=p; i=i+1; all_cousins(i)=p4; i=i+1; end end a=a+10; A=(a.^2-1)*9+5; end t=toc
Pendant que j'y suis, voici les entiers p des couples (p,p+4) de nombres premiers cousins (la recherche s'effectuant ici dans l'ensemble des n=1000 premiers nombres premiers impairs. Je compte ici uniquement les p tels que p,p+4 soient premiers, mais pas p+2, c'est-à-dire ceux pour lesquels le gap est égal à 4).
n = 1000; L = Prime[Range[2, n + 1]]; Pick[Most[L], Rest[L] - Most[L], 4]
C'est exactement ce que je me suis dit (je précise que je suis hors-concours). Je déplore la tonalité injurieuse du message de @PierrelePetit à l'encontre de @davidstr
Pour un traitement de ce type, on peut utiliser un fichier déjà existant avec des nombres premiers. Ce qui aide beaucoup. Davidstr disait dans ce message qu'il n'utilisait pas de fichier déjà existant. C'est clair.
Dans son code, si j'ai bien lu, il ne vérifie pas si les nombres trouvés sont premiers, il part du principe qu'ils ont toutes les chances de l'être. C'est risqué.
Souvent, quand on tire 5 cartes dans un jeu de cartes on n'obtient pas un brelan d'as. Mais des fois, on a un brelan d'as.
Tu me dis, j'oublie. Tu m'enseignes, je me souviens. Tu m'impliques, j'apprends. Benjamin Franklin
Si je résume, tu as écrit un algorithme te permettant de calculer tous les nombres premiers cousins jusqu'à un certain seuil $n$ : c'est un bon exercice de programmation.
Comme tu as posté dans Shtam, j'imagine que ton algorithme présente une méthode novatrice qui permet de gagner en complexité. L'algorithme naïf a une complexité exponentielle (en le nombre de bits de $n$). J'ai l'impression, en lisant le code, que ton algorithme est également exponentiel et ressemble beaucoup à l'algorithme naïf. Si je me trompe (c'est possible), aurais-tu une preuve ?
Dans un de mes messages ci dessus il y a la partie du script ou je testais la primalité Comme j'obtenais à chaque fois 100% je l'ai enlevé. Ci dessous le script complet.
clear all
tic;
all_cousins=[3,7,11,13,17,19,23]
a=[13,15,17]
A=(a.^2-1)*9+5
i=8
faux_cousins=[]
h=1
while max(all_cousins)<100000
for k=(1:length(A))
p=(A(k)+4)^0.5-2;
p4=(A(k)+4)^0.5+2;
oui = 0;
for t=(1:length(all_cousins))
if (mod(p,all_cousins(t))==0 | mod(p4,all_cousins(t))==0)
oui = 1;
break
end
end
for t=(1:length(faux_cousins))
if (mod(p,faux_cousins(t))==0 | mod(p4,faux_cousins(t))==0)
oui = 1;
break
end
end
if oui==1
faux_cousins(h)=p;
h=h+1;
faux_cousins(h)=p4;
h=h+1;
end
if (oui==0)
all_cousins(i)=p;
i=i+1;
all_cousins(i)=p4;
i=i+1;
end
end
a=a+10;
A=(a.^2-1)*9+5;
end
t=toc
prime=primes(100000000);
test=ismember(all_cousins,prime)
trouve=sum(test)
l=length(all_cousins)
pourcentage=trouve/l*100
> a=[13,15,17] On définit un tableau $A$ contenant les $3$ éléments $13,15,17$. > A=(a.^2-1)*9+5 $^$ est la puissance et le point avant est pour dire qu'on élève tous les termes du tableau $a$ à la puissance $2$. Plus précisément, c'est pour distinguer d'une matrice élevée au carré, ce qui ne serait pas possible ici. Puis tous les éléments du tableau sont multipliés par 9 et on leur ajoute 5 à chacun. > k=(1:length(A)) Pour $k$ variant de $1$ à la longueur du tableau $A$, c'est à dire $7$ ici.
Pourquoi 7 nombres dans A après cette manipulation ? Et ensuite, autre question, quels sont ces 7 nombres ? N'y connaissant rien, j'avais imaginé : a contient 3 éléments 13, 15 et 17 a.^2 : contient les 3 nombres13^2, 15^2 et 17^2 (a.^2-1)*9+5 : contient les 3 nombres (i^2-1)*9+5, pour i = 13, 15 ou 17.
Et c'est d'ailleurs ce que je comprends dans le reste de l'explication. Donc le 7 serait une faute de frappe ?
Tu me dis, j'oublie. Tu m'enseignes, je me souviens. Tu m'impliques, j'apprends. Benjamin Franklin
Merci beaucoup, maintenant je suis sur de la réponse à la question que je me suis posée. Notre @davidstr vérifie bien la primalité et affirme ne pas le faire!
Pour répondre @Heuristique : en fait ma conjecture est que avec ma méthode on n'a plus besoins de tester si mes nombres trouvés sont des nombres premiers...
@davidstr Si tu renvoies des nombres premiers cousins, c'est bien que, par une méthode ou pour une autre, tu peux affirmer qu'ils sont premiers. Soit les nombres trouvés sont premiers (et ton algo est un test en soi), soit certains ne le sont pas et alors ton algo n'est pas correct.
Pour l'instant, David constate (voire s'étonne) que les nombres trouvés sont tous premiers, et donc, il franchit le pas, et ne fait plus cette vérification. Du genre : puisque ça marche sur les 100000 premiers nombres, ça doit marcher sur tous les suivants.
Par ailleurs, au tout début de la discussion, Mediat Suprème avait fait remarquer que l'algorithme ne détecte pas tous les nombres premiers cousins. Cette remarque est restée sans réponse.
Tu me dis, j'oublie. Tu m'enseignes, je me souviens. Tu m'impliques, j'apprends. Benjamin Franklin
j'ai vérifié jusqu'à max(all_cousins)=21 640 841 et ils étaient tous premiers. Ma conjecture est de dire qu'avec ma méthode ils sont tous premiers Ci joint la liste.
Bonjour Je ne pense pas que ; davidstr s'étonne que les couples de premiers: p et p+4 soient premiers , puisqu'il me semble que son programme teste les faux cousins , car lorsque l'on prend A = 25 on obtient bien 73 et 77 qui est un faux cousin, car 77 modulo p == 0, avec p = 7.. Ensuite avec cette formule il obtient bien les suites de tous les nombres : 7 et 11 modulo 30 puis 13 et 17 modulo 30 ainsi que 19 et 23 modulo 30 ; les 6 familles contenant les nombres premiers cousins. Il lui suffit seulement d'avoir la liste des nombres premier $P\leqslant\sqrt {p+4}$ afin de vérifier si p+4 donne un couple de cousins tel que , si $p+4 == 0[P]$ ce n'est pas un couple de cousins
C'est peut être "" moins efficace "" que de tester directement la liste de nombre premiers 7 modulo 30 , 13 modulo 30 ou 19 modulo 30 car il faut quelque secondes pour extraire ces trois familles de nombres premiers $p < 1 0000 0000 000$ afin de les appeler , pour tester si $p+4 == 0 [P]$ . Ce qu'a fait remarquer Bisam ...
Ceci dit , son algorithme est juste, pour p > 5 . C'est à peu près la même densité que les premiers jumeaux , ou que les nombres premiers ayant un écart de 246 par tranche de 100 nombres premiers ...
Tu peux dire pourquoi s'embêter avec cette formule... pour tout entier A,B,C de la forme $30k+7$ , $30k+13$ et $30k+19$ où ensuite il ne te reste qu'à tester si $p$ et $p+4$ sont premiers; puisque ta formule extrait ces entiers, en partant de tes 3 suites arithmétiques de raison 10 et de premiers terme 3 , 5 , 7 pour ensuite obtenir les trois suites arithmétique de raison 30 et de premier terme 7 ,13, 19 ...
Mais il faut savoir que cela n'a pas vraiment d'intérêt... il y a des algorithmes qui te donne pour une limite fixée le nombre de premiers : jumeaux, cousins , sexys ...etc.
En exemple un petit fichier pour deux familles de nombres premiers : $30k +11$ et $30k + 13$
Réponses
J'affirme péremptoirement que toute affirmation péremptoire est fausse
Puis de 10 en 10
A s'il n'a pas un facteur qui est déjà dans la liste des cousins
C'est encore à vérifier
Je sais y a peu d'explications mais le script est simple
Mais un code informatique vient compléter une explication, il ne fait pas office d'explication.
Ma méthode.
Les 3 premiers couples de cousins. Je mets à part 3
On commence par créer un triplet 13 15 17
On calcule pour chaque nombre du triplet
Où a est un nombre du triplet
On teste si A est multiple et on note le nombre p sont son plus faible multiple.
On recommence avec le triplet 23 25 27
Etc. de 10 en 10
Oui j'avoue on a besoins des nombres premiers inférieur à sqrt(A).
Je me suis emballé.
Soit $n$ un nombre premier relativement grand (disons supérieur à 100 000)
Par construction, $n$ n'est pas divisible par $p$, mais quelle est la probabilité que $n+4$ soit divisible par $p$ ?
Cette proba est facile à calculer, elle vaut $1/(p-1)$ ; et donc $n+4$ ne sera pas divisible par $p$ avec une probabilité de $(p-2)/(p-1)$
Soit $(p_1,p_2 ... p_{24} )$ les nombres premiers entre $3$ et $97$ ? Quelle est la probabilité que $n+4$ ne soit divisible par aucun de ces nombres ?
On peut faire une approximation, et multiplier les probabilités, on trouve alors $15.9$%
Pour p<300 ma méthode sans chercher la primalité en trouve 74 %
all_cousins=[7,11,13,17,19,23]
Avec la primalité
clear all
format('long')
prime=primes(10000000);
all_cousins=[3,7,11,13,17,19,23]
a=[13,15,17]
A=(a.^2-1)*9+5
i=7
while max(all_cousins)<1000000
for k=(1:length(A))
j=1;
while (mod(A(k),prime(j))~=0)
j=j+1;
end
if (sum((all_cousins==prime(j)))==0 & sum((prime==(A(k)+4)^0.5+2))~=0 & sum((prime==(A(k)+4)^0.5-2))~=0)
all_cousins(i)=(A(k)+4)^0.5-2;
i=i+1;
all_cousins(i)=(A(k)+4)^0.5+2;
i=i+1;
end
end
a=a+10;
A=(a.^2-1)*9+5;
end
test=ismember(all_cousins,prime);
sum(test)
l=length(all_cousins)
test2=0
for h=(2:2:length(all_cousins))
prime=primes(all_cousins(h));
if (prime(length(prime))==all_cousins(h) & prime(length(prime)-1)==all_cousins(h-1))
test2=test2+1;
end
end
test2
l/2
Forcément , un des 3 nombres $p$, $p+2$, $p+4$ est multiple de $3$.
clear all
all_cousins=[3,7,11,13,17,19,23]
a=[13,15,17]
A=(a.^2-1)*9+5
i=8
faux_cousins=[]
h=1
while max(all_cousins)<300000
for k=(1:length(A))
p=(A(k)+4)^0.5-2;
p4=(A(k)+4)^0.5+2;
oui = 0;
for t=(1:length(all_cousins))
if (mod(p,all_cousins(t))==0 | mod(p4,all_cousins(t))==0)
oui = 1;
break
end
end
for t=(1:length(faux_cousins))
if (mod(p,faux_cousins(t))==0 | mod(p4,faux_cousins(t))==0)
oui = 1;
break
end
end
if oui==1
faux_cousins(h)=p;
h=h+1;
faux_cousins(h)=p4;
h=h+1;
end
if (oui==0)
all_cousins(i)=p;
i=i+1;
all_cousins(i)=p4;
i=i+1;
end
end
a=a+10;
A=(a.^2-1)*9+5;
end
prime=primes(100000000);
test=ismember(all_cousins,prime)
trouve=sum(test)
l=length(all_cousins)
pourcentage=trouve/l*100
À la fin du script je teste si tous les nombres cousins récoltés sont biens premiers.
Le programme VisualBasic ci-après donne les 5419 couples de nombres premiers consécutifs cousins en 4 minutes chrono sur mon PC.
Ci joint les 71655 couples de cousins
Un grand tour de magie de trouver des nombres premiers sans savoir s'ils le sont !!!
nombres premiers impairs obtenu en quelques secondes en
connaissant les premiers 10 000 000 de nombres premiers
GAPS des 9 999 999 premiers nombres premiers impairs
C'est un concours à qui a la plus grosse ?
Cordialement,
Rescassol
Quelques secondes plus tard :
Résultat immédiat ici :
Je déplore la tonalité injurieuse du message de @PierrelePetit à l'encontre de @davidstr
Aucune injure, une question que je me pose à son sujet puis une constatation de faits :
Davidstr disait dans ce message qu'il n'utilisait pas de fichier déjà existant. C'est clair.
Dans son code, si j'ai bien lu, il ne vérifie pas si les nombres trouvés sont premiers, il part du principe qu'ils ont toutes les chances de l'être. C'est risqué.
Souvent, quand on tire 5 cartes dans un jeu de cartes on n'obtient pas un brelan d'as.
Mais des fois, on a un brelan d'as.
Normal.
Comme j'obtenais à chaque fois 100% je l'ai enlevé.
Ci dessous le script complet.
> a=[13,15,17]
On définit un tableau $A$ contenant les $3$ éléments $13,15,17$.
> A=(a.^2-1)*9+5
$^$ est la puissance et le point avant est pour dire qu'on élève tous les termes du tableau $a$ à la puissance $2$.
Plus précisément, c'est pour distinguer d'une matrice élevée au carré, ce qui ne serait pas possible ici.
Puis tous les éléments du tableau sont multipliés par 9 et on leur ajoute 5 à chacun.
> k=(1:length(A))
Pour $k$ variant de $1$ à la longueur du tableau $A$, c'est à dire $7$ ici.
Le reste est clair.
Cordialement,
Rescassol
N'y connaissant rien, j'avais imaginé :
a contient 3 éléments 13, 15 et 17
a.^2 : contient les 3 nombres13^2, 15^2 et 17^2
(a.^2-1)*9+5 : contient les 3 nombres (i^2-1)*9+5, pour i = 13, 15 ou 17.
Et c'est d'ailleurs ce que je comprends dans le reste de l'explication. Donc le 7 serait une faute de frappe ?
Notre @davidstr vérifie bien la primalité et affirme ne pas le faire!
Cordialement
Bonne nuit
Du genre : puisque ça marche sur les 100000 premiers nombres, ça doit marcher sur tous les suivants.
cf la 2ème ligne de ce message https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2351947/#Comment_2351947
Par ailleurs, au tout début de la discussion, Mediat Suprème avait fait remarquer que l'algorithme ne détecte pas tous les nombres premiers cousins.
Cette remarque est restée sans réponse.
Ci joint la liste.
Je ne pense pas que ;
davidstr s'étonne que les couples de premiers: p et p+4 soient premiers , puisqu'il me semble que son programme teste les faux cousins , car lorsque l'on prend A = 25 on obtient bien 73 et 77 qui est un faux cousin, car 77 modulo p == 0, avec p = 7..
Ensuite avec cette formule il obtient bien les suites de tous les nombres : 7 et 11 modulo 30 puis 13 et 17 modulo 30 ainsi que 19 et 23 modulo 30 ; les 6 familles contenant les nombres premiers cousins.
Il lui suffit seulement d'avoir la liste des nombres premier $P\leqslant\sqrt {p+4}$ afin de vérifier si p+4 donne un couple de cousins tel que , si $p+4 == 0[P]$ ce n'est pas un couple de cousins
C'est peut être "" moins efficace "" que de tester directement la liste de nombre premiers 7 modulo 30 , 13 modulo 30 ou 19 modulo 30 car il faut quelque secondes pour extraire ces trois familles de nombres premiers $p < 1 0000 0000 000$ afin de les appeler , pour tester si $p+4 == 0 [P]$ .
Ce qu'a fait remarquer Bisam ...
Ceci dit , son algorithme est juste, pour p > 5 .
C'est à peu près la même densité que les premiers jumeaux , ou que les nombres premiers ayant un écart de 246 par tranche de 100 nombres premiers ...
clear all
tic;
prime=primes(1000000000);
all_cousins=[3,7,11,13,17,19,23]
a=(13:10:100000000)*3;
b=(15:10:100000000)*3;
c=(17:10:100000000)*3;
Ap=a-2;
Ap4=a+2;
Bp=b-2;
Bp4=b+2;
Cp=c-2;
Cp4=c+2;
all_cousinsp=sort([7 13 19 Ap Bp Cp]);
all_cousinsp4=sort([11 17 23 Ap4 Bp4 Cp4]);
p=ismember(all_cousinsp,prime);
p4=ismember(all_cousinsp4,prime);
ind=(p & p4);
all_cousinsp=all_cousinsp(find(ind==1));
all_cousinsp4=all_cousinsp4(find(ind==1));
all_cousins=sort([all_cousinsp all_cousinsp4]);
temps=toc
Tu peux dire pourquoi s'embêter avec cette formule... pour tout entier A,B,C de la forme $30k+7$ , $30k+13$ et $30k+19$ où ensuite il ne te reste qu'à tester si $p$ et $p+4$ sont premiers; puisque ta formule extrait ces entiers, en partant de tes 3 suites arithmétiques de raison 10 et de premiers terme 3 , 5 , 7 pour ensuite obtenir les trois suites arithmétique de raison 30 et de premier terme 7 ,13, 19 ...
Mais il faut savoir que cela n'a pas vraiment d'intérêt... il y a des algorithmes qui te donne pour une limite fixée le nombre de premiers : jumeaux, cousins , sexys ...etc.
En exemple un petit fichier pour deux familles de nombres premiers : $30k +11$ et $30k + 13$