Version:0.9
StartHTML:0000000105
EndHTML:0000017219
StartFragment:0000000152
EndFragment:0000017185
/******************************************************/
/*************** Isidro Pastor Jorda ******************/
/******************************************************/
/****************** Telematica ************************/
/******************************************************/
/************* Practica 7 Ejercicio 7 *****************/
/******************************************************/
#include <iostream.h>
#include <stdlib.h>
#include <string>
#include <time.h>
const int EQUIPOS = 10;
const int PARTIDOS = (EQUIPOS - 1) * 2 ;
struct dato
{
string nombre;
int puntos;
int ganados;
int empatados;
int perdidos;
int favor;
int contra;
};
typedef dato Vector[EQUIPOS];
/* Prototipos de funciones */
void GeneraAleatorios(Vector tabla);
void VerResultado(Vector tabla);
int Aleatorio( int downlim, int uplim );
void OrdenaDescendenteV(Vector v);
int PosMaximoV(Vector v);
void CopiaVector (Vector vaux, Vector v);
int main()
{
srand(time(NULL)); // inicializamos la funcion de aleatorios con semilla time(NULL)
Vector tabla,aux;
char opcion;
cout << " Generador de listas de clasificacion para una liga de futbol de " << EQUIPOS << " equipos \n" ;
/* Inicializacion del nombre de los equipos */
tabla[0].nombre = " Valencia CF ";
tabla[1].nombre = " Real Madrid ";
tabla[2].nombre = " Barcelona ";
tabla[3].nombre = " Zaragoza ";
tabla[4].nombre = " Ath. Bilbao ";
tabla[5].nombre = " Villareal ";
tabla[6].nombre = " Espanyol ";
tabla[7].nombre = " Sevilla ";
tabla[8].nombre = " Real Sociedad ";
tabla[9].nombre = " Deportivo ";
GeneraAleatorios(tabla);
OrdenaDescendenteV(tabla);
cout << endl;
cout << "\n Primer clasificado " << tabla[0].nombre << " con " << tabla[0].puntos << " puntos. \n";
cout << "\n Ultimo clasificado " << tabla[EQUIPOS - 1].nombre << " con " << tabla[EQUIPOS - 1].puntos << " puntos. \n";
cout << "\n Quieres ver la clasificacion completa? (S/N)-> ";
cin >> opcion;
if ( opcion == 'S' || opcion == 's')
{
VerResultado(tabla);
}
cout << endl << endl;
system("PAUSE");
return 0;
}
void GeneraAleatorios(Vector tabla)
{
int i;
for (i = 0; i < EQUIPOS; i++)
{
cout << "\n Generando datos para el equipo " << tabla[i].nombre ;
tabla[i].ganados = Aleatorio( 0, PARTIDOS + 1);
tabla[i].perdidos = Aleatorio( 0, PARTIDOS - tabla[i].ganados + 1);
tabla[i].empatados = PARTIDOS - (tabla[i].ganados + tabla[i].perdidos);
tabla[i].puntos = ( tabla[i].ganados * 3 )+ tabla[i].empatados; // los ganados valen 3 puntos empatados 1
tabla[i].favor = Aleatorio( 0, PARTIDOS * 5);
tabla[i].contra = Aleatorio( 0, PARTIDOS * 5 );
}
}
void VerResultado(Vector tabla)
{
int i;
cout << endl << " " << " Equipo " << "\t \t" << "PG " << "\t" << "PE " << "\t"<< "PP " << "\t" << "GF" << "\t" << "GC " << "\t" << "Ptos " ;
cout << endl << " ------------------------------------------------------------------------" ;
for (i=0; i< EQUIPOS ; i++)
{
cout << endl;
if (i < 10 )
cout << ' ' ;
cout << i+1 << ".- " << tabla[i].nombre << "\t" << tabla[i].ganados << "\t" << tabla[i].empatados << "\t"<< tabla[i].perdidos << "\t" << tabla[i].favor << "\t" << tabla[i].contra << "\t" << tabla[i].puntos ;
}
}
/************************************************************************************
* Funcion: Aleatorio
* Descripcion: Funcion que nos da un numero aleatorio comprendido
* entre un limite inferior, downlim (incluido) y un limite
* superior (excluido) uplim
*
* Parametros
* Nombre E/S Descripcion
* ------- ----- -----------
* dowlim float Limite Inferior (Incluido)
* uplim float Limite Superior (Excluido)
*
* Valor Devuelto:
* La funcion devuelve un valor float correspondiente al numero aleatorio
* que ha generado la funcion entre un limite inferior (incluido) y uno superior
*
************************************************************************************/
int Aleatorio( int downlim, int uplim ) // Función que genera numeros aleatorios
{
int aleat;
if ( downlim < uplim)
{
do
{
aleat = rand();
}
while ( aleat < downlim || aleat >= uplim );
}
else
aleat = 0;
return aleat;
}
/***********************************************************************************
* Funcion: OrdenaDescendenteV
* Descripcion: Funcion que ordena de manera descendente los datos almacenados
* en el vector de entrada
*
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E vector que se piensa ordenar
*
*
* Valor devuelto:
* void, la funcion no devuelve el valor pero modifica el vector.
***********************************************************************************/
void OrdenaDescendenteV(Vector v)
{
Vector vaux; // Vector auxiliar para ir ordenandolo ahi
int pmax; // variable para ir almacenando la posicion donse se encuentra el maximo del vector
/* Vamos a recorrer el vector en orden normal, buscaremos maximos
dentro de ese vector y los iremos guardando en el vector auxiliar
empezando desde la posicion mas baja del vector. */
for (int i = 0;i < EQUIPOS ; i++ )
{
pmax = PosMaximoV(v);// llamamos a PosMaximoV y nos dara la posicion donde esta el maximo del vector
vaux[i] = v[pmax] ; // Copiamos en vaux el valor del maximo numero del vector dado
v[pmax].puntos = 0; // Sobreescribimos este valor para eliminarlo del vector y volver a llamar a la funcion
}
/* Llamamos a una funcion que nos copia el contenido de un vector en otro
en nuestro caso queremo copiar el contenido de vaux en v */
CopiaVector(vaux, v);
return;
}
/***********************************************************************************
* Funcion: CopiaVector
* Descripcion: Funcion que copia el contenido del vector vaux en el vector v
*
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* vaux E Vector del que queremos hacer una copia
* v E/S Vector al cual copiaremos el contenido de vaux
*
* Valor devuelto:
* Funcion void que no devuelve nada, copia el contenido de vaux en v
***********************************************************************************/
void CopiaVector (Vector vaux, Vector v)
{
for (int i = 0; i < EQUIPOS; i++)
v[i] = vaux[i];
return;
}
/******************************************************************
* Funcion: PosMaximoV
* Descripcion: Funcion que nos devuelve la posicion donde se encuentra
* el valor maximo almacenado en un vector.
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E Vector a recorrer para encontrar el maximo
*
*
* Valor devuelto:
* La funcion devuelve un entero que es la posicion donde se encuentra
* almacenada en el vector el dato de mayor valor
*******************************************************************/
int PosMaximoV(Vector v)
{
int pos; // variable auxiliar para almacenar la posicion del dato mas alto
pos = 0;
for (int i=1; i<EQUIPOS; i++)
{
if (v[pos].puntos < v[i].puntos ) // Comparamos el vector numero a numero, si es mas grande que nuestro maximo almacenamos su posicion
pos = i;
/*if ( v[i-1].puntos = v[i].puntos )
{
if (v[pos].favor < v[i].favor)
pos = i;
} */
}
return pos;
}