You are on page 1of 20

## Facultad de Ingenierías y Arquitectura

Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 1
//Escriba una función llamada bisuma que calcule la suma de dos variables num1 y num2 enteras y

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

## int bisuma(int a,int b);

main()
{
int a,b,c;
printf("ingrese numero1\n");
scanf("%d",&a);
printf("ingrese numero2\n");
scanf("%d",&b);
c=bisuma(a,b);
getch();
return(0);
}
int bisuma(int a,int b)
{
int suma=0;
suma=a+b;
return(suma);
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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 <stdio.h>
#include <conio.h>
float media_de_3(int n);

main()
{
float n,a;
printf("digite el numero");
scanf("%f",&n);
a=media_de_3(n);
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 2
printf("la media de %.1f es %.1f",n,a);
getch();
}
float media_de_3(int n)
{
float r;
r=n/3;
return(r);
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

#include <stdio.h>
#include <conio.h>
int factorial(int x);
int fibonacci(int x);
main()
{
int x,a,b;
printf("digite el valor de x");
scanf("%d",&x);
a=factorial(x);
b=fibonacci(x);
printf("el factorial de %d es %d",x,a);
printf("el numero fibonacci de %d es %d",x,b);
getch();
}
int factorial(int x)
{
int i,r=1;
for(i=1;i<=x;i++)
{
r=r*i;
}
return(r);
}
int fibonacci(int x)
{
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 3
int n1=0,n2=1,suma=0,c;
for(c=3;c<=x;c++)
{
suma=n1+n2;
n1=n2;
n2=suma;
}

return(n2);
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

## 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 : 1 si es perfecto, 2 si es abundante, 3si 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
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<conio.h>
#include<stdio.h>

## int calcular_sumatoria_divisores(int n);

int valorar(int n,int d);

main()
{
int v,n,d,a=0,p=0,def=0 ;

## printf("Digite un numero: <0 para terminar> ");

scanf("%d",&n);
while(n!=0)
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 4
{
d=calcular_sumatoria_divisores(n);
v=valorar(n,d);

if(v==1)
{printf("\nEl numero %d es perfecto",n);
p++;
}else
if(v==2)
{printf("\nEl numero %d es deficiente",n);
def++;}
else
{printf("\nEl numero %d es abundante",n);
a++;}
printf("\nDigite un numero: <0 para terminar> ");
scanf("%d",&n);
}
printf("\nEl total numeros perfecto son %d",p);
printf("\nEl total numeros deficientes son %d",def);
printf("\nEl total numeros abundantes son %d",a);

getch();
return(0);
}

int calcular_sumatoria_divisores(int n)
{
int i=1,acum=0;
while(i<n)
{
if(n%i==0)
acum=acum+i;
i++;
}
return(acum);
}

## int valorar(int n,int d)

{
int v;
if(n==d)
v=1;
else
if(d<n)
v=2;
else
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 5
v=3;
return(v);
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXX

Un número narcisista es un número de n dígitos, que coincide con la suma de las potencias n-ésimas de
sus dígitos.

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>

## int contar(long int n);

int potencia(int n ,long int a);

main()
{

## long int n,w;

int cifra,i,j,a,p;
for(n=1;n<=10000;n++)
{
a=contar(n);
p=potencia(n,a)
}
if(p==n)
printf("El numero %ld es narcisista\n",n);
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 6
}
getch();
return(0);
}
int contar(long int n)
{
w=n;
for(i=0;w!=0;i++)
w=w/10;
w=n;
}

## int potencia(int n ,long int a)

{
int r=1,cifra,i,j,c=1,result=0;
for(j=1;j<=i;j++)
{
cifra=w%10;

for(c=1;c<=i;c++)
r=r*cifra;
result=result+r;
w=w/10;
return(result);
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXX
133-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
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 7

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
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>
int comprobar(long long int num)
{
while(num!=0)
{
num=num/10;
}
return(1);
else
return(0);
}
long int numerodescompuesto(long long int num)
{
long int acumpar=0, acumimpar=0;
while(num!=0)
{
dig=num%10;
num=num/10;
if((dig%2)==0)
{
}
else
{
}
}
if(acumpar>acumimpar)
return(acumpar);
else
return(acumimpar);
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 8
}

main()
{
int i,c;
long long int num,numnuevo;

## printf("Digite un numero de seis o mas cifras \n");

scanf("%lld",&num);
for(i=0;i<=10;i++)
{
c=comprobar(num);
if(c==1)
{
numnuevo=numerodescompuesto(num);
printf("El numero mayor es %lld \n",numnuevo);
}
else
printf("El numero es invalido vuelva a intentarlo \n");
printf("Digite un numero de seis o mas cifras \n");
scanf("%lld",&num);
}

getch();
}

OTRA FORMA

#include<stdio.h>
#include<conio.h>
int comprobar (int num);
int numerodescompuesto (int num);
int main()
{
int i, num, x,maygen;
for (i=1;i<=10;i++){
printf("\n digite un numero:");
scanf("%d",&num);
x=comprobar(num);
if (x==1){
maygen= numerodescompuesto (num);
printf("\n el numero mayor generado en la descomposicion es: %d",maygen);
}else{
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 9
printf("\n el numero no tiene una cantidad mayor o igual a seis cifras ");
}
}
getch();
return (0);
}
int comprobar (int num){

if (num>=100000){
return (1);
}else
return (0);
}
int numerodescompuesto(int num){
int numpares=0,numimpares=0,x;
do{
x=num%10;
num=num/10;
if(x%2==0){
numpares=(numpares*10)+ x;
}
else{
numimpares=(numimpares*10)+ x;
}
}while(num>0);
if (numpares>numimpares){
return (numpares);
}else{
return (numimpares);
}
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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 prestamos de libros.
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 10
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>

## int validar_codigo(long int codigo);

int prestamo(long int codigo);
int recoleccion(long int codigo);

main()
{
long int codigo;

int op,acu=0,v,p,r;
printf("1.Prestamo\n");
printf("2.Entrega\n");
printf("0.Salir\n");
printf("Cual desea: ");
scanf("%d",&op);

while(op!=0)
{
printf("ingrese el codigo del libro");
scanf("%ld",&codigo);
v=validar_codigo(codigo);
if(v==1)
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 11
{
if(op==1)
{
p=prestamo(codigo);
if(p==1)
printf("Puede prestar el libro");
else
printf("No puede prestar el libro");
}
else
if(op==2)
{
r=recoleccion(codigo);
printf("Debe de cancelar la cantidad de %d por prestamo",r);
acu=acu+r;
}
}
else

printf("1.Prestamo\n");
printf("2.Entrega\n");
printf("3.Salir\n");
printf("Cual desea: ");
scanf("%d",&op);
}
printf("El total recaudado en el dia fue: %d por prestamo",acu);
getch();
return(0);
}

## int validar_codigo(long int codigo)

{
if((codigo>=10101000)&&(codigo<=10899999))
return(1);
else
return(0);
}

## int prestamo(long int codigo)

{
long int area;
area= codigo/100000;
if((area==101)||(area==102)||(area==104))
return(1);
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 12
else
return(0);
}

## int recoleccion(long int codigo)

{
int ejemplares,valor;
long int residuo;
residuo=codigo/1000;
ejemplares=residuo%100;
if(ejemplares<=2)
valor=2000;
else
if((ejemplares>=3)&&(ejemplares<=6))
valor=1000;
else
if(ejemplares>6)
valor=500;
return(valor);
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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:
a. 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.
b. Una función que verifique si se trata de una referencia valida y retorne 1 si es valida y 0 si no lo
es.
c. 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.
d. La función main

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

## int leerRef(int cantprod);

Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 13
int validaRef(int codigo);
int calcGanancia(int cod,int costo,int valor);

int main(){
int cant,codganmax;
printf("\nDigite la cantidad de productos para los que leerá las referencias: ");
scanf("%d",&cant);
codganmax=leerRef(cant);
printf("\nLa referencia del producto que genera mayor ganancia es: %d",codganmax);
getch();
return(0);
}

## int leerRef(int cantprod){

int cod,costo,valor,ganancia,ganmax=0,codmax,valida,contvalidos=0;
do{
printf("\nDigite el código de referencia del producto: ");
scanf("%d",&cod);
valida=validaRef(cod); //validar el codigo
if (valida==1){
printf("\nDigite el costo de producción del producto: ");
scanf("%d",&costo);
printf("\nDigite el valor de venta del producto: ");
scanf("%d",&valor);
ganancia=calcGanancia(cod,costo,valor); //calcular la ganancia
contvalidos++; //contar los codigos validos
if (ganancia>ganmax){ //comparar la ganancia para obtener la máxima
ganmax=ganancia;
codmax=cod;
}
}else{
printf("\nEl codigo ingresado no es correcto"); //mensaje de salida opcional
}
}while(contvalidos<cantprod);
return(codmax);
}

## int validaRef(int codigo){

int linea;
if ((codigo>=1000)&&(codigo<=9999)){ //verificar que el codigo sea de cuatro cifras
linea=codigo%100; //obtener las dos ultimas cifras (linea de producciób)
if ((linea==11)||(linea==22)||(linea==44)){ //verificar que el cod pertenezca a una de las lineas de
producción
return(1); //codigo valido
}
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 14
}
return(0);//codigo no valido
}

## int calcGanancia(int cod,int costo,int valor){

int ganancia;
ganancia=valor-costo; //cálculo de la ganancia
return(ganancia);
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
125-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<stdio.h>
#include<conio.h>
float f_acum(float n1, float n2, float n3, float n4, float n5);
float f_calculo(float acum);
main ()
{
int c=0, ce=0;
long cod;
float n1, n2, n3, n4, n5, acum, ne=0, p, sacum=0;
do
{
printf ("ingrese el codigo del estudiante");
scanf ("%ld", &cod);
if (cod!=0)
{
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 15
ne++;
printf ("ingrese la primera nota");
scanf ("%f", &n1);
printf ("ingrese la segunda nota");
scanf ("%f", &n2);
printf ("ingrese la tercera nota");
scanf ("%f", &n3);
printf ("ingrese la cuarta nota");
scanf ("%f", &n4);
printf ("ingrese la quinta nota");
scanf ("%f", &n5);
acum =f_acum(n1, n2, n3, n4, n5);
sacum=sacum+acum;
if (acum>2.5)
c++;
printf ("el acumulado del estudiante hasta el momento es de %0.2f", acum);
f_calculo(acum);
ce++;
}
}
while (cod!=0);
{
printf (" el numero de estudiantes que tienen el ponderadopor debajo de 2.5 es %0.2d", c);
}
getch ();
return (0);
}
float f_acum(float n1, float n2, float n3, float n4, float n5)
{
float np=0;
np=(n1*0.2)+(n2*0.15)+(n3*0.2)+(n4*0.15)+(n5*0.1);
return (np);
}
float f_calculo(float acum)
{
float notares=0, nota=0;
if (acum>=0)
{
printf (" el estudiante puede darse el lujo de no presentar el parcial pues ya paso la materia ");
}
else
{
notares=3.0-acum;
nota=notares/0.2;
if (nota>=5)
printf (" el estudiante ya perdio la materia por estar en el malecon");
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 16
else
printf ("el estudiante necesita pasar la materia %0.20.2f", nota);
}
}

128- 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). Ejemplo:
N = 121589 al descomponer el número a=12 b=15 c=89
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. Ejemplo:

Función Unir que recibe a y c y debe retornar un solo numero resultado de unir a y c, el número
devuelto debe quedar
de 4 cifras. Ejemplo: a = 12 c = 89, el número nuevo queda así: nuevo = 1289
??El main

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

## int verifica (int num);

int unir(int a, int c);
int Calcular_tabla(int a,int b);

main ()
{
int num,ver,a,b,c,uni,x;
printf("Digite un numero de 6 cifras: ");
scanf("%d", &num);
ver=verifica(num);
if (ver==1)
{

a=num/10000;
x=num%10000;
b=x/100;
c=x%100;
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 17
printf ("\n el numero a es: %d ", a);
printf ("\n el numero b es: %d ", b);
printf ("\n el numero c es: %d ", c);
if (a>b)
{
printf("\n a no debe ser mayor que b");
}
else
{
Calcular_tabla(a,b);
}
uni=unir(a,c);
printf ("\n el numero unido de a y c es: %d ", uni); }
else
{
printf("el numero no es de 6 cifras");
}
getch();
}

## int verifica (int num)

{
if (( num >=100000)&&(num <=999999))
{
return(1);
}
else
{
return(0);
}
}

{
int un;
un=(a*100)+c;
return(un);
}

## int Calcular_tabla(int a,int b)

{
int x,y,mul;
for (x=a; x <= b; x++)
{
for (y=1; y<=10; y++)
{
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 18
mul=x*y;
printf("\n %d X %d = %d ", x,y,mul);
} }}

\\otra forma

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

## int verifica (int num);

int Calcular_tabla(int a,int b);
int unir(int a, int c);

main ()
{
int num,ver,a,b,c,uni;
printf("Digite un numero de 6 cifras: ");
scanf("%d", &num);
ver=verifica(num);
if (ver==0)
{
printf("el numero no es de 6 cifras");

}
a=num/10000;
b=(num/100)-(a*100);
c=num-((a*10000)+(b*100));
printf ("\n el numero a es: %d ", a);
printf ("\n el numero b es: %d ", b);
printf ("\n el numero c es: %d ", c);
if (a>b)
{
printf("\n a no debe ser mayor que b");
}
else
{
Calcular_tabla(a,b);
}
uni=unir(a,c);
printf ("\n el numero unido de a y c es: %d ", uni);
getch();
}
Programación Estructurada – Alexis Olvany Torres Ch
-------------------------------------------------------------------------------------------------------------------- 19
int verifica (int num)
{
int ver;
if (( num >=100000)&&(num <=999999))
{
return(1);
}
else
{
return(0);
}

## //ojo o tambien de esta forma

int verifica (int num)
{
int ver;
ver=num/100000;
if (ver>=0)
{
ver=1;
}
else
{
ver=0;
}
return(ver);}

{
int un;
un=(a*100)+c;
return(un);
}

## int Calcular_tabla(int a,int b)

{
int x,y,mul;
for (x=a; x <= b; x++)
{
for (y=1; y <=10; y++)
{
mul=x*y;
printf("\n %d X %d = %d ", x,y,mul);
} }}