/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P O S I T I O N N E M E N T   D E S   2 8   P R E M I E R S   N O M B R E S   E N T I E R S                                */
/*        A V E C   C O N T R A I N T E S   S U R   U N E   S T R U C T U R E   H E X A G O N A L E  :                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/HexagonesPremiers.01$vv$c' :                                                                               */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130128102535).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  INCLUDES.01.I"

int       placer__NombresPremiers=VRAI;
                                        /* On utilise soit les nombres premiers ('VRAI'), ce qui est donc le probleme original,      */
                                        /* soit les mutiples de 3 ('FAUX') pour voir si le fait que les nombres soient premiers      */
                                        /* est vraiment essentiel (j'ai choisi les multiples de 3 un peu arbitrairement, mais        */
                                        /* malgre tout parce qu'il y en a 9 dans [1,28] (comme pour les nombres premiers...).        */
                                        /*                                                                                           */
                                        /* Aux environs du 20180629133309, j'ai lance un test sur les huit processeurs de            */
                                        /* '$CMAP28' -ex "porte-de-la-chapelle"- (soit 10 process...) avec les parametres suivants : */
                                        /*                                                                                           */
                                        /*                  amplitude du segment [PREMIERE_SOMME,DERNIERE_SOMME]      : [-6,+6]      */
                                        /*                  GRAINES              [GRAINE_MINIMALE,GRAINE_MAXIMALE]    : [1,1000000]  */
                                        /*                                                                                           */
                                        /* apres de nombreuses heures de calculs, aucune solution n'a ete trouvee (mais "l'absence   */
                                        /* de preuve n'est pas la preuve de l'absence").                                             */
                                        /*                                                                                           */
                                        /* Utiliser autre chose que les nombres premiers m'avait ete suggere par Jean Moreau de      */
                                        /* Saint-Martin ('v $Dcourrier_in/20180629122253 References...20180625090318.72DB68F8017')   */
                                        /* pour qui les nombres premiers etaient associes a la mutiplication (via la factorisation   */
                                        /* des nombres entiers), alors que dans ce probleme precis, on ne fait que des additions     */
                                        /* (mais on notera au passage que la conjecture de Goldbach porte sur les nombres premiers   */
                                        /* et uniquement leur addition ; d'ailleurs y-aurait-il un lien entre ce probleme et cette   */
                                        /* conjecture, voire avec d'hypothetiques formules engendrant tout ou partie de l'ensemble   */
                                        /* des nombres premiers ?)...                                                                */
                                        /*                                                                                           */
                                        /* Il serait interessant de rendre tous les sommets equivalents et donc ne conserver que la  */
                                        /* contrainte de la somme constante des trois nombres portes par chaque arete et ce afin     */
                                        /* de voir s'il existe des solutions avec des nombres "quelconques" (c'est-a-dire non tous   */
                                        /* premiers) sur les neuf sommets verts de 'v $xiirv/HEXA.12.hexagones.sommets.01'...        */
                                        /* C'est que permet l'indicateur 'privilegier_les_sommets_AFEHIJKLM' ci-apres a compter du   */
                                        /* 20180702142923...                                                                         */
int       privilegier_les_sommets_AFEHIJKLM=VRAI;
                                        /* Ceci a ete introduit le 20180702142923. Le mode 'VRAI' correspond au probleme original,   */
                                        /* alors que le mode 'FAUX' correspond a des experiences dans lesquelles les 28 premiers     */
                                        /* nombres entiers peuvent etre places sur n'importe quel sommet et ce quelles que soient    */
                                        /* leurs proprietes numeriques...                                                            */
                                        /*                                                                                           */
                                        /* Aux environs du 20180702144216, j'ai lance un test sur les huit processeurs de            */
                                        /* '$CMAP28' -ex "porte-de-la-chapelle"- (soit 10 process...) avec les parametres suivants : */
                                        /*                                                                                           */
                                        /*                  amplitude du segment [PREMIERE_SOMME,DERNIERE_SOMME]      : [-6,+6]      */
                                        /*                  GRAINES              [GRAINE_MINIMALE,GRAINE_MAXIMALE]    : [1,1000000]  */
                                        /*                                                                                           */
                                        /* pour voir ce qu'il se passe lorsqu'aucun sommet n'est privilegie (n'importe quel sommet   */
                                        /* peut accueillir n'importe quel nombre qu'il soit premier ou pas...).                      */
                                        /*                                                                                           */
                                        /* Aux environs du 20180704093258, ce test n'a pas trouve de solutions, mais evidemment      */
                                        /* cela ne prouve rien. En particulier, aucune solution avec les 9 nombres premiers n'a ete  */
                                        /* decouverte ; cela est lie au fait que l'espace de recherche est beaucoup plus vaste dans  */
                                        /* le cas ou aucun sommet n'est privilegie...                                                */

int       edition_NombresPremiers=FAUX;
int       edition_Triplets_______=FAUX;
int       edition_Occurences_____=VRAI;
int       edition_Aretes_________=FAUX;
int       edition_Resultat_______=VRAI;
int       edition_Resultat_Trace_=FAUX;
                                        /* Controle des differentes editions possibles...                                            */
                                        /*                                                                                           */
                                        /* ATTENTION, je note le 20180627152245 que "edition_Resultat_Trace_=VRAI" inhibe la sortie  */
                                        /* du message "Solution obtenue avec la graine ..." tant attendu...                          */

#define   VIDE                                                                                                                          \
                    (INDEX0-1)

#define   PREMIER_NOMBRE                                                                                                                \
                    1
#define   PREMIER_NOMBRE_A_TESTER                                                                                                       \
                    (PREMIER_NOMBRE+2)
#define   DERNIER_NOMBRE                                                                                                                \
                    28
#define   NOMBRE_DE_NOMBRES                                                                                                             \
                    (DERNIER_NOMBRE-PREMIER_NOMBRE+1)
                                        /* Definition des nombres entiers a etudier...                                               */

#define   EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE                                                                           \
                    FAUX
#define   EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______                                                                           \
                    VRAI
                                        /* Indicateurs divers...                                                                     */

