/*************************************************************************************************************************************/
/* */
/* P A R A D O X E " D E S S I L E N C E S Q U I E N D I S E N T L O N G " : */
/* */
/* */
/* Nota : */
/* */
/* Ce probleme a ete pose par Jean-Paul Delahaye */
/* dans sa rubrique "Paradoxes" du numero 51 de la */
/* revue "Les Nouvelles d'Archimede" (deuxieme */
/* trimestre 2009, pages 20 et 21). */
/* */
/* */
/* Author of '$xtc/Paradoxe_JP_Delahaye.01$vv$c' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 20090326110530). */
/* */
/*************************************************************************************************************************************/
#include "INCLUDES.01.I"
#define A \
1
#define Z \
10
/* Bornes de definition des cinq nombres entiers {a,b,c,d,e}. */
#define DIMENSION \
(MaximumHistogrammes-MinimumHistogrammes+1)
#define ACCES(Histogramme,valeur) \
Histogramme[valeur-MinimumHistogrammes]
/* Dimension des histogrammes et acces direct. */
#define LIBRE \
0
#define BLOQUE \
1
#define BLOCAGE(HistogrammeX) \
{ \
if (HistogrammeX[index] == 1) \
{ \
Blocage##HistogrammeX[index]=BLOQUE; \
} \
else \
{ \
} \
}
/* Blocage des histogrammes. */
#define CALCULS_QUINTUPLETS(sequence) \
{ \
for (a=A ; a<=Z ; a++) \
{ \
for (b=a+1 ; b<=Z ; b++) \
{ \
for (c=b+1 ; c<=Z ; c++) \
{ \
for (d=c+1 ; d<=Z ; d++) \
{ \
for (e=d+1 ; e<=Z ; e++) \
{ \
int produit=a*b*c*d*e; \
int somme__=a+b+c+d+e; \
int carre__=(a*a)+(b*b)+(c*c)+(d*d)+(e*e); \
int valeur_=(a+b+c)*(d+e); \
/* Calcul systematique des quatre fonctions de {a,b,c,d,e}. */ \
\
sequence; \
/* Sequence variable... */ \
} \
} \
} \
} \
} \
}
main()
{
int a,b,c,d,e;
/* Definition des cinq nombres {a,b,c,d,e} dans [A,Z] tels que a<b<c<d<e. */
int NombreQuintuplets=0;
/* Nombre de Quintuplets (le 20090427101905 je note qu'avec les definitions par defaut */
/* -soit cinq nombres dans [1,10]- il vaut 'COnm(10,5)=252'). */
int MinimumHistogrammes=0x7fffffff;
int MaximumHistogrammes=0x80000000;
/* Extrema des histogrammes. */
int IlFautEditer=FAUX;
/* Afin de pouvoir editer, si besoin est, tous les quintuplets et les valeurs des quatre */
/* fonctions. */
CALCULS_QUINTUPLETS(
{
NombreQuintuplets++;
MinimumHistogrammes=MIN2(MinimumHistogrammes,produit);
MinimumHistogrammes=MIN2(MinimumHistogrammes,somme__);
MinimumHistogrammes=MIN2(MinimumHistogrammes,carre__);
MinimumHistogrammes=MIN2(MinimumHistogrammes,valeur_);
MaximumHistogrammes=MAX2(MaximumHistogrammes,produit);
MaximumHistogrammes=MAX2(MaximumHistogrammes,somme__);
MaximumHistogrammes=MAX2(MaximumHistogrammes,carre__);
MaximumHistogrammes=MAX2(MaximumHistogrammes,valeur_);
}
);
/* Dimensionnement... */
{
/* Ouverture d'un nouveau bloc afin d'assurer le dimensionnement variable des histogrammes */
/* et de leurs bloqueurs... */
int NumeroIteration=0;
int UnQuintupletUniqueExiste=FAUX;
/* Controle de l'iteration principale... */
int index;
int HistogrammeP[DIMENSION],BlocageHistogrammeP[DIMENSION];
int HistogrammeS[DIMENSION],BlocageHistogrammeS[DIMENSION];
int HistogrammeC[DIMENSION],BlocageHistogrammeC[DIMENSION];
int HistogrammeV[DIMENSION],BlocageHistogrammeV[DIMENSION];
/* Definition des histogrammes, de leurs bloqueurs et de leur index. */
for (index=0 ; index<DIMENSION ; index++)
{
BlocageHistogrammeP[index]=LIBRE;
BlocageHistogrammeS[index]=LIBRE;
BlocageHistogrammeC[index]=LIBRE;
BlocageHistogrammeV[index]=LIBRE;
/* A priori, aucune entree dans les histogrammes {P,S,C,V} n'est bloquee... */
}
while (UnQuintupletUniqueExiste == FAUX)
{
int CompteurQuintupletsNonAmbigus=0;
/* Compteur des cas non ambigus... */
int Ga,Gb,Gc,Gd,Ge;
int Gproduit,Gsomme__,Gcarre__,Gvaleur_;
/* Valeur de {produit,somme,carre,valeur} Gagnante (correspondant au dernier quintuplet */
/* {a,b,c,d,e} non ambigu qui est Gagnant s'il est unique...). */
NumeroIteration++;
for (index=0 ; index<DIMENSION ; index++)
{
HistogrammeP[index]=0;
HistogrammeS[index]=0;
HistogrammeC[index]=0;
HistogrammeV[index]=0;
/* Initialisation des histogrammes. */
}
CALCULS_QUINTUPLETS(
{
if ( (ACCES(BlocageHistogrammeP,produit) == BLOQUE)
|| (ACCES(BlocageHistogrammeS,somme__) == BLOQUE)
|| (ACCES(BlocageHistogrammeC,carre__) == BLOQUE)
|| (ACCES(BlocageHistogrammeV,valeur_) == BLOQUE)
)
{
}
else
{
ACCES(HistogrammeP,produit)++;
ACCES(HistogrammeS,somme__)++;
ACCES(HistogrammeC,carre__)++;
ACCES(HistogrammeV,valeur_)++;
/* Calcul des histogrammes des produits, des sommes, des sommes des carres et des valeurs, */
/* a condition qu'il n'y ait aucun blocage... */
}
}
);
for (index=0 ; index<DIMENSION ; index++)
{
BLOCAGE(HistogrammeP);
BLOCAGE(HistogrammeS);
BLOCAGE(HistogrammeC);
BLOCAGE(HistogrammeV);
/* Blocage des entrees non ambigues (histogramme=1)... */
}
CALCULS_QUINTUPLETS(
{
if ( (ACCES(HistogrammeP,produit) == 1)
&& (ACCES(HistogrammeS,somme__) == 1)
&& (ACCES(HistogrammeC,carre__) == 1)
&& (ACCES(HistogrammeV,valeur_) == 1)
)
{
CompteurQuintupletsNonAmbigus++;
Ga=a;
Gb=b;
Gc=c;
Gd=d;
Ge=e;
Gproduit=produit;
Gsomme__=somme__;
Gcarre__=carre__;
Gvaleur_=valeur_;
/* Comptage du nombre de cas non ambigus (pour lesquels les quatre histogrammes sont egaux */
/* a 1) et memorisation du dernier cas rencontre, qui si il est unique est le Gagnant... */
}
else
{
}
}
);
if (CompteurQuintupletsNonAmbigus == 1)
{
printf("A l'iteration %d un quintuplet unique a ete trouve :",NumeroIteration);
printf(" {a=%d,b=%d,c=%d,d=%d,e=%d}",Ga,Gb,Gc,Gd,Ge);
printf(" {P=%d,S=%d,C=%d,V=%d}",Gproduit,Gsomme__,Gcarre__,Gvaleur_);
printf("\n");
/* La solution pour [1,10] est : */
/* */
/* a=2 b=5 c=6 d=7 e=8 P=3360 S=28 C=178 V=195 */
/* */
UnQuintupletUniqueExiste=VRAI;
/* C'est fini... */
}
else
{
if (NumeroIteration > NombreQuintuplets)
/* Ce test n'est peut-etre pas optimal, mais il est le plus general... */
{
printf("Le probleme n'a pas de solution...\n");
UnQuintupletUniqueExiste=VRAI;
/* On aborte en faisant comme si une solution existait... */
}
else
{
}
}
}
if (IlFautEditer == VRAI)
{
printf("\n");
CALCULS_QUINTUPLETS(
{
printf("a=%02d b=%02d c=%02d d=%02d e=%02d",a,b,c,d,e);
printf(" P=%05d (NP=%03d)",produit,ACCES(HistogrammeP,produit));
printf(" S=%02d (NS=%03d)",somme__,ACCES(HistogrammeS,somme__));
printf(" C=%03d (NC=%03d)",carre__,ACCES(HistogrammeC,carre__));
printf(" V=%03d (NV=%03d)",valeur_,ACCES(HistogrammeV,valeur_));
printf("\n");
/* Edition eventuelle de tous les resultats. */
}
);
}
else
{
}
}
}