El documento presenta varios ejercicios de autoevaluación sobre estructuras simples y condicionales en programación. Cada ejercicio incluye instrucciones para ingresar datos y calcular resultados usando Sentencias C++, como el cálculo de dobles, promedios, conversiones de unidades y la manipulación de datos en estructuras repetitivas y condicionales. Se abordan temas como la anidación de bucles y el uso de estructuras if-else para tomar decisiones en función de entradas del usuario.

1. Capítulo 5
EJERCICIOS DE
AUTOEVALUACION
5.1 Estructuras Simples
5.2 Estructura condicional < if - else >
5.3 Estructura de selectiva múltiple < switch >
5.4 Estructura repetitiva < for >
5.5 Estructura repetitiva < while > y < do - while >
5.6 Anidamiento de bucles

2. 5.1 Estructuras Simples
/**********************Inicio del Programa***************************
Ejercicio 01: Ingrese por teclado un número, calcular y mostrar:
-El doble del número ingresado
-La 3ra. parte del número ingresado.
-El cubo del número ingresado.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int nro, doble, cubo;
double tercera_parte;
printf("nIngrese un numero: ");
scanf("%d", &nro); fflush(stdin);
doble = nro * 2;
cubo = nro * nro * nro;
tercera_parte = nro / 3.0;
printf("nDoble: %d", doble);
printf("nCubo: %d", cubo);
printf("nTercera Parte: %8.3lf", tercera_parte);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 02: Ingrese por teclado el nombre y 3 notas de un alumno,
calcular y mostrar el promedio del alumno
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char nombre[30];
int n1, n2, n3;
double prom;
printf("nIngrese nombre: "); gets(nombre); fflush(stdin);
printf("nIngrese nota 1: "); scanf("%d", &n1); fflush(stdin);
printf("nIngrese nota 2: "); scanf("%d", &n2); fflush(stdin);

3. printf("nIngrese nota 3: "); scanf("%d", &n3); fflush(stdin);
prom = ( n1 + n2 + n3 ) / 3.0;
printf("nn%s tiene promedio: %8.0lf", nombre, prom);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 03: Ingrese por teclado una cantidad en metros,
transformar los metros a centímetros, pulgadas (2.54 cm) y a pies (12 pulgadas)
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
double centimetro=100, pulgada=2.54, pie=12 ;
double metros, centimetros, pulgadas, pies;
printf("nIngrese cantidad en metros: "); scanf("%lf", &metros); fflush(stdin);
centimetros = metros * centimetro;
pulgadas = centimetros / pulgada;
pies = pulgadas / pie;
printf("nn Centimetros: %8.3lf", centimetros);
printf("n Pulgadas: %8.3lf", pulgadas);
printf("n Pies: %8.3lf", pies);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 04: Ingrese por teclado la descripción, precio y
cantidad vendida de un producto, calcular y mostrar:
-Importe de la compra
-Impuesto general a las ventas (18%)
-Importe Final

4. *********************************************************************/
#include <iostream>
using namespace std;
void main(){
char descripcion[50];
double precio, importe_compra, igv=0.18, impuestos, importe_final;
int cantidad;
printf("nIngrese descripcion producto: "); gets(descripcion); fflush(stdin);
printf("nIngrese precio: "); scanf("%lf", &precio); fflush(stdin);
printf("nIngrese cantidad vendida: "); scanf("%d", &cantidad); fflush(stdin);
importe_compra = precio * cantidad;
impuestos = importe_compra * igv;
importe_final = importe_compra + impuestos;
printf("nn Importe Compra: %8.2lf", importe_compra);
printf("n Impuesto General a las Ventas: %8.2lf", impuestos);
printf("n Importe Final: %8.2lf", importe_final);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 05: Ingrese por teclado un número de 3 cifras, calcular y mostrar:
- Suma de las cifras
- EL número ingresado en sentido inverso
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int nro, U, D, C, nroinv;
printf("nIngrese un numero de tres cifras: "); scanf("%d", &nro); fflush(stdin);
C = nro / 100;
D = (nro % 100) / 10;
U = nro % 10;
nroinv = U*100 + D*10 + C;
printf("nn Suma de cifras: %d", U + D + C);
printf("nn Nro ingresado invertido: %d", nroinv);
printf("nn");

5. system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 06: Ingrese por teclado el número de alumnos matriculados en un colegio,
calcular y mostrar:
- Cantidad de aulas completas
- Cantidad de alumnos que faltan para completar la última aula.
Nota: Un aula completa es de 40 alumnos.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int nro_alu, aulac, alufal, aula=40;
printf("nIngrese un numero de alumnos matriculados: "); scanf("%d", &nro_alu);
fflush(stdin);
aulac = nro_alu / aula;
alufal = aula - (nro_alu % aula);
printf("nn Aulas completas: %d", aulac);
printf("nn Alumnos que faltan para completar la ultima aula: %d", alufal);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 07: Se tiene n segundos, calcular y mostrar:
- Cantidad de horas
- Cantidad de minutos
- Cantidad de segundos restantes
*********************************************************************/
#include <iostream>
using namespace std;
void main(){

6. int seg, hor, min, seg_res, segxhor=3600, segxmin=60;
printf("nIngrese numero de segundos: "); scanf("%d", &seg); fflush(stdin);
hor = seg / segxhor;
min = (seg % segxhor) / segxmin;
seg_res = ((seg % segxhor) % segxmin);
printf("nn Horas: %d", hor);
printf("nn Minutos: %d", min);
printf("nn Segundos restantes: %d", seg_res);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 08: Ingrese por teclado el sueldo de un empleado, visualizar
la mejor forma de distribución, si para eso contamos con:
-Billetes de 100, 50, 20, 10
-Monedas de 5, 2, 1, 0.50, 0.20, 0.10
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
double sueldo_real, centavos_real;
int sueldo, B100, B50, B20, B10, M5, M2, M1, centavos, M05, M02, M01;
printf("nIngrese sueldo: "); scanf("%lf", &sueldo_real); fflush(stdin);
sueldo = sueldo_real;
B100 = sueldo /100;
B50 = (sueldo % 100) / 50;
B20 = ((sueldo % 100) % 50) / 20;
B10 = (((sueldo % 100) % 50) % 20) / 10;
M5 = ((((sueldo % 100) % 50) % 20) % 10) / 5;
M2 = (((((sueldo % 100) % 50) % 20) % 10) % 5) / 2;
M1 = (((((sueldo % 100) % 50) % 20) % 10) % 5) % 2 ;
centavos_real = sueldo_real - sueldo;
centavos = centavos_real * 10;
printf("nnCentavos:%d", centavos);
M05 = centavos / 5;
M02 = (centavos % 5) / 2;

7. M01 = (centavos % 5) % 2;
printf("nn Numero Billetes de 100: %d", B100);
printf("nn Numero Billetes de 50: %d", B50);
printf("nn Numero Billetes de 20: %d", B20);
printf("nn Numero Billetes de 10: %d", B10);
printf("nn Numero Monedas de 5: %d", M5);
printf("nn Numero Monedas de 2: %d", M2);
printf("nn Numero Monedas de 1: %d", M1);
printf("nn Numero Monedas de 0.50: %d", M05);
printf("nn Numero Monedas de 0.20: %d", M02);
printf("nn Numero Monedas de 0.10: %d", M01);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 09: Ingrese por teclado el nombre y 2 fechas (día, mes año)
una la fecha actual y otra la fecha de nacimiento de la persona,
calcule y muestre la edad exacta de dicha persona.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int anio=360, mes=30;
char nombre[50];
int an, mn, dn;//fecha nacimiento
int aa, ma, da;//fecha actual
int av, mv, dv;// tiempo vivido
int tdfn, tdfa, tdv;
printf("nIngrese nombre: "); gets(nombre); fflush(stdin);
printf("nnFecha Actual ");
printf("ndia: "); scanf("%d", &da); fflush(stdin);
printf("mes: "); scanf("%d", &ma); fflush(stdin);
printf("anio: "); scanf("%d", &aa); fflush(stdin);
printf("nnFecha de Nacimiento ");
printf("ndia: "); scanf("%d", &dn); fflush(stdin);
printf("mes: "); scanf("%d", &mn); fflush(stdin);
printf("anio: "); scanf("%d", &an); fflush(stdin);

8. //Pasamos los datos a días
tdfa=(aa*anio)+(ma*mes)+da;
tdfn=(an*anio)+(mn*mes)+dn;
//Restamos los días
tdv=tdfa-tdfn;
//Pasamos a formato año, mes y día
av=tdv/anio;
mv=(tdv%anio)/mes;
dv=(tdv%anio)%mes;
printf("nn%s tienes %d Ano(s) con %d Mes(es) y %d Dia(s) ", nombre, av, mv, dv );
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 10: Ingrese por teclado dos números, realice un
intercambio interno de valores entre variables.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int A, B, aux;
printf("nIngrese numero 1: "); scanf("%d", &A); fflush(stdin);
printf("nIngrese numero 2: "); scanf("%d", &B); fflush(stdin);
aux=A;
A=B;
B=aux;
printf("nn Numeros intercambiados");
printf("nnNumero 1: %d ", A);
printf("nnNumero 2: %d ", B);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

9. 5.2 Estructura condicional < if - else >
/**********************Inicio del Programa***************************
Ejercicio 01: Ingrese por teclado un número y muestre un mensaje "es cero",
solo cuando esto ocurra.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int nro;
printf("nIngrese numero : "); scanf("%d", &nro); fflush(stdin);
if(nro==0)
printf("nn Es cero");
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 02: Ingrese por teclado las tallas de dos personas,
solo si la segunda talla es mayor a la primera se visualizara la mayor talla.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
double talla1, talla2;
printf("nIngrese talla 1 : "); scanf("%lf", &talla1); fflush(stdin);
printf("nIngrese talla 2 : "); scanf("%lf", &talla2); fflush(stdin);
if(talla2 > talla1)
printf("nn La mayor talla es : %8.2lf", talla2);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

10. /**********************Inicio del Programa******************************
Ejercicio 03: Ingrese por teclado el nombre, cantidad de hijos y sueldo basico
de un trabajador, Solo si el trabajador tiene hijos tendra una bonificación
de 4% del sueldo basico, mostrar la bonificacion y el sueldo final.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char nombre[50];
int cant_hijos;
double sueldo, bonificacion, porc=0.04, sueldoFinal;
printf("nIngrese nombre de trabajador : "); gets(nombre); fflush(stdin);
printf("nIngrese cantidad de hijos : "); scanf("%d", &cant_hijos); fflush(stdin);
printf("nIngrese sueldo basico : "); scanf("%lf", &sueldo); fflush(stdin);
//Inicializacion
bonificacion = 0;
sueldoFinal = sueldo;
//Evaluacion
if(cant_hijos > 0){
bonificacion = sueldo * porc;
sueldoFinal = sueldo + bonificacion;
}
//Impresion de informacion
printf("nn Trabajador %s tiene ", nombre);
printf("nn Bonificacion es : %8.2lf", bonificacion);
printf("nn Sueldo Final es : %8.2lf", sueldoFinal);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 04: Ingrese un caracter por teclado y visualice el mensaje
"es letra del alfabeto mayuscula" solo cuando esto ocurra.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char caracter;
printf("nIngrese caracter : "); caracter=getchar(); fflush(stdin);

11. if(caracter >= 'A' && caracter <= 'Z')
printf("nn Es letra del alfabeto mayuscula ");
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 05: Ingrese un caracter por teclado y visualice el mensaje
"es vocal mayuscula o minuscula" solo cuando esto ocurra.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char caracter;
printf("nIngrese caracter : "); caracter=getchar(); fflush(stdin);
if(caracter == 'A' || caracter == 'E' || caracter == 'I' || caracter == 'O' || caracter == 'U')
printf("nn Es vocal mayuscula ");
if(caracter == 'a' || caracter == 'e' || caracter == 'i' || caracter == 'o' || caracter == 'u')
printf("nn Es vocal minuscula ");
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 06: Una empresa de transporte terrestre vendio una determinada
cantidad de boletos vendidos, ingrese por teclado el numero de correlativo
del primer y ultimo boleto vendido asi como el precio por boleto.
Si es que la cantidad de boletos vendidos es mayor 1000, calcular y mostrar:
-Importe de boletos vendidos
-Incentivo que sera el 20% del importe de boletos vendidos
*********************************************************************/
#include <iostream>
using namespace std;

12. void main(){
int bol_inicial, bol_final, cantidad, limite = 1000;
double precio, importe, incentivo, porc = 0.25 ;
printf("nIngrese Numero del primer boleto : "); scanf("%d", &bol_inicial); fflush(stdin);
printf("nIngrese Numero del ultimo boleto : "); scanf("%d", &bol_final); fflush(stdin);
printf("nIngrese precio unitario de boleto : "); scanf("%lf", &precio); fflush(stdin);
cantidad = (bol_final - bol_inicial) + 1 ;
if(cantidad > limite){
importe = precio * cantidad;
incentivo = importe * porc;
printf("nn Importe: %8.2lf", importe);
printf("nn Incentivo: %8.2lf", incentivo);
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 07: Ingrese 3 numeros enteros, muestre el mayor, menor y el
que se encuentra en el medio.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int a, b, c, mayor, menor, medio;
printf("nrIngrese 1er #: ");scanf("%d",&a); fflush(stdin);
printf("nrIngrese 2do #: ");scanf("%d",&b); fflush(stdin);
printf("nrIngrese 3er #: ");scanf("%d",&c); fflush(stdin);
mayor = a;
if(b > mayor)mayor = b;
if(c > mayor)mayor = c;
menor = a;
if(b < menor)menor = b;
if(c < menor)menor = c;
medio = ( a + b + c ) - ( mayor + menor );
printf("nnrEl mayor es: %d", mayor);
printf("nrEl que se situa en el medio es: %d", medio);

13. printf("nrEl menor es: %d", menor);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 08: Realizar la siguiente funcion:
|X , 1<=X<=5
|X + 5, 5< X <=25
Z => |1 / X, 25< X <=50
|5X -4, 50< X <=90
|X3 , X >90
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
double X;
printf("nrIngrese valor de X: "); scanf("%lf",&X); fflush(stdin);
//No anidamos porque segun la funcion, X solo puede entrar a una condicion.
if( 1 <= X && X <= 5){
printf("nnrZ: %8.2lf nn", X );
system("PAUSE");
exit(0);
}
if( 5 < X && X <= 25){
printf("nnrZ: %8.2lf nn", X + 5 );
system("PAUSE");
exit(0);
}
if( 25 < X && X <= 50){
printf("nnrZ: %8.2lf nn", 1 / X );
system("PAUSE");
exit(0);
}
if( 50 < X && X <= 90){
printf("nnrZ: %8.2lf nn", 5*X -4 );
system("PAUSE");
exit(0);
}
if( X > 90){

14. printf("nnrZ: %8.2lf nn", X*X*X );
system("PAUSE");
exit(0);
}
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 09: Ingrese por teclado un numero entero, evalue si cumple:
- Que sea positivo
- Que sea de dos ó 4 cifras
- Si es de dos cifras que la primera sea sea mayor a la segunda
- Si es de cuatro cifras que la suma de las cifras sea mayor a la primera
y a la segunda.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int nro, U, D, C, M;
bool bandera=false;
printf("nrIngrese numero a evaluar: "); scanf("%d",&nro); fflush(stdin);
//No es necesario validar que sea positivo,
//puesto que esta implicito en las evaluaciones
if( nro>=10 && nro <=99 ) {
D = nro / 10;
U = nro % 10;
bandera = D > U;
}
if( nro>=1000 && nro <=9999 ){
M = nro / 1000;
C = (nro % 1000) / 100;
D = ((nro % 1000) % 100) / 10;
U = nro % 10;
bandera = (M + C + D + U) > M && (M + C + D + U) > U;
}
if(bandera)
printf("nnSi cumple las condicionesnn");
else
printf("nnNo cumple las condicionesnn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

15. /*********************************************************************
Ejercicio 10: Ingrese un numero por teclado, diga si es par o impar
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int nro;
printf("nrIngrese numero a evaluar: "); scanf("%d",&nro); fflush(stdin);
if( nro % 2 == 0 )
printf("nnNumero es Parnn");
else
printf("nnNumero es Imparnn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 11: Ingrese por teclado el nombre, edad y sexo (M, F), muestre uno
de acuerdo a los datos ingresados los siguientes mensajes:
-Masculino mayor de edad
-Masculino menor de edad
-Femenino mayor de edad
-Femenino menor de edad
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char nombre[50], sexo;
int edad;
printf("nrIngrese nombre : "); gets(nombre); fflush(stdin);
printf("nrIngrese sexo (M, F): "); sexo=getchar(); fflush(stdin);
printf("nrIngrese edad: "); scanf("%d",&edad); fflush(stdin);
if( sexo=='M' )
if(edad>=18)
printf("nnMasculino mayor de edadnn");
else

16. printf("nnMasculino menor de edadnn");
else if( sexo=='F' )
if(edad>=18)
printf("nnFemenino mayor de edadnn");
else
printf("nnFemenino menor de edadnn");
else
printf("nnError en ingreso de sexonn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 12: Ingrese por teclado, el nombre e importe de compra de
un cliente, calcular y mostrar:
- Impuesto general a la venta (18%), solo si el importe de compra
es mayor a 5.00 soles, caso contrario sera cero.
-Subtotal
-Descuento del subtotal, Si el subtotal es mayor a 500.00 sera
el 9% de no ser asi sera 2%.
-Importe Final
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char nombre[50];
double importe, lim_impcomp = 5,
IGV = 0.18, impuestos,
dscto, descuentos,
subtotal, lim_subtotal = 500, importeFinal;
printf("nrIngrese nombre : "); gets(nombre); fflush(stdin);
printf("nrIngrese importe de la compra: "); scanf("%lf",&importe); fflush(stdin);
if(importe > lim_impcomp)
impuestos = importe * IGV;
else
impuestos = 0;
subtotal = importe + impuestos;
if(subtotal > lim_subtotal){
dscto = 0.09;
descuentos = subtotal * dscto;
}else{
dscto = 0.02;
descuentos = subtotal * dscto;
}

17. importeFinal = subtotal - descuentos;
printf("nnImpuesto general a la venta : %lf", impuestos);
printf("nnSubtotal : %lf", subtotal);
printf("nnDescuentos : %lf", descuentos);
printf("nnImporte Final : %lfnn", importeFinal);
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 13: Se desea saber cual es la mejor compra entre dos tipos
de pizza rectangular y circular. Para eso se ingresan las dimensiones
largo, ancho y diametro respectivamente, ademas del precio de la pizza.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
double PI=3.14159, radio, area;
double diametro,largo,ancho;
double precio_redonda, preciounit_redonda;
double precio_rectangular, preciounit_rectangular;
printf("nnPizza redondann");
printf("Ingrese diametro(en pulgadas) de una pizza redonda:"); scanf("%lf", &diametro);
fflush(stdin);
printf("Ingrese precio de una pizza redonda $/ :"); scanf("%lf", &precio_redonda);
fflush(stdin);
printf("nnPizza rectangularnn");
printf("Ingrese largo(en pulgadas) de una pizza rectangular :"); scanf("%lf", &largo);
fflush(stdin);
printf("Ingrese ancho(en pulgadas) de una pizza rectangular :"); scanf("%lf", &ancho);
fflush(stdin);
printf("Ingrese precio de pizza rectangular $/ :"); scanf("%lf", &precio_rectangular);
fflush(stdin);
area = largo * ancho;
preciounit_rectangular = precio_rectangular / area;
radio = diametro / 2.0;
area=PI*radio*radio;
preciounit_redonda=precio_redonda / area;
printf("nnPrecio pizza rendonda: $ %8.2lf", precio_redonda);
printf("nrPrecio pizza por pulgada cuadrada: $ %8.2lf", preciounit_redonda);
printf("nnPrecio pizza rectangular: $ %8.2lf", precio_rectangular);
printf("nrPrecio pizza por pulgada cuadrada: $ %8.2lf", preciounit_rectangular);

18. if(preciounit_redonda<preciounit_rectangular)
printf("nnLa pizza redonda es la mejor compra.");
else
printf("nnLa pizza rectangular es la mejor compra.");
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

19. 5.3 Estructura de selectiva múltiple < switch >
/*********************************************************************
Ejercicio 01: Se pide ingresar un número del uno al veinte,
imprima dicho número en letras.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int n;
printf("nrIngrese #(1-20) : "); scanf("%d",&n);
printf("nnr");
switch(n){
case 1: printf("Uno");break;
case 2: printf("Dos");break;
case 3: printf("Tres");break;
case 4: printf("Cuatro");break;
case 5: printf("Cinco");break;
case 6: printf("Seis");break;
case 7: printf("Siete");break;
case 8: printf("Ocho");break;
case 9: printf("Nueve");break;
case 10:printf("Diez");break;
case 11:printf("Once");break;
case 12:printf("Doce");break;
case 13:printf("Trece");break;
case 14:printf("Catorce");break;
case 15:printf("Quince");break;
case 16:printf("Diez y Seis");break;
case 17:printf("Diez y siete");break;
case 18:printf("Diez y ocho");break;
case 19:printf("Diez y nueve");break;
case 20:printf("Veinte");break;
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 02: Realizar un algoritmo que lea un numero que represente
el día de semana. Muestre el numero en dias:
(Lunes=1, Martes=2, …, Domingo=7).

20. *********************************************************************/
#include <iostream>
using namespace std;
void main(){
int n;
printf("nrIngrese numero de dia de semana #(1-7) : "); scanf("%d",&n);
printf("nnr");
switch(n){
case 1: printf("Lunes");break;
case 2: printf("Martes");break;
case 3: printf("Miercoles");break;
case 4: printf("Jueves");break;
case 5: printf("Viernes");break;
case 6: printf("Sabado");break;
case 7: printf("Domingo");break;
default: printf("Numero de dia No reconodido");break;
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 03: Escribir un algoritmo que solicite el ingreso de dos
números y a continuación un operador aritmético (+, -, *, /).
El algoritmo debe calcular el resultado de la operación seleccionada.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char ope;
double n1, n2;
printf("nrIngrese numero 1 : "); scanf("%lf",&n1); fflush(stdin);
printf("nrIngrese numero 2 : "); scanf("%lf",&n2); fflush(stdin);
printf("nrIngrese Operacion (+,-,*,/) : "); ope=getchar(); fflush(stdin);
printf("nnrResultado:");
switch(ope){
case '+': printf("%8.2lf", n1 + n2);break;
case '-': printf("%8.2lf", n1 - n2);break;
case '*': printf("%8.2lf", n1 * n2);break;
case '/': printf("%8.2lf", n1 / n2);break;

21. default: printf("Operacion ingresada No reconodido");break;
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 04: Escribir un algoritmo que solicite el ingreso de dos
números y a continuación un operador aritmético (+, -, *, /).
El algoritmo debe calcular el resultado de la operación seleccionada.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char ope;
double n1, n2;
printf("nrIngrese numero 1 : "); scanf("%lf",&n1); fflush(stdin);
printf("nrIngrese numero 2 : "); scanf("%lf",&n2); fflush(stdin);
printf("nrIngrese Operacion (+,-,*,/) : "); ope=getchar(); fflush(stdin);
printf("nnrResultado:");
switch(ope && ope){
case '+': printf("%8.2lf", n1 + n2);break;
case '-': printf("%8.2lf", n1 - n2);break;
case '*': printf("%8.2lf", n1 * n2);break;
case '/': printf("%8.2lf", n1 / n2);break;
default: printf("Operacion ingresada No reconodido");break;
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

22. 5.4 Estructura repetitiva < for >
/*********************************************************************
Ejercicio 01: Mostrar el doble, triple y el cuadrado de todos
los numeros que se encuentran entre el 10 y 30.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int ini = 10, fin = 30, i;
for(i=ini;i<=fin;i++)
printf("nrNumero %d, doble %d, triple %d y su cuadrado %d.",
i,
i * 2,
i * 3,
i * i);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 02: Visualice la palabra "ALGORITMO" 200 veces.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int ini = 1, fin = 200, i;
for(i=ini;i<=fin;i++)
printf("nrALGORITMO");
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************

23. Ejercicio 03: Digite un numero positivo y entero, visualice la
palabra "SENTENCIA" 5 veces el numero ingresado. Ademas enumere
cada visualizacion.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int ini = 1, fin , i, n;
printf("nrIngrese numero : "); scanf("%d",&n);
fin = n * 5;
for(i=ini;i<=fin;i++)
printf("nr %d ALGORITMO", i);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 04: Digite un numero entero, visualice
los 50 numeros superiores e inferiores consecutivos a este.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int cantidad = 50, i, n, ini, fin;
printf("nrIngrese numero : "); scanf("%d",&n);
printf("nnNumeros Superiores consecutivosnn");
ini = n + 1;
fin = n + cantidad ;
for(i = ini;i<=fin;i++)
printf("nr %d", i);
printf("nnNumeros Inferiores consecutivosnn");
ini = n - 1;
fin = n - cantidad ;
for(i = ini;i>=fin;i--)
printf("nr %d", i);
printf("nn");
system("PAUSE");

24. }
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 05: Ingrese por teclado dos numeros (asuma enteros y positivos)
visualice todos los enteros consecutivos que estan comprendidos
en estos. Ademas mostrar la suma al finalizar.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int S, i, n1, n2, ini, fin;
printf("nrIngrese numero 1: "); scanf("%d",&n1);
printf("nrIngrese numero 2: "); scanf("%d",&n2);
if(n1>n2){
ini = n2;
fin = n1;
}else{
ini = n1;
fin = n2;
}
S=0;
for( i = ini + 1 ; i < fin ; i++ ){
S+=i;
printf("nr %d", i);
}
printf("nn La Suma es %dnn", S);
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 06: Ingrese por teclado dos notas y el nombre de
N alumnos, mostrar el promedio, condicion (Aprobado, Desaprobado)
y promedio global.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){

25. char nombre[50];
int i, N, n1, n2;
double promA, promG, SG;
printf("nrIngrese numero de alumnos: "); scanf("%d",&N);fflush(stdin);
SG=0;
for(i=1;i<=N;i++){
printf("nrIngrese nombre alumno %d: ", i); gets(nombre); fflush(stdin);
printf("nrIngrese nota 1: "); scanf("%d",&n1); fflush(stdin);
printf("nrIngrese nota 2: "); scanf("%d",&n2); fflush(stdin);
promA = (n1 + n2) / 2.0;
if(promA >= 10.5)
printf("nAprobado con %8.2lf", promA);
else
printf("nDesaprobado con %8.2lf", promA);
SG+= promA;
}
printf("nnn El promedio global es %8.2lf", SG / N);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 07: Genere:
-Los 70 primeros impares positivos
-Los 50 primeros numeros multiplos de 3
-Los multiplos de 2 y 3 a la vez comprendidos en (20-100), al final
mostrar cuantos numeros se generaron.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int i, ini, fin, cantidad;
printf("nn70 primeros impares positivos nn");
ini = 1;
fin = 70 * 2;
for(i=ini ; i<=fin ; i+=2)
printf("%dt", i);
printf("nn50 primeros numeros multiplos de 3 nn");
ini = 3;
fin = 50 * ini;

26. for(i=ini ; i<=fin ; i+=3)
printf("%dt", i);
printf("nnMultiplos de 2 y 3 a la vez comprendidos en (20-100) nn");
ini = 20;
fin = 100;
cantidad=0;
for(i=ini ; i<=fin ; i++)
if(i%2==0 && i%3==0){
printf("%dt", i);
cantidad++;
}
printf("nnNumeros generados %dnn", cantidad);
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 08: Ingrese un numero, muestre el mensaje "Es primo o No"
segun sea el caso.
Numero primo es que solo es divisible por la unidad y el mismo numero
Ejm:7(1, 7), 13(1,13)
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int i, N, divisores;
printf("nrIngrese numero : "); scanf("%d",&N); fflush(stdin);
divisores=0;
for(i=1;i<=N;i++)
if(N%i==0)divisores++;
if(N==1 || divisores==2)
printf("nrEs primo ");
else
printf("nrNo es primo");
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************

27. Ejercicio 09: Ingrese un numero entero de n cifras,
muestre y sume sus cifras.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int i, N, nro, digito, S;
printf("nrIngrese numero : "); scanf("%d",&N); fflush(stdin);
S=0;
for(nro=N ; nro > 0 ; nro/= 10){
digito = nro % 10;
S+=digito;
}
printf("nnSuma digitos: %dnn", S);
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 10: Ingrese por teclados los N terminos. Sume y
genére las siguientes secuencias:
a) -2 -4 -6 -8 -10...N
b) 3.3 4.4 5.5 6.6 7.7 8.8...N
c) 1 4 9 16 25 36...N
d) -1 +2 -3 +4 -5 +6 -7...N
e) -1 3 15 35 63 99...N
f) 1 2 4 7 11 16...N
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int i, N, S, termino, parte_entera, incremento, A, B, C;
double parte_real, termino_real, S_real;
printf("nrIngrese numero de terminos : "); scanf("%d",&N); fflush(stdin);
printf("nn a) -2 -4 -6 -8 -10...N nn");
S=0;
for(i=1 ; i<=N ; i++){
termino = i*-2;
printf("%dt", termino);
S+=termino;
}
printf("nnSuma de secuencia: %dnn", S);

28. printf("nn b) 3.3 4.4 5.5 6.6 7.7 8.8...N nn");
S_real=0;
for(i=1 ; i<=N ; i++){
parte_entera = i + 2;
parte_real = parte_entera / 10.0;
termino_real = parte_entera + parte_real;
printf("%8.1lft", termino_real);
S_real+=termino_real;
}
printf("nnSuma de secuencia: %8.1lfnn", S_real);
printf("nn c) 1 4 9 16 25 36...N nn");
// B-> 3 5 7 9 11
S=0; A=1; B=3;
for(i=1; i<=N ; i++){
printf("%dt", A);
S+=A;
A+=B;
B+=2;
}
printf("nnSuma de secuencia: %dnn", S);
printf("nn d) -1 +2 -3 +4 -5 +6 -7...N nn");
S=0;
for(i=1 ; i<=N ; i++){
if(i%2!=0){
termino = i*-1;
printf("%dt", termino);
}else{
termino = i;
printf("+%dt", termino);
}
S+=termino;
}
printf("nnSuma de secuencia: %dnn", S);
printf("nn e) -1 3 15 35 63 99...N nn");
// B-> 4 12 20 28 36
// C-> 8 8 8 8
S=0; A=-1; B=4; C=8;
for(i=1; i<=N ; i++){
printf("%dt", A);
S+=A;
A+=B;
B+=C;
}
printf("nnSuma de secuencia: %dnn", S);

29. printf("nn f) 1 2 4 7 11 16...N nn");
// i-> 1 2 3 4 5
S=0; A=1;
for(i=1; i<=N ; i++){
printf("%dt", A);
S+=A;
A+=i;
}
printf("nnSuma de secuencia: %dnn", S);
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 11: Ingrese 2 numeros que representen una base y un
exponente. Muestre el resultado de la operacion.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int x,y,i; long r;
printf("Ingrese nro...");scanf("%d",&x);
printf("Ingrese exponente...");scanf("%d",&y);
r=1;
for(i=1;i<=y;i++)
r*=x;
printf("Resultado...%ldnn",r);
system("PAUSE");
}
/***************************Fin del Programa****************************/

30. 5.5 Estructura repetitiva < while > y < do - while >
/*********************************************************************
Ejercicio 01: Contruya un proceso repetitivo que permita el ingreso
por teclado de varias letras, el programa terminara cuando se
ingrese la letra 'K'
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
char car;
do{
printf("nIngrese caracter: "); car=getchar(); fflush(stdin);
}while(car!='K');
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 02: Contruya un proceso repetitivo que permita el ingreso
por teclado de varias numeros, el programa terminara cuando se
ingrese el numero cero.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int N;
do{
printf("nrIngrese numero : "); scanf("%d",&N);
}while(N!=0);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 03: Contruya un proceso repetitivo que permita el ingreso
por teclado de numeros de una cifra positivos, el programa terminara cuando se

31. ingrese un numero de mas de una cifra.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int N;
do{
printf("nrIngrese numero : "); scanf("%d",&N);
}while(N>=10);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 04: Contruya un proceso repetitivo que permita el ingreso
por teclado de numeros de dos cifras positivos, el programa terminara
cuando la suma de las cifras sea 12.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int N, U, D;
do{
printf("nrIngrese numero de dos cifras: "); scanf("%d",&N); fflush(stdin);
D = N/10;
U = N%10;
}while( D + U != 12 );
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 05: Contruya un proceso repetitivo que muestre en forma
ascendente todos los numeros impares comprendidos entre 33 y 9000
*********************************************************************/
#include <iostream>
using namespace std;
void main(){

32. int ini, fin, i;
ini=33;
fin=9000;
i=ini;
while( i<=fin ){
printf("nr %d", i);
i+=2;
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 06: Se pide ingresar un numero entero positivo de N cifras,
realice el proceso de invertir dicho numero.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
long N, nro, nroInv;
int R;
printf("nrIngrese numero de n cifras: "); scanf("%ld",&N); fflush(stdin);
nro=N;
nroInv=R=0; //Inicializamos las dos variables a cero.
do{
R = nro % 10;
nro = nro / 10;
nroInv = (nroInv * 10) + R;
}while( nro > 0 );
printf("nr Nro Invertido: %ld", nroInv);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 07: Se pide ingresar un numero en base 10, convierta
dicho numero a base 5.

33. *********************************************************************/
#include <iostream>
using namespace std;
void main(){
long N, nro, nroInv, incremento;
int R;
printf("nrIngrese numero en base 10: "); scanf("%ld",&N); fflush(stdin);
nro=N;
nroInv=R=0;
incremento=1;
do{
R = nro % 5;
nro = nro / 5;
nroInv = nroInv + R * incremento;
incremento = incremento * 10;
}while( nro > 0 );
printf("nr Nro Convertido: %ld", nroInv);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 08: Se pide ingresar una secuencia de numeros, diga
cuantos son pares, impares y multiplos de 7, ademas de la cantidad
de numeros ingresados. El programa acaba cuando se ingresa el
numero cero.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int N, cp, ci, c7, ct;
cp=ci=c7=ct=0;
do{
printf("nrIngrese numero : "); scanf("%d",&N); fflush(stdin);
if(N!=0){
if(N%2==0) cp++;
else ci++;
if(N%7==0)c7++;
}
ct++;
}while( N != 0 );

34. printf("nr Cantidad Pares : %ld", cp);
printf("nr Cantidad ImPares : %ld", ci);
printf("nr Cantidad Multiplos 7 : %ld", c7);
printf("nr Total Numeros Ingresados: %ld", ct);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 09: Se pide sumar y generar la serie fibonacci.
1 1 2 3 5 8 13 21 ...N
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int N, A, B, i, S;
printf("nrIngrese numero de terminos : "); scanf("%d",&N); fflush(stdin);
// A-> 1 1 2 3 5 8 13 21 ...N
// B-> 1 0 1 1 2 3 5 8
S=i=A=0;
B=1;
do{
A=A + B;
B=A - B;
S+= A;
printf("t%d", A);
i++;
}while( i<N );
printf("nn Suma : %d", S);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 10: Ingresar una secuencia de numeros, estos deben ser
sumados siempre que:
- Sea Impar
- Sus cifras sean diferentes
- Que la cifra del medio sea cualquiera

35. - Que sea de tres cifras
- Que sea Positivo
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int nro, U, D, C, S;
bool bandera=true;
S=0;
while(bandera){
printf("nrIngrese numero a evaluar: "); scanf("%d",&nro); fflush(stdin);
bandera = ( nro>=100 && nro <=999 );
if(!bandera)continue;
bandera = ( nro%2!=0 );
if( !bandera )continue;
C = nro / 100 ;
D = (nro % 100) / 10;
U = nro % 10;
bandera = ( C != D && D != U );
if( !bandera )continue;
S+=nro;
}
printf("nnSumatoria: %dnn", S);
system("PAUSE");
}
/***************************Fin del Programa****************************/
/*********************************************************************
Ejercicio 11: Sumar y generar la siguiente secuencia:
a) -1 -2 3 4 -5 -6 7 8...N
b) -1 -2 -3 4 5 6 -7 -8 -9...N
c) -1 -2 -3 -4 5 6 7 8...N
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int N, i, S, termino, cambio_signo, C;
bool bandera=true;
printf("nrIngrese numero de terminos: "); scanf("%d",&N); fflush(stdin);

36. cambio_signo=2;
S=C=0;
i=1;
while(i<=N){
C++;
if(bandera)
termino = i*-1;
else
termino = i;
printf("%dt", termino);
S+= termino;
if( C == cambio_signo ){
C=0;
bandera = !bandera;
}
i++;
}
printf("nnSumatoria: %dnn", S);
//Para la secuencia b) solo cambie la variable cambio_signo=3
//Para la secuencia c) solo cambie la variable cambio_signo=4
system("PAUSE");
}
/***************************Fin del Programa****************************/

37. 5.6 Anidamiento de bucles
/**********************Inicio del Programa***************************
Ejercicio 01: Se tiene en la billetera S/. 1,000 soles y se desea
comprar varios articulos, pero todos tienen el precio de
S/. 10, S/. 50 y S/. 100 soles. Diga las combinaciones posibles de
compra de tal forma que:
a) No me sobre dinero
b) Me sobre al menos S/. 10 soles
c) Me sobre al menos S/. 500 soles
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int i100, i50, i10,
final100, final50, final10,
B100=100, B50=50, B10=10;
int Monto=1000, sobra=0, combinacion;
final100 = Monto / B100;
final50 = Monto / B50;
final10 = Monto / B10;
combinacion=0;
for(i100=1;i100<=final100;i100++)
for(i50=1;i50<=final50;i50++)
for(i10=1;i10<=final10;i10++){
if( !((i100*B100 + i50*B50 + i10*B10) == (Monto - sobra)) )continue;
combinacion++;
printf("nrCombinacion: %dtB100: %d B50: %d B10: %d",
combinacion,
i100,
i50,
i10);
}
//Para el punto b) cambiar la variable sobra a 10
//Para el punto c) cambiar la variable sobra a 500
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 02: Sume u genere la siguiente secuencia de potencias
(base, potencia):

38. (10, 1), (15, 2), (20, 3), (25, 4), ...N
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int i,j, n, base ;
unsigned long s, termino;//Tipo long sin signo
printf("Ingrese #...");scanf("%d",&n);
base=10;
s=0;
for( i=1 ; i<=n ; i++){
termino=1;
for( j=1 ; j<=i ; j++)
termino = termino * base;
printf("nr(%d, %d) = %u n ",base, i, termino);
base+=5;
s+=termino;
}
printf("nnLa suma es...%u",s);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 03: Se pide mostrar y sumar todos los numeros primos de
cuatro cifras.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int c,cd,i,j;
long s;
c=s=0;
for(i=1000;i<=9999;i++){
cd=0;
for(j=1;j<=i;j++)
if(i%j==0)

39. cd++;
if(cd==2){
printf("Primo %d : %dnr",c, i);
c++;
s+=i;
}
}
printf("nnrSuma de los # primos de 4 cifras es...%d", s);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 04: Se pide mostrar y sumar la secuencia de factoriales.
FACTORIAL DE N TERMINOS S=1!+3!+5!+7!...N
Recordar que:
!3 = 3*2*1
!n = n*(n-1)*(n-2)*...* 1
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int n,i,j;
unsigned long s, termino;
printf("Ingrese #...");scanf("%d",&n);
s=0;
for(i=1;i<=n*2;i+=2){
termino=1;
for(j=1;j<=i;j++)
termino*=j;
printf("!%d = %un", i, termino);
s+=termino;
}//CIERRE FOR
printf("nnLa suma es...%u",s);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

40. /**********************Inicio del Programa***************************
Ejercicio 05: Sume u muestre todos los numeros perfectos entre
5 y 1000.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int i,j, sd, s;
s=0;
for(i=5;i<=1000;i++){
sd=0;
for(j=1;j<=i/2;j++)
if(i%j==0)
sd+=j;
if(sd==i){
printf("Es perfecto..%dn", i);
s+=i;
}
}
printf("nnLa suma es...%d",s);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 06: Sume y genere la siguiente secuencia:
1! 1 2! 1 3! 2 4! 3 5! 5 ...N
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int n,i;
unsigned long S, termino;
int A, B;//fibonacci
int j, terminofac;//factorial

41. printf("Ingrese #...");scanf("%d",&n);
// 1! 1 2! 1 3! 2 4! 3 5! 5 ...N
// 1! 2! 3! 4! 5! =>factorial
// 1 1 2 3 5 =>fibonacci
// 1 2 3 4 5 6 7 8 9 10...N -> i
S=0;
A=0;B=1;//fibonacci
terminofac=0;//factorial
for(i=1;i<=n;i++){
if(i%2==0){//fibonacci
A=A+B;
B=A-B;
termino = A;
printf("%un", termino);
}else{//factorial
terminofac++;
termino=1;
printf("%d! = ", terminofac);
for( j=1 ; j<=terminofac ; j++ ){
termino = termino * j;
if(j < terminofac)
printf("%d * ", j);
else
printf("%d", j);
}
printf(" = %un", termino);
}
S+=termino;
}
printf("nnLa suma es...%u",S);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 07: Ingrese por teclado el numerador y denominador de una
fraccion, visualice la fraccion simplificada, o la fraccion original
de no poderse simplificar.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){

42. int n,m, i, mayor, menor, ns, ms;
printf("Ingrese numerador...");scanf("%d",&n);
printf("Ingrese denominador...");scanf("%d",&m);
mayor=n;
if(m>mayor)mayor=m;
ns=n;
ms=m;
for(i=mayor;i>=1;i--)
if(ns%i==0 && ms%i==0){
ns=ns/i;
ms=ms/i;
}
printf("nnNumerador simplificado...%d",ns);
printf("nnDenominador simplificado...%d",ms);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 07: Ingrese por teclado el numerador y denominador de una
fraccion, visualice la fraccion simplificada, o la fraccion original
de no poderse simplificar.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int n,m, i, mayor, menor, ns, ms;
printf("Ingrese numerador...");scanf("%d",&n);
printf("Ingrese denominador...");scanf("%d",&m);
mayor=n;
if(m>mayor)mayor=m;
ns=n;
ms=m;
for(i=mayor;i>=1;i--)
if(ns%i==0 && ms%i==0){
ns=ns/i;
ms=ms/i;
}
printf("nnNumerador simplificado...%d",ns);
printf("nnDenominador simplificado...%d",ms);

43. printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 08:Ingresar por teclado un numero (1-3999).
Mostrar el numero en romanos.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
int n,u,d,c,m, i;
char r;
do{
printf("nnrIngrese Numero(1-3999)..."; scanf("%d",&n); fflush(stdin);
m=n/1000;
c=(n%1000)/100;
d=((n%1000)%100)/10;
u=n%10;
printf("nntt";
for(i=1;i<=m;i++)
printf("M");
if(c==9)
printf("CM");
else
for(i=1;i<=c;i++)
printf("C");
if(d==9)
printf("XC");
else
for(i=1;i<=d;i++)
printf("X");
switch(u){
case 1:printf("I");break;
case 2:printf("II");break;
case 3:printf("III");break;
case 4:printf("IV");break;
case 5:printf("V");break;
case 6:printf("VI");break;
case 7:printf("VII");break;
case 8:printf("VIII");break;
case 9:printf("IX");break;

44. }
printf("nnDesea Continuar S/N ";
r=getchar();
}while(r=='s'|| r=='S');
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************
Ejercicio 09: Caja de Prestamos a Plazos con descuentos
Se pide ingresar por teclado el monto, tasa de interes
y duracion de un prestamo a asignar a un cliente.
Debe mostrar el monto a entregar, ademas dar la opcion si desea entregar
exactamente el monto solicitado.
Debera mostrar las cuotas a pagar por meses.
*********************************************************************/
#include <iostream>
using namespace std;
void main(){
const double MES=12;
double cant, tasa, ncant, cant_sug, pag_men, inte;
int tiempo;char op;
printf("ntttPRESTAMOS A PLAZOS CON DESCUENTOS");
printf("nnIngrese monto de dinero que necesita...");
scanf("%lf",&cant); fflush(stdin);
printf("nIngrese tasa de interes...");
scanf("%lf",&tasa); fflush(stdin);
printf("nIngrese duracion de prestamo (En meses)...");
scanf("%d",&tiempo); fflush(stdin);
inte=((cant*tasa) / 100) * (tiempo / MES);
ncant=cant - inte;
pag_men=cant / tiempo;
printf("nnUsted recibira %1.2f y los pagara en %d meses con cuotas de %1.2f.",
ncant, tiempo, pag_men);
printf("nn1. Esta conforme con lo que recibe.n2. Desea recibir %1.2f", cant);
printf("nnIgrese Opcion: ");
op=getchar(); fflush(stdin);
switch(op){
case '2':
cant_sug=cant;

45. do{
cant_sug+=0.1;
inte=((cant_sug*tasa) / 100) * (tiempo / MES);
ncant=cant_sug - inte;
pag_men=cant_sug / tiempo;
}while(ncant < cant);
printf("nnUsted debe solicitar %1.2lf y los pagara en %d meses con cuotas de %1.2lf.",
cant_sug, tiempo, pag_men); break;
default: break;
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/