**********************************************
1.- Leer dos números enteros y escribir 
el mayor de ambos o un mensaje si son iguales.
**********************************************

#include <stdio.h>

main()
{
 int a,b;
 printf("Dame dos numeros... ");
 scanf("%d%d",&a,&b);
 if (a>b)
    printf("El mayor numero es... %d",a);
 else 
    if (b>a)
       printf("El numero mayor es.... %d",b);
    else
       printf("Los numeros son iguales");

return 0;
}

**********************************************
2.- Leer un carácter y dos números enteros. 
Si el carácter leído es un operador aritmético 
calcular la operación correspondiente, si es cualquier otro 
mostrar error. Hacer el programa utilizando switch 
**********************************************

#include <stdio.h>
void main()
{
  char c;
  int a,b;
  printf("dame un caracter\n");
  c=getchar();
  fflush (stdin);
  printf("dame dos numeros\n");
  scanf("%d %d",&a,&b);
  switch (c)
  {
   case '+':
       printf("resultado %d",a+b);
       break;
   case '-':
       printf("resultado %d",a-b);
       break;
   case '*':
       printf("resultado %d",a*b);
       break;
   case '/':
       printf("resultado %d",a/b);
       break;
   default:
       printf("error");
   }
}

**********************************************
3.- Leer un número entero y visualizar su 
    tabla de multiplicar. 
**********************************************

#include <stdio.h>
void main()
{
 int a,b;
 printf ("Introduce el número:");
 scanf("%d",&a);
 b=1;
 while (b<=10)
 {
    printf("%d * %d = %d\n",a,b,a*b);
    b++;
 }
}

**********************************************
4.- Media de una serie de números que finaliza al 
    introducir el 999. El 999 no debe ser tenido 
    en cuenta para la media.
**********************************************

#include <stdio.h>

void main()
{
  int n,c=0,s=0;
  // Típico esquema mientras.
  // Se lee el primer elemento de la secuencia fuera del bucle
  printf("Dame el primer nº:");
  scanf("%d",&n);
  while(n!=999)
  {
     s+=n; // Se trata el elemento leído
     c++;
     printf("Dame el siguiente nº:"); // Se obtiene el siguiente elemento
     scanf("%d",&n);
  }
  if (c) // Sólo se podrá dividir si en la secuencia hay algún nº
     printf("\nLa media de los números es %.2f\n",(float)s/c);
  else
     printf("\nNo se ha leído ningún número.\n");
}

**********************************************
5.- Leer un número entero positivo y averiguar 
si es perfecto. Un nº es perfecto cuando es igual 
a la suma de sus divisores excepto el mismo. 
**********************************************

#include <stdio.h>

void main()
{
  int i,numero,suma=0;
  do{
     printf("Dame un numero:");
     scanf("%d",&numero);
  } while (numero<=0);

  for (i=1;i<=(numero/2);i++)
      if ((numero%i)==0)
         suma+=i;

  if (numero==suma)
     printf("El numero es perfecto.");
  else
     printf("El numero NO es perfecto.");
}

**********************************************
6.- Leer dos números enteros a y b mayores o iguales 
    que cero y calcular su producto mediante sumas sucesivas. 
    (Se usan, a modo de ejemplo, los tres esquemas repetitivos 
    existentes en C.)
**********************************************

#include <stdio.h>

void main()
{
  int a,b,c,i,producto=0;
  
  do{
     printf("Dame un a:");
     scanf("%d",&a);
  } while (a<0);

  do{
     printf("Dame b:");
     scanf("%d",&b);
  } while (b<0);

// Suponemos que  a es mayor que b en caso contrario se hace un intercambio 

  if (a<b)
  {
    c=a;
    a=b;
    b=c;
  }
  printf("a=%d b=%d\n",a,b);
 
  for (i=0;i<b;i++)
          producto+=a;
  printf("El producto con for es: %d\n",producto);

  producto=0;
  i=0;
  while (i<b)
  {
    producto+=a;
    i++;
  }
  printf("El producto con while es: %d\n",producto);

  producto=0;
  i=0;
  do      /* con este bucle al multiplicar por cero */
  { /* me daria "a" */
     producto+=a;
     i++;
  } while (i<b);
  printf("El producto con do-while es: %d",producto);
}



