IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

[C] Problème Puissance 4


Sujet :

C

  1. #1
    Invité
    Invité(e)
    Par défaut [C] Problème Puissance 4
    Bonjour,
    je doit réaliser un puissance 4 avec le choix de jouer a 2 joueurs ou contre une IA. J'ai bientot fini le 2 joueurs mais le problème c'est que au lieu de jouer l'un àprès l'autre, c'est le premier joueur qui joue tout le temps et aprés qu'il a gagné c'est le deuxième joueur qui joue.
    SVP de l'aide

  2. #2
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    On a aucun moyen de t'aider sans voir le code que tu as fait.

  3. #3
    Invité
    Invité(e)
    Par défaut Voici mon code source
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    //Début du programme principal
    int main()
    {//Déclaration des variables
    char tab[8][6];
    char X='X';
    char O='O';
    int i,j,C1,C2,L1,L2,L3,L4,L5,L6;
    int gagn1=0;
    int gagn2=0;
    int jeux=0;
    char L,x;
    char choix=0;
    printf("\t\t--------------------------------------------------\n");
    printf("\t\t--------------------------------------------------\n");
    printf("\t\t--\tBienvenue au puissance 4 de Ziad\t--\n");
    printf("\t\t--------------------------------------------------\n");
    printf("\t\t--------------------------------------------------\n\n\n\n\n");
    printf("\t\tVeuillez choisir un mode de jeux entre:\n\n");
    printf("\t\t\t* Deux joueurs: Joueur 1 Vs Joueur 2 -> 1\n");
    printf("\n\t\t\t* Un joueur: Joueur 1 Vs Ordi --------> 2\n");
    choix=getchar();
    switch(choix)
        {
            case '1' :{
                        system("cls");
                        char J1[20], J2[20]; //Saisie des noms des deux joueurs:
                        printf("Vous avez choisi de jouer a deux joueurs");
                        printf("\nEntrez le nom du joueur 1: ");
                        scanf("%s",&J1);
                        printf("\nEntrez le nom du joueur 2: ");
                        scanf("%s",&J2);
                        printf("\nLe combat oppose %s Vs %s\n",J1,J2);
                        {//Initialisation du tableau toutes les cases affichent des espaces
                                    printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                                    printf("---------------------------------\n");
                                           for(j=5;j>=0;j--)
                                           {
                                              for(i=0;i<8;i++)
                                              {
                                                    tab[i][j]=' ';
                                                    tab[0][5]=tab[7][5]='f';
                                                    tab[0][4]=tab[7][4]='e';
                                                    tab[0][3]=tab[7][3]='d';
                                                    tab[0][2]=tab[7][2]='c';
                                                    tab[0][1]=tab[7][1]='b';
                                                    tab[0][0]=tab[7][0]='a';
                                                 printf("| %c ",tab[i][j]);//Affichage du plateau de jeu vide
                                              }
                                              printf("|\n");
                                              printf("---------------------------------\n");
                                           }
                                           printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                        }
                                    do
                                        {
                                            //Le 1er joueur joue
                                            do
                                            {
                                                L1=0;L2=0;L3=0;L4=0;L5=0;L6=0;
                                                printf("A vous de jouer %s, donner une lettre de ligne (de a à f) et un numero de colonne (de 1 à 6):\n",J1);
                                                scanf("%d",&C1);
                                            //Test sur la hauteur des colonnes, si elle sont remplies ou non
                                              if((C1==1 && L1>5)|| (C1==2 && L2>5) || (C1==3 && L3>5) || (C1==4 && L4>5)  || (C1==5 && L5>5) || (C1==6 && L6>5))
                                              {
                                                 printf("\nDesole %s mais, la colonne %d est pleine, veuillez donner un autre numero de colone\n",J1,C1);
                                                 C1=-1;
                                              }
                                            }
                                            while((C1<1 || C1>6));
                                        //Donne le caractère X à la case jouée par le 1er joueur
                                           {
                                        i=C1;j=0;
                                        if(tab[i][j]==' ')
                                        tab[i][j]='X';
                                        for(j=5;j>=0;j--)
                                            {
                                                if(tab[i][j]=='X' || tab[i][j]=='O')
                                                tab[i][j++]='X';
                                            }
                                           }
             	                           //Affichage de la grille
                                           system("cls");
                                           printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                                    printf("---------------------------------\n");
                                           for(j=5;j>=0;j--)
                                           {
                                              for(i=0;i<8;i++)
                                              {
                                                    tab[0][5]=tab[7][5]='f';
                                                    tab[0][4]=tab[7][4]='e';
                                                    tab[0][3]=tab[7][3]='d';
                                                    tab[0][2]=tab[7][2]='c';
                                                    tab[0][1]=tab[7][1]='b';
                                                    tab[0][0]=tab[7][0]='a';
                                                 printf("| %c ",tab[i][j]);//Affichage du plateau de jeu vide
                                              }
                                              printf("|\n");
                                              printf("---------------------------------\n");
                                           }
                                           printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                                        /*Vérification horizontale pour savoir si le joueur a gagné:
                                        on balaye toutes les lignes de 0 à 5 en vérifiant 4 cases à chaque fois
                                        Si 4 cases qui se suivent sont à X alors gagne prend pour valeur 1*/
                                        for(i=1;i<4;i++)
                                           {
                                              for(j=0;j<6;j++)
                                              {
                                                 if(tab[i][j]=='X' && tab[i+1][j]=='X' && tab[i+2][j]=='X' && tab[i+3][j]=='X')
                                                    gagn1=1;
                                              }
                                           }
             	                           //Même chose mais verticalement maintenant
                                           for(i=1;i<7;i++)
                                           {
                                              for(j=0;j<3;j++)
                                              {
                                                 if(tab[i][j]=='X' && tab[i][j+1]=='X' && tab[i][j+2]=='X' && tab[i][j+3]=='X')
                                                    gagn1=1;
                                              }
                                           }
     
                                        //Et diagonale bas gauche vers haut droit
                                           for(i=1;i<4;i++)
                                           {
                                              for(j=0;j<3;j++)
                                              {
                                                 if(tab[i][j]=='X' && tab[i+1][j+1]=='X' && tab[i+2][j+2]=='X' && tab[i+3][j+3]=='X')
                                                    gagn1=1;
                                              }
                                           }
                                        //Même chose pour les diagonales bas droite vers haut gauche
                                           for(j=0;j<3;j++)
                                           {
                                              for(i=6;i>3;i--)
                                              {
                                                 if(tab[i][j]=='X' && tab[i-1][j+1]=='X' && tab[i-2][j+2]=='X' && tab[i-3][j+3]=='X')
                                                    gagn1=1;
                                              }
                                           }
                                        //Test pour savoir si le joueur 1 a gagné, si c'est le cas alors arret de la boucle
                                           if(gagn1==1)
                                           {
                                              printf("Le gagnant est %s!!!\n",J1);
                                              break;
                                           }
                                        //On recommence pour le joueur 2
                                            //Le 2eme joueur joue
                                            do
                                            {
                                              L1=0;L2=0;L3=0;L4=0;L5=0;L6=0;
                                              printf("A vous de jouer %s, donner une lettre de ligne (de a à f) et un numero de colonne (de 1 à 6):\n",J2);
                                                scanf("%d",&C2);
                                            //Test sur la hauteur des colonnes, si elle sont remplies ou non
                                              if((C2==0 && L1>5)|| (C2==1 && L2>5) || (C2==2 && L3>5) || (C2==3 && L4>5)  || (C2==4 && L5>5) || (C2==5 && L6>5))
                                              {
                                                 printf("\nDesole %s mais, la colonne %d est pleine, veuillez donner un autre numero de colone\n",J2,C2);
                                                 C2=-1;
                                              }
                                            }
                                            while(C2<1 || C2>6);
                                        //Donne le caractère X à la case jouée par le 2eme joueur
                                           {
                                        i=C2;j=0;
                                        if(tab[i][j]==' ')
                                        tab[i][j]='X';
                                        for(j=5;j>=0;j--)
                                            {
                                                if(tab[i][j]=='X' || tab[i][j]=='O')
                                                tab[i][j++]='X';
                                            }
                                           }
                                        /* Affichage de la grille */
                                           system("cls");
                                           printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                                    printf("---------------------------------\n");
                                           for(j=5;j>=0;j--)
                                           {
                                              for(i=0;i<8;i++)
                                              {
                                                    tab[0][5]=tab[7][5]='f';
                                                    tab[0][4]=tab[7][4]='e';
                                                    tab[0][3]=tab[7][3]='d';
                                                    tab[0][2]=tab[7][2]='c';
                                                    tab[0][1]=tab[7][1]='b';
                                                    tab[0][0]=tab[7][0]='a';
                                                 printf("| %c ",tab[i][j]);//Affichage du plateau de jeu vide
                                              }
                                              printf("|\n");
                                              printf("---------------------------------\n");
                                           }
                                           printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                                        /*Vérification horizontale pour savoir si le joueur a gagné:
                                        on balaye toutes les lignes de 0 à 5 en vérifiant 4 cases à chaque fois
                                        Si 4 cases qui se suivent sont à O alors gagn2 prend pour valeur 1*/
                                        for(i=0;i<3;i++)
                                           {
                                              for(j=0;j<6;j++)
                                              {
                                                 if(tab[i][j]=='O' && tab[i+1][j]=='O' && tab[i+2][j]=='O' && tab[i+3][j]=='O')
                                                    gagn2=1;
                                              }
                                           }
             	                           /*Même chose mais verticalement maintenant*/
                                           for(i=0;i<6;i++)
                                           {
                                              for(j=0;j<3;j++)
                                              {
                                                 if(tab[i][j]=='O' && tab[i][j+1]=='O' && tab[i][j+2]=='O' && tab[i][j+3]=='O')
                                                    gagn2=1;
                                              }
                                           }
     
                                        /*Et diagonale bas gauche vers haut droit*/
                                           for(i=0;i<6;i++)
                                           {
                                              for(j=0;j<6;j++)
                                              {
                                                 if(tab[i][j]=='O' && tab[i+1][j+1]=='O' && tab[i+2][j+2]=='O' && tab[i+3][j+3]=='O')
                                                    gagn2=1;
                                              }
                                           }
                                        /*Même chose pour les diagonales bas droite vers haut gauche*/
                                           for(j=0;j<3;j++)
                                           {
                                              for(i=5;i>=0;i--)
                                              {
                                                 if(tab[i][j]=='O' && tab[i-1][j+1]=='O' && tab[i-2][j+2]=='O' && tab[i-3][j+3]=='O')
                                                    gagn2=2;
                                              }
                                           }
                                        /*Test pour savoir si le joueur 2 a gagné, si c'est le cas alors arret de la boucle*/
                                           if(gagn2==2)
                                           {
                                              printf("Le gagnant est %s!!!\n",J2);
                                              break;
                                           }
                                        }
                      while(gagn1!=1 || gagn2!=2);
                        break;
                      }
            default : printf("Erreur de saisie du choix!");
        }
    return 0;
    }
    Dernière modification par Invité ; 15/12/2008 à 23h18.

  4. #4
    Membre Expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Par défaut
    Citation Envoyé par ziad91 Voir le message
    Voila, j'ai réglé quelque problème mais d'autre sont apparu. si vous pouvez m'aider a les corriger.
    Si tu commençais par nous expliquer quels sont ces problèmes ?

  5. #5
    Invité
    Invité(e)
    Par défaut
    Mon problème c'est que les pions ne s'affiche pas ou ils le devraient et je n'arrive pas à jouer un pion au dessus de l'autre, celui ci remplace celui qui est déjà existant.
    Et ce serrais aussi si vous remarqué des choses qui peuvent se simplifier mais toujour en restant dans le même niveau de programmation, c'est à dire débutant .
    Merci

  6. #6
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par ziad91 Voir le message
    <code...>
    - Suppression des commentaires //
    - Réindentation
    - Définition des variables en début de bloc
    - Suppression des variables non utilisées.
    - Retiré & pour les tableaux de char passés à scanf()
    - Ajout de void aux fonctions sans paramètres
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    /* Début du programme principal */
    int main (void)
    {                               /* Déclaration des variables */
       char tab[8][6];
       int i, j, C1, C2, L1, L2, L3, L4, L5, L6;
       int gagn1 = 0;
       int gagn2 = 0;
       char choix = 0;
       printf ("\t\t--------------------------------------------------\n");
       printf ("\t\t--------------------------------------------------\n");
       printf ("\t\t--\tBienvenue au puissance 4 de Ziad\t--\n");
       printf ("\t\t--------------------------------------------------\n");
       printf
          ("\t\t--------------------------------------------------\n\n\n\n\n");
       printf ("\t\tVeuillez choisir un mode de jeux entre:\n\n");
       printf ("\t\t\t* Deux joueurs: Joueur 1 Vs Joueur 2 -> 1\n");
       printf ("\n\t\t\t* Un joueur: Joueur 1 Vs Ordi --------> 2\n");
       choix = getchar ();
       switch (choix)
       {
       case '1':
          {
             char J1[20], J2[20];   /* Saisie des noms des deux joueurs: */
             system ("cls");
             printf ("Vous avez choisi de jouer a deux joueurs");
             printf ("\nEntrez le nom du joueur 1: ");
             scanf ("%s", J1);
             printf ("\nEntrez le nom du joueur 2: ");
             scanf ("%s", J2);
             printf ("\nLe combat oppose %s Vs %s\n", J1, J2);
             {                      /* Initialisation du tableau toutes les cases affichent des espaces */
                printf ("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                printf ("---------------------------------\n");
                for (j = 5; j >= 0; j--)
                {
                   for (i = 0; i < 8; i++)
                   {
                      tab[i][j] = ' ';
                      tab[0][5] = tab[7][5] = 'f';
                      tab[0][4] = tab[7][4] = 'e';
                      tab[0][3] = tab[7][3] = 'd';
                      tab[0][2] = tab[7][2] = 'c';
                      tab[0][1] = tab[7][1] = 'b';
                      tab[0][0] = tab[7][0] = 'a';
                      printf ("| %c ", tab[i][j]); /* Affichage du plateau de jeu vide */
                   }
                   printf ("|\n");
                   printf ("---------------------------------\n");
                }
                printf ("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
             }
             do
             {
                /* Le 1er joueur joue */
                do
                {
                   L1 = 0;
                   L2 = 0;
                   L3 = 0;
                   L4 = 0;
                   L5 = 0;
                   L6 = 0;
                   printf
                      ("A vous de jouer %s, donner une lettre de ligne (de a à f) et un numero de colonne (de 1 à 6):\n",
                       J1);
                   scanf ("%d", &C1);
                   /* Test sur la hauteur des colonnes, si elle sont remplies ou non */
                   if ((C1 == 1 && L1 > 5) || (C1 == 2 && L2 > 5)
                       || (C1 == 3 && L3 > 5) || (C1 == 4 && L4 > 5) || (C1 == 5
                                                                         && L5 >
                                                                         5)
                       || (C1 == 6 && L6 > 5))
                   {
                      printf
                         ("\nDesole %s mais, la colonne %d est pleine, veuillez donner un autre numero de colone\n",
                          J1, C1);
                      C1 = -1;
                   }
                }
                while ((C1 < 1 || C1 > 6));
                /* Donne le caractère X à la case jouée par le 1er joueur */
                {
                   i = C1;
                   j = 0;
                   if (tab[i][j] == ' ')
                      tab[i][j] = 'X';
                   for (j = 5; j >= 0; j--)
                   {
                      if (tab[i][j] == 'X' || tab[i][j] == 'O')
                         tab[i][j++] = 'X';
                   }
                }
                /* Affichage de la grille */
                system ("cls");
                printf ("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                printf ("---------------------------------\n");
                for (j = 5; j >= 0; j--)
                {
                   for (i = 0; i < 8; i++)
                   {
                      tab[0][5] = tab[7][5] = 'f';
                      tab[0][4] = tab[7][4] = 'e';
                      tab[0][3] = tab[7][3] = 'd';
                      tab[0][2] = tab[7][2] = 'c';
                      tab[0][1] = tab[7][1] = 'b';
                      tab[0][0] = tab[7][0] = 'a';
                      printf ("| %c ", tab[i][j]); /* Affichage du plateau de jeu vide */
                   }
                   printf ("|\n");
                   printf ("---------------------------------\n");
                }
                printf ("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                /*Vérification horizontale pour savoir si le joueur a gagné:
                   on balaye toutes les lignes de 0 à 5 en vérifiant 4 cases à chaque fois
                   Si 4 cases qui se suivent sont à X alors gagne prend pour valeur 1 */
                for (i = 1; i < 4; i++)
                {
                   for (j = 0; j < 6; j++)
                   {
                      if (tab[i][j] == 'X' && tab[i + 1][j] == 'X'
                          && tab[i + 2][j] == 'X' && tab[i + 3][j] == 'X')
                         gagn1 = 1;
                   }
                }
                /* Même chose mais verticalement maintenant */
                for (i = 1; i < 7; i++)
                {
                   for (j = 0; j < 3; j++)
                   {
                      if (tab[i][j] == 'X' && tab[i][j + 1] == 'X'
                          && tab[i][j + 2] == 'X' && tab[i][j + 3] == 'X')
                         gagn1 = 1;
                   }
                }
     
                /* Et diagonale bas gauche vers haut droit */
                for (i = 1; i < 4; i++)
                {
                   for (j = 0; j < 3; j++)
                   {
                      if (tab[i][j] == 'X' && tab[i + 1][j + 1] == 'X'
                          && tab[i + 2][j + 2] == 'X' && tab[i + 3][j + 3] == 'X')
                         gagn1 = 1;
                   }
                }
                /* Même chose pour les diagonales bas droite vers haut gauche */
                for (j = 0; j < 3; j++)
                {
                   for (i = 6; i > 3; i--)
                   {
                      if (tab[i][j] == 'X' && tab[i - 1][j + 1] == 'X'
                          && tab[i - 2][j + 2] == 'X' && tab[i - 3][j + 3] == 'X')
                         gagn1 = 1;
                   }
                }
                /* Test pour savoir si le joueur 1 a gagné, si c'est le cas alors arret de la boucle */
                if (gagn1 == 1)
                {
                   printf ("Le gagnant est %s!!!\n", J1);
                   break;
                }
                /* On recommence pour le joueur 2 */
                /* Le 2eme joueur joue */
                do
                {
                   L1 = 0;
                   L2 = 0;
                   L3 = 0;
                   L4 = 0;
                   L5 = 0;
                   L6 = 0;
                   printf
                      ("A vous de jouer %s, donner une lettre de ligne (de a à f) et un numero de colonne (de 1 à 6):\n",
                       J2);
                   scanf ("%d", &C2);
                   /* Test sur la hauteur des colonnes, si elle sont remplies ou non */
                   if ((C2 == 0 && L1 > 5) || (C2 == 1 && L2 > 5)
                       || (C2 == 2 && L3 > 5) || (C2 == 3 && L4 > 5) || (C2 == 4
                                                                         && L5 >
                                                                         5)
                       || (C2 == 5 && L6 > 5))
                   {
                      printf
                         ("\nDesole %s mais, la colonne %d est pleine, veuillez donner un autre numero de colone\n",
                          J2, C2);
                      C2 = -1;
                   }
                }
                while (C2 < 1 || C2 > 6);
                /* Donne le caractère X à la case jouée par le 2eme joueur */
                {
                   i = C2;
                   j = 0;
                   if (tab[i][j] == ' ')
                      tab[i][j] = 'X';
                   for (j = 5; j >= 0; j--)
                   {
     
     
     
     
     
     
                      if (tab[i][j] == 'X' || tab[i][j] == 'O')
                         tab[i][j++] = 'X';
                   }
                }
                /* Affichage de la grille */
                system ("cls");
                printf ("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                printf ("---------------------------------\n");
                for (j = 5; j >= 0; j--)
                {
                   for (i = 0; i < 8; i++)
                   {
                      tab[0][5] = tab[7][5] = 'f';
                      tab[0][4] = tab[7][4] = 'e';
                      tab[0][3] = tab[7][3] = 'd';
                      tab[0][2] = tab[7][2] = 'c';
                      tab[0][1] = tab[7][1] = 'b';
                      tab[0][0] = tab[7][0] = 'a';
                      printf ("| %c ", tab[i][j]); /* Affichage du plateau de jeu vide */
                   }
                   printf ("|\n");
                   printf ("---------------------------------\n");
                }
                printf ("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                /*Vérification horizontale pour savoir si le joueur a gagné:
                   on balaye toutes les lignes de 0 à 5 en vérifiant 4 cases à chaque fois
                   Si 4 cases qui se suivent sont à O alors gagn2 prend pour valeur 1 */
                for (i = 0; i < 3; i++)
                {
                   for (j = 0; j < 6; j++)
                   {
                      if (tab[i][j] == 'O' && tab[i + 1][j] == 'O'
                          && tab[i + 2][j] == 'O' && tab[i + 3][j] == 'O')
                         gagn2 = 1;
                   }
                }
                /*Même chose mais verticalement maintenant */
                for (i = 0; i < 6; i++)
                {
                   for (j = 0; j < 3; j++)
                   {
                      if (tab[i][j] == 'O' && tab[i][j + 1] == 'O'
                          && tab[i][j + 2] == 'O' && tab[i][j + 3] == 'O')
                         gagn2 = 1;
                   }
                }
     
                /*Et diagonale bas gauche vers haut droit */
                for (i = 0; i < 6; i++)
                {
                   for (j = 0; j < 6; j++)
                   {
                      if (tab[i][j] == 'O' && tab[i + 1][j + 1] == 'O'
                          && tab[i + 2][j + 2] == 'O' && tab[i + 3][j + 3] == 'O')
                         gagn2 = 1;
                   }
                }
                /*Même chose pour les diagonales bas droite vers haut gauche */
                for (j = 0; j < 3; j++)
                {
                   for (i = 5; i >= 0; i--)
                   {
                      if (tab[i][j] == 'O' && tab[i - 1][j + 1] == 'O'
                          && tab[i - 2][j + 2] == 'O' && tab[i - 3][j + 3] == 'O')
                         gagn2 = 2;
                   }
                }
                /*Test pour savoir si le joueur 2 a gagné, si c'est le cas alors arret de la boucle */
                if (gagn2 == 2)
                {
                   printf ("Le gagnant est %s!!!\n", J2);
                   break;
                }
             }
             while (gagn1 != 1 || gagn2 != 2);
             break;
          }
       default:
          printf ("Erreur de saisie du choix!");
       }
       return 0;
    }
    Ce code me parait particulièrement indigeste (un main() de 282 lignes, 0 fonctions) et surtout non réfléchi.

    Quand on commence à numéroter ses variables, c'est sans doute qu'on a loupé la notion de 'tableau'.

    La réalisation de tout projet commence par une étude préalable qui consiste à :

    1 - bien définir l'objectif à réaliser
    2 - trouver les moyens de réaliser cet objectif (algorithmes, découpage en fonctions)
    3 - réaliser
    4 - tester

    1 - définir l'objectif

    Ici, on doit décrire :

    - la règle du jeu
    - comment il va s'interfacer avec l'utilisateur

    Je te laisse compléter.

    EDIT : après analyse détaillée du code, je constate qu'il est plus structuré qu'il ne le montre. C'est dommage que tu n'ai pas cherché à faire des fonctions. Ca permet de tester le code par morceaux et de le construire avec des briques vérifiées, ce qui est beaucoup plus rassurant...

    Par contre, il faut veiller à avoir un codage logique, et notamment respecter la notion de ligne et de colonne.

    Le tableau se définit enfait ainsi :

    Zone de jeu de 6 x 6 plus 2 colonnes d'information[1] :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    #define NLIN 6
    #define NCOL (1+6+1)
    <...>
    {
       char tab[NLIN][NCOL];
    D'ailleurs, je suis un peu étonné, car d'après

    http://fr.wikipedia.org/wiki/Puissance_4

    il y a 7 colonnes... Tu es sûr de ta règle ?

    ------------------------
    [1] On pourrait discuter de l'opportunité de mettre des informations d'affichage dans le tableau de données...

  7. #7
    Invité
    Invité(e)
    Par défaut
    Mon problème c'est que les pions ne s'affiche pas ou ils le devraient et je n'arrive pas à jouer un pion au dessus de l'autre, celui ci remplace celui qui est déjà existant.
    Et ce serrais aussi si vous remarqué des choses qui peuvent se simplifier mais toujour en restant dans le même niveau de programmation, c'est à dire débutant .
    Je suppose que ton tab[8][6] c'est ta grille. Il te faut un tab_nb_pions[8] dans lequel tu va mémoriser le nombre de jetons dans chaque colonne (donc laisse tomber tes L1,C1...). Au début du l'initialise à zéro, et quand tu veux ajouter un pion dans la colonne n tu fais :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    if(tab_nb_pions[n]<8)
    {
       tab[n][tab_nb_pions[n]] = 'x'; //ou 'o' (pour le type de pion)
       tab_nb_pions[n]++;
    }
    Sinon y a beaucoup de code dupliqué que tu pourrais mettre dans les fonctions. Et met ton test de 4 pions alignés dans une fonction, tu en auras à nouveau besoin plus tard.

    Après je sais pas pourquoi tu mets plusieurs fois le le haut des colonnes à abcdef, il n'y a pas de raison qu'elles se vident entre temps. De toute façon tes noms de colonne il vaut mieux que tu les écrivent en printf et pas dans le tableau de la grille, sinon tu vas t'embrouiller entre les lettres et les pions.

  8. #8
    Invité
    Invité(e)
    Par défaut
    Merci pour vos réponce.
    Pour les fonction c'est ça le problème c'est que nous n'en avons toujours pas vu en cours donc je ne peut pas en utiliser.

    Encore merci pour votre intervention que j'ai pri en compte pour faire des modification dans la parti 2 joueurs. Il me reste la parti 1 joueur.

    J'ai un problème au niveau de l'intéligence artificiel.
    -1er problème: Au début vu qu'en cours nous n'avons pas vu de fonction je voulais juste faire avec random mais bon c'est pas très serieux donc au final j'ai éssayé de compléter par des boucles.
    -2eme problème: pour le jeux en générale j'ai éssayé de permettre au joueur de refaire une parti mais on peut pas dire que ça marche bien
    -bonus : je voulé savoir si il y a un moyen simple de rendre plu agréable le jeux en changant le fond ou le texte (exemple couleur vert matrix )

    Merci pour l'aide.
    (jaffiche le code source 1 player dans un autre champ).

  9. #9
    Invité
    Invité(e)
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    /*Début du programme principal*/
    int main()
    {                               /*Déclaration des variables*/
        char tab[8][6];
        int i,j,C1,C2,L1,L2,L3,L4,L5,L6,gagn1,gagn2,alea;
        char jeux='Y';
        char choix=0;
        printf("\t\t--------------------------------------------------\n");
        printf("\t\t--------------------------------------------------\n");
        printf("\t\t--\tBienvenue au puissance 4 de Ziad\t--\n");
        printf("\t\t--------------------------------------------------\n");
        printf("\t\t--------------------------------------------------\n\n\n\n\n");
        printf("\t\tVeuillez choisir un mode de jeux entre:\n\n");
        printf("\t\t\t* Deux joueurs: Joueur 1 Vs Joueur 2 -> 1\n");
        printf("\n\t\t\t* Un joueur: Joueur 1 Vs Ordi --------> 2\n");
        choix=getchar();
        switch(choix)
        {
            case '2'
            {
                do
                {                                       /*initialisation de variables*/
                    gagn1=gagn2=L1=L2=L3=L4=L5=L6=alea=0;
                    system("cls");
                    char J[20];                         /*Saisie du nom du joueur*/
                    printf("Vous avez choisi de jouer a un joueurs");
                    printf("\nEntrez le nom du joueur: ");
                    scanf("%s",J);
                    printf("\nLe combat oppose %s Vs l'I.A.\n\n\n",J);
                    {           /*Initialisation du tableau toutes les cases affichent des espaces*/
                        printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                        printf("---------------------------------\n");
                        for(j=5;j>=0;j--)
                        {
                            for(i=0;i<8;i++)
                            {
                                tab[i][j]=' ';
                                tab[0][5]=tab[7][5]='f';
                                tab[0][4]=tab[7][4]='e';
                                tab[0][3]=tab[7][3]='d';
                                tab[0][2]=tab[7][2]='c';
                                tab[0][1]=tab[7][1]='b';
                                tab[0][0]=tab[7][0]='a';
                                printf("| %c ",tab[i][j]);      /*Affichage du plateau de jeu vide*/
                            }
                            printf("|\n");
                            printf("---------------------------------\n");
                        }
                        printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                    }
                    do
                    {                           /*Le joueur joue*/
                        do
                        {
                            printf("A vous de jouer %s, donner une lettre de ligne (de a à f) et un numero de colonne (de 1 à 6):\n",J);
                            scanf("%d",&C1);
                            /*Test sur la hauteur des colonnes, si elle sont remplies ou non*/
                            if((C1==1 && L1>5)|| (C1==2 && L2>5) || (C1==3 && L3>5) || (C1==4 && L4>5)  || (C1==5 && L5>5) || (C1==6 && L6>5))
                            {
                                printf("\nDesole %s mais, la colonne %d est pleine, veuillez donner un autre numero de colone\n",J,C1);
                                C1=-1;
                            }
                        }
                        while((C1<1 || C1>6) && (gagn1!=1  && gagn2!=1));
                        /*Donne le caractère X à la case jouée par le joueur*/
                        {
                            if(C1==1)
                                tab[C1][L1]='X';
                            if(C1==2)
                                tab[C1][L2]='X';
                            if(C1==3)
                                tab[C1][L3]='X';
                            if(C1==4)
                                tab[C1][L4]='X';
                            if(C1==5)
                                tab[C1][L5]='X';
                            if(C1==6)
                                tab[C1][L6]='X';
                        }
                        /*Affichage de la grille*/
                        system("cls");
                        printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                        printf("---------------------------------\n");
                        for(j=5;j>=0;j--)
                        {
                            for(i=0;i<8;i++)
                                printf("| %c ",tab[i][j]);//Affichage du plateau de jeu vide
                            printf("|\n");
                            printf("---------------------------------\n");
                        }
                        printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                        /*Vérification horizontale pour savoir si le joueur a gagné:
                            on balaye toutes les lignes en vérifiant 4 cases à chaque fois
                            Si 4 cases qui se suivent sont à X alors gagn1 prend pour valeur 1*/
                        for(i=1;i<4;i++)
                        {
                            for(j=0;j<6;j++)
                            {
                                if(tab[i][j]=='X' && tab[i+1][j]=='X' && tab[i+2][j]=='X' && tab[i+3][j]=='X')
                                {
                                    printf("Le gagnant est %s!!!\n",J);
                                    gagn1=1;
                                }
                            }
                        }
                        /*Même chose mais verticalement maintenant*/
                        for(i=1;i<7;i++)
                        {
                            for(j=0;j<3;j++)
                            {
                                if(tab[i][j]=='X' && tab[i][j+1]=='X' && tab[i][j+2]=='X' && tab[i][j+3]=='X')
                                {
                                    printf("Le gagnant est %s!!!\n",J);
                                    gagn1=1;
                                }
                            }
                        }
                        /*Et diagonale bas gauche vers haut droit*/
                        for(i=1;i<4;i++)
                        {
                            for(j=0;j<3;j++)
                            {
                                if(tab[i][j]=='X' && tab[i+1][j+1]=='X' && tab[i+2][j+2]=='X' && tab[i+3][j+3]=='X')
                                {
                                    printf("Le gagnant est %s!!!\n",J);
                                    gagn1=1;
                                }
                            }
                        }
                        /*Même chose pour les diagonales bas droite vers haut gauche*/
                        for(j=0;j<3;j++)
                        {
                            for(i=6;i>3;i--)
                            {
                                if(tab[i][j]=='X' && tab[i-1][j+1]=='X' && tab[i-2][j+2]=='X' && tab[i-3][j+3]=='X')
                                {
                                    printf("Le gagnant est %s!!!\n",J);
                                    gagn1=1;
                                }
                            }
                        }
                        /*On incremente la hauteur d'une colonne à chaque fois que celle si est jouée:*/
                        if(C1==1)
                            tab[C1][L1++];
                        else if(C1==2)
                            tab[C1][L2++];
                        else if(C1==3)
                            tab[C1][L3++];
                        else if(C1==4)
                            tab[C1][L4++];
                        else if(C1==5)
                            tab[C1][L5++];
                        else if(C1==6)
                            tab[C1][L6++];
                        /*On recommence pour l'ordi*/
                        /*L'I.A. joue*/
                        do
                        {
                            do
                            {
                                printf("A L'I.A. de jouer\n");
                                srand(time(NULL));/*initialisation des générateur*/
                                do
                                {
                                    for(i=1;i<4;i++)
                                    {
                                        for(j=0;j<6;j++)
                                        {
                                            if(tab[i][j]=='X' && tab[i+1][j]=='X' && tab[i+2][j]=='X')
                                                tab[i+3][j]=='O';
                                            else if(tab[i+1][j]=='X' && tab[i+2][j]=='X' && tab[i+3][j]=='X')
                                                tab[i][j]=='O';
                                            else
                                            {
                                                C2=rand()%7;/*génération et affichage d'un nombre*/
                                                alea++;
                                            }
                                        }
                                    }
                                    /*Même chose mais verticalement maintenant*/
                                    for(i=1;i<7;i++)
                                    {
                                        for(j=0;j<3;j++)
                                        {
                                            if(tab[i][j]=='X' && tab[i][j+1]=='X' && tab[i][j+2]=='X')
                                                tab[i][j+3]=='O';
                                            else if(tab[i][j+1]=='X' && tab[i][j+2]=='X' && tab[i][j+3]=='X')
                                                tab[i][j]=='O';
                                            else
                                            {
                                                C2=rand()%7;//génération et affichage d'un nombre
                                                alea++;
                                            }
                                        }
                                    }
                                    /*Et diagonale bas gauche vers haut droit*/
                                    for(i=1;i<4;i++)
                                    {
                                        for(j=0;j<3;j++)
                                        {
                                            if(tab[i][j]=='X' && tab[i+1][j+1]=='X' && tab[i+2][j+2]=='X')
                                                tab[i+3][j+3]=='O';
                                            else if(tab[i+1][j+1]=='X' && tab[i+2][j+2]=='X' && tab[i+3][j+3]=='X')
                                                tab[i][j]=='O';
                                            else
                                            {
                                                C2=rand()%7;//génération et affichage d'un nombre
                                                alea++;
                                            }
                                        }
                                    }
                                    /*Même chose pour les diagonales bas droite vers haut gauche*/
                                    for(j=0;j<3;j++)
                                    {
                                        for(i=6;i>3;i--)
                                        {
                                            if(tab[i][j]=='X' && tab[i-1][j+1]=='X' && tab[i-2][j+2]=='X')
                                                tab[i-3][j+3]=='O';
                                            else if(tab[i-1][j+1]=='X' && tab[i-2][j+2]=='X' && tab[i-3][j+3]=='X')
                                                tab[i][j]=='O';
                                            else
                                            {
                                                C2=rand()%7;//génération et affichage d'un nombre
                                                alea++;
                                            }
                                        }
                                    }
                                }
                                while(gagn1!=1 && gagn2!=1);
                                /*Test sur la hauteur des colonnes, si elle sont remplies ou non*/
                                if((C2==1 && L1>5)|| (C2==2 && L2>5) || (C2==3 && L3>5) || (C2==4 && L4>5)  || (C2==5 && L5>5) || (C2==6 && L6>5))
                                    C2=-1;
                            }
                            while((C2<1 || C2>6));
                        }
                        while(gagn1!=1  && gagn2!=1);
                        /*Donne le caractère O à la case jouée par l'I.A.*/
                        {
                            if(C2==1)
                                tab[C2][L1]='O';
                            else if(C2==2)
                                tab[C2][L2]='O';
                            else if(C2==3)
                                tab[C2][L3]='O';
                            else if(C2==4)
                                tab[C2][L4]='O';
                            else if(C2==5)
                                tab[C2][L5]='O';
                            else if(C2==6)
                                tab[C2][L6]='O';
                        }
                        /*Affichage de la grille*/
                        system("cls");
                        printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n");
                        printf("---------------------------------\n");
                        for(j=5;j>=0;j--)
                        {
                            for(i=0;i<8;i++)
                                printf("| %c ",tab[i][j]);          /*Affichage du plateau de jeu*/
                            printf("|\n");
                            printf("---------------------------------\n");
                        }
                        printf("|   | 1 | 2 | 3 | 4 | 5 | 6 |   |\n\n");
                        printf("L'ordi a joué en %d\n\n",C2);
                        /*Vérification horizontale pour savoir si le joueur a gagné:
                            on balaye toutes les lignes de 0 à 5 en vérifiant 4 cases à chaque fois
                            Si 4 cases qui se suivent sont à X alors gagn2 prend pour valeur 1*/
                        for(i=1;i<4;i++)
                        {
                            for(j=0;j<6;j++)
                            {
                                if(tab[i][j]=='O' && tab[i+1][j]=='O' && tab[i+2][j]=='O' && tab[i+3][j]=='O')
                                {
                                    printf("Le gagnant est l'I.A.!!!\n");
                                    gagn2=1;
                                }
                            }
                        }
                        /*Même chose mais verticalement maintenant*/
                        for(i=1;i<7;i++)
                        {
                            for(j=0;j<3;j++)
                            {
                                if(tab[i][j]=='O' && tab[i][j+1]=='O' && tab[i][j+2]=='O' && tab[i][j+3]=='O')
                                {
                                    printf("Le gagnant est l'I.A.!!!\n");
                                    gagn2=1;
                                }
                            }
                        }
                        /*Et diagonale bas gauche vers haut droit*/
                        for(i=1;i<4;i++)
                        {
                            for(j=0;j<3;j++)
                            {
                                if(tab[i][j]=='O' && tab[i+1][j+1]=='O' && tab[i+2][j+2]=='O' && tab[i+3][j+3]=='O')
                                {
                                    printf("Le gagnant est l'I.A.!!!\n");
                                    gagn2=1;
                                }
                            }
                        }
                        /*Même chose pour les diagonales bas droite vers haut gauche*/
                        for(j=0;j<3;j++)
                        {
                            for(i=6;i>3;i--)
                            {
                                if(tab[i][j]=='O' && tab[i-1][j+1]=='O' && tab[i-2][j+2]=='O' && tab[i-3][j+3]=='O')
                                {
                                    printf("Le gagnant est l'I.A.!!!\n");
                                    gagn2=1;
                                }
                            }
                        }
                        /*On incremente la hauteur d'une colonne à chaque fois que celle si est jouée:*/
                        if(C2==1)
                            tab[C2][L1++];
                        else if(C2==2)
                            tab[C1][L2++];
                        else if(C2==3)
                            tab[C2][L3++];
                        else if(C2==4)
                            tab[C2][L4++];
                        else if(C2==5)
                            tab[C2][L5++];
                        else if(C2==6)
                            tab[C2][L6++];
                    }
                    while(gagn1!=1 && gagn2!=1);
                    printf("voulez vous refaire une partie ? ('Y' ou 'N'):\n");
                    scanf("%c",&jeux);
                }
                while(jeux=='Y');
                break;
            }
            default : printf("Erreur de saisie du choix!");
        }
    return 0;
    }

  10. #10
    Invité
    Invité(e)
    Par défaut
    -2eme problème: pour le jeux en générale j'ai éssayé de permettre au joueur de refaire une parti mais on peut pas dire que ça marche bien
    C'est encore une question de boucle, qui englobe tout le reste. Mais si tu ne fais pas trop de fonctions, ça va alourdir le code pour une fonctionnalité qui n'est pas très importante.

Discussions similaires

  1. Problème puissance de nombre négatif
    Par Bob_Tom dans le forum Fortran
    Réponses: 8
    Dernier message: 14/12/2012, 12h13
  2. [ZF 1.8] Problème cours "Donnez de la puissance à vos modèles"
    Par pofexpray dans le forum MVC
    Réponses: 1
    Dernier message: 16/06/2009, 11h06
  3. Problème avec les puissances
    Par Hoopsy dans le forum C++Builder
    Réponses: 8
    Dernier message: 25/06/2007, 23h40
  4. Problème avec la fonction pow(les puissance)
    Par Clément76 dans le forum C
    Réponses: 10
    Dernier message: 04/10/2006, 12h44
  5. 8x11=0 !! problème fonction puissance
    Par Renesis57 dans le forum C
    Réponses: 18
    Dernier message: 26/11/2005, 14h54

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo