Creacion de Archivo de Acceso Secuencial en C++

En esta entrada explico brevemente cómo crear un archivo de acceso secuencial en C++. Información más detallada puede encontrarse en el capítulo 14 de Cómo Programar en C++, de Deitel. Sin embargo, cuando tuve la necesidad de crear y leer archivos de datos, para trabajar con métodos numéricos, leí y adapté buena parte de la información que ahí viene. Como tengo esto en mi computadora pienso que no esta mal subirlo y que le pueda servir a alguien más. Este tipo de conocimientos son muy útiles, sobre todo, si, como en mi caso, necesitan generar una cantidad grande de información para después procesarla. Por otro lado, los usuarios de linux o unix pueden usar las herramientas que proporciona el sistema.Como se muestra Aqui

 #include <iostream>
 using namespace::std;
 // <iostream> se incluye, como en todos los programas
 // porque se usara entrada - salida
 # include <fstream>
 using std::ifstream;
 // El encabezado fstream permite crear objetos ofstream
 // e ifstream, que abren un archivo para salida y para
 // entrada, respectivamente.
 # include <cstdlib>

 int main()

 { // Abre main

 ofstream Mi_Archivo_Salida( "Mis_Datos.dat", ios::out);
// El constructor ofstream abre un archivo para escribir en el,
// es decir para enviar datos a ese archivo, mediante la creacion
// de un objeto llamado Mi_Archivo_Salida (ustedes le pueden poner el
// nombre que quieran).
// Se pasan dos argumentos al constructor del objeto, el nombre
// del archivo, que es por completo arbitrario - "Mis_Datos.dat".
// y el modo de apertura del archivo - ios::out -.
// Existen diversos modos de apertura de archivos que pueden ser usados
// a conveniencia en este caso ( apertura para envio de datos)
// a saber:
// ios::out Si el archivo "Mis_Datos.dat" existe, entonces se
// sobreescribira todo lo que entre a continuacion en ese
// archivo y se BORRARAN todos los datos previos; hay que
// estar prevenidos acerca de esto.
// Si "Mis_Datos.dat" no existe, entonces se creara un
// archivo nuevo con ese nombre.
// ios::app En este caso, si el archivo existe, entonces la nuevas
// entradas se colocan debajo de las que ya existen.
// Caso contrario, el archivo se crea.
// ios::ate Si el archivo existe, borra los datos existentes y escribe
// los nuevos, si no existe, entonces lo crea.
// ios::trunc Si el archivo existe, borra los datos existentes y escribe
// los nuevos, si no, lo crea.
// ios::in Si el archivo existe, entonces borra dos entradas del archivo
// cada vez y eventualmente sustituye todos los datos existentes,
// pero si introduce menos de la mitad de datos, entonces los nuevos
// estaran encima de los datos primitivos, hay que tener cuidado.
// Si el archivo no existe, no lo crea.

 if ( !Mi_Archivo_Salida )
 { // Abre if
 cerr << "\nEL ARCHIVO NO PUDO ABRIRSE." <<endl;
 exit( 1 );
 // Por esto se incluyo <cstdlib>
 } // Cierra if

 /* como se esta usando ios::out como modo de apertura de archivo
 podria pensarse que es inutil poner el caso de un fallo en la
 apertura, ya que de no existir se creara. Sin embargo puede ocurrir
 otro tipo de fallos, como lo que sucede si se trata, por ejemplo, de
 crear un archivo en un directorio en el que no tenemos permiso
 ( basta sustituir "Mis_Datos.dat" por "/home/Mis_Datos.dat" para
 que, en mi caso, mande el mensaje); tambien podria suceder que no
 hay memoria suficiente para crear el archivo o cualquier otra cosa,
 asi que es mejor incluir la posibilidad de fallo */

 cout << "\nIntroduzca los datos (EOF para terminar): " << endl;
 float datos;

 /* while se evalua true siempre que no se introduzca el caracter
 de fin de archivo. Esta forma compacta de recibir datos es
 dificil de entender cuando se encuentra por primera vez, pero es muy
 util. En los ejercicios de Kernighan y Ritchie del capitulo 1
 ( que se pueden ver en este mismo blog) se
 puede encontrar un buen numero de ejemplos acerca del poder de esta
 forma de usar while */

 while ( cin >> datos )
 { // Abre while
 Mi_Archivo_Salida << datos << endl;

 // asi como se introduce datos, se podria introducir mas elementos
 // dejando un espacio ' ' si fuera necesario.
 cout << endl;

 } // Cierra while

 return 0;

 }

