Introducción

El presente trabajo tiene como finalidad la elaboración de material didáctico para facilitar el

aprendizaje en cuanto a la construcción de algoritmos y su correspondiente solución en

lenguaje C. Dicho material estará basado en la solución de problemas típicos, utilizados para

el desarrollo de programas de computadora de mediana complejidad. Para ello se incluirán

los siguientes elementos para el análisis y desarrollo del mismo, a fin de lograr la

comprensión del ejercicio desde su planteamiento hasta el desarrollo final:

1. Planteamiento del problema.

2. Análisis del problema.

3. Desarrollo del algoritmo (pseudocódigo)

4. Corrida paso a paso.

5. Codificación en lenguaje C

Se incluyen además por cada tema, una serie de ejercicios planteados relacionados con el

ejercicio resuelto.

El desarrollo de los algoritmos será realizado en función de cada uno de los temas que

comprende la programación estructurada como lo es estructuras secuenciales, selectivas y

de repetición. Para la prueba de cada algoritmo se ha utilizado el programa PSEINT Para lo

cual se realizará una introducción a cada uno, sin profundizar en su contenido teórico ya que

se trata de un material totalmente práctico.

Estructuras Secuenciales

En las estructuras secuenciales una instrucción sigue a otra en secuencia, es decir, la salida
de una instrucción es la entrada de la siguiente.
Planteamiento 1. Programa para calcular el porcentaje de hombres y de mujeres en un
grupo de estudiantes.

• Análisis

Entrada Salida Proceso

Cantidad de hombres(ch) Porcentaje de hombres (ph) total = ch + cm
Cantidad de mujeres(cm) Porcentaje de mujeres (pm) ph = ch * 100 / total
pm = cm * 100 / total

• Algoritmo

Pseudocódigo

// Permite calcular el porcentaje de hombres y mujeres

Proceso porcentaje
Escribir "Ingrese la cantidad de hombres: ";
Leer ch;
Escribir "Ingrese la cantidad de mujeres: ";
Leer cm;
total<-ch + cm;
ph<-ch*100 / total;
pm<-cm*100 / total;
Escribir "Porcentaje de mujeres: ",pm;
Escribir "Porcentaje de hombres: ",ph;

FinProceso

Corrida paso a paso

ch cm total ph (%) pm (%)
6 3 9 66,66 33,33
2 167 169 1 98
 • Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;
int main() {

int ch,cm, total;

float ph;
float pm;

cout<<"Ingrese la cantidad de hombres: "<<endl;

cin>>ch;
cout<<"Ingrese la cantidad de mujeres: "<<endl;
cin>>cm;

total=ch+cm;
ph=ch*100/total;
pm=cm*100/total;

cout<<"Porcentaje de mujeres: "<<pm<<endl;

cout<<"Porcentaje de hombres: "<<ph<<endl;

return 0;
}

Planteamiento 2. Un instructor prepara tres modelos de exámenes para tres secciones en un

curso de programación. El instructor sabe que tarda 5 minutos en el modelo del salón A, 8
minutos en el modelo del salón B y 6 minutos en el modelo del salón C. ¿Cuantas horas y
minutos tardará el instructor en revisar los exámenes de todos los salones?

• Análisis
Entrada Salida Proceso
Cantidad de estudiantes del Número de horas ta=ca*5 (tiempo invertido en el salón A)
salón A (ca) (nh) tb=cb*6 (tiempo invertido en el salón B)
Cantidad de estudiantes del Número de tc=cc*6 (tiempo invertido en el salón C)
salón B (cb) minutos (nm) tt = ta + tb + tc (total de minutos
Cantidad de estudiantes del invertidos)
salón C (cc) nh = tt / 60 (Calcula la cantidad de horas,
parte entera de la división)
nm = tt % 60 (Calcula el resto de la
división)
• Algoritmo

Pseudocódigo
// Permite calcular el tiempo en horas y minutos
// invertidos en revisar 3 modelos de exámenes
// Elaborado por: Prof. Carmen Uzcátegui

Proceso tiempo
Escribir "Ingrese la cantidad de estudiantes del salón A: ";
Leer ca;
Escribir "Ingrese la cantidad de estudiantes del salón B: ";
Leer cb;
Escribir "Ingrese la cantidad de estudiantes del salón c: ";
Leer cc;
ta<-ca*5; // Tiempo invertido en el salon A
tb<-cb*8; // Tiempo invertido en el salon B
tc<-cc*6; // Tiempo invertido en el salon C
tt = ta +tb + tc;
nh = tt / 60;
nm = tt % 60;
Escribir "Cantidad de horas invertidas ",nh;
Escribir "Cantidad de minutos invertidos ",nm;

FinProceso

Corrida paso a paso

ca cb cc ta tb tc tt nh nm

7 5 8 35 40 48 123 2 3

• Codificación en lenguaje C++

Código fuente
// Permite calcular el tiempo en horas y minutos
// invertidos en revisar 3 modelos de exámenes
// Elaborado por: Prof. Carmen Uzcátegui

#include<iostream>
using namespace std;

