/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T R I A N G L E   M A G I Q U E  :                                                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/TriMagik.02$c' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20050101105250).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"
                                        /* Introduit le 20051116095356...                                                            */

extern    double    log10();

#define   RechercheMaximum(t,l,i)                                                                                                       \
                    {                                                                                                                   \
                    for  (i=PREMIER ; (t=l[i]) != NuLl ; i++)                                                                           \
                         {                                                                                                              \
                         maximum = MAX2(t,maximum);                                                                                     \
                         }                                                                                                              \
                    }
#define   D                                                                                                                             \
                    ((((int)log10((double)maximum))+1)+2)                                                                               \
                                        /* La derniere constante additive (+2) definit l'espacement entre les valeurs editees...     */

#define   NuLl                                                                                                                          \
                    0
#define   ListeAPriori                                                                                                                  \
                    1,2,3,4,5,6,7,NuLl
#define   PREMIER                                                                                                                       \
                    0

main()
     {
     int       differents=1;
                                        /* Cet indicateur controle la "repetabilite" des valeurs en chaque noeud :                   */
                                        /*                                                                                           */
                                        /*        =0      : plusieurs noeuds peuvent contenir des valeurs identiques,                */
                                        /*        #0      : les noeuds ne peuvent contenir que des valeurs differentes.              */
                                        /*                                                                                           */

     int       maximum=-1000000;
                                        /* Afin de rechercher le maximum des differentes listes...                                   */

     int       solutions=0;
                                        /* Nombre de solutions trouvees...                                                           */

     int       l11[]={ListeAPriori};

     int       l21[]={ListeAPriori};
     int       l22[]={ListeAPriori};
     int       l23[]={ListeAPriori};

     int       l31[]={ListeAPriori};
     int       l32[]={ListeAPriori};
     int       l33[]={ListeAPriori};
                                        /* Liste des valeurs possibles des sept noeuds. Il faut en fait :                            */
                                        /*                                                                                           */
                                        /*                  int       l31[]={1,NuLl};                                                */
                                        /*                                                                                           */
                                        /* pour resoudre le probleme de Valentine Parmentier...                                      */

     int       i11;
     int       i21,i22,i23;
     int       i31,i32,i33;
                                        /* Liste des index d'acces aux valeurs possibles des sept noeuds.                            */

     int       t11;
     int       t21,t22,t23;
     int       t31,t32,t33;
                                        /* Liste des valeurs courantes des sept noeuds :                                             */
                                        /*                                                                                           */
                                        /*                            t11                                                            */
                                        /*                           / | \                                                           */
                                        /*                          /  |  \                                                          */
                                        /*                         /   |   \                                                         */
                                        /*                       t21--t22--t23                                                       */
                                        /*                      /      |      \                                                      */
                                        /*                     /       |       \                                                     */
                                        /*                    /        |        \                                                    */
                                        /*                  t31-------t32-------t33                                                  */
                                        /*                                                                                           */
                                        /* tout ceci etant pour Valentine Parmentier...                                              */

     RechercheMaximum(t11,l11,i11);
     RechercheMaximum(t21,l21,i21);
     RechercheMaximum(t22,l22,i22);
     RechercheMaximum(t23,l23,i23);
     RechercheMaximum(t31,l31,i31);
     RechercheMaximum(t32,l32,i32);
     RechercheMaximum(t33,l33,i33);

     for  (i31=PREMIER ; (t31=l31[i31]) != NuLl ; i31++)
          {
          for  (i32=PREMIER ; (t32=l32[i32]) != NuLl ; i32++)
               {
               if   (    (differents == 0)                                                                                              \
                    ||   (    (t32 != t31)                                                                                              \
                          )                                                                                                             \
                     )
                    {
                    for  (i33=PREMIER ; (t33=l33[i33]) != NuLl ; i33++)
                         {
                         if   (    (differents == 0)                                                                                    \
                              ||   (    (t33 != t31)                                                                                    \
                                   &&   (t33 != t32)                                                                                    \
                                    )                                                                                                   \
                               )
                              {
                              for  (i21=PREMIER ; (t21=l21[i21]) != NuLl ; i21++)
                                   {
                                   if   (    (differents == 0)                                                                          \
                                        ||   (    (t21 != t31)                                                                          \
                                             &&   (t21 != t32)                                                                          \
                                             &&   (t21 != t33)                                                                          \
                                              )                                                                                         \
                                         )
                                        {
                                        for  (i22=PREMIER ; (t22=l22[i22]) != NuLl ; i22++)
                                             {
                                             if   (    (differents == 0)                                                                \
                                                  ||   (    (t22 != t31)                                                                \
                                                       &&   (t22 != t32)                                                                \
                                                       &&   (t22 != t33)                                                                \
                                                       &&   (t22 != t21)                                                                \
                                                        )                                                                               \
                                                   )
                                                  {
                                                  for  (i23=PREMIER ; (t23=l23[i23]) != NuLl ; i23++)
                                                       {
                                                       if   (    (differents == 0)                                                      \
                                                            ||   (    (t23 != t31)                                                      \
                                                                 &&   (t23 != t32)                                                      \
                                                                 &&   (t23 != t33)                                                      \
                                                                 &&   (t23 != t21)                                                      \
                                                                 &&   (t23 != t22)                                                      \
                                                                  )                                                                     \
                                                             )
                                                            {
                                                            for  (i11=PREMIER ; (t11=l11[i11]) != NuLl ; i11++)
                                                                 {
                                                                 if   (    (differents == 0)                                            \
                                                                      ||   (    (t11 != t31)                                            \
                                                                           &&   (t11 != t32)                                            \
                                                                           &&   (t11 != t33)                                            \
                                                                           &&   (t11 != t21)                                            \
                                                                           &&   (t11 != t22)                                            \
                                                                           &&   (t11 != t23)                                            \
                                                                            )                                                           \
                                                                       )
                                                                      {
                                                                      int       l1=t11+t21+t31;
                                                                      int       l2=t11+t22+t32;
                                                                      int       l3=t11+t23+t33;
                                                                      int       l4=t21+t22+t23;
                                                                      int       l5=t31+t32+t33;
                                        /* Calcul des cinq longueurs qui, pour un triangle magique, doivent etre egales...           */

                                                                      if   (    (l1 == l2)                                              \
                                                                           &&   (l2 == l3)                                              \
                                                                           &&   (l3 == l4)                                              \
                                                                           &&   (l4 == l5)                                              \
                                                                            )
                                                                           {
                                                                           solutions++;

                                                                           printf("Un TRIANGLE MAGIQUE a ete trouve ");
                                                                           printf("(longueur des cinq alignements=%d) :\n\n",l1);
                                                                           printf("%*d\n",D+D+D,t11);
                                                                           printf("%*d%*d%*d\n",D+D,t21,D,t22,D,t23);
                                                                           printf("%*d%*d%*d\n",D,t31,D+D,t32,D+D,t33);
                                                                           printf("\n\n");
                                        /* On a trouve un triangle magique...                                                        */
                                                                           }
                                                                      else
                                                                           {
                                                                           }
                                                                      }
                                                                 else
                                                                      {
                                                                      }
                                                                 }
                                                            }
                                                       else
                                                            {
                                                            }
                                                       }
                                                  }
                                             else
                                                  {
                                                  }
                                             }
                                        }
                                   else
                                        {
                                        }
                                   }
                              }
                         else
                              {
                              }
                         }
                    }
               else
                    {
                    }
               }
          }

     printf("Il y a au total %d solution[s] differente[s].\n\n",solutions);
     }