Langage C / TP 4: Tableaux

1. Tableaux

Cette section illustre l'utilisation de tableaux en langage C.

Exercice 1.1.

Ecrire un programme tp4-ex11.c contenant une fonction void affiche(int t[], unsigned int n) qui affiche le tableau t de taille n passé en argument sur la sortie standard. La forme de l’affichage doit être : [ t[0], t[1], …, t[n] ]. Si le tableau est vide, la fonction affiche simplement [ ]. Le programme doit contenir également une fonction main qui permet de faire saisir à l’utilisateur un tableau de 5 éléments et l’affiche ensuite dans la bonne forme.

Exemple d’exécution

Element 1/5: 2
Element 2/5: 3
Element 3/5: 4
Element 4/5: 5
Element 5/5: 6

Tableau saisi: [ 2, 3, 4, 5, 6 ] 

#include <stdio.h>

#define N 5

void affiche(int t[], unsigned n) {
    
   printf("[ ");
   
   if (n > 0){
       printf("%d", t[0]);
       
       for(int i = 1; i < n; i++){
           printf(", %d", t[i]);
       }
   }
    
   printf(" ] ");
    
}


void main(void){
    
    int t[N];
    
    for(int i = 0; i < N; i++){
        printf("Element %d/%d: ", i+1, N);
        scanf("%d", &t[i]);
    }
    
    printf("\nTableau saisi: ");
    affiche(t, N);
    printf("\n");
}

Exercice 1.2.

Ecrire un programme tp4-ex12.c contenant une fonction int somme(int t[], unsigned n) qui calcule et retourne la somme des éléments d’un tableau t de taille n. Le programme doit contenir également une fonction main qui permet de faire saisir à l’utilisateur un tableau de 5 éléments et en affiche la somme.

Exemple d’exécution

Element 1/5: 2
Element 2/5: 3
Element 3/5: 4
Element 4/5: 1
Element 5/5: 1

Somme: 11 

#include <stdio.h>

#define N 5

int somme(int t[], unsigned int n){
  int res = 0 ;

  for (unsigned int i = 0; i < n; ++i)
    res += t[i];

  return res;
}


void main(void){
    
  int t[N];
    
  for(int i = 0; i < N; i++){
    printf("Element %d/%d: ", i+1, N);
    scanf("%d", &t[i]);
  }
    
  printf("Somme: %d", somme(t, N));
}

Exercice 1.3.

Ecrire un programme tp4-ex13.c contenant une fonction void extremum(int t[], unsigned int n, int* min, int*max) qui calcule les extremum (valeurs minimum et maximum) d’un tableau t de taille n et qui les stocke respectivement dans les variables min et max. Le programme doit contenir également une fonction main qui permet de faire saisir à l’utilisateur un tableau de 6 éléments et en affiche les extremum.

Exemple d’exécution

Element 1/6: 2
Element 2/6: 3
Element 3/6: 4
Element 4/6: 1
Element 5/6: 7
Element 6/6: 5

Minimum tableau: 1

Maximum tableau: 7

#include <stdio.h>
#include <limits.h> // pour INT_MIN et INT_MAX

#define N 6

void extremum(int t[], unsigned n, int* min, int*max) {
    
   *min = INT_MAX;
   *max = INT_MIN;
   
   for(int i = 0; i < n; i++){
       if (t[i] < *min) *min = t[i];
       
       if (t[i] > *max) *max = t[i];
   }
}


void main(void) {
    
    int t[N];
    
    int min, max;
    
    for(int i = 0; i < N; i++){
        printf("Element %d/%d: ", i+1, N);
        scanf("%d", &t[i]);
    }
    
    extremum(t, N, &min, &max);
    
    printf("\nMinimum tableau: %d\n", min);
    printf("\nMaximum tableau: %d\n", max);
}

Exercice 1.4.

Ecrire un programme tp4-ex14.c contenant une fonction void inverse(int t[], unsigned int n) qui inverse le tableau t de taille n passé en argument. L’inverse d’un tableau $t$ de taille $n$ est un tableau $t’$ tel que $t^\prime\left[i\right]=t\left[n-i\right],\ 0\le i<n$. Le programme doit contenir également une fonction main qui permet de faire saisir à l’utilisateur un tableau de 7 éléments et en afficher l’inverse.

