Discussion :

[Roland Chastain]

Merci pour le lien, droggo.

En cherchant des améliorations possibles, je suis tombé sur celle-ci, dont l'effet est foudroyant.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
        //while (d < n) and result do
        while (d * d < n) and result do

Reste que dans mon programme la fonction EstPremier() est appelée plusieurs fois avec le même argument. D'où l'intérêt peut-être de mettre d'abord les nombres premiers dans un tableau, puis de chercher les jumeaux, comme iks37 pensait le faire.

[Jipété]

Merci pour le lien, droggo.

En cherchant des améliorations possibles, je suis tombé sur celle-ci, dont l'effet est foudroyant.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
        //while (d < n) and result do
        while (d * d < n) and result do

Tutafait !
Je tombe à 11 msec ! Et toi ?

Reste que dans mon programme la fonction EstPremier() est appelée plusieurs fois avec le même argument. D'où l'intérêt peut-être de mettre d'abord les nombres premiers dans un tableau, puis de chercher les jumeaux, comme iks37 pensait le faire.

Attends un peu, car le fichier de résultat des versions 1 et 2 pesait 14186 octets, la version 3 (celle-ci) génère un truc de 14452 octets
Un peu la flemme de chercher le pourquoi du comment, c'est bientôt l'heure du dodo...

[Roland Chastain]

Une nouvelle version de la fonction EstPremier(), vraiment terrible celle-ci !

