//1).Hacer la funcion factorial.

//n! = 1 Si n=0 y n!= 1*2*3*4*..n Si n>0

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

double factorial(int n)
{
double f=1;
int i;
for(i=1;i<=n;i+1)
{
f = f * i;
};
return (f);
};

main()
{
double f;
int num;
printf(“Escriba un entero:”);
scanf(“%d”, & num);
f = factorial(num);
printf(“EL factorialrial de %d es: %lf\n”,num,f);

getch();
return(0);
}

2. //Crear la funcion potencia.

//
//146)Crear la funcion potencia.
// / 0 Si X=0 y Y diferente de 0
// y | 1 Si X diferente de 0 y Y=0
// X < x*x*x..y-veces Si X y Y diferentes de cero y Y>0
// | 1/(x*x*x..y-veces) Si X y Y diferentes de cero y Y<0
// \ indefinido Si X=0 y Y=0
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

float potencia(float bas, int ex)

{
float pot=1;
int i,t=0;
if(ex==0 && bas==0)
{
printf(“INDEFINIDO”);
return (0);
}

if(ex<0)
{
t=1;
ex = ex * -1;
}
for(i=0;i<ex;i+1)
{
pot = pot * bas;
};
if(t==1)
{
pot = 1/pot;
}
return (pot);
};

main()
{
float bas,valpot;
int ex;
printf(“\n Valor de la base:”);
scanf(“%f”,& bas);
printf(“\n Valor del exponente(entero):”);
scanf(“%d”,&ex);
valpot = potencia(bas,ex);
printf(“\n%0.f ^ %d = %0.f\n”,bas,ex,valpot);

getch();
return(0);
}
3. //147. Calcular la siguiente formula.
// _15_ k 2k+1
// Seno(x) = \ (-1) X
// ————–
// /___ (2k+1) !
// k=0

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

float potencia(float bas, int ex)

{
float pot=1;
int i,t=0;
if(ex==0 && bas==0)
{
printf(“INDEFINIDO”);
return (0);
}
if(ex<0)
{
t=1;
ex = ex * -1;
}
for(i=0;i<ex;i+1)
{
pot = pot * bas;
};
if(t==1)
{
pot = 1/pot;
}
return (pot);
};

float facto(int j)
{
float f=1;
int i;
for(i=1;i<=j;i+1)
{
f = f * i;
};
return (f);
};

float seno(float angu)

{
float potenciae,sen;
float fac;
int i,j;

angu = angu * 0.0174533;

sen = 0;
j=1;
for(i=0;i<15;i+1)
{
fac = facto(j);
potenciae = potencia(angu,j);
if(i%2 == 0)
{
sen = sen + (potenciae/fac);
}
else
{
sen = sen – (potenciae/fac);
j = j + 2;
}
}
return (sen);
};

main()
{
float angu,val;
printf(“\n ingrese el Valor del angulo: “);
scanf(“%f”, & angu);
val=seno(angu);
printf(“\n El seno (%f ) = %f\n”,angu,val);

getch();
return(0);
}
4.//148)Escriba una función llamada bisuma que calcule la suma de dos variables
//num1 y num2 enteras y regrese un resultado entero.
//Escriba una función llamada media_de_3 que reciba como parámetro un dato
entero y
//lo divida entre 3. Suponga que el dato enviado a la función es el total de sumar 3
//números, por lo que el resultado de esta función será la media de los 3 datos.
//Codifique un programa que lea tres valores enteros para las variables a, b, c, que
//enseguida invoque a las funciones bisuma y media_de_3 y que, por último,
despliegue
//el valor promedio de los tres datos con un mensaje apropiado. ¿Qué cambios
necesitaría
// realizar a las funciones para obtener el promedio de más de 3 datos?

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

float Fbisuma(float num1,float num2)

{
float Res;
Res=num1+num2;
return(Res);
};

main()
{
float num1,num2,suma;
float media;
printf(“ingrese los dos valores \n”);
scanf(“%f %f”, & num1, & num2);
suma=Fbisuma(num1,num2);
printf(“el resultado de la suma es %0.f”,suma);

getch();
return(0);
}

5.//Escriba una función llamada media_de_3 que reciba como parámetro un dato
entero y
//lo divida entre 3. Suponga que el dato enviado a la función es el total de sumar 3
//números, por lo que el resultado de esta función será la media de los 3 datos.
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

float Fmedia_de_3(float d)
{
float m;
m=d/3;
return(m);
};

main()
{
float num1,num2,num3,media,suma;
printf(“ingrese los tres valores \n”);
scanf(“%f %f %f”,& num1,& num2,& num3);
suma=num1+num2+num3;
media=Fmedia_de_3(suma);
printf(“\n la media es %2.f”,media);

getch();
return(0);
}

6.//Codifique un programa que lea tres valores enteros para las variables a, b, c,
que
//enseguida invoque a las funciones bisuma y media_de_3 y que, por último,
despliegue
//el valor promedio de los tres datos con un mensaje apropiado. ¿Qué cambios
necesitaría
// realizar a las funciones para obtener el promedio de más de 3 datos?

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

float Fmedia_de_3(float d)
{
float m;
m=d/3;
return(m);
};
float Fbisuma(float a,float b)
{
float R;
R=a+b;
return(R);
};

main()
{
float num1,num2,num3,suma,d;
float media;
printf(“ingrese los tres valores \n”);
scanf(“%f %f %f”,& num1,& num2,& num1);
suma=Fbisuma(num1,num2);
d=num1+num2+num3;
media=Fmedia_de_3(suma);
printf(“el resulatdo de la suma es %0.f”,suma);
printf(“\n la media es %2.f”,media);

getch();
return(0);
}

7.//Escriba una función llamada cuadrado que tenga un parámetro de entrada

llamado longitud
//y entregue como resultado el perímetro del cuadrado cuyo lado sea la longitud
especificada
//y su área. Todas las variables son reales.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

float cuadrado(float longi)

{
float aux1;
aux1=longi*4;
return(aux1);
}

main()
{
float longi, perim;
printf(“Ingrese la longitud de un lado del cuadrado \n”);
scanf(“%f”, & longi);
perim=cuadrado(longi);
printf(“El perimetro del cuadrado es %0.f”, perim);
getch();
}

8.//Escriba una función llamada magnitud que tenga cuatro parámetros de entrada
llamados
//x1, x2, y1, y2 y que entregue como resultado la distancia entre dos puntos cuyas
//coordenadas son (x1, y1) y (x2, y2) según la siguiente fórmula:
//
// Distancia=sqrt(((y2-y1)*(y2-y1))+((x2-x1)*(x2-x1))

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<math.h>

float magnitud (float y2 , float y1 , float x2 , float x1)

{
sqrt(((y2-y1)*(y2-y1))+((x2-x1)*(x2-x1)));

};

main()
{
float x1 , x2 , y1 , y2,dis;
printf(“ingrese x1:”);
scanf(“%f”,&x1);
printf(“ingrese x2:”);
scanf(“%f”,&x2);
printf(“ingrese y1:”);
scanf(“%f”,&y1);
printf(“ingrese y2:”);
scanf(“%f”,&y2);
dis=magnitud(x1 , x2 , y1 , y2);
printf(“la distancia es %0.f”,dis);
getch();
return(0);

}
9.//Un piso rectangular que mide 12 metros por 15 metros está cubierto
parcialmente
//por tapetes circulares. El radio de un tapete es un metro. El radio del otro es
//de dos metros. Analice, diseñe y codifique un programa que encuentre el área de
//la parte del piso que está descubierta.
//El programa deberá tener:
//Una función que reciba como parámetro el radio de un círculo y que regrese el
//valor del área de ese círculo.
//Suponga que el radio y el área son reales.
//Una función con dos parámetros reales que calcule el área de un rectángulo de
//base y altura dadas.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

float acirculo(float r1,float r2)

{
float r,t,j;
r=pow(r1,2)*3.14;
t=pow(r2,2)*3.14;
j=r+t;

return(j);
}

int arectangulo(int longitud)

{
int art,h=12,b=15;
art=h*b;
return(art);
}

