2da. Sesión Practica PyC 2019 - I

Programación y computación
Tema 3:
Programación Estructurada:
Estructuras de control secuencial y selectiva
Profesor
John Ledgard Trujillo Trejo
Facultad de Ingeniería de Sistemas e Informática

Departamento de Ciencias de la Computación
2019-I
Programación Estructurada
 En un inicio, la programación estructurada

fue desarrollada en sus principios por Edsgar
W. Dijkstra (de la Universidad de Hainover)
en sus Notes on Structured Programming y
se basa en el denominado Teorema de la
Estructura desarrollado en 1966 por Bömh y
Jacopini, que se ratificó con los trabajos de
Charlan D. Mills.
 Un famoso teorema, demostrado por
Edsger Dijkstra (1930-2002) en los
años sesenta, demuestra que todo
programa puede escribirse utilizando
únicamente las tres instrucciones de
control siguientes: Secuencial, selectiva y
Iterativo (bucle)

10 de mayo de 2019 1.1
 La programación estructurada es un caso especial de la

programación modular. El diseño de un programa estructurado
se realiza construyendo bloques tan pequeños que puedan ser
codificados fácilmente y esto se logra hasta que se alcanza el
nivel de módulos atómicos, es decir, sentencias individuales
(si-entonces, mientras-hacer, repetir-hasta que, etc).
 La Programación Estructurada está enfocada a las estructuras de control
de un programa. Su técnica primaria consiste en la eliminación del salto
incondicional y su reemplazo por sentencias bien estructuradas de
bifurcación y control.
 Los programas estructurados utilizan sólo estas tres instrucciones de
control básicas o sus variantes, pero no se usa la instrucción de
bifurcación incondicional GOTO
 Los programas que usan GOTO se vuelven inentendibles e indepurables.
Hace que el programa “salte” para cualquier lado sin ningún control ni
sentido lógico.
 El sistema operativo DOS la usa porque no es un lenguaje de
programación. Contiene pocas órdenes de programación muy precarias

10 de mayo de 2019 1.2
 Las características de la programación estructurada son:

 Se basa en el teorema de la estructura.
 Fácil de leer y comprender.
 Fácil de codificar en una amplia gama de lenguajes y en
diferentes sistemas.
 Fácil de mantener.
 Eficiente, aprovechando al máximo los recursos de la
computadora.
 Modularizable.

10 de mayo de 2019 1.3
Teorema de la Estructura
Diagrama Propio. Es aquel que posee un solo punto de

entrada y uno de salida.
 Programa Propio. Es aquel

programa que cumple las
siguientes condiciones:
 Posee un solo inicio y un solo fin.
 Todo elemento del programa es
accesible, es decir, existe al menos un
camino desde el inicio al fin que pasa a
través de él.
 No posee bucles infinitos.
10 de mayo de 2019 1.4
Teorema de la Estructura
Teorema de la Estructura. Todo programa propio, realice el

trabajo que realice, tiene siempre al menos un diagrama
propio equivalente que sólo utiliza las estructuras básicas
de la programación, que son: La secuencia, la selección, y
la repetición.

10 de mayo de 2019 1.5
Estructura de control secuencial
 Es una estructura con una entrada y una salida en la cual

figuran una serie de acciones cuya ejecución es lineal y en el
orden en que aparecen. A su vez. Todas las acciones tienen
una única entrada y una única salida

10 de mayo de 2019 1.6
Estructura de control Selectiva
 Estructura de Selección o Alternativa. Es una estructura

con una sola entrada y una sola salida en la cual se realiza
una acción de entre varias, según una condición o se realiza
una acción según el cumplimiento o no de una determinada
condición.

10 de mayo de 2019 1.7
 Condicional Simple: Determina la acción a tomar si se

cumple una condición.

10 de mayo de 2019 1.8

10 de mayo de 2019 1.9
 Estructura condicional doble : Es aquel que determina la

acción a tomar entre dos condiciones.

10 de mayo de 2019 1.10

10 de mayo de 2019 1.11
 Estructura condicional Anidada: Es aquel que determina la

acción a tomar entre más de dos condiciones

10 de mayo de 2019 1.12
 Estructura condicional Multiple: Es aquel que determina la