Un nombre qui n'est pas divisible par deux n'est pas divisible par quatre, ni par six, etc. Donc on essaie la division par deux, et on se dispense d'essayer la division par quatre. On est d'accord.
Mais de même, un nombre qui n'est pas divisible par trois, n'est pas divisible par six. Bref, l'idéal serait de n'essayer que des divisions par des nombres premiers. C'est le crible d'Ératosthène.
Pour mettre en œuvre cette méthode, je commence par remplir un tableau des n premiers nombres premiers. Ensuite je n'ai plus qu'à parcourir ce tableau pour obtenir les valeurs successives de mon diviseur. Du coup je trouve les jumeaux jusqu'à un million en une demi-seconde !
On pourrait remplir le tableau à l'exécution, mais pour un premier essai j'ai préféré faire un tableau en "dur".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
const cPremiers: array[1..1000]of integer = (
2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,
73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,
179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,
283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,
419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,
547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,
661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,
811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,
947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,
1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,
1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,
1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,
1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,1601,1607,1609,1613,1619,1621,1627,1637,1657,
1663,1667,1669,1693,1697,1699,1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,
1823,1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,1951,1973,1979,1987,
1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063,2069,2081,2083,2087,2089,2099,2111,2113,2129,
2131,2137,2141,2143,2153,2161,2179,2203,2207,2213,2221,2237,2239,2243,2251,2267,2269,2273,2281,2287,
2293,2297,2309,2311,2333,2339,2341,2347,2351,2357,2371,2377,2381,2383,2389,2393,2399,2411,2417,2423,
2437,2441,2447,2459,2467,2473,2477,2503,2521,2531,2539,2543,2549,2551,2557,2579,2591,2593,2609,2617,
2621,2633,2647,2657,2659,2663,2671,2677,2683,2687,2689,2693,2699,2707,2711,2713,2719,2729,2731,2741,
2749,2753,2767,2777,2789,2791,2797,2801,2803,2819,2833,2837,2843,2851,2857,2861,2879,2887,2897,2903,
2909,2917,2927,2939,2953,2957,2963,2969,2971,2999,3001,3011,3019,3023,3037,3041,3049,3061,3067,3079,
3083,3089,3109,3119,3121,3137,3163,3167,3169,3181,3187,3191,3203,3209,3217,3221,3229,3251,3253,3257,
3259,3271,3299,3301,3307,3313,3319,3323,3329,3331,3343,3347,3359,3361,3371,3373,3389,3391,3407,3413,
3433,3449,3457,3461,3463,3467,3469,3491,3499,3511,3517,3527,3529,3533,3539,3541,3547,3557,3559,3571,
3581,3583,3593,3607,3613,3617,3623,3631,3637,3643,3659,3671,3673,3677,3691,3697,3701,3709,3719,3727,
3733,3739,3761,3767,3769,3779,3793,3797,3803,3821,3823,3833,3847,3851,3853,3863,3877,3881,3889,3907,
3911,3917,3919,3923,3929,3931,3943,3947,3967,3989,4001,4003,4007,4013,4019,4021,4027,4049,4051,4057,
4073,4079,4091,4093,4099,4111,4127,4129,4133,4139,4153,4157,4159,4177,4201,4211,4217,4219,4229,4231,
4241,4243,4253,4259,4261,4271,4273,4283,4289,4297,4327,4337,4339,4349,4357,4363,4373,4391,4397,4409,
4421,4423,4441,4447,4451,4457,4463,4481,4483,4493,4507,4513,4517,4519,4523,4547,4549,4561,4567,4583,
4591,4597,4603,4621,4637,4639,4643,4649,4651,4657,4663,4673,4679,4691,4703,4721,4723,4729,4733,4751,
4759,4783,4787,4789,4793,4799,4801,4813,4817,4831,4861,4871,4877,4889,4903,4909,4919,4931,4933,4937,
4943,4951,4957,4967,4969,4973,4987,4993,4999,5003,5009,5011,5021,5023,5039,5051,5059,5077,5081,5087,
5099,5101,5107,5113,5119,5147,5153,5167,5171,5179,5189,5197,5209,5227,5231,5233,5237,5261,5273,5279,
5281,5297,5303,5309,5323,5333,5347,5351,5381,5387,5393,5399,5407,5413,5417,5419,5431,5437,5441,5443,
5449,5471,5477,5479,5483,5501,5503,5507,5519,5521,5527,5531,5557,5563,5569,5573,5581,5591,5623,5639,
5641,5647,5651,5653,5657,5659,5669,5683,5689,5693,5701,5711,5717,5737,5741,5743,5749,5779,5783,5791,
5801,5807,5813,5821,5827,5839,5843,5849,5851,5857,5861,5867,5869,5879,5881,5897,5903,5923,5927,5939,
5953,5981,5987,6007,6011,6029,6037,6043,6047,6053,6067,6073,6079,6089,6091,6101,6113,6121,6131,6133,
6143,6151,6163,6173,6197,6199,6203,6211,6217,6221,6229,6247,6257,6263,6269,6271,6277,6287,6299,6301,
6311,6317,6323,6329,6337,6343,6353,6359,6361,6367,6373,6379,6389,6397,6421,6427,6449,6451,6469,6473,
6481,6491,6521,6529,6547,6551,6553,6563,6569,6571,6577,6581,6599,6607,6619,6637,6653,6659,6661,6673,
6679,6689,6691,6701,6703,6709,6719,6733,6737,6761,6763,6779,6781,6791,6793,6803,6823,6827,6829,6833,
6841,6857,6863,6869,6871,6883,6899,6907,6911,6917,6947,6949,6959,6961,6967,6971,6977,6983,6991,6997,
7001,7013,7019,7027,7039,7043,7057,7069,7079,7103,7109,7121,7127,7129,7151,7159,7177,7187,7193,7207,
7211,7213,7219,7229,7237,7243,7247,7253,7283,7297,7307,7309,7321,7331,7333,7349,7351,7369,7393,7411,
7417,7433,7451,7457,7459,7477,7481,7487,7489,7499,7507,7517,7523,7529,7537,7541,7547,7549,7559,7561,
7573,7577,7583,7589,7591,7603,7607,7621,7639,7643,7649,7669,7673,7681,7687,7691,7699,7703,7717,7723,
7727,7741,7753,7757,7759,7789,7793,7817,7823,7829,7841,7853,7867,7873,7877,7879,7883,7901,7907,7919);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
program Jumeaux2;
 
{$IFDEF VPASCAL}
  {&PMTYPE VIO}
  {&USE32+}
{$ELSE}
  {$APPTYPE CONSOLE}
  {$IFDEF FPC}{$MODE DELPHI}{$ENDIF}
{$ENDIF}
 
{$B-}
 
uses
  Windows,  // GetTickCount
  SysUtils; // IntToStr
 
{$I Tableau.inc}
 
function EstPremier(const n: cardinal): boolean;
var
  i, d: cardinal;
begin
  if n < 2 then
    result := false
  else
    if n = 2 then
      result := true
    else
      if n mod 2 = 0 then
        result := false
      else
      begin
        i := 1;
        d := cPremiers[i];
        result := true;
        //while (d * d < n) and result do
        while (d * d <= n) and result do
        begin
          if n mod d = 0 then result := false;
          Inc(i);
          d := cPremiers[i];
        end;
      end;    