main()
{
float h,b,ac,ar,areapiso,r1,r2,r,longitud;

printf(“ingrese el radio del circulo pequeño \n”);

scanf(“%f”,& r1);
printf(“ingrese el radio del circulo grande \n”);
scanf(“%f”,& r2);
ac=acirculo(r1,r2);
ar=arectangulo(longitud);
areapiso=(ar-ac);
printf(“el area de la parte descubierta del piso es %f”,areapiso);
getch();
return(0);

10.//Dado un número entero N por teclado, hacer un programa

//en C con funciones para que calcule calcular la siguiente expresión
//(X/Y)expZ donde X es la suma de los divisores pares de N; Y es la suma de los
//divisores impares de N y Z es el número de dígitos de N.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

int numdigitos(int n)
{
int i=0;
while(n!=0)
{
n=n/10;
i=i+1;
}
return(i);
}
int numpares(int n)
{
int a=0,n1,i;
for(i=2;i<=n;i=i+2)
{
n1=n%i;
if(n1==0)
{
a=a+i;
}
};
return(a);
}
int numimpares(int n)
{
int aux1=0,n1,i;
for(i=1;i<=n;i=i+2)
{
n1=n%i;
if(n1==0)
{
aux1=aux1+i;
}
};
return(aux1);
}
float potencia(float res,int z)
{
float val;
int i;
for(i=1;i<=z;i++)
{
val=res*res;
}
return(val);
}

main ()
{
int n,z,x,y;
float res,res1;
printf(“digite el numero:”);
scanf(“%d”,& n);
z=numdigitos(n);
x=numpares(n);
y=numimpares(n);
res=x/y;
res1=potencia(res,z);
printf(“el valor de la expresion es %0.f”,res1);

getch();
return(0);
}

11.//Escriba una función llamada digfinal que tenga un parámetro de entrada

llamado número
//y que entregue como resultado el dígito de las unidades del número. Por
ejemplo,
//si el número es 234, el resultado es 4.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int digfinal (int numero)
{
int res;
res=numero%10;
return(res);
}
main()
{
int numero, res;
printf(“Ingrese el valor numero entero:”);
scanf(“%d”, & numero);
res=digfinal(numero);
printf(“El digito final es %d”, res);

getch();
return(0);
}

12.//Escribe una función que tome 3 parámetros: dos de tipo enteros y uno de tipo
carácter.
//La función deberá sumar, restar, multiplicar o dividir los valores de los dos
primeros
//parámetros dependiendo del código indicado en el tercer parámetro, y devolver el
resultado.
//(el carácter será ‘+’, ‘-‘, ‘ * ’, y ‘/ ’)

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

main()
{
float num1,num2,res;
int para;
printf(“introduzca el valor de a :”);
scanf(“%f”,& num1);
printf(“introduzca el valor de b:”);
scanf(“%f”,& num2);
printf(“Elige el numero de la operacion en el menu:\n 1-sumar\n 2-restar\n 3-
multiplicar\n 4-dividir\n”);
scanf(“%d”, & para);
if(para==1)
{
res=num1+num2;
}
else
{
if(para==2)
{
res=num1+num2;
}
else
{
if(para==3)
{
res=num1*num2;
}
else
{
res=num1/num2;
};
};
};

printf(“el resultado es : %2.f\n”,res);

getch();
return (0);
}

13.//Escribe una función que devuelva el (a) factorial, (b) n-simo número de
//Fibonacci, de su argumento.

#include<stdlib.h>
#include<stdio.h>
#include<conio.h>

long int factorial(int n)

{
long int f=1;
int i;
for(i=1;i<=n;i=i+1)
f = f * i;
return (f);
};
int fibona(int n)
{
int ter,act,ant;

ant=1;
act=1;
n–;

while(n>0)
{
ter = act;
act = act + ant;
ant = ter;
n–;
}
return ant;
};

main()
{
int n,fib;
long int fac;

printf(” Escriba un entero:\t “);

scanf(“%d”,&n);
fac = factorial(n);
fib = fibona(n);
printf(“\n El factorial de %d es: %ld\n”,n,fac);
printf(“\n El %d-esimo termino de Fibonaci es: %d\n”,n,fib);

getch();
return(0);
}

14.//Escribe una función con dos parámetros de tal forma que diga si sus dos
//parámetros son múltiplo el uno del otro (no importa cuál de cuál).

#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
int multiplo(int a, int b)
{
int c;
c = b%a;
if(c == 0)
{
return 1;
}
else
{
return (0);
}
};

main()
{
int a,b,c;

printf(” \n Primer valor:\t “);

scanf(“%d”,&a);
printf(” \n Segundo valor:\t”);
scanf(“%d”,&b);
c= multiplo(a,b);
if(c == 1)
{
printf(“\n%d es multiplo de %d\n”,a,b);
}
else
{
printf(“\n%d NO es multiplo de %d\n”,a,b);
}

c= multiplo(b,a);
if(c == 1)
{
printf(“\n%d es multiplo de %d\n”,b,a);
}
else
{
printf(“\n%d NO es multiplo de %d\n”,b,a);
}

getch();
return(0);
}
15.//Euclides encontró que para dos números enteros a y b cuales quiera:
//mcd(a, b) = mcd(b, a)
//mcd(0, b) = b
//mcd(a, b) = mcd(a – b, b)
//Escribe una función que devuelva el máximo común divisor de sus dos
//argumentos:
//mediante restas. Téngase aquí en cuenta que intercambiando los valores de
//a y de b y que debe existir un valor de mcd, siempre se llegará mediante
//restas (el mayor menos el menor) a un valor de la resta a’ –b’ que dará cero,
//dejando así el valor b’ como mcd.
//a)Los valores de a’ y b’ son resultados de restas anteriores que tienden
//necesariamente a 0 y al mcd, respectivamente.
//b)mediante división modular. Con esto se ahorran n = a DIV b restas, y se usa
//directamente el resto de esas n restas, que es el módulo a MOD b..

#include<stdlib.h>
#include<stdio.h>
#include<conio.h>

int maxcodi(int num1,int num2)

{
int t;
while(num1 != num2)
{
if(num1>num2)
{
t=num1;
num1=num2;
num2=t;
}
num2=num2-num1;
}
return(num1);
};

main()
{
int num1,num2,mcd;

printf(“\n Primer valor: \t”);

scanf(“%d”,&num1);
printf(“Segundo valor: \t “);
scanf(“%d”,&num2);
mcd=maxcodi(num1,num2);
printf(“\n El maximo comun divisor entre %d y %d es: %d\n\t”,num1,num2,mcd);

getch();
return(0);
}

16.//Escribe una función para calcular el mcd pero mediante la técnica

//práctica de: “comunes con el menor exponente” de sus descomposiciones
//factoriales. Por ejemplo: 24 = 23 × 3 y 9 = 32, de modo que mcd(24, 9) = 3.
//NOTA: Para descomponer el número n en sus factores primos, ir dividiendo
//(y contando cuántas veces se puede dividir) por cada primo hasta la n ).

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

int primo(int i)
{
int k;
for(k=2;k<i;k++)
{
if(k%i == 0)
return(0);
}
return(1);
}

int maxcodi(int n1,int n2)

{
int i, p=1,j,li;
if(n1>n2)
{
li=n2;
}
else
{
li=n1;
}
i=2;

while(n1>1 && n2>1 && i<li)

{
j = primo(i);
if(j==1)
{
while(n1%i == 0 && n2%i == 0)
{
p=p*i;
n1=n1/i;
n2=n2/i;
}
}
i+1;
}
return(p);
}

main()
{
int n1,n2,mcd;

printf(“\n Primer valor: “);

scanf(“%d”,&n1);
printf(“\n Segundo valor: “);
scanf(“%d”,&n2);
mcd=maxcodi(n1,n2);
printf(“\nEl maximo comun divisor entre %d y %d es: %d\n”,n1,n2,mcd);

getch();
return(0);
}

17.//159.Escriba una función que imprima los divisores y la suma de los divisores
de
//todos los enteros que se encuentran entre dos valores m y n dados por el
//usuario. Por último la función debe regresar cuál fue el número cuya suma
//de divisores fue mayor. Por ejemplo, si P= 100 y Q = 110, entonces la salida
//será:
//i Divisores suma
//100 1 2 4 5 10 20 25 50 100 217
//…
//110 1 2 5 10 11 22 55 110 216

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int divisores(int n, int m)
{
int i,t,ma,h,nu=n;

for(i=n;i<=m;i++)
{
t=1;
for(h=2;h<=i;h++)
{
if(i%h == 0)
{
t = t + h;
}
}
if(i == n)
{
ma = t;
}
else
{
if(ma<t)
{
ma = t;
nu = i;
}
}
}
return (nu);
}

main()
{
int m,n;

printf(“Valor de m: “);
scanf(“%d”,&m);
printf(“Valor de n(mayor a m): “);
scanf(“%d”,&n);

if(n<m)
{
n=divisores(n,m);
}
else
{
n=divisores(m,n);
}

printf(“\nEl numero %d tuvo la mayor suma de sus divisores\n”,n);

getch();
return(0);
}

18.//a. escriba una función que recibiendo dos números devuelva si son amigos o
//no.
//b. escriba una función que tenga como entrada un número natural n y que
//‘escriba’ todas las parejas de números amigosque existan menores que n.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

void amistad(int n);

int amigos(int n1, int n2);

main()
{
int n;

printf(” Escriba un numero: “);

scanf(“%d”,&n);
amistad(n);
getch();
return(0);
}

void amistad(int n)
{
int i,j,t;
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
t = amigos(i,j);
if(t == 1)
{
printf(“%d y %d, “,i,j);
}
}
}
}

int amigos(int n1, int n2)

{
int j,t1,t2;
t1=1;

for(j=2;j<n1;j++)
{
if(n1%j == 0)
{
t1 = t1 + j;
}
}
t2=1;
for(j=2;j<n2;j++)
{
if(n2%j == 0)
{
t2 = t2 + j;
}
}

if(t1 == n2 && t2 == n1)

{
return 1;
}
else
{
return 0;
}
}

19.//Haga un programa que despliegue un menú que ayude en la operación de la

pizzería “Domino Cicom”. El programa debe
//contener dos funciones:
//*Pedido: solicita al usuario el tamaño de la pizza que desea ordenar y el número
de ingredientes que debe contener, y
//*Calcula: determina el precio de la pizza y el tiempo de entrega del pedido
realizado.
//Las pizzas chicas (‘c’) cuestan 70 pesos, las medianas (‘m’) 90, las grandes (‘g’)
110 y las familiares (‘f’) 130. Además, cada
//ingrediente solicitado cuesta 10 pesos.
//El tiempo de entrega de las pizzas es de 20 minutos, a menos que sea una pizza
familiar o que tenga más de 3 ingredientes, en cuyo
//caso el tiempo de entrega es de 30 minutos.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

int t=20;
int pedido(int a, char b)
{
int p;
switch( b )
{
case ‘c’:
p=70;
break;
case ‘m’:
p=90;
break;
case ‘g’:
p=110;
break;
case ‘f’:
p=130;
break;
}
if(a>3 || b==’f’)
t=30;
return (10*a)+p;
}

main()
{
char tam;
int n;
printf(“\n\nQue tamano de pizza desea:\n”);
printf(“\tc. 1-Chica\n”);
printf(“\tm. 2-Mediana\n”);
printf(“\tg. 3-Grande\n”);
printf(“\tf. 4-Familiar\n\n”);
scanf(“%c”,&tam);
printf(“Cuantos ingredientes desea\n”);
scanf(“%d”,&n);
printf(“\nEl valor de la pizza es: $%0.d”,pedido(n,tam));
printf(“\nLa pizza se demora %d minutos\n\n”,t);
getch();
return(0);
}

20.// Hacer un programa utilizando funciones que visualice el triángulo de Pascal.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

main()

{
int lim,triang[200][200],L,C;
printf (“Ingrese el límite de filas: “);
scanf (“%i”,&lim);
system (“cls”);
for (L=0; (L<lim); L++)
{
for (C=0; (C<=L); C++)
{
if ((C==0) || (L==C))
{
triang[L][C]=1;
}
else
{
triang[L][C]=triang[L-1][C]+triang[L-1][C-1];
}
}
}
for (L=0; (L<lim); L++)
{
for (C=0; (C<=L); C++)
{
printf (“%i “,triang[L][C]);
}
printf (“\n\n”);
}
getch ();
return(0);
}

21.//Haga un programa que le permita al usuario obtener los valoes delas

//funciones trigonométricas: seno , coseno, tangente y cotangente, utilizando
//las series de Taylor. El programa debe utilizar una función que le muestre
//al usuario un menú con las diversas operaciones, en donde se debe incluir
//la posibilidad de terminar. El programa llamará a la función
//correspondiente a la opción elegida por el usuario, solicitandole antes el
//valor de y que representa un ángulo en grados. Este valor debe ser
//convertido a radianes para poder utilizar las fórmulas. El fin del cálculo
//de la serie se dará cuando el valor absoluto del nuevo término sea menor o
//igual a 0.0001.

#include<stdio.h>
#include<stdlib.h>
#include<stdlib.h>

float pot(float b, int e);

double facto(int n);
float seno(float x);
float coseno(float x);

main()
{
float ang,val1,val2;
int op;
do{
printf(“\n 1) Seno”);
printf(“\n 2) Coseno”);
printf(“\n 3) Tangente”);
printf(“\n 4) Cotangente”);
printf(“\n 5) Salir”);
printf(“\n Escoja una opcion: “);
scanf(“%d”,&op);
if(op <5 && op>0)
{
printf(“\n Valor del angulo: “);
scanf(“%f”,&ang);
if(op == 1)
{
val1 = seno(ang);
printf(“>>El seno de este angulo es: %f”,val1);
}
else
{
if(op == 2)
{
val1 = coseno(ang);
printf(“>>El coseno de este angulo es: %f”,val1);
}
else
{
if(op == 3)
{
val1 = seno(ang);
val2 = coseno(ang);
val1 = val1/val2;
printf(“>>La tangente de este angulo es: %f”,val1);
}
else
{
val1 = seno(ang);
val2 = coseno(ang);
val1 = val2/val1;
printf(“>>La cotangente de este angulo es: %f”,val1);
}
}
}
}
}while(op != 5);
}

