Libro1 PDF

Universidad Nacional de Moquegua
Curso: Algoritmos y Estructura de Datos
Escuela Profesional de Ing. de Sistemas e Informtica
INTRODUCCION
ara desarrollar un programa no implica, necesariamente, sentarse frente al computador y codificarlo en

algn Lenguaje de Programacin. Por lo tanto lo que se requiere es planificar una estrategia para
enfrentar y solucionar un problema planteado. Entonces a continuacin daremos las pautas o fases para
solucionar un problema.
1.)
2.)
3.)
4.)
5.)
6.)
Enunciado.
Definicin de Entradas y Salidas (E/S)
Desarrollo algortmico. (en nuestro caso Diseo del Diagrama de Flujo)
Prueba de Escritorio.
Codificacin y
Depuracin.
En todo los problemas resueltos solamente se presentan 4 de las 6 etapas para resolver un problema en
particular, es decir Enunciado, Definicin de E/S, Diseo del Diagrama de Flujo y la Codificacin. Adems en
algunos problemas daremos a conocer la Prueba de Escritorio para su mejor entendimiento a la solucin
planteada.
Los algoritmos resueltos utilizan estructuras de programacin de acuerdo a las reglas de programacin
estructurada, utilizando como herramienta para la Codificacin el Lenguaje de Programacin C/C++, debido
a que es adoptada universalmente en todos los Centros de Enseanza en lo que respecta a la Programacin.
ETAPAS PARA LA SOLUCION DE UN PROBLEMA

Para dar solucin a un problema comprende las siguientes etapas.
1.
Enunciado. Consiste en entender claramente el enunciado del problema para que la solucin vaya
justamente a satisfacer lo que el problema requiere. Este paso es fundamental para cualquier
programador, ya que en muchas ocasiones sucede que despus de haber codificado el programa nos
damos con la ingrata sorpresa que los resultados mostrados no son precisamente los que el problema
requiere y entonces recin se nos ocurre revisar con calma el enunciado del problema, trayendo como
consecuencia una prdida de tiempo.
Por lo tanto, una recomendacin importante es que la solucin de un problema debe estar en funcin de lo
que el problema requiera y no en funcin de lo que el programador quiera.
2.
Definicin de Entradas y Salidas (E/S). En esta etapa se definen y establecen los datos necesarios para
la solucin del problema y que no se conocen (ENTRADAS), que normalmente es proporcionado por el
usuario en el momento de la Ejecucin del Programa (luego de presionar CTRL+F9 en el Lenguaje C++);
as como los datos de salida que representa los requerimientos del problema expresados como resultados
(SALIDAS), que en la mayora de las veces es por Pantalla (porque podra ser tambin a travs de
Impresora u otro dispositivo).
3.
Desarrollo Algortmico. Un Algoritmo no es mas que la solucin al problema, por lo tanto desarrollar un
Algoritmo consiste en desarrollar la solucin de un problema. Bien, esta solucin no es nica ya que un
problema puede tener tantas formas de solucionar (algoritmos), como programadores lo intenten. Es
decir, cada quien tiene una solucin que dar y es por ello que fcilmente puede detectarse cuando una
solucin es copia de otra.
Para desarrollar un algoritmo existen 2 herramientas universalmente aceptadas y reconocidas en el
mundo de la Programacin y que ambas tiene vigencia, aunque algunos prefieran a una ms que a la otra.
Estas herramientas son: El Pseudocdigo y el Diagrama de Flujo. Es decir, que uno puede desarrollar su
algoritmo con cualquiera de las 2 herramientas, no con un Lenguaje de Programacin. Pues entonces
para desarrollar un algoritmo no es indispensable conocer un Lenguaje de Programacin sino mas bien
tener un entrenamiento lgico adecuado, ahora si el algoritmo desarrollado se desea probar en un
computador, s se hace necesario conocer un Lenguaje de Programacin.
En los problemas que damos solucin optamos en la mayor parte por utilizar los Diagramas de Flujo.
MSc. Ing. Euler Tito Chura

4.
Prueba de Escritorio. Este paso consiste en verificar que la solucin planteada satisfaga los
requerimientos del problema de acuerdo a su enunciado y para esto lo nico que se debe hacer es poner
sobre un papel y en forma de tabla todos los elementos que intervienen en el algoritmo, sean constantes o
variables de tal manera que a medida que recorremos las actividades de la solucin planteada, los valores
que van tomando dichos elementos se van registrando en el papel. Cuando se termine el recorrido de la
secuencia lgica del algoritmo, lo ltimo registrado en el papel sern los valores finales de cada variable,
de las cuales algunas sern los resultados del algoritmo que se compararn con los valores esperados.
5.
Codificacin. Este paso consiste en traducir el algoritmo desarrollado (en nuestro caso el Diseo del
Diagrama de Flujo) en algn Lenguaje de Programacin (para nosotros en C/C++), para lo cual es
necesario tener conocimiento las instrucciones propias del Lenguaje C/C++., es decir la Sintaxis del
Lenguaje C/C++.
Sintaxis no es otra cosa que la forma con la que deben usarse correctamente las instrucciones de un
Lenguaje de Programacin. Por ejemplo si queremos ingresar un dato por teclado, la instruccin para
ello en Lenguaje C/C++ es cin>>variable,; en donde el valor ingresado ser almacenado en variable.
6.
Depuracin (Debug). Este paso consiste concretamente en agregarle lo que le falta y quitarlo lo que le
sobra con la finalidad de que la presentacin de los resultados sean los ms agradables posibles.
Este paso consiste tambin en poder detectar los errores lgicos que el programador puede cometer, es
decir se ejecuta el programa pero nos muestran resultados inesperados. Este paso nos permite ejecutar el
programa instruccin por instruccin para ver la variacin de los posibles valores que puede tomar las
variables que estamos usando. La experiencia demuestra que aproximadamente el ochenta por ciento
del tiempo de desarrollo de grandes aplicaciones (programas) se invierte en la depuracin de la misma.
SIMBOLOS GRAFICOS PARA DISEAR DIAGRAMAS DE FLUJO

Cuando diseemos un Diagrama de Flujo para dar solucin a un problema, haremos uso de unos
smbolos cuya finalidad/significado de cada una se detalla en el siguiente cuadro.
Simbolo
Significado/Sintaxis en C++
Inicio/Fin
Entrada/Ingreso de datos por teclado.

Sintaxis en C++: cin>>variable
Salida/Impresin/Presentacin de datos por
pantalla.
Sintaxis en C++: cout<<variable
Decisin/Condicional.
Procesamiento.
Conector.
Observacin: Aqu mostramos algunos ejemplos de Entrada y Salida de Datos (en este caso N es una
variable).

Diagrama de Flujo
Sintaxis en C++
Entrada de datos por teclado:

cout<<Ingrese el valor de N: ;
cin>>N;
N
Salida de datos por pantalla:
cout<< El valor de N es: <<N;
OBSERVACION: Algunos autores acostumbran usar el Paralelogramo para la Entrada/Salida de datos.
Entrada/Salida
LENGUAJE DE PROGRAMACION C++