Multiplicacion de Matrices en C++

Esta entrada es un poco más simple que Multiplicacion de matrices en C , en la cual se presentan las matrices impresas, pero espero que también sea más fácil de entender. Estos ejercicios no tienen nada que ver con las soluciones a los problemas de Deitel porque no aparecen en el libro, sin embargo sí es un ejercicio obligado, y como lo he escrito lo subo por si a alguien le resulta útil. Si quiere multiplicar matrices de tamaño arbitrario entonces sólo hay que modificar las constantes M, N y P.

#include <iostream>
using namespace::std;
#define M 2 // Hay que modificar estas entradas para
#define N 3 // cambiar el tamanio de las matrices
#define P 4

// Este programa multiplica una matriz de N filas por M columnas
// con una de M filas por P columnas

/////////////////////////////////////////////////////////////
//FUNCION RECIBE_ENTRADAS1
/////////////////////////////////////////////////////////////

void Recibe_Entradas1( int Matriz[][M])

{ // Abre funcion Recibe_Entradas1

cout << "\nAqui se reciben las entradas de la primera matriz. " << endl;
cout << "De " << N << " filas y " << M << " columnas. " << endl << endl;

for ( int i = 0; i < N; i++ )
for ( int j = 0; j < M; j++ )

{ // Abre for
cout << "Introduzca el renglon " << i + 1 << " y la columna " << j + 1 << endl;
cin >> Matriz[i][j];
} // Cierra for
} // Cierra funcion Recibe_Entradas1

////////////////////////////////////////////////////////////////////////////
// ABRE FUNCION RECIBE_Entradas2
///////////////////////////////////////////////////////////////////////////

void Recibe_Entradas2( int Matriz[][P])

{ // Abre funcion Recibe_Entradas2_

cout << "\nAqui se reciben las entradas de la segunda matriz. " << endl;
cout << "De " << M << " filas y " << P << " columnas" << endl << endl;

for ( int i = 0; i < M; i++ )
for ( int j = 0; j < P; j++ )
{ // Abre for
cout << "Introduzca el renglon " << i + 1 << " y la columna " << j + 1 << endl;
cin >> Matriz[i][j];
} // Cierra for
} // Cierra funcion Recibe_Entradas2

//////////////////////////////////////////////////////////////////////////
// LA FUNCION MULTIPLICACION
//////////////////////////////////////////////////////////////////////////

// Esta es la funcion que multiplica. El problema, cuando se ve
// por primera vez parece dificil. La clave, en este y en otros problemas
// consiste en simplificarlo. Los casos limite de matrices son vectores.
// Traten primero de diseñar un algoritmo para multiplicar un vector
// renglon por un vector columna. Para hacer esto es necesario que los
// dos tengan la misma longitud. Esa multiplicacion les va a dar un numero
// y solo necesitan un indice para recorrer todas las entradas.
// Si quieren ahora multiplicar el mismo vector renglon por una matriz
// que incluya 2, 3 o mas columnas van a obtener 2, 3 o mas numeros
// en un renglon. Para esto necesitan dos subindices, uno para recorrer
// columnas y otro para recorrer el renglon. Finalmente, si en lugar de
// multiplicar un renglon por la matriz multiplican una matriz de n renglones
// por otra matriz, necesitaran 3 subindices.

void Multiplicacion( int Matriz1[][M], int Matriz2[][P], int Matriz3[][P])

{ // Abre la funcion Multiplicacion

for ( int k = 0; k < N; k++)
{ // abre primer ciclo for
for ( int j = 0; j < P; j++)
{ // abre el segundo ciclo for

for ( int i = 0; i < M; i++ )
Matriz3[ k ][j ] += Matriz1[k][i]*Matriz2[i][j];

} // Cierra el segundo ciclo for
}

} // Cierra la funcion Multiplicacion


///////////////////////////////////////////////////////////////////////////
// Funcion IMPRIMIR
//////////////////////////////////////////////////////////////////////////

void Imprimir( int Matriz[][P])

{ // Abre la funcion Imprimir

cout << endl << endl<< "Esta es la matriz producto: " << endl << endl;

for ( int i = 0; i < N; i++ )
{ // Abre for

for ( int j = 0; j < P; j++)

{ // abre for anidado

cout << Matriz[i][j] <<" \t";

} // Cierra for anidado

cout << endl << endl;

} // Cierra for


cout << endl << endl;
} // Cierra la funcion Imprimir


/////////////////////////////////////////////////////////////////////
// AQUI SE DEFINE LA FUNCION MAIN
////////////////////////////////////////////////////////////////////

int main()

{ // Abre la funcion main

int Matriz1[N][M] = {{0}};
int Matriz2[M][P] = {{0}};
int Matriz3[N][P] = {{0}};

Recibe_Entradas1( Matriz1 );
Recibe_Entradas2( Matriz2 );

Multiplicacion( Matriz1, Matriz2, Matriz3);
Imprimir(Matriz3);

return 0;
}

Kernighan_Ritchie_2.1 (Valores Máximos y Mínimos de los Tipos de Datos en C)

Ejercicio 2.1 Escriba un programa que imprima los valores máximos y mínimos de los tipos de datos int, char, long, etc. de su computadora.

El lector está acostumbrado a los números enteros y reales de las matemáticas elementales. Almacenar cada uno de esos tipos en el lenguaje C requiere más o menos espacio de memoria dependiendo del tamaño de los números. Por ejemplo, representar el número 3,14159265358979323846 requiere más espacio que el almacenamiento de 20 ó -123. Para optimizar la memoria debe asignarse un tipo de dato a cada número dependiendo de su tamaño. En atención a esto tenemos los siguientes datos en C:

Los  tipos enteros:                         Memoria que los contiene

        char                                                 |-|-|

        short                                                |-|-|-|-|

        int                                                    |-|-|-|-|-|-|-|-|

        long                                                 |-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|

                                                       

Los tipos flotantes:

       float

       double

Los tipos de enumeración:

       enum

Los tipos de dirección:

       Apuntador

       Referencia

Los tipos estructurados:

      struct

      union

      Arreglos

Los tipos enteros guardan sólo números enteros, en tanto que los números float y double sirven para almacenar decimales.

Los tamaños relativos para los tipos de datos enteros son representados esquemáticamente en la tabla por el número de elementos de memoria. Esto no se debe de tomar tan en serio puesto que a fin de cuentas el tamaño de esos números depende de la plataforma en que se ejecute el programa (procesador, sistema operativo, compilador).  Como norma el estandar dice que los tipos short e int deben ser al menos de 16 bits y long de 32. Además short no es mayor que int, el cual a su vez no es mayor que long. A estos tipos se les puede aplicar los calificativos signed o unsigned. Siendo los unsigned números enteros no negativos. Conforme vayan apareciendo los tipos de datos se irán analizando cada uno de ellos. Por lo pronto para verificar los  valores máximos y mínimos de su computadora debe copiar, pegar, compilar y ejecutar el siguiente programa.

/* Este programa imprime los tipos maximos y minimos para los tipos int, char,
long, etc, en una computadora particular. Las constantes estan definidas en el
encabezado <limits.h> que en el libro de Kernighan y Ritchie se encuentra
descrito en el apendice B */ 

#include <stdio.h>
#include <limits.h>