float seno(float x)
{
float pote,sen;
double fac,ter;
int i,j;

x = x * 0.0174533;
sen = 0;
j=1;
i=0;
ter=1;
while(ter > 0.0001)
{
fac = facto(j);
pote = pot(x,j);
ter = pote/fac;
if(i%2 == 0)
sen = sen + ter;
else
sen = sen – ter;
j = j + 2;
i+1;
if(ter<0)
ter = ter * -1;
}
return sen;
}

float coseno(float x)
{
float pote,sen,ter;
double fac;
int i,j;

x = x * 0.0174533;
sen = 0;
j=0;
ter=1;
i=0;
while(ter > 0.0001)
{
fac = facto(j);
pote = pot(x,j);
ter = pote/fac;
if(i%2 == 0)
sen = sen + ter;
else
sen = sen – ter;
j = j + 2;
i+1;
}
return sen;
}

float pot(float b, int e)

{
float p=1;
int i,t=0;
if(e==0 && b==0)
{
return 0;
}
if(e<0)
{
t=1;
e = e * -1;
}
for(i=0;i<e;i+1)
{
p = p * b;
}
if(t==1)
{
p = 1/p;
}
return p;
}

double facto(int n)
{
double f=1;
int i;
for(i=1;i<=n;i++)
{
f = f * i;
}
return f;
}

22.//Hacer un programa en Lenguaje C de forma modular que calcule los números

//narcisistas del 1 al 10000, el programa deberá generar una lista de aquellos
//números que cumplan con el requisito de ser narcisista.
//Un número narcisista es un Número de n dígitos que resulta ser igual a la
//suma de las potencias de orden n de sus dígitos.
//Ejemplo: 1 = 11
//153 = 1³ + 5³ + 3³.
//9474 = 94 + 44 + 74 + 44
//El programa deberá contener las siguientes funciones:
// Una función que cuente el número de dígitos de un número entero
// Una función potencia para calcular el resultado del dígito elevado a dicha
//potencia.
// Una función donde se desglosará el número en cifras, calcule la suma de
//potencias y diga si el número es o no narcisista.
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

int numdig(int n);

int potencia(int b, int e);
int narciso(int n);

main()
{
int i, n;

printf(“\n Listado de los numeros narcicistas: “);

for(i=1;i<10001;i++)
{
n = narciso(i);
if(n==1)
{
printf(“\n * %d “,i);
}
}
printf(“\n”);
getch();
return(0);
}

int numdig(int n)
{
int i=0;
while(n>0)
{
i+1;
n = n/10;
}
return (i);
}

int potencia(int b, int e)

{
int p=1,i;

for(i=0;i<e;i+1)
{
p = p * b;
}
return (p);
}

int narciso(int n)
{
int i,dig,sum=0, copia;
i = numdig(n);
copia = n;
while(n>0)
{
dig = n%10;
n = n /10;
sum = sum + potencia(dig,i);
}
if(sum == copia)
{
return (1);
}
else
{
return (0);
}
}

23.//La empresa metalmecánica del oriente nos contrata para diseñar un programa
que muestre rápidamente el valor de las escalas
//de temperatura de diferentes elementos de dicha empresa. Diseñe un programa
en lenguaje c que muestre en pantalla un menú con
//4 opciones así 1.Centígrados 2.Fahrenheit 3.kelvin 4.salir. El usuario al digitar la
opción correspondiente deberá escribir el valor de
//la temperatura en dicha escala y luego se muestra en pantalla el valor de la
temperatura digitada en las otras dos escalas. Por
//ejemplo si se escoge 1 y se escribe 32 se muestra en pantalla Centígrados 32,
Fahrenheit 89.6 y Kelvin 305.15 La conversión de
//temperaturas se basa en las siguientes formulas
//Centígrados (C) a Fahrenheit (F) F= C x (9 / 5) + 32
//Fahrenheit (F) a Centígrados (C) C= (F-32) x (5 / 9 )
//Centígrados a Kelvin(K) K = C + 273.15
//Kelvin(F) a Centígrados(C) C = K – 273.15
//Diseñe las funciones en C que realicen las conversiones de temperaturas
necesarias para cada una de las opciones y utilice estas
//funciones en el main para dar respuesta al menú.
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

float f_centigrados(float e,float a);

float f_kelvin(float j,float b);
float f_fahrenheit(float v,float g);

main()
{
float n,c,grafa,grake,grace,k,f;
printf(“Digite 1 centigrados\nDigite 2 fahrenhei\nDigite 3 kelvin\nDigite 4 si desea
salir\n”);
scanf(“%f”,&n);
if(n!=4)
{
if(n==1)
{
printf(“Ingrese los grados centigrados\t”);
scanf(“%f”,&c);
grafa=f_fahrenheit(n,c);
grake=f_kelvin(n,c);
printf(“%f Grados centigrados\n%f \tGrados fahrenheit\n%f \tGrados
kelvin\n”,c,grafa,grake);
}
else
{
if(n==2)
{
printf(“Ingrese los grados fahrenheit\t”);
scanf(“%f”,&f);
grace=f_centigrados(n,f);
grake=f_kelvin(n,f);
printf(“%f \tGrados fahrenheit\t \n%f \tGrados centigrados\t \n%f \tGrados
kelvin\n”,f,grace,grake);
}
else
{
if(n==3)
{
printf(“Ingrese los grados kelvin\t”);
scanf(“%f”,&k);
grace=f_centigrados(n,k);
grafa=f_fahrenheit(n,k);
printf(“%f \tGrados kelvin\t \n%f \tGrados centigrados\t \n%f \tGrados
fahrenheit\n”,k,grace,grafa);
}
else
{
printf(“La en trada no es valida\n”);
}
}
}
}
getch();
return(0);
}

float f_centigrados(float e,float a)

{
float u;
if(e==2)
{
u=(a-32)*(5/9);
}
else
{
u=a-273,15;
}

return(u);
}

float f_fahrenheit(float v,float g)

{
float m,l;
if(v==1)
{
m=(g*9/5)+32;
}
else
{
l=g-273,15;
m=(l*9/5)+32;}
}

return (m);
}

float f_kelvin(float j,float b)

{
float y,s;
if(j==1)
{
y=b+273,15;
}
else
{
s=(b-32)*(5/9);
y=s+273,15;
}
return(y);
}

24.//Determine la cantidad mínima de billetes y muestre la forma de pagar una

//cuenta (considere la cuenta en múltiplos de 10.000 únicamente), sabiendo
//que las denominaciones de los billetes son 10.000, 20.000, y 50.000.
//* nota 1: Debe validar que el valor de entrada (cuenta) sea múltiplo de
// 10.000 por medio de una función que tiene como parámetro el valor de la
// cuenta y devuelva 1 sí es múltiplo de 10.000 y 0 sí no lo es.
//* nota 2: Debe implementar una función que tiene como parámetro el valor
// de la cuenta y la denominación del billete y que devuelva elnúmero de
// billetes de esa denominación que se utilizará para pagar la cuenta.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

int valido(long int di);

int billetes(long int di,long int op);

main()
{
long int cant;
int op,bi;
do{
printf(“\n ** Cantidad que desea cobrar? “);
scanf(“%ld”,&cant);
op = valido(cant);
if(op == 0)
{
printf(“\nERROR: La cifra no es multiplo exacto de 10.000 (tiene unidades,
decenas y/o centenas)\n”);
}
}while(op == 0);
bi=billetes(cant,50000);
printf(“\nSe entregaran %d billetes de 50.000”,bi);
cant = cant – (bi*50000);
bi=billetes(cant,20000);
printf(“\nSe entregaran %d billetes de 20.000”,bi);
cant = cant – (bi*20000);
bi=billetes(cant,10000);
printf(“\nSe entregaran %d billetes de 10.000\n”,bi);

getch();
return(0);
}

int valido(long int di)

{
int j;
j = di % 10000;
if(j==0)
return (1);
else
return (0);
}

int billetes(long int di, long int op)

{
int j;
j= di/op;
return(j);
}

25.//Hacer una función en C que permita calcular la suma de los divisores

//pares de un numero entero positivo dado y otra función que permita
//pares de un numero entero positivo dado y otra funcion qur permita
//calcular la suma de los divisores impares de un número entero positivo
//dado. En el main el programa capturar un número entero positivo y
//hallar el cociente entre la suma de los divisores pares sobre la suma de
//sus divisores impares.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int sumapar(int n);
int sumaimpar(int n);

main()
{
int n;
float supa,suim,co;
printf(” Escriba un entero: “);
scanf(“%d”,&n);
supa = sumapar(n);
suim = sumaimpar(n);
co = supa / suim;
printf(“\n\nLa suma de los multiplos pares dio: %0.f”,supa);
printf(“\nLa suma de los multiplos impares dio: %0.f”,suim);
printf(“\nEl cociente es : %0.f\n”,co);
getch();
return(0);
}

int sumapar(int n)
{
int i,sum=0;
for(i=2;i<=n;i=i+2)
{
if(n%i == 0)
{
sum = sum + i;
}
}
return sum;
}

int sumaimpar(int n)
{
int i,sum=0;
for(i=1;i<=n;i=i+2)
{
if(n%i == 0)
{
sum = sum + i;
}
}
return sum;
}
26.//Cree un programa en C modular que: descomponga un número N de 6 dígitos
en
//tres números de 2 dígitos y calcule la siguiente formula:
// X! + Z^y X= 2 primero digitos
// R = – ———- Y= los 2 digitos del medio
// (X+Z)! Z= 2 ultimos digitos
//
//donde x, y, z se encuentran son los tres números de dos cifras que componen
//el número N
//Ej: N = 230411 al descomponer el número x=23 y=04 z=11
//Cree las siguientes Funciones:
// Función verificar que recibe el número N y determina si el número es de 6
// dígitos, Si es de 6 dígitos debe retornar un 1 pero si no debe retornar
// un 0.
// Función Calcular que recibe el número N y lo descompone para calcular el
// resultado de la formula
// Función Potencia
// Función Factorial

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

int verificar(long int n);

float calcular(long int n);
float pot(float b, int e);
long int facto(int n);

main()
{
long int nu;
int ver;
float val;
do
{
printf(“\n ** Escriba un numero de entero de 6 digitos: “);
scanf(“%ld”,&nu);
ver =verificar(nu);
}
while(ver == 0);
val = calcular(nu);
printf(“\nEl resultado es: %f\n”,val);
getch();
return(0);
}

int verificar(long int n)

{
if(n>99999 && n<1000000)
{
return (1);
}
else
{
return (0);
}
}