C++ se deriva del Lenguaje C, estrictamente hablando es un superconjunto de C. Fue desarrollado por
Bjarne Stroustrup en Bell Laboratories. Comenz su trabajo a principios de los ochenta en respuesta a la
necesidad de disear un lenguaje de simulacin que tuviera las caractersticas de PROGRAMACION
ORIENTADA A OBJETOS, por aquel entonces un nuevo paradigma de programacin. En lugar de disear
un lenguaje, decidi aadir las caractersticas deseadas en lenguaje C, que ya estaba bien definido.
En el CECOM, en el primer curso que se imparte en lo que respecta a programacin damos a conocer las
estrategias del paradigma de la PROGRAMACION ESTRUCTURADA, que nos servir de base para poder
migrar fcilmente a la Programacin Orientada a Objetos ( para quienes quieran migrar a Visual C++, Java,
Delphi, etc; para programar a nivel de DOS/Windows. )
Comentarios:
Cuando incluimos comentarios en el cdigo fuente (en instrucciones propias de un lenguaje de programacin),
son ignorados por el compilador del lenguaje.
C++ soporta dos comentarios:
1.
Viejo estilo. Todo lo que existe entre los separadores /* y */ son comentarios. El compilador ignora todo lo
que viene despus de /* hasta que se encuentra un */.
/* Este es un comentario en C estandar */
2.
Nuevo estilo C++. Los comentarios comienzan con el simbolo //. Estos comentarios se llaman comentario
de una linea., ya que su efecto termina cuando se alcanza el final de la linea actual.
// Esta es una lnea de comentario en C++.
TIPOS DE DATOS BASICOS EN C++

Carcter
char
Cdigos ASCII entre -128 a 127
Enteros
int
long int
-32768 a 32767
-2,147483,648 a 2,147483,647

Reales
float
double
long double
10E-37 a 10E-38
10E-307 a 10E-308
10E-4932 a 10E-4932
Observacin: Existe la posibilidad de anteponer la palabra reservada unsigned (sin signo) a un tipo de datos si
solamente queremos manipular datos positivos (por lo tanto el rango de la parte negativa pasa a ser la
positiva.) Por ejemplo:
Si estamos seguros de hacer uso de enteros sin signo ( unsigned, slo positivos) entonces la declaracin sera:
unsigned int ; en este caso el rango de valores que se puede hacer uso es: 0 al 65535.
OPERADORES EN C++.
a. Aritmticos.
Operador
+
*
/
%
++
-+=
-=
*=
/=
%=
Significado
Suma.
Resta.
Multiplicacin.
Divisin.
Residuo entero de la divisin de dos enteros.
Incrementa una unidad.
Disminuye una unidad.
Incrementa el valor que est a la derecha del igual.
Disminuye el valor que est a la derecha del igual.
Multiplica por el valor que est a la derecha del igual.
Divide por el valor que est a la derecha del igual.
Residuo de dividir por el valor que est a la derecha del igual.
Ejemplos:
Del operador de incremento (++):
Var=1;
Var++;
cout<<Var;
// es lo mismo que Var=Var+1;

// imprime el valor de Var que ahora es 2
Del operador de decremento (--):

Var=2;
Var--;
cout<<Var;
// es lo mismo que Var=Var-1;

//imprime el valor de Var que es 1
Del operador de asignacin compleja (+=):

Var=1;
Var += 2;
cout<<Var;
// es la abreviacin de Var=Var + 2
// imprimir 3.
Similar interpretacin es para los otros casos.
b. Lgicos.
Operador
Significado
!
&&
Negacin.
Interseccin ( Y ).
Unin ( O ).
c. Relacionales

Operador
==
!=
>
<
>=
<=
Significado
Igual.
Diferente.
Mayor.
Menor.
Mayor igual.
Menor igual.
VERDADERO Y FALSO EN C++

En C++ no existen explcitamente el tipo de dato booleano, pero el verdadero y falso se da bajo la siguiente
concepcin:
a.) Valores distintos de CERO, son considerados como VERDADERO. Ejemplo 1, -1 , 2 etc.
b.) Valores iguales a CERO, son considerados como FALSO.
En el siguiente ejemplo siempre se imprimir en pantalla. Hola, puesto que la condicin siempre es
verdadera ( en este caso es 1 ).
if ( 1 )
{ cout<<Hola;
else
{ cout<<Adios;
}
}

CAPITULO I
PROCESOS SECUENCIALES
Se llaman procesos secuenciales debido a que su ejecucin consiste en realizar un proceso tras otro, no
dependiendo de alguna condicin que haga variar su secuencia.
Entindase que un proceso puede ser una actividad o un bloque de actividades. Una actividad puede consistir
en una instruccin de asignacin , un ingreso de datos, un clculo o simplemente una sentencia para mostrar
resultados. Por ejemplo observe la sencuencia del siguiente bloque de actividades.
Pseudocdigo:
Diagrama de Flujo:
inicio
Ingresar datos
Calcular frmulas
Mostrar resultados
inicio
fin
Ingresar
datos
:
Calcular
frmulas
Mostrar
resultados
fin
ENUNCIADO 01
Determinar la suma de los N primeros nmeros enteros de acuerdo a la siguiente frmula:
Suma =N(N+1)/2
1.
DEFINICION DE E/S:
Inicio
Entradas: Nmero entero (N)

Salida : Suma
2.
DIAGRAMA DE FLUJO Y CODIFICACION:
#include <conio.h>
#include <iostream.h>
// para usar clrscr(), getch()

// para usar cin, cout
// funcin principal
void main()
{
// declaracin de variables
Suma = N(N+1)/2
Suma
long N, Suma;
fin
// ingreso de datos
clrscr();
cout<<Ingresar un nmero entero: ; cin>> N;

// calcular suma
suma = N * (N+1)/2;
// escribir resultado
cout<< La suma de los << N
<< Primeros nmeros enteros es: << Suma;
// pausa para ver los resultados
getch();
}
ENUNCIADO 02
Calcular el inters generado por un capital depositado durante cierta cantidad de periodos a una tasa de
inters determinada y expresada en porcentaje.
Aplicar las siguientes frmulas:
Monto = Capital * (1 + Tasa/100)Nmero de Perodos
Inters = Monto Capital; Donde, Tasa es el porcentaje de inters por perodo. Un perodo puede
ser un da, un mes, un ao, etc.
1.
DEFINICION DE E/S:
Entradas: Capital, Tasa de Inters (Tasa), Nmero de perodos (NumPer)
Salida : Inters ganado (Interes)
2.
DIAGRAMA DE FLUJO Y CODIFICACIN:
#include <conio.h>
#include <math.h>
// para clrscr(), getch()