int main()
{ // Abre main

printf("\nEl valor minimo del tipo char en esta computadora es: %d\n", CHAR_MIN);
printf("\nEl valor maximo del tipo char en esta computadora es: %d\n", CHAR_MAX);
printf("\nEl valor minimo del tipo int en esta computadora es: %d\n", INT_MIN);
printf("\nEl valor maximo del tipo int en esta computadora es: %d\n", INT_MAX);
printf("\nEl valor minimo del tipo long en esta computadora es: %d\n", LONG_MIN);
printf("\nEl valor maximo del tipo long en esta computadora es: %d\n", LONG_MAX);
printf("\nEl valor maximo del tipo unsigned int en esta computadora es: %d\n", UINT_MAX);

return 0;
} // Cierra main

__________________________________________________________________________________ 
Ahora hagamos un análisis del programa línea por línea para revisar cada instrucción.

/* Este programa imprime los tipos maximos y minimos para los tipos int, char,
long, etc, en una computadora particular. Las constantes estan definidas en el
encabezado <limits.h> que en el libro de Kernighan y Ritchie se encuentra
descrito en el apendice B */ 

Estas tres líneas son un comentario con información general sobre el programa. Recuerde que los comentarios en C empiezan con /* y terminan con */ Recuerde también que es una buena idea comentar los programas. Este comentario en particular hace referencia a un clásico de la programación en C: El Lenguage de Programación C, un libro de B. Kernighan y Dennis Ritchie, creadores del lenguaje.

#include <stdio.h>

Para incluir un encabezado cualquiera debe hacer uso de #include. A continuación debe utilizar el nombre del encabezado necesario. stdio.h incluye varias funciones y utilidades que serán necesarias. Siempre que use entrada o salida de datos debe incluirlo.

#include <limits.h>

Los tamaños máximos y mínimos de los tipos de datos en cualquier plataforma particular están definidos en este encabezado mediante las constantes CHAR_MIN, CHAR_MAX, etc.

int main()
{ // Abre main

La función main aparece en todos los programas. Se trata, como su nombre en inglés lo dice, de la función principal. Todas las funciones reciben y entregan datos. int es el tipo de datos que main entrega. Los paréntesis vacíos indican que la función main no recibe ningún dato. El cuerpo de main, como el de todas las funciones, está delimitado por llaves { } La forma de comentar que aparece aquí es nueva. El compilador pasa por alto todo lo que se encuentra después de //, estos caracteres inclusive. El comentario termina con el primer salto de línea. A pesar de que la forma estándar de comentar es usando /* */ practicamente todos los compiladores son capaces de reconocer comentarios con // (una forma de comentario propia del lenguaje C++)

printf("\nEl valor minimo del tipo char en esta computadora es: %d\n", CHAR_MIN);
printf("\nEl valor maximo del tipo char en esta computadora es: %d\n", CHAR_MAX);
printf("\nEl valor minimo del tipo int en esta computadora es: %d\n", INT_MIN);
printf("\nEl valor maximo del tipo int en esta computadora es: %d\n", INT_MAX);
printf("\nEl valor minimo del tipo long en esta computadora es: %d\n", LONG_MIN);
printf("\nEl valor maximo del tipo long en esta computadora es: %d\n", LONG_MAX);
printf("\nEl valor maximo del tipo unsigned int en esta computadora es: %d\n", UINT_MAX);

Estas líneas hacen uso de la función printf para imprimir los máximos y mínimos valores de algunos tipos de datos. Como hemos visto, la secuencia de escape \n indica nueva línea. Esto es, el cursor se coloca al inicio del siguiente renglón. Después de la instrucción printf todo lo que viene a continuación está contenido entre paréntesis, y termina con punto y coma. La estructura es printf( ); Todo lo que se coloque dentro de los paréntesis y entre comillas dobles se imprimirà, salvo que sea una secuencia de escape o una referencia a una variable. Para imprimir enteros es necesario usar %d entre las comillas, después de las comillas es necesario colocar una coma y la variable entera (o variables enteras separadas por comas).

return 0;

La función main retorna un entero. El entero que retorna es 0. Esta instrucción debe ir siempre al final del programa. Indica que se han terminado las instrucciones.

} // Cierra main

Con el cierre de las llaves se termina el cuerpo de main. __________________________________________________________________________________ 

Lo que aprendió: 

Los tipos de datos en C 