float calcular(long int n)

{
float xy, resul;
long int xf, xyf;
int x,y,z;
x = n/10000;
y = (n/100)%100;
z = n %100;

printf(“%d %d %d “,x,y,z);
xf = facto(x);
xy = pot(x,y);
xyf = facto(x+y);

resul = (xf + xy) / xyf;

return (resul);
}

float pot(float b, int e)

{
float p=1;
int i,t=0;
if(e==0 && b==0)
{
printf(“INDEFINIDO”);
return (0);
}

if(e<0)
{
t=1;
e = e * -1;
}
for(i=0;i<e;i+1)
{
p = p * b;
}
if(t==1)
{
p = 1/p;
}
return (p);
}

long int facto(int n)

{
long int f=1;
int i;
for(i=1;i<=n;i+1)
{
f = f * i;
}
return (f);
}

27.//Realizar las siguientes funciones:

// Una función denominada calcular_sumatoria_divisores que reciba un valor n y
devuelva la sumatoria de los divisores
//propios del valor n.
// Una función denominada valorar que reciba dos valores (el valor n y la sumatoria
de los divisores propios de dicho
//número) y devuelva : 0 si es perfecto, 1 si es abundante, 2si es deficiente
//El programa principal (main) debe calcular entre X y Y leídos por teclado, cuantos
números son deficiente, abundantes y
//perfectos. Para realizar estos procesos debe utilizar las funciones anteriores
definidas en el presente enunciado.
//Número perfecto es cuando la suma de sus divisores propios es igual al número
ejemplo el 6 sus divisores son 1+2+3 = 6
//Número deficiente cuando la suma de sus divisores es menor al número ejemplo
4
//Divisores 1+2 =3
//Número abundante cuando la suma de sus divisores es mayor al número ejemplo
12
//Divisores 1+2+3+4+6 =16
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

int Fcalsumdiv(int n)
{
int c,sumatoria=0;
for(c=1;c<n;c++)
{
if(n%c==0)
sumatoria= sumatoria+c;
}
return(sumatoria);
}

int Fvalor(int n, int sum)

{
if(sum==n)
return(0);
else
{
if(sum>n)
return(1);
else
return(2);
}
}

int Fcalsumdiv(int n);

int Fvalor(int n, int sum);

main()
{
int x,y,sum,valorar,c,acumper=0,acumab=0,acumd=0;
printf(“ingrese x”);
scanf(“%d”,& x);
printf(“ingrese y”);
scanf(“%d”,& y);
for(c=x; c<=y; c++)
{
sum=Fcalsumdiv(c);
printf(“sumatoria %d = %d\n”,c, sum);
valorar=Fvalor(c,sum);
if(valorar==0)
{
acumper+1;
}
else
{
if(valorar==1)
{
acumab+1;
}
else
{
acumd+1;
}
}
}
printf(“total de perfectos %d\n”, acumper);
printf(“total de abundantes %d\n”, acumab);
printf(“total de deficientes %d\n”, acumd);
getch();
return(0);
}

28.//Dados dos números X y N enteros positivos, calcular con la ayuda de dos

//funciones la siguiente formula matemática:
// (N + (1+X)!)^X
// R = – —————
// (X*2)^N!
// Realizar el main, la función potencia y la función factorial.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

float calcular(long int n);

float pot(float b, int e);
long int facto(int n);

main()
{
int n,x ;
long int fac1,fac2;
float po1,po2,r;
printf(“\n Valor de N:”);
scanf(“%d”,&n);
printf(“\n Valor de X:”);
scanf(“%d”,&x);
fac1 = facto(1+x);
fac2 = facto(n);
po1 = pot(n+fac1,x);
po2 = pot(x*2,fac2);
r = po1 / po2;
printf(“\nEl resultado es: %f\n”,r);
getch();
return(0);
}

float calcular(long int n)

{
float xy, resul;
long int xf, xyf;
int x,y,z;
x = n/10000;
y = (n/100)%100;
z = n %100;

printf(“%d %d %d “,x,y,z);
xf = facto(x);
xy = pot(x,y);
xyf = facto(x+y);

resul = (xf + xy) / xyf;

return (resul);
}

float pot(float b, int e)

{
float p=1;
int i,t=0;
if(e==0 && b==0)
{
printf(“INDEFINIDO”);
return (0);
}

if(e<0)
{
t=1;
e = e * -1;
}
for(i=0;i<e;i+1)
{
p = p * b;
}
if(t==1)
{
p = 1/p;
}
return (p);
}

long int facto(int n)

{
long int f=1;
int i;
for(i=1;i<=n;i+1)
{
f = f * i;
}
return (f);
}

29.//Se dice que dos número N y M son números amigos si la suma de los
divisores
//propios de N da como resultado M y al mismo tiempo la suma de los divisores
//propios de M da como resultado N.
//El conjunto de divisores propios de un número N, está formado por todos sus
//divisores, Excepto él mismo. Ejemplo
//Los divisores propios de 284 son 1,2,4,71 y 142 ;
//su suma resulta igual a 220.
//Los divisores propios de 220 son 1,2,4,5,10,11,20,22,44,55 y 110;
//su suma resulta igual a 284.
//Por lo tanto 284 y 220 son números amigos.
//Hacer un programa en C que lea dos número (N,M) y diga si son amigos o no,
//haciendo uso de un subprograma (función) que calcule la suma de los
//divisores propios de un número dado.

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int sumdiv(int n);

main()
{
int n1, n2,sum1,sum2;
printf(” Primer valor: “);
scanf(“%d”,&n1);
printf(” Segundo valor: “);
scanf(“%d”,&n2);
sum1=sumdiv(n1);
sum2=sumdiv(n2);
printf(“\nLa suma de los divisores de %d es: %d”,n1,sum1);
printf(“\nLa suma de los divisores de %d es: %d”,n2,sum2);

if(sum1==n2 && sum2==n1)

{
printf(“\npor lo tanto son: NUMERO AMIGOS\n”);
}
else
{
printf(“\npor lo tanto NO son: NUMERO AMIGOS\n”);
}
getch();
return(0);
}

int sumdiv(int n)
{
int j,t;
t=1;
printf(“\nDivisores de %d: 1”,n);
for(j=2;j<n;j++)
{
if(n%j == 0)
{
t = t + j;
printf(“,%d”,j);
}
}
return(t);
}

30.//172-Realice un programa en C, que lea un número entero positivo N, para que

//acumule y calcule los números perfectos que existen hasta el número N.
// En el main() debe leer el valor de N, realizar el llamado a las funciones
//necesarias (evalua_perfectos y acum_perfectos) e imprimir el resultado de
//dicho acumulado.
// Una función (evalua_perfectos) que permita evaluar, si el valor recibido
//es un número perfecto o no. Debe retornar el valor 1 (si es perfecto) o el
//valor 0 (si no es perfecto)
// La función (acum_perfectos) que acumule el valor de los números perfectos
//menores que un número N dado (Haga uso de la función anterior).
//Ejemplo: Se lee n que es ( 30 ), entonces:
//Perfectos que existen hasta N (30) : 6 , 28
//Acumulado de los perfectos hasta N es : 34
//Nota: Un número es perfecto si es igual a la suma de sus divisores,
//incluyendo al 1 y exceptuando a él mismo. Por ejemplo, 6 es perfecto porque
//6 =1+2+3.

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int acum_perfectos(int n);

int evalua_perfectos(int n);

main()
{
int n,sum;

printf(“\nPROGRAMA PARA ACUMULAR LOS NUMEROS PERFECTOS

MENORES A n\n”);
printf(“\n ** Valor de n: “);
scanf(“%d”,&n);
sum = acum_perfectos(n);
printf(“\nLa suma de los numeros perfectos menores que n es: %d\n”,sum);
getch();
return(0);
}

int acum_perfectos(int n)
{
int i,sum=0,j;
for(i=2;i<n;i+1)
{
j = evalua_perfectos(i);
if(j == 1)
{
sum = sum + i;
}
}
return (sum);
}

int evalua_perfectos(int n)
{
int i,sum=0;

for(i=1;i<n;i+1)
{
if(n%i == 0)
{
sum = sum +i;
}
}
if(sum == n)
{
return (1);
}
else
{
return (0);
}
}

31.//Los estudiantes de la universidad de Pamplona están preocupados por sus

//definitivas y le han solicitado a usted que cree un programa que lea el
//código del estudiante y las notas de los tres cortes (excepto la del examen
//final), el número de estudiantes es indeterminado (la lectura termina cuando
//el código del estudiante sea 0), el programa debe determinar la nota
//acumulada del estudiante, la nota que debe sacar el estudiante para pasar y
//el porcentaje de estudiantes que tiene el ponderado por encima de 2.5.
//Realice:
// Main
// Función Acumulado: que Reciba las 5 notas (Nota 1 (Examen 20%), Nota 2
// (TrabajoQuiz 15%), Nota 3 (Examen 20%), Nota 4 (TrabajoQuiz 15%) y Nota
5
// (TrabajoQuizFinal10%)) y retorne en cuanto lleva la materia el estudiante.
// Función Cálculo: que reciba en cuanto lleva el estudiante la materia y
// retorne cuanto debe sacar en el último examen para pasar la materia.
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

float acumulado(float n1,float n2,float n3,float n4,float n5);

float calculo(float acu);

main()
{
float n1,n2,n3,n4,n5,acu,final,por;
int cod=3,con=0,tot=0;

while(cod != 0)
{
printf(“\n\nPROGRAMA PARA DETERMINAR CUANTO SE NECESITA PARA
PASAR”);
printf(“\nCodigo del estudiante (0 para terminar): “);
scanf(“%d”,&cod);
if(cod != 0)
{
tot+1;
printf(“Nota 1(examen 20%%): “);
scanf(“%f”,&n1);
printf(“Nota 2(Trabajos/quices 15%%): “);
scanf(“%f”,&n2);
printf(“Nota 3(examen 20%%): “);
scanf(“%f”,&n3);
printf(“Nota 4(Trabajos/quices 15%%): “);
scanf(“%f”,&n4);
printf(“Nota 5(Trabajos/quices finales 10%%): “);
scanf(“%f”,&n5);
acu = acumulado(n1,n2,n3,n4,n5);
if(acu > 2.5)
{
con+1;
}
printf(“El estudiante tiene una acumulado de: %f”,acu);
final=calculo(acu);
if(final>0)
{
printf(“\nEl estudiante necesita sacar: %f para pasar”,final);
}
else
{
printf(“\nEl estudiante ya paso la materia”);
}
}
}
if(con>0)
{
por = con;
por = (por*100)/tot;
}
else
{
por=0;
}
printf(“\nEl %f %% de los estudiantes tuvo un ponderado por encima de
2.5\n”,por);
getch();
return(0);
}

float acumulado(float n1,float n2,float n3,float n4,float n5)

{
float nota;
nota = (n1*0.2)+ (n2*0.15)+ (n3*0.2)+ (n4*0.15)+ (n5*0.1);
return(nota);
}

