UNIVERSIDAD DE EL SALVADOR

FACULTAD DE INGENIERÍA Y
ARQUITECTURA
ESCUELA DE INGENIERIA DE SISTEMAS
INFORMATICOS

TEMA:
Guía de ejercicios 2 sobre la "Guía práctica de estructura selectivas"

NOMBRE DE ESTUDIANTE:
Luis Salvador Barrera Garcia BG17016

ASIGNATURA:
Programación I

SEDE:
INFRAVEZ

GRUPO:
Santa Rosa de Lima Grupo 7

TUTOR:
Ing. Liliana Esmeralda González

CICLO/AÑO:
Ciclo II 2017

LUGAR Y FECHA
Santa Rosa de Lima 12/11/2017
 Programación I UES

Contenido
Introducción ....................................................................................................................................... A
Objetivos ............................................................................................................................................ 1
Objetivo general ............................................................................................................................ 1
Objetivos específicos ................................................................................................................... 1
Ejercicio 1 .......................................................................................................................................... 2
Planteamiento general del problema (Método de la caja negra). ......................................... 2
Análisis del problema ................................................................................................................... 2
1. Definición de variables de entrada. ............................................................................... 2
2. Definición de variables de salida. .................................................................................. 3
3. Restricciones ..................................................................................................................... 3
4. Proceso .................................................................................................................................. 3
5. Definición de variables de proceso ................................................................................... 5
Diseño de la solución ................................................................................................................... 5
Algoritmo narrado ..................................................................................................................... 5
Diagrama de flujo ..................................................................................................................... 8
Sintaxis en C# ............................................................................................................................... 9
Ejercicio 2 ........................................................................................................................................ 11
Planteamiento general del problema (Método de la caja negra). ....................................... 11
Análisis del problema ................................................................................................................. 11
1. Definición de variables de entrada. ............................................................................. 11
2. Definición de variables de salida. ................................................................................ 12
3. Restricciones ................................................................................................................... 12
4. Proceso ................................................................................................................................ 12
5. Definición de variables de proceso ................................................................................. 14
Diseño de la solución ................................................................................................................. 14
Algoritmo narrado ................................................................................................................... 14
Diagrama de flujo ................................................................................................................... 17
Sintaxis en C# ............................................................................................................................. 18
Conclusiones ................................................................................................................................... 20
Recomendaciones .......................................................................................................................... 21
Bibliografía ....................................................................................................................................... 22
Anexos ............................................................................................................................................. 23
 Programación I UES

Introducción

A continuación, se presentan dos ejercicios desarrollados en el lenguaje de

programación C#. Dichos ejercicios presentan su funcionamiento a través de las
estructuras de control selectivas.

Las estructuras de control selectivas nos sirven para los casos en los que el sistema
debe de tomar una decisión. Esta decisión es tomada a través de una determinada
condición (if else) o a través de la selección de un caso específico (switch case).

Las estructuras selectivas se clasifican de la siguiente forma:

• Estructuras selectivas simples

• Estructuras selectivas dobles
• Estructuras selectivas múltiples.

A continuación, observemos su funcionamiento a través de los siguientes ejemplos.

A
 Programación I UES

Objetivos

Objetivo general

Comprender la utilización de las estructuras selectivas simples, dobles y múltiples

para aplicar soluciones lógicas a la hora de desarrollar un programa mediante la
selección de diferentes casos.

Objetivos específicos

• Aprender la utilización de las estructuras selectivas en C#

• Solucionar problemas cotidianos sencillos mediante la programación aplicando
estructuras selectivas.
• Comprender el funcionamiento de las aplicaciones de tipo consola a la hora de
programar.
• Comprender el funcionamiento de las aplicaciones de tipo ventana a la hora de
programar.

1
 Programación I UES

Ejercicio 1

1. Construya la solución de consola en C# que lea el salario de una persona e

indique cuanto es el bono según la siguiente tabla.

Rango de salario Bono

Salario >=100 y Salario Calculo del 10% del
<=200 salario.
Salario >200y Salario Calculo del 20% del
<=300 salario.
Salario >300 Calculo del 30% del
salario.

Planteamiento general del problema (Método de la caja negra).

