Sujet Précédent Sujet Suivant

Faite svp ce puissance 4 un peu spécial il est super compliké pr moi ki est novi

Résolu
cs_qsdfgh Messages postés 29 Date d'inscription jeudi 19 décembre 2002 Statut Membre Dernière intervention 30 mars 2006 - 1 déc. 2005 à 13:14
ymca2003 Messages postés 2070 Date d'inscription mardi 22 avril 2003 Statut Membre Dernière intervention 3 juillet 2006 - 5 déc. 2005 à 13:06
Soit une matrice 7×7 d’entiers, initialisée à 0. On vous demande de gérer un jeu de puissance 4 dans

cette matrice : à tour de rôle, les joueurs entrent un numéro de colonne entre 1 et 7, et un pion (symbolisé

par le numéro du joueur) est placé à la dernière position libre, i.e. celle d’indice le plus élevé, de la colonne

choisie (si cette colonne est déjà remplie, un message d’erreur doit signaler au joueur qu’un autre numéro

est attendu). Le jeu s’achève quand un joueur aligne 4 pions portant son numéro, ou quand la grille est

complètement remplie.

Votre programme doit d’une part gérer la partie, et d’autre part gérer l’intelligence artificielle d’un des

joueurs au moyen des règles suivantes :

– si un coup lui assure la victoire, ce coup (coup gagnant) est effectué :

1 0 0 0 0 0 0 0

2 0 0 0 0 0 0 0

3 0 0 0 0 0 0 0

4 0 0 0 0 0 0 0

5 0 0 0 0 0 0 0

6 1 0 0 2 2 2 0

7 1 2 1 2 1 1 1

1 2 3 4 5 6 7

dans ce cas, l’ordinateur (joueur 2) placera son pion dans la colonne d’indice 3, ce coup le faisant

gagner ;

– si un coup donne à l’adversaire un coup gagnant, ce coup (coup perdant) n’est pas effectué, dans la

mesure du possible :

1 0 0 0 0 0 0 0

2 0 0 0 0 0 0 0

3 0 0 0 0 0 0 0

4 0 0 0 0 0 0 0

5 0 0 0 0 0 0 0

6 0 0 0 1 1 1 0

7 2 1 0 2 1 2 2

1 2 3 4 5 6 7

dans ce cas, l’ordinateur (joueur 2) ne placera pas son pion en colonne 3, puisque ce coup permettrait

au joueur 1 de gagner (en plaçant son pion en colonne 3) ;

– si un coup oblige l’adversaire à jouer un coup perdant, ce coup est effectué.

1 0 0 0 0 0 0 0

2 0 0 0 0 0 0 0

3 0 0 0 0 0 0 0

4 0 0 0 0 0 0 0

5 0 0 0 0 0 0 0

6 0 0 0 2 2 0 0

7 1 1 2 1 1 2 1

1 2 3 4 5 6 7
1

dans ce cas, l’odinateur (joueur 2) placera son pion en colonne 3 puisque, quel que soit le coup

suivant du joueur 1, ce coup sera perdant.

Si ces règles n’ont pas permis à l’ordinateur de déterminer un coup à jouer, celui-ci devra le tirer au sort

parmi les coups possibles (voir ci-dessous pour la génération de nombres aléatoires). Nous vous conseillons

d’écrire une fonction pour chacune de ces règles, et à minimiser la duplication de code. Vous pouvez utiliser

des vecteurs de travail, à condition de justifier leur utilité de façon convaincante.

Nombres aléatoires La génération de nombres aléatoires en C++ peut se faire au moyen de la fonction

int rand() qui renvoie un entier aléatoire compris entre 0 et RAND_MAX (une constante définie dans le

fichier stdlib.h que vous devez inclure au début de votre programme). Pour que rand() donne des

résultats plus réalistes, il convient d’initialiser la suite des nombres aléatoires en début de programme, au

moyen de la fonction void srand(int), à laquelle on fournit un entier arbitraire. Cet entier arbitraire est

en général extrait de l’horloge de la machine en appelant srand(time(NULL)) par exemple (pour ce faire,

vous devez aussi inclure time.h). Voici un exemple de programme qui affiche un nombre compris en 1 et

10 inclus.

#include

#include <stdlib.h>

#include <time.h>

using namespace std ;

int main ()

{

int j ;

/* initialisation des nombres aléatoires */

srand ( time(NULL) ) ;

/* On fait appel à rand, puis on normalise le résultat

pour obtenir un nombre dans [1,..., 10] */

j = 1 + (int) (10.0 * (rand() / (RAND_MAX + 1.0))) ;

cout<< j ;

}

merci d'avance,

