/***********************************************************************
 * Soluciones propuestas para resolver el examen de ATDI del día 010207* 
 * Francisco Javier Garcia Castellano 2007                             *
 ***********************************************************************/

/***********************************************************************/ 
//BIBLOTECAS

#include <stdio.h>
#include <stdlib.h> //Para usar rand() y generar numeros aleatorios



/***********************************************************************/ 
//CONSTANTES
#define MAX 100 //Maximo tamaño para vectores y matrices


/***********************************************************************/ 
//FUNCIONES


/*---------------------------------------------------------------------*/ 
/** Procedimiento que devuelve los dos numeros que mas se repiten en 
   una serie de numeros enteros. Si la serie fuera multimodal, devuelve 
   las dos primeras modas que encuentre.
   

   Parametros:
    serie: vector de numeros enteros con la serie a estudiar
    n: tamaño del vector
    moda: Variable por referencia donde se guarda la moda
    moda2: Variable por referencia donde se guarda el segundo valor que 
           mas se repita. Si la serie es multimodal devuelve una segunda 
           moda.
*/
void modas (int serie[], int n, int *moda, int *moda2){

	int i,j;
	int frecuencias[MAX]; //Repeticiones del elemento i-esimo de la serie
	int max=0, max2=-1; //Posiciones de ls maximas frecuencias (el maximo sera el primero y
			    //el segundo maximo ya le asignaremos un valor)
	
	//Contamos las repeticiones del elemento i-esimo 
	for (i=0;i<n;i++) {
	  //Inicialmente la frecuencia es cero
	  frecuencias[i]=0;
	  
	  //Incrementamos las frecuencias por cada repeticion encontrada
	  for (j=i;j<n;j++)
		if (serie[i]==serie[j])
			frecuencias[i]++;

	  //Nos quedamos con el maximo
	  if (frecuencias[i]>frecuencias[max]) {
		//Guardamos el anterior max como el segundo max
		if (serie[i]!=serie[max])
		 max2=max;

		//Guardamos el nuevo max
		max=i;
	 }

	  //Nos quedamos con el segundo maximo, para ello primero
	  //miramos que no sea el mismo numero que el maximo
	  if (serie[i]!=serie[max]){
	   
	   //Si max2 es -1, esta sin incializar por lo que lo inicializamos
	   //con el primer valor distinto del max
	   if (max2==-1)
	      max2=i;

	   //Miramos si la frecuencia es mayor que el segundo maximo
	   else if (frecuencias[i]>frecuencias[max2]) 
	      max2=i;
 	  }
	}//fin for i

	//caso de que haya un solo numero
	if (max2==-1) max2=max;

	//Guardamos las modas encontradas
	*moda=serie[max];
	*moda2=serie[max2];
}

/*---------------------------------------------------------------------*/
/** Funcion que devuelve el crapulo del numero que se le pasa como parametro.
    Version corta.
    Parametros:
	n: numero entero del que se quiere conocer el crapulo.
*/
int crapulo(int n) {

	//El crapulo es el modulo 9 del numero, con dos excepciones:
	//-Si el numero es cero el crapulo es cero
	//-Si es disinto de cero y el resto de dividir por 9 es cero, 
	//  el crapulo es 9.
	return (n%9==0) ? ( (n==0)?0:9 ): (n%9);
}

/*---------------------------------------------------------------------*/
/** Funcion que devuelve el crapulo del numero que se le pasa como parametro.
    Version recursiva.
    Parametros:
	n: numero entero del que se quiere conocer el crapulo.
*/
int crapuloR(int n) {
	int aux;
	
	if (n<10)
	  //Si n es menor que 10, es crapulo de si mismo (caso base)
	  return n;
	else
	  //Si n es mayor que 10, el crapulo es la suma del resto de dividir 
	  //el número por 10 (extraccion de un digito) mas la suma del cociente
	  aux=n%10+crapuloR(n/10);
	
	//Tenemos en cuenta aquellos números que tras sumar sus dígitos, nos sale
	//una suma mayor que 10
	if (aux>9)
	  return crapuloR(aux);
	else
	  return aux;
}


/*---------------------------------------------------------------------*/
/** Funcion que devuelve el crapulo del numero que se le pasa como parametro.
    Version Iterativa.
    Parametros:
	n: numero entero del que se quiere conocer el crapulo.
*/
int crapuloI(int n) {
	int aux=0; //variable donde vamos a ir guardando el crapulo

	//si n es menor que 10, ya lo teneos calculado
	if (n<10) return n;
		
	//Calculamos el crapulo para numeros mayores que 9
	while (n>9) {
	  aux=aux+n%10; //Sumamos un digito de n
	  n=n/10; //Le quitamos ese digito a n

	  //Si no quedan más que un digito en n, el crapulo esta
	  //"casi" calculado
	  if (n<10){
		//Le sumamos al crapulo el ultimo digito
		aux=aux+n;
		
		//Si el carpulo calculado es mayor que 9, volvemos
		//a empezar
		if (aux>9) {
		  n=aux;
		  aux=0;
		}
	  }
	}//fin while
	
	//Devolvemos el crapulo calculado
	return aux;
}

