/* Fuente: RACIONAL.C
   Programa: ARITMETICA BASICA CON NUMEROS RACIONALES
   Descripción: Este programa permite operar con números racionales. Un número racional
   se caracteriza por estar expresado con un denominador y un denominador.
   Las operaciones que contempla son:
     - suma
     - resta
     - producto
     - división
   Además utiliza una función para proporcionar siempre la expresión irreducible del número
   racional
*/
 
#include <stdio.h>
#include <math.h>
#include <ctype.h>
 
/* ---------------------------------------------------------- */
/* Definiciones globales                                      */
/* ---------------------------------------------------------- */
typedef struct {
   int num;   /* Numerador   */
   int denom; /* Denominador */
} Racional;
 
/* ---------------------------------------------------------- */
/* Prototipos                                                 */
/* ---------------------------------------------------------- */
   void Modulo_Principal (void);
   void Presentacion (void);
   void LeerRacional (Racional *);
   void MostrarRacional (Racional);
   void SumaRacional (Racional, Racional, Racional *);
   void RestaRacional (Racional, Racional, Racional *);
   void MultiplicaRacional (Racional, Racional, Racional *);
   void DivideRacional (Racional, Racional, Racional *);
   void SimplificaRacional (Racional *);
   int mcd (int, int);
 
/* ---------------------------------------------------------- */
   int main (void) {
/* ---------------------------------------------------------- */
     char respuesta;
 
     system ("cls");
     Presentacion();
     do
       { printf("\n");
         Modulo_Principal();
	     printf("\n");
	     do
	       { printf("¿Otra ejecución (S/N)?: ");
	         fflush(stdin); /* Limpia el buffer de teclado */
	         respuesta = toupper(getchar());
	       }
	     while (respuesta != 'S' && respuesta != 'N');
 
       }
     while (respuesta != 'N');
 
     printf("\n");
     return 0;
 
} /* Fin del main */
 
 
/* ---------------------------------------------------------- */
   void Modulo_Principal (void) {
/* ---------------------------------------------------------- */
     Racional rac1, rac2, rsum, rres, rprod, rdiv;
 
     printf("Introduzca el primer número racional:\n");
     LeerRacional(&rac1);
     printf("Introduzca el segundo número racional:\n");
     LeerRacional(&rac2);
 
     printf("\n");
     SumaRacional (rac1, rac2, &rsum);
     printf("Suma.......: ");
     MostrarRacional(rsum);
     printf("\n");
 
     RestaRacional (rac1, rac2, &rres);
     printf("Resta......: ");
     MostrarRacional(rres);
     printf("\n");
 
     MultiplicaRacional (rac1, rac2, &rprod);
     printf("Producto...: ");
     MostrarRacional(rprod);
     printf("\n");
 
     DivideRacional (rac1, rac2, &rdiv);
     printf("División...: ");
     MostrarRacional(rdiv);
     printf("\n");
}
 
/* ---------------------------------------------------------- */
   void Presentacion (void) {
/* ---------------------------------------------------------- */
     puts("ARITMETICA BASICA CON NUMEROS RACIONALES");
     puts("========================================");
     puts("");
     puts("Realiza la suma de números racionales");
     puts("Siempre presenta la expresión irreducible del número racional");
     puts("");
}
 
/* ---------------------------------------------------------- */
   void LeerRacional (Racional *r) {
/* ---------------------------------------------------------- */
       scanf("%d/%d", &(r->num), &(r->denom));
}
 
/* ---------------------------------------------------------- */
   void SumaRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */
 
       if(a.denom == b.denom){
        (r->num)=(a.num + b.num);
        (r->denom)=(a.denom);
       }else{
        (r->denom)=(a.denom * b.denom);
        (r->num)=(((r->denom/a.denom)*a.num) + ((r->denom/b.denom)*b.num));
       }
 
       SimplificaRacional(&r);
}
 
 
/* ---------------------------------------------------------- */
   void RestaRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */
 
       if(a.denom == b.denom){
        (r->denom)=(a.denom);
        (r->num) = (a.num - b.num);
       }else{
        (r->denom)=(a.denom * b.denom);
        (r->num)=(((r->denom/a.denom)*a.num) - ((r->denom/b.denom)*b.num));
       }
 
    SimplificaRacional(&r);
}
 
 
 