3 réponses

Réponse 1 / 3
ymca2003 Messages postés 2070 Date d'inscription mardi 22 avril 2003 Statut Membre Dernière intervention 3 juillet 2006 7
5 déc. 2005 à 13:06
Have fun...

/****************************************************************************************
*
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>


/*=======================================================================================
*
*/
#define CX 7
#define CY 6
#define CONNECT 4
#define PLAYER1 1
#define PLAYER2 2
#define HUMAN 1
#define CPU 2


/*=======================================================================================
*
*/
#define OTHER_PLAYER(player) ((player == PLAYER1) ? PLAYER2 : PLAYER1)


/*=======================================================================================
*
*/
typedef struct GRID_TAG
{
int matrix[CX][CY];
int columns[CX];
int count;
}GRID;


/*=======================================================================================
*
*/
typedef int (*PFN_IA)(const GRID*, int);


/*=======================================================================================
*
*/
int get_winner(const GRID* grid);
int can_play(const GRID* grid, int x);
void play(GRID* grid, int x, int player);
int ia1(const GRID* grid, int player);
int ia2(const GRID* grid, int player);
int ia3(const GRID* grid, int player);
int get_player(int player);
int get_choice(const GRID* grid, int player, int type);
void display_grid(const GRID* grid);


/****************************************************************************************
*
*/
int get_winner(const GRID* grid)
{ int x 0, y 0, cx = 0, cy = 0, xn = 0, yn = 0; int i 0, j 0, score = 0, winner = 0;
int dep[4][2] = {{1, 0}, {0, 1}, {1, 1}, {1, -1}}; int ok 0, player 0;


for(i = 0; i < 4; i++)
{
cx = dep[i][0];
cy = dep[i][1];


for(x 0; winner 0 && x < CX; x++)
{ for(y 0; winner 0 && y < CY; y++)
{
ok = 1;
score = 0;
player = grid->matrix[x][y];
for(j = 0; ok && player != 0 && j < CONNECT; j++)
{
xn = x+cx*j;
yn = y+cy*j;
ok = (xn >= 0 && xn < CX && yn >= 0 && yn < CY); ok ok && (grid->matrix[xn][yn] player);
if(ok)
score += grid->matrix[xn][yn];
}


if(ok && player !0 && score CONNECT*player)
winner = player;
}
}
}

return winner;
}


/****************************************************************************************
*
*/
int can_play(const GRID* grid, int x)
{
return (grid->columns[x] < CY);
}


/****************************************************************************************
*
*/
void play(GRID* grid, int x, int player)
{
grid->matrix[x][grid->columns[x]++] = player;
grid->count++;
}


/****************************************************************************************
*
*/
int is_full(const GRID* grid)
{
return (grid->count == CX*CY);
}


/****************************************************************************************
*
*/
int ia1(const GRID* grid, int player)
{
GRID testgrid = {0}; int x 0, choice -1;


for(x 0; choice -1 && x < CX; x++)
{
memcpy(&testgrid, grid, sizeof(GRID));
if(can_play(&testgrid, x))
{
play(&testgrid, x, player);
if(get_winner(&testgrid) == player)
choice = x;
}
}


return choice;
}


/****************************************************************************************
*
*/
int ia2(const GRID* grid, int player)
{
GRID testgrid = {0}; int xother 0, choice -1;


for(xother 0; choice -1 && xother < CX; xother++)
{
memcpy(&testgrid, grid, sizeof(GRID));
if(can_play(&testgrid, xother))
{
play(&testgrid, xother, OTHER_PLAYER(player));
if(get_winner(&testgrid) == OTHER_PLAYER(player))
choice = xother;
}
}


return choice;
}


/****************************************************************************************
*
*/
int ia3(const GRID* grid, int player)
{
GRID testgrid = {0};
GRID testgrid2 = {0}; int x 0, xother 0, choice = -1;


for(x 0; choice -1 && x < CX; x++)
{
memcpy(&testgrid, grid, sizeof(GRID));
if(can_play(&testgrid, x))
{
play(&testgrid, x, player);
choice = x; for(xother 0; choice x && xother < CX; xother++)
{
memcpy(&testgrid2, &testgrid, sizeof(GRID));
if(can_play(&testgrid2, xother))
{
play(&testgrid2, xother, OTHER_PLAYER(player));
if(ia1(&testgrid2, player) != player)
choice = -1;
}
}
}
}


return choice;
}


/****************************************************************************************
*
*/
int get_player(int player)
{
int type = 0;
do
{
printf("Player %d (%d : Human, %d : CPU) : ", player, HUMAN, CPU);
scanf("%d", &type);
}while(type != HUMAN && type != CPU);
return type;
}