/*---------------------------------------------------------------------*/
/**Funcion que devuelve el maximo de una matriz.
Parametros:
matriz: Matriz de numeros reales.
n: numero de filas de la matriz.
m: numero de columnas de la matriz.*/
double max(double matriz[100][100], int n, int m) {
	int i,j;
	double maximo=matriz[0][0]; //el maximo inicialmente es el primero

	//Buscamos y guardamos aquellos números que 
	//sean mayores al mayor valor encontrado
	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			if (matriz[i][j]>maximo)
				maximo=matriz[i][j];

	return maximo;
}

/*---------------------------------------------------------------------*/
/**Funcion que devuelve el minimo de una matriz.
Parametros:
matriz: Matriz de numeros reales.
n: numero de filas de la matriz.
m: numero de columnas de la matriz.*/
double min(double matriz[100][100], int n, int m) {
	int i,j;
	double minimo=matriz[0][0]; //el min inicialmente es el primero

	//Buscamos y guardamos aquellos números que 
	//sean menores al menor valor encontrado
	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			if (matriz[i][j]<minimo)
				minimo=matriz[i][j];

	return minimo;
}

/*---------------------------------------------------------------------*/
/**Funcion que devuelve la media de una matriz.
Parametros:
matriz: Matriz de numeros reales.
n: numero de filas de la matriz.
m: numero de columnas de la matriz.*/
double media(double matriz[100][100], int n, int m) {
	int i,j;
	double suma=0;

	//Calculamos la suma de todos los elementos de la matriz
	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			suma=suma+matriz[i][j];

	//devolvemos la suma de todos los elementos, divididos
	//por el número de elementos
	return suma/(n*m);
}

/*---------------------------------------------------------------------*/
/*---------------------------------------------------------------------*/
int main(){

	int i,j;
	int filas=10,columnas=10;
	double matriz[MAX][MAX];
	int vector[MAX];
	int moda1,moda2;


	//Leemos el numero de filas que tendrá la matriz y el vector
	do {
		printf("\nDame el numero de filas en la matriz y elementos del vector=");
	    	scanf("%d",&filas);	
	} while ((filas<1)||(filas>MAX));

	//Leemos el numero de columnas que tendrá la matriz
	do {
		printf("\nDame el numero de columnas=");
	    	scanf("%d",&columnas);	
	} while ((columnas<1)||(columnas>MAX));


	
	//Inicializo la matriz con num aleatorios entre 0 y 9
	for (i=0;i<filas;i++)
		for (j=0;j<columnas;j++)
			matriz[i][j]=((int)rand()%10);

	/*//Si queremos leerla desde teclado
	 {
	  	printf "Dame el elemento %d , %d:",i,j);
	  	scanf("%lf",&matriz[i][j]);
	  	printf("\n");
	}*/	


	//Mostramos la matriz
	printf("\n");	
	for (i=0;i<filas;i++) {
	  for (j=0;j<filas;j++)
	    printf ("%lf ",matriz[i][j]);
	  printf("\n");
	}
	


	//mostramos max, min y media de la matriz
	printf("El maximo de la matriz es %lf \n",max(matriz,filas,columnas)); 
	printf("El minimo de la matriz es %lf \n",min(matriz,filas,columnas)); 
	printf("La media de la matriz es %lf \n",media(matriz,filas,columnas)); 

	//Calculamos unos cuantos crapulos
	for (i=1;i<100;i+=30) {
	  printf("El crapulo de %d es %d\n",i,crapulo(i));
	  printf("El crapuloR de %d es %d\n",i,crapuloR(i));
	  printf("El crapuloI de %d es %d\n",i,crapuloI(i));
	}

	
	//Creamos un vector aleatorio para las modas
	for (i=0;i<filas;i++)
	  vector[i]=((int)rand()%10);

	/*//Si queremos leerlo desde teclado
	 {
	  	printf "Dame el elemento %d:",i);
	  	scanf("%d",&vector[i]);
	  	printf("\n");
	}*/	
	
	
	//Mostramos el vector
	for (i=0;i<filas;i++)
	  printf ("%d ",vector[i]);
	printf("\n");

	//Calculamos las modas
	modas(vector,filas,&moda1,&moda2);

	//mostramos las modas
	printf("Moda1=%d Moda2=%d\n",moda1,moda2);

	return 0;

}
/*---------------------------------------------------------------------*/