Entradas Proceso Salidas

Opción Evaluar opción ingresada Bono

Dato
Evaluar Dato ingresado
Salario
Evaluar salario

Calcular bono aplicable

Análisis del problema

1. Definición de variables de entrada.

Nombre Tipo Descripción
En ella se ingresa la opción
Opción Cadena (string)
seleccionada por el usuario.
En ella se guarda temporalmente el
Dato Cadena (string)
salario ingresado por el usuario
Punto flotante Almacena el salario ingresado por el
Salario
doble (doublé) usuario para su posterior utilización.

2
 Programación I UES

2. Definición de variables de salida.

Nombre Tipo Descripción
Punto flotante Contiene el bono calculado mediante el
Bono
doble (float) salario ingresado.

3. Restricciones
Restricciones del Menú.
El usuario deberá elegir una de las 2 opciones del menú de la aplicación. La selección
se hará mediante el ingreso del número que lo acompaña
1.- Calcular bono.
2.- Salir
El usuario deberá ingresar el número de la opción que desea realizar (1 o 2).
Si el usuario ingresa un valor diferente de 1 o 2 se mostrará el mensaje “Opción
invalida”
Toda la aplicación está dentro de un ciclo Hacer hasta. Esto nos permite reutilizar el
programa hasta que el usuario elija la opción Salir

Restricciones en Ingresar Salario

Si el salario ingresado no es de tipo numérico se mostrará el mensaje “Dato
incorrecto”.

4. Proceso
Al ejecutar la aplicación se le pedirá al usuario que ingrese un número que
corresponde a la selección de 2 opciones determinadas.
1.- Calcular bono.
2.- Salir
Todos los procesos de la aplicación están contenidos en un bucle Hacer hasta, que
se repetirá hasta ingresar el valor 2 en el menú principal que corresponde a la opción
salir.
Si el usuario ingresa un valor diferente de 1 o 2 se mostrará el mensaje “opción
invalida”

3
 Programación I UES

Proceso de Ingresar Salario

Al ingresar un salario se verificará que este sea de valor numérico, de lo contrario se
mostrará el mensaje: “Dato incorrecto”.

Si es un valor numérico se verificará que sea mayor o igual a 100 dólares (Salario >=
100), de lo contrario mostrará el mensaje: “Bono no aplicable para su salario de #.##”,
donde #.## será el valor del salario ingresado.

Si el salario es mayor o igual a 100 y menor o igual a 200 dólares (Salario >= 100 &&
Salario <= 200) se aplicará el 10% de bono mediante el siguiente proceso
Bono = Salario * 0.10

Luego se mostrará el siguiente mensaje: “El bono aplicado es del 10%. Su bono es:
##.##”, donde ##.## será el bono calculado.

Si el salario es mayor a 200 y menor o igual a 300 (Salario > 200 && Salario <= 300)
dólares se aplicará el 20% de bono mediante el siguiente proceso
Bono = Salario * 0.20

Luego se mostrará el siguiente mensaje: “El bono aplicado es del 20%. Su bono es:
##.##”, donde ##.## será el bono calculado.

Si el salario es mayor a 300 (Salario > 300) dólares se aplicará el 30% de bono
mediante el siguiente proceso
Bono = Salario * 0.30

Luego se mostrará el siguiente mensaje: “El bono aplicado es del 20%. Su bono es:
##.##”, donde ##.## será el bono calculado.

4
 Programación I UES

5. Definición de variables de proceso

Nombre Tipo Descripción
Punto flotante En ella se calcula el valor del bono
Bono
doble (float) aplicado.
Mediante ella se verifica que el usuario
Conversión Boleano (bool)
ingrese un valor numérico como salario.

Diseño de la solución

Algoritmo narrado

Proceso: Verificar_Calcular_Bono

{El programa nos permitirá calcular el bono de un empleado con respecto a su

salario. El bono es aplicado a las personas que posean un salario mayor o igual a
100 dólares, aplicando el 10% de bono a las personas que posean un salario mayor
o igual a 100 y menor o igual a 200, 20% a las personas que posean un salario
mayor a 200 y menor o igual a 300, y el 30% de bono a las personas que posean un
salario mayor a 300}

