/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E N I G M E   ( 'v $Dcourrier_in/20000523145250 obac@aemiaif.lip6.fr' )  :                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/PlotPions.01$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>
#include  <math.h>

#define   FAUX      0
#define   VRAI      1

#define   PREMIER   1
#define   nPLOTS    8
#define   nPIONS    6

#define   acces(t,i)                                                                                                                    \
                    t[(i)-PREMIER]
#define   dPLOTS(n,e)                                                                                                                   \
                    {                                                                                                                   \
                    if        (((n) >= PREMIER) && ((n) <= nPLOTS))                                                                     \
                              {                                                                                                         \
                              acces(plots_occupes,n)=e;                                                                                 \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              printf("\nle plot %d est inexistant dans [%d,%d]\n",n,PREMIER,nPLOTS);                                    \
                              }                                                                                                         \
                    }

static    int       plots_occupes[nPLOTS];
static    int       hauteur_des_tours[nPLOTS];

static    int       nombre_de_configurations;

void      recursif(plot_courant,plus_haute_tour)
int       plot_courant;
int       plus_haute_tour;
          {
          int       plot,tour;
          int       sauve=acces(hauteur_des_tours,plot_courant);
          int       hauteur=((acces(plots_occupes,plot_courant) == VRAI) ? plus_haute_tour : PREMIER);

          for       (tour=PREMIER ; tour<=hauteur ; tour++)
                                        /* Avec cette boucle, on essaye tous les empilements possibles de pions sur le plot courant  */
                                        /* (a condition qu'il puisse etre occupe).                                                   */
                    {
                    if        (acces(plots_occupes,plot_courant) == VRAI)
                              {
                              acces(hauteur_des_tours,plot_courant)++;
                                        /* Empilement des pions lorsque le plot courant peut etre occupe.                            */
                              }
                    else
                              {
                              }

                    if        (plot_courant < nPLOTS)
                              {
                              recursif(plot_courant+1,plus_haute_tour);
                                        /* Allons faire recursivement la meme operation d'empilement sur le plot suivant, tant       */
                                        /* qu'il y a un suivant....                                                                  */
                              }
                    else
                              {
                              int       longueur=0;
                              for       (plot=PREMIER ; plot<=nPLOTS ; plot++)
                                        {
                                        longueur=longueur+acces(hauteur_des_tours,plot);
                                        /* Calcul du nombre de pions utilises dans la configuration courante d'occupation des plots. */
                                        }

                              if        (longueur == nPIONS)
                                        {
                                        int       tour;

                                        nombre_de_configurations++;
                                        /* Comptage des configurations possibles rencontrees...                                      */

                                        for       (tour=plus_haute_tour ; tour>=(PREMIER-1) ; tour--)
                                                  {
                                                  printf("\n");

                                                  for       (plot=PREMIER ; plot<=nPLOTS ; plot++)
                                                            {
                                                            if        (tour > acces(hauteur_des_tours,plot))
                                                                      {
                                                                      printf("  ");
                                                                      }
                                                            else
                                                                      {
                                                                      if        (tour >= PREMIER)
                                                                                {
                                                                                printf("+ ");
                                                                                }
                                                                      else
                                                                                {
                                                                                printf("- ");
                                                                                }
                                                                      }
                                                            }
                                                  }

                                        printf("\n");

                                        for       (plot=PREMIER ; plot<=nPLOTS ; plot++)
                                                  {
                                                  printf("%d ",acces(hauteur_des_tours,plot));
                                        /* Cas ou le nombre de pions utilises dans la configuration courante est egal au nombre      */
                                        /* de pions disponibles.                                                                     */
                                                  }

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

          acces(hauteur_des_tours,plot_courant)=sauve;
          }

void      recherche_des_configurations_possibles()
          {
          int       plot;
          int       nombre_de_plots_occupes;
          int       plus_haute_tour;

          nombre_de_plots_occupes=0;
          for       (plot=PREMIER ; plot<=nPLOTS ; plot++)
                    {
                    acces(hauteur_des_tours,plot)=0;
                    if        (acces(plots_occupes,plot) == VRAI)
                              {
                              nombre_de_plots_occupes++;
                              }
                    else
                              {
                              }
                    }
          plus_haute_tour=(nPIONS%nombre_de_plots_occupes)+1;
                                        /* Plus haute tour de pions possible etant donne le nombre de plots pouvant etre occupes     */
                                        /* et le nombre de pions...                                                                  */

          printf("plus haute tour : %d\n",plus_haute_tour);

          nombre_de_configurations=0;
                                        /* Comptage des configurations possibles rencontrees...                                      */

          recursif(PREMIER,plus_haute_tour);
                                        /* Exploration de toutes les configurations possibles d'empilement de pions en chaque plot   */
                                        /* en partant du premier plot...                                                             */

          printf("\nnombre de configurations possibles : %d",nombre_de_configurations);

          printf("\n");
          }

main()
          {
          dPLOTS(1,FAUX);
          dPLOTS(2,FAUX);
          dPLOTS(3,VRAI);
          dPLOTS(4,VRAI);
          dPLOTS(5,FAUX);
          dPLOTS(6,VRAI);
          dPLOTS(7,VRAI);
          dPLOTS(8,FAUX);
                                        /* Definition (arbitraire) de la configuration initiale.                                     */
          recherche_des_configurations_possibles();
                                        /* Recherche des configurations possibles pour la configuration initiale.                    */
          printf("\n\n");

          dPLOTS(1,FAUX);
          dPLOTS(2,VRAI);
          dPLOTS(3,FAUX);
          dPLOTS(4,FAUX);
          dPLOTS(5,VRAI);
          dPLOTS(6,VRAI);
          dPLOTS(7,VRAI);
          dPLOTS(8,VRAI);
                                        /* Definition (arbitraire) de la configuration initiale.                                     */
          recherche_des_configurations_possibles();
                                        /* Recherche des configurations possibles pour la configuration initiale.                    */
          printf("\n\n");

          dPLOTS(1,VRAI);
          dPLOTS(2,VRAI);
          dPLOTS(3,VRAI);
          dPLOTS(4,VRAI);
          dPLOTS(5,VRAI);
          dPLOTS(6,FAUX);
          dPLOTS(7,VRAI);
          dPLOTS(8,FAUX);
                                        /* Definition (arbitraire) de la configuration initiale.                                     */
          recherche_des_configurations_possibles();
                                        /* Recherche des configurations possibles pour la configuration initiale.                    */
          }



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