#define   UTILISER_9_NOMBRES_PREMIERS                                                                                                   \
                    {                                                                                                                   \
                    for       (NombreEntier1=PREMIER_NOMBRE_A_TESTER ; NombreEntier1 <= DERNIER_NOMBRE ; NombreEntier1++)               \
                              {                                                                                                         \
                              int       NombreEntier2;                                                                                  \
                              int       EstPremier=EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______;                                 \
                                                                                                                                        \
                              for       (NombreEntier2=(PREMIER_NOMBRE+1) ; NombreEntier2 < NombreEntier1 ; NombreEntier2++)            \
                                        {                                                                                               \
                                        if        (TYPE_NOMBRE(NombreEntier2) == EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______)   \
                                                  {                                                                                     \
                                                  if        ((NombreEntier1 % NombreEntier2) == 0)                                      \
                                                            {                                                                           \
                                                            EstPremier=EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE;             \
                                                            }                                                                           \
                                                  else                                                                                  \
                                                            {                                                                           \
                                                            }                                                                           \
                                                  }                                                                                     \
                                        else                                                                                            \
                                                  {                                                                                     \
                                                  }                                                                                     \
                                        }                                                                                               \
                                                                                                                                        \
                              if        (EstPremier == EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______)                             \
                                        {                                                                                               \
                                        TYPE_NOMBRE(NombreEntier1)=EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______;                 \
                                        /* Construction de la liste des nombres premiers...                                          */ \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        TYPE_NOMBRE(NombreEntier1)=EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE;                 \
                                        /* Construction de la liste des nombres non premiers...                                      */ \
                                        }                                                                                               \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* On cherche a placer les 9 nombres premiers dans [1,28].                                   */

#define   UNITE_DE_MULTIPLICITE                                                                                                         \
                    3
#define   UTILISER_9_MULTIPLES_DE_TROIS                                                                                                 \
                    {                                                                                                                   \
                    for       (NombreEntier1=PREMIER_NOMBRE_A_TESTER ; NombreEntier1 <= DERNIER_NOMBRE ; NombreEntier1++)               \
                              {                                                                                                         \
                              if        ((NombreEntier1 % UNITE_DE_MULTIPLICITE) == 0)                                                  \
                                        {                                                                                               \
                                        TYPE_NOMBRE(NombreEntier1)=EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______;                 \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        TYPE_NOMBRE(NombreEntier1)=EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE;                 \
                                        }                                                                                               \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* On cherche a placer les 9 multiples de 3 dans [1,28] (introduit le 20180627183218).       */ \
                                        /*                                                                                           */ \
                                        /* Aux environs du 20180629133309, il semble que ce choix ne donne pas de solution...        */

typedef   struct
          {
          int       propriete;
          int       occurence;
          }         entier;
#define   TYPE_NOMBRE(nombre)                                                                                                           \
                    (LEntiers[nombre-PREMIER_NOMBRE].propriete)
#define   OCCURENCE_NOMBRE(nombre)                                                                                                      \
                    (LEntiers[nombre-PREMIER_NOMBRE].occurence)

int       NombreEntier1;
entier    LEntiers[NOMBRE_DE_NOMBRES];
                                        /* Definition des proprietes des nombres entiers et Compteur d'utilisation...                */

#define   PREMIERE_SOMME                                                                                                                \
                    (somme_moyenne_de_trois_nombres-1)
#define   DERNIERE_SOMME                                                                                                                \
                    (somme_moyenne_de_trois_nombres+1)
                                        /* Definition de la somme de trois nombres entiers.                                          */
                                        /*                                                                                           */
                                        /* ATTENTION : changer l'amplitude du segment precedent [-6,+6] implique de changer la ou    */
                                        /* les graines de permutation aleatoires puisqu'en effet cette amplitude conditionne         */
                                        /* directement le nombre de triplets et donc leur permutation. On notera aussi que cette     */
                                        /* amplitude est evidemment trop grande, mais que cela constitue une marge de securite...    */
                                        /*                                                                                           */
                                        /* Le 20130206153026, je suis passe de [-6,+6] a [-1,+1] (maintenant que la somme commune    */
                                        /* est connue et egale a 44). Cela permet de reduire considerablement le nombre de triplets  */
                                        /* et donc d'accelerer le processus...                                                       */
                                        /*                                                                                           */
                                        /* Le 20161115131020, je fait une remarque "cabalistique" concernant cette somme egale       */
                                        /* a 44. En effet :                                                                          */
                                        /*                                                                                           */
                                        /*                  44 = 4x11                                                                */
                                        /*                       - --                                                                */
                                        /*                                                                                           */
                                        /* Or la liste des neuf premiers nombres premiers est :                                      */
                                        /*                                                                                           */
                                        /*                                      11                                                   */
                                        /*                                      --                                                   */
                                        /*                  2    3    5    7         13   17   19   23                               */
                                        /*                 \________________/       \_________________/                              */
                                        /*                                                                                           */
                                        /*                 4 nombres premiers       4 nombres  premiers                              */
                                        /*                 -                        -                                                */
                                        /*                                                                                           */
                                        /* Le nombre premier 11 est donc au milieu et entoure a gauche et a droite de 4 nombres      */
                                        /* premiers...                                                                               */
                                        /*                                                                                           */
                                        /* Simple coincidence ?                                                                      */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Le 20170515111750, je note qu'une approche "brutale" de ce probleme devrait examiner :    */
                                        /*                                                                                           */
                                        /*        9! x 19! = 362.880 x 121.645.100.408.832.000 = 44.142.574.036.356.956.160.000      */
                                        /*                                                                                           */
                                        /* cas (il y a 9 nombres premiers et 19 qui ne le sont pas), ce qui fait beaucoup...         */

typedef   struct
          {
          int       Type;
          int       Somme;
          int       N1;
          int       N2;
          int       N3;
          int       Compteur;
          }         triplet;
#define   TripletType___(triplet)                                                                                                       \
                    (LTriplets[triplet].Type)
#define   TripletSomme__(triplet)                                                                                                       \
                    (LTriplets[triplet].Somme)
#define   TripletValeur1(triplet)                                                                                                       \
                    (LTriplets[triplet].N1)
#define   TripletValeur2(triplet)                                                                                                       \
                    (LTriplets[triplet].N2)
#define   TripletValeur3(triplet)                                                                                                       \
                    (LTriplets[triplet].N3)
#define   TripletCount__(triplet)                                                                                                       \
                    (LTriplets[triplet].Compteur)
                                        /* Definition des triplets de trois nombres...                                               */

int       nombre_de_sommes_de_trois_nombres=0;
int       somme_cumulee_des_sommes_de_trois_nombres=0;
int       somme_moyenne_de_trois_nombres;
int       somme_de_trois_nombres;

#define   PREMIER_TRIPLET                                                                                                               \
                    INDEX0
#define   MX_TRIPLETS                                                                                                                   \
                    1000000
triplet   LTriplets[MX_TRIPLETS];
int       ITriplets=PREMIER_TRIPLET;
int       MTriplets;
                                        /* Definition des triplets...                                                                */

#define   GENERE_TRIPLETS(type,nbre1,type1,sel1,nbre2,type2,sel2,nbre3,type3,sel3,condition,titre)                                      \
                    {                                                                                                                   \
                    int       ITriplets_initial=ITriplets;                                                                              \
                                                                                                                                        \
                    for       (somme_de_trois_nombres=MAX2(PREMIERE_SOMME,PREMIER_NOMBRE) ;                                             \
                               somme_de_trois_nombres<=DERNIERE_SOMME ;                                                                 \
                               somme_de_trois_nombres++                                                                                 \
                               )                                                                                                        \
                              {                                                                                                         \
                              int       nbre1;                                                                                          \
                                                                                                                                        \
                              for       (nbre1=PREMIER_NOMBRE ; nbre1 <= DERNIER_NOMBRE ; nbre1++)                                      \
                                        {                                                                                               \
                                        if        (TYPE_NOMBRE(nbre1) == type1)                                                         \
                                                  {                                                                                     \
                                                  int       nbre2;                                                                      \
                                                                                                                                        \
                                                  for       (nbre2=PREMIER_NOMBRE ; nbre2 <= DERNIER_NOMBRE ; nbre2++)                  \
                                        /* En partant de 'nbre2=nbre1', il n'y aura pas de "couples commutes" (c'est-a-dire on ne    */ \
                                        /* trouvera que {A,B,C} OU {C,B,A}). En partant de 'nbre2=PREMIER_NOMBRE', ces couples sont  */ \
                                        /* bien presents (c'est-a-dire a la fois {A,B,C} ET {C,B,A}). Dans ce dernier cas on pourra  */ \
                                        /* exclure l'un des deux en testant le compteur d'utilisation du nombre 'B'...               */ \
                                                            {                                                                           \
                                                            if        (TYPE_NOMBRE(nbre2) == type2)                                     \
                                                                      {                                                                 \
                                                                      if        (nbre1 != nbre2)                                        \
                                                                                {                                                       \
                                                                                int       nbre3=somme_de_trois_nombres-(nbre1+nbre2);   \
                                                                                                                                        \
                                                                                if        (         (nbre3 >= PREMIER_NOMBRE)           \
                                                                                          &&        (nbre3 <= DERNIER_NOMBRE)           \
                                                                                          &&        (nbre3 != nbre1)                    \
                                                                                          &&        (nbre3 != nbre2)                    \
                                                                                          &&        (condition)                         \
                                                                                           )                                            \
                                                                                          {                                             \
                                                                                          if        (TYPE_NOMBRE(nbre3) == type3)       \
                                                                                                    {                                   \
                                                                                                    TripletType___(ITriplets)=type;     \
                                                                                                                                        \
                                                                                                    TripletSomme__(ITriplets)           \
                                                                                                    =somme_de_trois_nombres;            \
                                                                                                                                        \
                                                                                                    TripletValeur1(ITriplets)           \
                                                                                                    =sel1(nbre1,nbre2,nbre3);           \
                                                                                                                                        \
                                                                                                    TripletValeur2(ITriplets)           \
                                                                                                    =sel2(nbre1,nbre2,nbre3);           \
                                                                                                                                        \
                                                                                                    TripletValeur3(ITriplets)           \
                                                                                                    =sel3(nbre1,nbre2,nbre3);           \
                                                                                                                                        \
                                                                                                    TripletCount__(ITriplets)=0;        \
                                                                                                                                        \
                                                                                                    if        (ITriplets < MX_TRIPLETS) \
                                                                                                              {                         \
                                                                                                              ITriplets++;              \
                                                                                                              }                         \
                                                                                                    else                                \
                                                                                                              {                         \
                                                                                                              printf("DEBORDEMENT\n");  \
                                                                                                              }                         \
                                                                                                    }                                   \
                                                                                          else                                          \
                                                                                                    {                                   \
                                                                                                    }                                   \
                                                                                          }                                             \
                                                                                else                                                    \
                                                                                          {                                             \
                                                                                          }                                             \
                                                                                }                                                       \
                                                                      else                                                              \
                                                                                {                                                       \
                                                                                }                                                       \
                                                                      }                                                                 \
                                                            else                                                                        \
                                                                      {                                                                 \
                                                                      }                                                                 \
                                                            }                                                                           \
                                                  }                                                                                     \
                                        else                                                                                            \
                                                  {                                                                                     \
                                                  }                                                                                     \
                                        }                                                                                               \
                              }                                                                                                         \
                                                                                                                                        \
                    if        (ITriplets > 0)                                                                                           \
                              {                                                                                                         \
                              ITriplets--;                                                                                              \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    MTriplets=ITriplets;                                                                                                \
                                                                                                                                        \
                    if        (edition_Triplets_______)                                                                                 \
                              {                                                                                                         \
                              int       ITriplets_edition;                                                                              \
                              printf(titre);                                                                                            \
                                                                                                                                        \
                              for       (ITriplets_edition=ITriplets_initial ; ITriplets_edition <= MTriplets ; ITriplets_edition++)    \
                                        {                                                                                               \
                                        printf("%d (%d) %d=(%d,%d,%d)\n"                                                                \
                                              ,ITriplets_edition                                                                        \
                                              ,TripletType___(ITriplets_edition)                                                        \
                                              ,TripletSomme__(ITriplets_edition)                                                        \
                                              ,TripletValeur1(ITriplets_edition)                                                        \
                                              ,TripletValeur2(ITriplets_edition)                                                        \
                                              ,TripletValeur3(ITriplets_edition)                                                        \
                                               );                                                                                       \
                                        }                                                                                               \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }

#define   PREMIER_SOMMET                                                                                                                \
                    INDEX0
enum      nom_sommets
          {
           C=PREMIER_SOMMET
          ,G
          ,H
          ,I
          ,J
          ,B
          ,A
          ,F
          ,E
          ,D
          ,K
          ,L
          ,M
          };
typedef   struct
          {
          int       Valeur;
          double    x,y;
          }         sommet;
#define   SommetValeur(sommet)                                                                                                          \
                    (LSommets[sommet].Valeur)
#define   RAYON_HEXAGONES                                                                                                               \
                    0.5
#define   X_CENTRE                                                                                                                      \
                    0.5
#define   Y_CENTRE                                                                                                                      \
                    0.5
#define   SommetX(sommet)                                                                                                               \
                    (LSommets[sommet].x)
#define   SommetY(sommet)                                                                                                               \
                    (LSommets[sommet].y)
#define   INITIALISATION_SOMMET(sommet,angle1,angle2)                                                                                   \
                    {                                                                                                                   \
                    if        (sommet <= NombreVersIndex(PREMIER_SOMMET+NOMBRE_MAXIMAL_DE_SOMMETS))                                     \
                              {                                                                                                         \
                              SommetValeur(sommet)=VIDE;                                                                                \
                                                                                                                                        \
                              SommetX(sommet)=X_CENTRE+(RAYON_HEXAGONES*cos(angle1))+(RAYON_HEXAGONES*cos(angle2));                     \
                              SommetY(sommet)=Y_CENTRE+(RAYON_HEXAGONES*sin(angle1))+(RAYON_HEXAGONES*sin(angle2));                     \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              printf("Debordement de la liste des sommets (%d)\n",sommet);                                              \
                              }                                                                                                         \
                    }
                                        /* Definition des sommets...                                                                 */

#define   NOMBRE_MAXIMAL_DE_SOMMETS                                                                                                     \
                    NOMBRE_DE_NOMBRES
sommet    LSommets[NOMBRE_MAXIMAL_DE_SOMMETS];
                                        /* Definition des sommets (en notant que le nombre est trop grand, mais peu importe...).     */

#define   PREMIERE_ARETE                                                                                                                \
                    INDEX0
enum      type_des_aretes
          {
           P1_M_P2
          ,P__A_B_
          ,A__B_P_
          ,A__B_C_
          };
typedef   struct
          {
          int       Sommet1;
          int       Sommet2;
          int       Type;
          int       Triplet;
          int       Horloge;
          }         arete;
#define   AreteSommet1(arete)                                                                                                           \
                    (LAretes[arete].Sommet1)
#define   AreteSommet2(arete)                                                                                                           \
                    (LAretes[arete].Sommet2)
#define   AreteType___(arete)                                                                                                           \
                    (LAretes[arete].Type)
#define   AreteTriplet(arete)                                                                                                           \
                    (LAretes[arete].Triplet)
#define   AreteHorloge(arete)                                                                                                           \
                    (LAretes[arete].Horloge)
#define   INITIALISATION_ARETE(sommet1,sommet2,type)                                                                                    \
                    {                                                                                                                   \
                    AreteSommet1(IAretes)=sommet1;                                                                                      \
                    AreteSommet2(IAretes)=sommet2;                                                                                      \
                    AreteType___(IAretes)=type;                                                                                         \
                    AreteTriplet(IAretes)=VIDE;                                                                                         \
                                                                                                                                        \
                    if        (IAretes < NombreVersIndex(NOMBRE_MAXIMAL_D_ARETES))                                                      \
                              {                                                                                                         \
                              IAretes++;                                                                                                \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              printf("Debordement de la liste des aretes (%d)\n",IAretes);                                              \
                              }                                                                                                         \
                    }
                                        /* Definition des aretes...                                                                  */

                                        /* Definition des notations :                                                                */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                                     [J04]             [I03]                               */
                                        /*                                          P-----B-----P                                    */
                                        /*                                         /             \                                   */
                                        /*                                        /      [03]     \                                  */
                                        /*                                       B [04]            B [02]                            */
                                        /*                                      /                   \                                */
                                        /*                   [A06]             /                     \                               */
                                        /*                        P-----B-----C [B05]                 P [H02]                        */
                                        /*                       /             \                     /                               */
                                        /*                      /      [06]     \                   /                                */
                                        /*                     B [07]            B [05]            B [01]                            */
                                        /*                    /                   \               /                                  */
                                        /*                   /                     \             /                                   */
                                        /*            [F07] P                 [C00] A-----B-----C [G01]                              */
                                        /*                   \                     /             \                                   */
                                        /*                    \                   /      [00]     \                                  */
                                        /*                     B [08]            B [10]            B [14]                            */
                                        /*                      \               /                   \                                */
                                        /*                       \             /                     \                               */
                                        /*                        P-----B-----C [D09]                 P [M12]                        */
                                        /*                   [E08]             \                     /                               */
                                        /*                             [09]     \                   /                                */
                                        /*                                       B [11]            B [13]                            */
                                        /*                                        \               /                                  */
                                        /*                                         \             /                                   */
                                        /*                                          P-----B-----P                                    */
                                        /*                                     [K10]             [L11]                               */
                                        /*                                               [12]                                        */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* ou '[Xnn]' identifie un sommet (son nom 'X' et son numero 'nn'), alors que '[nn]'         */
                                        /* numerote une arete. Les lettres utilisees {A,B,C,P} designent les types de nombres :      */
                                        /*                                                                                           */
                                        /*        A         Sommet triple "internes" (trois aretes y convergent au centre),          */
                                        /*        B         Milieu des aretes,                                                       */
                                        /*        C         Sommet triple "externes" (trois aretes y convergent a la peripherie),    */
                                        /*        P         Sommet double (deux aretes y convergent, porteur d'un nombre Premier).   */
                                        /*                                                                                           */
                                        /* Le but du jeu est d'obtenir une somme S identique pour tous les triplets portes par       */
                                        /* toutes les aretes (cette somme commune semble etre egale a 44...).                        */
#define   GRAINE_MINIMALE                                                                                                               \
                    998
int       graine_minimale=GRAINE_MINIMALE;
#define   GRAINE_MAXIMALE                                                                                                               \
                    998
int       graine_maximale=GRAINE_MAXIMALE;
                                        /* ATTENTION : la ou les graines utilisees sont completement dependantes de la definition    */
                                        /* de {DERNIERE_SOMME,DERNIERE_SOMME)...                                                     */
                                        /*                                                                                           */
                                        /* On notera que les graines {2194,7026,8066,11259,12901,21597,...} donnent des solutions    */
                                        /* apparemment diverses, mais en fait identiques a des rotations et symetries pres (voir     */
                                        /* a ce propos un commentaire final et 'v $xiirv/HEXA.12.00998' qui est LA solution...).     */
                                        /*                                                                                           */
                                        /* Le 20180627152245, je remplace la graine '2194' par '998' car, en effet, cette derniere   */
                                        /* a l'avantage de donner une bonne solution directememt, l'ensemble des autres parametres   */
                                        /* etant inchanges...                                                                        */
#define   NOMBRE_MAXIMAL_D_ARETES                                                                                                       \
                    NOMBRE_DE_NOMBRES
int       IAretes=PREMIERE_ARETE;
int       MAretes;
arete     LAretes[NOMBRE_MAXIMAL_D_ARETES];
                                        /* Definition des aretes (en notant que le nombre est trop grand, mais peu importe...).      */

extern    void      srand48();
extern    double    drand48();
                                        /* Voir le 20130322101704 'v $xtc/Check_drand48.01$vv$c 20130322100813' pour garantir la     */
                                        /* compatibilite de 'drand48(...)'.                                                          */
#define   NOMBRE_D_INDEX_ALEATOIRES                                                                                                     \
                    IndexVersNombre(MTriplets)
#define   INDEX_ALEATOIRE                                                                                                               \
                    (int)(((PREMIER_TRIPLET) + (((MTriplets)-(PREMIER_TRIPLET))*(drand48())))+0.9999)

int       main()
          {
          int       ItererAretes0;
          int       ITriplets0;

          TYPE_NOMBRE(PREMIER_NOMBRE+0)=EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE;
          TYPE_NOMBRE(PREMIER_NOMBRE+1)=EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______;

          if        (placer__NombresPremiers)
                    {
                    UTILISER_9_NOMBRES_PREMIERS;
                    }
          else
                    {
                    UTILISER_9_MULTIPLES_DE_TROIS;
                    }

          for       (NombreEntier1=PREMIER_NOMBRE_A_TESTER ; NombreEntier1 <= DERNIER_NOMBRE ; NombreEntier1++)
                    {
                    OCCURENCE_NOMBRE(NombreEntier1)=0;
                    }

          if        (edition_NombresPremiers)
                    {
                    int       NombreEntier1_edition;
                    for       (NombreEntier1_edition=PREMIER_NOMBRE ; NombreEntier1_edition <= DERNIER_NOMBRE ; NombreEntier1_edition++)
                              {
                              if        (TYPE_NOMBRE(NombreEntier1_edition) == EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______)
                                        {
                                        printf("%d premier.\n",NombreEntier1_edition);
                                        /* Edition eventuelle de la liste des nombres premiers...                                    */
                                        }
                              else
                                        {
                                        }
                              }

                    printf("\n");
                    }
          else
                    {
                    }

          for       (NombreEntier1=PREMIER_NOMBRE ; NombreEntier1 <= DERNIER_NOMBRE ; NombreEntier1++)
                    {
                    int       NombreEntier2;

                    for       (NombreEntier2=PREMIER_NOMBRE ; NombreEntier2 <= DERNIER_NOMBRE ; NombreEntier2++)
                              {
                              int       NombreEntier3;

                              for       (NombreEntier3=PREMIER_NOMBRE ; NombreEntier3 <= DERNIER_NOMBRE ; NombreEntier3++)
                                        {
                                        if        (         (NombreEntier1 != NombreEntier2)
                                                  &&        (NombreEntier2 != NombreEntier3)
                                                  &&        (NombreEntier3 != NombreEntier1)
                                                   )
                                                  {
                                                  somme_cumulee_des_sommes_de_trois_nombres
                                                  =somme_cumulee_des_sommes_de_trois_nombres+(NombreEntier1+NombreEntier2+NombreEntier3) ;
                                                  nombre_de_sommes_de_trois_nombres++;
                                                  }
                                        else
                                                  {
                                                  }
                                        }
                              }
                    }

          somme_moyenne_de_trois_nombres = somme_cumulee_des_sommes_de_trois_nombres/nombre_de_sommes_de_trois_nombres;
                                        /* Calcul de la somme moyenne de trois nombres entiers differents choisis dans le segment    */
                                        /* [PREMIER_NOMBRE,DERNIER_NOMBRE].                                                          */

          if        (edition_Triplets_______)
                    {
                    printf("SommeMoyenne=%d\n\n",somme_moyenne_de_trois_nombres);
                    }
          else
                    {
                    }

          GENERE_TRIPLETS(P1_M_P2
                         ,NombreEntierP1,EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______,SE13
                         ,NombreEntierP2,EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______,SE33
                         ,NombreEntierM_,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE23
                         ,VRAI
                         ,"P1+M+P2\n\n"
                          );
                                        /* Les nombres 'P1' et 'P2' doivent etre premiers contrairement a 'M' ; ils doivent etre     */
                                        /* de plus tous les trois differents deux a deux...                                          */

          GENERE_TRIPLETS(P__A_B_
                         ,NombreEntierP,EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______,SE13
                         ,NombreEntierA,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE23
                         ,NombreEntierB,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE33
                         ,(NombreEntierB != NombreEntierA)
                         ,"P+A+B\n\n"
                          );
                                        /* Le nombre 'P' doit etre premier contrairement a 'A' et 'B' ; ils doivent etre de plus     */
                                        /* tous les trois differents deux a deux...                                                  */

          GENERE_TRIPLETS(A__B_P_
                         ,NombreEntierP,EST_PREMIER______OU__POSSEDE_AUTRE_PROPRIETE_______,SE33
                         ,NombreEntierA,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE23
                         ,NombreEntierB,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE13
                         ,(NombreEntierB != NombreEntierA)
                         ,"A+B+P\n\n"
                          );
                                        /* Afin de generer {A,B,P} (sachant que ci-dessus, c'est {P,A,B} qui avait ete genere...),   */
                                        /* mais cela va-t-il etre utile ? Ne peut-on faire jouer une "commutativite"...              */

          GENERE_TRIPLETS(A__B_C_
                         ,NombreEntierA,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE13
                         ,NombreEntierB,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE23
                         ,NombreEntierC,EST_NON_PREMIER__ET__NE_POSSEDE_PAS_AUTRE_PROPRIETE,SE33
                         ,(NombreEntierC != NombreEntierB)
                         ,"A+B+C\n\n"
                          );
                                        /* Aucun des nombres 'A', 'B' et 'C' ne doit etre premier ; ils doivent etre de plus         */
                                        /* tous les trois differents deux a deux...                                                  */

          INITIALISATION_SOMMET(C,3*PI_SUR_3,0*PI_SUR_3);
          INITIALISATION_SOMMET(G,1*PI_SUR_3,5*PI_SUR_3);
          INITIALISATION_SOMMET(H,1*PI_SUR_3,0*PI_SUR_3);
          INITIALISATION_SOMMET(I,1*PI_SUR_3,1*PI_SUR_3);
          INITIALISATION_SOMMET(J,1*PI_SUR_3,2*PI_SUR_3);
          INITIALISATION_SOMMET(B,3*PI_SUR_3,1*PI_SUR_3);
          INITIALISATION_SOMMET(A,3*PI_SUR_3,2*PI_SUR_3);
          INITIALISATION_SOMMET(F,3*PI_SUR_3,3*PI_SUR_3);
          INITIALISATION_SOMMET(E,3*PI_SUR_3,4*PI_SUR_3);
          INITIALISATION_SOMMET(D,3*PI_SUR_3,5*PI_SUR_3);
          INITIALISATION_SOMMET(K,5*PI_SUR_3,4*PI_SUR_3);
          INITIALISATION_SOMMET(L,5*PI_SUR_3,5*PI_SUR_3);
          INITIALISATION_SOMMET(M,5*PI_SUR_3,0*PI_SUR_3);
                                        /* Les sommets sont initialement vides...                                                    */

          if        (privilegier_les_sommets_AFEHIJKLM)
                                        /* Test introduit le 20180702142923...                                                       */
                    {
                    INITIALISATION_ARETE(C,G,A__B_C_);
                    INITIALISATION_ARETE(G,H,A__B_P_);
                    INITIALISATION_ARETE(H,I,P1_M_P2);
                    INITIALISATION_ARETE(I,J,P1_M_P2);
                    INITIALISATION_ARETE(J,B,P__A_B_);
                    INITIALISATION_ARETE(B,C,A__B_C_);
                    INITIALISATION_ARETE(B,A,A__B_P_);
                    INITIALISATION_ARETE(A,F,P1_M_P2);
                    INITIALISATION_ARETE(F,E,P1_M_P2);
                    INITIALISATION_ARETE(E,D,P__A_B_);
                    INITIALISATION_ARETE(D,C,A__B_C_);
                    INITIALISATION_ARETE(D,K,A__B_P_);
                    INITIALISATION_ARETE(K,L,P1_M_P2);
                    INITIALISATION_ARETE(L,M,P1_M_P2);
                    INITIALISATION_ARETE(M,G,P__A_B_);
                                        /* Cas du probleme original pour lequel les somments {A,F,E,H,I,J,K,L,M} ne peuvent          */
                                        /* accueillir que des nombres premiers...                                                    */
                    }
          else
                    {
                    INITIALISATION_ARETE(C,G,A__B_C_);
                    INITIALISATION_ARETE(G,H,A__B_C_);
                    INITIALISATION_ARETE(H,I,A__B_C_);
                    INITIALISATION_ARETE(I,J,A__B_C_);
                    INITIALISATION_ARETE(J,B,A__B_C_);
                    INITIALISATION_ARETE(B,C,A__B_C_);
                    INITIALISATION_ARETE(B,A,A__B_C_);
                    INITIALISATION_ARETE(A,F,A__B_C_);
                    INITIALISATION_ARETE(F,E,A__B_C_);
                    INITIALISATION_ARETE(E,D,A__B_C_);
                    INITIALISATION_ARETE(D,C,A__B_C_);
                    INITIALISATION_ARETE(D,K,A__B_C_);
                    INITIALISATION_ARETE(K,L,A__B_C_);
                    INITIALISATION_ARETE(L,M,A__B_C_);
                    INITIALISATION_ARETE(M,G,A__B_C_);
                                        /* Cas ou aucun sommet n'est "privilegie"...                                                 */
                    }

          MAretes=IAretes-1;

          if        (edition_Aretes_________)
                    {
                    int       IAretes_edition;
                    for       (IAretes_edition=PREMIERE_ARETE ; IAretes_edition <= MAretes ; IAretes_edition++)
                              {
                              printf("Arete%d=(%d,%d)\n"
                                    ,IAretes_edition
                                    ,AreteSommet1(IAretes_edition)
                                    ,AreteSommet2(IAretes_edition)
                                     );
                              }
                    }
          else
                    {
                    }

          {
                                        /* Ouverture d'un nouveau bloc destine a la declaration de variables locales...              */
          int       graine;

          gGet(graine_minimale,"GraineMinimale",GRAINE_MINIMALE);
          gGet(graine_maximale,"GraineMaximale",GRAINE_MAXIMALE);
                                        /* Parametrage eventuel du nombre d'iterations de permutations aleatoires de 'gITriplets0'   */
                                        /* et de 'gITripletsN' grace aux deux variables 'setenv' {$GraineMinimale,$GraineMaximale}.  */

          for       (graine=graine_minimale ; graine <= graine_maximale ; graine++)
                    {
                    int       horloge=0;
                                        /* Horloge permettant d'ordonner temporellement les differentes operations...                */

                    int       index_sequentiel;
                    int       index_aleatoires[NOMBRE_D_INDEX_ALEATOIRES];
                    int       occurence_des_index_aleatoires[NOMBRE_D_INDEX_ALEATOIRES];

                    srand48(graine);

                    for       (index_sequentiel=PREMIER_TRIPLET ; index_sequentiel <= MTriplets ; index_sequentiel++)
                              {
                              occurence_des_index_aleatoires[index_sequentiel]=FAUX;
                              }

                    for       (index_sequentiel=PREMIER_TRIPLET ; index_sequentiel <= MTriplets ; index_sequentiel++)
                              {
                              int       boucler=VRAI;
                              while     (boucler == VRAI)
                                        {
                                        int       index_aleatoire_courant=INDEX_ALEATOIRE;
                                        if        (         (index_aleatoire_courant >= PREMIER_TRIPLET)
                                                  &&        (index_aleatoire_courant <= MTriplets)
                                                   )
                                                  {
                                                  }
                                        else
                                                  {
                                                  index_aleatoire_courant = (PREMIER_TRIPLET+MTriplets)/2;
                                                  printf("Debordement des index aleatoires.\n");
                                                  }

                                        if        (occurence_des_index_aleatoires[index_aleatoire_courant] == FAUX)
                                                  {
                                                  occurence_des_index_aleatoires[index_aleatoire_courant]=VRAI;
                                                  index_aleatoires[index_sequentiel]=index_aleatoire_courant;
                                                  boucler=FAUX;
                                                  }
                                        else
                                                  {
                                                  }
                                        }
                              }
                    {
                                        /* Ouverture d'un nouveau bloc destine a la declaration de variables locales...              */
                    int       NombreFinalDAretesAyantUnTriplet;
                    int       NombreMaximalDAretesAyantUnTriplet=0;
                    int       ITriplets0DuNombreMaximalDAretesAyantUnTriplet;
                    int       SommeDuNombreMaximalDAretesAyantUnTriplet;

                    int       gITriplets0;
                    int       parcourir_la_liste_des_triplets_pour_l_arete_0=VRAI;

                    for       (gITriplets0=PREMIER_TRIPLET ; gITriplets0 <= MTriplets ; gITriplets0++)
                              {
                              int       ITriplets0=index_aleatoires[gITriplets0];
                              int       NombreCourantDAretesAyantUnTriplet=0;
                              horloge++;

                              if        (parcourir_la_liste_des_triplets_pour_l_arete_0 == VRAI)
                                        {
                                        int       IAretes0=PREMIERE_ARETE;

                                        if        (TripletType___(ITriplets0) == AreteType___(IAretes0))
                                                  {
                                                  int       somme____initiale=TripletSomme__(ITriplets0);
                                                  int       valeur_precedente=TripletValeur3(ITriplets0);
                                                  int       IAretesN;
                                                  int       parcourir_la_liste_des_aretes=VRAI;

                                                  int       nombre;
                                                  for       (nombre=PREMIER_NOMBRE ; nombre <= DERNIER_NOMBRE ; nombre++)
                                                            {
                                                            OCCURENCE_NOMBRE(nombre)=0;
                                                            }

                                                  horloge++;

                                                  AreteTriplet(IAretes0)=ITriplets0;
                                                  AreteHorloge(IAretes0)=horloge;
                                                  OCCURENCE_NOMBRE(TripletValeur1(ITriplets0))++;
                                                  OCCURENCE_NOMBRE(TripletValeur2(ITriplets0))++;
                                                  OCCURENCE_NOMBRE(TripletValeur3(ITriplets0))++;
                                                  SommetValeur(AreteSommet1(IAretes0))=TripletValeur1(ITriplets0);
                                                  SommetValeur(AreteSommet2(IAretes0))=TripletValeur3(ITriplets0);
                                                  NombreCourantDAretesAyantUnTriplet++;

                                                  for       (IAretesN=IAretes0+1 ; IAretesN <= MAretes ; IAretesN++)
                                                            {
                                                            horloge++;

                                                            if        (parcourir_la_liste_des_aretes == VRAI)
                                                                      {
                                                                      int       gITripletsN;
                                                                      int       parcourir_la_liste_des_triplets_pour_l_arete_N=VRAI;

                                                                      for       (gITripletsN=PREMIER_TRIPLET ; gITripletsN <= MTriplets ; gITripletsN++)
                                                                                {
                                                                                int       ITripletsN=index_aleatoires[gITripletsN];
                                                                                horloge++;

                                                                                if        (edition_Occurences_____)
                                                                                          {
                                                                                          if        (         (OCCURENCE_NOMBRE(TripletValeur1(ITripletsN)) > 1)
                                                                                                    ||        (OCCURENCE_NOMBRE(TripletValeur2(ITripletsN)) > 1)
                                                                                                    ||        (OCCURENCE_NOMBRE(TripletValeur3(ITripletsN)) > 1)
                                                                                                     )
                                                                                                    {
                                                                                                    printf("Probleme d'occurence avec le triplet %d=(%d,%d,%d) occurences=(%d,%d,%d) sur l'arete %d     horloge=%d.\n"
                                                                                                          ,ITripletsN
                                                                                                          ,TripletValeur1(ITripletsN)
                                                                                                          ,TripletValeur2(ITripletsN)
                                                                                                          ,TripletValeur3(ITripletsN)
                                                                                                          ,OCCURENCE_NOMBRE(TripletValeur1(ITripletsN))
                                                                                                          ,OCCURENCE_NOMBRE(TripletValeur2(ITripletsN))
                                                                                                          ,OCCURENCE_NOMBRE(TripletValeur3(ITripletsN))
                                                                                                          ,IAretesN
                                                                                                          ,horloge
                                                                                                           );
                                                                                                    }
                                                                                          else
                                                                                                    {
                                                                                                    }
                                                                                          }
                                                                                else
                                                                                          {
                                                                                          }

                                                                                if        (parcourir_la_liste_des_triplets_pour_l_arete_N == VRAI)
                                                                                          {
                                                                                          if        (ITripletsN != ITriplets0)
                                                                                                    {
                                                                                                    if        (TripletType___(ITripletsN) == AreteType___(IAretesN))
                                                                                                              {
                                                                                                              int       valeur___courante=TripletValeur1(ITripletsN);

                                                                                                              if        (         (somme____initiale == TripletSomme__(ITripletsN))
                                                                                                                        &&        (valeur_precedente == valeur___courante)
                                                                                                                         )
                                                                                                                        {
                                                                                                                        if        (         (AreteSommet1(IAretesN) < AreteSommet2(IAretesN))
                                                                                                                                  &&        (OCCURENCE_NOMBRE(TripletValeur1(ITripletsN)) == 1)
                                                                                                                                  &&        (OCCURENCE_NOMBRE(TripletValeur2(ITripletsN)) == 0)
                                                                                                                                  &&        (OCCURENCE_NOMBRE(TripletValeur3(ITripletsN)) == 0)
                                                                                                                                   )
                                        /* Cas ou l'on progresse sur la structure par numero croissant de sommets (a priori, le      */
                                        /* sommet atteint ne l'a pas encore ete...) :                                                */
                                                                                                                                  {
                                                                                                                                  OCCURENCE_NOMBRE(TripletValeur2(ITripletsN))++;
                                                                                                                                  OCCURENCE_NOMBRE(TripletValeur3(ITripletsN))++;
                                                                                                                                  AreteTriplet(IAretesN)=ITripletsN;
                                                                                                                                  AreteHorloge(IAretesN)=horloge;
                                                                                                                                  SommetValeur(AreteSommet1(IAretesN))=TripletValeur1(ITripletsN);
                                                                                                                                  SommetValeur(AreteSommet2(IAretesN))=TripletValeur3(ITripletsN);
                                                                                                                                  valeur_precedente=TripletValeur3(ITripletsN);
                                                                                                                                  NombreCourantDAretesAyantUnTriplet++;
                                                                                                                                  parcourir_la_liste_des_triplets_pour_l_arete_N=FAUX;
                                        /* Abandon de la boucle ('parcourir_la_liste_des_triplets_pour_l_arete_N') :                 */
                                        /*                                                                                           */
                                        /*             for  (ITripletsN=PREMIER_TRIPLET ; ITripletsN <= MTriplets ; ITripletsN++)    */
                                        /*                                                                                           */
                                        /* car, en effet, le triplet 'ITripletsN' a pu etre attache a l'arete 'IAretesN' et on       */
                                        /* peut donc passser a l'arete suivante...                                                   */
                                                                                                                                  }
                                                                                                                        else
                                                                                                                                  {
                                                                                                                                  }

                                                                                                                        if        (         (AreteSommet1(IAretesN) > AreteSommet2(IAretesN))
                                                                                                                                  &&        (TripletValeur3(ITripletsN) == SommetValeur(AreteSommet2(IAretesN)))
                                                                                                                                  &&        (OCCURENCE_NOMBRE(TripletValeur1(ITripletsN)) == 1)
                                                                                                                                  &&        (OCCURENCE_NOMBRE(TripletValeur2(ITripletsN)) == 0)
                                                                                                                                  &&        (OCCURENCE_NOMBRE(TripletValeur3(ITripletsN)) == 1)
                                                                                                                                   )
                                        /* Cas ou l'on progresse sur la structure par numero decroissant de sommets (le sommet       */
                                        /* atteint l'a deja ete, la structure n'etant pas lineaire...) :                             */
                                                                                                                                  {
                                                                                                                                  OCCURENCE_NOMBRE(TripletValeur2(ITripletsN))++;
                                                                                                                                  AreteTriplet(IAretesN)=ITripletsN;
                                                                                                                                  AreteHorloge(IAretesN)=horloge;
                                                                                                                                  SommetValeur(AreteSommet1(IAretesN))=TripletValeur1(ITripletsN);
                                                                                                                                  SommetValeur(AreteSommet2(IAretesN))=TripletValeur3(ITripletsN);
                                                                                                                                  NombreCourantDAretesAyantUnTriplet++;
                                                                                                                                  parcourir_la_liste_des_triplets_pour_l_arete_N=FAUX;
                                        /* Abandon de la boucle ('parcourir_la_liste_des_triplets_pour_l_arete_N') :                 */
                                        /*                                                                                           */
                                        /*             for  (ITripletsN=PREMIER_TRIPLET ; ITripletsN <= MTriplets ; ITripletsN++)    */
                                        /*                                                                                           */
                                        /* car, en effet, le triplet 'ITripletsN' a pu etre attache a l'arete 'IAretesN' et on       */
                                        /* peut donc passser a l'arete suivante...                                                   */
                                                                                                                                  }
                                                                                                                        else
                                                                                                                                  {
                                                                                                                                  }
                                                                                                                        }
                                                                                                              else
                                                                                                                        {
                                                                                                                        }
                                                                                                              }
                                                                                                    else
                                                                                                              {
                                                                                                              }
                                                                                                    }
                                                                                          else
                                                                                                    {
                                                                                                    }
                                                                                          }
                                                                                else
                                                                                          {
                                                                                          }
                                                                                }
                                        /* Fin de la boucle ('parcourir_la_liste_des_triplets_pour_l_arete_N') :                     */
                                        /*                                                                                           */
                                        /*             for  (ITripletsN=PREMIER_TRIPLET ; ITripletsN <= MTriplets ; ITripletsN++)    */
                                        /*                                                                                           */

                                                                      if        (parcourir_la_liste_des_triplets_pour_l_arete_N == VRAI)
                                                                                {
                                                                                parcourir_la_liste_des_aretes=FAUX;
                                        /* Abandon de la boucle ('parcourir_la_liste_des_aretes') :                                  */
                                        /*                                                                                           */
                                        /*        for  (IAretesN=IAretes0+1 ; IAretesN <= MAretes ; IAretesN++)                      */
                                        /*                                                                                           */
                                        /* car, en effet, etant donne qu'il n'a pas ete possible d'attacher un triplet a l'arrete    */
                                        /* 'IAretesN', il n'est pas utile s'il est possible de le faire pour les aretes suivantes    */
                                        /* (s'il y a encore...).                                                                     */
                                                                                }
                                                                      else
                                                                                {
                                                                                }
                                                                      }
                                                            else
                                                                      {
                                                                      }
                                                            }
                                        /* Fin de la boucle ('parcourir_la_liste_des_aretes') :                                      */
                                        /*                                                                                           */
                                        /*        for  (IAretesN=IAretes0+1 ; IAretesN <= MAretes ; IAretesN++)                      */
                                        /*                                                                                           */

                                                  if        (NombreCourantDAretesAyantUnTriplet >= NombreMaximalDAretesAyantUnTriplet)
                                                            {
                                                            NombreMaximalDAretesAyantUnTriplet=NombreCourantDAretesAyantUnTriplet;
                                                            ITriplets0DuNombreMaximalDAretesAyantUnTriplet=ITriplets0;
                                                            SommeDuNombreMaximalDAretesAyantUnTriplet=TripletSomme__(ITriplets0);
                                                            }
                                                  else
                                                            {
                                                            }

                                                  if        (NombreMaximalDAretesAyantUnTriplet == IndexVersNombre(MAretes))
                                                            {
                                                            parcourir_la_liste_des_triplets_pour_l_arete_0=FAUX;
                                        /* Abandon de la boucle ('parcourir_la_liste_des_triplets_pour_l_arete_0') :                 */
                                        /*                                                                                           */
                                        /*   for  (ITriplets0=PREMIER_TRIPLET ; ITriplets0 <= MTriplets ; ITriplets0++)              */
                                        /*                                                                                           */
                                        /* puisque de toute evidence, une solution a ete trouvee...                                  */

                                                            if        (edition_Resultat_______)
                                                                      {
                                                                      int       IAretes_edition;

                                                                      if        (edition_Resultat_Trace_)
                                                                                {
                                                                                }
                                                                      else
                                                                                {
                                                                                printf("\nSolution obtenue avec la graine %d :\n\n",graine);
                                                                                }

                                                                      for       (IAretes_edition=PREMIERE_ARETE ; IAretes_edition <= NombreVersIndex(PREMIERE_ARETE+NombreCourantDAretesAyantUnTriplet) ; IAretes_edition++)
                                                                                {
                                                                                if        (AreteTriplet(IAretes_edition) != VIDE)
                                                                                          {
                                                                                          if        (edition_Resultat_Trace_)
                                                                                                    {

#define   FORMAT_D_EDITION_DES_COORDONNEES                                                                                              \
                    "Nombre=%d Premier=%d X=%f Y=%f\n"                                                                                  \
                                        /* ATTENTION : le format "Nombre=%d Premier=%d X=%f Y=%f\n" defini ci-dessus conditionne     */ \
                                        /* directement la recuperation des informations par 'v $xiirv/.HEXA.11.1.$U 20130228102050'  */ \
                                        /* (ceci fut note le 20130228102034).                                                        */

                                                                                                    printf(FORMAT_D_EDITION_DES_COORDONNEES
                                                                                                          ,TripletValeur1(AreteTriplet(IAretes_edition))
                                                                                                          ,TYPE_NOMBRE(TripletValeur1(AreteTriplet(IAretes_edition)))
                                                                                                          ,SommetX(AreteSommet1(IAretes_edition))
                                                                                                          ,SommetY(AreteSommet1(IAretes_edition))
                                                                                                           );
                                                                                                    printf(FORMAT_D_EDITION_DES_COORDONNEES
                                                                                                          ,TripletValeur2(AreteTriplet(IAretes_edition))
                                                                                                          ,TYPE_NOMBRE(TripletValeur2(AreteTriplet(IAretes_edition)))
                                                                                                          ,(SommetX(AreteSommet1(IAretes_edition))+SommetX(AreteSommet2(IAretes_edition)))/2
                                                                                                          ,(SommetY(AreteSommet1(IAretes_edition))+SommetY(AreteSommet2(IAretes_edition)))/2
                                                                                                           );
                                                                                                    printf(FORMAT_D_EDITION_DES_COORDONNEES
                                                                                                          ,TripletValeur3(AreteTriplet(IAretes_edition))
                                                                                                          ,TYPE_NOMBRE(TripletValeur3(AreteTriplet(IAretes_edition)))
                                                                                                          ,SommetX(AreteSommet2(IAretes_edition))
                                                                                                          ,SommetY(AreteSommet2(IAretes_edition))
                                                                                                           );
                                        /* Edition speciale destinee a representer graphiquement la solution trouvee :               */
                                        /*                                                                                           */
                                        /*   :Debut_listG_TraceHexagones:                                                            */
                                        /*                                                                                           */
                                        /*   $Z             FilSTmpB  FHeXaGoNeS                                                     */
                                        /*                                                                                           */
                                        /* Il y a alors deux possibilites :                                                          */
                                        /*                                                                                           */
                                        /*   $Z             $aPout                                                                \  */
                                        /*   $Z                                                      >> $FHeXaGoNeS                  */
                                        /*   $Z                                                                                      */
                                        /*   $Z             $CA       $FHeXaGoNeS                                            |    \  */
                                        /*   $Z             $AW       ' { print $3 } '                                       |    \  */
                                        /*   $Z             $SE       -e "s/^.*=//"                                               \  */
                                        /*   $Z                                                      >  $FHeXaGoNeS$COORD_X          */
                                        /*   $Z             $CA       $FHeXaGoNeS                                            |    \  */
                                        /*   $Z             $AW       ' { print $4 } '                                       |    \  */
                                        /*   $Z             $SE       -e "s/^.*=//"                                               \  */
                                        /*   $Z                                                      >  $FHeXaGoNeS$COORD_Y          */
                                        /*                                                                                           */
                                        /* qui donnera la geometrie du probleme (Les trois hexagones) et :                           */
                                        /*                                                                                           */
                                        /*   $Z             $aPout                                                           |    \  */
                                        /*   $Z             $SE       -e "s/^[^=][^=]*=//"                                   |    \  */
                                        /*   $Z             $SOR      -n                                                          \  */
                                        /*   $Z                                                      >> $FHeXaGoNeS                  */
                                        /*   $Z                                                                                      */
                                        /*   $Z             $CA       $FHeXaGoNeS                                            |    \  */
                                        /*   $Z             $AW       ' { print $3 } '                                       |    \  */
                                        /*   $Z             $SE       -e "s/^.*=//"                                               \  */
                                        /*   $Z                                                      >  $FHeXaGoNeS$COORD_X          */
                                        /*   $Z             $CA       $FHeXaGoNeS                                            |    \  */
                                        /*   $Z             $AW       ' { print $4 } '                                       |    \  */
                                        /*   $Z             $SE       -e "s/^.*=//"                                               \  */
                                        /*   $Z                                                      >  $FHeXaGoNeS$COORD_Y          */
                                        /*                                                                                           */
                                        /* qui joindra les points dans l'ordre {1,2,3,...} des valeurs trouvees...                   */
                                        /*                                                                                           */
                                        /*   $Z             FilSTmpE  FHeXaGoNeS                                                     */
                                        /*                                                                                           */
                                        /*   :Fin_listG_TraceHexagones:                                                              */
                                        /*                                                                                           */
                                                                                                    }
                                                                                          else
                                                                                                    {
                                                                                                    printf("Arete%02d=(%d,%d) Triplet=(%d,%d,%d) Somme=%d     Occurences=(%d,%d,%d)     Horloge=%d     Graine=%d\n"
                                                                                                          ,IAretes_edition
                                                                                                          ,AreteSommet1(IAretes_edition)
                                                                                                          ,AreteSommet2(IAretes_edition)
                                                                                                          ,TripletValeur1(AreteTriplet(IAretes_edition))
                                                                                                          ,TripletValeur2(AreteTriplet(IAretes_edition))
                                                                                                          ,TripletValeur3(AreteTriplet(IAretes_edition))
                                                                                                          ,TripletSomme__(AreteTriplet(IAretes_edition))
                                                                                                          ,OCCURENCE_NOMBRE(TripletValeur1(AreteTriplet(IAretes_edition)))
                                                                                                          ,OCCURENCE_NOMBRE(TripletValeur2(AreteTriplet(IAretes_edition)))
                                                                                                          ,OCCURENCE_NOMBRE(TripletValeur3(AreteTriplet(IAretes_edition)))
                                                                                                          ,AreteHorloge(IAretes_edition)
                                                                                                          ,graine
                                                                                                           );
                                        /* Voici donc une solution avec la graine 2194 et le "segment" de somme [-6,+6] qui peut     */
                                        /* aussi etre obtenue avec la graine 998 et le "segment" de somme [-1,+1] :                  */
                                        /*                                                                                           */
                                        /*                  arete00=(0,1)       triplet=(1,15,28)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete01=(1,2)       triplet=(28,14,2)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete02=(2,3)       triplet=(2,25,17)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete03=(3,4)       triplet=(17,8,19)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete04=(4,5)       triplet=(19,4,21)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete05=(5,0)       triplet=(21,22,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete06=(5,6)       triplet=(21,20,3)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete07=(6,7)       triplet=(3,18,23)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete08=(7,8)       triplet=(23,10,11)  somme=44  occurences=(1,1,1)     */
                                        /*                  arete09=(8,9)       triplet=(11,6,27)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete10=(9,0)       triplet=(27,16,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete11=(9,10)      triplet=(27,12,5)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete12=(10,11)     triplet=(5,26,13)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete13=(11,12)     triplet=(13,24,7)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete14=(12,1)      triplet=(7,9,28)    somme=44  occurences=(1,1,1)     */
                                        /*                                                                                           */
                                        /* soit :                                                                                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                                         19-----8-----17                                   */
                                        /*                                         /             \                                   */
                                        /*                                        /               \                                  */
                                        /*                                       4                 25                                */
                                        /*                                      /                   \                                */
                                        /*                                     /                     \                               */
                                        /*                        3-----20----21                      2                              */
                                        /*                       /             \                     /                               */
                                        /*                      /               \                   /                                */
                                        /*                     18                22                14                                */
                                        /*                    /                   \               /                                  */
                                        /*                   /                     \             /                                   */
                                        /*                  23                      1-----15----28                                   */
                                        /*                   \                     /             \                                   */
                                        /*                    \                   /               \                                  */
                                        /*                     10                16                9                                 */
                                        /*                      \               /                   \                                */
                                        /*                       \             /                     \                               */
                                        /*                        11----6-----27                      7                              */
                                        /*                                     \                     /                               */
                                        /*                                      \                   /                                */
                                        /*                                       12                24                                */
                                        /*                                        \               /                                  */
                                        /*                                         \             /                                   */
                                        /*                                          5-----26----13                                   */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Voici une autre solution avec la graine 7026 et le "segment" de somme [-6,+6] qui peut    */
                                        /* aussi etre obtenue avec la graine 11193 et le "segment" de somme [-1,+1] :                */
                                        /*                                                                                           */
                                        /*                  arete00=(0,1)       triplet=(1,16,27)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete01=(1,2)       triplet=(27,12,5)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete02=(2,3)       triplet=(5,26,13)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete03=(3,4)       triplet=(13,24,7)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete04=(4,5)       triplet=(7,9,28)    somme=44  occurences=(1,1,1)     */
                                        /*                  arete05=(5,0)       triplet=(28,15,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete06=(5,6)       triplet=(28,14,2)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete07=(6,7)       triplet=(2,25,17)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete08=(7,8)       triplet=(17,8,19)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete09=(8,9)       triplet=(19,4,21)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete10=(9,0)       triplet=(21,22,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete11=(9,10)      triplet=(21,20,3)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete12=(10,11)     triplet=(3,18,23)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete13=(11,12)     triplet=(23,10,11)  somme=44  occurences=(1,1,1)     */
                                        /*                  arete14=(12,1)      triplet=(11,6,27)   somme=44  occurences=(1,1,1)     */
                                        /*                                                                                           */
                                        /* soit :                                                                                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                                          7-----24----13                                   */
                                        /*                                         /             \                                   */
                                        /*                                        /               \                                  */
                                        /*                                       9                 26                                */
                                        /*                                      /                   \                                */
                                        /*                                     /                     \                               */
                                        /*                        2-----14----28                      5                              */
                                        /*                       /             \                     /                               */
                                        /*                      /               \                   /                                */
                                        /*                     25                15                12                                */
                                        /*                    /                   \               /                                  */
                                        /*                   /                     \             /                                   */
                                        /*                  17                      1-----16----27                                   */
                                        /*                   \                     /             \                                   */
                                        /*                    \                   /               \                                  */
                                        /*                     8                 22                6                                 */
                                        /*                      \               /                   \                                */
                                        /*                       \             /                     \                               */
                                        /*                        19----4-----21                      11                             */
                                        /*                                     \                     /                               */
                                        /*                                      \                   /                                */
                                        /*                                       20                10                                */
                                        /*                                        \               /                                  */
                                        /*                                         \             /                                   */
                                        /*                                          3-----18----23                                   */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Voici une autre solution avec la graine 8066 et le "segment" de somme [-6,+6] qui peut    */
                                        /* aussi etre obtenue avec la graine 12733 et le "segment" de somme [-1,+1] :                */
                                        /*                                                                                           */
                                        /*                  arete00=(0,1)       triplet=(1,22,21)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete01=(1,2)       triplet=(21,4,19)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete02=(2,3)       triplet=(19,8,17)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete03=(3,4)       triplet=(17,25,2)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete04=(4,5)       triplet=(2,14,28)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete05=(5,0)       triplet=(28,15,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete06=(5,6)       triplet=(28,9,7)    somme=44  occurences=(1,1,1)     */
                                        /*                  arete07=(6,7)       triplet=(7,24,13)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete08=(7,8)       triplet=(13,26,5)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete09=(8,9)       triplet=(5,12,27)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete10=(9,0)       triplet=(27,16,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete11=(9,10)      triplet=(27,6,11)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete12=(10,11)     triplet=(11,10,23)  somme=44  occurences=(1,1,1)     */
                                        /*                  arete13=(11,12)     triplet=(23,18,3)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete14=(12,1)      triplet=(3,20,21)   somme=44  occurences=(1,1,1)     */
                                        /*                                                                                           */
                                        /* soit :                                                                                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                                          2-----25----17                                   */
                                        /*                                         /             \                                   */
                                        /*                                        /               \                                  */
                                        /*                                       14                8                                 */
                                        /*                                      /                   \                                */
                                        /*                                     /                     \                               */
                                        /*                        7-----9-----28                      19                             */
                                        /*                       /             \                     /                               */
                                        /*                      /               \                   /                                */
                                        /*                     24                15                4                                 */
                                        /*                    /                   \               /                                  */
                                        /*                   /                     \             /                                   */
                                        /*                  13                      1-----22----21                                   */
                                        /*                   \                     /             \                                   */
                                        /*                    \                   /               \                                  */
                                        /*                     26                16                20                                */
                                        /*                      \               /                   \                                */
                                        /*                       \             /                     \                               */
                                        /*                        5-----12----27                      3                              */
                                        /*                                     \                     /                               */
                                        /*                                      \                   /                                */
                                        /*                                       6                 18                                */
                                        /*                                        \               /                                  */
                                        /*                                         \             /                                   */
                                        /*                                          11----10----23                                   */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Voici une autre solution avec la graine 11259 et le "segment" de somme [-6,+6] qui peut   */
                                        /* aussi etre obtenue avec la graine 3295 et le "segment" de somme [-1,+1] :                 */
                                        /*                                                                                           */
                                        /*                  arete00=(0,1)       triplet=(1,15,28)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete01=(1,2)       triplet=(28,9,7)    somme=44  occurences=(1,1,1)     */
                                        /*                  arete02=(2,3)       triplet=(7,24,13)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete03=(3,4)       triplet=(13,26,5)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete04=(4,5)       triplet=(5,12,27)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete05=(5,0)       triplet=(27,16,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete06=(5,6)       triplet=(27,6,11)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete07=(6,7)       triplet=(11,10,23)  somme=44  occurences=(1,1,1)     */
                                        /*                  arete08=(7,8)       triplet=(23,18,3)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete09=(8,9)       triplet=(3,20,21)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete10=(9,0)       triplet=(21,22,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete11=(9,10)      triplet=(21,4,19)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete12=(10,11)     triplet=(19,8,17)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete13=(11,12)     triplet=(17,25,2)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete14=(12,1)      triplet=(2,14,28)   somme=44  occurences=(1,1,1)     */
                                        /*                                                                                           */
                                        /* soit :                                                                                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                                          5-----26----13                                   */
                                        /*                                         /             \                                   */
                                        /*                                        /               \                                  */
                                        /*                                       12                24                                */
                                        /*                                      /                   \                                */
                                        /*                                     /                     \                               */
                                        /*                        11----6-----27                      7                              */
                                        /*                       /             \                     /                               */
                                        /*                      /               \                   /                                */
                                        /*                     10                16                9                                 */
                                        /*                    /                   \               /                                  */
                                        /*                   /                     \             /                                   */
                                        /*                  23                      1-----15----28                                   */
                                        /*                   \                     /             \                                   */
                                        /*                    \                   /               \                                  */
                                        /*                     18                22                14                                */
                                        /*                      \               /                   \                                */
                                        /*                       \             /                     \                               */
                                        /*                        3-----20----21                      2                              */
                                        /*                                     \                     /                               */
                                        /*                                      \                   /                                */
                                        /*                                       4                 25                                */
                                        /*                                        \               /                                  */
                                        /*                                         \             /                                   */
                                        /*                                          19----8-----17                                   */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Voici une autre solution avec la graine 12901 et le "segment" de somme [-6,+6] qui peut   */
                                        /* aussi etre obtenue avec la graine 4226 et le "segment" de somme [-1,+1] :                 */
                                        /*                                                                                           */
                                        /*                  arete00=(0,1)       triplet=(1,16,27)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete01=(1,2)       triplet=(27,6,11)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete02=(2,3)       triplet=(11,10,23)  somme=44  occurences=(1,1,1)     */
                                        /*                  arete03=(3,4)       triplet=(23,18,3)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete04=(4,5)       triplet=(3,20,21)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete05=(5,0)       triplet=(21,22,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete06=(5,6)       triplet=(21,4,19)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete07=(6,7)       triplet=(19,8,17)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete08=(7,8)       triplet=(17,25,2)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete09=(8,9)       triplet=(2,14,28)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete10=(9,0)       triplet=(28,15,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete11=(9,10)      triplet=(28,9,7)    somme=44  occurences=(1,1,1)     */
                                        /*                  arete12=(10,11)     triplet=(7,24,13)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete13=(11,12)     triplet=(13,26,5)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete14=(12,1)      triplet=(5,12,27)   somme=44  occurences=(1,1,1)     */
                                        /*                                                                                           */
                                        /* soit :                                                                                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                                          3-----18----23                                   */
                                        /*                                         /             \                                   */
                                        /*                                        /               \                                  */
                                        /*                                       20                10                                */
                                        /*                                      /                   \                                */
                                        /*                                     /                     \                               */
                                        /*                        19----4-----21                      11                             */
                                        /*                       /             \                     /                               */
                                        /*                      /               \                   /                                */
                                        /*                     8                 22                6                                 */
                                        /*                    /                   \               /                                  */
                                        /*                   /                     \             /                                   */
                                        /*                  17                      1-----16----27                                   */
                                        /*                   \                     /             \                                   */
                                        /*                    \                   /               \                                  */
                                        /*                     25                15                12                                */
                                        /*                      \               /                   \                                */
                                        /*                       \             /                     \                               */
                                        /*                        2-----14----28                      5                              */
                                        /*                                     \                     /                               */
                                        /*                                      \                   /                                */
                                        /*                                       9                 26                                */
                                        /*                                        \               /                                  */
                                        /*                                         \             /                                   */
                                        /*                                          7-----24----13                                   */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Voici une autre solution avec la graine 21597 et le "segment" de somme [-6,+6] qui peut   */
                                        /* aussi etre obtenue avec la graine 19239 et le "segment" de somme [-1,+1] :                */
                                        /*                                                                                           */
                                        /*                  arete00=(0,1)       triplet=(1,22,21)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete01=(1,2)       triplet=(21,20,3)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete02=(2,3)       triplet=(3,18,23)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete03=(3,4)       triplet=(23,10,11)  somme=44  occurences=(1,1,1)     */
                                        /*                  arete04=(4,5)       triplet=(11,6,27)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete05=(5,0)       triplet=(27,16,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete06=(5,6)       triplet=(27,12,5)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete07=(6,7)       triplet=(5,26,13)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete08=(7,8)       triplet=(13,24,7)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete09=(8,9)       triplet=(7,9,28)    somme=44  occurences=(1,1,1)     */
                                        /*                  arete10=(9,0)       triplet=(28,15,1)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete11=(9,10)      triplet=(28,14,2)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete12=(10,11)     triplet=(2,25,17)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete13=(11,12)     triplet=(17,8,19)   somme=44  occurences=(1,1,1)     */
                                        /*                  arete14=(12,1)      triplet=(19,4,21)   somme=44  occurences=(1,1,1)     */
                                        /*                                                                                           */
                                        /* soit :                                                                                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                                         11-----10----23                                   */
                                        /*                                         /             \                                   */
                                        /*                                        /               \                                  */
                                        /*                                       6                 18                                */
                                        /*                                      /                   \                                */
                                        /*                                     /                     \                               */
                                        /*                        5-----12----27                      3                              */
                                        /*                       /             \                     /                               */
                                        /*                      /               \                   /                                */
                                        /*                     26                16                20                                */
                                        /*                    /                   \               /                                  */
                                        /*                   /                     \             /                                   */
                                        /*                  13                      1-----22----21                                   */
                                        /*                   \                     /             \                                   */
                                        /*                    \                   /               \                                  */
                                        /*                     24                15                4                                 */
                                        /*                      \               /                   \                                */
                                        /*                       \             /                     \                               */
                                        /*                        7-----9-----28                      19                             */
                                        /*                                     \                     /                               */
                                        /*                                      \                   /                                */
                                        /*                                       14                8                                 */
                                        /*                                        \               /                                  */
                                        /*                                         \             /                                   */
                                        /*                                          2-----25----17                                   */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Tout cela prouve qu'il y a au moins six solutions et peut-etre pas plus car, en effet,    */
                                        /* ces six solutions se retrouvent plusieurs fois pour 100.000 graines differentes dans      */
                                        /* [1,100000]. Voici le resultat de ce test fait avec le "segment" de somme [-1,+1]          */
                                        /* qui montre les nombres d'occurences (reperes grace a 'arete14') de chacune des six        */
                                        /* solutions :                                                                               */
                                        /*                                                                                           */
                                        /*        arete14=(12,1)      triplet=(7,9,28)    ==>       58 occurences avec les graines : */
                                        /*                                                                                           */
                                        /*                    998   1712   1754   2285   2296   3896   3959   4522   5555   5776     */
                                        /*                  12643  21019  22147  22218  23092  26711  28610  30903  31362  32197     */
                                        /*                  32351  33456  34164  34554  34889  36349  41099  42130  45678  49096     */
                                        /*                  49856  50566  53398  55588  56777  58802  62237  63688  63823  65115     */
                                        /*                  65404  67334  71497  72614  72980  73901  75007  76673  76902  78213     */
                                        /*                  79402  81209  83914  85334  90910  94204  94526  97381                   */
                                        /*                                                                                           */
                                        /*                  (6214 occurences pour 12.000.000 graines differentes)                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*        arete14=(12,1)      triplet=(11,6,27)   ==>       45 occurences avec les graines : */
                                        /*                                                                                           */
                                        /*                  11193  11562  12313  12329  13282  13783  15170  16586  20685  22692     */
                                        /*                  27001  27365  28782  30671  37477  40063  40935  51670  53483  54172     */
                                        /*                  55952  59215  60967  63037  63808  65648  76388  78053  79740  81186     */
                                        /*                  81615  81651  82300  84207  86575  87511  89417  92084  93405  93447     */
                                        /*                  93838  96148  97445  97876  98596                                        */
                                        /*                                                                                           */
                                        /*                  (6184 occurences pour 12.000.000 graines differentes)                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*        arete14=(12,1)      triplet=(3,20,21)   ==>       05 occurences avec les graines : */
                                        /*                                                                                           */
                                        /*                  12733  14877  35420  38223  64535                                        */
                                        /*                                                                                           */
                                        /*                  (1089 occurences pour 12.000.000 graines differentes)                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*        arete14=(12,1)      triplet=(2,14,28)   ==>       39 occurences avec les graines : */
                                        /*                                                                                           */
                                        /*                   3295   5632   7482   9856  12585  13480  15060  15097  16173  25992     */
                                        /*                  29497  30033  30134  31847  35241  37444  39865  44430  45954  50432     */
                                        /*                  53673  54881  58120  58131  64205  71099  71863  72527  73994  75389     */
                                        /*                  75559  79429  79932  85076  86182  95662  96731  98674  98676            */
                                        /*                                                                                           */
                                        /*                  (5027 occurences pour 12.000.000 graines differentes)                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*        arete14=(12,1)      triplet=(5,12,27)   ==>       23 occurences avec les graines : */
                                        /*                                                                                           */
                                        /*                   4226   5949   8531   9597  17159  20078  22648  27044  28212  29315     */
                                        /*                  32685  36655  39752  47563  51100  58897  58960  71760  73524  92132     */
                                        /*                  95064  95341  96227                                                      */
                                        /*                                                                                           */
                                        /*                  (4254 occurences pour 12.000.000 graines differentes)                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*        arete14=(12,1)      triplet=(19,4,21)   ==>       11 occurences avec les graines : */
                                        /*                                                                                           */
                                        /*                  19239  21227  24504  29604  31906  67666  72546  74812  78225  93632     */
                                        /*                  98661                                                                    */
                                        /*                                                                                           */
                                        /*                  (1902 occurences pour 12.000.000 graines differentes)                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* On notera qu'elles commencent toutes les six par 1 (premier sommet de 'arete00').         */
                                        /*                                                                                           */
                                        /* En fait ces six solutions sont identiques a des rotations (d'un multiple de 2.pi/3) et    */
                                        /* symetries (par rapport a l'un des trois axes portant les trois cotes qui sont communs     */
                                        /* aux trois hexagones) pres :                                                               */
                                        /*                                                                                           */
                                        /*                              +R3                         +R3                              */
                                        /*        $xiirv/HEXA.11.00998 -----> $xiirv/HEXA.11.11193 -----> $xiirv/HEXA.11.19239       */
                                        /*                                                                                           */
                                        /*                 /|\                         /|\                         /|\               */
                                        /*                  |                           |                           |                */
                                        /*                 S|1                         S|1                         S|1               */
                                        /*                  |                           |                           |                */
                                        /*                 \|/                         \|/                         \|/               */
                                        /*                              -R3                         -R3                              */
                                        /*        $xiirv/HEXA.11.03295 -----> $xiirv/HEXA.11.04226 -----> $xiirv/HEXA.11.12733       */
                                        /*                                                                                           */
                                        /* avec :                                                                                    */
                                        /*                                                                                           */
                                        /*                  R3 = Rotation de 2.pi/3,                                                 */
                                        /*                  S1 = Symetrie par rapport a l'axe des 'X' (cote commun horizontal).      */
                                        /*                                                                                           */
                                        /* Tout cela se voit tres bien avec les images suivantes disposees suivant le schema         */
                                        /* presente ci-dessus :                                                                      */
                                        /*                                                                                           */
                                        /*                  ext       Pud                                                            */
                                        /*                                                                                           */
                                        /*                  v         $xiirv/HEXA.11.00998          Fc=FAUX yc=2 xc=0                */
                                        /*                  v         $xiirv/HEXA.11.11193          Fc=FAUX yc=2 xc=1                */
                                        /*                  v         $xiirv/HEXA.11.19239          Fc=FAUX yc=2 xc=2                */
                                        /*                                                                                           */
                                        /*                  v         $xiirv/HEXA.11.03295          Fc=FAUX yc=1 xc=0                */
                                        /*                  v         $xiirv/HEXA.11.04226          Fc=FAUX yc=1 xc=1                */
                                        /*                  v         $xiirv/HEXA.11.12733          Fc=FAUX yc=1 xc=2                */
                                        /*                                                                                           */
                                        /* Des "schemas" identiques sont obtenus en utilisant les symetries 'S2' et 'S3' par         */
                                        /* rapport aux deux autres cotes communs...                                                  */
                                        /*                                                                                           */
                                        /* Ainsi, finalement, il semble qu'il n'y ait qu'une seule solution que montre tres          */
                                        /* joliment 'v $xiirv/HEXA.12.00998' !                                                       */
                                                                                                    }
                                                                                          }
                                                                                else
                                                                                          {
                                                                                          printf("Une arete est vide.");
                                                                                          }
                                                                                }

                                                                      if        (edition_Resultat_Trace_)
                                                                                {
                                                                                }
                                                                      else
                                                                                {
                                                                                printf("\n");
                                                                                }
                                                                      }
                                                            else
                                                                      {
                                                                      }
                                                            }
                                                  else
                                                            {
                                                            }
                                                  }
                                        else
                                                  {
                                                  }
                                        }
                              else
                                        {
                                        }

                              NombreFinalDAretesAyantUnTriplet=NombreMaximalDAretesAyantUnTriplet;

                              if        (gITriplets0 == MTriplets)
                                        {
                                        if        (NombreFinalDAretesAyantUnTriplet != IndexVersNombre(MAretes))
                                                  {
                                                  printf("Il n'y a pas de solution mais une des meilleures solutions partielles contient ");
                                                  printf("%d triplets de numero initial %d et de somme %d pour la graine %d.\n"
                                                        ,NombreMaximalDAretesAyantUnTriplet
                                                        ,ITriplets0DuNombreMaximalDAretesAyantUnTriplet
                                                        ,SommeDuNombreMaximalDAretesAyantUnTriplet
                                                        ,graine
                                                         );
                                                  }
                                        else
                                                  {
                                                  }
                                        }
                              else
                                        {
                                        }
                              }
                                        /* Fin de la boucle :                                                                        */
                                        /*                                                                                           */
                                        /*   for  (ITriplets0=PREMIER_TRIPLET ; ITriplets0 <= MTriplets ; ITriplets0++)              */
                                        /*                                                                                           */
                    }
                                        /* Fermeture d'un nouveau bloc destine a la declaration de variables locales...              */
                    }
          }
                                        /* Fermeture d'un nouveau bloc destine a la declaration de variables locales...              */
          }



Copyright (c) Jean-François Colonna, 2013-2019.
Copyright (c) CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2013-2019.