end;
 
function EstJumeau(const n: cardinal): boolean;
begin
  result := EstPremier(n) and (EstPremier(n - 2) or EstPremier(n + 2));
end;
 
var
  i: cardinal;
  a, b: cardinal;
  t: text;
begin
  Assign(t, 'Jumeaux.txt');
  Rewrite(t);
 
  a := GetTickCount;
 
  i := 1;
  while i <= 1E6 do
  begin
    if EstJumeau(i) then
      WriteLn(t, i);
    Inc(i, 2);
  end;
 
  b := GetTickCount;
 
  Close(t);
 
  WriteLn('Temps '#130'coul'#130' : ', IntToStr(b - a), ' millisecondes.');
  Write('Appuyez sur la touche Entr'#130'e... ');
  ReadLn;
end.

Attends un peu, car le fichier de résultat des versions 1 et 2 pesait 14186 octets, la version 3 (celle-ci) génère un truc de 14452 octets
Un peu la flemme de chercher le pourquoi du comment, c'est bientôt l'heure du dodo...

Bien vu, Jipété. Je ne m'explique pas non plus la différence. A suivre...

P.-S. Oui, j'ai cinquante lignes de différence entre un fichier et l'autre.
Pourtant les premiers et les derniers nombres de la liste sont les mêmes, enfin il m'a semblé.

[Roland Chastain]

J'ai trouvé l'erreur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
        //while (d * d < n) and result do
        while (d * d <= n) and result do

Avec la première formule, les nombres comme 9 (3*3), 25 (5*5)... devenaient premiers.

D'où l'excès de poids du fichier. Merci pour l'avertissement, Jipété.

Je vais éditer mon message précédent, pour y mettre le code corrigé.

[Jipété]

Une nouvelle version de la fonction EstPremier(), vraiment terrible celle-ci !
(...)
Du coup je trouve les jumeaux jusqu'à un million en une demi-seconde !

Quelle horreur : 9 millisecondes chez moi

Sinon, bien joué pour tout le reste

[e-ric]

Ma petite version :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
program Primes;
 
{$APPTYPE CONSOLE}
 
uses
  Windows,
  SysUtils,
  Classes;
 
var
  Nombres : array of boolean;
 
procedure FindPrimes(nmax: Integer);
var
  i,j, step : integer;
  sqrt_lim: integer;
begin
  Nombres[0] := False;
  Nombres[1] := False;
  Nombres[2] := True;
  for i := 3 to High(Nombres) do
    Nombres[i] := (i and 1) = 1;
 
  sqrt_lim := trunc(sqrt(nmax));
 
  for i := 2 to High(Nombres) do
    if Nombres[i] and (i <= sqrt_lim)then
    begin
      j := i*i; step := i * 2;
      while j <= High(Nombres)do
      begin
        Nombres[j] := False;
        inc(j, step);
      end;
    end;
End;
 
procedure WriteNombres;
var
  i : integer;
begin
  for i := 0 to High(Nombres) do
    if Nombres[i] then
      Write(Format('%9d ',[i]));
End;
 
// imprimer les nombres jumeaux
procedure WriteTwins;
var
  i : integer;
begin
  i := 1;
  while i < High(Nombres) do
  begin
    if Nombres[i] and Nombres[i-2] then
      WriteLn(Format('%9d %9d',[i-2, i]));
    Inc(i);
  end;
End;
 
function GetCeil: Integer;
var
  ValSaisie: string;
begin
  if not TryStrToInt(ParamStr(1), Result) then
  begin
    Write('Entrer la limite : ');
    ReadLn(ValSaisie);
    if not TryStrToInt(ValSaisie, Result) then
      raise Exception.Create('Pas de limite.');
  end;
End;
 
var
  nmax: Integer;
  t: Cardinal;
 
begin
//  nmax := GetCeil;
  nmax := 1000000;
  // Allocation initiale
  SetLength(Nombres, nmax);
  try
    try
      // Initialiser la liste
      t := GetTickCount;
      FindPrimes(nmax);
      t := GetTickCount - t;
//      WriteNombres;
//      WriteLn;
      WriteTwins;
      WriteLn('Temps écoulé : ', IntToStr(t), ' millisecondes.');
      ReadLn;
    finally
      Nombres := Nil;
    end;
  except
    on E: Exception do
      WriteLn(E.Message);
  end;
end.

Je ne chronomètre que le temps de calcul des nombres, pas de sortie en fichier.
Pourriez-vous comparer avec vos essais ? Etant donné les différences de machine, c'est pas objectif de parler de temps d'exécution...

@+

@+

[Roland Chastain]

Très joli, je trouve, et ça décoiffe !

[Jipété]

Pourriez-vous comparer avec vos essais ? Etant donné les différences de machine, c'est pas objectif de parler de temps d'exécution...

Ça fait rien
13 millisecondes,

[wiwaxia]

Bonjour,
Ayant fortuitement découvert le sujet de la discussion, j'ai été surpris que personne n'ait fait remarquer qu'à l'exception de 2 et 3, tous les nombres premiers sont de la forme (6k ± 1) puisqu'à partir de 5 le reste de leur division par 6 ne peut valoir que 1 ou 5 (sinon ils seraient divisibles par 2 ou 3).
Cette propriété permet d'accélérer l'exécution de la recherche à deux niveaux:
a) le balayage des entiers devient une recherche directe des premiers jumeaux par quelques instructions de la forme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
For k:= 1 TO Kmax DO 
           BEGIN
             p:= 6 * k; Dec(p); Tp:= TestP(p);
             q:= p + 2; Tq:= TestP(q);
             IF (Tp AND Tq) THEN BEGIN
                                   Inc(n); Liste[n]:= k
                                 END  
           END;

la récolte des résultats se réduisant à la consignation des valeurs de k dans une liste d'entiers (ou un fichier);
b) L'énumération des diviseurs, nécessaire lors de l'établissement du test de primalité (réalisé par la fonction booléenne "TestP(r)"), commence à 5 et se trouve allégée d'un tiers si l'on tient compte que ces diviseurs sont eux aussi de la forme (6l ± 1), puisque non multiples de 2 et 3; on l'obtient à l'aide d'une incrémentation alternée commençant par exemple par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Delta:= 2; d:= 1