Exemple d’exécution

Element 1/7: 1
Element 2/7: 2
Element 3/7: 3
Element 4/7: 4
Element 5/7: 5
Element 6/7: 6
Element 7/7: 7

Tableau original: [ 1, 2, 3, 4, 5, 6, 7 ]

Tableau inverse: [ 7, 6, 5, 4, 3, 2, 1 ]

#include <stdio.h>

#include <limits.h> // pour INT_MIN et INT_MAX

#define N 7

void affiche(int t[], unsigned n) {
    
   printf("[ ");
   
   if (n > 0){

       printf("%d", t[0]);
       
       for(int i = 1; i < n; i++){
           printf(", %d", t[i]);
       }
   }
    
   printf(" ] ");
    
}

void inverse(int t[], unsigned n)  {
    
   if (n > 1){   // On iverse qu'a partir de 2 elements
       
       int tmp;
       
       for(int i = 0; i < n/2; i++){
           tmp = t[i];
           t[i] = t[n-i-1];
           t[n-i-1] = tmp;
       }
   }
}

void main(void){
    
    int t[N];
    
    int min, max;
    
    for(int i = 0; i < N; i++){
        printf("Element %d/%d: ", i+1, N);
        scanf("%d", &t[i]);
    }
    

    printf("\nTableau original: ");
    affiche(t, N);
    
    inverse(t, N);
    
    printf("\nTableau inverse: ");
    affiche(t, N);
}

2. Tri de tableaux

Il existe de nombreux algorithmes de tri pour ordonner les éléments d'un tableau. Chacun ayant ses avantages et ses inconvénients. 

2.1. Tri sélection

le tri sélection est un un algorithme de tri utilisant la comparaison d'éléments 2 à 2. Cet algorithme est simple mais est relativement inefficace car pour un tableau de taille $n$ il s'exécute en temps quadratique $O(n^2)$. L'algorithme du tri sélection est le suivant:

algorithme tri_selection(tableau t)

      variable n entier
      variable i entier

      n $\leftarrow$ longueur(t) 
      
      i $\leftarrow$ 0
      tanque i < n - 1 faire
          min $\leftarrow$ i
          
          j $\leftarrow$ i + 1
          tantque j < n faire
              si t[j] < t[min] alors 
                min $\leftarrow$ j
              finsi
                
              j $\leftarrow$ j + 1
          fintq
          
          si min $\neq$ i alors 
            échanger(t[i], t[min])
          finsi
          
          i $\leftarrow$ i + 1
          
      fintq
fin

Exercice 2.1.

Ecrire un programme tp4-ex21.c contenant une fonction void tri_selection(int t[], unsigned int n) qui trie le tableau t de taille n passé en argument en utilisant l’algorithme de tri par sélection. Le programme doit contenir également une fonction main qui permet de faire saisir à l’utilisateur un tableau de 5 éléments et d’afficher le tableau une fois trié.

Exemple d’exécution

Element 1/5: 3
Element 2/5: 2
Element 3/5: 5
Element 4/5: 4
Element 5/5: 1

Tableau original: [ 3, 2, 5, 4, 1 ] 
Tableau trie: [ 1, 2, 3, 4, 5 ]

#include <stdio.h>

#define N 5

void affiche(int t[], unsigned n) {
    
    printf("[ ");
   
    if (n > 0){
        printf("%d", t[0]);
       
        for(int i = 1; i < n; i++){
            printf(", %d", t[i]);
        }
    }
    
    printf(" ] ");
    
}

void tri_selection(int t[], unsigned int n)  {
    
    unsigned int i, j, min; // Indices

    int c; // Valeur tampon

    // On ne trie qu'a partir de 2 elements
    if (n > 1){

        // Parcours du tableau de 0 a n
        for(i = 0; i < n-1; i++){         
        
            min = i;

			// Recherche de l'indice de la plus petite valeur
            // inferieure a t[i] dans le reste du tableau			
            for(j = i+1; j < n; j++)
                if ( t[j] < t[min] )    
                    min = j;
          
            // Echange de t[i] et t[min]
            if (min != i){
                c = t[i];
                t[i] = t[min];
                t[min] = c;
            }
        }
    }
}