// para cin, cout
// para pow(), calcula potencia
void main()
{
Inicio
Capital, Tasa, NumPer
// inicio
float Capital, Tasa, Monto, Interes; int NumPer;
// ingresar datos
Monto = Capital*(1+Tasa/100)NumPer
Interes = Monto - Capital
clrscr(); cout<< Ingrese capital : ; cin>> Capital;

cout<< % de Tasa Inters : ; cin>> Tasa;
Interes
cout<< Nmero de perodos : ; cin>> NumPer;

// Calcular Monto de acuerdo a la frmula
Monto= Capital*pow((1+Tasa/100),NumPer);
Fin
Interes = Monto Capital // Calcular valor de los intereses

cout<<endl;
// cambio de lnea
cout<< Intereses ganados :<< Interes; // Escribir resultado

getch(); // Pausa para ver los resultados }//fin

CAPITULO II
PROCESO CONDICIONAL SIMPLE (if - else)

Se llaman procesos condicionales simples ya que la ejecucin de un proceso depende de una condicin la cual
puede ser Verdadera o Falsa.
Diagrama de Flujo:
a.) if
inicio
Sintaxis en C++:
Condicin?
if ( Condicin )
{ // inicio if
Accion_V
} // fin if
Accion_V
fin
b.) if - else
inicio
Sintaxis en C++:
if ( Condicion)
{ // inicio if
Accion_V
} // fin if
else // caso contrario
{ // inicio else
Accion_F
} // fin else
F
Condicin?
Accion_V
Accion_F
fin
Pseudocdigo:
a.) SI ENTONCES
b.) SI ENTONCES - SINO
SI
SI
condicin es verdad ENTONCES
condicin es verdad ENTONCES
Accin de Verdadero
Fin_de_SI
Accin de Verdadero
SINO
Accin de Falso
Fin_de_SI

Funcionamiento:
(1)
(2)
(3)
Evalua la condicin.
Si el resultado es verdadero
Ejecuta la Accin Verdadera y termina la estructura.
Si el resultado es falso.
Ejecuta la Accin Falsa y termina la estructura.
Ejemplo:
Ingresar EDAD
SI
EDAD >18
ENTONCES
Escribir Mayor de Edad
SINO
Escribir Menor de Edad
Fin_de_SI
Cul sera la respuesta para una persona de 21 aos? Rpta = Mayor de edad
Cul sera la respuesta para una persona de 17 aos? Rpta = Menor de edad
ENUNCIADO 01
Un restaurant ofrece un descuento al 10% para consumos de hasta S/. 30.00, un descuento de 20% para
consumos mayores y para ambos casos aplica un impuesto del 15%. Determinar el importe a pagar por lo
consumido, mostrando todos los importes.
1. DEFINICION E/S:
Entradas : Consumo
Salida : Consumo, Descuento (Dscto), Impuesto.
Importe a Pagar (Importe)
2.
inicio
//-----------------------------------------------------------------// Programa 01
// Procesos Condicionales: if-else
//-----------------------------------------------------------------Consumo
#include <conio.h>
// para usar clrscr y getch
// para usar cin y cout
#include <iomanip.h>
// para manipuladores setw, setiosflags, etc. (formato para nmeros reales)
Consumo
> 30
// funcin principal
void main()
{
Dscto = Consumo*0.20
Dscto = Consumo*0.10
float Consumo, Dscto, Impuesto, Importe;

// ingreso de consumo
Impuesto = (Consumo - Dscto) *0.15
clrscr(); // borrar pantalla

cout<< Ingrese consumo : ; cin>> Consumo;
// calcular descuento
if (Consumo > 30)
Dscto = Consumo*0.20;
else
Dscto = Consumo*0.10;
Importe = Consumo - Dscto + Impuesto
Consumo, Dscto
Impuesto, Importe
// calcular monto de impuesto

Impuesto = (Conssumo - Dscto)*0.15;
fin
// calcular monto de importe a pagar

Importe = Consumo Dscto + Impuesto

// escribir resultados
cout<< endl;
cout<< setiosflags (ios::fixed ios::showpoint); //formato para reales
cout<< Consumo :
<< setw(10) << setprecision(2) <<Consumo << endl
<< Descuento :
<< setw(10) << setprecision(2) <<Dscto << endl
<< Impuesto :
<< setw(10) << setprecision(2) <<Impuesto << endl
<< endl
<< Importe a pagar:
<< setw (10) << setprecision(2) << Importe << endl;
getch();
}
Nota:- Recordar que ios::fixed, fija formato para reales; ios::showpoint, para mostrar punto decimal y
decimales.
- Recordar que setw(n), establece el ancho del dato,.
- setprecision(2), para dos decimales.
- endl; para que el cursor vaya a la siguiente lnea (ENTER a travs de cdigo).
- En las instrucciones if y else no tienen inicio y fin de llaves ( { ..} ), pues estas llaves se obvian cuando slo
tengan una sola instruccin ( sentencia ).
ENUNCIADO 02
Ingresar por teclado 5 nmeros y determinar el MAYOR de estos nmeros.
1.
DEFINICION DE E/S:
Entradas : 5 Nmeros (A,B,C,D,E)
Salidas : Nmero mayor (mayor)
2.
//---------------------------------------------------------------// Programa 02
// Procesos Condicionales if
//---------------------------------------------------------------#include <conio.h>
void main()
{
float A, B, C, D, E, mayor;
// ingreso de 5 nmeros
clrscr();
10

cout<< Ingrese 5 nmeros separados por un espacio: ;

cin>>A>>B>>C>>D>>E;
// determinar el mayor de los nmeros ingresados

mayor = A;
inicio
A, B, C, D ,E
// asume que es el primero
if (mayor < B)
mayor = B;
mayor = A
if (mayor < C)
mayor = C;
if (mayor < D)
mayor = D;
mayor<B
F
V
mayor = B
if (mayor < E)
mayor = E;
// escribir resultado
cout<< endl;
mayor<C
V
mayor = C
cout<< Mayor valor ingresado : << mayor;

getch();
} // fin
mayor<D
V
mayor = D
mayor<E
V
mayor = E
mayor
fin
Nota: Como el control if solamente tiene una sola instruccin, entonces podemos obviar las llaves de inicio y
fin.
11

ENUNCIADO 03
El gobierno ha implementado como parte de su programa social, un subsidio familiar bajo la
siguiente reglamentacin.
a) Las familias que tienen hasta 2 hijos reciben S./. 70.00, las que tienen entre 3 y 5 hijos reciben
s/. 90.00 y las que tienen 6 hijos o ms reciben s/. 120.00 mensual.
b) Por cada hijo en edad escolar reciben S/. 10.00 adicionales. Se considera la edad escolar entre 6
y 18 aos.
c) Si la madre de familia fuera viuda, la familia recibe s/. 20.00 adicionales.
Determinar el monto mensual que recibir una familia de acuerdo a su propia realidad
familiar.
1.
DEFINICION DE E/S:
inicio
Entradas: nmero de hijos (Nhijos).

nmero de hijos en edad escolar (NhijosEsc)
estado civil de la madre (Ecivil).
Salidas: importe del subsidio (Subsidio). Nhijos, NhijosEsc, ECivil
2.
DIAGRAMA DE FLUJO.
F
V
Nhijos <= 2?
Subsidio = 70
V
Nhijos <= 5 ?
Subsidio = 120
Subsidio = 90
Subsidio = Subsidio + NhijosEsc*10
V
Ecivil = 'V'?
F
Subsidio = Subsidio +20
Subsidio
fin
12

