Está en la página 1de 11

Algoritmos de Programación

División mediante Restas


1. Introducción: La División como todos la conocemos, es una operación en la cual tratamos de buscar
el producto que multiplicado por el divisor, dé el dividendo o lo más parecido a este.
Ejemplo:
5 / 2 = 2 (2 x 2= 4), con residuo de 1 (5 - 4 = 1)
Sin embargo, la división no es mecánica. Existe todo un proceso, de restas por la cual obtenemos un
resultado.
2. Explicación: Las computadoras solo pueden restar y sumar. Para multiplicar, suman
progresivamente y para dividir… (Supongo ya lo habrás adivinado) restan progresivamente.
Veámoslo con el ejemplo del 5 / 2. Tenemos los siguientes datos:
• Dividendo: 5
• Divisor: 2
• Cociente: 2
• Residuo: 1
Ahora veamos las restas sucesivas:
5-2=3
3-2=1
Como verás se ha ido restando del dividendo, el divisor y la operación se repite hasta que el resultado
ya no sea mayor que el divisor o menor que 0. El resultado de la última resta es el residuo y la cantidad
de restas realizadas es el cociente. Nótese que el cociente es 2 y en total hay 2 restas.
Dicho esto… veámos como se implementa mediante un Pseudocódigo.
3. Pseudocódigo: Si lo expresamos como Pseudocódigo, algo así quedaría:
Nota: divid, es el divisor, divc, es el divisor, cosc, es el cociente, res, es el residuo.
leer divid, divc
si (divc=0) entonces
escribir “No se puede dividir entre cero”
salir()
fin_si

mientras divid >= divc hacer


divid = divid - divc
cosc = cosc + 1
fin mientras

res=divid

escribir “El cociente es”, cosc


escribir “El residuo es”, res
4. Implementación en Lenguaje C: Ya lo tenemos en Pseudocódigo, pero para un curso, normalmente
lo exigen en lenguaje C. Si lo implementamos, así quedaría:
#include <stdio.h>

int main()
{
int divd, divc, cosc, res;

scanf(”%d %d”, &divd, &divc);

if (divc==0) {
printf(”No se puede dividir entre cero\n”);
return 0;
}

while (divd >= divc) {


divd=divd-divc;
cosc++;
}

res=divd;

printf(”El cociente es %d\n”, cosc);


printf(”El residuo es %d\n”, res);

return 0;
}

**********************************************
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;
}