void main(void){
    
    int t[N];
    
    int min, max;
    
    for(int i = 0; i < N; i++){
        printf("Element %d/%d: ", i+1, N);
        scanf("%d", &t[i]);
    }
    

    printf("\nTableau original: ");
    affiche(t, N);
    
    tri_selection(t, N);
    
    printf("\nTableau trie: ");
    affiche(t, N);
}

2.2. Tri à bulles

Le tri à bulles est un algorithme permettant de trier un tableau en comparant répétitivement ses éléments consécutifs et en les permutant lorsqu'ils sont mal triés. Cet algorithme doit son nom au fait qu'il déplace rapidement les plus grands éléments en fin de tableau, comme des bulles d'air qui remonteraient rapidement à la surface d'un liquide. Tout comme le tri sélection,  pour un tableau de taille $n$ le tri à bulles s'exécute en temps quadratique $O(n^2)$.

L'algorithme du tri à bulles est le suivant:

algorithme tri_a_bulles(tableau t)

  variable n entier
  variable i entier

  n $\leftarrow$ longueur(t)

  i $\leftarrow$ n - 1
  tantque i $\geq$ 1 faire

    j $\leftarrow$ 0
    tantque j $\leq$ i - 1 faire
      si t[j+1] < t[j] alors
        echanger(t[j], t[j+1])
      finsi
      
      j $\leftarrow$ j + 1  
    fintq
    
    i $\leftarrow$ i - 1
  fintq
fin

Exercice 2.2.

Ecrire un programme tp4-ex22.c contenant une fonction void tri_bulle(int t[], unsigned int n) qui trie le tableau t de taille n passé en argument en utilisant l’algorithme de tri à bulle. Le programme doit contenir également une fonction main qui permet de faire saisir à l’utilisateur un tableau de 6 éléments et d’afficher le tableau une fois trié.

Exemple d’exécution

Element 1/6: 4
Element 2/6: 6
Element 3/6: 7
Element 4/6: 2
Element 5/6: 1
Element 6/6: 3

Tableau original: [ 4, 6, 7, 2, 1, 3 ] 
Tableau trie: [ 1, 2, 3, 4, 6, 7 ]

#include <stdio.h>

#include <limits.h> // pour INT_MIN et INT_MAX

#define N 6

void affiche(int t[], unsigned n) {
    
   printf("[ ");
   
   if (n > 0){
       printf("%d", t[0]);
       
       for(int i = 1; i < n; i++){
           printf(", %d", t[i]);
       }
   }
    
   printf(" ] ");
    
}

void tri_bulle(int t[], unsigned n)  {
    
  if (n > 1){   // On ne trie qu'a partir de 2 elements
    
    int c;
    
    for(int j=1;j<=n;j++){ 
      for(int i=0;i<n-1;i++) {
        if ( t[i] > t[i+1] ) {
          c = t[i];
          t[i] = t[i+1];
          t[i+1] = c;
        }
      }
    }
  }
}

void main(void){
    
    int t[N];
    
    int min, max;
    
    for(int i = 0; i < N; i++){
        printf("Element %d/%d: ", i+1, N);
        scanf("%d", &t[i]);
    }
    

    printf("\nTableau original: ");
    affiche(t, N);
    
    tri_bulle(t, N);
    
    printf("\nTableau trie: ");
    affiche(t, N);
}

3. Jeu du Morpion

Le but de cette partie du TP est de réaliser un jeu de morpion en C 

Le jeu de morpion repose sur un plateau qui sera représenté par un tableau d’unsigned char à deux dimensions de taille 3x3. Chaque case du tableau peut contenir une valeur parmi :

  • ' ' le caractère espace.
  • 'X' le caractère X qui est le symbole du joueur 1.
  • 'O' le caractère O qui est le symbole du joueur 2.

Un exemple de plateau en cours de partie est le suivant :

[   X   ]
[ O   X ]
[ O   O ]

Le déroulement de la partie est le suivant :

  1. Le plateau de jeu est initialisé avec des espaces ' '
  2. Le joueur 1 place un symbole 'X' sur une case vide
  3. Si 3 symboles du joueur 1 sont alignés, il gagne la partie
  4. Le joueur 2 place un symbole 'O' sur une case vide
  5. Si 3 symboles du joueur 2 sont alignés, il gagne la partie
  6. Si aucun des 2 joueurs n’a gagné et s’il reste au moins une case libre, on reprend on point 2