float calculo(float acu)

{
float nota;
nota = (3 – acu)/0.2;
return(nota);
}

32.//Hacer un programa en C utilizando funciones que lea un número entero

positivo de cualquier cantidad de dígitos (cifras), que
//averigüe e imprima lo siguiente: si la cantidad de cifras es impar averiguar si el
número es capicúa (Ej:585,25352) y el si la
//cantidad de cifras es par, averiguar si el número es múltiplo de 4 y termina en 8
(Ej:28).
//NOTA: Debe tener las siguientes funciones:
// main.
// Una función que reciba el número leído y devuelva 1 (UNO) si la cantidad de
cifras es impar y devuelva 0 (CERO) si la
//cantidad de cifras es par.
// Una función que reciba el número cuya cantidad de dígitos sea impar y que
devuelva 1 (UNO) Si el número es capicúa
//(Ej:585,25352) y devuelva 0 (CERO) si el número NO es capicúa. (Ej:485,35352).
// Una función que reciba el número cuya cantidad de dígitos sea par y que calcule
e imprima si el número es múltiplo de 4 y
//termina en 8. (Ej:28).

#include<stdlib.h>
#include<stdio.h>
#include<conio.h>

int F_verificar(int n);

int F_capicua(int n);
void F_multiplo(int n);

main()
{
int n, ver, ca;
printf(“Ingrese el numero\n”);
scanf(“%d”,& n);
printf(“El numero %d\n”, n);
ver= F_verificar(n);
if(ver == 1)
{
ca= F_capicua(n);
printf(“%d\n”, ca);
if(ca == 1)
printf(“El numero es capicua\n”);
else
printf(“El numero no es capicua\n”);
}
else
{
F_multiplo(n);
}
getch();
return(0);
}

int F_verificar(int n)
{
int c=0, copia= n;
printf(“%d\t”, copia);
while(copia > 0)
{
c+1;
copia= copia/10;
}
printf(“contador %d\n”, c);
if(c%2==0)
return(0);
else
return(1);
}

int F_capicua(int n)
{
int copia= n, nuevo=0, digito;
while(copia > 0)
{
digito= copia%10;
nuevo= (nuevo*10) + digito;
copia= copia/10;
}
printf(“NUEVO: %d”, nuevo);
if(nuevo==n)
return(1);
else
return(0);
}

void F_multiplo(int n)
{
if((n%4==0)&&(n%10==8))
printf(“Es multiplo de 4 y termina en 8”);
else
printf(“No es multiplo de 4 ni termina en 8”);
}

33.//La biblioteca pública de la ciudad de Pamplona tiene sistematizado el total

//de libros que posee, y desea que usted cree un programa que ayude en el
//control de préstamos y recolección de libros, la cantidad de personas que
//visitan la biblioteca es indeterminada de ellos se conoce: Tipo de Servicio
//(1. Préstamo (Llevarse el libro para la casa) o 2. Entrega) y el código del
//libro.
//El proceso de préstamo y recolección termina cuando el tipo de servicio es 0.
//Realice un programa que lea el tipo de servicio y el código del libro y si
//es un código debe determinar si se puede prestar el libro o el valor a
//cobrar por los libros prestados (según el tipo de servicio solicitado) y al
//final imprimir el total recaudado por prestamosde libros.
//El código del libro está compuesto por 8 dígitos donde los tres primeros
//representan el área del Libro, los siguientes dos la cantidad de libros que
//existen y los últimos 3 el identificador del libro.
//Ej: Para el código 10105153
//El área es 101 la cantidad de libros es 05 y su código de identificación es
//153
//Realice:
// Main()
// Función Validar código: Debe recibir el código del libro y este debe cumplir: ser
un número de 8 dígitos, el área debe
// estar entre 101 y 108 y la cantidad debe ser diferente de 0. Si cumple debe
retornar un 1(uno), si no cumple debe retornar
// un 0 (cero).
// Función Préstamo: La función debe recibir el código del libro y solo se pueden
prestar libros del área 101, 102 y 104. La
// función debe retornar 1 (uno) si se puede prestar o 0 (cero) si no se puede
realizar el préstamo
// Función Recolección: La función debe recibir el código del libro y dependiendo
de la cantidad de ejemplares disponibles
// se cobra un valor al usuario según la siguiente tabla, debe retornar el valor que
se debe cobrar

// Cantidad de ejemplares existentes Valor del servicio de préstamo

// 1a2 $2.000
// 3a6 $1.000
// Mas de 6 $ 500

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int validar(long int cod);

int prestar(long int cod);
int recojer(long int cod);

main()
{
int op,j,costo;
long int cod;

printf(“\nPROGRAMA PARA MANEJAR LA BIBLIOTECA PUBLICA\n”);

do{
printf(“\n ** OPCIONES DE SERVICIO”);
printf(“\n ** 0 ** Salir del sistema.”);
printf(“\n ** 1 ** Prestamos “);
printf(“\n ** 2 ** Entrega “);
do{
printf(“\n >> Que opcion desea? “);
scanf(“%d”,&op);
}while(op<0 || op>2);
if(op >0)
{
do{
printf(“\n Codigo del libro? “);
scanf(“%ld”,&cod);
j=validar(cod);
if(j==0)
{
printf(“ERROR: codigo no valido”);
}
}while(j == 0);
if(op == 1)
{
j= prestar(cod);
if( j == 1)
{
printf(“<<< EL libro se le puede prestar por 5 dias >>>”);
}
else
{
printf(“<<< EL libro no puede ser prestado >>>”);
}
}
else
{
costo = recojer(cod);
printf(“<<<EL costo del prestamo es de: %d>>>”,costo);
}
}
}while(op > 0);
}

int validar(long int cod)

{
int pri,med;

pri = cod / 100000;

med = (cod/1000)%100;
if(pri > 100 && pri <109 && med>0)
{
return (1);
}
else
{
return (0);
}
}

int prestar(long int cod)

{
int pri;

pri = cod/100000;
if(pri == 101 || pri == 102 || pri == 104 )
{
return (1);
}
else
{
return (0);
}
}

int recojer(long int cod)

