/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T I R A G E   A   P I L E   O U   F A C E   P A R A D O X A L  :                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Nota :                                                                                                                     */
/*                                                                                                                                   */
/*                    Ce programme est destine a resoudre le                                                                         */
/*                  probleme 'v $Dcourrier_in/20150428165002 From.jeanpierre.borg@orange.fr..Tue.Apr.28.14:59:10.2015'.              */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/pile_ou_face_Paradoxal.02$vv$c' :                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20150513085056).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

int       EditerLesTirages=VRAI;
int       ColorierLesJeuxGagnants=VRAI;
char      SeparateurAvantJeuGagnant[]="<";
char      SeparateurApresJeuGagnant[]=">";
                                        /* Indicateur de controle des editions de tous les tirages aleatoires.                       */

#define   P                                                                                                                             \
                    0
#define   F                                                                                                                             \
                    1
                                        /* Definition de 'PILE' et 'FACE'...                                                         */

char      Jeu1[]={P,P,F};
char      Jeu2[]={F,P,P};
                                        /* Definition des "Jeu1" et "Jeu2". On notera qu'ils n'ont pas necessairement la meme        */
                                        /* longueur ; il est de plus imperatif que le type soit 'char' afin que 'sizeof(...)'        */
                                        /* donne bien le nombre d'elements des vecteurs (qui est egal au nombre d'octets...).        */

#define   NOMBRE_DE_PARTIES                                                                                                             \
                    500
#define   NOMBRE_MAXIMAL_DE_TIRAGES_ALEATOIRES                                                                                          \
                    (100*NOMBRE_DE_PARTIES)

extern    double    drand48();

#define   SEUIL                                                                                                                         \
                    (1.0/2.0)
#define   TIRAGE_ALEATOIRE                                                                                                              \
                    ((int)COND((drand48() < SEUIL),P,F))
                                        /* Generation aleatoire...                                                                   */

