UNIVERSIDAD DE EL SALVADOR

FACULTAD DE INGENIERÍA Y ARQUITECTURA

ESCUELA DE INGENIERÍA INDUSTRIAL

LOGICA Y ALGORITMOS CICLO I 2020

LABORATORIO 2: “Guía práctica de estructuras selectivas”.

PROFESOR: Ing. EAV.

ALUMNO: Jonathan.

Ciudad Universitaria, 20 de abril de 2020

Contenido

INTRODUCCION.......................................................................................................4
OBJETIVOS...............................................................................................................5
Objetivos Generales...............................................................................................5
Objetivos Específicos.............................................................................................5
DESARROLLO..........................................................................................................6
1. Planteamiento del problema...............................................................................6
2. Análisis del problema..........................................................................................7
CONCLUSIONES......................................................................................................9
RECOMENDACIONES............................................................................................10
REFERENCIAS BIBLIOGRAFICAS........................................................................11
ANEXOS..................................................................................................................12
1. Diagrama de flujo..............................................................................................12
2. Código fuente...................................................................................................12
 INTRODUCCION

Las estructuras selectivas en la programación de algoritmos son de importancia ya

que simplifican valores lógicos de decisión, estas al simplificarse se pueden
determinar que operaciones aritméticas se deben realizar y que valor se le debe
asignar a la variable, esto lo vemos todos los días en la vida cotidiana, al momento
de encender el televisor y seleccionar que canal vamos a ingresar, que tipo de
programación vamos a escoger en el microondas y este tiene el tiempo ya
preconfigurado.

En este laboratorio consiste en la realización de un enunciado a una programación

lógica que consiste en estructuras selectivas, la programación “Mr pizza” se
necesita una programación donde se debe escoger distintas variables, en las que
se puede mencionar el tamaño de la pizza, el tipo de pago, acciones que
representen dependiendo de que cantidad puede aplicarse descuento y bajo que
condición. En este documento se iniciará desde la identificación de variables de
entrada y salida para ello se aplicara el método de la caja negra, luego se utilizará
el lenguaje de narración para determinar como esas variables de entrada y salida
van estar relacionada dentro de un proceso y la identificación de restricciones.
Posteriormente se realizará el seudocódigo en c++ para su ejecución.
 OBJETIVOS

Objetivos Generales

Aplicar el método de la caja negra para la determinación de variables de entrada y

salida.
Aplicar la programación de algoritmo narrado para comprender el proceso y
restricciones deben aplicarse
Utilizar la programación de seudocódigo para la ejecución del programa.

Objetivos Específicos

Aplicar la programación de algoritmo narrada para comprender las ecuaciones de

aritmética a utilizar para la asignación de variables.

Utilizar las estructuras de control y las estructuras selectivas para la asignación de

valores reales a las variables.

Utilizar la programación de pseudocodigo en Dev C++ para la ejecución correcta

del programa.

Utilizar estructuras repetitivas para la en la programación de seudocódigo en Dev

C++ para la comprobación rápida del proceso de selección durante la ejecución.
 DESARROLLO

1. Planteamiento del problema

Enunciado:
“Mr. Pizza” ofrece Pizzas Pequeñas, Medianas y Gigantes, las cuales tienen un
costo de $10.00, $15.00 y $20.00 respectivamente. La Pizzería acepta 2 tipos de
pago, en efectivo ó tarjeta, pero si paga con tarjeta de crédito tendrá un cargo
extra de 3% sobre la compra total. Suponiendo que los clientes adquieren sólo un
tipo de pizza hay promoción por compras superiores a 5 pizzas se les da un
descuento de 15% y superiores a 10 un descuento de 20% al total de la compra,
pero esta promoción solo aplica a los clientes que hacen su pago en efectivo,
realice un algoritmo para determinar cuánto debe pagar una persona por N pizzas
y el descuento que se le aplico a la compra.

Para ello se determinan las entradas y salidas y el proceso en general por medio
de la caja negra.

Entradas
Tamaño de la pizza
Cantidad de la pizza
Salida
Operaciones Aritméticas
Total a pagar
Valores constantes asignados a
variables (descuentos y recargos)

Tipo de pago Restricciones

Condicionales, estructuras
selectivas, estructuras de control,
estructuras repetitivas, banderas
lógicas.
2. Análisis del problema.

a. Definición de las variables de salida

Nombre Tipo Descripción
Total_1 Real Representa el total sin ningún descuento
Total_2 Real Representa el total en efectivo o en
tarjeta, resultado de una operación
previamente
promo Real Representa el descuento, bajo ciertas
condiciones

b. Definición de las variables de entrada