Exercice 3.1.

Créer un fichier tp4-morpion.c. C'est dans celui-ci que seront ajoutées toutes les fonctions nécessaires à la programmation du jeu. Ajouter à tp4-morpion.c une fonction main qui déclare une variable plateau comme un tableau de char à deux dimensions de taille 3 x 3 et initialise chacune de ses cases avec le caractère espace ' '.

#include <stdio.h>

int main(){
  char plateau[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};

  return 0;
}

Exercice 3.2.

Dans le fichier tp4-morpion.c, ajouter une fonction void affiche(char plateau[][3]) qui affiche le plateau de jeu dans la console sous la forme :

[   X   ]
[ O   X ]
[ O   O ]

Modifier la fonction main du programme pour tester l'affichage du tableau {{' ', 'X', ' '}, {'O', ' ', 'X'}, {'O', ' ', ' O'}}

Remarque: Dans le cadre du langage C, lors du passage d'un tableau à 2 dimensions à une fonction, seule la taille de la seconde dimension est nécessaire. Ceci est du au fait qu'un tableau est toujours stocké en mémoire sous forme d'un tableau à 1 dimension.

#include <stdio.h>

void affiche(char plateau[][3]){
    
    for(int i = 0; i < 3; i++){
        printf("[ ");
        
        printf("%c", plateau[i][0]);
        for(int j = 1; j < 3; j++){
            printf(" %c", plateau[i][j]);
        }
        
        printf(" ]\n");
    }
    
}

int main() {
    char plateau[3][3] = {{' ', 'X', ' '}, {'O', ' ', 'X'}, {'O', ' ', 'O'}};

    affiche(plateau);

    return 0;
}

Exercice 3.3.

Dans le fichier tp4-morpion.c, ajouter une fonction char case_valide(int ligne, int colonne, char plateau[][3]) qui retourne 1 si la case (ligne, colonne) du plateau est valide et 0 sinon. Une case est valide si elle satisfait toutes les conditions suivantes :

  • ligne est positive et strictement inférieure à 3.
  • colonne est positive et strictement inférieure à 3.
  • la case plateau[ligne][colonne] contient le caractère espace ' '.

Modifier la fonction main du programme pour créer un plateau avec les valeurs: {{' ', 'X', ' '}, {'O', ' ', 'X'}, {'O', ' ', ' O'}}. et tester ensuite la fonction case_valide sur différentes cases en affichant sur la console si elles sont valides ou non.

Exemple d'exécution:

case (0, 0) valide.
case (0, 1) invalide.
case (0, 2) valide.
case (1, 0) invalide.
case (1, 1) valide.
case (1, 2) invalide.
case (2, 0) invalide.
case (2, 1) valide.
case (2, 2) invalide.

#include <stdio.h>

void affiche(char plateau[][3]){
    
    for(int i = 0; i < 3; i++){
        printf("[ ");
        
        printf("%c", plateau[i][0]);
        for(int j = 1; j < 3; j++){
            printf(" %c", plateau[i][j]);
        }
        
        printf(" ]\n");
    }
    
}

char case_valide(int ligne, int colonne, char plateau[][3]){
    
    char valide = 0;
    
    if ((ligne >= 0) && (ligne < 3) && (colonne >= 0) && (colonne < 3)){
        valide = (plateau[ligne][colonne]==' ')?1:0;
    }
    
    return valide;
}

char case_libre(char plateau[][3]){
    for(int ligne = 0; ligne < 3; ligne++){
        for(int colonne = 0; colonne <3; colonne++){
            if (plateau[ligne][colonne] == ' ')
                return 1;
        }
    }
    
    return 0;
}

int main(){
  char plateau[3][3] = {{' ', 'X', ' '}, {'O', ' ', 'X'}, {'O', ' ', ' O'}};

  for(unsigned int row = 0; row < 3; row++)
    for(unsigned int col = 0; col < 3; col++)
      if (case_valide(row, col, plateau))
        printf("case (%u, %u) valide.\n", row, col);
      else
        printf("case (%u, %u) invalide.\n", row, col);

  return 0;
}

Exercice 3.4.

