***Ej1.

int menu_general(int N) /*paso por valor ya que N no se modifica*/
{ 
   int i;
   int opcion;

   printf("\nElije entre las diferentes opciones:\n");
   for (i=0;i<N;i++)
      printf("\-Opcion %d: Pulsa el %d\n",i,i);
   scanf("%d", &opcion);  /*esta fuera del bucle*/
   return(opcion);
}

b) Version Mejorada

int menu_general(int N) /*paso por valor ya que N no se modifica*/
{ 
   int i;
   int opcion;
   do{
      printf("\nElije entre las diferentes opciones:\n");
      for (i=0;i<N;i++)
         printf("\-Opcion %d: Pulsa el %d\n",i,i);
      scanf("%d", &opcion);  /*esta fuera del bucle*/
      if((opcion<0)||(opcion>=N))
         printf("\nOpcion Incorrecta.");
   }
   while((opcion<0)||(opcion>=N));
      return(opcion);
}



***Ej2
a)
float suma_Q(int num1, int den1, int num2, int den2){  /*por valor */
   return((float)(num1*den2+num2*den1)/(den1*den2));
     /*daros cuenta que hay que hacer un casting, sino devolveria un entero*/
}

b)
void suma_Q2(int num1, int den1, int num2, int den2, int *numR,int *denR ){ 
       /*una funcion no puede devolver dos valores. Hay que devolverlos */
       /*a traves de argumentos*/
       /*Las variables que acojen el resultado se pasan por referencia NECESARIAMENTE*/

       *numR = num1*den2+num2*den1;
       *denR = den1*den2;
}  /*al salir en los parametros reales que hagan de */
   /*numR y  denR estan los resultados buscados*/

c)Programa completo

void Euclides(int *num, int *den){
  int aux;
  int resto;
  int numaux, denaux;

  numaux = *num;
  denaux = *den;

  do{
      coc = (numaux) / (denaux);
      resto = (numaux) % (denaux);
      numaux = denaux;
      denaux = coc;
     }
  while(resto !=0);
  /*en numaux esta el MCD cuando salimos del bucle*/

  *num = *num / numaux;
  *den = *den / numaux;

  /*como el numerador y el denominador estan pasados por referencia*/
  /*estos se modifican a la salida de la funcion*/
}


void suma_Q2(int num1, int den1, int num2, int den2, int *numR,int *denR ){ 

       *numR = num1*den2+num2*den1;
       *denR = den1*den2;

       Euclides( numR, denR);
}  /*al salir en los parametros reales que hagan de */
   /*numR y  denR estan los resultados buscados*/

void main(){
int denA, numA, denB, numB, denR, numR;
   printf("\escribe el numerador y el denominador del primer numero: ");
   scanf("%d%d", &numA, &denA);
   printf("\escribe el numerador y el denominador del segundo numero: ");
   scanf("%d%d", &numB, &denB);
   suma_Q2(numA, denA, numB, denB, &numR, &denR);
   printf("\nElresultado es:");
   printf("\n %d / %d", numR, denR);
}

***Ej3

Comentario: La función debe necesariamente tener 6 argumentos. 4 de ellos estaran pasados
por valor y se usarán para recibr los valores de las partes real e imaginaria de los dos
números complejos. 2 de ellos se deben pasar por referencia y serán la parte real e imaginaria 
del complejo resultante de la operación. Es necesario pasar por referencia estas dos variables
ya que una función no puede devolver dos valores, por lo que el único modo de recojer
los dos valores del resultado es pasar dos variables por referencia que recogeran dichos
valores. Otra solución es definir una estructura "complejo" pero eso no es de este tema.

Nota recordar que la multiplicación de dos complejos se define como:
(a+bi) * (c+di) = (a*c -b*d)+ (a*d+b*c) i

void mult_C(float R1, float I1, float R2, float I2, float *R_sol, float *I_sol){

   *R_sol = R1*R2 -I1*I2;
   *I_sol = R1*I2 - I1*R2;
}


***Ej4
/*el parámetro Err será el error de aproximación al  verdadero valor*/
/*Como la sucesión de cálculos converge de manera contínua al verdadero valor,
 el algoritmo parará cuando la diferencia entre una aproximación calculada y la
 siguiente calculada sea menor que Err, ya que esto indica que entre el último
 valor calculado y el verdadero valor,va a existir también una diferencia menor que Err*/