Nombre Tipo Descripción
T_pizza Entero Representara las opciones del tamaño de
la pizza
Dinero Entero Representa la forma de pago, si es en
efectivo o en tarjeta
cantidad Entero Representa la cantidad de pizzas
k_pizza Real Representa el valor adquirido por alguna
constante durante el proceso

Constantes
Los valores de cada tamaño de pizza, pizza grande ($20.00), pizza mediana
($15.00) y pizza pequeña ($10.00).
Los valores del 15% y 20% ambas serán constantes.
El valor del cargo del 3% al cancelar en tarjeta, será una constante.

c. Restricciones
Los valores de T_pizza solo podrán ser del 1 al 4,indicando 4 como cierre o
finalizar el ciclo repetitivo si no es dentro de esos valores deberá pedir
nuevamente los valores, no se aceptan números negativos o cero.
Los valores de Dinero solo pondrán ser 1 o 2, de lo contrario deberá pedir
nuevamente el valor, no se aceptan números negativos o cero.
Los valores de cantidad solo pueden ser positivos, de lo contrario deberá pedir
nuevamente el valor, no se aceptan números negativos o cero.

d. Proceso

Total_1=cantidad*k_pizza
Total_2=Total_1*promo

e. Definición de variables de proceso:

Para k_pizza es la variable que adquiere un valor de la constante, esto depende

del tamaño de la pizza, es decir, si la pizza que se escogió con T_pizza es grande
entonces k_pizza=20. Para ello el valor entero que se mostrara para tomar la
opción:
T_pizza=1 ; k_pizza=20 //Entendiendo que el valor 1 es para pizza grande.
T_pizza=2 ; k_pizza=20 //Entendiendo que el valor 2 es para pizza mediana.
T_pizza=3 ; k_pizza=20 //Entendiendo que el valor 3 es para pizza pequeña.
Adicionalmente al colocar el valor 4 este podrá salirse del programa:
T_pizza=4: cerrando programa
Si es otro valor entonces volverá a pedir que se coloque una opción valida.
Para el proceso inicial de Total_1 será la multiplicación del valor unitario de cada
pizza con la cantidad que necesitan.
Total_1=cantidad*k_pizza
Para el proceso de promo, se evalúa si compra mas de 5 o mas de 10 se aplica el
descuento correspondiente.
Si cantidad >5 y >=10 entonces promo = 0.15,
Si cantidad >10 entonces promo=0.2,
Para el proceso de Total_2 será la multiplicación del valor de Total_1 por promo,
sin importar si el valor de promo inicialmente está en cero.
Para salida de Total_1 dependerá de la opción de pago, adicionalmente de la
cantidad de pizzas que se compren, la condición es que Total_1 se paga con
tarjeta se actualice con la constante del 3%.

CONCLUSIONES

Al utilizar estructuras selectivas se puede notar la facilidad con respecto a las

condicionales ya que estas pueden evaluar solo un valor y realizar operaciones
conforme a este.

Al combinarlo con estructuras repetitivas se puede utilizar como si fuera un menú

en el que si no se ingresa una opción válida, puede volverse a evaluar en la
selección.
 RECOMENDACIONES

Se pueden utilizar banderas para el uso de condicionales y tener un dato que lo

valide una condicional.
Puede restringirse todo el programa a utilizar solo estructuras selectivas sin
ninguna condicional.
 REFERENCIAS BIBLIOGRAFICAS

Graham, N., LEARNING C++, McGraw Hill, 1992.

Schildt, H., C++: Guía de Autoenseñanza, McGraw-Hill, 2ª edición, 1995.
 ANEXOS

1. Diagrama de flujo

2. Código fuente

#include<stdio.h>
#include<conio.h>
#include<locale.h>
//Se incluyen las librerías necesarias
//Se definen las constantes
#define grande 20
#define mediana 15
#define pequena 10
#define card 0.03
#define promo_1 0.15
#define promo_2 0.2

int T_pizza=0, cantidad=0, dinero=0, flag=1, auxflag=1; //flag y auxflag, son

banderas para los ciclos repetitivos y condicionales
float porcentaje=0, Total_1=0.0, Total_2=0.0, k_pizza=0, promo=0.0;