/* ---------------------------------------------------------- */
   void MultiplicaRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */
 
       (r->num)=(a.num*b.num);
       (r->denom)=(a.denom*b.denom);
       SimplificaRacional(&r);
}
 
 
/* ---------------------------------------------------------- */
   void DivideRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */
 
       (r->num)=(a.num*b.denom);
       (r->denom=a.denom*b.num);
       SimplificaRacional(&r);
}
 
 
/* ---------------------------------------------------------- */
   void MostrarRacional (Racional r) {
/* ---------------------------------------------------------- */
     printf("%3d", r.num);
     if (r.denom != 1)
       printf(" /%3d", r.denom);
}
 
 
/* ---------------------------------------------------------- */
   void SimplificaRacional (Racional *r) {
/* ---------------------------------------------------------- */
// Calcula el mcd del numerador y del denominador
// Divide numerador y denominador por su mcd
// Si la fraccion debe llevar segno negativo (num*dem <0)
//    entonces el signo se coloca al numerador
    int min;
 
       min=mcd(r->num, r->denom);
       r->num = (r->num)/min;
       r->denom =(r->denom)/min;
       if((r->num * r->denom)<0){
        r->num = - r->num;
       }
}
 
 
 
/* ---------------------------------------------------------- */
   int mcd (int n, int d) {
/* ---------------------------------------------------------- */
/* Calcula el máximo común dividor de n y d */
/* Precisa que d sea distinto de cero       */
/* Precisa que n > d                        */
    int c;
 
       if(n!=0 && d!=0 && n>d){
        do{
            c=n%d;
            if(c!=0){
                n=d;
                d=c;
            }
        }while(c!=0);
       }else{
        return;
       }
 
return d;
}

#include <stdio.h>
#include <stdlib.h>
 
#define MAXN 10 /* Número máximo de notas del alumno */
 
typedef struct{
    int dia;
    int mes;
    int anno;
}tipo_fecha;
 
typedef struct{
    char nombre[51];
    int curso;
    tipo_fecha fechaNacimiento;
    char direccion[61];
    float notas[MAXN];
}tipo_alumno;
 
/* PROTOTIPOS */
 
void leerAlumno(tipo_alumno *);
void imprimiralumno(tipo_alumno *);
 
/* FUNCIONES */
 
void leerAlumno(tipo_alumno * pa){
    int i;
 
    printf("Introduzca el nombre y apellidos del alumno (max. 50 caracteres): ");
    gets(pa->nombre);
    printf("Curso: ");
    scanf("%d", &pa->curso);
    printf("Fecha de Nacimiento (dd/mm/aaaa): ");
    scanf("%2d/%2d/%4d", &pa->fechaNacimiento.dia, &pa->fechaNacimiento.mes, &pa->fechaNacimiento.anno);
    puts("Direccion: ");
    fflush(stdin);
    gets(pa->direccion);
    for(i=0; i<MAXN; i++){
        printf("Nota[%d]: ", i+1);
        scanf("%f", &pa->notas[i]);
    }
}
 
void imprimirAlumno(tipo_alumno * pa){
    int i;
 
    fflush(stdin);
    printf("Nombre: %s", pa->nombre);
    fflush(stdin);
    printf("Curso: %d", pa->curso);
    fflush(stdin);
    printf("Fecha de Nacimiento: %2d/%2d/%4d\n", pa->fechaNacimiento.dia, pa->fechaNacimiento.mes, pa->fechaNacimiento.anno),
    fflush(stdin);
    printf("Direccion: %s\n", pa->direccion);
    for(i=0; i<MAXN; i++){
        printf("Nota[%d]: %2.1f\n", i+1, pa->notas[i]);
    }
}
 
int main (void){
 
    tipo_alumno alumno;
    tipo_alumno * ptalumno;
    ptalumno=&alumno;
 
    leerAlumno(ptalumno);
 
    imprimirAlumno(ptalumno);
 
 
printf("\n\n");
system("pause");
return 0;
}
 

typedef struct tipo_alumno{
    tipo1 miembro1;
    tipo2 miembro2;
    ...
    tipoN miembroN;
} var1, var2,...;
 

typedef struct tipo_jugador{
    tipo1 miembro1;
    tipo2 miembro2;
    ...
    tipoN miembroN;
}tipo_jugador;
 

tipo_jugador equipo[MAX_JUG];

void EliminarNodos(NODO *lst, int maximo){
    NODO *indice=NULL, *anterior=NULL;
 
    if(lst!=NULL){
        indice=lst;
 
 
        while((indice->sig)!=NULL){
            if((indice->num)>=maximo){
                if(anterior==NULL){
                    lst=(indice->sig);
                    free(indice);
                    indice=lst;
                }else{
                    (anterior->sig)=(indice->sig);
                    free(indice);
                    indice=anterior->sig;
                }
            }
        }
    }
}