/****************************************************************************************
*
*/
int get_choice(const GRID* grid, int player, int type)
{ int choice 0, i 0;
PFN_IA ia[3] = {&ia1, &ia2, &ia3};


if(type == HUMAN)
{
do
{
printf("Player %d (%c) : ", player, (player == PLAYER1) ? 'X' : 'O');
scanf("%d", &choice);
choice--;
}while(choice < 0 || choice >= CX || !can_play(grid, choice));
}
else
{
choice = -1; for(i 0; choice -1 && i < 3; i++)
choice = (*ia[i])(grid, player);

if(choice == -1)
{
do
{
choice = rand()%CX;
}while(!can_play(grid, choice));
}
}


return choice;
}


/****************************************************************************************
*
*/
void display_grid(const GRID* grid)
{ int x 0, y 0;


printf("\n");
for(x = 0; x < CX; x++)
printf(" %2d ", x+1);
printf("\n");


for(y = CY-1; y >= 0; y--)
{
for(x = 0; x < CX; x++)
printf("----");
printf("-\n");
for(x = 0; x < CX; x++)
{
switch(grid->matrix[x][y])
{
case PLAYER1 : printf("| X "); break;
case PLAYER2 : printf("| O "); break;
default : printf("| "); break;
}
}
printf("|\n");
}


for(x = 0; x < CX; x++)
printf("----");
printf("-\n");
}


/****************************************************************************************
*
*/
int main()
{
int players[2] = {0, 0};
GRID grid = {0}; int stop 0, currentplayer 0, currenttype = 0, winner = 0, choice = 0;
char c = 0;


srand(time(NULL));
do
{
printf("\n\nPuissance %d\n\n", CONNECT);
players[0] = get_player(PLAYER1);
players[1] = get_player(PLAYER2);


memset(&grid, 0, sizeof(GRID)); currentplayer (rand()%2 0) ? PLAYER1 : PLAYER2;
do
{
display_grid(&grid); currenttype ((currentplayer PLAYER1) ? players[0] : players[1]);
choice = get_choice(&grid, currentplayer, currenttype);
play(&grid, choice, currentplayer);
winner = get_winner(&grid);
currentplayer = OTHER_PLAYER(currentplayer);
}while(winner == 0 && !is_full(&grid));


display_grid(&grid);
if(winner == 0)
printf("Nobody won\n");
else
printf("Player %d won\n", winner);


printf("Continue (Y/N) ? ");
fflush(stdin);
scanf("%c", &c);
stop = (c != 'Y' && c != 'y');
}while(!stop);


return 0;
}
3
Réponse 2 / 3
MrdJack Messages postés 146 Date d'inscription jeudi 22 avril 2004 Statut Membre Dernière intervention 8 mars 2008 2
1 déc. 2005 à 15:05
c'est super simple, tu vas dans google, tu tapes cours c/c++ et tu potasses un peu les bases.

car ce cahier des charges n'est pas bien dur a réaliser si on connais les petites bases du c/c++.

il n'y a que des conditions ( if(...) { }//au cas où tu
n'en serais pas encore là), un tableau et pour finir, des boucles . le
reste n'est pas sorcier non plus, quelques variables et voilà.



pour finir, rien n'est impossible en c/c++. donc si tu trouves que
c'est compliqué, heureusement que tu ne t'attaques pas a un jeu
d'echec..... sinon je vois le carnage sur le forum... (SVP:FAITES MOI
UN ALGO D'UN JEU D'ECHEC AVEC IA)


pour info, l'IA que tu veux implementer dans ton puissance 4 n'est
pas tres evolué, en gros c'est juste une suite de conditions, je te
conseille meme d'utiliser la récursivité situ souhaite faire une
analyse sur plusieurs tours (comme ca ton ia n'est pas trop bete...)



voila, ptete que tu auras plus de chance avec quelqu'un d'autre, mais ca ne serait pas la meilleure solution pour toi.



@++
0
Réponse 3 / 3
cs_qsdfgh Messages postés 29 Date d'inscription jeudi 19 décembre 2002 Statut Membre Dernière intervention 30 mars 2006
2 déc. 2005 à 11:01
tricheur



















MASSART
0

Discussions similaires

[C#] Puissance en C#
Phenomenium -
LeNarvallo -

6 réponses
Eléver un nombre à la puissance
boninou -
leprov -

3 réponses
les puissances
T103 -
ricklekebekoi -

4 réponses
fonction puissance
abbeilleee -
abbeilleee -

5 réponses
Math.Pow je comprend pas :S
cs_floc95 -
floc95 -

3 réponses
Rejoignez-nous