main()
{
setlocale(LC_ALL, "Spanish");

while(T_pizza!=4){//ciclo repetitivo tal que si T_pizza es 4 se termina el

programa

puts("Buen día! Mr. Pizza te saluda\n\nIngrese el tipo de pizza que

necesita\n\n");
puts("1.Pizza Grande\n2.Pizza Mediana\n3.Pizza Pequeña\n4.Salir del
sistema\n");
scanf("%i", &T_pizza);

switch(T_pizza)
{
case 1:
while(cantidad<=0){

puts("Ingrese la cantidad de pizza grande que desea\n");

scanf("%i", &cantidad);
if(cantidad<0)
{
printf("Ha colocado un numero no valido\n\n");
 }
}
k_pizza=grande;
Total_1=k_pizza*cantidad;
break;

case 2:
while(cantidad<=0)
{

puts("Ingrese la cantidad de pizza mediana que desea\n");

scanf("%i", &cantidad);
if(cantidad<0)
{
printf("Ha colocado un numero no valido");

}
}
k_pizza=mediana;
Total_1=k_pizza*cantidad;
break;

case 3:
while(cantidad<=0){

puts("Ingrese la cantidad de pizza pequeña que

desea\n");
scanf("%i", &cantidad);
if(cantidad<0)
 {
printf("Ha colocado un numero negativo o un caracter, el programa
se reiniciará");

}
}
k_pizza=pequena;
Total_1=k_pizza*cantidad;
break;

case 4:
printf("El programa se cierra\n");
flag=0;
break;

default:
printf("No ha seleccionado ninguna opcion valida\n");
printf("---------------------------------------------------------\n\n");
flag=0;//bandera que indica que si se ha presionado 5 -1
o 0 en las siguientes condicionales se desactivaran
break;
}

if(cantidad>5&&cantidad<=10)
{
promo=promo_1;
Total_2=(Total_1-Total_1*promo);
printf("El monto a pagar es de $ %.2f",Total_1);
printf(", pero como te llevas mas de 5 pizzas te damos\nun 15%% de
descuento y te quedara a $ %.2f",Total_2);
 printf(" al pagar en efectivo");
}
else
{
if(cantidad>10)
{
promo=promo_2;
Total_2=(Total_1-Total_1*promo);
printf("El monto a pagar es de $ %.2f",Total_1);
printf(", pero como te llevas mas de 10 pizzas te damos\nun 20%% de
descuento y te quedara a $%.2f",Total_2);
printf(" al pagar en efectivo");
}
else
{
if(cantidad>=1&&cantidad<5)
{
printf("El monto a pagar es de $ %.2f",Total_1);
}
}

}
if(flag!=0){

while(auxflag!=0){

puts("\n\nIngrese el tipo de pago\n 1. En efectivo\n 2. En tarjeta\n\nNOTA: Al pagar

con tarjeta hay cargo adicional del 3%");
scanf("%i",&dinero);
if(dinero==1)
{
printf("\n\nUsted ha seleccionado cancelar en Efectivo\n\n");
auxflag=0;
}
else {
if(dinero==2)

{
printf("\n\nUsted ha seleccionado cancelar en Tarjeta\n\n");
auxflag=0;
}
else
{
if(dinero!=1&&dinero!=2)
printf("\n No es una opcion valida\n\n");

}
}

}
}

if(flag!=0)
{

printf("--------------------------------------------------------------\n");
printf("\n Cantidad de pizzas:\t\t %i",cantidad);
if(cantidad==1){
printf(" unidad");
}
else
{
if(cantidad>1)
printf(" unidades");
}
switch(T_pizza)
{
case 1:
if(cantidad==1)
{
printf(" de pizza grande");
}
else{
if(cantidad>1)
{

printf(" de pizzas grandes");

}
}
break;
case 2:
if(cantidad==1)
{
printf(" de pizza mediana");
 }
else{
if(cantidad>1)
{

printf(" de pizzas medianas");

}
}
break;

case 3:
if(cantidad==1)
{
printf(" de pizza pequeña");
}
else{
if(cantidad>1)
{

printf(" de pizzas pequeñas");

}
}
break;

printf("\n Precio unitario de cada pizza :\t $ %.2f",k_pizza);

printf("\n Precio de monto de las pizzas :\t $ %.2f",Total_1);
if(dinero==1){
if(cantidad>5){

printf("\n Descuento (%.2f",promo*100);

printf(" %%): \t $ -");
printf("%.2f",promo*Total_1);
printf("\n-------------------------------------------------------------------------\n");
printf("TOTAL: \t $ %.2f",Total_2);
}
else
{
if(cantidad<=5)
{
printf("\n-------------------------------------------------------------------------\n");
printf("TOTAL: \t $ %.2f",Total_1);
}
}
}
else{

if(dinero==2&&flag!=0)

{
printf("\n Descuento (0.00");
printf(" %%): \t $ ");
printf("%.2f",promo*Total_1*0);

printf("\n Recargo del 3%% : \t $ %.2f",Total_1*card);

Total_1=Total_1+Total_1*card;
printf("\n-------------------------------------------------------------------------\n");
printf("TOTAL: \t $ %.2f",Total_1);

}
}

flag=1;
auxflag=1;
cantidad=0;
Total_1=0;
Total_2=0;
printf("\n");
printf("................................................................................\n\n");
}

getch();
return 0;