Los valores máximos y mínimos de cada tipo básico en su plataforma.

Los comentarios usando //

____________________________________________________________________________________________
Esta entrada forma parte del Curso de C con Programas Explicados Línea por Línea
Índice
Entrada Anterior
Entrada Siguiente

Sedgewick2.6 (Un Caso Particular del Algoritmo de Euclides)

Ejercicio 2.6  Obtener los valores que toman u y v cuando se invoca mcd con la llamada inicial mcd(12345, 56789).

   #include <iostream>
   using namespace std;

   int mcd(int u = 12345, int v = 56789);

 
   int main()

  {

   cout <<"\n\nSe muestran los valores que toma la funcion mcd cuando se invoca";
   cout <<" con los parametros ";
   cout       <<"12345 y 56789 " << endl;

   int m;

   m = mcd();

   cout <<"\nEl maximo comun divisor es: " << m << endl;

   return 0;

  }

  int mcd ( int u, int v)

  {

   int t;

   while ( u > 0 )

   {
   if ( u < v  )
   {
    t = u;
    u = v;
    u = v;
    v = t;

    cout <<"u vale: " << u << "\tv vale: " << v << endl;

   }

  u = u - v;

  }

  return v;

  }

Sedgewick2.5 (Convertir de Decimal a Binario en C++)

Este programa en C++ recibe un  entero decimal y lo convierte a binario. Es interesante analizar este problema mediante el mapeo de Bernoulli, el cual hace posible realizar esta conversión de otra manera. En tanto preparo ese programa, aquí va esta versión.

El algoritmo consta de los siguientes pasos:

1) Expresar el número x como una combinación lineal de potencias de dos

x = a0*2^0 + a1*2^1 + a2*2^2 + a3*2^3 + .....

Y entonces,

mientras x != 0 se hace lo siguiente

{

Si x es impar, entonces

      el siguiente coeficiente ai es 1

      se resta 1 a x

      se divide x entre 2

Si x es par, entonces

       el siguiente coeficiente ai es 0

       se divide x entre 2

}

 

Tal vez un ejemplo sencillo sea más ilustrativo, sea x = 5

5 = a0*2^0 + a1*2^1 + a2*2^2 + a3*2^3 + ....

como el numero x es impar, entonces a0 = 1

restando 1 en ambos lados de la ecuación se tiene

4 =  a1*2^1 + a2*2^2 + a3*2^3 + ....

después se divide entre 2 ambos lados

2 =  a1*2^0 + a2*2^1 + a3*2^2 + ....

en este caso x es par, por lo cual a1 = 0

se divide todo entre 2 y queda

1 = a2*2^0 + a3*2^1 +.....

en este caso x es impar, asi que a2 = 1

se resta 1 en ambos lados y se cumple la condición de que el número x es 0. El resultado es:

a0 = 1

a1 = 0

a2 = 1

y los otros coeficientes son cero. De esta forma se ha mostrado cómo convertir de decimal a binario un número. Este algoritmo es bastante sencillo, sin embargo imprimir el equivalente binario en forma correcta es bastante más complicado. El problema es que cuando escribimos lo hacemosde izquierda a derecha, pero los números en un sistema posicional deben escribirse de derecha a izquierda, esto crea un problema con la impresión en pantalla. He decidido no complicar el programa e imprimir el número en orden inverso con una advertencia al usuario.

 #include <iostream>
 using namespace::std;
 
 // Prototipo de funcion
 void Binario(int x);

 ///////////////////////////////
 // FUNCION MAIN
 ///////////////////////////////

 int main()
 {    // Abre main
 int numero;

 cout <<"\nIntroduzca un numero entero";
 cout <<" y se imprimira su equivalente en binario. " <<endl;
 cin >> numero;

 // Se llama a la funcion Binario
 Binario(numero);

 return 0;  
 }    // Cierra main

 /////////////////////////////
 // FUNCION BINARIO
 /////////////////////////////

 void Binario( int x )
 {    // Abre funcion Binario

 cout << "\nEste numero en binario se ha imprimido invertido";
 cout << "\nLEASE AL REVES!" <<endl;

 while ( 0 != x )
 {  // Abre while
 if ( 0 != x % 2 )
 {   // Abre if
 cout << "1";
 
 x -= 1;
 x /= 2;
 
 }   // Cierra if

 else // Si el numero es par
 {  // Abre else
 cout <<"0";
 
 x /= 2;
 }  // Cierra else
 }  // Cierra while

 cout <<endl <<endl;

 }    // Cierra funcion Binario

 