{Opción, Dato son variables de tipo string}

{Salario, Bono son variables de tipo doublé}
{Conversión es variable de tipo boleano}

1. Mientras Opción != '2' Hacer

a. Escribir 'Ingrese una de las siguientes opciones:
1_Calcular bono
2_Salir'
b. Leer Opción
c. Según Opción Hacer
I. Caso '1':

5
 Programación I UES

i. Escribir 'Ingrese su salario para calcular el

bono'
ii. Leer Dato
iii. Conversión = Convertir Dato a double Salario
iv. Si Conversión es verdadero Entonces
A. Si Salario>=100 Entonces
i. Si Salario<=200 Entonces
a. Bono = Salario*0.10
b. Escribir 'El bono aplicado es del
10%. Su bono es: ', Bono
ii. Sino
Si Salario>200 && Salario<=300 Entonces
a. Bono = Salario*0.20
b. Escribir "El bono aplicable es del
20%. Su bono es de: ", Bono
iii. Sino
Si Salario>300 Entonces
a. Bono = Salario*0.30
b. Escribir "El bono aplicable es del
30%. Su bono es: ",Bono
Fin Si
Fin Si
Fin Si
B. Sino
i. Escribir 'Bono no aplicable para su salario'
Fin Si
v. Sino
A. Escribir ‘Dato incorrecto’
Fin Si
II. Caso '2':

6
 Programación I UES

i. Escribir 'Saliendo de la aplicación'

III. De Otro Modo:
i. Escribir 'Opción invalida'
FinSegun
FinMientras
2. Fin

7
 Programación I UES

Diagrama de flujo

8
 Programación I UES

