Cuestión 803

Cuestión 803
Mastermind es un juego de mesa, de ingenio y reflexión, para dos jugadores.
Hay una serie de fichas de colores, un jugador (la banca) escoge una combinación de 4 colores
(que se pueden repetir) y el otro jugador tiene que adivinar dicha combinación. Para ello prueba
una combinación y la banca le responde con unas fichas blancas y negras, tantas negras
como fichas de color bien colocadas y tantas blancas como fichas de color mal colocadas.
Termina al averiguarse la combinación (es decir, se consigue una combinación con cuatro
negras), o bien se agota el tablero (depende del tamaño, aunque generalmente son 15
combinaciones).
Vamos a realizar un programa que simule el juego de la banca (el jugador que escoge 4
colores y los oculta). Los colores vamos a simularlas con números, la banca sacará N números
(en ppio 4) entre 1 y M (que será en ppio 6). O sea, que escogemos 4 fichas y cada una puede
adoptar uno de 6 colores. El jugador tiene que intentar adivinar la combinación secreta para
ello prueba una combinación en la banca responderá con una cadena de caracteres con tantas
'n' como números bien colocados y tantas 'b' como números que existen pero no están bien
colocados.
El juego termina cuando algún jugador averigua la combinación oculta de la banca, es decir, se
consigue una combinación con cuatro negras, o bien se agota el tablero , dependiendo esto del
tamaño, limitándose generalmente a 15 combinaciones.
Para la implementación de este juego se definen las siguientes estructuras:
struct jugada
{
int colores[N];
int num;
char banca[N+1];
banca
struct jugada * sig;
};
// almacena la jugada
// turno
// cadena de caracteres con respuesta de la
// puntero al siguiente elemento;
typedef struct jugada NODO;
Como se puede observar, cada una de las jugadas se va almacenando en una lista enlazada.
Se pide:
Programar la función compara_solucion que que recibe como parámetros 2 vectores de N
números, uno con la combinación del jugador (jugada) y otro con la combinación solución de la
banca (real). La función debe devolver por parámetro una cadena de caracteres de tamaño
N+1 con tantos caracteres ’n’ como números bien colocados y tantos caracteres ’b’ como
números que existen pero no están bien colocados. La cadena de caracteres debe contener el
carácter fin de cadena ‘\0’ .El prototipo de esta función es:
void compara_solucion(int jugada[N], int real[N], char nota[N+1]);
Para probar esta función puede disponer del siguiente código.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 4 //Numero de numeros a adivinar.
#define M 6 //Numero de valores q pueden tomar los numeros.
1
void compara_solucion(int jugada[N], int real[N], char nota[N+1]);
void main(void)
{
int i,j;
int real[N]={1,3,3,5};
int jugadas[4][N]={{3,3,3,3},{6,5,4,3},{4,3,2,3},{1,3,6,3}};
char nota[N+1];
for(j=0;j<4;j++)
{
printf("solucion: ");
for(i=0;i<N;i++)
{
printf("%d",real[i]);
}
printf(" jugada: ");
for(i=0;i<N;i++)
{
printf("%d",jugadas[j][i]);
}
compara_solucion(jugadas[j],real,nota);
printf(" Respuesta: %s\n",nota);
}
}
void compara_solucion(int jugada[N], int real[N], char nota[N+1])
{
/************************INICIO CODIGO ALUMNO************************/
/************************ FIN CODIGO ALUMNO*************************/
}
La solución debe ser:
REAL
JUGADA
RESPUESTA
1335
1335
1335
1335
3333
6543
4323
1363
nn
bb
nb
nnb
COMENTARIOS
Los elementos bien colocados no cuentan para ver los descolocados
El 3 solo esta descolocado 1 vez
2
JUEGO COMPLETO MASTER MIND
Una vez acabas las tres funciones de este ejercicio, puede incluir el código de las funciones
para poder jugar al juego master mind. En la ejecución se genera un fichero llamado
“mastermind.txt” donde podrá ver sus jugadas y cuantos pasos ha necesitado para averiguar la
combinación secreta de la banca.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 4 //Numero de numeros a adivinar.
#define M 6 //Numero de valores q pueden tomar los numeros.
struct jugada
{
int colores[N]; // almacena la jugada
int num; // turno
char banca[N+1]; // cadena de caracteres con la respuesta de la banca
struct jugada * sig; // puntero al siguiente elemento;
};
typedef struct jugada NODO;
void
void
NODO
NODO
compara_solucion(int jugada[N], int real[N], char nota[N+1]);
imprime_jugadas(NODO *);
* inserta_final(NODO * raiz, NODO * nuevo);
* reserva_jugada(void);
void main(void)
{
int i,fin=1,cont=0;
int aux,auxj=1;
char jugada[N+1];
char nota[N+1];
int real[N];
NODO * top=NULL, *nuevo;
// generamos al azar combinaci\’{o}n de "colores" a adivinar
for(i=0;i<N;i++)
{
srand(i+time(NULL));
real[i]=1+rand() % M;
//printf("%d ",real[i]);
}
printf("\n");
while(fin)
{
nuevo=reserva_jugada();
nuevo->num=cont+1;
auxj=1;
while(auxj) // Por si los numeros introducidos no son validos
{
printf("Introduzca jugada:\n");
scanf("%s",jugada); //guardamos jugada como cadena de carateres
auxj=0; //suponemos numeros correctos
for(i=0;i<N;i++) //convertimos cadena jugada de caracteres
// a cadena de numeros y comprobamos que son v\’{a}lidos
3
{
aux=jugada[i]-48;
if(aux<1 || aux>M) // Si algun numero no es correcto
//volvemos a pedir
{
printf("Jugada erronea, vuelva a
introducirla\n");
auxj=1;
i=N;
}
else
{
nuevo->colores[i]=aux;
}
} //end for
} //end (while(auxj))
// Vemos El resultado de nuestra jugada:
compara_solucion(nuevo->colores,real,nuevo->banca);
printf("La respuesta de la banca es %s\n",nuevo->banca);
nuevo->num=++cont;
fin=0;
for(i=0;i<N;i++)
{
if(nuevo->banca[i]!=’n’)
{
fin=1;
}
}
top=inserta_final(top,nuevo);
} //end while (fin)
printf("\n\nGANASTE !!!\n");
imprime_jugadas(top);
system("pause");
}
NODO * reserva_jugada(void)
{
NODO *nuevo;
nuevo=(NODO*)malloc(sizeof(NODO));
if(nuevo==NULL)
{
printf("Error en reserva dinamica de memoria\n");
exit(1);
}
nuevo->sig=NULL;
return nuevo;
}
4