**********************************************
7.- Leer un numero entero y averiguar si es o no múltiplo de 9. 
    Un nº es múltiplo de 9 si la suma de sus cifras es 9 
    o múltiplo de 9. Ej.: 99  es múltiplo pues 9+9=18, 
    que a su vez 1+8=9 
**********************************************

#include <stdio.h>

void main()
{
int numero,sumacifras,s;

printf("Dame un numero: ");
scanf("%d",&numero);

s=numero;

while (numero>9)
{
sumacifras=(numero%10);    //Inicializamos sumacifras con el primer resto.

while ((numero/=10)!=0)      //Mientras la parte entera de la división sea distinta de 0
   sumacifras+=(numero%10);     //Seguimos sumando los restos

numero=sumacifras;     //Asignamos la suma de las cifras al número
}

if (numero==9)            //Al salir si el número es igual a 9 es múltiplo
printf("El numero %d, es multiplo de 9.",s);
else
printf("El numero %d, NO es multiplo de 9.",s);
}


**********************************************
8.- Generar los N primeros términos de la serie de 
    Fibonacci. El valor de N (entero y positivo) deberá 
    ser leído por teclado. 
    En esta serie los dos primeros números son 1, y 
    el resto se obtiene sumando los 
    dos anteriores: 1,1,2,3,5,8,13,21,... 
**********************************************


#include <stdio.h>
void main()
{
  int n,a,b,c,aux;
  do{                   // Se lee el número hasta que sea mayor que cero.
      printf("\nDame un numero :");
      scanf("%d",&n);
  } while(n<=0);
  a=1;b=0;
  for(c=1;c<=n;c++)
  {
    printf("%d\t",a);
    aux=a;
    a+=b;
    b=aux;
  }
}


**********************************************************************
9.- Presentar en la función main() el siguiente menú de opciones:
    1.- Tabla de multiplicar (leer en main() un número y en una 
        función mostrar su tabla de multiplicar).
    2.- Producto por sumas (en main() leer dos números enteros 
        mayores que 0 y en una función calcular su producto 
         mediante sumas sucesivas).
    3.- Mostrar números comprendidos 
        (leer dos números enteros cualesquiera y en función mostrar 
        los números comprendidos entre ambos, no se incluyen). 
**********************************************************************

#include <stdio.h>
void tabla(int);
void producto(int,int);
void numeros(int,int);

void main()
{
 int op,n,m;
 do {
   system ("cls");
   printf ("\n MENÚ DE OPCIONES");
   printf ("\n ================\n");
   printf ("\n 1.- TABLA DE MULTIPLICAR\n");
   printf ("\n 2.- PRODUCTO POR SUMAS\n");
   printf ("\n 3.- MOSTRAR NÚMEROS COMPRENDIDOS ENTRE DOS\n");
   printf ("\n 4.- SALIR \n\n\n\n");
   printf ("\n ELIGE UNA OPCION : ");
   scanf ("%d",&op);
   switch (op)
   {
   case 1: 
     system ("cls");
     printf ("\n Dame un número : ");
     scanf ("%d",&n);
     tabla(n);      // Llamada a la función
     printf ("\n");
     system("pause");
     break;
   case 2:
     system ("cls");
     do{
        printf ("\n Dame un número : ");
        scanf ("%d",&n);
      }while (n < 0);
      do{
        printf ("\n Dame otro número : ");
        scanf ("%d",&m);
      }while (m < 0);
      producto(n,m);
      printf ("\n");
      system("pause");
      break;
   case 3:
     system ("cls");
     printf ("\n Dame un n£mero : ");
     scanf ("%d",&n);
     printf ("\n Dame un n£mero : ");
     scanf ("%d",&m);
     numeros(n,m); 
     printf ("\n");
     system("pause");
     break;
   }
  }while (op != 4);
}

void tabla(int n)
{
 int c,p=1;
 for (c=1;c<=10;c++)
 {
   p=n* c;
   printf ("\n %d * %d = %d",n ,c,p);
 }
return;
}