3.
CODIFICACION EN LENGUAJE C++.
//-------------------------------------------------------------------// Programa 03
// Esctructura condicional simple (if-else)
//-------------------------------------------------------------------#include iostream.h // para usar cin (entrada de datos) y cout (salida de datos por pantalla)
#include conio.h
// para usar clrscr() ( borrar pantalla ) y getch() ( pausa para ver resultados )
#include ctype.h
void main()
{ // inicio
int Nhijos, NhijosEsc; // declaracin de variables.
float Subsidio;
char Ecivil;
// ingreso de datos
cout<<Ingrese el nmero de hijos; cin>>Nhijos;
cout<<Ingrese el nmero de hijos en edad escolar; cin>>NhijosEsc;
cout<<Ingrese el estado civil de la madre < Viuda =V, otro >: ;
Ecivil=toupper(getche());
// calcular subsidio por total de hijos.
if ( Nhijos <= 2 )
{
Subsidio = 70;
}
else
{
if ( Nhijos <= 5 ) {
Subsidio = 90;
}
else {
Subsidio = 120;
}// fin else
} // fin de else
// incrementar subsidio por hijos en edad escolar.
Subsidio= Subsidio + NhijosEsc*10;
// incrementar subsidio por viudez de la madre.
if ( Ecivil == V ) {
Subsidio = Subsidio + 20;
} // fin de if
// impresin de resultado en pantalla previamente con un mensaje.
cout<<La familiar recibir un subsidio de: <<Subsidio<< soles;
getch(); // pausa para ver resultados
} // fin
Nota: getche(); nos permite ingresar un solo caracter por teclado, en nuestro caso para ingresar V si la
madre fuera viuda.
- Pero resulta que el usuario puede ingresar V (mayscula ) o v (es decir minscula); para ello como la
comparacin de if es con el carcter V mayscula, la letra ingresada debemos de convertir a mayscula para
que se pueda comparar perfectamente, entonces hacemos uso de la funcin del C++ toupper, que nos permite
convertir a mayscula una letra.
Es decir:
Ecivil=toupper(getche()) ; nos permite ingresar una letra por teclado (con getche) y esta a su vez convertirla
a mayscula (con toupper ) y luego asignarla a la variable Ecivil.
13

Observacin: No confundir getch () con getche(), la diferencia es que getch no nos permite ver en pantalla la
letra ingresada por teclado, encambio getche() si nos permite verla.
ENUNCIADO 04
Un restaurant decide ampliar sus ofertas de acuerdo a la siguiente escala de consumo que se detalla en la tabla.
Determinar el importe a pagar por lo consumido, mostrando todo los importes (Impuesto = 15%)
1.
Consumo(S/.)
Dscto(%)
Mayor a 100 soles.
30%
Mayor a 60 soles.
20%
Mayor a 30 soles.
15%
Hasta 30 soles.
10%
DEFINICION E/S.
Entrada: Consumo
Salida: Consumo, Descuento (Dscto), Impuesto, Importe a Pagar (Importe)
2.
DIAGRAMA DE FLUJO.
Inicio
Consumo
Consumo>100
Dscto=Consumo*0.3
Consumo>60
Dscto=Consumo*0.2
Consumo>30
Dscto=Consumo*0.10
Dscto=Consumo*0.15
Impuesto=(Consumo-Dscto)*0.15
Importe = Consumo Dscto + Impuesto
Consumo, Dscto,
Impuesto, Importe
fin
14

