Programación Estructurada

Unidad 2

Alumno:

Juan Ángel Hernández de León

No. De Control:
22050521

Docente:

Humberto Moreno Posada

Saltillo, Coahuila 16 de octubre del 2023

 • Hacer un programa que pida un nombre, y mande un mensaje personalizado

string nombre;
Console.WriteLine("¿Cuál es tu nombre?");
nombre = Console.ReadLine();
Console.WriteLine("¡Hola, " + nombre + "!. Te damos la bienvenida.");

Resumen:

Este programa imprime a la consola la pregunta de cuál es tu nombre, para inmediatamente después
esperar por una respuesta, una vez que ésta es introducida a la consola, se imprime un mensaje de
bienvenida.

Conclusión:
En este programa se trabaja con variables de tipo string. Lo que escriba la persona en la consola se
almacena en forma de string, por lo que no es necesario hacer ningún tipo de conversión. El mensaje
que se imprime es una concatenación de tres diferentes cadenas de caracteres.

• Hacer un programa para leer la edad, si es mayor de edad, mostrar un mensaje de acceso
permitido, si no, mostrar acceso denegado

Console.WriteLine("¿Cuál es tu edad?");
int edad = Convert.ToInt16(Console.ReadLine());

if (edad >= 18)

{
Console.WriteLine("Acceso permitido");
}
else
{
Console.WriteLine("Acceso denegado");
}

Resumen:

Se pide a través de un mensaje a la consola que se introduzca una edad. Como lo que solicitamos
esta vez es un número, es necesario convertir lo que se lea de la consola a un número entero.
Después, lo que se hace es comparar si el número ingresado es mayor o igual que 18, es decir, si la
persona es mayor de edad. En caso de ser mayor, se muestra un mensaje de acceso permitido, de lo
contrario, se muestra un mensaje de acceso denegado.

Conclusión:

Se introducen dos nuevas funcionalidades, primero, el cambiar el formato de los datos que se
ingresan a la consola, puesto que, por defecto, todo lo que escribamos se registra en formato de
string, por lo que es necesario cambiar el formato en aquellas situaciones que lo ameriten. Además,
la estructura if – else nos permite comparar una variable con determinada condición lógica, lo que
resulta útil para hacer diferentes acciones, dependiendo de las condiciones que se presenten.

• Hacer un programa igual que el anterior, pero para 10 edades

int edad;

for (int i = 0; i < 10; i++)

{
Console.WriteLine("Dame tu edad");
edad = Convert.ToInt16(Console.ReadLine());

if (edad >= 18)

Console.WriteLine("Acceso permitido");
else
Console.WriteLine("Acceso denegado");
}

Resumen:
La diferencia entre el programa anterior y éste es que se agrega la estructura for, la cual se usa para
generar ciclos cuando se cumplen ciertas condiciones. En este caso, se asigna una variable que
funciona como contador; mientras ésta sea menor que 10, se ejecuta el código contenido dentro de
la estructura y se aumenta en 1 la variable, hasta que la condición ya no se cumpla.

Conclusión:

La estructura for sirve para ejecutar una sección de código de manera cíclica. Puede ser usada para
ejecutar el código un número específico de veces, o para repetir una instrucción hasta que se cumpla
una condición.

• Completar el programa anterior para leer 100 edades, y además mostrar qué cantidad
fueron mayores y cuántos fueron menores

int edad, i_MM = 0, i_mm = 0;

for (int i = 0; i < 100; i++)

{
Console.WriteLine("Dame tu edad");
edad = Convert.ToInt16(Console.ReadLine());

if (edad >= 18)

 {
Console.WriteLine("Acceso permitido");
i_MM++;
}
else
Console.WriteLine("Acceso denegado");
}

i_mm = 100 – i_MM;