Dans le fichier tp4-morpion.c, ajouter une fonction char case_libre(char plateau[][3]) qui retourne 1 si le plateau contient au moins une case vide et 0 sinon. Une case est considérée comme libre si elle contient le caractère espace ' '. Modifier ensuite la fonction main du programme pour tester le retour de la fonction case_vide avec différentes configurations de plateau.

#include <stdio.h>

void affiche(char plateau[][3]){
    
    for(int i = 0; i < 3; i++){
        printf("[ ");
        
        printf("%c", plateau[i][0]);
        for(int j = 1; j < 3; j++){
            printf(" %c", plateau[i][j]);
        }
        
        printf(" ]\n");
    }
    
}

char case_valide(int ligne, int colonne, char plateau[][3]){
    
    char valide = 0;
    
    if ((ligne >= 0) && (ligne < 3) && (colonne >= 0) && (colonne < 3)){
        valide = (plateau[ligne][colonne]==' ')?1:0;
    }
    
    return valide;
}

char case_libre(char plateau[][3]){
    for(int ligne = 0; ligne < 3; ligne++){
        for(int colonne = 0; colonne <3; colonne++){
            if (plateau[ligne][colonne] == ' ')
                return 1;
        }
    }
    
    return 0;
}

int main() {
    char plateau[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};

    if (case_libre(plateau))
      printf("Le plateau possede au moins une case de libre.");

    return 0;
}

Exercice 3.5.

Dans le fichier tp4-morpion.c, ajouter une fonction char aligne(char symbole, char plateau[][3]) qui retourne 1 si pour le symbole donné ('X' ou 'O') une ligne existe sur le plateau et 0 sinon. Une ligne peut être horizontale, verticale ou diagonale. Modifier la fonction main du programme pour créer un plateau avec les valeurs: {{'X', 'O', ' '}, {'O', 'X', ' '}, {'O', ' ', 'X'}} et tester ensuite la fonction aligne. Essayer ensuite plusieurs configurations de plateau.

#include <stdio.h>

void affiche(char plateau[][3]){
    
    for(int i = 0; i < 3; i++){
        printf("[ ");
        
        printf("%c", plateau[i][0]);
        for(int j = 1; j < 3; j++){
            printf(" %c", plateau[i][j]);
        }
        
        printf(" ]\n");
    }
    
}

char case_valide(int ligne, int colonne, char plateau[][3]){
    
    char valide = 0;
    
    if ((ligne >= 0) && (ligne < 3) && (colonne >= 0) && (colonne < 3)){
        valide = (plateau[ligne][colonne]==' ')?1:0;
    }
    
    return valide;
}

char case_libre(char plateau[][3]){
    for(int ligne = 0; ligne < 3; ligne++){
        for(int colonne = 0; colonne <3; colonne++){
            if (plateau[ligne][colonne] == ' ')
                return 1;
        }
    }
    
    return 0;
}

char aligne(char symbole, char plateau[][3]){
    return    ((plateau[0][0] == symbole) && (plateau[0][1] == symbole) && (plateau[0][2] == symbole))
           || ((plateau[1][0] == symbole) && (plateau[1][1] == symbole) && (plateau[1][2] == symbole))
           || ((plateau[2][0] == symbole) && (plateau[2][1] == symbole) && (plateau[2][2] == symbole))
           || ((plateau[0][0] == symbole) && (plateau[1][0] == symbole) && (plateau[2][0] == symbole))
           || ((plateau[0][1] == symbole) && (plateau[1][1] == symbole) && (plateau[2][1] == symbole))
           || ((plateau[0][2] == symbole) && (plateau[1][2] == symbole) && (plateau[2][1] == symbole))
           || ((plateau[0][0] == symbole) && (plateau[1][1] == symbole) && (plateau[2][2] == symbole))
           || ((plateau[0][2] == symbole) && (plateau[1][1] == symbole) && (plateau[2][0] == symbole));
}

int main() {
    char plateau[3][3] = {{'X', 'O', ' '}, {'O', 'X', ' '}, {'O', ' ', 'X'}};

    affiche(plateau);

    if (aligne('X', plateau))
      printf("Il existe une ligne sur le plateau.");
    else
      printf("Le plateau ne contient pas de ligne.");

    return 0;
}

Exercice 3.6.

