miércoles, 5 de enero de 2011

Deitel_C++_5.13 (Juego de Poker en C++)

Una Flor Imperial
Lo primero que debo hacer es ofrecer una disculpa por haber hecho un programa tan grande. Contiene mas de 1100 lineas de código y cuando lo imprimí me llevé 18 hojas. Sin embargo creo que no es posible hacerlo mas compacto, por lo menos no sin un grave deterioro de la simplicidad que tiene. Creo que se puede seguir muy bien a pesar de que casi no tiene comentarios. Está dividido en bloques que hacen una función muy precisa. Sólo, el ciclo main es un poco confuso. Lo que hace este programa es repartir dos manos y decidir cuál de ellas es la mejor. Revisé las funciones una por una para ver que realmente hacían su tarea. Puedo decir que salvo una, que evalúa un caso realmente raro, creo que las dos manos sean poquer o full, algo de verdad raro, todas funcionan bien. Sin embargo están advertidos acerca de esa funcion, que ahora no recuerdo porque fue hace mucho. En la práctica supongo que pueden pasar la vida jugando y no van a estar en una mesa en la que ustedes y alguien mas tengan un full, pero si hubiera de usarse este programa, digamos para un casino, debería revisarse de manera exhaustiva. Yo lo hice, y no detecte más error que ese, pero desde luego puede haber más. La manera de evaluarlas es enviarles casos solo a las funciones. Por ejemplo para una flor imperial hice un programa independiente llamado flor imperial que únicamente analizaba esos casos. Debo decir que me sorprendió cuando empezaron a salir flores imperiales en menos de un millón de manos, algunas en 600 mil, si no me falla la memoria. Yo esperaba que fueran más raras porque había visto en wikipedia las posibles combinaciones que no incluían el hecho de que una flor imperial es la misma de 5! maneras diferentes ( la probabilidad de que una mano sea flor imperial es 4*5!*47!/52!). Este programa no juega poquer, sólo evalúa manos, hacer que juegue es el siguiente ejercicio, pero con esta base es mas fácil resolverlo.


 #include <iostream>
 using namespace::std;

 #include <cstdlib>
 #include <ctime>

 const int manos = 2; //Este programa solo reparete dos manos
 const int Numero_Palos = 4;
 const int Cartas_de_Palo = 13;

 const int n = Cartas_de_Palo + 1;

 void Barajar( int[][n], int[], int[] );
 void Repartir( int[][n] );
 int Analizar( int[][n], int[], int[] );
 int Corrida( int[]);
 int Flor_Imperial( int[]);
 int Desempate1( int[], int[]);
 int Desempate2( int[], int[]);
 int Desempate3( int[], int[]);
 int Desempate4( int[], int[]);
 int Desempate5( int[], int[]);
 int Desempate6( int[], int[]);
 int Desempate7( int[], int[]);
 int Desempate8( int[], int[]);
 int Desempate9( int[], int[]);
 //Las funciones Corrida y Flor_Imperial son llamadas por la funcion Analizar


 int main()
 { // Inicia main
 int centinela = 0;


 // while ( 0 == centinela )
  //{ //Abre while
 int contador_de_manos = 1;
 int valor = 0;
 int Valores_Manos[ manos + 1 ] = { 0};
 // en el arreglo valores se guardaran los valores de las manos
 int mano1[Numero_Palos + 1] = {0};
 int mano2[Numero_Palos + 1] = {0};

 cout << "\nEl numero de manos a repartir es: " << manos << endl;

 srand(time(0));

 while ( contador_de_manos <= manos )
 { // Abre while
 int cartas[Numero_Palos + 1][n] = { {0, 0} };
 int xF[53] = {0};
 int xN[53] = { 0 };



 Barajar( cartas, xF, xN );
 cout << "\nEsta es la mano del jugador " << contador_de_manos <<" : ";
 cout << endl;
 Repartir( cartas );
 //Esta funcion debe repartir 5 cartas del arreglo cartas
 // solo hay que imprimir los numeros 1 a 5 ;

 if ( 1 == contador_de_manos )
 {
 for (int cont = 1; cont <= 5; cont++)
 mano1[cont] = xN[cont];
 }

 else
 {
 for (int conta = 1; conta <= 5; conta++)
 mano2[conta] = xN[conta];
 }
 valor = Analizar( cartas, xF, xN );
 Valores_Manos[ contador_de_manos ] = valor;

 contador_de_manos++;

 } // Cierra while

 int mayor;
 int ganador;

 // Aqui se desempata para el caso de la carta mas alta
 if ( Valores_Manos[1] == Valores_Manos[2] )
 { // Abre if

 switch (Valores_Manos[1])

 {

 // Desempata carta mas alta
 case 1:
 {
 ganador = Desempate1( mano1, mano2);
 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;

 // Desempata pares
 case 2:
 {
 ganador = Desempate2(mano1, mano2);

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 // Desempata dos pares
 case 3:

 {
 ganador = Desempate3(mano1, mano2);

 centinela = 1;
 // La linea de arriba estaba comentada

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 // Desempata tercias
 case 4:

 {
 ganador = Desempate4(mano1, mano2);
 centinela = 1;
 // La linea de arriba estaba comentada

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 case 5:
 // Desempata escaleras

 {
 ganador = Desempate5(mano1, mano2);


 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;



 // Desempata color

 case 6:
 {
 ganador = Desempate1(mano1, mano2);


 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 // Desempata full

 case 7:
 { // Abre case 7
 ganador = Desempate7(mano1, mano2);
 centinela = 1;

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }

 break;


 case 8: // Desempata poquer
 { // Abre case 8
 ganador = Desempate8(mano1, mano2);


 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 } // Cierra case 8

 break;


 case 9: // Desempata escaleras de color

 { // Abre case 9;
 ganador = Desempate9( mano1, mano2);

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }

 } // Cierra case 9

 break;

 case 10:

 { // Abre case 10

 cout << "\nHAY DOS FLORES IMPERIALES!" <<endl << endl;

 } // Cierra case 10
 default:
 break;


 } // Cierra switch
 } // Cierra if del caso en el que las manos son iguales
 // (del mismo tipo)


 else
 { //Abre else
 if ( Valores_Manos[1] > Valores_Manos[2] )
 cout << "\nLa mano del jugador 1 es mejor que la del jugador 2."<<endl;
 else
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1."<< endl;
 } //Cierra else


 // } // Cierra while de centinela
 //comento esta linea
 return 0;
 } // Cierra main


 // Esta funcion define las variables y llama a las funciones
 // barajar y repartir

 //////////////////////////////////////////////////////////////////
 // Inicia la funcion barajar
 /////////////////////////////////////////////////////////////////

 void Barajar(int Mazo[][14], int xFiguras[], int xNumeros[] )

 { // Abre barajar

 int contador;
 int tipo_carta;
 int numero_carta;

 for ( contador = 1; contador <= 52; contador++ )
 { //Abre for
 // El numero de cartas a llenar es 52, las entradas de la variable
 // mazo.
 do{ //Abre do
 tipo_carta = 1 + rand() % 4; //Se elige al azar la columna y la
 numero_carta = 1 + rand() % 13; //fila del arreglo mazo en donde
 // se pondra el numero siguiente
 } while( 0 != Mazo[tipo_carta][numero_carta] ); //Cierra do
 //Con la condicion del while se cuida que no se llene una casilla
 // ya llenada


 if ( 0 == Mazo[tipo_carta][numero_carta] )
 // Este if es porque es muy probable que la fila y columna elegida
 // ya este llena, sobre todo para los numeros finales
 { // Abre if
 Mazo[tipo_carta][numero_carta] = contador;
 xFiguras[contador] = tipo_carta;
 xNumeros[contador] = numero_carta;
 } //Cierra if
 } //Cierra for

 return;
 } // Cierra barajar




 /////////////////////////////////////////////////////////////////
 // Inicia la funcion repartir
 ////////////////////////////////////////////////////////////////

 void Repartir( int barajadas[][14] )

 { // Abre Repartir
 const char *Numero[14] = { "error", "As", "Dos", "Tres", "Cuatro", "Cinco",
 "seis", "siete", "ocho", "Nueve", "Diez",
 "Sota", "Reina", "Rey"};

 const char *Palos[5] = { "error", "Corazones", "Treboles", "Espadas",
 "Diamantes"};

 //cout << "\nSu mano es la siguiente:\n " << endl;


 for ( int r = 1; r <= 5; r++ )
 // Se repartiran 5 cartas

 { //Abre for
 for ( int y = 1; y <= 4; y++ )
 {
 for ( int z = 1; z <= 13; z++ )
 { //Abre for doble anidado
 if ( r == barajadas[y][z])
 cout << Numero[z] << " de " << Palos[y] << endl;

 } // Cierra for doble anidado
 } //Cierra for anidado
 } //Cierra for
 } // Cierra Repartir



 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion analizar
 ///////////////////////////////////////////////////////////////////////


 int Analizar( int xcartas[][14], int Fig[], int Num[] )

 { //Abre Analizar

 int temp = Fig[1];
 int iguales = 1;
 int corrida = 0;
 int valor = 1; //El valor de la mano es 1, siempre habra una carta
 // de mayor valor;

 //Aqui se analizan los numeros

 int temp2[14] = {0 };
 for ( int s = 1; s <= 5; s++ )
 { // Abre for
 temp2[Num[s]]++;

 } //Cierra for


 int contador_pares = 0;
 int contador_tercia = 0;
 int contador_poquer = 0;

 for ( int w = 1; w <= 14; w++ )
 { //Abre for
 if ( 2 == temp2[w] )
 contador_pares++;

 if ( 3 == temp2[w] )
 contador_tercia = 1;

 if ( 4 == temp2[w] )
 {
 contador_poquer = 1;
 }

 } //Cierra for

 if ( 0 != contador_pares )
 {
 cout <<"\nUsted tiene " << (1 == contador_pares? " 1 par " :
 " dos pares") << endl;
 if ( 1 == contador_pares)
 valor = 2;
 else
 valor = 3;
 }

 if ( 1 == contador_tercia )
 { // Abre if
 cout <<(0 != contador_pares? "y 1 tercia ( Un full). " :
 "\nUsted tiene una tercia. ");
 if ( 1 == contador_pares )
 valor = 7;
 else
 valor = 4;
 } // Cierra if

 if ( 1 == contador_poquer )
 {
 cout <<"\nUsted tiene un poquer. " << endl;
 valor = 8;
 }



 //En este ciclo for se analizan las figuras


 for ( int i = 2; i <= 5; i ++ )
 { // Abre for
 if ( Fig[ i ] != temp )
 { // Abre if
 iguales = -1;
 } // Cierra if
 } // Cierra for

 /////////////////////////////////////////////////////////////////////
 // Despues de haber analizado el color, se usa esa informacion

 if ( 1 == iguales )
 { //Abre if de iguales

 corrida = Corrida( Num );
 // La funcion corrida verifica que los numeros sean consecutivos
 int flor; // Se verifica que haya flor imperial
 if ( 0 == corrida )
 { // Abre if anidado
 flor = Flor_Imperial(Num);
 if ( 0 == flor )
 { //Abre if doble anidado
 cout <<"\n\nUsted tiene un flux!" << endl;
 valor = 6;
 } //Cierra if doble anidado
 else
 { // Abre else doble anidado
 cout <<"\n\nUSTED TIENE UNA FLOR IMPERIAL!" << endl << endl;
 valor = 10;
 } // Cierra else doble anidado
 } // Cierra if anidado

 else // Abre else anidado
 {
 cout << "\nUsted tiene una escalera de color!" << endl;
 valor = 9;
 } //Cierra else anidado


 } // Cierra if de colore iguales




 else
 { //Analiza escalera para el caso de colores distintos
 int escalera;
 escalera = Corrida( Num);

 if ( 1 == escalera )
 { // Abre if anidado
 cout << "\nUsted tiene una escalera. " << endl;
 valor = 5;
 } // cierra if anidado
 } // Cierra else

 cout << "\nEl valor de su mano es: " << valor << endl;
 return valor;
 } //Cierra Analizar

 ///////////////////////////////////////////////////////////////////
 // Inicia la funcion corrida, esta funcion se llama por la funcion
 // Analizar
 //////////////////////////////////////////////////////////////////

 int Corrida( int X[])

 { // Abre la funcion Corrida

 int temporal;
 for ( int l = 1; l < 5; l++)
 { //Abre for
 for ( int d = 1; d < 5; d++ )

 { // Abre for anidado
 if ( X[d + 1] < X[d] )
 { //Abre if
 temporal = X[d];
 X[d] = X[d + 1];
 X[d + 1] = temporal;
 } //Cierra if
 } //Cierra for anidado
 } //Cierra for

 int ordenados = 0;

 for ( int t = 1; t < 5; t++ )
 { //Abre for
 if ( X[t + 1] == X[t] + 1 )
 { //Abre if
 //cout << X[t] << " ";
 ordenados++;
 } // Cierra if
 } //Cierra for

 //cout << X[5] << endl;
 if ( 4 != ordenados )

 return 0;

 else

 return 1;
 }



 //////////////////////////////////////////////////////////////////////////
 /// Se define la funcion Flor_Imperial
 /////////////////////////////////////////////////////////////////////////


 int Flor_Imperial( int Y[] )
 { //Abre la funcion
 int tempor;
 for ( int f = 1; f < 5; f++)
 { //Abre for
 for ( int d = 1; d < 5; d++ )

 { // Abre for anidado
 if ( Y[d + 1] < Y[d] )
 { //Abre if
 tempor = Y[d];
 Y[d] = Y[d + 1];
 Y[d + 1] = tempor;
 } //Cierra if
 } //Cierra for anidado
 } //Cierra for

 // El doble ciclo for anterior ordeno de menor a mayor el arreglo
 // de numeros de las cartas

 int variable = 10;
 int cambio = 0;

 if ( 1 != Y[1] )
 return 0;

 else
 { // Abre else

 for ( int z = 2; z <= 5; z++ )
 { //Abre for
 if ( Y[z] != variable )
 {
 cambio = 1;
 }
 variable++;
 } //Cierra for
 } // Cierra else

 if ( 0 != cambio )
 return 0;
 else
 return 1;
 } // Cierra la funcion



 /////////////////////////////////////////////////////////////////////
 // Inicia Desempate1
 ////////////////////////////////////////////////////////////////////

 // Desempata en caso de carta mas alta

 int Desempate1( int Mano1[], int Mano2[])

 { //Abre desempate




 int hold;
 int temporal;
 for ( int x = 1; x < 5; x++)

 {

 for (int j = 1; j < 5; j++ )
 if ( Mano1[j] > Mano1[j + 1])
 {
 hold = Mano1[j];
 Mano1[j] = Mano1[j + 1];
 Mano1[j + 1] = hold;
 }

 for (int t = 1; t < 5; t++ )
 if ( Mano2[t] > Mano2[t + 1])
 {
 temporal = Mano2[t];
 Mano2[t] = Mano2[t + 1];
 Mano2[t + 1] = temporal;
 }
 }

 for (int d = 1; d <= 5; d++ )
 cout << Mano1[d] << " " << Mano2[d] <<endl;

 int no_as = 1;

 if( 1 == Mano1[1])
 {
 if( 1 != Mano2[1])
 return 1;
 else
 no_as = 1;
 }



 if( 1 == Mano2[1])
 {
 if( 1 != Mano1[1])
 return 2;
 else
 no_as = 1;
 }


 if ( 1 == no_as )
 {
 for ( int h = 5; h >= 1; h--)
 {
 if ( Mano1[h] > Mano2[h])
 {
 cout <<"\nRetorna 1" << endl;
 return 1;
 }
 else
 {
 if ( Mano1[h] < Mano2[h] )
 {
 cout << "\nRetorna 2." << endl;
 return 2;
 }
 }

 }

 cout << "\nRetorna 0." << endl;
 return 0;
 }



 } //Cierra desempate1



 /////////////////////////////////////////////////////////////////
 // Inicia Desempate2
 ////////////////////////////////////////////////////////////////

 // Desempata el caso de manos con un par cada una


 int Desempate2( int Mano1[], int Mano2[])
 {

 int par1 = 0;
 int par2 = 0;

 for ( int r = 1; r <= 4; r++ )
 for ( int s = r + 1; s <= 5; s++)
 {
 if (Mano1[r] == Mano1[s])
 par1 = Mano1[s];


 if (Mano2[r] == Mano2[s])
 par2 = Mano2[s];

 }

 if ( par1 > par2 )
 {
 if ( 1 == par2)
 return 2;
 else
 return 1;
 }
 else
 {
 if ( par1 < par2 )
 {
 if ( 1 == par1 )
 return 1;
 else
 return 2;
 }
 else
 return Desempate1(Mano1, Mano2);
 }


 }


 ////////////////////////////////////////////////////////////////////
 // Inicia Desempate3
 //////////////////////////////////////////////////////////////////////

 //Desempata en caso de manos con dos pares cada una



 int Desempate3( int Mano1[], int Mano2[])

 {

 // Aqui se buscan los pares de la mano1

 int par1 = 0;
 int par2 = 0;
 for ( int i = 1; i <= 4; i++)
 { // Abre for
 for ( int y = i + 1; y <= 5; y++)

 { // Abre for anidado
 if ( (Mano1[i] == Mano1[y]) && (0 == par1) )
 { // Abre if
 par1 = Mano1[i];
 } // Cierra if

 if ( (0 != par1) && (Mano1[i] == Mano1[y] && (Mano1[y] != par1)) )
 { // Abre if
 par2 = Mano1[i];
 } // Cierra if

 } // Cierra for anidado
 } // Cierra for


 // Aqui se determina el mayor par de la mano1

 int mayor1 = 0;
 int mayor1a = 0;

 if ( par1 > par2)
 { // Abre if
 mayor1 = par1;
 mayor1a = par2;
 } // Cierra if

 else // En el caso de que par2 sea mayor que o igual a par1
 {
 mayor1 = par2;
 mayor1a = par1;
 }



 // Aqui se determinan los pares de la mano2




 int par1m2 = 0;
 int par2m2 = 0;

 for ( int i = 1; i <= 4; i++)
 { // Abre for
 for ( int y = i + 1; y <= 5; y++)

 { // Abre for anidado
 if ( Mano2[i] == Mano2[y] && 0 == par1m2 )
 { // Abre if
 par1m2 = Mano2[i];
 } // Cierra if

 if ( (0 != par1m2) && ((Mano2[i] == Mano2[y]) && (Mano2[y] != par1m2)) )
 { // Abre if
 par2m2 = Mano2[i];
 } // Cierra if

 } // Cierra for anidado
 } // Cierra for



 // Aqui se determina el mayor de los pares de la mano 2



 int mayor2 = 0;
 int mayor2a = 0;

 if ( par1m2 > par2m2)
 { // Abre if
 mayor2 = par1m2;
 mayor2a = par2m2;
 } // Cierra if

 else // En el caso de que par2 sea mayor que o igual a par1
 { // Abre else
 mayor2 = par2m2;
 mayor2a = par1m2;
 } // Cierra else


 // Aqui se envia el mayor valor o se llama a desempate a la funcion
 // Desempate1

 // Aqui se ve el caso de que haya pares de ases

 if ( (1 == mayor1a) || (1 == mayor2a) )
 { // Abre if para par de ases
 cout <<"\nReconoce que hay un par de ases. " <<endl;

 if ( (1 == mayor1a) && (1 != mayor2a) )
 return 1;
 }
 else
 { // Abre else
 if ( (1 != mayor1a) && (1 == mayor2a) )
 return 2;
 } // Cierra if para par de ases



 if ( mayor1 > mayor2 )

 return 1;

 else
 { // Abre else
 if ( mayor2 > mayor1 )
 return 2;

 else // En caso de que los pares mayores sean iguales
 // Solo se consideran los casos en los que los pares menores son
 // diferentes, si son iguales se pasa a la ultima instruccion que
 // llama al desempate por la carta mas alta.
 { // Abre else
 if ( mayor1a > mayor2a)
 return 1;
 else
 {
 if ( mayor2a > mayor1a )
 return 2;
 }
 } // cierra else
 return Desempate1(Mano1, Mano2);

 } // Cierra else


 }




 //////////////////////////////////////////////////////////////////////
 // Inicia funcion Desempate4
 /////////////////////////////////////////////////////////////////////

 // Se desempatan las tercias

 int Desempate4( int Mano1[], int Mano2[])

 {
 // Aqui se determina el valor de las tercias

 int par1 = 0;
 int par2 = 0;

 for ( int i = 1; i <= 4; i++)
 { // Abre for
 for ( int y = i + 1; y <= 5; y++)

 { // Abre for anidado
 if ( Mano1[i] == Mano1[y] )
 { // Abre if
 par1 = Mano1[i];
 } // Cierra if

 if ( Mano2[i] == Mano2[y] )
 { // Abre if
 par2 = Mano2[i];
 } // Cierra if


 if (par1 > par2)
 return 1;
 else
 return 2;
 } // Cierra for anidado
 } // Cierra for


 return 1;

 }


 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion desempate 5
 ////////////////////////////////////////////////////////////////////////

 // Desempata corrida

 int Desempate5( int Mano1[], int Mano2[])

 {
 return Desempate1( Mano1, Mano2);
 }



 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion Desempate6
 /////////////////////////////////////////////////////////////////////////

 // Desempata color
 int Desempate6( int Mano1[], int Mano2[])
 { // Abre Desempate6

 return Desempate1(Mano1, Mano2);

 } // Cierra Desempate6


 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion desempate7
 ///////////////////////////////////////////////////////////////////////


 // Desempata full

 int Desempate7( int Mano1[], int Mano2[])
 { // Inicia la funcion Desempate7

 int parmano1 = 0; // No es necesario conocer los pares
 int parmano2 = 0;
 int terciamano1= 0;
 int terciamano2 = 0;

 // Aqui se se ordenan las manos para tomar los valores mas chicos
 int hold;
 int temporal;
 for ( int x = 1; x < 5; x++)

 {

 for (int j = 1; j < 5; j++ )
 if ( Mano1[j] > Mano1[j + 1])
 {
 hold = Mano1[j];
 Mano1[j] = Mano1[j + 1];
 Mano1[j + 1] = hold;
 }

 for (int t = 1; t < 5; t++ )
 if ( Mano2[t] > Mano2[t + 1])
 {
 temporal = Mano2[t];
 Mano2[t] = Mano2[t + 1];
 Mano2[t + 1] = temporal;
 }
 }

 // Aqui se consdera el caso en el que la tercia es menor y esta
 // por lo tanto al principio de Mano1
 if ( Mano1[1] == Mano1[3] )
 { // Abre if
 terciamano1 = Mano1[1];
 parmano1 = Mano1[4]; // El par es Mano1[4] y Mano1[5]
 } // Cierra if

 else
 { // Abre else para el caso en el que los primeros tres numeros
 // ordenados no son iguales
 terciamano1 = Mano1[4];
 parmano1 = Mano1[1];

 } // Cierra else



 if ( Mano2[1] == Mano2[3] )
 { // Abre if
 terciamano2 = Mano2[1];
 parmano2 = Mano2[4]; // El par es Mano1[4] y Mano1[5]
 } // Cierra if

 else
 { // Abre else para el caso en el que los primeros tres numeros
 // ordenados no son iguales
 terciamano2 = Mano2[4];
 parmano2 = Mano2[1];

 } // Cierra else


 // Aqui se desempatan las tercias

 if ( 1 == terciamano1 )
 { // Abre if de parmano1 = 1
 if ( 1 != terciamano2 )
 {
 return 1;
 }
 } // Cierra if de parmano1 = 1


 if ( 1 == terciamano2 )
 { // Abre if de parmano1 = 1
 if ( 1 != terciamano1 )
 {
 return 2;
 }
 } // Cierra if de parmano1 = 1


 // Si ninguna de las tercias es de ases se llega a esta etapa,
 // donde se considera la mayor tercia

 if ( terciamano1 > terciamano2 )
 return 1; // La terciamano1 es la mayor
 if ( terciamano2 > terciamano1 )
 return 2;

 // En este punto debe de haber retornado un valor, ya que las tercias
 // no pueden ser iguales

 } // Cierra la funcion Desempate7



 ////////////////////////////////////////////////////////////////////
 // Inicia la funcion Desempate8
 //////////////////////////////////////////////////////////////////////



 int Desempate8( int Mano1[], int Mano2[])
 { // Abre Desempate8

 return Desempate1(Mano1, Mano2);

 } // Cierra Desempate8



 //////////////////////////////////////////////////////////////////////
 // Inicia Desempate9
 /////////////////////////////////////////////////////////////////////

 int Desempate9( int Mano1[], int Mano2[])
 {
 return Desempate1( Mano1, Mano2 );
 }








12 comentarios:

  1. Muy buen aporte, estoy estudiando por el libro de Deitel y tu código me ayuda a entender como se hace este ejercicio. La verdad me aclara algunas cosas que yo no sabía como empezar a hacer.

    Muchas gracias por compartir tus conocimientos.

    Un saludo, Pablo

    ResponderEliminar
  2. Gracias a ti. Qué bueno que te sirvió. Saludos.

    ResponderEliminar
  3. man.. excelente aporte.. MONSTRUOSO EL CODIGO!! hace 3 horas que llevo partiendome la cabeza tratando de hacerlo por punteros..!! esa mierda yo sabia que era dificil..!! tambien estoy estudiando por el libro y hasta ahora todo lo que voy encontrando se hace mas dificil.. jaja..

    gracias...!

    atte: eduardo - venezuela

    ResponderEliminar
  4. Gracias, Eduardo, por tus palabras. La verdad el programa es bastante largo porque hay que hacer varios desempates de manos. Estoy a punto de resolver este programa en java y prometo que lo mejoraré. Muchos saludos.

    ResponderEliminar
  5. Hola!
    Yo lo he programado en Java, para hacer los ejercicios 7.30 al 7.33 de la 7a edición del libro de Deitel, donde la parte de barajar y repartir ya la tienes hecha en un código ejemplo.

    Para no crear un método para desempatar cada tipo de mano, lo que he hecho es que en el análisis de la mano, aparte de determinar que tipo de jugada ( una pareja por ejemplo), también se determina el valor (número), y el kicker/kickers, ya que si hay un empate con la carta más alta (kicker), se tiene en cuenta la carta más alta que sigue. Cada tipo de valor es numérico, así al comparar las manos de los jugadores solo será necesario ver cual tiene el valor numérico mayor, para determinar cual es la mano ganadora o si hay un empate. Todos estos valores los podemos meter en un arreglo y después almacenar este en un arreglo bidimensional, donde se almacenan todos los valores de la mano de cada jugador. Finalmente comparamos las manos de todos los jugadores y determinamos cual es el ganador o si hay un empate.
    Por ejemplo, una mano que tiene J-J-A-10-2 se podría traducir a un arreglo con los siguientes valores 1,9,12,8,0; el 1 indica que jugada es, en este caso es una pareja ( 0- carta alta, 1- pares, 2- dos pares, etc.), los valores siguientes son traducidos a partir de un arreglo con una lista ordenada de menor a mayor "Dos", "Tres", "Cuatro", "Cinco","Seis", "Siete", "Ocho", "Nueve", "Diez","Sota", "Reina", "Rey", "As".

    Lo he explicado muy por encima y un poco mal, pero creo que ya se entiende cual es la idea. Puede que no sea la mejor forma de hacerlo, pero es lo que se me ha ocurrido y ha funcionado bien.

    ResponderEliminar
  6. Muchas gracias, anónimo. La verdad me da gusto que me des ideas para mejorarlo. Yo lo quiero escribir también en java y desde que hice este me quedó la idea de escribirlo de otra forma. La que tú comentas suena interesante. Me hubiera gustado que me dijeras cuántas líeneas de código te salieron.
    Gracias y muchos saludos.

    ResponderEliminar
  7. Hola otra vez, soy el anónimo jeje.
    Sumando las lineas de código de cada clase son unas 593. Se debe tener en cuenta que he hecho lo que piden los ejercicios, por ejemplo el descarte.

    Un saludo

    ResponderEliminar
  8. ¡Hola de nuevo, anónimo! Pues sì que suena interesante. Estos problemas de las cartas son complicados. Ojalá ahora tenga algo de tiempo para hacer este mismo programa en java usando un poco la idea que pusiste. Gracias por el comentario y un saludo de regreso.

    ResponderEliminar
  9. Hola que tal! Antes que nada déjame felicitarte por tu blog, en verdad me ha sido de mucha ayuda para entender mejor el mundo de la programación. Recientemente me dejaron este mismo problema, pero en lenguaje Java. Ya le he dado varias vueltas, pero no me sale. Me gustaría que me ayudaras a traducir ese mismo código a lenguaje Java. En verdad te lo agradecería bastante! De antemano, Muchas Gracias!

    Saludos!

    ResponderEliminar
    Respuestas
    1. Mira. Yo creo que el único problema que puedes tener a la hora de hacer el cambio es de sintaxis. Estos lenguajes son muy parecidos. Fíjate que las funciones en C++ son muy parecidas a los métodos en Java. Sólo tienes que hacer eso, por cada función tienes que crear un método. Tal vez te cause alguna confusión las instrucciones cin y cout. cin se utiliza para recibir datos (como recibir un entero) y cout para imprimir un dato, digamos que en Java lo puedes hacer con System.out.printf(). Toda la estructura del programa se puede traducir fácilmente. Los ciclos, condicionales, asignaciones y operadores son los mismos.
      Ojalá te sirva. Cualquier detalle en particular, me dices.
      Saludos.

      Eliminar
  10. Hola crees que puedas hacer este trabajo....
    Utilizando todo lo aprendido en clases en el presente curso, implementar una solución para el siguiente juego recreativo:

    Implementar una carrera de Caballos, con 10 animales y sus jinetes. El avance de los caballos durante la carrera deberá ser de manera aleatoria utilizando distintos rangos de velocidad, donde influyen:
    -La velocidad original del animal
    -El peso que lleva de mas,
    -La destreza del jinete y
    -Las ultimas 2 carreras.
    Se deberá simular la carrera hasta obtener un ganador, un segundo puesto y un tercer puesto. Esta simulación podrá hacerse visualmente.

    Antes de que se realice la carrera existirán las apuestas. Las personas podrán apostar a ganador, a segundo puesto y a tercero o combinaciones. Dependiendo de cuantas apuestas haya, el monto acumulado de las apuestas más un premio por cada carrera será repartido como sigue:
    -Apuestas a ganador 25%
    -Apuestas a ganador y 2do puesto 30%
    -Apuestas a ganador, 2do y 3er puesto 45%
    Al final de cada carrera se anunciarán los ganadores de la misma, y se mostrara los pagos por las 3 categorías de apuestas.

    ResponderEliminar
  11. Estoy terminando este ejercicio de juego de poker del libro como programar en c c++ java deitel, lo estoy haciendo en c. Voy 220 lineas y no creo que llegue a 250. Ademas se puede introducir el numero de jugadores que jugaran la mano. Si a alguien le interesa cuando termine lo subo.

    ResponderEliminar

Related Posts Plugin for WordPress, Blogger...