3. CODIFICACION EN C++.
//-------------------------------------------------// Programa 04
// Procesos condicionales (if else )
//-------------------------------------------------#include iostream.h
// para usar cin( ingreso de datos) y cout( salida de datos )
#include conio.h
// para clrscr y getch.
#include iomanip.h
// para formato de nmeros reales.
void main()
{ // inicio .
float Consumo, Dscto, Impuesto, Importe; // declaracin de variables
// ingreso de consumo
cout<<Ingrese el consumo:; cin>>Consumo;
// calcular descuento.
if ( Consumo > 100 )
{ Dscto=Consumo*0.30; }
else {
if ( Consumo > 60 )
{ Dscto=Consumo*0.20;
else { // inicio else

if ( Consumo>30 )
{ Dscto=Consumo*0.15; }
else
{Dscto=Consumo*0.10;
} // fin else
}
Impuesto = (Consumo-Dscto)*0.15; // calcular monto del impuesto.
Importe = Consumo Dscto + Impuesto;
// Escribir resultados
cout<<setiosflags(ios::fixed|ios::showpoint); // formato para reales.
cout<< Consumo
<<setw(10)<<setprecision(2)<<Consumo<<endl
<<Descuento
<<setw(10)<<setprecision(2)<<Dscto<<endl
<<Impuesto
<<setw(10)<<setprecision(2)<<Impuesto<<endl
<<endl
<<Importe a pagar:
<<setw(10)<<setprecision(2)<<Importe<<endl;
15


Inicio
} // fin
ENUNCIADO 05
A, B, C
Determinar las races de una ecuacin de segundo grado del tipo: Ax2 + Bx + C = 0. Considerar la siguiente
frmula:
Imaginario = Falso
X = (-B +- B2 4AC) / 2A
1.
DEFINICION DE E/S:
A=0 YB=0
Entradas : Coeficientes (A,B,C)

Salidas : Races (Raiz1, Raiz2)
2.
DIAGRAMA DE FLUJO:
F
Sin Races
A=0
Disc = B2 4AC
Raiz1 = C / B * (-1)
Disc <0
Raiz2 = Raiz1
Imaginario = Verdadero
Disc = Disc * (-1)
Raiz1 = (-B+\|disc)/2A
Raiz2 = (-B-\|disc)/2A
Raiz1, Raiz2
Imaginario =
Verdadero
F
Raices
Imaginarias
fin
16

3. CODIFICACION:
//--------------------------------------------------------// Programa 05
// Programas Condicionales: if - else
//--------------------------------------------------------#include <conio.h>
#include <math.h>
// definir constantes
#define False 0
#define True 1
// False= 0
// True = 1
// funcin principal
void main()
{
float A, B, C, Disc, Raiz1, Raiz2;
int imaginario;
// ingreso de 3 coeficientes
clrscr();
cout<< Ingressar los 3 coeficientes separados por espacios : ;
cin>>A>>B>>C;
// Asumir que no hay races imaginarias

Imaginario = False
// verificar si la ecuacin tiene solucin
if (A ==0 && B==0)
cout<<Ecuacin sin solucion;
else
{
if (A == 0)
{
Raiz1 = C/B * (-1);
Raiz2 = Raiz1;
}
else
{
Disc = pow(B,2) 4 *A *C;
if (Disc < 0)
{
Imaginario = True;
Disc = abs (Disc);
}
Raiz1 = (-B + pow(Disc,1/2)) / (2*A);
Raiz2= (-B pow (Disc,1/2)) / (2*A);
}
// escribir resultados
cout<<endl;
cout<<setiosflags(ios::fixed | ios::showpoint);
cout<<Ecuacin a resolver: <<endl
<<setw(12)<<2<<endl
<<setw(10)<<setprecision(2)<<A<<X +
<<setw(10)<<setprecision(2)<<B<<X +
<<setw(10)<<setprecision (2)<<C<< = 0
<<endl
<<Raiz1 = <<setw (8)<<setprecision(3)<<Raiz1<<endl
<<Raiz2 = <<setw(8)<<setprecision(3)<<Raiz2<<endl;
if (imaginario)
cout<< Son races imaginarias;
}
getch();}
17

CAPITULO III
PROCESO SELECCIN MULTIPLE (switch)

Sintaxis en C++
Diagrama de Flujo
Inicio
switch ( Selector )
Selector
{ // inicio switch
case Alternativa1 : Instrucciones1; break;
case Alternativa2 : Instrucciones2; break;
Alternativa1
Instrucciones1
........
Alternativa2
Instrucciones2
case AlternativaN : InstruccionesN; break;

default: InstruccionesX;
............................
} // fin switch
Alternativa
InstruccionesN
OTRO CASO
InstruccionesX
Fin
Pseudocdigo:
EN CASO
que SELECTOR SEA
Alternativa1 : Acciones1
Alternativa2 : Acciones2
...........
AlternativaN : AccionesN
SINO
AccinX
FIN del CASO
18

El Selector puede ser: variable, expresin, funcin; sin embargo, el valor que representa debe ser escalar. Es
decir numrico entero, o carcter individual. De ninguna manera puede ser una cadena ni un float. Este
selector ser evaluado en cada alternativa hasta encontrar su lugar.
Funcionamiento:
(1). El valor del SELECTOR es evaluado en las alternativas una por una.
(2). Si encuentra una alternativa que contenga el valor del selector, ejecuta la accin correspondiente y
termina la estructura.
(3). El uso de default (otro caso) es opcional, sin embargo sirve para ejecutar algo (InstruccionesX) cuando el
selector no encuentra su lugar; es decir, que su valor no se encuentra contenido en ninguna alternativa.
Ejemplo:
EN CASO
0 a 2
que EDAD
SEA
: escribir beb
3. a 15 : escribir nio
16 .a 25 : escribir joven
26 a 15 : escribir adulto
SINO
Escribir anciano
Fin del CASO
Cul sera el resultado para una persona de 20 aos? Rpta= joven
Cul sera el resultado para una persona de720 aos? Rpta= anciano
19

ENUNCIADO 01
Inicio
Determinar el nombre correspondiente a un nmero de mes y adems a la estacin a la que pertenece,
considerando 3 meses completos por estacin.
NumMes
1. DEFINICION DE E/S:
Entradas: Nmero de mes (NumMes)
Salida : nombre del mes (NombreMes), estacin
2.
DIAGRAMA DE FLUJO:
NumMes
1, 2, 3
Estacin = Verano
4, 5, 6
Estacin = Otoo
7, 8, 9
Estacin = Invierno
10, 11,12
Estacin = Primavera
Otro caso
Estacin = Desconocida
NumMes
NombreMes =Enero
NombreMes = Febrero
NombreMes = Marzo
NombreMes = Abril
NombreMes = Mayo
NombreMes = Junio
NombreMes = Julio
NombreMes = Agosto
NombreMes = Setiembre
10
NombreMes = Octubre
11
NombreMes = Noviembre
12
NombreMes = Diciembre
Otro
NombreMes = Desconocido
NombreMes,
Estacin
Fin
20

3.
CODIFICACION:
//-------------------------------------------------------------// Programa 01
// Procesos de Seleccin Mltiple: switch()
//-------------------------------------------------------------#include <conio.h>
#include<string.h>
// para strcpy()
void main()
{
unsigned int NumMes;
char estacion[15], NombreMes[15];
// ingreso del nmero del mes

clrscr();
cout<<Ingrese Nmero de Mes: ; cin>>NumMes;
// determinar estacin
switch (NumMes){
case 1: case 2: case3:
strcpy(estacion,Verano); break; // lo mismo que estacion = Verano
case 4: case 5: case 6:
strcpy(estacion,Otoo); break;
strcpy(estacion,Invierno); break;
Nota:
La funcin strcpy(estacion,Otoo), hace
que se copie la cadena Otoo a la variable
estacion; algo as como:
Estacion=Otoo
strcpy(estacion,Primavera); break;
default:
strcpy(estacion,Desconocida); break;
}
// Determinar nombre del mes
switch (NumMes){
case 1: strcpy(NombreMes, Enero); break; // lo mismo que NombreMEs = Enero
case 2: strcpy(NombreMes, Febrero); break;
case 3: strcpy(NombreMes, Marzo); break;
case 4: strcpy(NombreMes, Abril); break;
case 5: strcpy(NombreMes, Mayo); break;
case 6: strcpy(NombreMes, Junio); break;
case 7: strcpy(NombreMes, Julio); break;
case 8: strcpy(NombreMes, Agosto); break;
21

case 9: strcpy(NombreMes, Setiembre); break;

case 10: strcpy(NombreMes, Octubre); break;
case 11: strcpy(NombreMes, Noviembre); break;
case 12: strcpy(NombreMes, Diciembre); break;
default: strcpy(NombreMes, Desconocido);
// lo mismo que NombreMes = Desconocido
}
cout<<endl;
cout<<Nombre : <<NombreMes<<endl
<<Estacin : <<estacion<<endl;
getch(); }
ENUNCIADO 02
En una tienda de accesorios para computadores, el precio de venta unitario de los diskettes es el mismo para
cualquier marca, sin embargo el descuento vara de acuerdo a la marca y se establece en la siguiente tabla.
Determinar el importe a pagar por la cantidad de diskettes comprados de una sola marca, considerando que
no se paga impuestos. Mostrar importe bruto, descuento e importe a pagar.
Marca
Dscto (%)
3M
10
NRC
15
Sentinel
20
Burroughs
25
GoldStar
30
Inicio
Marca,Precio,
Cantidad
ImpBruto = Cantidad*Precio
1.
DEFINICION DE E/S:
Entradas : Marca, Precio,Cantidad
Marca
Salidas : Importe bruto(ImpBruto),

Descuento (Dscto),
Importe a Pagar (Importe).
2.
3M
Dscto = ImpBruto*0.10
NCR
Sentinel
#include <conio.h>
Burrougths
Goldstar
void main() {
float Precio, ImpBruto, Dscto, Importe;
unsigned int Cantidad; // slo enteros positivos
Importe=ImpBruto-Dscto
char Marca; clrscr();

cout<<setw(10)<<MARCAS<<endl<<endl;
cout<<[1]... 3M <<endl
ImpBruto, Dscto,
Importe
<<[2]... NCR <<endl

<<[3]... Sentinel <<endl
Fin
<<[4]... Burroughs <<endl
22

<<[5]... GoldStar <<endl;

cout<<Marca: ; cin>>Marca;
cout<<Precio: ; cin>>Precio;
cout<<Cantidad: ; cin>>Cantidad;
ImpBruto=Cantidad * Precio;
switch ( Marca ){
case 1: Dscto = ImpBruto * 0.10; break;
}
Importe = ImpBruto-Dscto;
cout<<setiosflags( ios::fixed|ios :: showpoint );
cout<<Importe Bruto:
<<setw(10)<<setprecision(2) <<ImpBruto<<endl
<<Descuento:
<<setw(10)<<setprecision(2) <<ImpBruto<<endl
<<Importe:
<<setw(10)<<setprecision(2) <<ImpBruto<<endl;
getch(); }
// fin
ENUNCIADO 03
Determinar el importe a pagar por un alumno de un instituto cuya cuota tiene un porcentaje de descuento que
se establece en la siguiente tabla y est en funcin del colegio de procedencia del alumno; asimismo los
importes estn exonerados de impuestos.
Colegio
Nacional
Particular
1.
INSTITUTOS
A B C
50 40 30
25 20 15
DEFINICION DE E/S:
Entradas : Instituto, Colegio, Cuota.
Salidas : Importe a pagar (Importe).
2.
DIAGRAMA DE FLUJO:
23

Inicio
Instituto,Colegio,Cuota
Instituto
A
Colegio
Dscto=Cuota*0.50
Dscto=Cuota*0.25
B
Colegio
Dscto=Cuota*0.40
Dscto=Cuota*0.20
C
Colegio
Dscto=Cuota*0.40
Dscto=Cuota*0.20
Importe=Cuota-Dscto
Importe
Fin
24

3.
CODIFICACION:
//----------------------------------------------// Programa 03
// Procesos de Seleccin Mltiple: switch()
//----------------------------------------------#include <conio.h>
#include <ctype.h>
// para toupper()
void main()
{
char Instituto, Colegio; // declaracin de variables
// ingreso de datos
clrscr();
cout<<Ingrese instituto A/B/C: ;
Instituto = toupper (getche()); // en espera de ingresar el instituto. cout<<endl<<Ingrese Colegio N/P: ;

Colegio = toupper(getche()); // en espera de ingresar tipo de colegio.
cout <<endl<<Ingrese cuotas del mes: ; cin>>Cuota;
// determinar descuento correspondiente
switch (instituto){
caseA: switch (Colegio) {
caseN : Dscto = Cuota *0.50; break;
caseP : Dscto = Cuota *0.25; break;
}
break;
caseB: switch (Colegio) {

caseN : Dscto = Cuota 0.40; break;
}
break;
caseC: switch (Colegio) {

caseN : Dscto = Cuota *0.30; break;
}
break;
25

// calcular el importe a pagar

Importe = Cuota Dscto;
cout<<endl;
cout<<setiosflags(ios::fixed|ios::showpoint);
cout<<Importe a pagar :
<< setprecision(2)<<Importe<<endl;
// pausa para ver resultados
getch();
}
26

ENUNCIADO 04
Inicio
Validar el ingreso de una fecha en el formato da, mes, ao numricos determinando si es correcta o no,
mostrando el mensaje correspondiente, considerar aos bisiestos.
1.
Dia, Mes, Anio
DEFINICION DE E/S:
Entradas : Da, Mes, ao (anio)
Salidas : Mensaje
2.
correcto
DIAGRAMA DE FLUJO:
F
Mes
1, 3, 5, 7, 8, 10, 12:
DMax = 31
4, 6, 9, 11:
DMax = 30
2
F
Anio es
bisisesto
DMax = 28
DMax = 29
Dia >
DMax
F
Correcto
Fecha incorrecta
Correcto = Falso
Fecha Correcta
Fin
27

3.
CODIFICACION:
//----------------------------------------------------// Problema 04
// Procesos de Seleccin Mltiple : switch
//----------------------------------------------------#include <conio.h>
// definicin de constantes
#define False 0
// False=0
#define True 1
// False=1
// funcin principal
void main()
{
// declaracin de constantes
unsigned int Dia, Mes, Anio, DMax;
unsigned int Correcto;
// ingresar dia, mes, ao
clrscr();
cout<<Ingrese dia<1...31>: ; cin >>Dia;
cout<<Ingrese mes<1...12>: ; cin >>Mes;
cout<<Ingrese ao<1900>: ; cin >>Anio;
// Evaluar da mximo correspondiente al mes ingresado
switch (Mes){
case 1: case 3: case 5: case 7: case 8:
case 10: case 12: DMax = 31; break;
case 4: case 6: case 9: case 11: DMax = 30; break;
case 2: if (Anio % 4 == 0)
DMax = 29;
else
DMax = 28;
}
// Evaluar validez de la fecha
if ( (Dia>= 1 && Dia<= DMax) &&
(Mes>=1 && Mes <= 12) && (Anio>= 1900))
Correcto = True;
else
Correcto = False;
// Escribir un mensaje
if (Correcto)
cout <<fecha correcta ; // if tiene una sola instruccin, entonces se obvia las llaves
else
cout<<fecha incorrecta; // else tiene una sola instruccin, entonces se obvia las llaves
// Pausa para ver resultado

getch();
}
28

CAPITULO III
CONTROL DE FLUJO REPETITIVO ( for )

Sintaxis en C++.
for ( inicializacin; condicin; incremento )
for ( contador = ValorInicial; contador <= ValorFinal;

contador = contador + incremento)
{ // inicio de for.
{ // inicio de for.
Instrucciones
Instrucciones
} // fin de for
} // fin de for
NOTA: Esto es si ValorInicial <= ValorFinal
Diagrama de Flujo
Inicio
contador=ValorInicial
ValorFinal ; incremento
Instrucciones
Fin
Pseudocdigo:
PARA contador = ValorInicial HASTA
ValorFinal HACER
Instrucciones
FIN_de_PARA
Interpretacin:
El contador debe ser necesariamente una variable
El ValorInicial y el ValorFinal pueden ser: constantes (numeros) o variables, funciones.
Funcionamiento:
(1). contador toma primeramente el ValorInicial
(2). Si contador <= ValorInicial, entonces ejecutamos el conjunto de instrucciones, luego se
incrementa el contador dependiendo del valor del incremento, regresando al punto (2).
29

(3). Termina cuando el contador sea mayor que el ValorFinal.
OBSERVACION:
Si ValorInicial >= ValorFinal, entonces la sintaxis en C++ sera: (cuando usemos el for para decrementar.)
for ( contador=ValorInicial; contador>= ValorFinal;
contador = contador - incremento)
{ // inicio de for.
Instrucciones
} // fin de for
ENUNCIADO 01
Mostrar en pantalla la tabla de multiplicar del 1 al 18 para cualquier nmero, de la siguiente manera:
Ejemplo: Ingrese un nmero 7
Tabla de multiplicar del 7:
7*1=7
7 * 2 = 14
7 * 3 = 21
.................
.................
7 * 18 = 126
Entradas: Un nmero (Num)
Salidas : Tabla de multiplicar
2. DIAGRAMA DE FLUJO Y CODIFICACION:

//--------------------------------------------------
Inicio
// Procesos Repetitivos: for

//--------------------------------------------------
Num
#include <conio.h>
Cont = 1
18;1
// funcin principal
Num,x,Cont,=
Num * Cont
void main()
{
Fin
float Num;
short cont; // tipo de dato intero pequeo
// ingresar nmero
30

clrscr();
cout<<Ingresar un nmero: ; cin>>Num;
// Mostrar la tabla
cout<<setiosflags(ios::fixed | ios::showpoint);
for (cont =1; cont <= 18; cont ++)
cout<<setprecision(2)<<Num
<<x
<<setw(3)<<cont
<<=
<<setw(10)<<setprecision(2)<<Num * cont
<<endl;
getch();
}
Note que el for de mostrar tabla no lleva las llaves debido a que el cout que va dentro del for es una sola sentencia.
ENUNCIADO 02
Mostrar todos los divisores de un nmero entero. Si el nmero solo tiene por divisores al 1 y al propio nmero,
mostrar el mensaje Numero Primo.
Entradas: Un nmero entero (NumEnt)
Salidas : Cantidad de divisores (ContDiv)
Mensaje : No es Primo o Nmero Primo
2. DIAGRAMA DE FLUJO Y CODIFICACION:
//----------------------------------------------------// Procesos Repetitivos: for

//----------------------------------------------------#include <conio.h>
// funcin principal
void main()
{
long NumEnt, ContDiv, Divisor;
// ingresar un nmero entero

clrscr();
cout<<Ingrese un nmero entero: ; cin>>NumEnt;
31

cout<<endl
Inicio
<<Divisores de <<NumEnt<< : <<endl;
NumEnt
// inicializar CONTADOR de divisores

ContDiv = 0;
ContDiv = 0
// Mostrar y contabilizar divisores
for (Divisor = 1; Divisor <=NumEnt; Divisor ++)
Divisor = 1, NumEnt;1
if (NumEnt % Divisor == 0)
{
cout<<Divisor<<endl;
Residuo de
NumEnt/Divisor=0
ContDiv++;
}
Divisor
F
// Escribir mensaje
cout<<endl;
ContDiv = ContDiv+1
if(ContDiv == 2)
cout<<NUMERO PRIMO;
else
cout<<NO ES PRIMO;
getch();
ContDiv = 2
Numero Primo
No es Primo
Fin
NOTA: Si un nmero slo es divisible por 1 y por l mismo, nicamente tendr 2 divisores; de sta manera
sabremos si un nmero es primo.
32

ENUNCIADO 03
Un jurado Provincial desea hacer un proceso de simulacin realizando 10 simulacros aleatorios previos a la
realizacin de unas elecciones municipales. Para lo cual considera solamente 2 candidaturas, 43 distritos, y en
cada distrito un mximo de 400 electores; adems no se deben considerar votos nulos/blancos/viciados.
Generando votaciones aleatorias en todos los distritos , mostrar el nmero de votos alcanzados por cada
candidato con su correspondiente porcentaje que representa en cada simulacro. Al trmino de todo el proceso
de simulacin indicar las veces que gana cada candidato y el nmero de la candidatura ganadora si lo hubo ya
que se considera ganador aquella candidatura que obtenga ms de la mitad de votos.
1. DEFINICION E/S.
Entradas: ninguna
Salidas : resultados parciales:
Nmero del simulacro (simulacro).
Votacin del candidato 1 ( total_cand1)
Votacin del candidato 2 ( total_cand2)
Porcentaje del candidato 1 ( ptaje_cand1 )
Porcentaje del candidato 2 ( ptaje_cand2 )
Nmero de candidato ganador ( ganador)
Resultados finales:
Nmero de veces que gana candidato 1 ( cont_ganador1 )
Nmero de veces que gana candidato 2 ( cont_ganador2 )
Nmero del candidato ganador ( ganador )
2. CODIFICACION
//-----------------------------------------------------------------// Programa 03
// Procesos repetitivos: for
//------------------------------------------------------------------#include conio.h
#include iostream.h
#include iomanip.h // para el formato de nmeros reales (flotantes)
#include stdlib.h
// para randomize(), random(); es decir para la generacin de nmeros aleatorios.
void main()
{ // inicio
// declaracin de variables.
short candidato, ganador, distrito, cont_ganador1, cont_ganador2, simulacro;
long votos_cand1, votos_cand2, total_cand1, total_cand2, poblacion;
float ptaje_cand1, ptaje_cand2;
// determinar poblacin total de electores

poblacion=43*400;
33

// inicializar contadores.
cont_ ganador1=0; // nmero de veces que gana el candidato1
cont_ganador2=0; // nmero de veces que gana el candidato2
// inicializar generador de nmeros aleatorios.

randomize();
// escribir ttulos
clrscr(); // se borra pantalla.
cout<<setw(10)<<SIMULACRO
<<setw(15)<<CANDIDATO1
<<setw(10)<<% CAND1
<<setw(15)<<CANDIDATO2
<<setw(10)<<%CAND2
<<setw(10)<<GANADOR
<<endl;
// proceso repetitivo de simulacros.

for (simulacro=1; simulacro <= 10; simulacro++)
{
// inicializar elementos
total_cand1=0; // total votacin del candidato1
total_Cand2=0; // total votacin del candidato2
// proceso repetitivo de distritos

for ( distrito=1; distrito <= 43; distrito++ )
{ // generar votacin aleatoria para cada candidato
votos_cand1=random(400);
votos_cand2=400 votos_cand1;
// acumular votaciones
total_cand1 += votos_cand1;
total_cand2 += votos_cand2;
} // for distrito
// calcular porcentaje de votaciones

ptaje_cand1 = (float)(total_cand1*100/poblacion); // con float se fuerza a un resultado real.
ptaje_cand2= 100 ptaje_cand1;
// determinar el nmero de candidato ganador.

if ( total_cand1 > poblacion/2 )
34

ganador=1;
// como es una sola instruccin, se obvian las llaves.
else
ganador=2; // no se consideran votos nulos., adems como es una sola instruccin, se obvian las llaves
// incrementar contador de veces que gana un candidato.

switch( ganador )
{ case 1 : cont_ganador1++; break; // es lo mismo que cont_ganador1=cont_ganador1 + 1
case 2 : cont_ganador2++; break; // es lo mismo que cont_ganador2=cont_ganador2 + 1
} // fin switch
// mostrar resultados por simulacro.

cout<<setiosflags(ios::fixed | ios::showpoint); // para el formato de nmeros reales
cout<<setw(10)<<simulacro
// para un ancho de 10
<<setw(15)<<total_cand1
<<setw(10)<<setprecision(1)<<ptaje_cand1 // un ancho de 10 y 1 decimal.
<<setw(15)<<total_cand2
<<setw(10)<<setprecision(1)<<ptaje_cand2
<<setw(10)<<ganador<<endl;
delay(100); // para un tiempo de espera (pausa)

} // for simulacro
// determinar ganador de todo el proceso de simulacin
if ( cont_ganador1 > cont_ganador2 )

ganador=1;
else
if ( cont_ganador1 < cont_ganador2 )
ganador=2;
else
ganador=0;
// empate
// mostrar resultados finales

cout<<endl<<setiosflags(ios::fixed | ios::showpoint)
<<CANDIDATO 1, gan <<setw(3)<<cont_ganador1
<< veces<<endl
<<CANDIDATO 2, gan<<setw(3)<<cont_ganador2
<<veces<<endl<<endl;
if ( ganador != 0 ) // si ganador es diferente de CERO

cout<<se proclama GANADOR al candidato<<ganador;
35

else
cout<<NO HAY GANADOR;
} // fin
NOTA: La funcin random(n) , nos retorna un nmero aleatorio comprendidos entre 0 y (n-1).
3. DIAGRAMA DE FLUJO.
36

Inicio
poblacion = 2 * 400
cont_ganador = 0
cont =_ganador = 0
simulacro = 1, 10; 1
total_cand1 = 0
total_cand2 = 0
cont_ganad1 >
cont ganador2
F
distrito = 1, 43; 1
V
ganador = 1
F
votos _cand1 = RANDOM (100)
votos_cand2 = 400 votos_cand1
cont_ganador1 >
cont_ganador2
ganador = 0
V
ganador = 1
total_cand1 = total_cand +
votos_cand1
total_cand2 = total_cand2 +
votos_cand2
ganador != 0
F
ptaje_cand1 = total_cand1 * 100/poblacion
ptaje_cand2 = total_cand2 * 100/poblacion
ganador = 0
ganador = 1
total_cand1
> poblacion/2
ganador = 2
Fin
ganador = 1
ganador
cont_ganador1 =
cont_ganador1 + 1
cont_ganador2 =
cont_ganador2 + 1
simulacro,
total_cand1, ptaje_cand1
total_cand2, ptaje_cand2,
ganador
37

ENUNCIADO 04
En cierta empresa se van a producir aumentos de sueldos a sus trabajadores en base a la siguiente escala:
Sueldo (S/.)
Aumento (%)
501 - ms
10
351 - 500
15
201 - 350
20
hasta 200
25
La empresa cuenta con 50 trabajadores y se desea calcular el total de personas que recibirn el 10, 15, 20 y
25% de aumento, as como el total a desembolsar por la empresa.
1.
DEFINICION DE E/S.
Entradas:
Sueldo
Salidas:
Cantidad de personas con 10% de aumento (Np10)

Monto total a desembolsar por la empresa (Monto).
2.
CODIFICACION EN C++
// ------------------------------------------// Programa 04
// Procesos Repetitivos: for
// -----------------------------------------#include conio.h
#include iostream.h
#include iomanip.h
//definicin de constantes.
#define NumEmp 50 // Nmero de empleados ( NumpEmp=50)
void main() {
// declaracin de variables.
short Np10, Np15, Np20, Np25, ContEmpe;
float Monto, Sueldo;
// inicializar CONTADORES.
Np10=0; // reciben 10% de aumento
//Inicializar ACUMULADOR total a pagar por la empresa.
Monto=0.0;
clrscr();
cout<<Ingresar<<NumEmp<< sueldos:<<endl;
for ( ContEmpe=1; ContEmp<=NumEmp; ContEmp++)
38

{ // inicio
// ingresar sueldo
cout<<setw(2)<<ContEmp<<) Sueldo: ; cin>>Sueldo;
// determinar porcentaje de aumento

if ( Sueldo <= 200 )
{
Sueldo * = 1.25; // lo mismo que Sueldo=Sueldo*1.25, 25% mas

Np25++; // lo mismo que Np25=Np25+1
}
else
if ( Sueldo <= 350 )
{
Sueldo * = 1.20;
Np20++;
}
else
if ( Sueldo<=500)
{
Sueldo * = 1.15;
Np15++;
}
else
{
Sueldo *=1.10;
Np10++;
}
// Acumular monto
Monto + = Sueldo; // lo mismo que Monto = Monto + Sueldo
} // for
cout<<endl<<setiosflags( ios::fixed | ios::showpoint );
cout<<Nmero de personas que recibe 10% de aumento
<<setw(4)<<Np10<<endl
<<Nmero de personas que recibe 15% de aumento
<<setw(4)<<Np25<<endl;
39

getch();
} // fin
OBSERVACIONES: La evaluacin de los sueldos NO PUEDE hacerse con una estructura switch debido a
que el SUELDO no necesariamente es entero, por lo general es float (real). Recuerde que la estructura switch
no funciona para valores reales ni cadena ( es decir el valor del Selector ).
Tambin hay expresiones que simplifican en C++. Ejemplos.
-
Suma++
es equivalente a
Suma * = y
Sum=Suma+1
es equivalente a
Suma = Suma * y
40

3.
DIAGRAMA DE FLUJO.
Inicio
Np10=0; Np15=0
Np20=0; Np25=0
Monto=0
ContEmp = 1, NumEmp; 1
Sueldo
Sueldo <=500
Sueldo = Sueldo * 1.10
Np10 = Np10 +1
Sueldo <= 350
Sueldo <= 200
Sueldo = Sueldo * 1..02
Np25 = Np25 +1
Np20 = Np20 +1
Np15 = Np15 +1
Monto = Monto + Sueldo
Np10,Np15
Np20, Np25,Monto
fin
41

Libro1 PDF

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Libro1 PDF

Transféré par

Droits d'auteur :

Formats disponibles

Universidad Nacional de Moquegua

Curso: Algoritmos y Estructura de Datos

Escuela Profesional de Ing. de Sistemas e Informtica

ara desarrollar un programa no implica, necesariamente, sentarse frente al computador y codificarlo en

ETAPAS PARA LA SOLUCION DE UN PROBLEMA

MSc. Ing. Euler Tito Chura

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

SIMBOLOS GRAFICOS PARA DISEAR DIAGRAMAS DE FLUJO

Entrada/Ingreso de datos por teclado.

MSc. Ing. Euler Tito Chura

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

Entrada de datos por teclado:

cout<< El valor de N es: <<N;

OBSERVACION: Algunos autores acostumbran usar el Paralelogramo para la Entrada/Salida de datos.

LENGUAJE DE PROGRAMACION C++

TIPOS DE DATOS BASICOS EN C++

Cdigos ASCII entre -128 a 127

MSc. Ing. Euler Tito Chura

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

// es lo mismo que Var=Var+1;

Del operador de decremento (--):

// es lo mismo que Var=Var-1;

Del operador de asignacin compleja (+=):

Similar interpretacin es para los otros casos.

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

VERDADERO Y FALSO EN C++

MSc. Ing. Euler Tito Chura

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

Entradas: Nmero entero (N)

DIAGRAMA DE FLUJO Y CODIFICACION:

// para usar clrscr(), getch()

MSc. Ing. Euler Tito Chura

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

DIAGRAMA DE FLUJO Y CODIFICACIN:

// para clrscr(), getch()

Capital, Tasa, NumPer

clrscr(); cout<< Ingrese capital : ; cin>> Capital;

cout<< Nmero de perodos : ; cin>> NumPer;

Interes = Monto Capital // Calcular valor de los intereses

cout<< Intereses ganados :<< Interes; // Escribir resultado

MSc. Ing. Euler Tito Chura

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

PROCESO CONDICIONAL SIMPLE (if - else)

b.) SI ENTONCES - SINO

condicin es verdad ENTONCES

condicin es verdad ENTONCES

MSc. Ing. Euler Tito Chura

Universidad Nacional de Moquegua

Escuela Profesional de Ing. de Sistemas e Informtica

DIAGRAMA DE FLUJO Y CODIFICACION:

float Consumo, Dscto, Impuesto, Importe;

Impuesto = (Consumo - Dscto) *0.15

clrscr(); // borrar pantalla

Importe = Consumo - Dscto + Impuesto

// calcular monto de impuesto