acción a tomar entre varias condiciones. Esta estructura
evalua una expresión que puede tomar n valores distintos, 1,
2, 3, ..., n. Según que elija uno de estos valores en la
condición, se realizará una de las n acciones.

10 de mayo de 2019 1.13
true
case a case a action(s) break
false
true
case b case b action(s) break
false
.
.
.
true
case z case z action(s) break
false
default action(s)

10 de mayo de 2019 1.14
Problema 1
Pepe salió a celebrar su cumpleaños con un grupo de amigos y decidieron ir a comer a un
restaurante. Ellos acostumbran pagar la cuenta por partes iguales, es decir, cada uno paga lo
mismo. Sin embargo, la cuenta incluye el consumo de todos los comensales, y no considera el IGV
(19 %) ni la propina. Pepe y su grupo de amigos acostumbran dejar un 10 % como propina. El
problema es que no saben cuánto debe pagar cada uno.
Cada algoritmo empieza por el nombre del
ENTRADA: consumo, nump algoritmo: Algoritmo Nombre_Algoritmo
SALIDA: montoporp
Algoritmo Pago_Consumo
INTERMEDIOS : montoigv, propina, montot
cons
igv  0.19
porprop  0.1
var
real: consumo
real: nump
real: montoporp, montoigv, propina, motot
inicio
escribir (“Ingrese el numero de personas: ”)
leer(nump)
escribir (“Ingrese el consumo: ”)
leer (consumo)
montoigv  igv*consumo
propina  porprop*consumo
montot  consumo + montoigv + propina
montoporp  montot/nump
escribir (“El monto total a pagar es: ”, montot)
escribir (“El monto por persona es: “, montoporp)
fin10 de mayo de 2019
Problema 1
ENTRADA: consumo, nump

SALIDA: montoporp
cons
igv  0.19
Se escribe la palabra reservada cons para definer las porprop  0.1
constants del algoritmo. var
real: consumo
real: nump
inicio
leer(nump)
leer (consumo)
montoigv  0.19*consumo
propina  01*consumo
escribir
John Ledgard(“El monto
Trujillo Trejopor persona es: “, montoporp)
Problema 1

SALIDA: montoporp
cons
igv  0.19
porprop  0.1
var
real: consumo
Se escribe la palabra reservada var para definer las real: nump
variables del algoritmo. real: montoporp, montoigv, propina, motot
inicio
leer(nump)
leer (consumo)
escribir
Problema 1

SALIDA: montoporp
cons
igv  0.19
porprop  0.1
var
Se usa inicio para empezar a escribir las real: consumo
instrucciones del algoritmo.
real: nump
inicio
leer(nump)
leer (consumo)
escribir
Problema 1

SALIDA: montoporp
cons
igv  0.19
porprop  0.1
var
real: consumo
Se usa escribir() para mostrar en pantalla lo que esta real: nump
en parenthesis, si es una cadena tiene que estar entre
comillas real: montoporp, montoigv, propina, motot
inicio
leer(nump)
leer (consumo)
escribir
Problema 1

SALIDA: montoporp
cons
igv  0.19
porprop  0.1
var
real: consumo
real: nump
Se usa leer() para ingresar los datos. Los datos real: montoporp, montoigv, propina, motot
ingresados se le asigna a la variable indicada.
inicio
leer(nump)
leer (consumo)
escribir
Problema 1
ENTRADA: consumo, nump Algoritmo Pago_Consumo

SALIDA: montoporp
INTERMEDIOS : montoigv, propina, montot cons
igv  0.19
porprop  0.1
var
real: consumo
real: nump
inicio
leer(nump)
Se usa “” para asignar valores a las variables y escribir (“Ingrese el consumo: ”)
constantes leer (consumo)
escribir (“El monto por persona es: “, montoporp)
fin Ledgard Trujillo Trejo
John
10 de mayo de 2019
Problema 1

SALIDA: montoporp
cons
igv  0.19
porprop  0.1
var
real: consumo
real: nump
inicio
leer(nump)
leer (consumo)
Se usa fin para finalizar el algoritmo.
escribir
Problema 1
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
float igv = 0.19, porprop = 0.1;
SALIDA: montoporp
float consumo;
float nump;
float montoporp, montoigv, propina, montot;
cout<<"Ingrese el numero de personas: ";