suivie d'une boucle du type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
REPEAT
            IF Delta=4 THEN Delta:= 2
                           ELSE Delta:= 4; Inc(d, Delta);
                           ... { test de divisibilité }
         UNTIL ((d>Dmax) OR (Test))

Pour les grandes valeurs de k, le temps devrait être plus court.

Note: je n'ai pas compris que la variable booléenne "result" n'ait pas fait l'objet d'une déclaration en début de procédure; c'est peut-être lié aux directives de compilation, qui m'échappent.

[Roland Chastain]

Bonjour !

C'est intéressant, en effet.

Note: je n'ai pas compris que la variable booléenne "result" n'ait pas fait l'objet d'une déclaration en début de procédure; c'est peut-être lié aux directives de compilation, qui m'échappent.

Les compilateurs Delphi, Virtual Pascal et aussi Free Pascal avec la directive {$MODE DELPHI} permettent d'utiliser la variable (le mot-clé ?) "result" sans déclaration, dans toutes les fonctions. La variable n'est pas nécessairement de type booléen, mais du type du résultat renvoyé par la fonction.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
program ExempleResult;
 
{$IFDEF VPASCAL}
  {&PMTYPE VIO}
{$ELSE}
  {$APPTYPE CONSOLE}
  {$IFDEF FPC}{$MODE DELPHI}{$ENDIF}
{$ENDIF}
 
function Chaine: string;
begin
  result := 'bonjour';
end;
 
function Entier: integer;
begin
  result := 2;
end;
 