#define   EDITER(impression)                                                                                                            \
                    {                                                                                                                   \
                    if        (EditerLesTirages == VRAI)                                                                                \
                              {                                                                                                         \
                              impression;                                                                                               \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Edition conditionelle de quelque chose...                                                 */

#define   K_ESC                                                                                                                         \
                    0x1b                                                                                                                \
                                        /* Caractere <ESCAPE> (voir a ce propos 'v $xtc/InvVideo.01$c'...).                          */
#define   CouleurDebut                                                                                                                  \
                    "["
#define   CouleurFin__                                                                                                                  \
                    "m"
#define   CouleurReset                                                                                                                  \
                    "0"
#define   CouleurLumineux                                                                                                               \
                    "1"
#define   CouleurFondNoir                                                                                                               \
                    "40"
#define   CouleurJeu1                                                                                                                   \
                    "31"
#define   CouleurJeu2                                                                                                                   \
                    "33"
#define   BCouleur(jeu,couleur)                                                                                                         \
                    {                                                                                                                   \
                    int       IndexJeu;                                                                                                 \
                                                                                                                                        \
                    for       (IndexJeu=INDEX0 ; IndexJeu <= NombreVersIndex(sizeof(jeu)) ; IndexJeu++)                                 \
                              {                                                                                                         \
                              EDITER(printf("\b"));                                                                                     \
                                        /* Retour en arriere car, en effet, le 'jeu' a deja ete marque en minuscule (Noir et Blanc). */ \
                              }                                                                                                         \
                                                                                                                                        \
                    EDITER(printf("%s",SeparateurAvantJeuGagnant););                                                                    \
                                                                                                                                        \
                    if        (ColorierLesJeuxGagnants == VRAI)                                                                         \
                              {                                                                                                         \
                    EDITER(printf("%c%s%s;%s;%s%s",K_ESC,CouleurDebut,couleur,CouleurFondNoir,CouleurLumineux,CouleurFin__););          \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                        /* Afin de marquer 'jeu' en couleurs...                                                      */ \
                    }
#define   ECouleur                                                                                                                      \
                    {                                                                                                                   \
                                                                                                                                        \
                    if        (ColorierLesJeuxGagnants == VRAI)                                                                         \
                              {                                                                                                         \
                    EDITER(printf("%c%s%s%s",K_ESC,CouleurDebut,CouleurReset,CouleurFin__););                                           \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    EDITER(printf("%s",SeparateurApresJeuGagnant););                                                                    \
                    }
                                        /* Procedures de coloriage...                                                                */

#define   EDITER_JEU(jeu)                                                                                                               \
                    {                                                                                                                   \
                    int       IndexJeu;                                                                                                 \
                                                                                                                                        \
                    for       (IndexJeu=INDEX0 ; IndexJeu <= NombreVersIndex(sizeof(jeu)) ; IndexJeu++)                                 \
                              {                                                                                                         \
                              EDITER(printf("%c",COND((jeu[IndexJeu] == P)                                                              \
                                                     ,'P'                                                                               \
                                                     ,COND((jeu[IndexJeu] == F)                                                         \
                                                          ,'F'                                                                          \
                                                          ,'?'                                                                          \
                                                           )                                                                            \
                                                      )                                                                                 \
                                            );                                                                                          \
                                     );                                                                                                 \
                                        /* Marquage de 'jeu' en couleurs et en majuscules...                                         */ \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Edition conditionelle d'un jeu gagnant...                                                 */

int       JeuGagnant;
#define   TESTER_JEU(jeu)                                                                                                               \
                    {                                                                                                                   \
                    int       IndexTest;                                                                                                \
                                                                                                                                        \
                    JeuGagnant=VRAI;                                                                                                    \
                                        /* A priori, le 'jeu' est gagnant.                                                           */ \
                                                                                                                                        \
                    for       (IndexTest=INDEX0 ; IndexTest <= NombreVersIndex(sizeof(jeu)) ; IndexTest++)                              \
                              {                                                                                                         \
                              if        (Tirages[IndexTirages-(NombreVersIndex(sizeof(jeu))-IndexTest)] == jeu[IndexTest])              \
                                        {                                                                                               \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        JeuGagnant=FAUX;                                                                                \
                                        /* En fait des la premiere non coincidence, on sait que le 'jeu' n'est pas gagnant...        */ \
                                        }                                                                                               \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Est-on en presence d'un jeu ('Jeu1' ou 'Jeu2') gagnant ?                                  */

main()
          {
          int       IndexParties;

          int       IndexTirages=INDEX0;
          int       Tirages[NOMBRE_MAXIMAL_DE_TIRAGES_ALEATOIRES];

          int       CompteurPILE=0;
          int       CompteurFACE=0;

          int       CompteurJeu1=0;
          int       CompteurJeu2=0;

          for       (IndexParties=INDEX0 ; IndexParties <= NombreVersIndex(NOMBRE_DE_PARTIES) ; IndexParties++)
                    {
                    int       LaPartieCouranteNEstPasFinie=VRAI;

                    int       CompteurPartieCourante=0;

                    while     (LaPartieCouranteNEstPasFinie == VRAI)
                              {
                              int       TirageAleatoireCourant=TIRAGE_ALEATOIRE;

                              Tirages[IndexTirages]=TirageAleatoireCourant;

                              CompteurPartieCourante++;

                              if        (TirageAleatoireCourant == P)
                                        {
                                        CompteurPILE++;
                                        EDITER(printf("p"););
                                        /* Marquage des 'PILE's en minuscules quitte a les ecraser ensuite...                        */
                                        }
                              else
                                        {
                                        if        (TirageAleatoireCourant == F)
                                                  {
                                                  CompteurFACE++;
                                                  EDITER(printf("f"););
                                        /* Marquage des 'FACE's en minuscules quitte a les ecraser ensuite...                        */
                                                  }
                                        else
                                                  {
                                                  printf("\nERREUR : un autre etat que 'PILE' ou 'FACE' a ete rencontre.\n");
                                                  }
                                        }

                              if        (CompteurPartieCourante >= MAX2(sizeof(Jeu1),sizeof(Jeu2)))
                                        {
                                        TESTER_JEU(Jeu1);
                                        if        (JeuGagnant == VRAI)
                                                  {
                                                  CompteurJeu1++;
                                                  BCouleur(Jeu1,CouleurJeu1);
                                                  EDITER_JEU(Jeu1);
                                                  ECouleur;
                                        /* Marquage des tirages gagnants de "Jeu1"...                                                */

                                                  LaPartieCouranteNEstPasFinie=FAUX;
                                                  }
                                        else
                                                  {
                                                  TESTER_JEU(Jeu2);
                                                  if        (JeuGagnant == VRAI)
                                                            {
                                                            CompteurJeu2++;
                                                            BCouleur(Jeu2,CouleurJeu2);
                                                            EDITER_JEU(Jeu2);
                                                            ECouleur;
                                        /* Marquage des tirages gagnants de "Jeu2"...                                                */

                                                            LaPartieCouranteNEstPasFinie=FAUX;
                                                            }
                                                  else
                                                            {
                                                            }
                                                  }
                                        }
                              else
                                        {
                                        }

                              if        (IndexTirages < NombreVersIndex(NOMBRE_MAXIMAL_DE_TIRAGES_ALEATOIRES))
                                        {
                                        IndexTirages++;
                                        }
                              else
                                        {
                                        printf("\nERREUR : debordement de la liste des tirages.\n");
                                        }
                              }
                    }

          EditerLesTirages=VRAI;
                                        /* Afin de activer 'EDITER(...)' dans 'EDITER_JEU(...)' ci-apres...                          */

          printf("\n");
          printf("nombre de tirages = %d = %d+%d\n",IndexTirages,CompteurPILE,CompteurFACE);
          printf("nombre de 'pile's = %d\n",CompteurPILE);
          printf("nombre de 'face's = %d\n",CompteurFACE);

          printf("\n");

          printf("nombre de '");
          EDITER_JEU(Jeu1);
          printf("'s = %d\n",CompteurJeu1);

          printf("nombre de '");
          EDITER_JEU(Jeu2);
          printf("'s = %d\n",CompteurJeu2);

          printf("\n");

          EDITER_JEU(Jeu1);
          printf("/");
          EDITER_JEU(Jeu2);
          printf(" = %d/%d = %f\n",CompteurJeu1,CompteurJeu2,((double)CompteurJeu1)/((double)(CompteurJeu2)));
                                        /* Le rapport PPF/FPP semble proche de 1/3, cette propriete etant independante du test       */
                                        /* effectue dans 'TIRAGE_ALEATOIRE' pour choisir PILE ou FACE...                             */
          }



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