void producto(int n, int m)
{
 int c,sum=0,aux;
 if (n > m)     // Se supone n el menor, en caso de no serlo se intercambian los valores
 { 
  aux=n;
  n=m;
  m=aux;
 }
 for (c=1;c<=n;c++)    sum+=m;
 printf ("\n El producto por sumas es %d",sum);
 return;
}

void numeros(int n, int m)
{
 int c,aux;
 if (n > m)
 {
  aux = n;
  n = m; 
  m = aux;
 }
 if (n+ 1 >= m) printf ("\n No hay números \n");
 else  for (c=n + 1;c < m ;c++)    printf ("\n %d",c);
 return;
}

**********************************************************************
10.- Leer por teclado un numero entero N. Escribir los 
     números primos comprendidos entre 1 y N. 
     Diseñar una función que permita averiguar si un 
     número es o no primo. 
**********************************************************************

#include <stdio.h>

#define TRUE 1
#define FALSE 0

int primo(int);

void main()
{ 
  int n,i;
  printf("\nDame un numero:");
  scanf("%d",&n);
  for (i=1;i<=n;i++)
     if(primo(i))
       printf(" %d ",i);
}

int primo (int n)
{
 int i;
 for (i=2;i<=(n/2);i++)
    if((n%i)==0)
       return FALSE;
 return TRUE;
}

**********************************************************************
11.- Leer una fecha en formato dia-mes-año, averiguar si es 
     correcta e indicar el día siguiente. 
**********************************************************************

#include <stdio.h>
#define TRUE 1
#define FALSE 0

int correcta_fecha(int,int,int);
int bisiesto(int); 

void main()
{
  int dia,mes,anio;
  printf("Dame una fecha:(dd-mm-aaaa)");
  scanf("%d-%d-%d",&dia,&mes,&anio);
  if (!correcta_fecha(dia,mes,anio))
     printf("\nLa fecha no es correcta.");
}

int correcta_fecha(int dia,int mes,int anio)
{
 int d;
 switch (mes)
 {
   case 4:
   case 6:
   case 9:
   case 11:d=30;
                  break;
   case 1:
   case 3:
   case 5:
   case 7:
   case 8:
   case 10:
   case 12: d=31;
                   break;
   case 2: if (bisiesto(anio))
                    d=29;
                 else
                    d=28;
                 break;
   default: return FALSE;
 }
 if (dia<=d)
  { 
    if (dia<d)
       dia++;
    else
    {
      dia=1;
      if (mes==12)
      {
        mes=1; 
        anio++;
      }
      else
        mes++;
    }
    printf("\nEl proximo dia sera:%2d-%2d-%d.",dia,mes,anio);
    return TRUE;
  }
  else
    return FALSE; 
}

/* Un ano es bisiesto cuando es multiplo de 4 pero no de 100 o multiplo de 400. */
int bisiesto(int anio)
{
if ((anio%4==0 && anio%100!=0) || (anio%400==0)) return TRUE;
return FALSE;
}


**********************************************************************
12.- Implementar un programa que sea capaz de calcular 
     el resultado de aplicar la fórmula siguiente 
     c = n! /( i! * (n-i)!).
     Para ello se dispone de dos funciones, una de ellas 
     lee un número por teclado que debe ser mayor o igual 
     que cero. Teniendo en cuenta además  que n tiene que 
     ser necesariamente mayor que i. La otra función 
     calcula el factorial de un número.  
**********************************************************************

#include <stdio.h>

int lee_numero();
long int factorial(int);

// Programa principal.
void main()
{
 int n,i; 
 printf("Valor de i...\n");
 i=lee_numero();
 printf("\nValor de n...\n");
 do
     n=lee_numero();
 while(n<i);
 printf("Resultado %d sobre %d = %d",n,i,factorial(n)/(factorial(i)*factorial(n-i)));
}

// Funciones.
int lee_numero()
{
 int a; 
 do{
   printf("Escribe un valor:");
   scanf("%d",&a);
 }while(a<0);
 return a;
}

long int factorial(int x)
{
 long int f=1;
 for(;x>0;x--)
    f*=x;
 return f;
}