begin
  WriteLn(Chaine);
  WriteLn(Entier);
 
  Write('Appuyez sur la touche Entr'#130'e... ');
  ReadLn;
end.

[wiwaxia]

- Au Rédacteur Roland Chastain

Merci pour le renseignement, que je retiens d'autant plus que j'envisage de me convertir au Free Pascal (cela deviendra sans doute urgent, à partir du prochain mois d'avril, à moins que la Chine convainque Microsoft de surseoir à la mise au rancart de Windows XP).

- En ce qui concerne les valeurs alternée de l'incrément, il me revient que l'instruction conditionnelle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
IF Delta=4 THEN Delta:= 2
           ELSE Delta:= 4;

peut être plus simplement remplacée par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Delta:= 6 - Delta;

qui utilise l'application involutive f(x) = 6 - x .

[Roland Chastain]

Mais (si je puis me permettre), pourquoi ne pas proposer votre programme en entier ? Cela permettrait à chacun d'apprécier l'efficacité du procédé.

[e-ric]

Bonjour,
Ayant fortuitement découvert le sujet de la discussion, j'ai été surpris que personne n'ait fait remarquer qu'à l'exception de 2 et 3, tous les nombres premiers sont de la forme (6k ± 1) puisqu'à partir de 5 le reste de leur division par 6 ne peut valoir que 1 ou 5 (sinon ils seraient divisibles par 2 ou 3).

je ne suis pas matheux de profession ...

Note: je n'ai pas compris que la variable booléenne "result" n'ait pas fait l'objet d'une déclaration en début de procédure; c'est peut-être lié aux directives de compilation, qui m'échappent.

par contre, je suis développeur, pascalien entre autre, et je sais que result est implicitement déclarée dans une fonction ...

[wiwaxia]

Bonjour,
Je viens de réécrire le programme, qui semble fonctionner correctement; il liste sur fichier texte, en un peu plus d'une minute, les couples de premiers jumeaux compris entre 4 et 5000000 .
J'avais donné de tête (j'aurais dû l'écrire sur un papier) une initialisation incorrecte des variables "Delta" et "d"; les bonnes instructions sont:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

d:= 1;       Delta:= 2;

Faut-il envoyer le programme ? Je croyais que sur ce forum l'usage réprouvait ce genre de démarche.

[Roland Chastain]

Faut-il envoyer le programme ? Je croyais que sur ce forum l'usage réprouvait ce genre de démarche.

Ce qui est réprouvé, c'est (me semble-t-il) de faire le travail des étudiants à leur place. Autrement, c'est un forum dédié à la programmation : ce serait un comble qu'on ne puisse pas poster du code.

[Alcatîz]

Bonjour,

Une application permet de proposer des codes sources de manière très simple :
http://pascal.developpez.com/telecharger/
Il suffit de choisir la catégorie correspondant au compilateur.

[wiwaxia]

Bonjour,
Voici le programme, muni de plusieurs versions d'inventaire des paires de premiers jumeaux; de petites variantes de programmation entraînent effectivement de grands écarts sur la durée de calcul, comme j'ai pu le vérifier pour des entiers <=999999:
version 0: 29.9s version 3: 0.60 à 0.66s
version 1: 17.7s version 4: 0.60s
version 2: 0.720s
Les inventaires les plus rapides demandent:
- un établissement simultané du test de primalité pour les deux entiers (p, q);
- un arrêt de l'énumération des diviseurs dès qu'un cas de divisibilité est établi, soit en utilisant la racine carrée de (q), soit en augmentant progressivement la limite (Dmax) des diviseurs.
Il me paraît difficile de descendre en-dessous de 600 ms (pour N<=999999) ou 60 ms (pour N<=99999); cela dépend sans doute du PC, et de ce que fait exactement le programme (écrire ou non dans un fichier, par exemple).
J'aimerais connaître les temps d'exécution sur vos machines. Merci de me signaler les bourdes, qui peuvent encore traîner dans le texte.

Les limites (Kmin, Kmax) ont été déterminées de telle sorte qu'une paire de jumeaux figure dans la liste dès que l'un des entiers se trouve dans l'intervalle (Borne1, Borne2).

Note: Je mets le fichier .pas en pièce jointe, en espérant que l'indentation du texte sera préservée. Le code du 1er envoi était illisible.

[wiwaxia]

Détail amusant:
si l'on remplace dans la procédure "Inventaire" l'instruction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

WriteLn(FichierT, l:5, k:u, i:u, j:u);

par la séquence

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
IF (k=m+1) 
  THEN WriteLn(FichierT, l:5, k:u, i:u, j:u, '    Quadruplet')
  ELSE WriteLn(FichierT, l:5, k:u, i:u, j:u);	
m:= k

après y avoir déclaré et initialisé la variable supplémentaire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

m: LONGINT; ... m:= -1;

on voit apparaître les nombres premiers quadruplets, correspondant à deux paires consécutives de jumeaux, et de la forme
(6k-1, 6k+1, 6k+5, 6k+7).
La seule anomalie présente est le bloc initial (5, 7, 11, 13, 15, 17), unique sextuplet apparemment connu (de ce type) de nombres premiers.

http://en.wikipedia.org/wiki/Prime_quadruplet?oldid=