Sintaxis en C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Ejercicio1
{
class Program
{
static void Main(string[] args)
{
string Opción = null;

do
{
Console.Clear();
Console.WriteLine("-------------------Menu-------------------");
Console.WriteLine("Ingrese una de las siguientes opciones,");
Console.WriteLine("1_Calcular Bono.");
Console.WriteLine("2_Salir");
Opción = Console.ReadLine();

switch (Opción)
{
case "1":
{
double Salario, Bono;
string Dato;
bool Conversión;

Console.Clear();
Console.WriteLine("Ingrese su salario para calcular el
bono.");
Dato = Console.ReadLine();
Conversión = double.TryParse(Dato, out Salario);

if (Conversión)
{
if (Salario >= 100)
{
if (Salario <= 200)
{
Bono = Salario * 0.10;
Console.WriteLine("El bono aplicado es del
10%. Su bono es: {0:C}", Bono);
Console.WriteLine("Precione una tecla para
continuar.");
}

else if (Salario > 200 && Salario <= 300)

{
Bono = Salario * 0.20;
Console.WriteLine("El bono aplicado es del
20%. Su bono es: {0:C}", Bono);

9
 Programación I UES

Console.WriteLine("Precione una tecla para

continuar");
}

else if (Salario > 300)

{
Bono = Salario * 0.30;
Console.WriteLine("El bono aplicado es del
30%. Su bono es: {0:C}", Bono);
Console.WriteLine("Precione una tecla para
continuar.");
}
}

else
{
Console.WriteLine("Bono no aplicable para su
salario de {0:C}", Salario);
Console.WriteLine("Precione una tecla para
continuar.");
}

else
Console.WriteLine("Dato Incorrecto");

}
break;
case "2":
Console.WriteLine("Saliendo de la aplicación");
break;

default:
Console.WriteLine("Opción invalida");
break;
}
Console.ReadKey();
} while (Opción != "2");

}
}
}

10
 Programación I UES

Ejercicio 2

1. Construya una solución en C# al ingresar el valor de la temperatura, despliegue

el tipo de clima, según la siguiente tabla, realizarlo con Windows forms.

Temperatura Tipo de clima

Temperatura menor 10 “Frío”
Temperatura entre 10 y 20 “Nublado”
Temperatura entre 21 y 30 “Calor”
Temperatura mayor a 30 “Tropical”

Planteamiento general del problema (Método de la caja negra).

Entradas Proceso Salidas

Dato Clima
Temperatura Evaluar Dato ingresado
Temperatura
Evaluar Temperatura

Asignar clima

Análisis del problema

1. Definición de variables de entrada.

Nombre Tipo Descripción
En ella se guarda temporalmente la
Dato Cadena (string)
temperatura ingresada por el usuario
Punto flotante Almacena la temperatura en valor
Temperatura
(float) numérico

11
 Programación I UES

2. Definición de variables de salida.

Nombre Tipo Descripción
Contiene el tipo de clima determinado
Clima Cadena (string) mediante la verificación de la
temperatura.

3. Restricciones

Restricciones en Ingresar Temperatura

Si la temperatura ingresada no es de tipo numérico se mostrará el mensaje “Dato
incorrecto”.

4. Proceso
Al ejecutar la aplicación se mostrará al usuario una interfaz gráfica en la que el deberá
ingresar la temperatura para que mediante este dato se pueda determinar el tipo de
clima. La interfaz gráfica es la siguiente.

La interfaz posee cuatro botones operables:

• Ingresar: Ingresa la temperatura para poder verificarla.
• Limpiar: Limpia todas las cajas de texto de la interfaz.
• Minimizar: Minimiza la interfaz en la barra de tareas de nuestro sistema
operativo.
• Cerrar: Cierra la aplicación.

12
 Programación I UES

Proceso del botón Ingresar

Al dar clic en el botón Ingresar el programa leerá el contenido de la caja de texto de
ingreso (txtDato).
Se verificará que el dato ingresado como temperatura sea de tipo numérico, de lo
contrario se mostrará el mensaje “Dato incorrecto” en una ventana emergente.
Luego se evaluará la temperatura de la siguiente forma:
i. Temperatura > 30
En este caso se mostrará el mensaje: “Clima Tropical” en una ventana emergente, al
mismo tiempo que se muestra la temperatura ingresada en la caja de texto
Temperatura (txtTemperatura) y el tipo de clima en la caja de texto Clima (txtClima).

ii. Temperatura > 20 y <= 30

En este caso se mostrará el mensaje: “Clima Cálido” en una ventana emergente, al
mismo tiempo que se muestra la temperatura ingresada en la caja de texto
Temperatura (txtTemperatura) y el tipo de clima en la caja de texto Clima (txtClima).

iii. Temperatura > 10 y <= 20

En este caso se mostrará el mensaje: “Clima Nublado” en una ventana emergente, al
mismo tiempo que se muestra la temperatura ingresada en la caja de texto
Temperatura (txtTemperatura) y el tipo de clima en la caja de texto Clima (txtClima).

iv. Temperatura < 10

En este caso se mostrará el mensaje: “Clima Frio” en una ventana emergente, al
mismo tiempo que se muestra la temperatura ingresada en la caja de texto
Temperatura (txtTemperatura) y el tipo de clima en la caja de texto Clima (txtClima).

Proceso del botón Limpiar

Limpia todas las cajas de texto de nuestra interfaz
• txtDato
• txtTemperatura
• txtClima

13
 Programación I UES

5. Definición de variables de proceso

Nombre Tipo Descripción
En ella se verifica si el dato ingresado
Numérico Boleano (bool)
como temperatura es numérico.

Diseño de la solución

Algoritmo narrado

Proceso: Verificar_Temperatura
{El programa nos pedirá una temperatura para mostrarnos el tipo de clima. Si la
temperatura es mayor a 30 mostrara el mensaje: “Clima Tropical”, si la temperatura
es mayor a 20 y menor o igual a 30 mostrara el mensaje: “Clima Cálido”, si la
temperatura es mayor o igual a 10 y menor o igual a 20 mostrara el mensaje: “Clima
Nublado” y si la temperatura es menor a 10 mostrara el mensaje: “Clima frio”.}
{Dato, Clima son variables de tipo string}
{Temperatura es variable de tipo float}
{Numérico es variable de tipo boleano}

{Método Clima()}
1. Dato = Texto de txtDato
2. Numérico = Convertir Dato a float Temperatura
3. Si Numérico es verdadero Entonces
A. Si Temperatura>30 Entonces
I. Clima = ‘Tropical’
II. Ventana emergente (“Clima “ + Clima)
III. Texto de txtTemperatura = Temperatura + “ °”
IV. Texto de txtClima = Clima
B. Sino
Si Temperatura>20 && Temperatura<=30 Entonces

14
 Programación I UES

I. Clima = ‘Cálido’
II. Ventana emergente (“Clima “ + Clima)
III. Texto de txtTemperatura = Temperatura + “ °”
IV. Texto de txtClima = Clima

C. Sino
Si Temperatura>=10 && Temperatura<=20 Entonces
I. Clima = ‘Nublado’
II. Ventana emergente (“Clima “ + Clima)
III. Texto de txtTemperatura = Temperatura + “ °”
IV. Texto de txtClima = Clima
D. Sino
I. Clima = ‘Frio’
II. Ventana emergente (“Clima “ + Clima)
III. Texto de txtTemperatura = Temperatura + “ °”
IV. Texto de txtClima = Clima
FinSi
FinSi
FinSi
4. Sino
A. Ventana emergente (“Dato incorrecto”)
5. Fin.

{Método Limpiar()}
1. Texto de txtDato = nulo
2. Texto de txtTemperatura = nulo
3. Texto de txtClima = nulo

15
 Programación I UES

{Botón Ingresar}
1. Llama al método Clima()
2. Fin

{Botón Limpiar}
1. Llama al método Limpiar()
2. Fin

16
 Programación I UES

Diagrama de flujo

17
 Programación I UES

Sintaxis en C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Ejercicio2
{
public partial class Ejercicio2 : Form
{
public Ejercicio2()
{
InitializeComponent();
}

public void Clima()

{
string Dato, Clima;
bool Numerico;
float Temperatura;

Dato = txtDato.Text;
Numerico = float.TryParse(Dato, out Temperatura);

if (Numerico)
{
if(Temperatura > 30)
{
Clima = "Tropical";
MessageBox.Show("Clima " + Clima);
txtTemperatura.Text = Temperatura.ToString() + "°";
txtClima.Text = Clima;
}

else if(Temperatura > 20 && Temperatura <=30)

{
Clima = "Calido";
MessageBox.Show("Clima " + Clima);
txtTemperatura.Text = Temperatura.ToString() + "°";
txtClima.Text = Clima;
}

else if(Temperatura >= 10 && Temperatura <= 20)

{
Clima = "Nublado";
MessageBox.Show("Clima " + Clima);
txtTemperatura.Text = Temperatura.ToString() + "°";
txtClima.Text = Clima;
}

else

18
 Programación I UES

{
Clima = "Frio";
MessageBox.Show("Clima " + Clima);
txtTemperatura.Text = Temperatura.ToString() + "°";
txtClima.Text = Clima;
}

else
{
MessageBox.Show("Dato Incorrecto.");
}

public void Limpiar()

{
txtDato.Text = null;
txtTemperatura.Text = null;
txtClima.Text = null;
}

private void btnIngresar_Click(object sender, EventArgs e)

{
Clima();
}

private void btnLimpiar_Click(object sender, EventArgs e)

{
Limpiar();
}
}
}

19
 Programación I UES

Conclusiones

Las estructuras selectivas nos ayudan a dar solución a diversos problemas mediante
la lógica de las condiciones. Esto mediante el análisis de un intervalo de datos (if else)
o mediante un caso específico (switch case).

También nos ayuda la práctica para el manejo y programación de las aplicaciones de

tipo consola y de tipo ventana.

20
 Programación I UES

Recomendaciones

• Utilizar las estructuras selectivas que mejor satisfaga la solución de nuestro

problema.
• Aplicar restricciones a nuestro programa para evitar errores y caídas del mismo.
• Aplicar el dominio de aplicaciones de tipo ventana para facilitar al usuario la
utilización del programa.

21
 Programación I UES

Bibliografía

• https://youtu.be/MKI8opjIg8c
• http://campus.ues.edu.sv/mod/resource/view.php?id=110452
• https://youtu.be/ucgHhPmZo0M
• http://campus.ues.edu.sv/mod/resource/view.php?id=114764

22
 Programación I UES

Anexos

Ejercicio 1 en funcionamiento

23
 Programación I UES

Funcionamiento del ejercicio 2

24