/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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
                              {
                              }
                    }
          }



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