Console.WriteLine("El número de mayores es: " + i_MM + " personas \nEl número
de menores es: " + i_mm + " personas");

Resumen:

En este programa se agrega un conteo de las personas que son mayores y las que son menores en
un grupo de 100 personas. Para realizar lo anterior, se aumenta una variable cada vez que se registra
un mayor, y al final se muestra en la consola la cantidad de personas mayores y menores.

Conclusión:

Se pueden usar los ciclos para ejecutar instrucciones cíclicas, en este caso se usa para llevar el conteo
de las personas mayores y menores, para al final mostrar los resultados.

• Completar el programa anterior para solicitar la edad, y al final obtener el promedio de

edad

int edad, i_MM = 0, i_mm = 0, anterior = 0, suma = 0, promedio = 0;

for (int i = 0; i < 100; i++)

{
Console.WriteLine("Dame tu edad");
edad = Convert.ToInt16(Console.ReadLine());

if (edad >= 18)

{
Console.WriteLine("Acceso permitido");
i_MM++;
}
else
{
Console.WriteLine("Acceso denegado");
}

suma = suma + edad;

promedio = suma / (i + 1);

if (edad > anterior)

anterior = edad;
}
i_mm = 10 - i_MM;
Console.WriteLine("El número de mayores es: " + i_MM + " personas \nEl número
de menores es :" + i_mm + " personas");
Console.WriteLine("El promedio de edades es: " + promedio + " años \nEl mayor
de las edades es: " + anterior + " años");

Resumen:

En este caso, se hace lo mismo que el código anterior, añadiéndole que además de mostrar el
número de mayores y menores, se calculará el promedio de todas las edades ingresadas, lo cual
puede ser muy útil en situaciones prácticas.

Conclusión:

Este código se asemeja más a un programa que pudiera ser usado de manera práctica, puesto que
muchos establecimientos pueden estar interesados en ver la cantidad de menores que intentan
ingresar a sus instalaciones o el promedio de edad de sus clientes.

• Hacer un algoritmo para leer 3 datos numéricos y determinar el mayor de ellos

int A, B, C;

Console.WriteLine("Ingrese los valores de A,B y C para determinar el mayor de

los 3 números");
Console.WriteLine("Valor de A:");
A = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Valor de B:");
B = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Valor de C:");
C = Convert.ToInt16(Console.ReadLine());

if (A > B)
if (A > C)
Console.WriteLine(A + " es el mayor");
else
Console.WriteLine(C + "Es el mayor");
else if (B > C)
Console.WriteLine(B + "Es el mayor");
else
Console.WriteLine(C + "Es el mayor");

Resumen:

Se pide que se ingresen 3 valores, y cada uno de ellos es convertido de string a entero de 16 bits
para poder trabajar con ellos. Después, se analiza caso por caso cuál es el mayor, comparando el
valor de dos de ellos, para enseguida comparar el mayor de éstos con un tercero, y así poder
determinar el mayor de los tres números ingresados.
Conclusión:

En el caso de tres números, basta con comparar las diferentes combinaciones para determinar cuál
es el mayor de los números ingresados, sin embargo, esto no resulta óptimo con un número mayor
de datos, puesto que las combinaciones incrementan exponencialmente.

• Hacer un programa para leer 100 datos y determinar la cantidad que corresponda al
mayor

int dato, mayor = 0;

for (int i = 0; i < 100; i++)

{
Console.WriteLine("Ingrese un valor");
dato = Convert.ToInt16(Console.ReadLine());

if (dato > mayor)

mayor = dato;
}
Console.WriteLine("El mayor de los números es: " + mayor);

Resumen:

Se hace uso de los ciclos para solicitar 100 datos, y cada vez que se solicite un dato, se compare con
el dato más grande hasta el momento, de forma que al final del programa se obtenga el número
mas grande que fue ingresado.

Conclusión:
Como vimos en el caso anterior, no era práctico analizar caso por caso cuál número era mayor, sobre
todo entre más números analicemos. Por lo tanto, lo que se hace es ir guardando desde el inicio el
número más grande ingresado, de manera que cada vez que se ingrese un nuevo valor, se compare
con éste, y se determine si el nuevo valor es mayor o menor, para al final imprimir el valor de la
variable que registraba el número más grande.
 • Completar el diagrama anterior, determinando la cantidad de mayores, así como la
cantidad de menores

int dato, mayor = 0, menor = 9999999, n_MM = 0, n_mm = 0;

for (int i = 0; i < 100; i++)

{
Console.WriteLine("Ingrese un valor");
dato = Convert.ToInt16(Console.ReadLine());

if (dato > mayor)

{
mayor = dato;
n_MM = 1;
}
else if (dato < menor)
{
menor = dato;
n_mm = 1;
}
else if (dato == mayor)
n_MM++;
else if (dato == menor)
n_mm++;
}

Console.WriteLine("El mayor de los números es: " + mayor);

Console.WriteLine("El menor de los números es: " + menor);
Console.WriteLine("El número de mayores es: " + n_MM);
Console.WriteLine("El número de menores es: " + n_mm);

Resumen:

Para este caso, además de lo anterior, se solicita que se determine la cantidad de mayores y menores,
es decir, si el mayor de los números se repite 5 veces, mostrar al final del programa que se repitió 5
veces. Para lograr lo anterior, se comparan 4 diferentes situaciones: si el nuevo dato ingresado es
mayor al número mayor hasta el momento, si es menor al número menor hasta el momento, o si es
igual al mayor o al menor. De esta forma, dependiendo del caso, se aumenta el contador que registra
el número de mayores o menores, o se reinicia a 1 y se guarda el nuevo valor.

Conclusión:

Se usan en conjunto dos estructuras como el for y el if para parametrizar un conjunto de acciones a
realizar, según lo que se requiera. Primero, el for permite realizar el mismo proceso para los 100
datos requeridos, mientras que el if va filtrando los diferentes casos que se pueden presentar, y
realiza una determinada acción, según sea el caso.
 • Hacer un programa con las siguientes características:

Leer una calificación, si la calificación se encuentra entre 90 y 100, el padre del estudiante otorga el
premio A. Si la calificación está entre 80 a 89, se otorga el premio B. Si la calificación se encuentra
entre el rango de 70 a 79, se otorga el premio C. Si la calificación es menor a 70, se otorga un castigo.

- Premio A: 1 mes de uso del vehículo con tanque lleno y 4 domingos de $1000
- Premio B: 1 semana de uso del vehículo con tanque lleno
- Premio C: 1 domingo de uso del vehículo
- Castigo: 1 mes sin celular, limpiar la casa durante 3 meses

int grupo, calificacion;

string premio_A = "El premio es: 1 mes de uso del vehículo con tanque lleno y 4
domingos de $1000";
String premio_B = "El premio es: 1 semana de uso del vehículo con tanque
lleno";
String premio_C = "El premio es: 1 domingo de uso del vehículo";
String castigo_X = "El castigo es: 1 mes sin celular y limpiar la casa durante
3 meses";
Console.WriteLine("Escriba el tamaño del grupo");
grupo = Convert.ToInt32(Console.ReadLine());

for (int i = 0; i <= grupo; i++)

{
Console.WriteLine("Inserte una calificacion");
calificacion = Convert.ToInt32(Console.ReadLine());
switch (calificacion)
{
case < 70:
Console.WriteLine(castigo_X);
break;
case < 80:
Console.WriteLine(premio_C);
break;
case < 90:
Console.WriteLine(premio_B);
break;
case <= 100:
Console.WriteLine(premio_A);
break;
}
}

Resumen:

Para este programa se pide que se asigne un determinado premio, dependiendo de la calificación
de un grupo de n niños, por lo que se usa el for para repetir el proceso con cada niño del grupo, y se
usa la estructura switch como sustituto del if, puesto que compara repetidamente una misma
variable con diferentes valores de calificación. Primero se asignaron en sus respectivas variables de
tipo string los diferentes premios, para luego pedir el tamaño del grupo, y repetir el proceso de pedir
una calificación y asignar un premio el número de veces que especifique la variable de grupo.
Conclusión:

La estructura de switch puede usarse como el if, sin embargo, el switch tiene la ventaja que resulta
más práctico y entendible al momento de leer o escribir el código, puesto que se compara
repetidamente una misma variable con diferentes parámetros numéricos, por lo que no es necesario
estar escribiendo constantemente la sintaxis de un if.

• Hacer un programa que genere un cronómetro que represente los segundos de un

minuto

for (byte N = 0; N < 60; N++)

{
Console.Clear();

if (N < 10)
{
Console.Write("0" + N);
}
else
{
Console.Write(N);
}
Thread.Sleep(1000);
}

Resumen:

Se usa la estructura for para contar del 0 al 59, es decir, los segundos de un minuto. Para darle más
apariencia de cronómetro, se agregó el código Console.Clear(); para limpiar la consola cada vez que
se ejecuta el código. Además, el código Thread.sleep(); ejecuta una espera de n milisegundos, que
en este caso se requiere que sea de 1000 ms, puesto que el cronómetro avanza cada segundo.

Conclusión:

Los ciclos permiten realizar una tarea repetidamente. Además, existen diferentes comandos que nos
permiten manipular y estilizar la forma y apariencia de la consola.
 • Completar el programa anterior, considerando que tenemos una hora

for (byte M = 0; M < 60; M++)

{
for (byte N = 0; N < 60; N++)
{
Console.Clear();
if (M < 10)
{
Console.Write("0" + M + ":");
}
else
Console.Write(M + ":");
if (N < 10)
{
Console.Write("0" + N);
}
else
{
Console.Write(N);
}
Thread.Sleep(1000);
}
}

Resumen:

Se hace uso de un segundo ciclo for, de manera que se requiee que se ejecunten todos los ciclos del
ciclo interno para ejecutar un ciclo externo. De esta manera, el cronómetro anterior ahora puede
contar hasta una hora.

Conclsuión:

Se pueden ejecutar ciclos dentro de otros ciclos, es decir, se pueden anidar ciclos, para que existan
diferentes controles en etapas màs internas o externas del programa.

• Completar el programa anterior, haciendo el cronómetro para un año

for (byte YY = 0; YY < 3; YY++)

{
for (byte MM = 1; MM <= 12; MM++)
{
for (int DD = 1; DD < 31; DD++)
{
for (byte H = 0; H < 24; H++)
{
for (byte M = 0; M < 60; M++)
 {
for (byte N = 0; N < 60; N++)
{
Console.Clear();
Console.WriteLine(DD + "/" + MM + "/" + YY);
if (H < 10)
{
Console.Write("0" + H + ":");
}
else
Console.Write(H + ":");
if (M < 10)
{
Console.Write("0" + M + ":");
}
else
Console.Write(M + ":");
if (N < 10)
{
Console.Write("0" + N);
}
else
{
Console.Write(N);
}
Thread.Sleep(1000);
}

}
}
}
}
}

Resumen:

Se hace uso de ciclos anidados de forma repetida para generar un cronómetro que sea capaz de
registrar hasta tres años, todo esto aplicando un for para cada unidad de medida de tiempo que
queramos agregar.

Conclusión:
Podemos usar tantos ciclos anidados como lo necesitemos, pero es importante considerar que entre
más externo esté el control, más se tardará en ejecutar, puesto que se necesitan completar el resto
de los ciclos internos para completarse.
 • Complete el programa anterior para que despliegue un mensaje de felicitaciones el día
de tu cumpleaños

byte DiaC, MesC;

Console.WriteLine("Escribe tu mes de nacimiento");

MesC = Convert.ToByte(Console.ReadLine());
Console.WriteLine("Escribe tu dia de nacimiento");
DiaC = Convert.ToByte(Console.ReadLine());

for (byte YY = 0; YY < 3; YY++)

{
for (byte MM = 1; MM <= 12; MM++)
{
for (int DD = 1; DD < 31; DD++)
{
for (byte H = 0; H < 24; H++)
{
for (byte M = 0; M < 60; M++)
{
for (byte N = 0; N < 60; N++)
{
Console.Clear();
Console.WriteLine(DD + "/" + MM + "/" + YY);
if (H < 10)
{
Console.Write("0" + H + ":");
}
else
Console.Write(H + ":");
if (M < 10)
{
Console.Write("0" + M + ":");
}
else
Console.Write(M + ":");
if (N < 10)
{
Console.Write("0" + N);
}
else
{
Console.Write(N);
}
if (MesC == MM && DiaC == DD)
{
Console.WriteLine("\n¡Felicidades, es el día de tu
cumpleaños!");
}
Thread.Sleep(1000);
}

}
}
}
}
}
Resumen:

A diferencia que los programas anteriores, aquí se ejecuta una estructura if dentro de los ciclos
anidados, por lo que tenemos un control para realizar una determinada tarea en uno o varios de los
ciclos del programa.

Conclusión:

Podemos parametrizar lo que se va a realizar en cada una de las partes de los ciclos anidados,
ayudándonos con otras estructuras de control, como es el caso del if.

• Hacer un programa para ingresar el sueldo del trabajador, las horas trabajadas, bono de
asistencia. Se asume que las horas trabajadas por semana equivalen a 40, el bono de
productividad se otorga si se cumplió con el total de horas semanales, y se calcula en
base en la siguiente tabla, que corresponde a la evaluación por desempeño. Mostrar el
sueldo al final.

int horas_trabajadas, sueldo, px;

double bono = 0;
double sueldo_F;

Console.WriteLine("Introduzca el sueldo:");
sueldo = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Introduzca las horas trabajadas:");
horas_trabajadas = Convert.ToInt16(Console.ReadLine());
px = horas_trabajadas / 40 * 100;

switch (px)
{
case < 80:
bono = .5;
break;
case < 90:
bono = .8;
break;
case < 100:
bono = .9;
break;
case < 101:
bono = 1;
break;
}

sueldo_F = sueldo * bono;

Console.WriteLine("El sueldo final es: " + sueldo_F + "$");
Resumen:

Se muestran dos mensajes en consola para que el usuario ingrese un sueldo y la cantidad de horas
trabajadas, de manera que, por medio de ciertos parámetros, pueda saber el sueldo final. Para lo
anterior se hace uso del switch para hacer una diferente acción según el porcentaje de asistencia, y
con base a esto, se obtiene un sueldo diferente.

Conclusión:

La estructura switch puede suplir al if para analizar una variable entre un rango amplio de valores,
es decir, es más útil cuando se requiere hacer múltiples comparaciones sobre una misma variable.

• Hacer un programa para calcular la serie de Fibonacci

int x = 0, y = 1, z, N;

Console.WriteLine("Introduzca el número de valores para la serie de

fibonacci");
N = Convert.ToInt32(Console.ReadLine());
Console.Clear();

for (int i = 0; i <= N; i++)

{
z = x + y;
Console.WriteLine(y);
x = y;
y = z;
}

Resumen:

La serie de Fibonacci se define como la suma de los dos términos anteriores, comenzando con dos
unos, por lo que, para obtener un valor concreto de la serie, basta con repetir un ciclo tantas veces
como el número de la serie deseada. En este ciclo se realizará la suma de 2 variables, y se almacenará
en una tercera. Se imprimirá una de estas variables, y enseguida se transferirá los valores de manera
sistémica, hasta que se completen todos los ciclos requeridos.

Conclusión:

Hacemos uso del ciclo for porque requerimos repetir una fracción del código de manera sistemática,
hasta obtener un resultado que es el deseado.
 • Hacer un programa para calcular el factorial de un número
int N, R = 1;

Console.WriteLine("Introduzca el número del que quiere calcular el factorial");

N = Convert.ToInt32(Console.ReadLine());

for (int i = 0; i != N; i++)

{
R = R * (i + 1);
}

Console.WriteLine("El factorial de " + N + " es: " + R);

Resumen:

Para calcular el factorial de un número, se debe multiplicar ese número por todos los números
enteros menores que éste, por lo que, para calcular el factorial el un programa, se repite un ciclo, en
el que se multiplica un número hasta que el número de ciclos es igual al número del que queríamos
calcular el factorial.

Conclusión:

Como en el programa anterior, se pueden realizar diferentes operaciones matemáticas que

requieren de constantes iteraciones para llegar al resultado, todo esto gracias a los controles que
permiten controlar la ejecución de los ciclos.

• Hacer un programa para leer un número, y generar la serie de Fibonacci, y a cada serie,
calcular el factorial

int x = 0, y = 1, z, N, R = 1;

Console.WriteLine("Introduzca un número");
N = Convert.ToInt32(Console.ReadLine());

for (int i = 0; i <= N; i++)

{
z = x + y;
for (int j = 0; j != y; j++)
{
R = R * (j + 1);
}
Console.Write("Serie de fibonacci: " + y);
Console.WriteLine("\tFactorial de ese número: " + R);
x = y;
y = z;
R = 1;
}
Resumen:

Se ejecuta primero un ciclo que determina el número de determinada serie de Fibonacci, después,
se entra en otro ciclo que calcula el factorial del número de la serie de Fibonacci que acabamos de
calcular, básicamente es una combinación de los dos códigos anteriores.

Conclusión:
Una vez que tenemos el código de diferentes partes del programa, y ya hemos probado que
funcionan, es más simple conseguir que funcione el programa entero, puesto que sólo hay que
acoplar todas sus partes.

• Hacer un programa para generar los números del 1 al 100, y del 100 al 1

int i = 1;

Console.WriteLine("Contador ascendente");

for (i = 1; i <= 100; i++)

{
Console.WriteLine(i);
}

Console.WriteLine("Contador descendente");

for (i = 100; i > 0; i--)

{
Console.WriteLine(i);
}

Resumen:

Se tienen dos ciclos, uno cuenta del uno al 100, y otro del 100 al 1, de manera que tenemos una
cuenta ascendente y otra descendente.

Conclusión:

Los ciclos sirven para realizar una misma tarea repetidamente.