Version:0.9
StartHTML:0000000105
EndHTML:0000024884
StartFragment:0000000152
EndFragment:0000024850
/******************************************************/
/*************** Isidro Pastor Jorda ******************/
/******************************************************/
/****************** Telematica ************************/
/******************************************************/
/************* Practica 6 Ejercicio 3 *****************/
/******************************************************/
#include <iostream.h>
#include <stdlib.h>
const int FILAS = 3;
const int COLUMNAS = 3;
typedef int Matriz[FILAS][COLUMNAS];
typedef int Vector[FILAS*COLUMNAS];
void InicializaMatriz(Matriz M, int reset);
void GrabarMatriz(Matriz M);
void MostrarMatriz(Matriz M);
void CalculaTraspuesta (Matriz A, Matriz T);
int MediaMatriz(Matriz M);
void MaxMinMatriz(Matriz A,int & maximo,int & minimo) ;
void Concatena(Matriz M, Vector v);
void MostrarV(Vector v);
int MatrizToVector (int i,int j);
int main()
{
bool salir = false;
int opcion, maximo, minimo, media, i, j, pos;
char opcion2;
Matriz A, traspuesta;
Vector v;
InicializaMatriz(A, 0); // Inicializamos la matriz A a ceros
InicializaMatriz(traspuesta, 0); // Inicializamos la matriz traspuesta a ceros
Concatena(A, v); // Como A es aqui una matriz de ceros nos sirve para inicializar v
do
{
/* Menu del programa que se mostrara por pantalla */
cout << " ******************** M E N U ****************************"<< endl;
cout << " * 1.- Presentacion en pantalla de la matriz tabulada *"<< endl;
cout << " * 2.- Calculo de la traspuesta y presentacion *"<< endl;
cout << " * 3.- Media de los elementos, maximo y minimo *"<< endl;
cout << " * 4.- Representar en un vector de " << FILAS*COLUMNAS << " elementos *"<< endl;
cout << " * 5.- Devolver valor de i,j del vector concatenado *"<< endl;
cout << " * 6.- Salir del programa *"<< endl;
cout << " *********************************************************"<< endl;
cout << endl << " Elige una opcion -> " ;
cin >> opcion;
if ( opcion != 6) // usaremos esto para preguntar por una nueva matriz cada vez que elijamos opcion
{
cout << " Quieres introducir una nueva matriz ? ( S/N )-> ";
cin >> opcion2;
}
else
opcion2 = 'N';
if ( opcion2 == 's' || opcion2 == 'S' ) // Si queremos introducir una nueva mantriz llamaremos a la funcion correspondiente
{
cout << " Introduce los " << FILAS*COLUMNAS << " valores para la matriz todos seguidos: \n";
GrabarMatriz( A );
}
switch (opcion)
{
case 1: // Presentacion en pantalla de la matriz tabulada
cout << " La matriz tabulada resultante es: \n \n";
MostrarMatriz(A);
break;
case 2: // Calculo de la traspuesta y presentacion
CalculaTraspuesta (A, traspuesta); // Calculamos la traspuesta con la funcion
cout << " La matriz traspuesta de ";
MostrarMatriz(A); // Mostramos la matriz inicial
cout << " es la matriz ";
MostrarMatriz(traspuesta); // Mostramos la matriz traspuesta
break;
case 3: // Media de los elementos, maximo y minimo
media = MediaMatriz(A);
MaxMinMatriz(A, maximo, minimo);
cout << " La media de los elementos es -> " << media << endl ;
cout << " El maximo de los elementos es -> " << maximo << endl;
cout << " El minimo de los elementos es -> " << minimo << endl;
break;
case 4: // Representar en un vector de FILAS*COLUMNAS elementos
Concatena(A, v); // Concatenamos la matriz en el vector
cout << " El vector concatenado es: ";
MostrarV(v);
cout << endl << endl;
break;
case 5:
Concatena(A, v); // Concatenamos la matriz introducida con el vector v
do // Bucle para control de errores y asegurarnos que el numero introducido es correcto
{
cout << " Dame las coordenadas i y j -> ";
cin >> i >> j;
cout << endl;
if ( i >= FILAS) // Mensajes de error si nos excedemos en el numero de filas o columnas
cout << " Error las filas introducidas exceden de la matriz " << endl;
if (j >= COLUMNAS)
cout << " Error las columnas introducidas exceden de la matriz " << endl;
}
while ( i >= FILAS || j >= COLUMNAS); // repetimos mientras i y j sean mayores que los valores de la matriz
pos = MatrizToVector (i, j);// Llamada a la funcion que devuelve la posicion del vector
cout << " El valor buscado se encuentra en la posicion " << pos << " del vector y vale " << v[pos] << endl ;
break;
case 6: // Salir del programa
salir = true; // Activamos el "centinela" para salir del programa y termina su ejecucion
break;
default: // En caso que la opcion elegida no sea correcta mostraremos mensaje y repetiremos bucle
cout << endl << " Error en la eleccion " << endl;
break;
}
if (opcion != 6)
{
system("PAUSE"); // Pausamos la salida por pantalla hasta pulsar una tecla
system("cls"); // Limpiamos pantalla para dibujar de nuevo el menu
}
}
while (!salir);
cout << endl << " Fin del Programa -> Isidro Pastor Jorda 2002 <- " << endl << endl;
system("PAUSE");
return 0;
}
/******************************************************************
* Funcion: InicializaMatriz
* Descripcion: Funcion que inicializa una matriz al valor de reset
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E/S Matriz a inicializar
* reset E Valor usado para inicializar la matriz
*
* Valor devuelto:
* void, la matriz no devuelve nada pero modifica el vector
*******************************************************************/
void InicializaMatriz(Matriz M, int reset)
{
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
M[i][j] = reset;
return;
}
/******************************************************************
* Funcion: GrabarMatriz
* Descripcion: Funcion para grabar en la matriz los datos introducidos
* por teclado.
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E/S Matriz que iremos asignando valores leidos por teclado
*
*
* Valor devuelto:
* void, no devuelve nada la funcion pero modifica la matriz M
*******************************************************************/
void GrabarMatriz(Matriz M)
{
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
cin >> M[i][j];
}
/******************************************************************
* Funcion: MostrarMatriz
* Descripcion: Funcion para mostrar por pantalla la matriz tabulada
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz a mostrar por pantalla
*
*
* Valor devuelto:
* void, la funcion solo muestra por pantalla la matriz
*******************************************************************/
void MostrarMatriz(Matriz M)
{
cout << endl << endl;
for (int i = 0; i < FILAS; i++ )
{
for (int j = 0; j< COLUMNAS; j++)
{
if (M[i][j] < 10)
cout << " " << M[i][j];
else
cout << " " << M[i][j];
}
cout << endl;
}
cout << endl;
}
/******************************************************************
* Funcion: CalculaTraspuesta
* Descripcion: Funcion para intercambiar filas por columnas de una matriz
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz original de la que queremos calcular la traspuesta
* T E/S Matriz donde iremos almacenando los valores de la traspuesta
*
* Valor devuelto:
* void, la funcion no devuelve nada pero se modifica la matriz T
*******************************************************************/
void CalculaTraspuesta (Matriz M, Matriz T)
{
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
T[j][i] = M[i][j];
return;
}
/**********************************************************************************
* Funcion: MediaMatriz
* Descripcion: Funcion para calcular la media de los valores de una matriz
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz de la que queremos calcular la media de sus valores
*
*
* Valor devuelto:
* La funcion devuelve un entero que sera la media de los valores de la matriz
***********************************************************************************/
int MediaMatriz(Matriz M)
{
int aux;
aux = 0;
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
aux = aux + M[i][j];
return (aux / FILAS*COLUMNAS);
}
/******************************************************************
* Funcion: MaxMinMatriz
* Descripcion:Funcion que modifica los valores de max y min, que tomaran
* los valores maximo y minimo de la matriz
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz de la que queremos obtener los datos
* max E/S variable donde almacenamos el valor maximo
* min E/S variable donde almacenamos el valor minimo
*
* Valor devuelto:
* void, la funcion no devuelve nada pero modifica max y min
*******************************************************************/
void MaxMinMatriz(Matriz M,int & max,int & min)
{
min = M[0][0]; // Inicializamos maximo y minimo por si no estuvieran antes
max = M[0][0];
for (int i = 1; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
{
if (M[i][j] > max)
max = M[i][j];
if (M[i][j] < min)
min = M[i][j];
}
}
/******************************************************************
* Funcion:Concatena
* Descripcion: Funcion que concatena una matriz en un vector
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz origen de los datos
* v E/S Vector destino de la concatenacion
*
* Valor devuelto:
* void, la funcion no devuelve nada pero modifica el vector v
*******************************************************************/
void Concatena(Matriz M, Vector v)
{
int k; // Variable indice para el vector v
k = 0;
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j < COLUMNAS; j++)
{
v[k] = M[i][j];
k++;
}
}
/*******************************************************************************
* Funcion: MatrizToVector
* Descripcion: Funcion que nos devuelve dada la posicion de la matriz
* indicando Filas y columnas a su correspondiente en un
* vector concatenado con los valores de la matriz
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* i E Valor de la fila de la matriz
* j E Valor de la columna de la matriz
*
* Valor devuelto:
* Devuelve un entero correspondiente al indice donde se encuentra
* el valor de i,j de la matriz en un vector v concatenado con la matriz
*******************************************************************************/
int MatrizToVector (int i,int j)
{
int aux;
aux = ((i * COLUMNAS)+ j );
return(aux);
}
/***********************************************************************************
* Funcion: MostrarV
* Descripcion: Funcion que unicamente muestra por pantalla el contenido
* de nuestro vector.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E Vector a mostrar por pantalla, no se modifica en la funcion
*
*
* Valor devuelto:
* La funcion solo muestra por pantalla, es void y no se modifica nada
***********************************************************************************/
void MostrarV(Vector v)
{
for (int i = 0; i < FILAS*COLUMNAS; i++)
cout << " " << v[i];
return;
}