cin>>nump;
cout<<"Ingrese el consumo: ";
cin>>consumo;
montoigv = igv*consumo;
propina = porprop*consumo;
montot = consumo + montoigv + propina;
montoporp = montot/nump;
cout<<"El monto por IGV es: "<<montoigv<<endl;
cout<<"El monto por propina es: "<<propina<<endl;
cout<<"El monto total a pagar es: "<<montot<<endl;
cout<<"El monto por persona es: "<<montoporp;
getch();
return 0;
}

10 de mayo de 2019
Problema 2
Un alumno quiere calcular la nota final que obtuvo en Cálculo. Se sabe que en el curso se tomaron
tres pruebas, la primera de ellas con un valor de 20 % de la nota final, mientras que las otras dos
tienen un valor de 30 % cada una. Además, la nota obtenida en controles y tareas tiene un peso de
20 %. Elabore una solución algorítmica que ayude a este alumno a resolver su problema.
ENTRADA: exa1, exa2, exa3, control Algoritmo Promedio_Final_Calculo

SALIDA: nota_final var
real: exa1, exa2, exa3, control
real: nota_final
inicio
escribir (“Ingrese primer examen: ”)
leer(exa1)
escribir (“Ingrese segundo examen: ”)
leer(exa2)
escribir (“Ingrese tercer examen: ”)
leer(exa3)
escribir (“Ingrese nota controles y tareas: ”)
leer (control)
nta_final  0.2*exa1+0.3*exa2+0.3*exa3+0.2*control
escribir (“La nota final es: ”, nota_final)
fin

10 de mayo de 2019
Problema 3
El ejército está experimentando con un nuevo tipo de proyectil para determinar el alcance que
consigue. Para esto, lleva a cabo pruebas en el desierto y registra en un mapa cartesiano las
coordenadas desde donde lanza el proyectil y donde cae a tierra. Estas coordenadas están dadas
como pares ordenados de números enteros positivos que representan metros. Ayude al ejército a
contar con un algoritmo que le permita determinar la distancia recorrida por el proyectil en un
lanzamiento.
Algoritmo distancia_proyectilvar
var
ENTRADA: coox1, cooy1, coox2, cooy2 real: coox1, cooy1, coox2, cooy2
SALIDA: distancia real: distancia
inicio
escribir (“Ingrese X de coordenada 1: ”)
leer(coox1)
escribir (“Ingrese Y de coordenada 1: ”)
leer(cooy1)
escribir (“Ingrese X de coordenada 2: ”)
leer(coox2)
escribir (“Ingrese Y de coordenada 2: ”)
leer(cooy2)
distancia  ((coox1-coox2)^2+(cooy1-cooy2)^2)^0.5
escribir (“La distancia recorrida es: ”, distancia)
fin

10 de mayo de 2019
Problema 4
Una empresa constructora vende terrenos con la forma A de la figura. Realice un algoritmo para
obtener el área respectiva de un terreno de medidas de cualquier valor.
Algoritmo área_terreno
real: A, B, C
real: area
inicio
escribir (“Ingrese valor de A: ”)
leer(A)
escribir (“Ingrese valor de B: ”)
ENTRADA: A, B, C leer(B)
SALIDA: area escribir (“Ingrese valor de C: ”)
leer(C)
area  (A-C)*B/2 + C*B
escribir (“El área del terreno es: ”, area)
fin