int main() {

// Declaración de variables
int ca,cb, cc, ta, tb, tc, tt, nh, nm;

// Entrada de datos
 cout<<"Ingrese la cantidad de estudiantes del salón A: "<<endl;
cin>>ca;
cout<<"Ingrese la cantidad de estudiantes del salón B: "<<endl;
cin>>cb;
cout<<"Ingrese la cantidad de estudiantes del salón c: "<<endl;
cin>>cc;

// Proceso
ta=ca*5;
tb=cb*8;
tc=cc*6;
tt=ta+tb+tc;
nh=tt / 60; // Calcula nro de horas, (/) toma la parte entera de la división
nm=tt % 60; // Calcula el nro de minutos, (%) toma el residuo de la división.

// Salida
cout<<"Cantidad de horas invertidas "<<nh<<endl;
cout<<"Cantidad de minutos invertidos "<<nm<<endl;

return 0;

Ejercicios propuestos:

1. Una tienda ofrece un descuento del 15 % cobre el total de la compra y un cliente

desea saber cuánto deberá pagar finalmente por su compra.
2. Dada la base y altura de un rectángulo, calcular el área y el perímetro del mismo. Las
fórmulas son area=base*altura y perimetro=2*(base+altura)
3. Dados como datos el precio final pagado por un producto y su precio de venta al
público (PVP), se requiere que calcule y muestre el porcentaje de descuento que le ha
sido aplicado.
4. Un alumno desea saber cual será su calificación final en la materia Programación I.
Dicha calificación se compone de los siguientes porcentajes : 55 % del promedio de
sus tres parciales, 30 % de las practicas evaluadas y 15 % del trabajo final.

Estructuras de Decisión

Las estructuras de decisión o también llamadas de selección permite que el algoritmo tome
decisiones y ejecute u omita algunos procesos dependiendo del cumplimiento de una
condición.

Se pueden manejar tres tipos de decisiones: simple, doble y múltiple.

Una decisión es simple, cuando sólo se tiene determinado los pasos a seguir si el resultado
de la condición es verdadero, mientras que si es falso, la ejecución del algoritmo continúa
después de la estructura condicional.

Una decisión es doble, cuando se tiene un curso de acción para el caso que el resultado de
la comparación sea verdadero y otro para cuando sea falso.

La decisión múltiple determina el valor de una variable y dependiendo de éste sigue un

curso de acción. Es importante tener en cuenta que sólo se verifica la condición de igualdad
entre la variable y la constante.

Decisión simple

Planteamiento 1 : Elabore un programa que permita emitir la factura correspondiente a la

compra de un artículo determinado, del que se adquieren una o varias unidades. El IVA es
del 15% y si el monto bruto (precio venta más IVA) es mayor a 500 Bs., se debe realizar un
descuento del 5% sobre el monto total.
• Análisis
Entrada Salida Proceso
Cantidad de artículos (cant) Descripción del pv= cant*precio (precio de venta)
Precio de venta (precio) articulo (descrip) IVA = pv * 15/100
Descripción del articulo Monto a pagar mbruto= pv + IVA
(descrip) (monto) si mbruto > 500 entonces
desc= mbruto – mbruto * 5/100
monto = mbruto – desc

• Algoritmo

Pseudocódigo
// Se trata de calcular el monto a pagar por una compra, especificando un descuento
// del 5 % si el monto bruto es mayor a 500 Bs.
Proceso descuento
//Entrada
Escribir "Ingrese la descripción del articulo: ";
Leer descrip;
Escribir "Ingrese la cantidad de articulos: ";
Leer cant;
Escribir "Ingrese el precio del articulo: ";
Leer precio;

//Proceso
 pv<-cant * precio;
IVA<-pv * 15 /100;
mbruto<-pv + IVA;
desc<- 0; //Inicializo la variable descuento
Si mbruto > 500 Entonces
desc<-mbruto * 5 / 100; //Calcula el descuento
monto<-mbruto - desc;
FinSi
monto = mbruto - desc;

//Salida
Escribir "Descripcion del articulo:",descrip;
Escribir "Monto a pagar:",monto," Bs.F";

FinProceso

Corrida paso a paso

Nro descrip cant precio pv IVA mbruto desc monto
corrida
1 mesa 2 400 800 120 920 46 874
2 audifonos 1 134.50 134.50 20.175 154.675 0 154.675

• Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;

int main() {

int cant;
float desc,iva,mbruto,monto,precio,pv;
char descrip[20];

cout<<"Ingrese la descripción del articulo: ";

cin>>descrip;
cout<<"Ingrese la cantidad de articulos: ";
cin>>cant;
 cout<<"Ingrese el precio del articulo: ";
cin>>precio;

pv=cant * precio;
iva=pv * 15 / 100;
mbruto=pv + iva;
desc=0;
if (mbruto>500) {
desc=mbruto*5/100;
monto=mbruto-desc;
}
monto=mbruto-desc;

cout<<"Descripcion del articulo: "<<descrip<<endl;

cout<<"Monto a pagar: "<<monto<<" Bs.F"<<endl;

return 0;
}

Decisión doble

Planteamiento 2 : Una empresa que comercializa cosméticos tiene organizados a sus

vendedores en tres departamentos y ha establecido un programa de incentivos para
incrementar su productividad. El gerente, al final del mes, pide el importe global de las
ventas de los tres departamentos y aquellos que excedan el 33% de las ventas totales se les
paga una cantidad extra equivalente al 20% de su salario mensual. Si todos los vendedores
ganan lo mismo, determinar cuánto recibirán los vendedores de los tres departamentos al
finalizar el mes.

• Análisis
Entrada Salida Proceso
sueldo = 1500 Pago recibido por vend de vt -> ventas totales
Ventas en Bs. realizadas dep1 (sdep1) p33 -> Porcentaje de 33 % sobre vt
por el dep 1 (vdep1) Pago recibido por vend de
Ventas en Bs. realizadas dep2 (sdep2) vt = vdep1 + vdep2 + vdep3
por el dep 2 (vdep2) Pago recibido por vend de p33 = vt * 33 / 100
Ventas en Bs. realizadas dep3 (sdep3)
por el dep 3 (vdep3) // si la venta supera el 33 %, tiene un
incremento del 20 %, de lo contrario
el sueldo no cambia

si vdep1 > p33 entonces

sdep1 = sueldo + sueldo * 20/100
sino
sdep1= sueldo;
 • Algoritmo

Pseudocódigo
Proceso ventas
// Este codigo permite pagar un aumento del 20 % a aquellos vendedores
// que superaron el 33 % de las ventas globales

// Entradas de datos

sueldo <- 1500 // se define como un valor constante

Escribir "Ventas en Bs. realizadas por departamento 1:";
Leer vdep1;
Escribir "Ventas en Bs. realizadas por departamento 2:";
Leer vdep2;
Escribir "Ventas en Bs. realizadas por departamento 3:";
Leer vdep3;

// Proceso

vt <- vdep1+vdep2+vdep3;
p33 <- vt * 33 / 100;

Si (vdep1 > p33) Entonces

sdep1 <- sueldo + sueldo * 20 /100;
Sino
sdep1 <- sueldo;
FinSi

// Se hace el mismo procedimiento para los tres departamentos

Si (vdep2 > p33) Entonces
sdep2 <- sueldo + sueldo * 20 /100;
Sino
sdep2 <- sueldo;
FinSi

Si (vdep3 > p33) Entonces

sdep3 <- sueldo + sueldo * 20 /100;
Sino
sdep3 <- sueldo;
FinSi
// Salidas del programa

Escribir "Los vendedores del dep 1 recibiran un pago de :",sdep1," Bs.";

Escribir "Los vendedores del dep 2 recibiran un pago de :",sdep2," Bs.";
Escribir "Los vendedores del dep 3 recibiran un pago de :",sdep3," Bs.";
// Fin del programa

FinProceso

Corrida paso a paso

Nro sueldo vdep1 vdep2 vdep3 vt p33 sdep1 sdep2 sdep3
corrida
1 1500 12000 1300 10000 23300 7689 1800 1500 1800
2 1500 200 200 200 600 198 1800 1800 1800

• Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;
#define sueldo 1500 // para definir un valor constante
int main() {

float p33,sdep1,sdep2,sdep3,vdep1,vdep2,vdep3,vt;

// Entrada de datos
cout<<"Ventas en Bs. realizadas por departamento 1:";
cin>>vdep1;
cout<<"Ventas en Bs. realizadas por departamento 2:";
cin>>vdep2;
cout<<"Ventas en Bs. realizadas por departamento 3:";
cin>>vdep3;

//proceso
 vt=vdep1+vdep2+vdep3;
p33=vt*33/100;

if ((vdep1>p33)) {
sdep1=sueldo+sueldo*20/100;
}
else {
sdep1=sueldo;
}
if ((vdep2>p33)) {
sdep2=sueldo+sueldo*20/100;
}
else {
sdep2=sueldo;
}
if ((vdep3>p33)) {
sdep3=sueldo+sueldo*20/100;
}
else {
sdep3=sueldo;
}

//Salida
cout<<"Los vendedores del dep 1 recibiran un pago de :"<<sdep1<<" Bs."<<endl;
cout<<"Los vendedores del dep 2 recibiran un pago de :"<<sdep2<<" Bs."<<endl;
cout<<"Los vendedores del dep 3 recibiran un pago de :"<<sdep3<<" Bs."<<endl;
return 0;
}

Planteamiento 3: El gobierno del estado Táchira desea reforestar un bosque que mide
determinado número de hectáreas. Si la superficie del terreno excede a 50000 metros
cuadrados, entonces decidirá sembrar de la siguiente manera:
PORCENTAJE DE LA SUPERFICIE DEL TIPO
BOSQUE DEÁRB
OL
70% Pino
20% Eucalipto
10% Cedro

Si la superficie del terreno es menor o igual a 50000 metros cuadrados, entonces decidirá
sembrar de la siguiente manera:
PORCENTAJE DE LA SUPERFICIE DEL TIPO DE
BOSQUE ÁRBOL
50% Pino
30% Eucalipto
20% Cedro
El gobierno desea saber el número de pinos, eucaliptos y cedros que tendrá que sembrar
en el bosque, si se sabe que en 10 metros cuadrados caben 8 pinos, en 15 metros
cuadrados caben 15 eucaliptos y en 18 metros cuadrados caben 10 cedros. También se
sabe que una hectárea equivale a 10 mil metros cuadrados.

• Análisis

Entrada Salida Proceso

1 hect = 10000 Cantidad depinos supmts → Superficie en metros cuadrados
metros (cpinos) suppin → Superficie para los pinos
supeuc → Superficie para los eucalipto
Superficie del Cantidad de supced → Superficie para los cedros
bosque en hect. eucaliptos (ceucalipto)
(suphec) supmts = suphec * hect; Conversion de
Cantidad de cedros hectareas a mts2
(ccedros) // Si la sup es mayor a 50000 mts2
Se determina que superficie del terreno será
utilizado para cada tipo de árbol

si (supmts > 50000) entonces

suppin = supmts * 70/100

supeuc = supmts * 20/100
supced = supmts * 10/100
en caso contrario
...

Se aplica una regla de tres para saber la

cantidad de arboles de acuerdo a la superficie
disponible.
cpinos = suppin * 8 /10;
ceucalipto = supeuc * 15 /15;
ccedros = supced * 10 / 18;

• Algoritmo

Pseudocódigo
Proceso bosque
// Programa que calcula la cantidad de pinos, cedros y eucaliptos que se podrán
// sembrar en una superficie de terreno determinada */

hect <- 10000; // 1 hectárea equivale a 10000 metros cuadrados

// Entrada
Escribir "Ingrese la superficie del bosque en hectareas:";
Leer suphec;

// proceso
supmts <- suphec * hect; // Conversion de hectareas a mts2
 Si supmts > 50000 Entonces // Si la sup es mayor a 50000 mt2
suppin <- supmts * 70/100;
supeuc <- supmts * 20/100;
supced <- supmts * 10/100;
Sino
suppin <- supmts * 50/100;
supeuc <- supmts * 30/100;
supced <- supmts * 20/100;
FinSi
cpinos = suppin * 8 /10;
ceucaliptos = supeuc * 15 /15;
ccedros = supced * 10 / 18;

// Salida
Escribir "Cantidad de pinos a sembrar: ",cpinos;
Escribir "Cantidad de eucaliptos a sembrar: ",ceucaliptos;
Escribir "Cantidad de cedros a sembrar: ",ccedros;

FinProceso

Corrida paso a paso

Nro hect suphe supmt suppin supeuc supced cpinos ceucalip ccedros
corrid c s tos
a
1 10000 3 30000 15000 9000 6000 12000 9000 3333
2 10000 6 60000 42000 12000 6000 33600 12000 3333
3 10000 2,7 27000 13500 8100 5400 10800 8100 3000

• Codificación en lenguaje C++

Código fuente
#include<iostream>
#define hect 10000
using namespace std;

int main() {

int ccedros,ceucaliptos,cpinos;
float supced,supeuc,suppin,suphec,supmts;
 cout<<"Ingrese la superficie del bosque en hectareas:";
cin>>suphec;

supmts=suphec*hect; // Conversion a metros 2

if (supmts>50000) {
suppin=supmts*70/100;
supeuc=supmts*20/100;
supced=supmts*10/100;
}
else {
suppin=supmts*50/100;
supeuc=supmts*30/100;
supced=supmts*20/100;
}
cpinos=suppin*8/10;
ceucaliptos=supeuc*15/15;
ccedros=supced*10/18;

cout<<"Cantidad de pinos a sembrar: "<<cpinos<<endl;

cout<<"Cantidad de eucaliptos a sembrar: "<<ceucaliptos<<endl;
cout<<"Cantidad de cedros a sembrar: "<<ccedros<<endl;

return 0;
}

Planteamiento 4: Dada una cantidad de Bs. F, desarrolle un algoritmo que permita

desglosar dicha cantidad en los billetes y monedas de curso legal en el País.
Recuerde que estos son: 100, 50, 20, 10, 5, 2, 1, 0.5, 0.250, 0.125, 0.1 Imprima el
número de billetes y/monedas correspondientes.

• Análisis

Entrada Salida Proceso

Monto a desglosar, Cantidad de billetes de 100 c100 <-- monto / 100 ; se obtiene el
valor entero (c100) cociente de la division, es decir la
(monto) cantidad de billetes de 100
Cantidad de billetes de 50 (c50)
resto <-- monto % 100; con este
Cantidad de billetes de 20 (c20) operador se obtiene el residuo de la
división, el cual se tomará para la
Cantidad de billetes de 10 (c10) siguiente operación y así
Cantidad de billetes de 5 (c5) sucesivamente.
Cantidad de billetes de 2 (c2)
Cantidad de monedas de 1 (c1)
 • Algoritmo

Pseudocódigo
Proceso desglose
// Este algoritmo se encarga de tomar un monto en Bs. F
// (cantidad entera) y desglosarlo en billetes de 100, 50,20,10,5,2,1

// Declaración de variables enteras

Definir monto,resto,c100,c50,c10,c5,c2,c1 Como Entero;

Escribir "Ingrese el monto a desglosar (valor entero):";

Leer monto;
// Inicializar variables
c100<-0; c50<-0; c20<-0; c10<-0; c5<-0; c2<-0;c1<-0;

Si (monto >= 100) Entonces

c100 <- monto / 100;
resto <- monto % 100;
FinSi
Si (resto >= 50) Entonces
c50 <- resto / 50;
resto <- resto % 50;
FinSi
Si (resto >= 20) Entonces
c20 <- resto / 20;
resto <- resto % 20;
FinSi
Si (rest0 >= 10) Entonces
c10 <- resto / 10;
resto <- resto % 10;
FinSi
Si (resto >= 5) Entonces
c5 <- resto / 5;
resto <- resto % 5;
FinSi
Si (resto >= 2) Entonces
c2 <- resto / 2;
resto <- resto % 2;
FinSi
c1 <- resto;
Escribir "Cantidad de billetes de 100 ",c100;
Escribir "Cantidad de billetes de 50 ",c50;
Escribir "Cantidad de billetes de 20 ",c20;
Escribir "Cantidad de billetes de 10 ",c10;
Escribir "Cantidad de billetes de 5 ",c5;
Escribir "Cantidad de billetes de 2 ",c2;
Escribir "Cantidad de monedas de 1 ",c1;
FinProceso
Corrida paso a paso
Nro monto c100 resto c50 c20 c10 c5 c2 c1
corrid
a
1 473 0 0 0 0 0 0 0
4 73 1
23 1
3 1
1 1
2 765431 0 0 0 0 0 0 0
7654 31 1
11 1
1 1

• Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;

int main() {
int c1,c10,c100,c2,c20,c5,c50,monto,resto;
cout<<"Ingrese el monto a desglosar (valor entero):";
cin>>monto;

c100=0; c50=0; c20=0; c10=0; c5=0; c2=0; c1=0;

if ((monto>=100)) {
c100=monto/100;
resto=monto%100; // Se obtiene el residuo de la division
}
if ((resto>=50)) {
c50=resto/50;
resto=resto%50;
}
if ((resto>=20)) {
c20=resto/20;
resto=resto%20;
}
if ((resto>=10)) {
c10=resto/10;
resto=resto%10;
}
if ((resto>=5)) {
c5=resto/5;
 resto=resto%5;
}
if ((resto>=2)) {
c2=resto/2;
resto=resto%2;
}
c1=resto;
cout<<"Cantidad de billetes de 100 :"<<c100<<endl;
cout<<"Cantidad de billetes de 50 :"<<c50<<endl;
cout<<"Cantidad de billetes de 20 :"<<c20<<endl;
cout<<"Cantidad de billetes de 10 :"<<c10<<endl;
cout<<"Cantidad de billetes de 5 :"<<c5<<endl;
cout<<"Cantidad de billetes de 2 :"<<c2<<endl;
cout<<"Cantidad de monedas de 1 :"<<c1<<endl;

return 0;
}

Planteamiento 6: Leer tres números naturales y calcular el máximo el mínimo y el

promedio de esos números.

• Análisis

Entrada Salida Proceso

Numero 1 (a) Numero mayor (mayor) // Determinar si a es el mayor de todos
Numero 2 (b) Numero menor (menor) Si (a > b y a > c) Entonces
Numero 3 (c) Promedio (promedio) mayor<-a
// De los dos que quedan determinar cual
// es el menor
Si (b > c) Entonces
menor<-c;
Sino
menor<-b;
FinSi
...

• Algoritmo

Pseudocódigo
Proceso mayor_menor
// Este algoritmo va a pemitir buscar el numero mayor, el menor y el promedio
// a partir de tres valores ingresados
Escribir "Ingresar tres valores diferentes";
Escribir "Valor 1:";
Leer a;
 Escribir "Valor 2:";
Leer b;
Escribir "Valor 3:";
Leer c;

// validar que todos los valores son diferentes entre si

Si (a != b y a != c y b != c) Entonces
Escribir "valores correctos ...";
Si (a > b y a > c) Entonces
mayor<-a;
Si (b > c) Entonces
menor<-c;
Sino
menor<-b;
FinSi
Sino
Si (b > c) Entonces
mayor<-b;
Si (a > c) Entonces
menor<-c;
Sino
menor<-a;
FinSi
Sino
mayor<-c;
Si (b > a) Entonces
menor<-a;
Sino
menor<-b;
FinSi
FinSi
FinSi

promedio<-(a + b + c) / 3;
Escribir "Valor mayor:",mayor;
Escribir "Valor menor:",menor;
Escribir "Promedio:",promedio;
Sino
Escribir "Valores incorrectos, no se puede procesar";
FinSi
FinProceso

Corrida paso a paso

Nro a b c mayor menor promedi
corrid o
a
1 7 7 5 Valores incorrectos
2 14 -3 1 14 -3 4
3 6 678 -6 678 -6 226

• Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;
// Este algoritmo va a pemitir buscar el numero mayor, el menor y el promedio
// a partir de tres valores diferentes ingresados
int main() {

int a,b,c,mayor,menor;
float promedio;
cout<<"Ingresar tres valores diferentes"<<endl;
cout<<"Valor 1:";
cin>>a;
cout<<"Valor 2:";
cin>>b;
cout<<"Valor 3:";
cin>>c;
if (a != b && a != c && b != c) {
cout<<"valores correctos ..."<<endl;
if ((a>b && a>c)) { // verifica si a es el mayor
mayor=a;
if ((b>c)) { // Examina el menor entre b y c
menor=c;
} else {
menor=b;
}
} else {
if ((b>c)) { // verifica si b es el mayor
mayor=b;
if ((a>c)) { // verifica el menor entre a y c
menor=c;
 } else {
menor=a;
}
} else {
mayor=c; // el mayor es c
if ((b>a)) { // verifica el menor entre a y b
menor=a;
} else {
menor=b;
}
}
}
promedio=(a+b+c)/3;
cout<<"Valor mayor:"<<mayor<<endl;
cout<<"Valor menor:"<<menor<<endl;
cout<<"Promedio:"<<promedio<<endl;
} else {
cout<<"Valores incorrectos, no se puede procesar"<<endl;
}
return 0;
}

Decisión múltiple

Planteamiento 1 : Dado el numero del mes, muestre el numero de días y a que mes
corresponde.

• Análisis
Entrada Salida Proceso
Numero del mes (num) Descripción del mes Si num = 1 entonces
(mes) Escribir “enero”
Numero de días (ndias) Escribir “numero de dias 31”

• Algoritmo

Pseudocódigo
Proceso mes
Escribir "Ingrese el numero del mes: ";
Leer num;
ban=1;
Segun num Hacer
1:
mes<-"enero";
ndias <- 31;
2:
mes<-"febrero";
 ndias <- 28;
3:
mes<-"marzo";
ndias <- 31;
4:
mes<-"abril";
ndias <- 30;
5:
mes<-"mayo";
ndias <- 31;
6:
mes<-"junio";
ndias <- 30;
7:
mes<-"julio";
ndias <- 31;
8:
mes<-"agosto";
ndias <- 31;
9:
mes<-"septiembre";
ndias <- 30;
10:
mes<-"octubre";
ndias <- 31;
11:
mes<-"noviembre";
ndias <- 31;
12:
mes<-"diciembre";
ndias <- 31;
De Otro Modo:
ban=0;
Escribir "Error... valor incorrecto";
FinSegun
Si ban = 1 Entonces
Escribir "El mes ",num," corresponde a ", mes," y tiene ",ndias," dias";
FinSi
FinProceso

Corrida paso a paso

Nro num mes ndias Salida
corrida
1 14 Error... valor incorrecto
2 01 enero 31
 • Codificación en lenguaje C++
Código fuente
#include<iostream>
using namespace std;

int main() {

int ban,num,ndias;
string mes;

cout<<"Ingrese el numero del mes: ";

cin>>num;
ban=1; // bandera vale 1
switch (num) {
case 1:
mes="enero";
ndias=31;
break;
case 2:
mes="febrero";
ndias=28;
break;
case 3:
mes="marzo";
ndias=31;
break;
case 4:
mes="abril";
ndias=30;
break;
case 5:
mes="mayo";
ndias=31;
break;
case 6:
mes="junio";
ndias=30;
break;
case 7:
mes="julio";
ndias=31;
break;
case 8:
mes="agosto";
ndias=31;
break;
case 9:
mes="septiembre";
 ndias=30;
break;
case 10:
mes="octubre";
ndias=31;
break;
case 11:
mes="noviembre";
ndias=31;
break;
case 12:
mes="diciembre";
ndias=31;
break;
default:
ban=0; // bandera vale 0, valor incorrecto
cout<<"Error... valor incorrecto"<<endl;
break;
} // fin del case
if (ban==1) {
cout<<"El mes "<<num<<" corresponde a "<<mes<<" y tiene "<<ndias<<"
dias"<<endl;
}

return 0;

Ejercicios propuestos:

1. Calcular el cociente y el resto de la división de dos números naturales.

2. Elabore un programa que lea un número e indique si éste es par-positivo, par-negativo,
impar-positivo o impar-negativo.
3. Dados sus tres lados, determinar si un triángulo es: equilátero, isósceles o escaleno.
Equilátero: todos sus lados son iguales. Isósceles: Dos lados iguales y uno diferente.
Escaleno: Todos sus lados diferentes.
4. Determinar la edad de una persona. Mostrar la edad en años, meses y días.
5. Validar una fecha en formato DD/MM/AA.
6. Una persona desea iniciar un negocio, para lo cual piensa verificar cuánto dinero le
prestaría el banco por hipotecar su casa. Tiene una cuenta bancaria, pero no quiere
disponer de ella a menos que el monto por hipotecar su casa sea muy pequeño. Si el
monto de la hipoteca es menor que $1.000.000 entonces invertirá el 50% de la inversión
total, y un socio invertirá el otro 50%. Si el monto de la hipoteca es de $1.000.000 o
más, entonces invertirá el monto total de a hipoteca y el resto del dinero que se necesite
para cubrir la inversión total se repartirá a partes iguales entre el socio y él.
 Estructuras de Repetición

Un ciclo consiste en un grupo de acciones que se ejecutan repetidas veces

dependiendo del cumplimiento de una condición. En algunos casos, el número de
repeticiones se conoce con anterioridad, mientras que en otros depende de cálculos o
estados de variables que se dan dentro de la solución del problema. Existen tres tipos de
ciclos: ciclo Mientras-Hacer, ciclo Haga-Mientras, ciclo Desde.

Ciclo Mientras-Hacer: consiste en un conjunto de instrucciones que se repiten mientras se

cumpla una condición. Las instrucciones contenidas en el cuerpo del ciclo, se ejecutarán
solamente si al evaluar la condición se genera un valor verdadero, en caso contrario se
ejecutará la instrucción que este después del Fin-mientras.

Ciclo Repita- Hasta: funciona muy similar al ciclo Mientras-Hacer, sólo que en ésta siempre
se ejecuta el cuerpo del ciclo al menos una vez, ya que la condición se evalúa al final del
mismo y se sale del ciclo cuando la condición sea verdadera.

Ciclo Desde: este ciclo, a diferencia de los anteriores, maneja el valor inicial, el valor de
incremento o decremento y el valor final de la variable de control como parte de la
instrucción. Se utiliza cuando se conoce con anterioridad el número de veces que se debe
repetir el ciclo.

Ciclo Repita-Hasta

Planteamiento 1 : Solicite al usuario 10 números positivos y muestre el mayor de ellos

• Análisis
Entrada Salida Proceso
Número positivo Número mayor Inicializar mayor en un valor muy pequeño mayor=0
(num) (mayor) si num > mayor entonces
mayor <- num
Este proceso se repite con cada uno de los números
ingresados.
 • Algoritmo

Pseudocódigo
Proceso valor_mayor
// Solicita 10 numeros positivos y muestra el mayor de ellos
mayor<-0; // Se inicaliza la variable mayor
contador<-0; // Se inicializa el contador de los números
Repetir
Escribir "Ingrese un valor positivo: ";
Leer num;
// Se evalua si el numero es mayor a la variable 'mayor'
Si (num > mayor) Entonces
mayor<-num;
FinSi
contador<-contador+1; // Se incrementa el contador
Hasta Que contador = 10; // se repite hasta que la condicion sea verdadera, es decir
// hasta que el contador = 10
Escribir "El numero mayor es ", mayor;
FinProceso

Corrida paso a paso

Nro mayor contador num Nota
corrida
1 0 0 5 La prueba se hará solo con 5 números
5 1 17
17 2 3
3 18
18 4 1
5

• Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;

int main() {
// Declaracion de variables
 int contador, mayor, num;
mayor=0;
contador=0;
do {
// Entrada de datos
cout<<"Ingrese un valor positivo: ";
cin>>num;
if (num > mayor) {
mayor=num;
}
contador=contador+1;
} while (contador != 10);

// Salida
cout<<"El numero mayor es "<<mayor<<endl;

return 0;

Nota: Es importante resaltar que la estructura Repita-hasta, no existe en Lenguaje C y en su

defecto se utiliza la estructura Haga-Mientras, y en ella cambia la condición, ya que se
ejecuta el ciclo mientras la condición sea verdadera.

Ciclo Mientras-Hacer

Planteamiento 2 : Dadas N notas de un estudiante, calcular:

Cuantas asignaturas tiene reprobadas.
Cuantas asignaturas tiene aprobadas.
El promedio de todas las calificaciones.

• Análisis
Entrada Salida Proceso
Número de Cantidad de Si nota >= 12 entonces
notas a asignaturas ca = ca+1
procesar (n) reprobadas Sino
(cr) cr = cr+1
Calificación del Si la nota es mayor o igual a 12 (se aprueba con 12), se
estudiante Cantidad de incrementa en 1 el contador de abrobadas, de lo contrario
(nota) asignaturas se incrementa el contador de reprobadas; este proceso se
aprobadas (ca) hace con cada nota ingresada.

Promedio de suma = suma + nota; Se acumula en 'suma' el total de

calificaciones todas las notas ingresadas.
(prom)
prom = suma / n; Se divide la suma de todas las notas
entre la cantidad de ellas
 • Algoritmo

Pseudocódigo
Proceso NotasAprobasyReprobadas
// Calcular la cantidad de notas aprobadas y reprobadas de un estudiante, así como el
// promedio de ellas

ca<-0; cr<-0; suma<-0;

contador<-1;
Escribir "Cantidad de calificaciones del estudiante: ";
Leer n;
Mientras contador <= n Hacer
Escribir "Ingrese la calificacion ",contador;
Leer nota;
Si nota >=12 Entonces
ca<-ca+1; // Contador de aprobadas
Sino
cr<-cr+1; // Contador de reprobadas
FinSi
suma<-suma+nota; // Acumulador de notas
contador<-contador+1;
FinMientras
prom<-suma/n;
Escribir "Cantidad de calificaciones aprobadas: ",ca;
Escribir "Cantidad de calificaciones reprobadas: ",cr;
Escribir "Promedio de notas : ",prom;

FinProceso

Corrida paso a paso

Nro contador ca cr suma n nota prom
corrida
1 1 0 0 0 5 10 10
2 1 1 10 13
3 2 2 23 17
4 3 40 4
5 44 6
50
 • Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;

int main() {

int ca, contador, cr, n;

float nota, prom, suma;

ca=0; cr=0; suma=0; contador=1;

cout<<"Cantidad de calificaciones del estudiante: ";
cin>>n;

while (contador<=n) {
cout<<"Ingrese la calificacion "<<contador;
cin>>nota;
if (nota>=12) {
ca=ca+1;
} else {
cr=cr+1;
}
suma=suma+nota;
contador=contador+1;
}
prom=suma/n;
cout<<"Cantidad de calificaciones aprobadas: "<<ca<<endl;
cout<<"Cantidad de calificaciones reprobadas: "<<cr<<endl;
cout<<"Promedio de notas : "<<prom<<endl;

return 0;

Planteamiento 3 :La serie Fibonacci comienza con los números 0,1,1,2,3,5,8,13,21..

Desarrolle un algoritmo para generar los primeros 10 términos de la serie de Fibonacci.

• Análisis
Entrada Salida Proceso
No hay La serie 0, 1, A dos variable se asignan los primeros dos valores iniciales a=0; b=1; se
entradas 1, 2, 3, 5, 8, imprimen
13, 21, 34. c= a+b; se genera el siguiente término con la suma de los anteriores, se
imprime.
a=b; b=c; Luego a toma el valor de b y b toma el valor de c
Se repite de nuevo el paso anterior hasta que se generen los diez
términos.
 • Algoritmo

Pseudocódigo
Proceso Fibonacci
// Algoritmo que genere los primeros 10 términos de la
// serie de Fibonacci
a<-0;
b<-1;
contador<-2; // Van dos términos
Escribir "Serie de Fibonacci";
Escribir a," ",b;
Mientras contador < 10 Hacer
c<- a+b; // Se genera el sig termino
Escribir " ",c;
a<- b;
b<- c;
contador<-contador + 1;
FinMientras
FinProceso
#

Corrida paso a paso

Nro a b contador c
corrida
1 0 1 2 1
1 1 3 2
1 2 4 3
2 3 5 5
3 5 6 8
5 8 7 13
8 13 8 21
13 21 9 34

• Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;

int main() {

int a,b,c,contador;
a=0;
 b=1;
contador=2;
cout<<"Serie de Fibonacci"<<endl;
cout<<a<<" "<<b;
while (contador<10) {
c=a+b;
cout<<" "<<c;
a=b;
b=c;
contador=contador+1;
}

return 0;
}

Planteamiento 4: Una empresa paga a sus empleados como: Gerentes (reciben un salario
fijo semanal), Empleados por hora (reciben un pago fijo por hora por las primeras 40 horas
de trabajo, y 1.5 veces su pago por hora, por el tiempo extra trabajado), Empleados por
comisión (reciben 2500 Bs F. Más el 5.7 % de sus ventas brutas semanales), Empleados a
destajo (reciben un monto fijo por cada uno de los elementos que producen, y cada uno sólo
trabajan con un tipo de artículo). Calcule la paga semanal por cada empleado. No se conoce
el número de empleados. Cada empleado tiene su propio código de pago. Se procesarán
empleados hasta que se ingrese un “ * ” en el campo nombre.

• Análisis
Entrada Salida Proceso
Salario del gerente (sal_ger=2000 ). Pago semanal del Dependiendo del tipo de empleado
Salario de empleado por hora empleado (pago) se calcula el pago semanal.
(sal_hora=100 ). Los valores para tipo son 1 =
gerente, 2 = por hora, 3 = Por
Salario de empleados por comision comision, 4 = a destajo
(sal_com= 1000).
Nombre del empleado(nombre). Si tipo = 1 entonces
Tipo de empleado: gerente, por hora, pago = sal_ger
por comision, a destajo (tipo) Si tipo = 2 entonces
Si tipo = por hora, leer ch
Cant de horas trab (ch) .
.
Si tipo = comision .
Venta bruta semanal(vs)
Si tipo = destajo
Monto por articulo (monto)
Cant de articulo (cant)

• Algoritmo

Pseudocódigo
Corrida paso a paso
Nro Salida
corrida
1

• Codificación en lenguaje C++

Código fuente

Ciclo Para (Repita-Para)

Planteamiento 5: Programa que muestra los divisores de 7 comprendidos entre dos

números dados.

• Análisis
Entrada Salida Proceso
Numero 1 Los números Para todos los números comprendidos entre n1 y n2
(n1) divisores de 7 Si (numero mod 7) = 0 entonces
Numero 2 que están escribe numero
// si al dividir el numero entre 7, el resto es 0 entonces se imprime el
(n2) entre n1 y n2 // numero
• Algoritmo

Pseudocódigo
Proceso divisores_de_7
// Algoritmo que imprime los divisores de 7 comprendidos entre dos números dados
Escribir "Ingrese un primer numero";
Leer n1;
Escribir "Ingrese el segundo numero (debe ser mayor que n1)";
Leer n2;
Si n2 > n1 Entonces // Los valores ingresados son correctos
Escribir "Numero divisores de 7 comprendidos entre ",n1," y ",n2;
Para x<-n1 Hasta n2 Con Paso 1 Hacer
Si x mod 7 = 0 Entonces
Escribir " ",x;
FinSi
FinPara
Sino
Escribir "Error, el numero 2 debe ser mayor al numero 1";
 FinSi
FinProceso

Corrida paso a paso

Nro n1 n2 x Salida
corrida
1 6 23 6
7 7
8
9
10
11
12
13
14 14
15
16
17
18
19
20
21 21
22
23

• Codificación en lenguaje C++

Código fuente
#include<iostream>
using namespace std;

#define SIN_TIPO string

int main() {

int n1, n2,x;

cout<<"Ingrese un primer numero";
cin>>n1;
cout<<"Ingrese el segundo numero (debe ser mayor que n1)";
cin>>n2;

if (n2>n1) {
cout<<"Numero divisores de 7 comprendidos entre "<<n1<<" y "<<n2<<endl;
for (x=n1;x<=n2;x++) {
 if (x % 7==0) { // El operador % equivale al resto o residuo de la división
cout<<" "<<x<<endl;
}
}
} else {
cout<<"Error, el numero 2 debe ser mayor al numero 1"<<endl;
}

return 0;
}