Foros aprenderaprogramar.com
Aprender a programar => C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más => Mensaje iniciado por: rackdon en 24 de Junio 2014, 00:02
-
Buenas noches.
He hecho un ejercicio en C que me pedía comparar entre 2 manos de cartas de poker y decidir cual era mejor.
Pensaba que estaba todo bien, pero al ejecutar nunca llega a mostrar quien tiene mejor mano. En teoría no tendría por qué haber ningún error pero está visto que sí que lo hay.
Agradecería cualquier ayuda por pequeña que sea, y pido un poco de paciencia ya que son 400 líneas de código....
P.d. En principio hice el programa para un número indeterminado de jugadores, pero como tenía que poner un número de jugadores para el arreglo resultados, al final lo hice solo para 2 jugadores, a pesar de que pida el número de jugadores al principio, siempre pongo el valor 2
Muchisimas gracias.
Un saludo
/*Ejercicio 7.13: Determinar cual es la mejor mano de poker */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* prototipos */
void baraja( int wMazo[][ 13 ] );
void reparte( const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], int carta_inicial, int carta_final );
void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], const char *combinacion_simple[], const char *combinacion_doble[], int carta_inicial, int carta_final,int resultados[][9] , int jugador );
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble);
void determina_ganador(int resultados[][9],int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *wCara[]);
int main()
{
/* inicializa el arreglo palo */
const char *palo[ 4 ] = { "Corazones", "Diamantes", "Treboles", "Espadas" };
/* inicializa el arreglo cara */
const char *cara[ 13 ] =
{ "As", "Dos", "Tres", "Cuatro",
"Cinco", "Seis", "Siete", "Ocho",
"Nueve", "Diez", "Jota", "Dama", "Rey" };
const char *combinacion_simple[7] = {"carta mas alta", "pareja", "trio", "poker","escalera", "color", "escalera de color" };
const char *combinacion_doble[3] = {"carta mas alta", "doble pareja","full"};
/* inicializa el arreglo mazo */
int mazo[ 4 ][ 13 ] = { 0 };
int jugadores, jugador;
srand( time( 0 ) ); /* semilla del generador de números aleatorios */
baraja( mazo );
printf("Por favor introduzca el número de jugadores: ");
scanf("%d", &jugadores);
int resultados[2][9] = {0};// arreglo que guarda los resultados //
for (jugador = 0; jugador < jugadores; jugador++)
{
printf("\n\nJugador %d\n\n", jugador + 1);
reparte( mazo, cara, palo,1 + (jugador * 5),5 + (jugador * 5) );
combinacion_mano(mazo,cara,palo,combinacion_simple, combinacion_doble,1 + (jugador * 5),5 + (jugador * 5), resultados, jugador );
}
printf("\npor aquí\n");
determina_ganador(resultados, jugadores, combinacion_simple, combinacion_doble,cara);
return 0; /* indica terminación exitosa */
} /* fin de main */
/* baraja las cartas del mazo */
void baraja( int wMazo[][ 13 ] )
{
int fila; /* número de fila */
int columna; /* número de columna */
int carta; /* contador */
/* elige aleatoriamente un espacio para cada una de las 52 cartas */
for ( carta = 1; carta <= 52; carta++ ) {
/* elije una nueva ubicación al azar hasta que encuentra un espacio vacío */
do {
fila = rand() % 4;
columna = rand() % 13;
} while( wMazo[ fila ][ columna ] != 0 ); /* fin de do...while */
/* coloca el número de carta en el espacio vacío del mazo */
wMazo[ fila ][ columna ] = carta;
} /* fin de for */
} /* fin de la función baraja */
/* reparte las cartas del mazo */
void reparte( const int wMazo[][ 13 ], const char *wCara[],
const char *wPalo[],int carta_inicial, int carta_final )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* si el espacio contiene la carta actual, despliega la carta */
if ( wMazo[ fila ][ columna ] == carta ) {
printf( "%6s de %-9s%c", wCara[ columna ], wPalo[ fila ],
carta % 2 == 0 ? '\n' : '\t' );
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
} /* fin de la función reparte */
//Determina la combinacion de la mano //
void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[],
const char *combinacion_simple[], const char *combinacion_doble[],int carta_inicial, int carta_final,int resultados[][9],int jugador )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
int posicion_carta;// contador para el resto de cartas que se comparan en función de la actual //
int numero_cartabase; //numero de la carta actual //
int palo_cartabase; //palo de la carta actual //
int num_combinacion_simple = 0; //combinacion que hay en la mano //
int num_combinacion_doble = 0; // segunda combinación que hay en la mano //
int mano[5] = {0};
int color = 1; // contador para saber si tienes color en la mano //
int escalera = 1; // contador para saber si tienes escalera //
int numero_carta_simple;
int numero_carta_doble;
int carta_mas_alta = 0;
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* Determina si hay una combinacion en función de la carta actual */
if ( wMazo[ fila ][ columna ] == carta && mano[carta - carta_inicial ] == 0 )
{
numero_cartabase = columna;
palo_cartabase = fila;
if(carta == carta_inicial ) // determina si tienes color a partir de la primera carta //
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta && fila == palo_cartabase)
{
if (fila == palo_cartabase)
{
color++;
numero_carta_simple = numero_cartabase;
}
if(columna == numero_cartabase + carta)
{
escalera++;
numero_carta_simple = numero_cartabase;
}
}
}
}
}
} // fin carta == 1 //
if (color != 5)// si no hay color //
{
if(num_combinacion_simple == 0)
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if(carta_mas_alta < numero_cartabase)
{
carta_mas_alta = numero_cartabase;
}
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_simple++;
numero_carta_simple = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
}// fin if combinacion simple //
else // la combinacion es doble//
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_doble++;
numero_carta_doble = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
} // fin de else //
}// fin de if si no hay color //
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
if(escalera == 5) // establece la escalera //
{
num_combinacion_simple = 4;
}
if(color == 5) // Establece el color //
{
num_combinacion_simple = 5;
}
if(escalera == 5 && color == 5) // Establece la escalera de color //
{
num_combinacion_simple = 6;
}
if(num_combinacion_simple == 2 && num_combinacion_doble == 1) // establece la otra posibilidad de full//
{
num_combinacion_doble = 2;
}
if (num_combinacion_doble == 0)
{
printf("\n\nEn esta mano hay %s \n", combinacion_simple[num_combinacion_simple] );
}
else
{
printf("\n\nEn esta mano hay %s \n", combinacion_doble[num_combinacion_doble] );
}
if(num_combinacion_simple == 0)
{
numero_carta_simple = carta_mas_alta;
}
almacena_resultados(resultados, num_combinacion_simple, num_combinacion_doble, jugador, numero_carta_simple, numero_carta_doble);
} // fin de la funcion combinacion mano //
// funcion almacena resultados //
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble)
{
if ( num_combinacion_doble == 0)
{
switch (num_combinacion_simple) {
case 0: resultados[jugador][0] = numero_carta_simple;
return;
case 1: resultados[jugador][1] = numero_carta_simple;
return;
case 2: resultados[jugador][3] = numero_carta_simple;
return;
case 3: resultados[jugador][7] = numero_carta_simple;
return;
case 4: resultados[jugador][4] = numero_carta_simple;
return;
case 5: resultados[jugador][5] = numero_carta_simple;
return;
case 6: resultados[jugador][8] = numero_carta_simple;
return;
} // fin switch //
}// fin if //
else
{
switch (num_combinacion_doble) {
case 1: resultados[jugador][2] = numero_carta_doble;
return;
case 2: resultados[jugador][6] = numero_carta_doble;
return;
}//fin switch//
}// fin else//
}
// funcion determina_ganador //
void determina_ganador(int resultados[][9], int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[])
{
int jugador;
int mejor = -1;
int jugada = 9;
int jugador_ganador1;
int jugador_ganador2 = -1;
int mano_simple = -1;
int mano_doble = 0;
printf("\n\njugadores = %d\n\n", jugadores);
while (mejor == -1)
{
jugada--;
jugador = 0;
while(resultados[jugador][jugada] == -1 || jugador < jugadores)
{
jugador++;
}
if(resultados[jugador][jugada] != -1)
{
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
for(jugador; jugador <= jugadores; jugador++)
{
if(resultados[jugador][jugada] > mejor && mejor != 0 )
{
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
}
if(resultados[jugador][jugada] == mejor )
{
jugador_ganador2 = jugador;
}
}
}
}
switch (jugada) {
case 0: mano_simple = 0;
return;
case 1: mano_simple = 1;
return;
case 2: mano_doble = 1;
return;
case 3: mano_simple = 2;
return;
case 4: mano_simple = 4;
return;
case 5: mano_simple = 5;
return;
case 6: mano_doble = 2;
return;
case 7: mano_simple = 3;
return;
case 8: mano_simple = 6;
return;
}
if (jugador_ganador2 == -1) // si no hay empate //
{
if(mano_doble == 0)
{
if(mano_simple != 5) // si no hay color //
{
printf("\n\nHa ganado el jugador %d con %s de %d\n\n",jugador_ganador1 + 1, cara[mano_simple], mejor);
}
else //hay color//
{
printf("\n\nHa ganado el jugador %d con %s \n\n",jugador_ganador1 + 1, cara[mano_simple]);
}
}
else
{
printf("\n\nHa ganado el jugador %d con %s de %d\n\n",jugador_ganador1 + 1, cara[mano_doble], mejor);
}
}
else // hay empate //
{
if(mano_doble == 0)
{
if(mano_simple != 5) // si no hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %d\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple], mejor);
}
else //hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple]);
}
}
else
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %d\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_doble], mejor);
}
}
}
-
Pues sí 400 líneas de código son mucho código ¿Podrías explicar en unas cuantas líneas cómo has organizado el programa?
He ejecutado y he obtenido esto:
Por favor introduzca el número de jugadores: 2
Jugador 1
Seis de Treboles Dos de Treboles
Seis de Diamantes Jota de Treboles
Dama de Corazones
En esta mano hay pareja
Jugador 2
Cuatro de Espadas
Diez de Diamantes As de Treboles
Nueve de Espadas Nueve de Treboles
En esta mano hay pareja
por aquí
jugadores = 2
Ninguno de los dos jugadores tiene pareja, sin embargo el programa dice "En esta mano hay pareja" Ahí aparentemente hay un problema, es decir, no hay pareja pero dice que sí hay pareja, a no ser que estés llamando pareja a otra cosa. ¿A qué estás llamando pareja?
-
Buenos dias.
He llamado pareja a cuando tienen 2 cartas del mismo número.
En el caso del jugador 1 sería seis de tréboles y 6 de diamantes.
En el caso del jugador 2 sería nueve de espadas y nueve de treboles.
Asique hasta ese punto todo está correcto. El problema viene después. Una vez que ha mostrado que mano tiene cada jugador, debería decir quien de los 2 ha ganado y es lo que no hace.
De hecho estuve comprobando hasta donde llegaba el programa antes de fallar. unas veces llega hasta el inicio de la funcion 'determina_ganador' y otras ni siquiera llega a entrar en esa función.
Por eso puse que se mostrara el texto "Por aquí" antes de entrar en esa función, y el texto "Jugadores = 2" cuando entraba en esa función.
Pero aún entrando en esa función, no llega a mostrar quien gana.
Todo esto me hace pensar que el problema debe de estar o en la función 'almacena_resultados' o en 'determina_ganador'.
El programa está organizado de la siguiente manera:
la función 'baraja' asigna un número a cada una de las 52 cartas, por lo que cada vez que busco una carta tengo que hacer la pasada por todo el mazo hasta que encuentra dicho número.
la función 'reparte' asigna 5 cartas al jugador.
la función 'combinacion_mano' imprime las 5 cartas del jugador y determina que tipo de jugada tiene(jugadas de poker).
la función 'almacena_resultados': entro a ella al final de 'combinación_mano' y guarda en el arreglo 'resultados' el tipo de jugada y el número de la carta de la jugada (por ejemplo: pareja de 7).
la funcion 'determina_ganador' va analizando el arreglo 'resultados' de arriba a abajo (de mejor jugada a peor). Cuando encuentra un valor distinto de -1, almacena los valores en una variable, compara a ver si alguien más tiene esa jugada y de ser así compara a ver quien tiene la carta de mayor número.
Tras todo esto debería imprimir el jugador ganador y el tipo de jugada.
Pero no lo hace :'(
Muchas gracias por la ayuda
Un saludo
p.d. El arreglo resultados hay que inicializarlo en -1, que yo lo hice todo en 0. Lo he cambiado en el programa pero sigue sin funcionar. Intente modificar el código aquí en el foro pero no me deja, por eso lo aviso por aquí.
-
Buenos dias.
He visto que entra sin problemas en la función 'determina_ganador' con los valores del arreglo 'resultados' bien (todo -1 menos lo que corresponde a las cartas de los jugadores que tiene el valor de las cartas). Ahora bien, al entrar en el ciclo 'for', solo lo ejecuta una vez, y ademas le da a 'mejor' el valor 0 (el ciclo debería ejecutarse más veces ya que para que solo se ejecute una vez, el jugador 1 tendría que tener escalera de color).
Además de todo esto no llega a mostrar quien es el ganador.
No entiendo por qué ocurre esto, no soy capaz de ver el fallo.
Pongo el código de esta función a continuación a ver si sois capaces de ver el fallo (he modificado un par de cosas respecto al código completo que puse al inicio del post.
He puesto printf dentro del ciclo for para ver cuantas veces lo realizaba, por eso digo que solo lo hace 1 vez.
Muchas gracias
void determina_ganador(int resultados[][9], int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[])
{
int jugador = 0;
int mejor = -1;
int jugada;
int jugador_ganador1;
int jugador_ganador2 = -1;
int mano_simple = -1;
int mano_doble = 0;
for (jugada = 8;resultados[jugador][jugada] == -1;jugada--)
{
jugador = 0;
printf("resultados = %d\n",resultados[jugador][jugada]);
printf("jugador = %d\n",jugador);
printf("jugada = %d\n", jugada );
while(resultados[jugador][jugada] == -1 && jugador < jugadores)
{
jugador++;
}
}
mejor = resultados[jugador][jugada];
printf("mejor = %d\n", mejor);
jugador_ganador1 = jugador;
jugador++;
for(; jugador < jugadores; jugador++)
{
if(resultados[jugador][jugada] > mejor )
{
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
}
if(resultados[jugador][jugada] == mejor )
{
jugador_ganador2 = jugador;
}
}
switch (jugada) {
case 0: mano_simple = 0;
return;
case 1: mano_simple = 1;
return;
case 2: mano_doble = 1;
return;
case 3: mano_simple = 2;
return;
case 4: mano_simple = 4;
return;
case 5: mano_simple = 5;
return;
case 6: mano_doble = 2;
return;
case 7: mano_simple = 3;
return;
case 8: mano_simple = 6;
return;
}
if (jugador_ganador2 == -1) // si no hay empate //
{
if(mano_doble == 0) // si es mano simple//
{
if(mano_simple != 5) // si no hay color //
{
printf("\n\nHa ganado el jugador %d con %s de %d\n\n",jugador_ganador1 + 1, cara[mano_simple], mejor);
}
else //hay color//
{
printf("\n\nHa ganado el jugador %d con %s \n\n",jugador_ganador1 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa ganado el jugador %d con %s de %d\n\n",jugador_ganador1 + 1, cara[mano_doble], mejor);
}
}
else // hay empate //
{
if(mano_doble == 0) // si es mano simple /7
{
if(mano_simple != 5) // si no hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %d\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple], mejor);
}
else //hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %d\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_doble], mejor);
}
}
}
-
Sí que había pareja, perdón por la mi equivocación. He cambiado la inicialización a -1 como indicabas y la función determina_ganador como la has puesto la última vez. He estado probando a correr el programa y me encuentro por ejemplo con esto:
Jugador 2
Rey de Treboles
Rey de Espadas Dos de Corazones
Nueve de Treboles Cinco de Treboles
En esta mano hay trio
¿Por qué dice que en esta mano hay trío? ¿No sería que hay pareja de reyes?
Jugador 2
Jota de Treboles
Jota de Espadas Dos de Espadas
Rey de Corazones Diez de Treboles
En esta mano hay trio
¿Por qué dice que en esta mano hay trío? ¿No sería que hay pareja de jotas?
Hay otra cosas que no entiendo. Si cuando pide "Por favor introduzca el número de jugadores le pongo 3, aparece por pantalla Jugador1, Jugador2, Jugador3, Jugador4, Jugador5, Jugador6, Jugador7, Jugador8, Jugador9, Jugador10, Jugador1 , y el jugador 11 solo aparece con dos cartas en una ejecución.
Si repito a ponerle 3 jugadores, me aparece hasta Jugador10
Si repito a ponerle 3 jugadores, me aparece hasta Jugador3
Repito a ponerle 3 jugadores y me aparece mensaje de error "imposible continuar"
Sigo repitiendo a ponerle 3 jugadores y en unos casos me muestra 3 jugadores, en otros 10, en otros 11, en otros se cierra el programa...
Esto parece algo extraño posible malfuncionamiento ¿No se supone que si meto 3 jugadores tendría que aparecer Jugador1, Jugador2 y Jugador3 simplemente?
-
Buenos dias.
He estado comprobando lo que me decías pero a mi no me pasa.
A mi siempre me dice la combinación correcta y con el número de jugadores correcto.
Lo único que no consigo que haga bien es determinar quien gana, que directamente no lo hace, se queda a la mitad de la función.
Seguiré mirando de todas formas por si acaso
Muchas gracias.
Un saludo
-
Buenas tardes, he encontrado 2 fallos pero no se por qué se producen.
el primero : Program received signal SIGSEGV, Segmentation fault. en la línea 46.
Parece ser que no puede acceder a algún dato..... pero este error no ocurre siempre...
El siguiente error es a partir de la línea 387: Hasta aquí llega con todas las variables bien, pero luego a pesar de cumplirse los requisitos no entra en el bucle para imprimir el ganador.
¿Alguna idea?
Muchas gracias por vuestro tiempo.
Pongo el código de nuevo con las cosas que he modificado para corregir errores:
/*Ejercicio 7.13: Determinar cual es la mejor mano de poker */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* prototipos */
void baraja( int wMazo[][ 13 ] );
void reparte( const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], int carta_inicial, int carta_final );
void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], const char *combinacion_simple[], const char *combinacion_doble[], int carta_inicial, int carta_final,int resultados[][9] , int jugador );
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble);
void determina_ganador(int resultados[][9],int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *wCara[]);
int main()
{
/* inicializa el arreglo palo */
const char *palo[ 4 ] = { "Corazones", "Diamantes", "Treboles", "Espadas" };
/* inicializa el arreglo cara */
const char *cara[ 13 ] =
{ "As", "Dos", "Tres", "Cuatro",
"Cinco", "Seis", "Siete", "Ocho",
"Nueve", "Diez", "Jota", "Dama", "Rey" };
const char *combinacion_simple[7] = {"carta mas alta", "pareja", "trio", "poker","escalera", "color", "escalera de color" };
const char *combinacion_doble[3] = {"carta mas alta", "doble pareja","full"};
/* inicializa el arreglo mazo */
int mazo[ 4 ][ 13 ] = { 0 };
int jugadores, jugador;
srand( time( NULL ) ); /* semilla del generador de números aleatorios */
baraja( mazo );
printf("Por favor introduzca el número de jugadores: ");
scanf("%d", &jugadores);
int resultados[2][9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1};// arreglo que guarda los resultados //
for (jugador = 0; jugador < jugadores; jugador++)
{
printf("\n\nJugador %d\n\n", jugador + 1);
reparte( mazo, cara, palo,1 + (jugador * 5),5 + (jugador * 5) );
combinacion_mano(mazo,cara,palo,combinacion_simple, combinacion_doble,1 + (jugador * 5),5 + (jugador * 5), resultados, jugador );
}
determina_ganador(resultados, jugadores, combinacion_simple, combinacion_doble,cara);
return 0; /* indica terminación exitosa */
} /* fin de main */
/* baraja las cartas del mazo */
void baraja( int wMazo[][ 13 ] )
{
int fila; /* número de fila */
int columna; /* número de columna */
int carta; /* contador */
/* elige aleatoriamente un espacio para cada una de las 52 cartas */
for ( carta = 1; carta <= 52; carta++ ) {
/* elije una nueva ubicación al azar hasta que encuentra un espacio vacío */
do {
fila = rand() % 4;
columna = rand() % 13;
} while( wMazo[ fila ][ columna ] != 0 ); /* fin de do...while */
/* coloca el número de carta en el espacio vacío del mazo */
wMazo[ fila ][ columna ] = carta;
} /* fin de for */
} /* fin de la función baraja */
/* reparte las cartas del mazo */
void reparte( const int wMazo[][ 13 ], const char *wCara[],
const char *wPalo[],int carta_inicial, int carta_final )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* si el espacio contiene la carta actual, despliega la carta */
if ( wMazo[ fila ][ columna ] == carta ) {
printf( "%6s de %-9s%c", wCara[ columna ], wPalo[ fila ],
carta % 2 == 0 ? '\n' : '\t' );
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
} /* fin de la función reparte */
//Determina la combinacion de la mano //
void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[],
const char *combinacion_simple[], const char *combinacion_doble[],int carta_inicial, int carta_final,int resultados[][9],int jugador )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
int posicion_carta;// contador para el resto de cartas que se comparan en función de la actual //
int numero_cartabase; //numero de la carta actual //
int palo_cartabase; //palo de la carta actual //
int num_combinacion_simple = 0; //combinacion que hay en la mano //
int num_combinacion_doble = 0; // segunda combinación que hay en la mano //
int mano[5] = {0};
int color = 1; // contador para saber si tienes color en la mano //
int escalera = 1; // contador para saber si tienes escalera //
int numero_carta_simple;
int numero_carta_doble;
int carta_mas_alta = 0;
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* Determina si hay una combinacion en función de la carta actual */
if ( wMazo[ fila ][ columna ] == carta && mano[carta - carta_inicial ] == 0 )
{
numero_cartabase = columna;
palo_cartabase = fila;
if(carta == carta_inicial ) // determina si tienes color a partir de la primera carta //
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta && fila == palo_cartabase)
{
if (fila == palo_cartabase)
{
color++;
numero_carta_simple = numero_cartabase;
}
if(columna == numero_cartabase + carta)
{
escalera++;
numero_carta_simple = numero_cartabase;
}
}
}
}
}
} // fin carta == 1 //
if (color != 5)// si no hay color //
{
if(num_combinacion_simple == 0)
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if(carta_mas_alta < numero_cartabase)
{
carta_mas_alta = numero_cartabase;
}
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_simple++;
numero_carta_simple = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
}// fin if combinacion simple //
else // la combinacion es doble//
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_doble++;
numero_carta_doble = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
} // fin de else //
}// fin de if si no hay color //
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
if(escalera == 5) // establece la escalera //
{
num_combinacion_simple = 4;
}
if(color == 5) // Establece el color //
{
num_combinacion_simple = 5;
}
if(escalera == 5 && color == 5) // Establece la escalera de color //
{
num_combinacion_simple = 6;
}
if(num_combinacion_simple == 2 && num_combinacion_doble == 1) // establece la otra posibilidad de full//
{
num_combinacion_doble = 2;
}
if (num_combinacion_doble == 0)
{
printf("\n\nEn esta mano hay %s \n", combinacion_simple[num_combinacion_simple] );
}
else
{
printf("\n\nEn esta mano hay %s \n", combinacion_doble[num_combinacion_doble] );
}
if(num_combinacion_simple == 0)
{
numero_carta_simple = carta_mas_alta;
}
almacena_resultados(resultados, num_combinacion_simple, num_combinacion_doble, jugador, numero_carta_simple, numero_carta_doble);
} // fin de la funcion combinacion mano //
// funcion almacena resultados //
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble)
{
if ( num_combinacion_doble == 0)
{
switch (num_combinacion_simple) {
case 0: resultados[jugador][0] = numero_carta_simple;
return;
case 1: resultados[jugador][1] = numero_carta_simple;
return;
case 2: resultados[jugador][3] = numero_carta_simple;
return;
case 3: resultados[jugador][7] = numero_carta_simple;
return;
case 4: resultados[jugador][4] = numero_carta_simple;
return;
case 5: resultados[jugador][5] = numero_carta_simple;
return;
case 6: resultados[jugador][8] = numero_carta_simple;
return;
} // fin switch //
}// fin if //
else
{
switch (num_combinacion_doble) {
case 1: resultados[jugador][2] = numero_carta_doble;
return;
case 2: resultados[jugador][6] = numero_carta_doble;
return;
}//fin switch//
}// fin else//
}
// funcion determina_ganador //
void determina_ganador(int resultados[][9], int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[])
{
int jugador = 0;
int mejor = -1;
int jugada = 8;
int jugador_ganador1;
int jugador_ganador2 = -1;
int mano_simple = -1;
int mano_doble = 0;
while(resultados[jugador][jugada] == -1 && jugador < jugadores)
{
jugador++;
if (jugador == jugadores)
{
jugador = 0;
jugada--;
}
}
mejor = resultados[jugador][jugada];
printf("mejor = %d\n", mejor);
jugador_ganador1 = jugador;
jugador++;
for(; jugador < jugadores; jugador++)
{
if(resultados[jugador][jugada] > mejor )
{
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
}
if(resultados[jugador][jugada] == mejor )
{
jugador_ganador2 = jugador;
}
}
switch (jugada) {
case 0: mano_simple = 0;
return;
case 1: mano_simple = 1;
return;
case 2: mano_doble = 1;
return;
case 3: mano_simple = 2;
return;
case 4: mano_simple = 4;
return;
case 5: mano_simple = 5;
return;
case 6: mano_doble = 2;
return;
case 7: mano_simple = 3;
return;
case 8: mano_simple = 6;
return;
}
if (jugador_ganador2 == -1) // si no hay empate //
{
if(mano_doble == 0) // si es mano simple//
{
if(mano_simple != 5) // si no hay color //
{
printf("\n\nHa ganado el jugador %d con %s de %d\n\n",jugador_ganador1 + 1, cara[mano_simple], mejor);
}
else //hay color//
{
printf("\n\nHa ganado el jugador %d con %s \n\n",jugador_ganador1 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa ganado el jugador %d con %s de %d\n\n",jugador_ganador1 + 1, cara[mano_doble], mejor);
}
}
else // hay empate //
{
if(mano_doble == 0) // si es mano simple /7
{
if(mano_simple != 5) // si no hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %d\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple], mejor);
}
else //hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %d\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_doble], mejor);
}
}
}
-
Buenas noches.
Pongo otra respuesta ya que no me deja editar las anteriores. Lo siento si ocupa mucho espacio el post.
Ya he encontrado el fallo de la línea 387 que comentaba en la respuesta anterior. Resulta que soy tonto y para salir del ciclo 'switch' usaba 'return' en vez de 'break' :-[ :-[ .
Tuve que modificar también un par de cosillas en las respuestas que daba al determinar un ganador pero cosas sin importancia.
Antes de que digais nada, cuando determina ganador entre 2 jugadores con carta más alta no lo determina bien, pero porque me falta añadir el aspecto de elegir cual es la mayor carta de la mano (detalle sin importancia).
Lo que aún no entiendo es el otro fallo que comente en la respuesta anterior:
-Program received signal SIGSEGV, Segmentation fault. en la línea 46.
Parece ser que no puede acceder a algún dato..... pero este error no ocurre siempre...
Agradecería cualquier ayuda.
Pongo el código que ya funciona a continuación:
/*Ejercicio 7.13: Determinar cual es la mejor mano de poker */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* prototipos */
void baraja( int wMazo[][ 13 ] );
void reparte( const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], int carta_inicial, int carta_final );
void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], const char *combinacion_simple[], const char *combinacion_doble[], int carta_inicial, int carta_final,int resultados[][9] , int jugador );
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble);
void determina_ganador(int resultados[][9],int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[]);
int main()
{
/* inicializa el arreglo palo */
const char *palo[ 4 ] = { "Corazones", "Diamantes", "Treboles", "Espadas" };
/* inicializa el arreglo cara */
const char *cara[ 13 ] =
{ "As", "Dos", "Tres", "Cuatro",
"Cinco", "Seis", "Siete", "Ocho",
"Nueve", "Diez", "Jota", "Dama", "Rey" };
const char *combinacion_simple[7] = {"carta mas alta", "pareja", "trio", "poker","escalera", "color", "escalera de color" };
const char *combinacion_doble[3] = {"carta mas alta", "doble pareja","full"};
/* inicializa el arreglo mazo */
int mazo[ 4 ][ 13 ] = { 0 };
int jugadores, jugador;
srand( time( NULL ) ); /* semilla del generador de números aleatorios */
baraja( mazo );
printf("Por favor introduzca el número de jugadores: ");
scanf("%d", &jugadores);
int resultados[2][9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1};// arreglo que guarda los resultados //
for (jugador = 0; jugador < jugadores; jugador++)
{
printf("\n\nJugador %d\n\n", jugador + 1);
reparte( mazo, cara, palo,1 + (jugador * 5),5 + (jugador * 5) );
combinacion_mano(mazo,cara,palo,combinacion_simple, combinacion_doble,1 + (jugador * 5),5 + (jugador * 5), resultados, jugador );
}
determina_ganador(resultados, jugadores, combinacion_simple, combinacion_doble,cara);
return 0; /* indica terminación exitosa */
} /* fin de main */
/* baraja las cartas del mazo */
void baraja( int wMazo[][ 13 ] )
{
int fila; /* número de fila */
int columna; /* número de columna */
int carta; /* contador */
/* elige aleatoriamente un espacio para cada una de las 52 cartas */
for ( carta = 1; carta <= 52; carta++ ) {
/* elije una nueva ubicación al azar hasta que encuentra un espacio vacío */
do {
fila = rand() % 4;
columna = rand() % 13;
} while( wMazo[ fila ][ columna ] != 0 ); /* fin de do...while */
/* coloca el número de carta en el espacio vacío del mazo */
wMazo[ fila ][ columna ] = carta;
} /* fin de for */
} /* fin de la función baraja */
/* reparte las cartas del mazo */
void reparte( const int wMazo[][ 13 ], const char *wCara[],
const char *wPalo[],int carta_inicial, int carta_final )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* si el espacio contiene la carta actual, despliega la carta */
if ( wMazo[ fila ][ columna ] == carta ) {
printf( "%6s de %-9s%c", wCara[ columna ], wPalo[ fila ],
carta % 2 == 0 ? '\n' : '\t' );
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
} /* fin de la función reparte */
//Determina la combinacion de la mano //
void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[],
const char *combinacion_simple[], const char *combinacion_doble[],int carta_inicial, int carta_final,int resultados[][9],int jugador )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
int posicion_carta;// contador para el resto de cartas que se comparan en función de la actual //
int numero_cartabase; //numero de la carta actual //
int palo_cartabase; //palo de la carta actual //
int num_combinacion_simple = 0; //combinacion que hay en la mano //
int num_combinacion_doble = 0; // segunda combinación que hay en la mano //
int mano[5] = {0};
int color = 1; // contador para saber si tienes color en la mano //
int escalera = 1; // contador para saber si tienes escalera //
int numero_carta_simple;
int numero_carta_doble;
int carta_mas_alta = 0;
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* Determina si hay una combinacion en función de la carta actual */
if ( wMazo[ fila ][ columna ] == carta && mano[carta - carta_inicial ] == 0 )
{
numero_cartabase = columna;
palo_cartabase = fila;
if(carta == carta_inicial ) // determina si tienes color a partir de la primera carta //
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta && fila == palo_cartabase)
{
if (fila == palo_cartabase)
{
color++;
numero_carta_simple = numero_cartabase;
}
if(columna == numero_cartabase + carta)
{
escalera++;
numero_carta_simple = numero_cartabase;
}
}
}
}
}
} // fin carta == 1 //
if (color != 5)// si no hay color //
{
if(num_combinacion_simple == 0)
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if(carta_mas_alta < numero_cartabase)
{
carta_mas_alta = numero_cartabase;
}
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_simple++;
numero_carta_simple = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
}// fin if combinacion simple //
else // la combinacion es doble//
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_doble++;
numero_carta_doble = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
} // fin de else //
}// fin de if si no hay color //
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
if(escalera == 5) // establece la escalera //
{
num_combinacion_simple = 4;
}
if(color == 5) // Establece el color //
{
num_combinacion_simple = 5;
}
if(escalera == 5 && color == 5) // Establece la escalera de color //
{
num_combinacion_simple = 6;
}
if(num_combinacion_simple == 2 && num_combinacion_doble == 1) // establece la otra posibilidad de full//
{
num_combinacion_doble = 2;
}
if (num_combinacion_doble == 0)
{
printf("\n\nEn esta mano hay %s \n", combinacion_simple[num_combinacion_simple] );
}
else
{
printf("\n\nEn esta mano hay %s \n", combinacion_doble[num_combinacion_doble] );
}
if(num_combinacion_simple == 0)
{
numero_carta_simple = carta_mas_alta;
}
almacena_resultados(resultados, num_combinacion_simple, num_combinacion_doble, jugador, numero_carta_simple, numero_carta_doble);
} // fin de la funcion combinacion mano //
// funcion almacena resultados //
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble)
{
if ( num_combinacion_doble == 0)
{
switch (num_combinacion_simple) {
case 0: resultados[jugador][0] = numero_carta_simple;
break;
case 1: resultados[jugador][1] = numero_carta_simple;
break;
case 2: resultados[jugador][3] = numero_carta_simple;
break;
case 3: resultados[jugador][7] = numero_carta_simple;
break;
case 4: resultados[jugador][4] = numero_carta_simple;
break;
case 5: resultados[jugador][5] = numero_carta_simple;
break;
case 6: resultados[jugador][8] = numero_carta_simple;
break;
} // fin switch //
}// fin if //
else
{
switch (num_combinacion_doble) {
case 1: resultados[jugador][2] = numero_carta_doble;
break;
case 2: resultados[jugador][6] = numero_carta_doble;
break;
}//fin switch//
}// fin else//
}
// funcion determina_ganador //
void determina_ganador(int resultados[][9], int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[])
{
int jugador = 0;
int mejor = -1;
int jugada = 8;
int jugador_ganador1;
int jugador_ganador2 = -1;
int mano_simple = -1;
int mano_doble = 0;
while(resultados[jugador][jugada] == -1 && jugador < jugadores)
{
jugador++;
if (jugador == jugadores)
{
jugador = 0;
jugada--;
}
}
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
jugador++;
for(; jugador < jugadores; jugador++)
{
if(resultados[jugador][jugada] > mejor )
{
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
}
if(resultados[jugador][jugada] == mejor )
{
jugador_ganador2 = jugador;
}
}
switch (jugada) {
case 0: mano_simple = 0;
break;
case 1: mano_simple = 1;
break;
case 2: mano_doble = 1;
break;
case 3: mano_simple = 2;
break;
case 4: mano_simple = 4;
break;
case 5: mano_simple = 5;
break;
case 6: mano_doble = 2;
break;
case 7: mano_simple = 3;
break;
case 8: mano_simple = 6;
break;
}
if (jugador_ganador2 == -1) // si no hay empate //
{
if(mano_doble == 0) // si es mano simple//
{
if(mano_simple != 5) // si no hay color //
{
printf("\n\nHa ganado el jugador %d con %s de %s\n\n",jugador_ganador1 + 1, combinacion_simple[mano_simple], cara[mejor]);
}
else //hay color//
{
printf("\n\nHa ganado el jugador %d con %s \n\n",jugador_ganador1 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa ganado el jugador %d con %s de %s\n\n",jugador_ganador1 + 1, combinacion_doble[mano_doble], cara[mejor]);
}
}
else // hay empate //
{
if(mano_doble == 0) // si es mano simple /7
{
if(mano_simple != 5) // si no hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, combinacion_simple[mano_simple], cara[mejor]);
}
else //hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, combinacion_doble[mano_doble], cara[mejor]);
}
}
}
-
He hecho algunas pruebas y compruebo estos problemas:
Ejemplo 1: dice que hay trío en jugador 2 cuando no lo hay y dice que gana jugador con escalera pero no la hay
Ejemplo 2: introduzco 3 jugadores y saca resultados para 11 jugadores
EJEMPLO 1
Por favor introduzca el numero de jugadores: 3
Jugador 1
As de Corazones Tres de Corazones Dos de Diamantes Ocho de Diamantes
Tres de Diamantes
En esta mano hay pareja
Jugador 2
Siete de Espadas Siete de Corazones Dos de Treboles
Rey de Diamantes As de Diamantes
En esta mano hay trio
Jugador 3
Cuatro de Diamantes Cuatro de Treboles Seis de Espadas Nueve de Treboles
Cinco de Espadas
En esta mano hay pareja
Ha ganado el jugador 3 con escalera de color de
EJEMPLO 2
Por favor introduzca el número de jugadores: 3
Y me genera hasta 11 jugadores...
-
Estableciendo un seguimiento de las variables que controlan el bucle for (jugador = 0; jugador < jugadores; jugador++) encuentro que en algunos casos ocurre lo siguiente:
Por favor introduzca el numero de jugadores: 3
Estamos en bucle con jugador 0 y jugadores vale 3
Jugador 1
Estamos en bucle con jugador 1 y jugadores vale 3
Jugador 2
Estamos en bucle con jugador 2 y jugadores vale 3
Jugador 3
Estamos en bucle con jugador 3 y jugadores vale 12
Jugador 4
Estamos en bucle con jugador 4 y jugadores vale 12
Jugador 5
...
... y sigue ¡¡¡DICIENDO QUE HAY 12 JUGADORES!!!
En otra ejecución:
Por favor introduzca el n·mero de jugadores: 3
Hay 3 jugadores
Estamos en bucle con jugador 0 y jugadores vale 3
Jugador 1
Estamos en bucle con jugador 1 y jugadores vale 3
Jugador 2
Estamos en bucle con jugador 2 y jugadores vale 3
Estamos en bucle con jugador 3 y jugadores vale 10
Jugador 4
Estamos en bucle con jugador 4 y jugadores vale 10
Jugador 5
Estamos en bucle con jugador 5 y jugadores vale 10
Jugador 6
...
... y sigue ¡¡¡DICIENDO QUE HAY 10 JUGADORES!!!
Viendo estos resultados, ese bucle funciona a veces bien y a veces mal, y cuando funciona mal no siempre genera el mismo número de jugadores.
Posiblemente esté habiendo una manipulación incorrecta de las variables de control del bucle (esto no he llegado a verlo todavía)
-
Buenas noches.
Perdón por haber tardado tanto en contestar pero he estado un poco liado.
He revisado lo que me comentaste y he visto varias cositas.
Por un lado a mi no me dice que existan más jugadores de los que marco, directamente me pone segmentation fault (core dumped). También he visto que no siempre me sale esta alerta. Hay veces que finaliza el programa correctamente diciendo quién ha ganado. Otras dice quién ha ganado pero lo dice mal (la última vez que ocurrió esto contó un trio como pareja y salió otro jugador como ganador debido a esto).
Lo que sí que me he fijado es que normalmente finaliza la función de almacenar resultados correctamente y o bien salta el error al volver al ciclo de incrementar el jugador, o salta el error en la función de determinar ganador.
La verdad esque he estado revisando todo pero no soy capaz de ver donde está el fallo.
Pongo el código a continuación con las cosas que he modificado:
/*Ejercicio 7.13: Determinar cual es la mejor mano de poker */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* prototipos */
void baraja( int wMazo[][ 13 ] );
void reparte( int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], int carta_inicial, int carta_final );
void combinacion_mano( int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], const char *combinacion_simple[], const char *combinacion_doble[], int carta_inicial, int carta_final,int resultados[][9] , int jugador );
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble);
void determina_ganador(int resultados[][9],int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[]);
int main()
{
/* inicializa el arreglo palo */
const char *palo[ 4 ] = { "Corazones", "Diamantes", "Treboles", "Espadas" };
/* inicializa el arreglo cara */
const char *cara[ 13 ] =
{ "As", "Dos", "Tres", "Cuatro",
"Cinco", "Seis", "Siete", "Ocho",
"Nueve", "Diez", "Jota", "Dama", "Rey" };
const char *combinacion_simple[7] = {"carta mas alta", "pareja", "trio", "poker","escalera", "color", "escalera de color" };
const char *combinacion_doble[3] = {"carta mas alta", "doble pareja","full"};
/* inicializa el arreglo mazo */
int mazo[ 4 ][ 13 ] = {{ 0 }};
int jugadores, jugador;
srand( time( NULL ) ); /* semilla del generador de números aleatorios */
baraja( mazo );
printf("Por favor introduzca el número de jugadores entre 2 y 5: ");
scanf("%d", &jugadores);
int resultados[5][9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1};// arreglo que guarda los resultados //
for (jugador = 0; jugador < jugadores; jugador++)
{
printf("\n\nJugador %d\n\n", jugador + 1);
reparte( mazo, cara, palo,1 + (jugador * 5),5 + (jugador * 5) );
combinacion_mano(mazo,cara,palo,combinacion_simple, combinacion_doble,1 + (jugador * 5),5 + (jugador * 5), resultados, jugador );
}
determina_ganador(resultados, jugadores, combinacion_simple, combinacion_doble, cara);
return 0; /* indica terminación exitosa */
} /* fin de main */
/* baraja las cartas del mazo */
void baraja( int wMazo[][ 13 ] )
{
int fila; /* número de fila */
int columna; /* número de columna */
int carta; /* contador */
/* elige aleatoriamente un espacio para cada una de las 52 cartas */
for ( carta = 1; carta <= 52; carta++ ) {
/* elije una nueva ubicación al azar hasta que encuentra un espacio vacío */
do {
fila = rand() % 4;
columna = rand() % 13;
} while( wMazo[ fila ][ columna ] != 0 ); /* fin de do...while */
/* coloca el número de carta en el espacio vacío del mazo */
wMazo[ fila ][ columna ] = carta;
} /* fin de for */
} /* fin de la función baraja */
/* reparte las cartas del mazo */
void reparte( int wMazo[][ 13 ], const char *wCara[],
const char *wPalo[],int carta_inicial, int carta_final )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* si el espacio contiene la carta actual, despliega la carta */
if ( wMazo[ fila ][ columna ] == carta ) {
printf( "%6s de %-9s%c", wCara[ columna ], wPalo[ fila ],
carta % 2 == 0 ? '\n' : '\t' );
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
} /* fin de la función reparte */
//Determina la combinacion de la mano //
void combinacion_mano( int wMazo[][ 13 ], const char *wCara[], const char *wPalo[],
const char *combinacion_simple[], const char *combinacion_doble[],
int carta_inicial, int carta_final,int resultados[][9],int jugador )
{
int carta; /* contador de cartas */
int fila; /* contador de filas */
int columna; /* contador de columnas */
int posicion_carta;// contador para el resto de cartas que se comparan en función de la actual //
int numero_cartabase; //numero de la carta actual //
int palo_cartabase; //palo de la carta actual //
int num_combinacion_simple = 0; //combinacion que hay en la mano //
int num_combinacion_doble = 0; // segunda combinación que hay en la mano //
int mano[5] = {0};
int color = 1; // contador para saber si tienes color en la mano //
int escalera = 1; // contador para saber si tienes escalera //
int numero_carta_simple = -1;
int numero_carta_doble;
int carta_mas_alta = 0;
/* reparte cada una de las 52 cartas */
for ( carta = carta_inicial; carta <= carta_final; carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
/* Determina si hay una combinacion en función de la carta actual */
if ( wMazo[ fila ][ columna ] == carta && mano[carta - carta_inicial ] == 0 )
{
numero_cartabase = columna;
palo_cartabase = fila;
if(carta == carta_inicial ) // determina si tienes color a partir de la primera carta //
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta )
{
if (fila == palo_cartabase)
{
color++;
if(numero_carta_simple < columna)
numero_carta_simple = columna;
}
if(columna == numero_cartabase + (posicion_carta - 1) )
{
escalera++;
if(numero_carta_simple < columna)
numero_carta_simple = columna;
}
}
}
}
}
} // fin carta == 1 //
if (color != 5 && escalera != 5)// si no hay color ni escalera //
{
if(num_combinacion_simple == 0)
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if(carta_mas_alta < numero_cartabase && carta_mas_alta != 0)
{
carta_mas_alta = numero_cartabase;
}
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_simple++;
numero_carta_simple = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
}// fin if combinacion simple //
else // la combinacion es doble//
{
for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {
/* realiza el ciclo a través de las filas de wMazo */
for ( fila = 0; fila <= 3; fila++ ) {
/* realiza el ciclo a través de las columnas de wMazo en la fila actual */
for ( columna = 0; columna <= 12; columna++ ) {
if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
{
num_combinacion_doble++;
numero_carta_doble = numero_cartabase;
mano[posicion_carta - 1] = 1;
}
}
}
}
} // fin de else //
}// fin de if si no hay color //
} /* fin de if */
} /* fin de for */
} /* fin de for */
} /* fin de for */
if(escalera == 5) // establece la escalera //
{
num_combinacion_simple = 4;
}
if(color == 5) // Establece el color //
{
num_combinacion_simple = 5;
}
if(escalera == 5 && color == 5) // Establece la escalera de color //
{
num_combinacion_simple = 6;
}
if(num_combinacion_simple == 2 && num_combinacion_doble == 1) // establece la otra posibilidad de full//
{
num_combinacion_doble = 2;
}
if (num_combinacion_doble == 0)
{
printf("\n\nEn esta mano hay %s \n", combinacion_simple[num_combinacion_simple] );
}
else
{
printf("\n\nEn esta mano hay %s \n", combinacion_doble[num_combinacion_doble] );
}
if(num_combinacion_simple == 0)
{
numero_carta_simple = carta_mas_alta;
}
printf("fin combinacion mano\n\n");
almacena_resultados (resultados, num_combinacion_simple, num_combinacion_doble, jugador, numero_carta_simple, numero_carta_doble);
} // fin de la funcion combinacion mano //
// funcion almacena resultados //
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble)
{
if ( num_combinacion_doble == 0)
{
switch (num_combinacion_simple) {
case 0: resultados[jugador][0] = numero_carta_simple;
break;
case 1: resultados[jugador][1] = numero_carta_simple;
break;
case 2: resultados[jugador][3] = numero_carta_simple;
break;
case 3: resultados[jugador][7] = numero_carta_simple;
break;
case 4: resultados[jugador][4] = numero_carta_simple;
break;
case 5: resultados[jugador][5] = numero_carta_simple;
break;
case 6: resultados[jugador][8] = numero_carta_simple;
break;
} // fin switch //
}// fin if //
else
{
switch (num_combinacion_doble) {
case 1: resultados[jugador][2] = numero_carta_doble;
break;
case 2: resultados[jugador][6] = numero_carta_doble;
break;
}//fin switch//
}// fin else//
printf("fin alamacena resultados\n\n");
}
// funcion determina_ganador //
void determina_ganador(int resultados[][9], int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[])
{
int jugador = 0;
int mejor = -1;
int jugada = 8;
int jugador_ganador1;
int jugador_ganador2 = -1;
int mano_simple = -1;
int mano_doble = 0;
printf("determina ganador\n\n");
while(resultados[jugador][jugada] == -1 && jugador < jugadores)
{
jugador++;
if (jugador == jugadores)
{
jugador = 0;
jugada--;
}
}
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
jugador++;
for(; jugador < jugadores; jugador++)
{
if(resultados[jugador][jugada] == mejor )
{
jugador_ganador2 = jugador;
}
else
{
if(resultados[jugador][jugada] > mejor || resultados[jugador][jugada] == 0 )
{
mejor = resultados[jugador][jugada];
jugador_ganador1 = jugador;
}
}
}
switch (jugada) {
case 0: mano_simple = 0;
break;
case 1: mano_simple = 1;
break;
case 2: mano_doble = 1;
break;
case 3: mano_simple = 2;
break;
case 4: mano_simple = 4;
break;
case 5: mano_simple = 5;
break;
case 6: mano_doble = 2;
break;
case 7: mano_simple = 3;
break;
case 8: mano_simple = 6;
break;
}
if (jugador_ganador2 == -1) // si no hay empate //
{
if(mano_doble == 0) // si es mano simple//
{
if(mano_simple != 5) // si no hay color //
{
printf("\n\nHa ganado el jugador %d con %s de %s\n\n",jugador_ganador1 + 1, combinacion_simple[mano_simple], cara[mejor]);
}
else //hay color//
{
printf("\n\nHa ganado el jugador %d con %s \n\n",jugador_ganador1 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa ganado el jugador %d con %s de %s\n\n",jugador_ganador1 + 1, combinacion_doble[mano_doble], cara[mejor]);
}
}
else // hay empate //
{
if(mano_doble == 0) // si es mano simple //
{
if(mano_simple != 5) // si no hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, combinacion_simple[mano_simple], cara[mejor]);
}
else //hay color//
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple]);
}
}
else // si es mano doble //
{
printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, combinacion_doble[mano_doble], cara[mejor]);
}
}
}
-
He estado probando y ya no salta el problema de que el número de jugadores "se vuelva un número aleatorio" (10, 12, etc.).
Ahora en ejecuciones estoy obteniendo aproximadamente esto:
80 % programa termina con resultados correctos
10 % programa termina pero resultados no son correctos
10 % programa genera error o queda bloqueado
Hay una cosa que dificulta la depuración, y es que al tener generación aleatoria de datos (combinaciones de cartas) no puedes reproducir o hacer que vuelva a ocurrir lo mismo para poder depurar el error.
Te recomendaría que anotes 3 o 4 resultados donde el programa se cierra o bloquea, y 3 o 4 resultados donde el programa da un resultado erróneo.
A continuación, genera un fragmento de código que te permita establecer manualmente el número de jugadores y la combinación de cartas de cada jugador (desactivando la opción a introducir el dato o generar aleatoriamente los datos), de este modo podrás repetir la ejecución.
Luego desactiva el funcionamiento automático y activa el manual. Una vez activado el manual, comprueba qué ocurre cuando se invoca siempre la misma ejecución ¿falla siempre o sólo falla algunas veces?
A partir de ahí, trata de depurar ese error siguiendo paso a paso la traza del programa. Cuando hayas depurado los errores que tienes apuntados uno a uno en modo manual, vuelve a activar el modo automático y desactiva el modo manual, y comprueba lo que ocurre.
Te indico un caso de resultado incorrecto y otro de error y cierre del programa.
RESULTADO INCORRECTO
Por favor introduzca el numero de jugadores entre 2 y 5: 3
Hay 3 jugadores
Jugador 1
Dos de Corazones Seis de Treboles
Rey de Espadas As de Treboles
Diez de Espadas
En esta mano hay carta mas alta
fin combinacion mano
fin alamacena resultados
Jugador 2
Ocho de Corazones
Dos de Espadas Rey de Corazones
Jota de Corazones Diez de Corazones
En esta mano hay carta mas alta
fin combinacion mano
fin alamacena resultados
Estamos en bucle con jugador 2 y jugadores vale 3
Jugador 3
Ocho de Treboles Dos de Treboles
Cinco de Treboles Nueve de Espadas
Tres de Diamantes
En esta mano hay carta mas alta
fin combinacion mano
fin alamacena resultados
determina ganador
Ha habido un empate entre el jugador 1 y el jugador 3 con carta mas alta de As
Si no me equivoco no hay empate, debería ganar el jugador 1, sin embargo dice que hay empate.
EJEMPLO QUE GENERA EL BLOQUEO O ERROR AL EJECUTAR EL PROGRAMA
Por favor introduzca el n·mero de jugadores entre 2 y 5: 3
Hay 3 jugadores
Estamos en bucle con jugador 0 y jugadores vale 3
Jugador 1
Nueve de Diamantes Nueve de Treboles
Cinco de Treboles Dama de Espadas
Cuatro de Treboles
En esta mano hay pareja
fin combinacion mano
fin alamacena resultados
Estamos en bucle con jugador 1 y jugadores vale 3
Jugador 2
Siete de Espadas
As de Diamantes Diez de Treboles
Dos de Diamantes Diez de Espadas
En esta mano hay pareja
fin combinacion mano
fin alamacena resultados
Estamos en bucle con jugador 2 y jugadores vale 3
Jugador 3
Rey de Diamantes Dama de Treboles
Rey de Espadas Tres de Corazones
Cinco de Espadas
En esta mano hay doble pareja
fin combinacion mano
fin alamacena resultados
determina ganador
(... AQUÍ NO SIGUE AVANZANDO, ERROR Y SE CIERRA)
En este caso se bloqueó antes de mostrar los resultados.
Saludos