float raiz_cuadrada(float X, float Err){
float a;
   a = X / 2;
   
   while( (a*a - X) > Err){
      a = (a + X/a) / 2;
   }  /*Como la función converge siempre, se garantiza que el bucle no es infinito*/

   return a;
}

/*Notar que los parámetros de la función son por valor */

***Ej5
/*dos versiones*/
/* VERSION 1 La manera de hallar los divisores de un número será simplemente la fuerza bruta*/

void decide_perfecto(int num){
   int i;
   int acum=1;

   for(i=2; i<num; i++)
     if((num % i)==0) /*entonces es un divisor*/
        acum = acum + i;
  
   if( acum == num)
      printf("\n El numero es perfecto");
   else
      printf("\nEl número no es perfecto");
}

/* Versión 2. Como máximo existirán divisores hasta la mitad del número, porque cualquier número
 que sea mayor que la mitad del analizado, no cabrá en una división entera (Ej si
el número analizado es 12 no tendremos que comprobar si 7, 8, 9, 10, 11, 12 son divisores
porque no caben en la dibisión entera mas que a 1*/

void decide_perfecto(int num){
   int i;
   int acum=1;

   for(i=2; i<=num/2; i++) /*Aqui esta la modificación*/
     if((num % i)==0) /*entonces es un divisor*/
        acum = acum + i;
  
   if( acum == num)
      printf("\n El numero es perfecto");
   else
      printf("\nEl número no es perfecto");
}

***Ej6
void fermat(int p){
int i;
int exp;
int no_primo=0;

exp = p-1;
for(i=0;(i<p) && (no_primo ==0);i++) /*fijarse que el bucle para en el momento*/
                                     /*en que se descubre que el test de Fermat es negativo*/
   if((pow(i,exp) % p)!=1) /*no cumple el test de Fermat*/
       no_primo=1;

if(no_primo==0)
   printf("\nEl numero es primo);
else
   printf("\nEl numero NO es primo);

}

/*NOTA: El test de Fermat puede parecer a primera vista inutil ya que bastaría con ir */
/*diviviendo p por cada uno de los enteros de 2 a P/2. Sin embargo la ventaja es que */
/*existem métodos muy rápidos para calcular las potencias de números (de tiempo logarítmico)*/
/*evidentemente nuestro programa no los implementa con lo que es ineficiente*/
/*para más informacion KNUTH, D. The Art of Computer Programming" Vol 2 pp. 391 y ss. 3ª Edicion*/

***Ej7
/*Os expongo aquí una solución clasica a este problema*/
/*el algoritmo vale para cualquier número de elementos N */
/*No solo para N = 4 y además de cualquier tipo*/
/*Supone que los valores están almacenados en un vector*/
/*¿Podrías hacer una versión que no use  la estructura vector Value 
para tu problema en concreto?*/

void getNext()
{
  int i = N - 1;

  while (Value[i-1] >= Value[i]) i = i-1;

  int j = N;

  while (Value[j-1] <= Value[i-1]) j = j-1;

  swap(i-1, j-1);  // intercambia valores en las posiciones (i-1) y (j-1)

  i++; j = N;

  while (i < j)
  {
    swap(i-1, j-1);
    i++;
    j--;
  }
}
Reference
E.W.Dijkstra, A Discipline of Programming, Prentice-Hall, 1976
R.Sedgewick, Algorithms, Addison-Wesley, 1983


***Ej 9
a)
void clave_1(int N, char letra){

int aux;
char l;

aux = N % 25 + 65;
l= char (aux);
if(l == letra)
   printf("\nSi coincide");
else
   printf("\nNO coincide");
}

b)
void clave_1(int N, char letra){

int aux,c;
int inv=0;
char l;
/*transformo el numero N en el inverso. Supongo enteros de 2 bytes*/
for(i=4,j=0;i<=0;i--){
  c=N / pow(10,i);
  if (c!=0){
     aux=c;
     N = N % pow(10,i);
     inv=inv + aux * pow(10,j);
     j++;
   }

}
   
inv = N % 25 + 65;
l= char (inv);
if(l == letra)
   printf("\nSi coincide");
else
   printf("\nNO coincide");
}