{
int med;

med = (cod/1000)%100;
if(med <3)
{
return (2000);
}
else
{
if(med <7)
{
return (1000);
}
else
{
return (500);
}
}
}
34.//Dado un número de 6 cifras, hacer un programa en forma modular que realice
lo siguiente:
//Descomponga un número N de 6 dígitos en tres números de dos dígitos cada
uno en la función main (siempre y cuando el número
//sea de 6 dígitos).Cree las siguientes Funciones:
// Función verificar que recibe el número N y determina si el número es de 6
dígitos, Si es de 6 dígitos debe retornar un 1
//pero si no debe retornar un 0. si el numero es de 6 cifras debe continuar
// Función Calcular_tabla que recibe los números a y b y genera las tablas de
multiplicar de a hasta b, donde a debe ser
//menor que b.

#include<conio.h>
#include <stdio.h>
#include<stdlib.h>

main ()
{
int n,x,p,k=1;
printf(“DIGITE EL NUMERO HASTA DONDE QUIERE LAS TABLAS: “);
scanf(“%d”,&n);
do
{
printf(“LA TABLA DEL %d ES \n”,k);
if(n<=10);
{
for (x=1;x<=10;x++)
{
p=x*k;

printf(“%d x %d = %d \n”,k,x,p);
}
}

while(k>n)

while(n<10)
{
for (x=1;x<=n;x+1)
{
p=x*n;
printf(“%d x %d = %d \n”,n,x,p);
}
}
printf(“\n”);
k++;
}
while(k<=n);

getch();
return(0);

35.//Una empresa de seguros desea que usted cree un programa que permita
validar
//el código de una póliza de seguro, determinar el tipo de seguro y el valor
//que se debe pagar el cliente (monto) en una clínica al momento de presentar
//el seguro. La cantidad de pólizas que se consultarán es indeterminado, solo
//se sabe que la lectura del código de las pólizas termina cuando este número
//sea 0.
//El Código de la póliza esta compuesto por 7 dígitos donde el primero
//corresponde al tipo de póliza (Ver tabla). Los tipos de pólizas de seguro
//son los siguientes.

// Tipo Cobertura
// 1. Total El 100% del Total del pago
// 2. Normal Cubre el 100% si no sobrepasa 1’000.000 y si lo
// sobrepasa solo cubre el 70% del pago
// 3. Básica Para cualquier monto cubre el 65% del pago
// Cree las siguientes funciones:
// Main
// Función Validar Código: que debe recibir el código de la póliza y
// verificar que el código sea de 7 dígitos, que el primer dígito este entre
// 1 y 3 y la suma del último dígito con el primero debe ser par. Si cumple,
// el número de póliza es valido debe retornar un 1 sino debe retornar un 0.
// Función CalcularPago: que debe recibir el código del seguro y el monto a
// pagar y retornará el valor que se debe pagar la persona.

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int validar(long int nu);

float calcular_pago(long int nu, float mon);
main()
{
int n;
long int nu;
float mon;

printf(“\nPROGRAMA PARA MANEJAR LOS PAGOS DE UNA EMPRESA DE

SEGUROS\n”);
do{
printf(“\nCodigo del asegurado (# de 7 digitos o 0 para terminar): “);
scanf(“%ld”,&nu);
if(nu>0)
{
n=validar(nu);
if(n>0)
{
printf(“\nMonto de la hospitalizacion: “);
scanf(“%f”,&mon);
mon = calcular_pago(nu,mon);
printf(“\nEl seguro pagara %f pesos\n”,mon);
}
else
{
printf(“\nEl codigo no es valido…\n”);
getch();
}
}
}while(nu>0);
}

int validar(long int nu)

{
int n=0,u,p;

u = nu%10;
while(nu>0)
{
n+1;
p = nu % 10;
nu = nu / 10;
}
if(n != 7 || p<0 || p>3 || (u+p)%2 == 1)
{
return (0);
}
else
{
return (1);
}
}

float calcular_pago(long int nu, float mon)

{
while(nu>9)
{
nu = nu/10;
}
if(nu ==2)
{
if(mon>1000000)
{
mon = mon*0.7;
}
}
else
{
if(nu ==3)
{
mon = mon * 0.65;
}
}
return (mon);
}

36./*Haga un programa en C de manera modular (usando funciones) para el

siguiente
problema: la empresa “rapinet” ofrece el servicio de Internet de acuerdo a
las siguientes condiciones:
La tarifa se cobra por horas y minutos de la siguiente forma: Si el número
de minutos es menor de 30 no se le cobran los minutos extras (solo las horas
enteras) si los minutos están entre 30 y 45 se cobra a 15 pesos los minutos
que exceden de 30 y si los minutos son mayores de 45 se le cobra una hora
completa.
La tarifa por horas depende del número de horas que navegue de acuerdo a la
siguiente tabla
Tiempo de navegación Valor a pagar por hora
De 1 a 5 horas 1500 pesos por hora
De 5 a 10 horas 1200 pesos por hora
Más de 10 horas 900 pesos por hora
La empresa ofrece el 10% de descuento sobre el total a pagar, para las
personas cuya cuenta supere los 10000 pesos.
Dado por teclado el tiempo de navegación de cada una de las personas que
reciben el servicio en un día, hacer un programa en C que calcule el total
a pagar de cada una de las personas que hacen uso del servicio y el total
recaudado por la empresa en un día.
Para ello desarrolle las siguientes funciones
Una función llamada “calcular” que calcule el total a pagar (sin descuento)
conociendo el número de horas y minutos navegados
Una función llamada “descuento” que calcule el total de dinero a descontar
por el servicio de Internet, conociendo el total a pagar sin descuento.
En el main se debe capturar las horas y minutos de navegación de cada uno
de los clientes del día. Como no se conoce el número de clientes que
atiende la empresa durante el día, el proceso termina cuando el número de
horas navegadas sea un número negativo. En el main también hay que calcular
el total recaudado por la empresa en dicho día.
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

float calcular(int h, int m);

float descuento(float p);

main()
{
int h,m;
float total=0,mon,des;

printf(“\nPROGRAMA PARA MANEJAR UN INTERNET”);

do{
printf(“\nNumero de horas (negativas para salir): “);
scanf(“%d”,&h);
if(h>=0)
{
printf(“Numero de minutos: “);
scanf(“%d”,&m);
mon = calcular(h,m);
des = descuento(mon);
mon = mon – des;
total = total + mon;
printf(“\nEl cliente debe pagar $%.5f pesos se dio $%.5f pesos de
descuento\n\n”,mon,des);
}
}while(h>=0);
printf(“\nAl final del dia se recaudo: $%.5f pesos\n”,total);
getch();
return(0);
}

float calcular(int h, int m)

{
float monto=0;
if(m>29)
{
if(m>45)
{
h+1;
}
else
{
monto = ( m – 30 )* 15;
}
}
if(h<5)
{
monto = monto + h*1500;
}
else
{
if(h<11)
{
monto = monto + h*1200;
}
else
{
monto = monto + h*900;
}
}
return (monto);
}

float descuento(float p)
{
if(p<10000)
{
return (0);
}
else
{
p = p*0.1;
return (p);
}
}

37./*Dado un número de cualquier cantidad de cifras, sumar las cifras que son
menores o iguales del número de cifras que componen el número.
Ejemplos
Si le número dado es 7428 tiene 4 cifras y los dígitos de 7428 que son
menores o iguales de 4 son 4 y 2, por lo tanto la suma da 6
Si el número dado es 924 tiene 3 cifras y el único dígitos de 924 que es
menor o iguales de 3 es el 2 y por lo tanto la suma es 2
Si el número es 23418 tiene 5 cifras y los dígitos de 23418 que son menores
o iguales de 5 son el 2, el 3, el 4 y el 1 y por lo tanto la suma es 10
Si el número dado es 7 tiene 1 cifra y este número no tiene dígitos menores
o iguales a 1 por lo tanto la suma es cero
Hacer las siguientes funciones en C:
Una función que dado un número entero como parámetro devuelva el número
de cifras que tiene dicho número
Una función que dado un número entero de cualquier cantidad de dígitos y
un número entero de un dígito, sume los dígitos del primer parámetro que
sean menores o iguales del segundo parámetro
Realizar el main en el cual se capture por teclado cinco números enteros
de cualquier cantidad de dígitos e imprima para cada uno de ellos la suma
de los dígitos menores o iguales del número de cifras que tiene cada
número tecleado
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int numdig(int n);

int suma(int nu, int n);

main()
{
int n,nu,sum,i;

printf(“\nPROGRAMA PARA TOMAR UN NUMERO Y SUMAR LOS DIGITOS

MENORES”);
printf(“\n AL NUMERO DE DIGITOS DEL MISMO\n”);
for(i=0;i<5;i+1)
{
printf(“\nEscriba un numero (quedan %d)”,4-i);
scanf(“%d”,&nu);
n = numdig(nu);
printf(“El numero tiene %d digitos, “,n);
sum = suma(nu,n);
printf(“la suma de los digitos menores a %d es: %d\n”,n,sum);
}
getch();
return(0);
}

int numdig(int n)
{
int i=0;
while(n>0)
{
n=n/10;
i++;
}
return (i);
}

int suma(int nu, int n)

{
int sum=0,d;
while(nu>0)
{
d=nu%10;
if(d<n)
{
sum = sum + d;
}
nu=nu/10;
}
return (sum);
}

38./*Una empresa tiene sus productos codificados mediante referencias

compuestas
por 4 cifras. Las dos primeras cifras representan un consecutivo del
producto, las siguientes dos cifras representan la línea de producción a la
que pertenece (por ejemplo la referencia 7211 esta asignada a un producto
cuyo consecutivo es 72 y pertenece a la línea 11). En la empresa existen
solo tres líneas de producción 11, 22 y 44. Elabore un programa en C que lea
n referencias validas de productos (n dado por teclado), sus costos de
producción y precios de venta e indique cual es el producto que más ganancia
le genera a la empresa.
Para ello debe implementar las siguientes funciones:
Una función que lea n referencias de productos, sus costos de producción y
su valor de venta de cada uno y retorne la referencia del producto que más
ganancia le genera a la empresa.
Una función que verifique si se trata de una referencia valida y retorne 1
si es valida y 0 si no lo es.
Una función que reciba la referencia de cada producto, su costo de
producción y su valor de venta y retorne el valor que aporta de ganancia
dicho producto.
La función main
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int masgana(int n);

int validar(int ref);
float ganan(float v, float c);

main()
{
int m,n;

printf(“\nNumero de referencias a revisar: “);

scanf(“%d”,&n);
m = masgana(n);
if(m>0)
{
printf(“\nLa referencia del producto que mas ganacias dio es: %d\n”,m);
}
else
{
printf(“\nNo hubo ventas\n”);
}
getch();
return(0);
}
int masgana(int n)
{
int i,r,v,mas=0;
float mayga=0,g,cos,ven;

for(i=0;i<n;i+1)
{
printf(“\nNumero de la referencia (4 digitos): “);
scanf(“%d”,&r);
v=validar(r);
if(v>0)
{
printf(“Precio de venta: “);
scanf(“%f”,&ven);
printf(“Costo de produccion: “);
scanf(“%f”,&cos);
g=ganan(ven,cos);
printf(“La ganancia del producto fue de: %.3f pesos\n”,g);
if(g>mayga)
{
mayga = g;
mas = r;
}
}
else
{
printf(“ERROR: referencia incorrecta\n”);
}
getch();
}
return (mas);
}

int validar(int ref)

{
int n,i=0;
n=ref;
while(n>0)
{
n= n /10;
i++;
}
if(i==4)
{
n=ref/100;
if( n== 11 ||n== 22 ||n== 44 )
return (1);
}
return (0);
}

float ganan(float v, float c)

{
float g;
g = v-c;
return (g);
}

39./*Desarrolle un programa que permita capturar por teclado 10 números

ingresados por el usuario, de seis o más cifras. Para cada número ingresado
el programa deberá comprobar si el número es de seis o más cifras, si es así
deberá separarlo en dos números independientes (uno compuesto por las cifras
pares y otro compuesto por las cifras impares), para el programa se deberán
crear las siguientes funciones:
Función comprobar: La función deberá recibir como parámetro de entrada un
número, y deberá retornar uno (1) si el número es de seis o más cifras, y
cero (0) si el número tiene menos de seis cifras.
Función numerodescompuesto: La función deberá recibir como parámetro de
entrada un número, deberá descomponerlo en sus cifras (de derecha a
izquierda) y deberá formar dos nuevos números uno con las cifras pares, y
otro con las cifras impares, la función debe retornar el número mayor de
los dos generados.
Ej. La función recibe como parámetro de entrada el número 1548792397563
deberá generar los siguientes números 157939753 y 4826, y deberá retornar
el número 157939753 dado que este es el mayor de los dos generados.
Función main: La función permitirá ingresar 10 números al usuario
(implementar por medio de ciclo) y deberá realizar lo solicitado en el
programa usando las funciones antes descritas
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int comprobar(long int n);

int numerodescompuesto(long int n);
main()
{
long int n;
int i,v;

printf(“\nPROGRAMA PARA TOMAR NUMEROS DE 6 O MAS CIFRAS Y

FORMAR OTROS DOS NUMEROS\n”);
printf(“\n UNO CON LOS DIGITOS PARES Y OTRO CON LOS IMPARES\n”);

for(i=0;i<5;i+1)
{
printf(“\nEscriba un numero (6 o mas cifras): “);
scanf(“%ld”,&n);
v = comprobar(n);
if(v>0)
{
n = numerodescompuesto(n);
printf(“\nEl mayor de los numeros fue: %ld\n”,n);
}
else
{
printf(“\nEl numero no cumple con las condiciones requeridas\n”);
}
getch();
}
}

int comprobar(long int n)

{
int i=0;
while(n>0)
{
n = n/10;
i++;
}
if(i>5)
return (1);
else
return (0);
}

int numerodescompuesto(long int n)

{
long int p=0,i=0,div=1;
int d;
while(div<n)
{
div = div*10;
}
div = div/10;
while(n>0)
{
d = n/div;
n = n – (div*d);
div = div/10;
if(d%2 == 0)
{
p = p*10 +d;
}
else
{
i = i*10 +d;
}
}
printf(“\nLos numeros formados fueron: el par %ld y el impar %ld\n”,p,i);
if(p>i)
return (p);
else
return (i);
}

40.//Un factorial es un número que es igual a la suma de los factoriales, de los

//dígitos que lo componen. Por ejemplo 145 es un factorión,
//ya que 1! + 4! + 5! = 1 + 24 + 120 = 145.
//Escriba un programa en C, utilizando funciones que encuentre los tres
//primeros factoriones.

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int factorial(int n);

int factorion(int n);

main()
{
int n,i,t;
printf(“\nPROGRAM PARA DETERMINAR SI UN NUMERO ES O NO UN
FACTORION”);
printf(“\nEscriba un numero: “);
scanf(“%d”,&n);
for(i=1;i<=n;i++)
{
t=factorion(i);
if(t==1)
{
printf(“\nEl numero es un factorion %d \n”,i);
}
else
{
printf(“\nEl numero NO es un factorion \n”);
};
};
getch();
return(0);
}

int factorial(int n)
{
int fa=1;
while(n>1)
{
fa = fa * n;
n–;
}
return (fa);
}

int factorion(int n)
{
int i,sum=0,m;

m = n;
while(m>0)
{
i = m%10;
m = m/10;
sum = sum + factorial(i);
}
if(sum == n)
return (1);
else
return (0);
}

41./*Se necesita realizar un programa que imprima todos los números precisos
que
existen hasta el 5000. Un número preciso es aquel que al elevar al cuadrado
la cantidad de cifras que tiene, su resultado es igual a la suma de cada uno
de sus dígitos.
Ejemplo: el número 13, es preciso pues tiene 2 cifras, y 22 = 4
Ahora la suma de sus cifras es: 1+3 = 4. Como la suma de sus cifras es igual
a la cantidad de cifras elevada al cuadrado este es un número preciso.
Realizar las siguientes funciones:
Función cuadrado: que recibe el número y devuelve el cuadrado de la
cantidad de cifras que tiene
Función suma: que recibe el número y suma las cifras del número
Función preciso: retorna 1 si el numero recibido como parámetro es preciso
o 0 si no es preciso
Función main que lista cada uno de los números precisos que existen hasta
el 5000.
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int cuadrado(int n);

int sumacif(int n);
int preciso(int n);

main()
{
int n,i;

printf(“\nPROGRAMA PARA MOSTRAR TODOS LOS NUMEROS PRECISOS

QUE HAY”);
printf(“\n DEL 1 HASTA EL 5000\n”);
for(i=1;i<5001;i++)
{
n = preciso(i);
if(n ==1 )
printf(“%d,\t”,i);
}
printf(“\n”);
getch();
return(0);
}

int cuadrado(int n)
{
int i=0;
while(n>0)
{
i++;
n = n/10;
}
i = i*i;
return (i);
}

int sumacif(int n)
{
int sum=0;
while(n>0)
{
sum = sum + n%10;
n = n/10;
}
return (sum);
}

int preciso(int n)
{
int su, cu;

su = sumacif(n);
cu = cuadrado(n);
// printf(“%d=%d,%d “,n,su,cu);
if(cu == su)
return (1);
else
return (0);

}
42./*El gobierno nacional ha encargado a la empresa Arbolizadora de Colombia
SA.
La tarea de planear la arborización de un número indeterminado hectáreas
ubicadas en el departamento Norte de Santander.
Para este proceso se está seleccionando la especie de árbol a sembrar, para
cada especie se describe la cantidad de árboles que se pueden sembrar por
cada 10m2 y el costo según la siguiente tabla:
Id Especie Cantidad por 10 m2 Costo C/U
1 Cedro 4 30.000
2 Roble 6 27.000
3 Pino 9 18.000
4 Eucalipto 7 11.000
De acuerdo a la cantidad de arboles que se puedan sembrar se presenta un
descuento en el costo, si la cantidad es par se da un descuento del 10%, si
es impar no se da descuento.
Una hectárea equivale a 10000 m2
Realice las siguientes funciones:
Función espar, recibe un número cualquiera y retorna 1 si es par, o si es
impar.
Función hectareaametros, recibe un número que representa la cantidad de
hectáreas y retorna la cantidad de metros.
Función cantidadarboles, recibe el Id de una especie de árboles y la
cantidad de metros cuadrados, y retorna la cantidad de arboles que se
pueden sembrar.
Función costoarboles, recibe el Id de una especie de árboles, la cantidad
de árboles que se pueden sembrar de esta, y retorna el costo de sembrar el
total de árboles de esa especie (implementa la función espar para la
aplicación del descuento).
Función main, Solicita la cantidad de hectáreas al usuario. Llama a las
funciones hectareaametros, cantidadarboles y costoarboles. Imprime en
pantalla los siguientes datos: Especie – cantidad árboles – costo total.
Por cada una de lasespecies de árboles.
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int espar(int n);

long int hectareametros( long int a);
long int cantidadarboles(int id, long int hecta);
float costoarboles(int espe, long int cant);

main()
{
float costo;
long int cantarb, hecta, metros;
int id;

printf(“\n* Cantidad de hectareas a reforestar “);

scanf(“%ld”,&hecta);
metros = hectareametros(hecta);
printf(“\n Las especies de arboles disponibles son:”);
printf(“\n1. Cedro \n2. Roble \n3. Pino \n4. Eucalipto\n”);

printf(“\n Especie – Cantidad de arboles – costo total\n”);

for(id=1;id<5;id++)
{
cantarb = cantidadarboles(id,metros);
costo = costoarboles(id,cantarb);
printf(” %d %ld %.2f\n”,id, cantarb, costo);
}
getch();
return(0);
}

int espar(int n)
{
if(n%2 == 0)
return (1);
else
return (0);
}

long int hectareametros( long int a)

{
long int arb;
arb = a * 10000;
}

long int cantidadarboles(int id, long int hecta)

{
long int arb;

if(id == 1)
{
arb = (hecta/10)*4;
}
else
{
if(id == 2)
{
arb = (hecta/10)*6;
}
else
{
if(id == 3)
{
arb = (hecta/10)*9;
}
else
{
arb = (hecta/10)*7;
}
}
}
}

float costoarboles(int espe, long int cant)

{
float costo;

if(espe == 1)
{
costo = cant * 30000;
}
else
{
if(espe == 2)
{
costo = cant * 27000;
}
else
{
if(espe == 3)
{
costo = cant * 18000;
}
else
{
costo = cant * 11000;
}
}
}
if(cant%2 == 0)
{
costo = costo * 0.9;
}
return (costo);
}

44./*
Los almacenes de cadena ÉXITO, con motivo de la temporada de navidad, se
encuentran desarrollando planes promocionales
para sus clientes. Al iniciar el día el cajero debe ingresar en la caja el día del mes
(ej. 14), se atienden X cantidad de
clientes en una caja, por cada cliente se debe solicitar: número de documento,
número de teléfono, cantidad de productos,
por cada producto se solicita el código (número de 4 dígitos y siempre comienza
en número par) y valor. A cada cliente se le muestra
el valor total a pagar por sus productos. No se conoce la cantidad de clientes, al
final del día el cajero dígita el número de cédula
0. Los productos que sus dos últimos dígitos coincidan con el día tienen un
descuento del 20%. En caso que la sumatoria de los
dígitos de la cédula sea igual al día, el cliente recibe un descuento del 100%.
Realice un programa en C++ modular, que implemente
las siguientes funciones:
Función verificar: Recibe un número entero y verifica que corresponda a un código
valido, número de cuatro dígitos, de los
cuales el primer dígito (de izquierda a derecha) debe ser par.

Función descuentopromo: Recibe el código de un producto, su valor y el día,

retoma el valor del producto aplicando el descuento
en caso que los dos últimos dígitos del código coincidan con el día, de lo contrario
retoma el valor del producto sin descuento.

Función leerproductos: Recibe la cantidad de productos y el día, por cada uno de

los productos solicita el código
(usa la función verificar) y el valor, por cada producto deberá usar la función
descuentopromo para verificar si se debe
aplicar el descuento. Retoma el valor a pagar por los productos.
Función cedulaganadora: Recibe el número de cédula y el día, halla la sumatoria
de los dígitos, retoma 1 si la sumatoria es igual al
día, y 0 si no lo es.
Función main(). Realiza el control del programa de acuerdo al enunciado inicial. Al
final del día deberá imprimir el total recaudado
por ventas, el cliente con mayor valor de compra, el total de dinero
correspondiente a descuentos de 100% entregados y la cantidad
de personas que fueron premiadas con ese descuento.
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int verficar (int cod ,int dia, int vl );

int validarcod(int cod);
int desadicional(int cp, int dia);
int verced( int dia);

main()
{
int cod,p,pa,um,x,cont=0,vt,ced,dia,cont3,cp,i,cont2=0,np,vl,b,k;

printf (“digite el codigo” );

scanf (“%d”, & cod);
printf(“digite la cedula”);
scanf (“%d”, & ced);
printf (“digite el dia” );
scanf (“%d”, & dia);
printf(“digite la cantidad de productos”);
scanf (“%d”, & cp );
printf(“digite el valor del producto”);
scanf (“%d”, & vl);
b=desadicional(cp, dia);
k= vl-verficar(cod, dia, vl);

printf(” %d %d %d\n”,k, np, b);

getch();
return (0);
}
int validarcod(int cod)
{
int p,pa;
if((cod<=1000)&&(cod>=999))
{
{
p=cod/1000;
pa=pa%2;
}
if(pa==0)
{
return(1);
}
}
else
{

return(0);
}
};
int verficar (int cod ,int dia, int vl )
{
int num,x,cont=0,vt,np=0;

while (num >0)

{
x= num % 10;
num= num/10;
cont=cont + x;

};
if(dia==x)
{
vt=vl*0.20;
return(vt);
np=np+1;
}
else
{
return(vl);
}
}

int desadicional(int cp, int dia)

{
int i,cont,cont2=0,d,cod,vl;

for( i=1;i<=cp;i=i+1)
{
d=verficar(cod,dia,vl);
cont2=cont+d;
return(cont2);
};
}

int verced( int dia)

{
int cont3, x ,ced;
while (ced>0)
{
x= ced % 10;
ced= ced/10;
cont3=cont3 + x;
};
if(cont3==dia)
{
return(1);
}
else
{
return(0);
}
}

45./* Elabore un programa en C++ que reciba dos números, los cuales
representan la fecha de nacimiento y una fecha posterior
al nacimiento de una persona. Con estas fechas, la función debe retomar cuantos
días exactamente han pasado entre la fecha
de nacimiento y la fecha posterior dada. Las fechas están en formato aaaammdd,
es decir, los cuatro primeros dígitos del número
recibido corresponden al afto, los siguientes dos dígitos corresponden al mes y los
dos últimos dígitos corresponden al día.
Tenga en cuenta que:

Enero, Marzo, Mayo, Julio, Agosto, Octubre y Diciembre tienen 31 días. Abril,
Junio, Septiembre y Noviembre tienen 30 días.
Febrero tiene 28 días en un año no bisiesto y 29 días en un año bisiesto.
Un año no bisiesto tiene 365 días.
Un año es bisiesto si no es múltiplo de 400 pero sí es múltiplo de 4, salvo el caso
en que sea múltiplo de 100.
Por ejemplo
el año 1900 no fue bisiesto, el 2000 sí y el 2100 no lo será.

Ejemplo: si la función recibe por parámetro las fechas 25 y 20070901, debe

retornar 1995, que es la cantidad
exacta de días transcurridos desde el 15 de marzo de 2002 y el 01 de septiembre
de 2007. El anterior resultado se debe
a que la persona ha vivido exactamente cinco años no bisiestos más 170 días.
Se sugieren, entre otras, las siguientes funciones:
Una función que dado un año, retome si es o no bisiesto.
Una función que dado un año, retome el número de días que tuvo (teniendo en
cuenta si es o no bisiesto).
Una función que dado el número de un mes, retome cuantos días tiene
Una función que retome cuantos días exactamente han pasado entre las dos
fechas.
*/

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

int bisiesto(int ano);

int diasano(int ano);
int diasmes(int mes, int ano);
int diasfecha(int a1, int a2);

main()
{
int f1,f2, dias,i;
printf(“\nFecha inicial: “);
scanf(“%d”,&f1);
printf(“\nFecha final: “);
scanf(“%d”,&f2);
dias = diasfecha(f1,f2);
printf(“\nEntre las dos fechas han pasado %d dias”,dias);
getch();
return(0);
}

int bisiesto(int ano)

{
if(ano%4 == 0)
{
if(ano%100==0 && ano%400 !=0)
{
return(0);
}
else
{
return(1);
}
}
else
{
return(0);
}
}

int diasano(int ano)

{
int i;

if(i==1)
{
return(366);
}
else
{
return(365);
}
}

int diasmes(int mes, int ano)

{
int i;

if(mes==2)
{
i = bisiesto(ano);
if(i==1)
{
return(29);
}
else
{
return(28);
}
}
else
{
if(mes==4 || mes== 6 || mes==9 || mes== 11 )
{
return(30);
}
else
{
return(31);
}
}
}
int diasfecha(int a1, int a2)
{
int d1,m1,d2,m2,i,acu1=0,acu2=0, acu3=0;

d1 = a1%100;
a1 = a1/100;
m1 = a1%100;
a1 = a1/100;

d2 = a2%100;
a2 = a2/100;
m2 = a2%100;
a2 = a2/100;

printf(“\n%d – %d – %d”, d1,m1,a1);

printf(“\n%d – %d – %d\n”, d2,m2,a2);

for(i=12;i>=m1;i–)
{
acu1 = acu1 + diasmes(i,a1);
}
acu1 = acu1 -d1-1;

for(i=1;i<m2;i+1)
{
acu2 = acu2 + diasmes(i,a2);
}
acu2 = acu2 + d2;

for(i=a1+1;i<a2;i++)
{
acu3 = acu3 + diasano(i);
}
acu1 = acu1 + acu2 + acu3;
return(acu1);
}

46./*La boletería para entrar al estadio en el torneo nacional de fútbol se va a

codificar con 8 dígitos que contienen la siguiente
información. Los dos primeros dígitos (los dos más significativos) proporcionan la
zona del asignada (11, oriental, 22 occidental,
33 norte, 44 sur). Los 4 siguientes el número del asiento en dicha zona. Los
últimos dos dígitos, el porcentaje de descuento en la
boleta, y. Estos deben estar entre 10 y 50. Los precios de cada entrada son
$15000 en norte-.o sur, y $30000, en oriental u
occidental. Hacer un programa en C, con las siguientes funciones.
*/

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>

int verficiarcod (int cod)

{
int codigo;
if((codigo<=10000000)&&(codigo>=99999999))
{
return(1);
}
else
{
return(0);
}
}

int asientoasig (int cod)

{
int codigo,p;
p=codigo/100;
return(p);
}

int numdeasi (int cod)

{
int codigo,c,d;
c=cod&1000000;
d=c/10000;
return(d);
}

int valtotal (int cod)

{
int codigo,p,g,des,vb;
p=codigo%100;
if((p<=10)&&(p>=50))
{
g=asientoasig(cod);
if(g<=33)
{
des=p/100;
vb=des*30000;
}
if((g<=1)&&(g>=33))
{
des=p/100;
vb=des*15000;
}

}
if(g<=33)
{
des=30000;
}
else((g<=1)&&(g>=33));
{
des=15000;
}
return(des);
}

main()
{
int h,g,j,cod,k;
printf (“digite el codigo”);
scanf (“%d”,&cod);
g=verficiarcod(cod);
if(g==1)
{
h=asientoasig(cod);
j= numdeasi(cod);
k= valtotal(cod);
if((h<=01)&&(h>=11))
{
printf(“la zona es oriental %d”,h);
}
if((h<=11)&&(h>=22))
{
printf(“la zona es occidental %d”,h);
}
if((h<=33)&&(h>=44))
{
printf(“la zona es nrte %d”,h);
}
if((h<=44)&&(h>=99))
{
printf(“la zona es nrte %d”,h);
}

printf(“el numero del asiento es %d”,j);

printf(“el valor de la boleta es %d”,k);
}
getch();
return(0);
}

49.//Realizar un programa que permita el registro de un grupo de personas entre

15 y 60 años, que desean asistir a un evento gratuito en un coliseo cubierto de la
capital, con capacidad máxima de 1000 personas.
//En la puerta de entrada al coliseo se solicita a cada persona que desee ingresar,
la siguiente información: cédula, edad y un código de asistencia, que está
conformado por cinco dígitos así: el primer digito (de izquierda a derecha)(digito
más significativo) corresponde área de procedencia (1-centro, 2-oriente 3-norte 4-
sur 5- occidente 6-otra), el segundo digito corresponde al tipo de asistente: (1-
empresa, 2-independiente, 3-estudiante), el tercer digito corresponde a la
nacionalidad (1-nacional 2-extranjero) y los dos últimos dígitos del código
corresponden a los dos últimos dígitos del número de la cédula.
//Se desconoce el número de asistentes al evento y el proceso de registro
terminará cuando se digite una cédula igual a cero o cuando el número de
personas registradas sea igual a la capacidad máxima del estadio.
//Una vez las personas se han registrado en el evento, se les asigna un número de
boleta para participar en diferentes sorteos que se llevaran a cabo dentro del
evento. Esté número se construye de la siguiente manera:
//Los dos primeros dígitos corresponden a la edad de la persona y los dos últimos
corresponden a un consecutivo que va entre 01 y 99 según el orden de llegada.
//Realizar un programa en C que contenga las siguientes funciones:
// Validar edad que dado un número entero retome 1 si ese número representa
una edad válida para la asistencia al evento y un 0 si es no válida.
//Validar código de asistente que retome 1 si es válido el código o 0 si es inválido.
//Asignar boleta, debe retomar el número de la boleta asignada a un asistente.
//En la función principal se debe hacer el registro de cada uno de los asistentes y
haciendo el llamado de la(s) función(es) necesaria, se valide la edad de cada
persona, el código de registro, e imprima el número de boleta asignada para los
sorteos. Al final del proceso de registro, se debe imprimir la cantidad de personas
que asistieron al evento
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

int edade (int ed);

int validar ( int cc);
int codigo (long int cc, int cod);
int boleta(int edad, int cant);

main()
{
int j,k,h,cant,cantcap,cod,ed,i,p;
int cc;

do{

printf(“digite la cedula”);
scanf(“%d”,& cc);
h=validar(cc);
if(h==1)
{
printf(“digite edad”);
scanf(“%d”,& ed);
p=edade(ed);
if(p==1)
{
printf(“digite codigo”);
scanf(“%d”, & cod);
if(j==1)
{
cant=cant+1;

printf(“digite boleta”);
cantcap=cantcap+1;
i=1;
}

}
}

}
while((cc==0)||(cantcap==100));
getch();
return(0);

int edade(int ed)

{
if(ed>=16&& ed<=60)

return(1);

else

return(0);

int codigo (int cc, int cod)

{
int x,y;
while(cc>0)
{
x=cc%100;
}
if( cod>=11100 && cod<=63299)
{
y=cod%100;
if(y==x)
{
return(1);
}
}

int validar (int cc)

{
int par;

par=cc%2;
if(par==0)
return(1);
}
50./*Por motivo de aniversario (bodas de plata), de un supermercado de la ciudad
de Pamplona,
se está realizando una promoción a los clientes. Se requiere un programa que al
iniciar
el día laboral, el cajero teclea la fecha actual (tres datos correspondientes al día,
mes y año),
y que permita atender a todos los clientes que lleguen al supermercado. No se
sabe cuántos
clientes ingresan al supermercado por lo que el proceso de atención se termina
cuando se teclee
una cédula igual a cero.
A cada cliente se le registra: Cédula, un código (número de 6 cifras) (si es un
código válido,
se continúa pidiendo datos de dicho cliente), fecha de nacimiento (día, mes, año),
cantidad de
productos comprados. Por cada producto se solicita el código, el valor unitario y el
tipo de producto
(1.Perecedero , 2. No perecedero). Los productos perecederos tienen un 25% de
descuento y los no perecederos
tienen un descuento del 15%.

Se necesita implementar las siguientes funciones

Función que valida el código del cliente, que sea de 6 dígitos y que la suma de sus
dígitos sea menor a
25 para lo cual retornará 1 significando que es válido, en caso contrario retornara
0 significando que no es válido dicho código.
Función que dada la fecha de nacimiento (día, mes y año), de un diente y la fecha
actual (día, mes y año),
calcule y retorne la edad de la persona en años cumplidos.
Función que dado el valor unitario y el tipo de un producto, retorne el precio a
pagar incluido el descuento.
En el cuerpo principal del programa, se debe llevar el control de la atención de los
clientes
hasta encontrar una cédula cero y a cada uno de ellos decir cuánto debe cancelar
por su compra
(pago neto incluido descuentos). Si la edad del cliente es de 25 años se realiza un
descuento
adicional del 10% sobre el valor de su compra. Al finalizar el proceso de atención
de los clientes
se debe indicar el total de ingresos del supermercado en el día.
*/
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

int fvalcod(int cod)

{
int x1,x2,x3,x4,x5,x6,y1,y2,y3,y4,sum,num,x;
if((cod>=100000)&&(cod<=999999))
{
while(cod!=0)
{
x=cod/10;
num=num+x;
}
if(num<25)
{
return(1);
}
else
{
return(0) ;
}
}
else
{
return(0);
}
}

float fvuytp(float vp,int tp)

{
float vv=0,vuts,des;
int i;
if(tp==1)
{

des=vp*0.25;

return(des);
}
else
{

des=vp*0.15;
return(des);
}
}

int edad (int anoa, int mesa, int anoc, int mesc)

{
int rese;

if(mesa<mesc)

rese=(anoa-anoc)-1;

return(rese);
}

main()
{
float cc,cod,vp,vev,tot,valvdia,h,desa;
int diaa,mesa,anoa,diac,mesc,anoc,cam,i,tp,e,c,can,des;
printf(“ingrese el año actual en día/mes/año”);
scanf(“%d %d %d”,&diaa, &mesa, &anoa);
do
{
printf(“ingrese la cedula”);
scanf(“%f”, & cc);
printf(“ingrese el codigo “);
scanf(“%f”, & cod);
c=fvalcod(cod);

if(c==1)
{
printf(“ingrese el año de cumpleaños en día/mes/año”);
scanf(“%d %d %d”,&diac, & mesc, & anoc);
e=edad(anoa, mesa, anoc,mesc);
printf(“ingrese la cantidad de productos”);
scanf(“%d”, &cam);
for(i=1;i<=cam;i+1)
{
printf(“ingrese 1 si el producto es perededero o 2 si noes perecedero”);
scanf(“%d”, & tp);
printf(“ingrese el valor de el producto:”);
scanf(“%f”, & vp);
if(tp==1)
{
vev=fvuytp(vp,tp);
}
else
{
vev=fvuytp(vp,tp);
}
tot=tot+vev;
if(e==25)
{
desa= tot*0.10;
h=h+des;
}
valvdia=tot+h;
}
}
}while(cc!=0);

printf(“el total bendido fue de %f”,valvdia);

printf(“la eada de el cliente es de %d”,e);
getch();
return(0);
}