10 de mayo de 2019
Problema 5
Todas las semanas se estudia la posible variación en el precio de la bencina. Para ello, se utiliza un polinomio de
tercer grado, de la forma:
en donde x es un factor que determina semanalmente el Ministerio de Economía. Cuando el valor del polinomio es
mayor que 10, esa semana la bencina sube, en un factor igual al valor obtenido. Cuando el valor del polinomio es
menor que −10, el valor de la bencina baja en un factor igual al valor absoluto del valor obtenido para el polinomio.
Cuando el valor se encuentra en el intervalo [−10; 10], el precio no cambia en esa semana. Nos interesa contar con
un algoritmo que evalué el precio de la bencina para una semana particular, e indique no sólo si sube, baja, o se
queda igual, sino también en cuánto sube. Por ejemplo, si el valor del polinomio resultara ser -15, entonces el precio
de la bencina para la semana siguiente bajaría en un 15
Algoritmo precio_bencina
var
real: x
real: p
inicio
ENTRADA: x
SALIDA: escribir (“Ingrese valor de x: ”)
INTERMEDIOS : p p  x^3-2*x^2+3*x-5
si (p<-10) entonces
escribir (“El valor de la bencina baja: ”, -p)
sino
si ((p>=-10) y (p<=10)) entonces
escribir (“El valor de la bencina se mantiene”)
sino
escribir (“El valor de la bencina sube: ”, p)
fin_si
fin_si
fin
10 de mayo de 2019
Problema 6
Algoritmo Ecuacion_segundo_grado
var
Calcular las posibles raíces para real: coe1, coe2, coe3
una ecuación de segundo grado: real : raiz1, raiz2, dis
ax2+bx+c=0 inicio
escribir (“Ingrese los coeficientes :”,)
leer (coe1, coe2, coe3)
si (coe1 = 0) entonces
escribir (“La ecuación dada no es de 2do. Grado”)
sino
dis  coe2*coe2 – 4*coe1*coe3
ENTRADA: coe1, coe2, coe3 si (dis > 0) entonces
SALIDA: raiz1, raiz2 raiz1 (-coe2 – raiz(disc))/2*coe1
INTERMEDIOS : disc raiz2  (-coe2 + raiz(disc))/2*coe1
escribir (“Las raices de la ecuación son: “, raiz1, raiz2)
sino si (dis = 0) entonces
raiz1  -coe2/2*coe1
raiz2  raiz1
escribir (“Las raices de la ecuación son:”, raiz1, raiz2)
sino escribir (“No existen raíces reales”)
fin_si
fin_si
fin_si
fin