Sedgewick2.1 (Algorimo de Euclides en C++)

Máximo común divisor de dos números usando el algoritmo de Euclides
Este programa utiliza el hecho de que el máximo común divisor de un par de enteros es igual al máximo común divisor de el número menor y la diferencia entre el mayor y el menor. De esta forma el problema se puede ir reduciendo cada vez. Por ejemplo, el mcd(54,48) = mcd(48,6) = 6
o mcd(54,14) = mcd(14,40) = mcd(14, 26) = mcd(14, 12) = mcd(12, 2) = 2
Hay que observar que en la diferencia de los números puede ser mayor que el número menor (como la diferencia de 54 y 14, que es mayor a 14). Por sencillez, en el ciclo while de la función mcd se ordenan los números al final, de tal manera que al principio del ciclo la variable x es siempre el número mayor y la variable y es el menor.

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 * ESTE PROGRAMA CALCULA EL MAXIMO COMUN DIVISOR DE DOS NUMEROS +
 *                                                              +
 * LO QUE RECIBE: DOS NUMEROS ENTEROS                           +
 * LO QUE DEVUELVE: EL MAXIMO COMUN DIVISOR                     +
 *                                                              +
 * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  *                                                                            *
  *                               ALGORITMO:                                   *
  *                                                                            *
  *                      EN EL BLOQUE PRINCIPAL:                               *
  *  PEDIR DOS NUMEROS                                                         *
  *  RECIBIR LOS DOS NUMEROS                                                   *
  *                                                                            *
  *  SI LOS NUMEROS SON IGUALES                                                *
  *  EL MAXIMO CUMUN DIVISOR ES CUALQUIERA DE LOS NUMEROS                      *
  *                                                                            *
  *  SI ALGUNO DE LOS DOS NUMEROS ES IGUAL A CERO                              *
  *     EL MAXIMO COMUN DIVISOR ES EL NUMERO DISTINTO DE CERO                  *
  *                                                                            *
  *  DE LO CONTRARIO (CORRESPONDIENTE AL SI INMEDIATAMENTE PRECEDENTE)         *
  *     CALCULAR ES MAXIMO COMUN DIVISOR DE LOS NUMEROS (MEDITANTE GCD         *
  *____________________________________________________________________________*
  *  
  *                                                                            *
  *                          EN LA FUNCION MCD                                 *
  *                                                                            *
  *  RECIBIR UN PAR DE NUMEROS COMO ARGUMENTOS                                 *
  *  X  =  EL NUMERO MAYOR                                                     *
  *  Y  =  EL NUMERO MENOR                                                     *
  *                                                                            *
  *  MIENTRAS X > Y                                                            *
  *        SI X ES DIVISIBLE ENTRE Y                                           *
  *        {                                                                   *
  *        EL MAXIMO CUMUN DIVISOR ES X (LA FUNCION DEVUELVE EL CONTROL)       *
  *        }                                                                   *
  *                                                                            *
  *        DE LO CONTRARIO (SI U NO ES DIVISIBLE ENTRE Y)                      *
  *        {                                                                   *
  *        EL NUEVO MAYOR U = ANTIGUO MENOR                                    *
  *        EL NUEVO MENOR v = ANTIGUO MAYOR - ANTIGUO MENOR                    *
  *                                                                            *  
  *        SI Y > X {                                                          *   
  *        NUEVO MAYOR = Y                                                     *
  *        NUEVO MENOR = X  }                                                  *
  *        }                                                                   *
  *                                                                            *          
  *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/  
#include <iostream>
 using namespace std;

 int mcd(int, int );

 int  main()
 {          /*Abre main */

   int x, y;

   cout <<"\n\nIntroduzca tantos pares de numeros positivos  como quiera " <<endl;
   cout <<"para saber su maximo comun divisor. " << endl;
   cout << "\n(Teclee una letra para terminar). " << endl;

   while ( cin >> x && cin >> y )

   if ( x > 0 && y > 0 )
   cout << x << " " << y << " " << " su maximo comun divisor es : " << mcd(x,y) << endl;

   return 0;
  }     /*Cierra main */


 //////////////////////////////////////////////////////////////////
 // FUNCION MCD
 //////////////////////////////////////////////////////////////////

  int mcd(int u, int v)

  {
   int t;

   while ( u > 0)
   {

   if ( u < v )
   {
    t = u;
    u = v;
    v = t;
   }

   u = u - v;
  }
  
  return v;
  }

Deitel_C++_5.17 (Carrera entre la Liebre y la Tortuga)

Este es un programita divertido.  La carrera entre la liebre y la tortuga incluye algunas otras expresiones diferentes a las que menciona Deitel. Observar la carrera es entretenido.

 #include <iostream>
 using namespace::std;

 #include <cstdlib>


 const int Tamano_Arreglo = 70;

 void Imprime_Pista(char A[], int );
 int Avanza_Liebre( int );
 int Avanza_Tortuga(int );

 int main()
 { // Abre main

 cout << "\n\nESTE PROGRAMA SIMULA LA MEMORABLE CARRERA ENTRE LA ";
 cout <<"LIEBRE (L) Y LA TORTUGA (T)!" <<endl;
 cout <<"AMBAS INICAN EMPATADAS (E) EN LA CASILLA 1." <<endl;
 cout <<"\t\t\tHAGAN SUS APUESTAS! " << endl <<endl;

 srand(time(0));


 char Pista[Tamano_Arreglo + 1] = { 0, 'E', 0, 0 };
 int Posicion_Tortuga = 1;
 int tortuga = 1;
 int Posicion_Liebre = 1;
 int liebre = 1;
 int centinela = 0;
 int numero;
 int contador = 1;
 Imprime_Pista( Pista, Tamano_Arreglo );


 while ( 0 == centinela )
 { // Abre while

 cout <<"\nIntroduzca un numero: " << endl;
 cin >> numero;

 cout <<"\t\t\t\tBANG!" << endl;
 cout <<"\t\t\t Y ARRANCAN!" << endl;

 for ( int x = 1; x <= Tamano_Arreglo; x++ )
 {
 Pista[x] = 0;
 }

 Posicion_Tortuga = Avanza_Tortuga( Posicion_Tortuga );
 tortuga = Posicion_Tortuga;
 Posicion_Liebre = Avanza_Liebre( Posicion_Liebre );
 liebre = Posicion_Liebre;
 //cout << Posicion_Liebre <<endl;
 // cout << Posicion_Tortuga <<endl;
 // Descomentar


 if ( (1 <= Posicion_Liebre) && ( Tamano_Arreglo > Posicion_Liebre) )
 { // Abre if
 Pista[ Posicion_Liebre ] = 'L';
 } // Cierra if

 if ( 1 > Posicion_Liebre )
 {
 // cout << "Menor " <<endl;
 // Descomentar
 
 Posicion_Liebre = 1;
 Pista[Posicion_Liebre] = 'L';
 }
 if ((Posicion_Tortuga >= 1) && (Tamano_Arreglo > Posicion_Liebre ) )
 { // Abre if
 // cout << "entro a if " << endl;
 // Descomentar
 
 if ( Posicion_Tortuga == Posicion_Liebre )
 {
 Pista[ Posicion_Tortuga ] = 'E';
 }
 else
 {
 Pista[ Posicion_Tortuga ] = 'T';
 }
 } // Cierra if

 if ( Posicion_Tortuga < 1 )
 {
 Posicion_Tortuga = 1;
 if ( 1 == Posicion_Liebre )
 Pista[Posicion_Tortuga] = 'E';
 else
 Pista[Posicion_Tortuga] = 'T';
 }

 if ( Posicion_Liebre >= Tamano_Arreglo )
 { // Abre if
 centinela = -1;
 if ( Posicion_Tortuga> Tamano_Arreglo)
 cout << "\nQUE CIERRE! LA LIEBRE Y LA TORTUGA EMPATARON! " <<endl;
 else
 cout <<"\nNI HABLAR, GANO LA LIEBRE! " <<endl;

 Pista[Tamano_Arreglo] = 'L';
 } // Cierra if


 if ( Posicion_Tortuga >= Tamano_Arreglo )
 { // Abre if
 centinela = -1;
 if ( Posicion_Liebre < Tamano_Arreglo)
 {
 Pista[Tamano_Arreglo] = 'T';
 cout <<"\nZANAHORIA Y LECHUGAS FRESCAS PARA LA TORTUGA QUE SE LLEVA ";
 cout <<"LA COMPETENCIA! BRAVO! " << endl;

 }
 else
 {
 Pista[Tamano_Arreglo] = 'E';
 cout <<"\nEN UN DRAMATICO CIERRE LA TORTUGA Y LA LIEBRE EMPATAN! "<<endl;
 }
 } // Cierra if


 Imprime_Pista( Pista, Tamano_Arreglo );

 if ( 'E' == Pista[Posicion_Tortuga])
 { // Abre if

 switch (contador)

 { // Abrre switch
 case 1:
 {
 cout <<"\aOUCH! LA TORTUGA TRAMPOSA HA MORDIDO A LA LIEBRE! " << endl;
 contador++;
 break;
 }
 case 2:
 {
 cout <<"\aOUCH! NO SE VALE! LA TORTUGA VUELVE A HACERLO!" << endl;
 contador++;
 break;
 }
 case 3:
 {
 cout<<"\aOUCH!ESTO YA ES COSTUMBRE, VUELVEN A MORDER A LA LIEBRE!" << endl;
 contador++;
 break;
 }
 default:
 {
 cout<< "\aOUCH! PERO DE QUE SE TRATA?!!" <<endl;
 break;
 }
 } // cierra switch

 } // Cierra if

 } // Cierra centinela
 return 0;

 } // Cierra main


 //////////////////////////////////////////////////////////////
 // INICIA LA FUNCION IMPRIME PISTA
 ////////////////////////////////////////////////////////////////

 void Imprime_Pista( char A[], int n)

 { // Abre Imprime pista

 cout <<"***";
 for ( int i = 1; i <= n; i++ )
 { // Abre for
 if ( 0 == A[i] )
 cout << " ";
 else
 cout << A[i];
 } // Cierra for

 cout <<"****";
 cout << endl;

 } // Cierra Imprime pista


 /////////////////////////////////////////////////////////////////////
 // INICIA AVANZA LIEBRE
 ////////////////////////////////////////////////////////////////////

 int Avanza_Liebre ( int l )

 { // Abre Avanza Liebre
 srand(time(0));
 int ruleta;
 ruleta = 1 + rand() % 10;

 //cout << "ruleta = " << ruleta << endl;
 //quitar este comentario para ver como se mueve esta variable
 
 if ( 2 >= ruleta )
 return l;

 if ( 4 >= ruleta )
 return (l + 9);

 if ( 5 >= ruleta )
 return l - 12;

 if ( 8 >= ruleta )
 return l + 1;

 if ( 10 >= ruleta )
 return l - 2;

 } // Cierra Avanza Liebre



 ///////////////////////////////////////////////////////////////////
 // INICIA AVANZA TORTUGA
 ////////////////////////////////////////////////////////////////////

 int Avanza_Tortuga ( int t )

 { // Abre Avanza tortuga
 srand(time(0));
 int dados = 1 + rand() % 10;

 // cout <<"dados = " << dados << endl;;
 // Descomentar para ver la variable dados
 
 if ( 5 >= dados )
 return (t + 3);

 if ( 7 >= dados )
 return (t - 6);

 if ( 10 >= dados )
 return (t + 1);

 } // Cierra Avanza tortuga

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 );
 }