/*************************************************************************************************************************************/
/* */
/* 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 -1-... */
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 -2-... */
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 (gITriplets0=PREMIER_TRIPLET ; gITriplets0 <= MTriplets ; gITriplets0++) */
/* */
}
/* Fermeture d'un nouveau bloc destine a la declaration de variables locales -2-... */
}
/* Fin de la boucle : */
/* */
/* for (graine=graine_minimale ; graine <= graine_maximale ; graine++) */
/* */
}
/* Fermeture d'un nouveau bloc destine a la declaration de variables locales -1-... */
}
/* Fin du programme principal : */
/* */
/* int main() */
/* */