10 de mayo de 2019
Problema 6
/***********************************************************
Universidad Nacional Mayor de San Marcos
Facultad de Ingenieria de Sistemas e Informatica
Laboratorio de Algoritmica I
***********************************************************
Nombre de archivo : C:\ecuasg.CPP
Fecha de Creación : 9/05/01
Hora de Creación : 12:03:24 PM Comentarios
Descripción : Solucion a la ecuacion de segundo grado
Escrita entre /* y */ :
Autor : Ing. John Ledgard Trujillo Trejo comentario varias lineas.
Copyright : Unmsm - 2001 Despues de //: comentario de una
*/ línea
//Inclusion de librerias Mejora la legibilidad del programa..
#include <conio.h>
#include <iostream.h>
#include <math.h>
int main()
{
float coe1, coe2, coe3;
float raiz1, raiz2, dis;

10 de mayo de 2019 1.29
Problema 6
/***********************************************************
***********************************************************
Hora de Creación : 12:03:24 PM
Autor : Ing. John Ledgard Trujillo Trejo
Copyright : Unmsm - 2001
*/ Directiva de preprocesador
//Inclusion de librerias Mensage para el preprocesador del compilador C++.
#include <conio.h> Se empieza a escribir con #.
#include <iostream.h> #include <iostream.h> incluye operaciones de
#include <math.h> input/output (como escribir en la pantalla).
int main()
{

10 de mayo de 2019 1.30
Problema 6
/***********************************************************
***********************************************************
*/
//Inclusion de librerias
#include <conio.h> Programas en C++ contienen una o más funciones, uno de ellos es
el principal: main
Son usados parentesis para indicar una función
#include <math.h> int indica que main "retorna" un valor entero.
int main()
{

10 de mayo de 2019 1.31
Problema 6
/***********************************************************
***********************************************************
*/
#include <conio.h>
#include <math.h>
int main()
{
Una llave abierta { empieza el cuerpo de la función y una
float coe1, coe2, coe3; llave cerrada } el final.

10 de mayo de 2019 1.32
Problema 6
/***********************************************************
***********************************************************
*/
#include <conio.h>
#include <math.h>
int main()
{
Declaración de variables.

10 de mayo de 2019 1.33
Problema 6
clrscr();
cout<<"Ingrese el valor de los coeficientes: ";
cin>>coe1;
cin>>coe2; cout imprime un string de caracteres contenidos entre “ y ”.
Imprime el valor de una variable y constante. << operador de flujo de
cin>>coe3;
salida.
if (coe1==0)
{ cin ingresar valores por el teclado. >> operador de flujo de entrada.
cout<<"La ecuacion dada no es de segundo grado";
}
else
{
dis = coe2*coe2-4*coe1*coe3;
cout<<"Discriminante="<<dis<<endl;
if (dis>0)
{
raiz1 = (-coe2+sqrt(dis))/2*coe1;
raiz2 = (-coe2-sqrt(dis))/2*coe1;
cout<<"Las raices de la ecuacion son:" ;
cout<<raiz1<<“ y “<<raiz2<<endl;
}

10 de mayo de 2019 1.34
Problema 6
else
if (dis==0)
{
raiz1=-coe2/2*coe1;
raiz2=raiz1;
cout<<"Las raices de la ecuacion son:";
cout<<raiz1<<“ y “<<raiz2<<endl;
}
else
{
cout<<"No existe solucion en los reales";
};
};
getch();
}

10 de mayo de 2019
Problema 7
Hacer un algoritmo que pida ingresar las coordenadas de un punto (x, y) e ubique
su posición en el plano cartesiano y su distancia al origen (0, 0).
DATOS DE ENTRADA: coorx, coory

DATOS DE SALIDA: distancia
Algoritmo ubicación_punto
var
real : coorx, coory, distancia
inicio
escribir ("Ingresar la coordenada x: ")
leer (coorx)
escribir ("Ingresar la coordenada y: "
leer (coory)
si (coorx>0 y coory>0) entonces
escribir ("El punto (", coorx, ", " coory, “) pertenece al I cuadrante")
fin_si
si (coorx<0 y coory>0) entonces
escribir ("El punto ", coorx, ", ", coory, ") pertenece al II cuadrante”)
fin_si

10 de mayo de 2019
Problema 7
si (coorx<0 y coory<0) entonces
escribir ("El punto (", coorx, ", ", coory, ") pertenece al III cuadrante”)
fin_si
si (coorx>0 y coory<0) entonces
escribir ("El punto (", coorx, ", ", coory, ") pertenece al IV cuadrante")
fin_si
si (coorx>0 y coory=0) entonces
escribir ("El punto (", coorx, ", ", coory, ") esta en la abcisa X (positiva)")
fin_si
si (coorx<0 y coory=0) entonces
escribir ("El punto (", coorx, ", ", coory, ") esta en la abcisa X (negativa)")
fin_si
si (coorx=0 y coory>0) entonces
escribir ("El punto (", coorx, ", ", coory, ") esta en la ordenada Y (positiva)")
fin_si
si (coorx=0 y coory<0) entonces
escribir ("El punto (", coorx, ", ", coory, ") esta en la ordenada Y (negativa)")
fin_si
// Calculo de la distancia del punto al origen
distancia  sqrt(coorx*coorx + coory*coory)
escribir ("La distancia desde el origen (0, 0) al punto ingresado es: ", distancia)
fin

10 de mayo de 2019
Problema 7
#include <conio.h>
#include <math.h>
void main() // Programa Principal
{
float coorx, coory, distancia; //coordenadas x e y.
cout << "Ingresar la coordenada x: ";cin>>coorx; //pide coordenada x
cout << "Ingresar la coordenada y: ";cin>>coory; //pide coordenada y
clrscr();
if (coorx>0 && coory>0)
cout << "El punto ("<<coorx<<", "<<coory<<") pertenece al I cuadrante\n";
if (coorx<0 && coory>0)
cout << "El punto ("<<coorx<<", "<<coory<<") pertenece al II cuadrante\n";
if (coorx<0 && coory<0)
cout << "El punto ("<<coorx<<", "<<coory<<") pertenece al III cuadrante\n";
if (coorx>0 && coory<0)
cout << "El punto ("<<coorx<<", "<<coory<<") pertenece al IV cuadrante\n";

10 de mayo de 2019
Problema 7
if (coorx>0 && coory==0)

cout << "El punto ("<<coorx<<", "<<coory<<") esta en la abcisa X (positiva)\n";
if (coorx<0 && coory==0)
cout << "El punto ("<<coorx<<", "<<coory<<") esta en la abcisa X (negativa)\n";
if (coorx==0 && coory>0)
cout << "El punto ("<<coorx<<", "<<coory<<") esta en la ordenada Y (positiva)\n";
if (coorx==0 && coory<0)
cout << "El punto ("<<coorx<<", "<<coory<<") esta en la ordenada Y (negativa)\n";
// Calculo de la distancia del punto al origen

distancia = sqrt(pow(coorx,2) + pow(coory, 2));
cout << "La distancia desde el origen (0, 0) al punto ingresado es: "<<distancia;
getch();
}

10 de mayo de 2019
Problema 8
Con objeto de fomentar el ahorro energético, el recibo de la

electricidad se elabora de forma que el precio de cada Kwh
(kilowatio/hora) consumido es más caro cuanto más se consume:
• 100 Ptas de gastos fijos.
• 50 Ptas/Kwh para los primeros 100 Kwh.
• 70 Ptas/Kwh para los siguientes 150 Kwh (de 101 a 250).
• 100 Ptas/Kwh para el resto.
Elabore un algoritmo y programa que lea de teclado los dos últimos
valores del contador (lo que marca el contador actualmente y lo que
marcaba en la última lectura), y calcule e imprima en pantalla el
importe total a pagar.
DATOS DE ENTRADA : C1, C2

DATOS DE SALIDA: recibo

10 de mayo de 2019 1.40
Problema 8
Algoritmo recibo_de_consumo
real: C1, C2, recibo
inicio
escribir ("Escribe el valor del contador anterior al último: ")
leer (C1)
escribir ("Escribe el último valor del contador: ")
leer (C2)
si (C1 > C2) entonces
escribir ("ERROR: El último valor es menor que el anterior.")
sino
C1  C2 - C1
si (C1 <= 100) entonces
recibo  100 + 50*C1;
sino si (C1<=250) entonces
recibo  5100 + 70*(C1 - 100)
sino
recibo  5100 + 70*150 + 100*(C1 - 250)
fin_si
escribir ("El valor del recibo es: ", recibo)
fin_si
fin_si
fin

10 de mayo de 2019 1.41
Problema 8
#include <stdio.h>
#include <conio.h>
void main() {
float C1,C2, recibo;
printf("Escribe el valor del contador anterior al último: ");
scanf("%f", &C1);
printf("Escribe el último valor del contador: ");
scanf("%f", &C2);
if (C1>C2)
printf("ERROR: El último valor es menor que el anterior.");
else {
C1=C2-C1;
if (C1<=100)
recibo=100 + 50*C1;
else if (C1<=250)
recibo= 5100 + 70*(C1-100);
else
recibo= 5100 + 70*150 + 100*(C1-250);
printf("El valor del recibo es: %f.\n", recibo);
}
getch();
}

10 de mayo de 2019 1.42
Problema 9
Calcular la cuenta de un cliente para un pedido de cierta cantidad de

unidades de un producto. Suponemos que solo se dispone de cuatro
productos. Entre ellos:
Número de producto Precio Unitario
100 24.50
247 105.00
16 10.35
240 16.00
Se puede hacer un descuento en un pedido grande: si la cuenta total es
de s/.1000.00 o más, se hace un descuento del 2%; de s/.800.00 a
s/.999.99 obtiene un descuento del 1%.
DATOS DE ENTRADA: Código del producto (CP), Cantidad (Cant).

DATOS DE SALIDA: Costo tota (CT), descuento (Desc), Monto neto (MonN)

10 de mayo de 2019 1.43
Problema 9
Algoritmo CUENTA
Var
Entero: CP
Real : PU, Cant, CT, MonN, Des
Const
D1 = 0.02 //Porcentaje de descuento 1
D2 = 0.01 // Porcentaje de descuento 2
Inicio
leer CP, Cant
si CP=100 entonces
PU  24.05
sino
si CP=247 entonces
PU  105.00
sino
si CP=16 entonces
PU  10.35
Sino
PU  16.00
fin_si
fin_si
fin_si

10 de mayo de 2019
Problema 9
CT  PU * Cant
si CT  1000 entonces
Desc  CT *D1
sino
si CT  800 entonces
Desc  CT*D2
Sino Desc  0
fin_si
fin_si
MonN  CT – Desc
escribir(CT, Desc, MonN)
fin

10 de mayo de 2019
Problema 9
#include <constrea.h>
main()
{
int CP;
float PU, Cant, CT, MonN, Desc;
const float D1=0.02, D2 = 0.0;
cout<<"Ingrese el codigo del producto y la cantidad: ";
cin>>CP>>Cant;
if (CP==100) PU=24.05;
else if (CP==247) PU=105.00;
else if (CP==16) PU=10.35;
else PU=16.00;
CT = PU * Cant;
if (CT>=1000) Desc=CT*D1;
else if (CT>=800) Desc = CT*D2;
else Desc=0;
MonN = CT - Desc;
cout<<CT<<endl<<Desc<<endl<<MonN;
getch();
}

10 de mayo de 2019
Problema 11
Leer tres números diferentes e imprimir el numero mayor de los tres.
Algoritmo Número_mayor
Var
Real : num1, num2, num3
ENTRADA: num1, num2, num3 Real : mayor
SALIDA: mayor Inicio
leer (num1, num2, num3)
si (num1 > num2) and (num1 > num3) entonces
mayor  num1
sino
si (num2 > num1) and (num2 > num3) entonces
mayor  num2
sino
mayor  num3
fin-si
fin-si
escribir (“El número mayor es :”, mayor)
Fin

10 de mayo de 2019
Bibliografía
 Fundamentos de programación, Algoritmos y Estructura de datos

y Objetos, Joyanes, Luis, Editorial McGraw Hill, 2003.
 Metodología de la programación estructurada, Joyanes, Luis,

Editorial McGraw Hill, 1993.
 El lenguaje de programación C, Kernighan y Ritchie, Editorial

Prentice Hall, 1991.
 Como programar en C/C++ , H.M. Deitel and P.J. Deitel, Ed.

Prentice Hall, 1998, 6ta. edición
1.48
¿ Preguntas ?
1.49

2da. Sesión Practica PyC 2019 - I

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

2da. Sesión Practica PyC 2019 - I

Cargado por

Copyright:

Formatos disponibles

Programación y computación

Facultad de Ingeniería de Sistemas e Informática

 En un inicio, la programación estructurada

John Ledgard Trujillo Trejo

 La programación estructurada es un caso especial de la

John Ledgard Trujillo Trejo

 Las características de la programación estructurada son:

John Ledgard Trujillo Trejo

Diagrama Propio. Es aquel que posee un solo punto de

 Programa Propio. Es aquel

Teorema de la Estructura. Todo programa propio, realice el

John Ledgard Trujillo Trejo

 Es una estructura con una entrada y una salida en la cual

John Ledgard Trujillo Trejo

 Estructura de Selección o Alternativa. Es una estructura

John Ledgard Trujillo Trejo

 Condicional Simple: Determina la acción a tomar si se

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

 Estructura condicional doble : Es aquel que determina la

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

 Estructura condicional Anidada: Es aquel que determina la

John Ledgard Trujillo Trejo

 Estructura condicional Multiple: Es aquel que determina la

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

ENTRADA: consumo, nump

ENTRADA: consumo, nump

ENTRADA: consumo, nump

ENTRADA: consumo, nump

ENTRADA: consumo, nump

ENTRADA: consumo, nump Algoritmo Pago_Consumo

ENTRADA: consumo, nump

cout<<"Ingrese el numero de personas: ";

John Ledgard Trujillo Trejo

ENTRADA: exa1, exa2, exa3, control Algoritmo Promedio_Final_Calculo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

DATOS DE ENTRADA: coorx, coory

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

if (coorx>0 && coory==0)

// Calculo de la distancia del punto al origen

John Ledgard Trujillo Trejo

Con objeto de fomentar el ahorro energético, el recibo de la

DATOS DE ENTRADA : C1, C2

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

John Ledgard Trujillo Trejo

Calcular la cuenta de un cliente para un pedido de cierta cantidad de

DATOS DE ENTRADA: Código del producto (CP), Cantidad (Cant).

John Ledgard Trujillo Trejo