Dans le fichier tp4-morpion.c, compléter la fonction main afin de faire se dérouler une partie de morpion. L’utilisation des fonctions implantées précédemment est obligatoire.

Rappel: Le déroulement de la partie est le suivant :

  1. Le plateau de jeu est initialisé avec des espaces ' '
  2. Le joueur 1 place un symbole 'X' sur une case vide
  3. Si 3 symboles du joueur 1 sont alignés, il gagne la partie
  4. Le joueur 2 place un symbole 'O' sur une case vide
  5. Si 3 symboles du joueur 2 sont alignés, il gagne la partie
  6. Si aucun des 2 joueurs n’a gagné et s’il reste au moins une case libre, on reprend on point 2

#include <stdio.h>

void affiche(char plateau[][3]){
    
    for(int i = 0; i < 3; i++){
        printf("[ ");
        
        printf("%c", plateau[i][0]);
        for(int j = 1; j < 3; j++){
            printf(" %c", plateau[i][j]);
        }
        
        printf(" ]\n");
    }
    
}

char case_valide(int ligne, int colonne, char plateau[][3]){
    
    char valide = 0;
    
    if ((ligne >= 0) && (ligne < 3) && (colonne >= 0) && (colonne < 3)){
        valide = (plateau[ligne][colonne]==' ')?1:0;
    }
    
    return valide;
}

char case_libre(char plateau[][3]){
    for(int ligne = 0; ligne < 3; ligne++){
        for(int colonne = 0; colonne <3; colonne++){
            if (plateau[ligne][colonne] == ' ')
                return 1;
        }
    }
    
    return 0;
}

char aligne(char symbole, char plateau[][3]){
    return    ((plateau[0][0] == symbole) && (plateau[0][1] == symbole) && (plateau[0][2] == symbole))
           || ((plateau[1][0] == symbole) && (plateau[1][1] == symbole) && (plateau[1][2] == symbole))
           || ((plateau[2][0] == symbole) && (plateau[2][1] == symbole) && (plateau[2][2] == symbole))
           || ((plateau[0][0] == symbole) && (plateau[1][0] == symbole) && (plateau[2][0] == symbole))
           || ((plateau[0][1] == symbole) && (plateau[1][1] == symbole) && (plateau[2][1] == symbole))
           || ((plateau[0][2] == symbole) && (plateau[1][2] == symbole) && (plateau[2][1] == symbole))
           || ((plateau[0][0] == symbole) && (plateau[1][1] == symbole) && (plateau[2][2] == symbole))
           || ((plateau[0][2] == symbole) && (plateau[1][1] == symbole) && (plateau[2][0] == symbole));
}

int main()
{
    char plateau[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};

    char partie_en_cours = 1;

    unsigned char joueur_1_actif = 1;
    
    unsigned char joueur_2_actif = 0;

    unsigned int ligne, colonne;

    affiche(plateau);

    while(partie_en_cours && case_libre(plateau)){

        if (joueur_1_actif){
            printf("Coup joueur 1 (ligne colonne): ");
            scanf("%d %d", &ligne, &colonne);
            
            if (case_valide(ligne, colonne, plateau)){
                plateau[ligne][colonne] = 'X';
                
                affiche(plateau);
                
                if (aligne('X', plateau)){
                    printf("Victoire du joueur 1 !!\n");
                    partie_en_cours = 0;
                } else {
                  joueur_1_actif = 0;
                  joueur_2_actif = 1;
                }
                
                
            } else {
                printf("Case invalide, joueur 1 rejoue !!\n");
            }
        }
        
        if (joueur_2_actif && case_libre(plateau)){
            
            printf("Coup joueur 2 (ligne colonne): ");
            scanf("%d %d", &ligne, &colonne);
            
            if (case_valide(ligne, colonne, plateau)){
                plateau[ligne][colonne] = 'O';
                
                affiche(plateau);
                
                if (aligne('O', plateau)){
                    printf("Victoire du joueur 2 !!\n");
                    partie_en_cours = 0;
                } else {
                   joueur_1_actif = 1;
                   joueur_2_actif = 0; 
                }

            } else {
                printf("Case invalide, joueur 2 rejoue !!\n");
            }
        }
        
    }

    printf("Partie terminee...\n");

    return 0;
}