Microsoft – CLASE 13

Educación Profesional/Ejercicios en C#/Ingeniería y Desarrollo/Sin categoría

Números del Sistema Binario – Resolviendo Algoritmos en C#

17 de abril, 202317 de abril, 2023 Rodolfo PeñaDeja un comentario

En el video de hoy, te enseñaré a crear un programa para convertir números del sistema decimal (los que usamos normalmente) al sistema binario (aquellos que están representados solo con 0 y 1). También haremos un programa para convertir del sistema binario al sistema decimal, es decir, al revés. Por último, te enseñaré un poco de Git y Github porque estaremos subiendo todos estos ejercicios a esa plataforma. Recuerda que es importante que nos apoyes con una suscripción, un me gusta y compartiendo el video con tus amigos, eso nos ayudará a crecer y nos alentará a continuar haciendo videos de este tipo. ¡Gracias!

Recuerda que puedes comentar, suscribirte a nuestro blog y calificar la entrada para saber si el contenido te ha gustado. Si tienes alguna duda, no temas en preguntar. También te invitamos a seguir todas nuestras redes sociales y a unirte a nuestro servidor de discord. Te invito también a mis propias redes sociales en donde estaré colgando contenido adicional sobre programación, libros y videojuegos.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Arreglos en C#

26 de enero, 202326 de enero, 2023 Rodolfo PeñaDeja un comentario

Un arreglo (yo lo llamaré así, ya que es la traducción de array, aunque también lo podrás encontrar como matriz o vector) es un tipo de dato estructurado que sirve para almacenar múltiples variables de un tipo en común. En palabras más sencillas, es una lista que nos va a permitir guardar muchos datos del mismo tipo. También podemos acceder a esos datos almacenados gracias al índice que posee cada arreglo, estos suelen empezar desde cero, por ejemplo, si tengo un arreglo o lista de cinco espacios, el índice empezará en cero (esto no lo olvides nunca) y terminará en cuatro. Veamos como se ve un arreglo de manera gráfica.

Como podemos apreciar, un arreglo se puede graficar de aquella manera, donde cada cuadrado representa un item del arreglo. En cada item vamos a guardar un nombre y en la parte inferior, podemos ver los índices que nos van a ayudar a identificar cada item dentro del arreglo. Por ejemplo, si nuestro arreglo se llama «estudiantes», para obtener a la estudiante «Karen», tendremos que hacer lo siguiente: estudiantes[3].

Ahora veamos como se ve el ejemplo anterior dentro de C#, para ello vamos a crear un nuevo proyecto e ingresaremos las siguientes líneas de código.

/* Declaración básica */
string[] estudiantes = new string[5];

De esta manera hemos creado un arreglo que almacenará elementos de tipo string y que tendrá cinco espacios. No confundir el tamaño del arreglo con el valor máximo del índice. Cuando declaramos un arreglo tenemos que especificar la cantidad de espacios que este tendrá, según el ejemplo anterior, este debe tener cinco espacios (o cinco casilleros como se muestra en el gráfico), esto no tiene nada que ver con el índice que siempre empezará en cero, y en nuestro ejemplo, su valor máximo será cuatro (siempre será una unidad menos que el tamaño del arreglo el cual se representa como n-1).

Ahora vamos a asignarle valores a nuestro arreglo.

estudiantes[0] = "Carla";
estudiantes[1] = "José";
estudiantes[2] = "Juan";
estudiantes[3] = "Karen";
estudiantes[4] = "Denis";

A cada item del arreglo le hemos asignado un valor, y como ven, hemos empezado en el índice cero y hemos terminado en el cuatro. ¿Qué pasa si le asignamos un valor a un item que no existe? Supongamos que ponemos lo siguiente: estudiantes[5] = «Pepe». Según nuestro ejemplo, ese item no existe dentro del arreglo, por lo tanto, el compilador de C# nos arrojará una excepción (así se les llama a los horrores de programación) llamada «índice fuera de rango» y el programa dejará de funcionar. Aunque no lo crean, este tipo de error es bastante común dentro del mundo de la programación.

Ahora te voy a enseñar como declarar y asignar valores de una forma más simple.

/* Declaramos los valores entre llaves y separados por comas,
 * así mismo, ya no es necesario ponerle el tamaño al arreglo,
 * C# contará los valores que asignamos y ese será el tamaño de nuestro arreglo */
string[] fruits = new string[] { "Pera", "Manzana", "Uva" };

/* También podemos obviar el "new" */
int[] years = { 1992, 1993, 1994, 1995, 1996 };

La cosa no cambia mucho, pero es importante tenerlo en cuenta.

También es importante tener en cuenta los siguientes puntos.

Un arreglo puede ser de cualquier tipo, inclusive puedes almacenar un arreglo dentro de otro.
El tamaño de un arreglo se establece siempre al inicio y este no puede cambiar durante el ciclo de vida del arreglo, existen algunas funciones que te permiten hacerlo, pero digamos que no es una buena práctica. Siempre debemos programar sabiendo que su tamaño no cambiará.
Existen elementos más avanzados como el arrayList o las listas genéricas que funcionan mucho mejor que un arreglo, pero es necesario saber como funcionan estos para que el aprendizaje de los otros sea más fácil.
Puedes usar la propiedad Length para saber de que tamaño es un arreglo.
Las palabras almacenadas en un string se convierten automaticámente en un arreglo de Char, por lo tanto, podrás acceder a cada letra de una palabra recorriendolo con un for como si fuera un arreglo.

Ahora resolvamos algunos ejercicios.

Ejercicio 1: Cree un programa que solicite cinco calificaciones y al final imprima todas las calificaciones y el promedio de estas.

// Declaramos nuestro arreglo, pero no le asignamos ningún valor.
// Como son cinco calificaciones, lo crearemos con tamaño 5
double[] scores = new double[5];
// Este índice nos ayudará a recorrer nuestro arreglo.
int index = 0;
// Para obtener el promedio, necesitamos sumar todas las calificaciones.
double scoreSum = 0;
double prom;

// Ahora le pediremos al usuario que ingrese las calificaciones
// Para ello necesitamos un bucle que se repita cinco veces, 
// para las cinco calificaciones. Eso lo podemos hacer con un for, while o do while
// para este ejemplo usaremos un while, es decir, nuestro bucle se va a
// ejecutar mientras index sea menor que 5
while (index < 5)
{
    // A index le sumamos 1 porque recuerda que empieza en 0
    Console.Write($"Ingrese la calificacón número {index+1}: ");
    // A nuestro arreglo le iremos asignando los valores que el usuario ingrese
    scores[index] = double.Parse(Console.ReadLine());
    // Aquí sumaremos todas las calificaciones.
    scoreSum += scores[index];
    // Actualizamos nuestro índice sino nuestro bucle se ejecutará de manera infinita
    index++;
}

// Como último paso, tenemos que imprimir todas las calificaciones.
// Para ello usaremos un for
// El for iniciará en 0 y se ejecutará mientras este sea menor que el tamaño del arreglo
for(int i = 0; i < scores.Length; i++)
{
    Console.WriteLine($"La calificación número {i + 1} es: {scores[i]}");
}

// Nos falta obtener el promedio de las calificaciones
// Para ellos vamos a dividir la suma de las calificaciones, entre el tamaño del arreglo
// o mejor dicho el número de calificaciones.
prom = scoreSum / scores.Length;
Console.WriteLine($"El promedio de todas las calificaciones es: {prom}");

Como pueden ver en el código, el ejercicio es bastante fácil, ahora vamos a ver el resultado.

Ingrese la calificacón número 1: 6
Ingrese la calificacón número 2: 6.5
Ingrese la calificacón número 3: 7
Ingrese la calificacón número 4: 1.2
Ingrese la calificacón número 5: 3
La calificación número 1 es: 6
La calificación número 2 es: 6.5
La calificación número 3 es: 7
La calificación número 4 es: 1.2
La calificación número 5 es: 3
El promedio de todas las calificaciones es: 4.74

Aumentemos un poco la dificultad.

Ejercicio 2: Cree un programa que permita saber cual es el número mayor y menor de un grupo de números ingresados por el usuario.

// Declaramos nuestro arreglo de tamaño 10 y le vamos a pedir al usuario que ingrese 10 números.
int[] numbers = new int[10];
int index = 0;
int maxNumber = 0;
int minNumber = 0;

// El proceso para pedirle los números al usuario será lo mismo que el ejercicio anterior.
while(index < 10)
{
    Console.Write($"Ingrese el número {index + 1}: ");
    numbers[index] = int.Parse(Console.ReadLine());
    index++;
}

// Ahora procesaremos nuestros datos para saber que número es mayor o menor
// Para ello recorreremos todo el arreglo con un for
for (int i = 0; i < numbers.Length; i++)
{
    // Asignamos el primer valor del arreglo a nuestras variables.
    if (i == 0)
    {
        minNumber = numbers[i];
        maxNumber = numbers[i];
    }
    // Ahora realizamos las comparaciones. Si el número del arreglo es mayor
    // al que está almacenado en nuestras variables, actualizamos la variable
    // para obtener el número menor se hará lo mismo, pero comparando si es menor.
    if(numbers[i] < minNumber)
    {
        minNumber = numbers[i];
    }
    if (numbers[i] > maxNumber)
    {
        maxNumber = numbers[i];
    }
}

// Ahora le mostramos al usuario los resultados
Console.WriteLine($"El número mayor ingresado es: {maxNumber}");
Console.WriteLine($"El número menor ingresado es: {minNumber}");

Aunque hay que pensar un poquito, el ejercicio no es tan complicado, ahora veremos el resultado.

Ingrese el número 1: 9
Ingrese el número 2: 1
Ingrese el número 3: 3
Ingrese el número 4: 8
Ingrese el número 5: 7
Ingrese el número 6: 1
Ingrese el número 7: 0
Ingrese el número 8: 8
Ingrese el número 9: 16
Ingrese el número 10: 8
El número mayor ingresado es: 16
El número menor ingresado es: 0

Interesante, ¿verdad? Ahora te toca a ti.

Ejercicio 3: Cree un programa que le permita al usuario ingresar 10 números y que al final te muestre cual es el número que se repite más veces y la cantidad de veces que se repite.

Ingrese el número 1: 9
Ingrese el número 2: 1
Ingrese el número 3: 3
Ingrese el número 4: 8
Ingrese el número 5: 7
Ingrese el número 6: 1
Ingrese el número 7: 0
Ingrese el número 8: 8
Ingrese el número 9: 16
Ingrese el número 10: 8
El número que se repite más veces es el 1, y se repite 2 veces.

Pista: Este ejercicio es parecido al número 2, tienes que empezar con el primer número y compararlo con todo el arreglo, así mismo, debes ir contando cuantas veces se repite. Si existe otro número que se repite más veces, actualizas las variables de apoyo que estés usando.

Ejercicio 4: Cree un programa que ayude a identificar si un número o palabra ingresada por el usuario es capicúa, es decir, que se lee de la misma manera tanto de derecha a izquieda, como de izquierda a derecha.

Ingrese un número o palabra: reconocer
El número o palabra ingresada es capicúa.
Ingrese un número o palabra: 1234
El número o palabra ingresada no es capicúa.

Pista: Como te comenté más arriba, todas las palabras se convierten en un arreglo de manera automática, por lo tanto, lo único que tienes que hacer es comparar del inicio al final si las letras se repiten, en caso alguna no lo haga, puedes decir que no es capicúa.

¡Con eso hemos terminado la clase de hoy!

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Bucle While en C#

13 de octubre, 202213 de octubre, 2022 Rodolfo Peña3 comentarios

El bucle while tiene la misma estructura que un IF, es decir, que para que el bloque de código que está dentro del while se ejecute, hace falta que se cumpla una condición con resultado verdadero. El bloque de código se va a ejecutar tantas veces mientras que el resultado de la condición siga siendo verdadera y esta evaluación siempre se hará al inicio. Si dentro de tu bloque de código hay una lógica que cambie el resultado de la condición a falsa, el bucle while terminará su ejecución y el compilador ejecutará el código restante. Veamos la sintaxis con un pequeño ejemplo.

// Vamos a crear un programa que sume números mientras estos sean menores que 10
// Declaramos nuestras variables
int index = 1;
int sum = 0;
while(index < 10)
{
    // Sumamos el valor actual de index
    sum += index;
    // Mostramos el valor de index
    Console.Write($"{index}, ");
    // Le sumamos un 1 al valor a index
    index++;
}
//Hacemos un salto de línea
Console.WriteLine();
// Mostramos la suma total
Console.WriteLine($"La suma total es: {sum}");

Al ejecutar, debe quedar algo así.

1, 2, 3, 4, 5, 6, 7, 8, 9,
La suma total es: 45

La lógica es simple, declaramos una variable index que inicializará en uno y luego declaramos un while con la condición de que se ejecute ese bloque de código (lo que está dentro del while), siempre y cuando el valor de index sea menor que diez. Cada vez que terminemos de ejecutar el bloque de código, le aumentamos un valor a index (sino lo hacemos, el while se ejecutaría por siempre y el compilador nos arrojaría un error) al final del código, y en la siguiente iteración, se vuelve a evaluar la condición, donde index será igual a dos y seguirá siendo menor que 10. Esto se hará repetitivamente hasta que index tenga el valor de 10 y el resultado de la evaluación de la condición sea falsa, ya que 10 no es menor que 10. Solo en ese momento terminará de ejecutarse el bloque de código dentro del while y el compilador continuará ejecutando el código restante de tu programa.

Si aún no queda claro, resolveremos algunos ejemplos.

Ejercicio 1: Vamos a crear el juego de naipes llamado 21, ¿lo conoces? El juego es simple, el jugador irá sacando naipes aleatorios entre el 1 y el 13 y el valor de estas se irá sumando, si el jugador saca un naipe y la suma supera el número 21, el jugador perdará automáticamente. Por ello, el jugador debe saber cuando detenerse y dejar de sacar naipes. Normalmente esto se juega entre dos o más personas y gana el que más cerca quedó del 21, pero en nuestro ejemplo, vamos a cambiar ligeramente las normas. Vamos a pedirle al usuario que saque naipes y cada vez que lo haga le vamos a preguntar si aún desea sacar un naipe adicional. Si el jugador decide sacar otro y la suma supera el número 21, el jugador perderá, en caso contrario, el programa escogerá un naipe y evaluará si la suma de los naipes del jugador más ese naipe adicional supera el 21, en ese caso, el jugador ganará. Si no, el jugador habrá perdido por no arriesgarse a escoger un naipe más. Comencemos a codificar para ver si el ejercicio se entiende mejor así.

// Primero debemos saber en que momento se detendrá el While
// Y eso se hará cuando el jugador no quiera elegir un naipe más
// Declaramos nuestras variables
// Aquí guardaremos la respuesta del usuario, que puede ser S/N (si o no)
// Si vamos a usar esta variable en una condición antes de que sea inicializada,
// Es necesario hacerlo antes asignándole un valor por defecto, yo le pondré 'S'
char userAnswer = 'S';
// Aquí sumaremos los valores de los naipes
int sumCards = 0;
// Estas variables serán de apoyo
int randomCard;
int additionalCard;
// Creamos una variable aleatoria Random para simular la acción de escoger un naipe
Random nextCard = new Random();
// Declaramos nuestro While
// El while se ejecutará mientras la respuesta del usuario sea S
while (userAnswer == 'S')
{
    // Le preguntamos al usuario si desea escoger un naipe
    Console.WriteLine("¿Desea seleccionar un naipe? (S/N)");
    userAnswer = char.Parse(Console.ReadLine());
    // Si dice que si, sumaremos el valor del naipe
    // En caso contrario, no haremos nada
    if (userAnswer == 'S')
    {
        // Con nuestra variable random, le diremos que queremos
        // un valor aleatorio entre el 1 y el 13, y lo sumamos
        randomCard = nextCard.Next(1, 13);
        // Mostramos el naipe que el usuario seleccionó
        Console.WriteLine($"El naipe seleccionado tiene el valor de: {randomCard}");
        // Y lo sumamos
        sumCards += randomCard;
        // Ahora vamos a evaluar si la suma supera el número 21
        if (sumCards > 21)
        {
            // Como ha superado el número 21, el usuario pierde.
            Console.WriteLine("¡¡Lo sentimos, usted ha perdido!!");
            // Con la instrucción break, forzamos a que el While termine
            break;
        }
    }
}
// Aquí vamos a evaluar si el usuario dijo que no
// Porque si perdió sacando muchos naipes, entonces el valor
// de userAnswer seguirá siendo S
if (userAnswer == 'N')
{
    // El programa sacará un naipe adicional
    additionalCard = nextCard.Next(1, 13);
    // Mostramos el naipe que el programa seleccionó.
    Console.WriteLine($"El naipe seleccionado por el programa tiene el valor de: {additionalCard}");
    // Lo sumamos a lo que ya tenía el usuario acumulado
    sumCards += additionalCard;
    // Evaluamos si superó el número 21
    if (sumCards > 21)
    {
        // El usuario gana porque si hubiera seleccionado un naipe más, hubiera perdido,
        // es decir, se detuvo en el momento exacto
        Console.WriteLine("¡¡Felicidades, usted ha ganado!!");
    }
    else
    {
        // El usuario pierde porque no se arriesgó a escoger un naipe más.
        Console.WriteLine("¡¡Lo sentimos, usted ha perdido por no arriesgarse a seleccionar un naipe más!!");
    }
    // Le mostramos al usuario el valor final de todos sus naipes
    Console.WriteLine($"La suma final de sus naipes es: {sumCards}");
}

Vamos a ejecutar y comenzar a jugar contra nuestro programa.

¿Desea seleccionar un naipe? (S/N)
S
El naipe seleccionado tiene el valor de: 12
¿Desea seleccionar un naipe? (S/N)
S
El naipe seleccionado tiene el valor de: 10
¡¡Lo sentimos, usted ha perdido!!

Perdí por sacar muchos naipes ¡que mala suerte! Vamos a intentarlo una vez más.

¿Desea seleccionar un naipe? (S/N)
S
El naipe seleccionado tiene el valor de: 7
¿Desea seleccionar un naipe? (S/N)
S
El naipe seleccionado tiene el valor de: 5
¿Desea seleccionar un naipe? (S/N)
S
El naipe seleccionado tiene el valor de: 8
¿Desea seleccionar un naipe? (S/N)
N
El naipe seleccionado por el programa tiene el valor de: 7
¡¡Felicidaes, usted ha ganado!!
La suma final de sus naipes es: 27

En este caso, he seleccionado tres naipes al azar y ahi me he detenido, le he dicho al programa que ya no quiero seleccionar otro naipe. Por lo tanto, el programa sacará un naipe adicional y lo sumará con lo que ya teníamos acumulado y vemos que supera el 21, por lo tanto, yo he ganado.

¿Les gustó el ejercicio? ¿Creen que se pueda mejorar? Hazmelo saber en la zona de comentarios.

Ejercicio 2: Cree un programa que le pida un número al usuario entre el 1 y el 5, y que lo compare con un número aleatorio generado por el programa, también del 1 al 5, y si ambos coinciden, mostrar un mensaje y terminar el programa.

// Declaramos nuestras variables
int randomNumber = 1;
int userNumber = 0;
Random rnd = new Random();
// Declaramos nuestro while
// Nuestro bucle se va a ejecutar mientras ambos números sean diferentes
while (randomNumber != userNumber)
{
    // Actualizamos el valor de nuestras variables
    // Pedimos un número al usuario
    Console.WriteLine("Ingrese un número entre el 1 al 5");
    userNumber = int.Parse(Console.ReadLine());
    // Generamos un número aleatorio
    randomNumber = rnd.Next(1, 5);
    // Mostramos el número generado por el programa
    Console.WriteLine($"El número generado por el programa es: {randomNumber}");
    // Validamos si son iguales
    if (randomNumber == userNumber)
    {
        Console.WriteLine("¡Los números coincidieron, el programa termina aquí!");
        //Al evaluar nuevamente la condición del while, el programa terminará ya que ambos números son iguales.
    }
    //Si los números son diferentes, no debemos hacer nada,
    //el bucle continuará hasta que ambos números sean iguales.
}

El código es bastante simple, ahora vamos a ejecutar y probar.

Ingrese un número entre el 1 al 5
2
El número generado por el programa es: 4
Ingrese un número entre el 1 al 5
5
El número generado por el programa es: 4
Ingrese un número entre el 1 al 5
2
El número generado por el programa es: 3
Ingrese un número entre el 1 al 5
1
El número generado por el programa es: 4
Ingrese un número entre el 1 al 5
5
El número generado por el programa es: 4
Ingrese un número entre el 1 al 5
3
El número generado por el programa es: 3
¡Los números coincidieron, el programa termina aquí!

Bastante fácil, ¿verdad? Ahora te toca practicar a ti, recuerda que la mejor manera de aprender a programar es practicando bastante, ¡no te rindas!

Ejercicio 3: Cree un programa que permita simular el juego de piedra, papel o tijera. El programa debe enfrentar la opción seleccionada por el usuario y la opción seleccionada aleatoriamente por el programa, y el programa debe ejecutarse tantas veces hasta que haya un ganador.

Elija piedra, papel o tijera:
tijera
El programa seleccionó tijera.
Resultado: ¡Empate! Vuelva a intentarlo.
Elija piedra, papel o tijera:
papel
El programa seleccionó piedra.
Resultado: ¡Felicidades! Usted ha ganado.

Pista: Lo mejor es trabajar con números, por eso, asignale un número a cada opción 1 = Piedra, 2 = Papel, 3 = Tijera, así se te hará más fácil trabajarlo.

Ejercicio 4: Cree un programa que le permita al usuario ingresar las notas de su materia, número del 1 al 10, y cuando ingrese la quinta y última nota, el programa debe mostrarle su promedio general.

Ingrese nota 1:
7
Ingrese nota 2:
10
Ingrese nota 3:
5
Ingrese nota 4:
10
Ingrese nota 5:
7
Su promedio es: 7.8

Pista: Recuerda que el promedio es la suma de todas las notas entre el número de notas ingresadas.

¡Con eso hemos terminado la clase hoy!

Este ha sido todo por la clase de hoy, recuerda que si aún te quedan dudas, puedes dejar un comentario para ayudarte. También hemos creado un servidor en discord para que la ayuda sea más rápida. No olvides que nos puedes seguir en todas nuestras redes sociales para más información de nuestro proyecto.

A mi me puedes encontrar en mis redes sociales, estaré publicando más contenido para que puedan aprender a programar.

¡Suscríbete y comparte nuestro contenido!

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Bucle FOR descendiente en C# [Parte 2]

10 de octubre, 202210 de octubre, 2022 Rodolfo PeñaDeja un comentario

El bucle FOR también nos permite realizar un recorrido de manera descendiente, es decir, desde el final hasta el inicio. Para ello vamos a tener que cambiar nuestras condiciones dentro de la sintáxis, pero todo lo demás será igual. Para entender un poco mejor, vamos a realizar un conteo regresivo para saber si ya es año nuevo.

            // Sintaxis
            for(int i = 5; i >= 0; i--) {
                Console.WriteLine("Falta " + i.ToString() + " segundos.");
                if (i == 0) {
                    Console.WriteLine("¡Feliz año nuevo!");
                }
            }

En nuestro ejemplo podemos ver como se ha construido la sintaxis. En la primera parte declaramos nuestra variable que nos va a servir como índice para iterar (también lo puedes declarar fuera del for), este iniciará con un valor de 5 y no en 0 porque queremos que el índice vaya en reversa. En la segunda parte indicamos la condición que nuestro bucle FOR deberá cumplir para que se siga ejecutando, en este caso indicamos que queremos que el bucle FOR se ejecute mientras sea mayor o igual que 0. En la última parte indicamos el sentido que tomará nuestra variable i, en este caso, indicamos que en cada iteración se reste un valor (i–), así que por cada vuelta que haga el bucle, la variable i irá disminuyendo su valor. Empezará con 5 y finalizará en 0. Cuando ejecutemos (recuerda que es con el comando dotnet run), el resultado se mostrará de la siguiente manera.

Falta 5 segundos.
Falta 4 segundos.
Falta 3 segundos.
Falta 2 segundos.
Falta 1 segundos.
Falta 0 segundos.
¡Feliz año nuevo!

El código es sencillo, vamos a escribir en consola el valor de nuestra variable i (como ven, va disminuyendo), y al final, cuando el valor de i sea 0, mostraremos el mensaje de felicidades por el año nuevo.

Ahora practicaremos realizando algunos ejemplos.

Ejercicio 1: Cree un programa que permita al usuario ingresar su edad y le muestre todos los años que ha vivido.

// Declaramos las variables
int years, lastYear;
// Le pedimos al usuario su edad
Console.WriteLine("Ingrese su edad: ");
years = int.Parse(Console.ReadLine());
// Obtenemos el año actual
lastYear = DateTime.Today.Year;
// Mostramos un texto
Console.WriteLine("Has vivido los siguientes años: ");
/* Declaramos un for que empiece por la edad actual del usuario
 * Luego iremos restando ese número para saber todos los años que ha vivido. */
for (int i = years; i >= 0; i--)
{
    // Al año actual le vamos restando el valor de i
    Console.WriteLine((lastYear - i).ToString());
}

Probamos nuestro código y nos debe salir un resultado similar.

Ingrese su edad:
30
Has vivido los siguientes años:
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022

Sencillo, ¿verdad? Sigamos con el tema.

FOR ascendente y descendente

En algunos casos nos tocará combinar las dos formas de usar el bucle for, y no habrá problema en hacerlo, vamos a resolver el siguiente ejercicio.

Ejercicio 2: Cree un programa que dibuje la mitad de un rombo (o un triángulo vertical, como lo quieras ver), donde la anchura lo defina el usuario y el valor mínimo sea dos.

// Declaramos las variables
int width;
// Le pedimos la anchura al usuario.
Console.WriteLine("Ingrese la anchura, valor mínimo 2: ");
width = int.Parse(Console.ReadLine());
// Mostramos un texto
Console.WriteLine("La figura es:");
/* Para este ejercicio necesitaremos dos for
 * uno irá de manera ascendente y el segundo
 * de manera contraria. */
// Declaramos nuestro for ascedente
for(int i = 1; i <= width; i++)
{
    // Este for irá desde 1 hasta el valor que ingrese el usuario
    for(int j = 1; j <= i; j++)
    {
        /* Este for dibujará la figura con asteriscos.
         * y por cada línea, tiene que dibujar tantos
         * asteriscos como el valor de i
         * usamos la función Write para que lo haga sobre
         * la misma línea. */
        Console.Write("*");
    }
    // Con la función WriteLine vacía hacemos un salto de línea
    Console.WriteLine();
}
// Declaramos nuestro for descendente
// Podemos volver a utilizar la variable i porque el for anterior ya terminó.
// Nuestra variable i iniciará con el valor de la anchura menos uno
// Porque tenemos que dibujar el triangulito inferior
for(int i = width - 1; i >= 1; i--)
{
    // Este for se ejecutará hasta que el valor de i sea 1
    for(int j = 1; j <= i; j++)
    {
        // Dibujamos tantos asteriscos como el valor de i
        Console.Write("*");
    }
    // Hacemos un salto de línea
    Console.WriteLine();
}

He tratado de explicar con comentarios cada línea del código, si aún no se entiende, recuerda que puedes dejar un comentario para ayudarte, o para mejorar la explicación. Ahora vamos a ejecutar el código para ver el resultado.

Ingrese la anchura, valor mínimo 2:
5
La figura es:
*
**
***
****
*****
****
***
**
*

Y con ello tenemos la mitad de un rombo.

FOR con iterador diferente

Hasta ahora hemos visto que el valor de nuestra variable i que declaramos dentro del for (recuerda que le puedes poner cualquier nombre) siempre asciende o desciende de uno en uno, pero esa no es la única forma de iterar. También lo puedes hacer de dos en dos, de tres en tres, o con el valor que quieras. Vamos a ver otro ejemplo.

Ejercicio 3: Cree un programa que genere una serie de múltiplos de 7 en el rango del 1 al 100.

// Declaramos nuestro for
// La única diferencia es en la tercera parte
// Usamos el valor += para indicarle que vaya de 7 en 7
// Si queremos que sea al revés, usaríamos el valor -= 7
for(int i = 0; i < 100; i += 7)
{
    Console.Write($"{i},");
}

Ese código nos dará el siguiente resultado.

0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,

Obviamente, podemos resolver el ejercicio de otra manera, pero quería que vieran como usar otros valores en la iteración.

También tenemos el for each, pero eso lo veremos más adelante.

¡Ahora te toca a ti!

Ejercicio 4: Cree un programa que dibuje un triángulo, donde el usuario ingrese la altura. La consola te debe mostrar lo siguiente:

Ingrese la altura del triángulo: 
3
La figura quedará así.
  *
 ***
*****

Pista: Es necesario dibujar la mitad de un triángulo con «espacios en blanco» para poder centrar nuestro triángulo de asteriscos.

Ejercicio 5: Cree un programa que te indique en que años se celebrarán los siguientes mundiales de futbol a partir de hoy. El usuario debe decidir cuantos mundiales quiere ver.

¿Cuantos mundiales quiere ver?
5
Los siguientes mundiales se celebrarán en los años:
2026
2030
2034
2038
2042

Pista: Los mundiales se celebran cada cuatro años.

Ejercicio 6: Cree un programa que dibuje un trapecio con la altura definida por el usuario. La consola te debe mostrar lo siguiente:

Ingrese la altura del trapecio:
4
La figura es la siguiente:
   *****   
  *******
 *********
***********

Pista: Hace falta dibujar dos triángulos a los lados y un rectángulo de cualquier tamaño en el centro.

A mi me puedes encontrar en mis redes sociales, estaré publicando más contenido para que puedan aprender a programar.

¡Suscríbete y comparte nuestro contenido!

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Bucle FOR en C# [Parte 1]

11 de octubre, 2021 Rodolfo PeñaDeja un comentario

Los bucles nos ayudan a repetir el código que queramos, respetando ciertas condiciones para que estos puedan terminar sin problemas. Un bucle mal programado puede ejecutarse de manera infinita causando problemas en la computadora y posiblemente, lanzando errores de Time Out (cuando un proceso demora mucho en terminar su ejecución). En esta clase vamos a aprender a usar el bucle FOR, el cual, con ayuda de un índice, podemos repetir de manera finita un bloque de código.

La sintaxis en C# es la siguiente.

            for(int i = 0; i <= 10; i++)
            {
                Console.WriteLine("Iteración número: " + i.ToString());
            }

Y el resultado de aquel código es el siguiente.

Iteración número: 0
Iteración número: 1
Iteración número: 2
Iteración número: 3
Iteración número: 4
Iteración número: 5
Iteración número: 6
Iteración número: 7
Iteración número: 8
Iteración número: 9
Iteración número: 10

Como han podido observar, hemos repetido el bloque de código 11 veces (contando desde el 0) y también hemos impreso el índice i, el cual va cambiando de valor a medida que el bucle se va ejecutando. Primero empezó en 0, porque le indicamos que empiece en 0, y ha terminado en 10, además, ha ido cambiando de valor de uno en uno.

Para entender cómo funciona el bucle FOR, debemos aprender cada parte de su estructura. En el ejemplo podemos observar que está dividido en tres secciones por el punto y coma (;). En la primera sección definimos el índice (podemos crear el índice anteponiendo el prefijo int o utilizar una variable que ya tengamos creada previamente) y le asignamos su valor inicial. En la segunda sección definimos hasta que momento se va a ejecutar el bucle, para ello se usa una expresión lógica que indique el valor final del índice. En el ejemplo, hemos indicado que el bucle debe ejecutarse mientras que el índice sea menor o igual que 10, es decir, el bucle se va a ejecutar mientras aquella condición sea verdadera. Finalmente, en la última sección definimos cual es el valor que va a tomar el índice luego de cada iteración (iterar significa realizar una acción varias veces). En el ejemplo, agregamos la siguiente expresión (i++) el cual significa que el índica va a ir creciendo de uno en uno. También podemos indicarle al índica que crezca de dos en dos, de tres en tres, etc., e inclusive, indicarle que disminuya, pero ya lo veremos en la siguiente clase.

No hay mucho más que aprender del FOR, por esa razón vamos a ir a los ejemplos, para que el concepto quede aún más claro.

Ejercicio 1. Cree un programa que solicite un valor inicial y un valor final y que imprima todos los números impares del rango ingresado. En caso no haya ningún número en el rango establecido o el usuario haya ingresado un rango incorrecto, mostrar un mensaje informativo.

using System;

namespace For1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int rangeStart;
            int rangeEnd;
            int imparesCount = 0; // Variable para contar los números impares

            // Solicitamos los datos al usuario.
            Console.Write("Ingrese rango inicial: ");
            rangeStart = int.Parse(Console.ReadLine());
            Console.Write("Ingrese rango final: ");
            rangeEnd = int.Parse(Console.ReadLine());

            Console.WriteLine("Los números impares entre " + rangeStart + " y " + rangeEnd + " son:");

            // Declaramos nuestro for
            // Primera sección:
            // El valor inicial de nuestro índice será rangeStart
            // Segunda sección:
            // El bucle se ejecutará mientras el índice sea menor que rangeEnd
            // Tercera sección:
            // El índice incrementará su valor de uno en uno

            for (int i = rangeStart; i <= rangeEnd; i++)
            {
                // Para saber si un número es par o impar, debemos dividirlo entre 2
                // Si el residuo es 0, entonces es par, sino es impar.
                // Para hallar el residuo en una división se usa el signo porcentaje (%)
                if (i % 2 != 0) 
                {
                    // Si el residuo es diferente de 0, entonces...
                    Console.WriteLine(i.ToString());
                    // Y contamos cuantos números impares encontramos
                    imparesCount++;
                }
            }

            // Ahora mostramos un mensaje informativo si no se encontró ningún número impar
            // O si el usuario puso un rango erróneo
            // Por ejemplo, si el usuario pone como rango inicial 10 y rango final 5
            // El bucle nunca se va a ejecutar, ya que 10 es mayor que 5 y nuestra expresión lógica
            // indica que el bucle se debe ejecutar mientras el valor de nuestro índice sea menor que el rango final
            // Y 10 no es menor que 5

            if (imparesCount == 0)
            {
                // Si nunca se ejecutó el bucle, o no se encontró ningún número impar
                Console.WriteLine("El rango ingresado es inválido o no se encontró ningún número impar.");
            }
            else
            {
                // En caso contrario, indicamos cuantos números impares se encontraron.
                Console.WriteLine("Se encontraron " + imparesCount + " números impares.");
            }
        }
    }
}

Ahora veamos si funciona o no.

¡Funcionó! Ahora hagamos un ejercicio más.

Ejercicio 2. Cree un programa que muestre los 15 primeros múltiplos de 4.

Básicamente, debemos mostrar la tabla de multiplicar del número 4.

using System;

namespace For2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int result;

            Console.WriteLine("Los primeros 15 múltiplos de 4 son: ");

            // Nuestro índice empezará en 1 y terminará en 15
            // Y su valor se incrementará de 1 en 1
            for (int i = 1; i <= 15; i++)
            {
                result = i * 4;
                Console.WriteLine(result.ToString());
            }
        }
    }
}

Veamos si funciona…

Demasiado fácil, ¿verdad? Vamos por uno más complejo.

Ejercicio 3. Cree un programa que muestre los n primeros números de la serie Fibonacci, donde n será definido por el usuario.

En primer lugar, debemos saber que cosa es la serie Fibonacci y en resumen, es una serie que empieza por 0 y 1, y el siguiente número es la suma de los dos anteriores. Ejemplo: 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597…

using System;

namespace For3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Definimos nuestras variables
            int rangeEnd;
            int currentValue = 0; // El primer valor de la serie que se convertirá en el valor actual
            int nextValue = 1; // El segundo valor de la serie que se convertirá en el valor que vamos a calcular
            int aux = 0; // Variable auxiliar

            // Solicitamos los datos al usuario
            Console.Write("¿Cuántos números de la serie Fibonacci desea visualizar?: ");
            rangeEnd = int.Parse(Console.ReadLine());

            // Nuestro índice va a empezar en 3, ya que los dos primeros valores siempre serán 0 y 1
            // Y terminará cuando hayamos mostrado todos los números solicitados por el usuario.
            
            Console.WriteLine("*** SERIE FIBONACCI ***");
            // Imprimimos nuestros dos primeros valores
            Console.Write(currentValue + ", " + nextValue + ", ");


            for(int i = 3; i <= rangeEnd; i++)
            {
                // Lo primero que tenemos que hacer es sumar los dos primeros valores
                // Teniendo en cuenta que los valores se deben actualizar en la siguiente iteración

                // Primero guardamos el valor actual en el auxiliar para no perderlo.
                // aux = 0
                aux = currentValue; 

                // Luego actualizamos el valor actual, con el valor siguiente que calculamos en la anterior iteración
                // En la primera iteración será 1
                // currentValue = 1
                currentValue = nextValue;

                // Por último, sumamos el valor anterior (que guardamos en aux) con el valor actual, para hallar el próximo valor
                // nextValue = 1
                nextValue = aux + currentValue;

                Console.Write(nextValue.ToString() + ", ");
            }

            // Primera iteración
            // aux = 0; currentValue = 1, nextValue = 1
            // Segunda iteración
            // aux = 1; currentValue = 1, nextValue = 2
            // Tercera iteración
            // aux = 1, currentValue = 2, nextValue = 3
            // Y así sucesivamente
        }
    }
}

¡Probemos!

Funciona correctamente, ahora te propongo un reto, ¿cómo quitarías la coma que está sobrando al final de la serie? ¡Déjame un comentario con la solución!

FOR anidado

Al igual que con IF, podemos programar un FOR dentro de otro FOR, teniendo en cuenta que nuestro índice debe tener otro nombre, normalmente le ponemos i, pero para el segundo FOR debemos ponerle otro nombre, por ejemplo: j.

            for(int i = 0; i < 8; i++)
            {
                for(int j = 0; j < 4; j++)
                {
                    Console.Write(j.ToString());
                }
                Console.WriteLine();
            }

En el ejemplo anterior, estamos declarando un primero FOR que se va a ejecutar 8 veces, y un segundo FOR que se va a ejecutar 4 veces. Además, estamos indicando que el valor de J se debe imprimir sobre la misma línea, y cuando el segundo de FOR termine de ejecutarse, se ejecutará un WriteLine() para saltar de línea. En resumen, la ejecución de ese código debe quedar algo así:

Si aún hay dudas, estoy seguro que se disiparán con los ejemplos.

Ejercicio 4. Cree un programa que encuentre los números primos de un rango definido por el usuario.

using System;

namespace For4
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int rangeStart;
            int rangeEnd;
            int dividers = 0;

            // Solicitamos los datos al usuario.
            Console.Write("Ingrese el valor inicial del rango: ");
            rangeStart = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el valor final del rango: ");
            rangeEnd = int.Parse(Console.ReadLine());

            Console.WriteLine("*** LOS NÚMEROS PRIMOS SON ***");

            // El primer for va a recorrer el rango ingresado por el usuario.
            for(int i = rangeStart; i <= rangeEnd; i++)
            {
                // El segundo for lo usaremos para saber si un número es primo o no.
                // Recuerda: un número primo es un número entero que solo es divisible por el mismo número y por 1
                // Entonces declaramos nuestro segundo for, que empezará por 1
                // Y terminará cuando alcance el valor de nuestro primer índice.
                for(int j = 1; j <= i; j++)
                {
                    // Para saber si un número es divisible por un valor, verificamos si el residuo es 0
                    if (i % j == 0)
                    {
                        // Contamos los divisores
                        dividers++;
                    }
                }

                // Luego que termine el segundo FOR, evaluamos cuantos divisores tiene el número.
                // Si es igual a 2, entonces es primo.

                if (dividers == 2)
                {
                    Console.WriteLine(i.ToString());
                }

                // Nuestra variable dividers le asignamos 0 para que pueda contar los divisores del siguiente número.
                dividers = 0;
            }
        }
    }
}

Veamos el resultado.

¡Perfecto! Ahora un ejercicio más para que quede claro.

Ejercicio 5. Cree un programa que solicite la base y la altura de un cuadrilátero y que lo dibuje con asteriscos (*)

using System;

namespace For5
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int xbase;
            int height;

            // Solicitamos los datos al usuario
            Console.Write("Ingrese la base del cuadrilátero: ");
            xbase = int.Parse(Console.ReadLine());
            Console.Write("Ingrese la altura del cuadrilátero: ");
            height = int.Parse(Console.ReadLine());

            // El primero FOR será la altura del cuadrilátero
            // Mientras que el segundo será la base
            for(int i = 0; i < height; i++)
            {
                for(int j = 0; j < xbase; j++)
                {
                    Console.Write("*");
                }
                Console.WriteLine();
            }
        }
    }
}

¡Probemos!

¡Un ejercicio fácil para finalizar la clase!

Con esto hemos terminado la clase y en la siguiente veremos como usar un FOR de forma descendente. ¡Nos vemos!

Te dejo algunos ejercicios para que practiques lo aprendido.

Ejercicio 6. Cree un programa que busque los múltiplos de 5 en un rango definido por el usuario.

Ejercicio 7. Cree un programa que dibuje la siguiente figura, donde N será la altura definida por el usuario

1
22
333
4444
55555
NNNNNN

Ejercicio 8. Cree un programa que sume todos los números de un rango definido por el usuario.

Espero que el contenido de esta clase te haya servido de mucho, y si aún tienes dudas, o algo no está claro, déjanos tu comentario para tenerlo en cuenta y explayarnos un poco más (o corregir) en caso sea necesario.

Nos sería de mucha ayuda que compartas el contenido si te ha gustado y te invitamos a seguirnos en nuestras redes sociales de Clase13, estamos en Facebook, Instagram y Twitter como @Clase13lat, de esa manera te enterarás de las últimas novedades de manera rápida. También te invito a seguirme en Instagram como @rodolfopenia donde estaré subiendo contenido adicional para complementar la clase.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional SWITCH en C#

27 de agosto, 2021 Rodolfo Peña4 comentarios

El elemento Switch nos permite evaluar una variable y realizar diferentes cosas según el resultado de la evaluación. Es parecido a usar múltiples IF de manera secuencial, aunque se podría decir que con Switch puedes lograr un código más ordenado. Entonces… ¿cuándo usar switch o if? Depende de ti como desarrollador usar lo que creas más conveniente dentro de tu programa, ya sabes que siempre debes tener en cuenta que tu código sea entendible. ¡No serás el único que lo va a modificar!

Personalmente, solo suelo usar switch cuando tengo que evaluar la respuesta de un servicio (esto es algo que aprenderemos mucho más adelante), y mostrar un mensaje según el código que retornen. O cuando me piden mostrar un mensaje personalizado según la acción que haya realizado el usuario en nuestro programa.

Ahora vamos a ver como es la sintaxis dentro de C# para empezar a usarlo.

            string number;
            int opt = 2;

            switch(opt)
            {
                case 1: 
                    number = "One";
                    break;
                case 2: 
                    number = "Two";
                    break;
                default:
                    number = "Error";
                    break;
            }
            Console.WriteLine("El número es: " + number);

En el ejemplo anterior, lo que estamos haciendo es evaluar la variable «opt» (dentro de switch), la cual es numérica (también podemos evaluar variables tipo texto, booleanos y caracteres),y luego definimos los diferentes resultado con case. En ese caso, estamos indicando que cuando el número sea uno (case 1), vamos a guardar en la variable number la palabra «One». En el caso que la variable sea dos (case 2), vamos a guardar en la variable number la palabrea «Two». Por último, tenemos un comodín llamado «Default«, este se usa cuando queremos hacer algo luego que la evaluación no ha caído en ninguna condición previamente programada. En nuestro ejemplo, si la variable opt no es ni uno ni dos, irá a «default» y guardará en la variable number la palabra «Error».

Por último, debemos tener en cuenta la palabra clave «break» el cual se usa para indicar que el «case» ya ha terminado y se puede continuar con el siguiente. Es obligatorio usarlo, o sino, el sistema lo marcará como error.

Y eso es todo, no hay mucho más que explicar de Switch, ahora vamos a resolver algunos ejercicios para terminar de entender esta condicional.

Ejercicio 1. Diseñe una calculadora que permita sumar, restar, multiplicar, dividir y elevar a la potencia dos números. Recuerda que no puedes dividir entre 0.

using System;

namespace switch1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int option;
            double numberOne;
            double numberTwo;
            double result;
            string message;

            // Dibujamos el menú para que el usuario pueda ver que opciones tiene.
            Console.WriteLine("***** CALCULADORA *****");
            Console.WriteLine("1. Sumar.");
            Console.WriteLine("2. Restar.");
            Console.WriteLine("3. Multiplicar.");
            Console.WriteLine("4. Dividir.");
            Console.WriteLine("5. Elevar a la potencia.");
            Console.Write("Seleccione una opción (1 - 5): ");
            // Guardamos la variable
            option = int.Parse(Console.ReadLine());
            // Ahora pedimos los dos números.
            Console.Write("Ingrese el primer número: ");
            numberOne = double.Parse(Console.ReadLine());
            Console.Write("Ingrese el segundo número: ");
            numberTwo = double.Parse(Console.ReadLine());

            // Evaluamos la opción elegida y retornamos los resultados.
            switch(option)
            {
                case 1:
                result = numberOne + numberTwo;
                message = "El resultado de la suma de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 2:
                result = numberOne - numberTwo;
                message = "El resultado de la resta de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 3:
                result = numberOne * numberTwo;
                message = "El resultado de la multiplicación de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 4 when numberTwo > 0:
                // Con when, podemos realizar validaciones adicionales, en este caso, validamos que el segundo número sea mayor a 0, sino se cae la división.
                result = numberOne / numberTwo;
                message = "El resultado de la división de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 5:
                result = Math.Pow(numberOne, numberTwo);
                message = "El resultado de elevar " + numberOne.ToString() + " a la potencia de " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                default:
                result = 0;
                message = "Seleccione una opción correcta.";
                break;
            }

            // Imprimimos el mensaje.
            Console.WriteLine(message);
        }
    }
}

Guardamos nuestro código, ejecutamos y probamos para ver si funciona correctamente.

¡Vamos a resolver otro ejercicio!

Ejercicio 2. Cree un programa que permita ingresar un edad y te diga que tipo de persona eres, considerar los siguientes rangos. Validar que la edad sea mayor o igual a 0.

De 0 a 3 años, recién nacido.
De 4 a 9 años, infante.
De 10 a 12 años, puberto.
De 13 a 19 años, adolescente.
de 20 a 29 años, joven.
de 30 a 39 años, adulto.
de 50 a 59 años, adulto mayor.
de 60 a más, anciano.

Nota: Para que switch funcione correctamente, no puede haber dos case con el mismo resultado. Si tu pones case > 60 y luego case > 80, y vas a evaluar el número 85, tu programa se va a caer porque el resultado coincide con dos de tus case (85 es mayor que 60 y 80). Siempre tienes que programar tus case pensando que los resultados son únicos. De todas formas, el sistema no te dejará compilar si no lo haces bien.

using System;

namespace switch2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int years;
            string type;

            // Solicitamos la información al usuario.
            Console.Write("Ingrese su edad: ");
            years = int.Parse(Console.ReadLine());

            // Evaluamos la edad
            switch(years)
            {
                case >= 60:
                type = "anciano";
                break;
                case >= 50:
                type = "adulto mayor";
                break;
                case >= 30:
                type = "adulto";
                break;
                case >= 20:
                type = "joven";
                break;
                case >= 13:
                type = "adolescente";
                break;
                case >= 10:
                type = "puberto";
                break;
                case >= 4:
                type = "infante";
                break;
                case >= 0:
                type = "recién nacido";
                break;
                default:
                type = "ingrese una edad correcta";
                break;
            }

            Console.WriteLine("Usted es: " + type);
        }
    }
}

Probemos nuestro programa.

¡Un ejercicio más para que quede claro!

Ejercicio 3. Cree un programa que permita ingresar una vocal y te devuelva una palabra que empiece por esa vocal.

using System;

namespace switch3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            char vocal;
            string word;

            // Solicitamos al usuario la información
            Console.Write("Ingrese una vocal: ");
            vocal = char.Parse(Console.ReadLine());

            // Recuerda, un char es una letra, vocal o signo que se representa con comillas simples
            // Ejemplo: 'A', '+', 'd'
            // Un texto se representa con comillas dobles
            // Ejemplo: "Hola", "Amarillo", "Carro rojo".

            // Evaluamos el char ingresado.
            // Convertimos a mayúscula para hacer la validación más simple.
            switch(char.ToUpper(vocal)) 
            {
                case 'A':
                word = "Avión";
                break;
                case 'E':
                word = "Elefante";
                break;
                case 'I':
                word = "Iglesia";
                break;
                case 'O':
                word = "Octubre";
                break;
                case 'U':
                word = "Universidad";
                break;
                default:
                word = "Ingrese una vocal válida.";
                break;
            }

            Console.WriteLine("Palabra con la vocal ingresada: " + word);
        }
    }
}

Probemos nuestro programa.

Espero que con todos esos ejercicios haya quedado claro, ¡ahora te toca a ti!

Ejercicio 4. Cree un programa que permita ingresar una de las estaciones del año y te devuelva el rango de fechas de su duración (de tu país). Validar que ingrese una estación válida.

Ejercicio 5. Cree un programa que te permita ingresar un número en romanos y te devuelva su valor en números enteros. Solo considerara del 1 al 20.

Ejercicio 6. Crea un programa que te permita ingresar un número de teléfono y te devuelva que tipo de teléfono es, según las siguientes condiciones.

Si tiene 7 dígitos, es fijo local.
Si tiene 9 dígitos es móvil.
Si tiene 9 dígitos y empieza por 99 es móvil – movistar.
Si tiene 9 dígitos y empieza por 98 es móvil – claro.
Si tiene más de 9 dígitos es un número internacional.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional IF en C# [Parte 3 – CONDICIONES MÚLTIPLES]

16 de agosto, 2021 Rodolfo PeñaDeja un comentario

Ya hemos visto que podemos evaluar muchas condiciones con múltiples IF, ya sea de forma anidada o secuencial, ahora veremos como evaluar muchas condiciones en un solo IF, mejorando bastante nuestro código al hacerlo más compacto. Para ello vamos a usar dos expresiones lógicas: «Y» y «O«. ¿Cómo se entiende esto? Sencillo, por ejemplo, si queremos evaluar el rango de edad de una persona, vamos a hacer lo siguiente: Si la edad de Fulano es mayor que 15 y es menor que 20 hacemos algo. O también podemos decir lo siguiente: Si la edad de Fulano es 15 o es 16, entonces hacemos otra cosa. En conclusión, con «Y» y «O» podemos evaluar varias condiciones a la vez.

También debemos tener en cuenta el resultado final de la evaluación, ya que al tener varias condiciones, algunas de estas pueden resultar verdaderas y otras falsas. ¿Qué pasa en ese caso? C# no lo va a reconocer como error, ya que es una lógica programada por el desarrollador, por lo tanto, solo debemos realizar un buen análisis de lo que queremos hacer y aplicarlo. A continuación te voy a dejar una tablita en donde vamos a ver el resultado final de la evaluación de varias condiciones.

Expresión lógica	Condición 1	Condición 2	Condición N	Resultado
Y	V	V	V	V
Y	V	V	F	F
Y	V	F	F	F
Y	F	F	F	F
O	V	V	V	V
O	V	V	F	V
O	V	F	F	V
O	F	F	F	F

V = VERDADERO, F= FALSO

Recuerda que por defecto IF siempre evalúa que la condición sea verdadera, en caso que la condición sea falsa, se va a ir directamente al ELSE, solo si lo hemos programado. También podemos «negar» el IF para que evalúe por defecto que la condición sea falsa, pero esto lo veremos más adelante.

Antes de ir a los ejemplos, vamos a ver como es la sintaxis en C#, donde la «Y» se representa con un símbolo llamado «ampersand (&)», el cual lo puedes obtener en el teclado con shift + 6 o pulsando alt + 38, y la «O» se representa con un símbolo llamado «pleca (|)», el cual lo puedes obtener en el teclado con la tecla que está encima del tab y antes del 1 (al menos en el mío está ahí) o pulsando las teclas alt + 124.

            bool condition1 = true;
            bool condition2 = false;
            bool condition3 = true;

            if (condition1 && condition2 && condition3)
            {
                // Hacemos algo.
            }

            if (condition1 || condition2 || condition3)
            {
                // Hacemos algo.
            }

¿Podemos combinar condiciones, así como las operaciones combinadas? Claro que sí, solo debemos tener en cuenta que la evaluación será de izquierda a derecha y que tomará en cuenta, como prioridad, lo que esté dentro de paréntesis.

            int number = 5;

            if(number > 0 && number <= 10 || number == 4)
            {
                Console.WriteLine("La validación es verdadera.");
                // Recuerda.
                // La primera condición es verdadera.
                // La segunda condición es verdadera.
                // Y según nuestra tablita, si dos condiciones son verdaderas y usamos "Y"
                // Entonces tendremos como resultado final Verdadero.
                // La tercera condición es falsa
                // Según la tablita, si una condición es falsa y la otra es verdadera, y usamos "O"
                // Entonces tendremos como resultado final Verdadero.
                // Por eso se cumple la validación.
            }

            if (number > 0 || (number <= 10 && number == 4))
            {
                Console.WriteLine("La validación es verdadera.");
                // Recuerda.
                // Primero se valida lo que está dentro del paréntesis.
                // La segunda condición es verdadera.
                // La tercera condición es falsa
                // Según la tablida, si una condición es falsa y la otra es verdadera, y usamos "Y"
                // Entonces tendremos como resultado final Falso.
                // La primera condición es verdadera.
                // Según la tablita, si una condición es falsa y la otra es verdadera, y usamos "O"
                // Entonces  tendremos como resultado final verdadero.
                // Por eso se cumple la validación.
            }

He comentado el código para tratar de explicar como funcionan las condiciones múltiples, leer atentamente por favor, y en caso hayan quedado dudas, espero esclarecerlas resolviendo los siguientes ejercicios.

Ejercicio 1. Cree un programa que pida tres números e indique cual es el menor y el mayor.

using System;

namespace CondicionalMultiple
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int numberOne, numberTwo, numberThree;
            int maxValue, minValue;

            // Solicitamos al usuario que ingrese los datos necesarios.
            Console.Write("Ingrese el primer número: ");
            numberOne = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el segundo número: ");
            numberTwo = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el tercer número: ");
            numberThree = int.Parse(Console.ReadLine());

            // Buscamos el número mayor.

            // La lógica es simple.
            // Primero comparamos si el primer número es mayor que el segundo y tercero.
            if (numberOne >= numberTwo && numberOne >= numberThree)
            {
                maxValue = numberOne;
            }
            else
            {
                // Si no se cumple la validación anterior, comparamos el segundo número.
                if (numberTwo >= numberOne && numberTwo >= numberThree)
                {
                    maxValue = numberTwo;
                }
                else
                {
                    // Sino, el número mayor será el tercero.
                    maxValue = numberThree;
                }
            }

            // Para hallar el número menor, hacemos lo mismo, pero cambiamos el signo a menor.
            if (numberOne <= numberTwo && numberOne <= numberThree)
            {
                minValue = numberOne;
            }
            else
            {
                if (numberTwo <= numberOne && numberTwo <= numberThree)
                {
                    minValue = numberTwo;
                }
                else
                {
                    minValue = numberThree;
                }
            }

            Console.WriteLine("El número mayor es: " + maxValue.ToString());
            Console.WriteLine("El número menor es: " + minValue.ToString());

        }
    }
}

Ejecutamos para probar si nuestro programa funciona bien.

Ejercicio 2. Cree un programa que pida los tres lados de un triángulo e indique el tipo de triángulo que es según sus lados: Equilátero, Isósceles o Escaleno.

using System;

namespace CondicionalMultiple2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int sideOne, sideTwo, sideThree;
            string triangleType;

            Console.Write("Ingrese el primer lado del triángulo: ");
            sideOne = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el segundo lado del triángulo: ");
            sideTwo = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el tercer lado del triángulo: ");
            sideThree = int.Parse(Console.ReadLine());

            // Validamos si el triángulo es equilátero, es decir, que todos sus lados son iguales.
            if (sideOne == sideTwo && sideOne == sideThree && sideTwo == sideThree)
            {
                triangleType = "Equilátero";
            }
            else
            {
                // Es isósceles cuando dos de sus lados son iguales.
                if(sideOne == sideTwo || sideOne == sideThree || sideTwo == sideThree)
                {
                    triangleType = "Isósceles";
                }
                else
                {
                    // Por defecto indicamos que es escaleno, ya que los tres lados son diferentes.
                    triangleType = "Escaleno";
                }
            }

            Console.WriteLine("El triángulo es: " + triangleType);
        }
    }
}

Ejecutamos y probamos.

¡Ahora te toca a ti!

Ejercicio 3. Cree un programa que pida un número e indique cuantos dígitos tiene. Considerar como máximo 5 dígitos, si tiene más, mostrar un mensaje cualquiera.

Ejercicio 4. Cree un programa que pida los tres ángulos internos de un triángulo e indique que tipo de triángulo, según sus ángulos internos, es: acutángulo, rectángulo u obtusángulo.

La negación (!)

Como he comentado anteriormente, la condicional IF funciona solamente si el resultado de la condición es verdadero, sino se va para el ELSE. Si queremos que funcione de manera contraria, es decir, que entre al IF cuando el resultado de la condición sea falsa, usaremos la negación, el cual se representa con el signo de admiración (!). Vamos a ver como funciona con un ejemplo.

Ejercicio 5. Cree un programa que solicite un número e indique si es par o impar.

using System;

namespace CondicionalMultiple3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int number;
            string value;

            Console.Write("Ingrese el número a evaluar: ");
            number = int.Parse(Console.ReadLine());

            // Para saber si un número es par o no, usamos el residuo (%).
            // Además, usaremos la negación.
            if (!(number % 2 == 0))
            {
                value = "impar";
            }
            else
            {
                value = "par";
            }

            Console.WriteLine("El número " + number.ToString() + " es " + value);
        }
    }
}

Veamos si funciona correctamente.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional IF en C# [Parte 2 – Anidacion]

12 de agosto, 2021 Rodolfo Peña4 comentarios

Como hemos visto anteriormente, podemos anidar varios IF para crear múltiples caminos y consecuencias. Esto se llama anidación y puede darse de dos maneras: agregando varios IF de manera secuencial, o poniendo un IF dentro de otro. Cualquier forma es válida, lo único que tenemos que tener en cuenta, es tratar de no abusar de ello, de encontrar la mejor forma de no programar muchos caminos dentro de tu programa. Ahora vamos a ver como se ve esto en C#.

            // IF Anidado
            if (true)
            {
                if (true)
                {
                    if (true)
                    {
                        // Hacemos algo
                    }
                }
                else
                {
                    // Hacemos otra cosa
                }
            }
            else
            {
                if (true)
                {
                    // Hacemos algo mejor
                }
                else
                {
                    // O hacemos algo peor
                }
            }

Y como se ve de manera secuencial.

            // IF secuencial

            if (true)
            {
                // Hacemos algo
            }
            else if (true)
            {
                // Hacemos otra cosa
            }
            else if (true)
            {
                // Hacemos algo mejor
            }
            else
            {
                // O no... 
            }

También podemos combinar ambos métodos y hacer cosas increíbles.

Entonces, ¿es buena práctica poner muchos IF’s? Ni si, ni no, todo depende de lo que tengas que programar, si te piden hacer un programa que requiera hacer muchas evaluaciones, no te va a quedar de otra que hacerlo. Lo que si tienes que considerar es que el código se entienda, recuerda que no vas a hacer el único programador que haga mantenimiento a ese programa. Por lo tanto, hay que invertir tiempo en hacer un buen análisis, para que nuestro código quede lo más óptimo posible.

Vamos a los ejercicios que no hay nada más que explicar en la teoría.

Ejercicio 1. Cree un programa que calcule el descuento en las compras de un supermercado. Considerar las siguientes premisas.

Si el producto se compró el día sábado, se debe aplicar el 3% de descuento.
Si el producto se compró el día domingo, se debe aplicar el 5% de descuento.
Si se compró otro día, se debe aplicar el 8% de descuento.
Si el producto es de tipo electrodoméstico, se aplicará 2% más al descuento.
Si el producto es de tipo gamer, se aplicará el 5% más al descuento.
Si el producto es de tipo ferretería, se aplicará el 4% más al descuento.

Solicitar la fecha de compra, el tipo de producto y el valor total de compra. Mostrar el total de descuento, y el valor neto a pagar.

using System;

namespace CondicionalAnidada1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int type;
            DateTime date;
            double productPrice;
            double discount = 0; // Iniciamos en 0 porque será una sumatoria.
            double discountValue;
            double total;

            // Solicitamos al usuario que ingrese los datos correspondientes.
            Console.Write("Ingrese la fecha de compra (dd/mm/yyyy): ");
            // Validamos si el formato es correcto.
            if(DateTime.TryParse(Console.ReadLine(), out date))
            {
                // La validación es correcta.
                // Ahora validamos que día es.
                if ((int)date.DayOfWeek == 6)
                {
                    discount = discount + 3;
                    
                }
                else if((int)date.DayOfWeek == 0) // Domingo es 0 en idioma gringo.
                {
                    discount = discount + 5;
                }
                else
                {
                    discount = discount + 8;
                }
            }
            else
            {
                // Si no es correcta, dejamos un mensaje y terminamos el programa.
                Console.WriteLine("Ingrese una fecha correcta.");
                Environment.Exit(1);
            }

            // Solicitamos el tipo de producto.
            Console.WriteLine("Opciones 1. Electrodoméstico || 2. Gamer || 3. Ferretería ");
            Console.Write("Ingrese el número de opción: ");
            if (int.TryParse(Console.ReadLine(), out type))
            {
                // Validamos que ha ingresado un número correcto.
                // Ahora validaremos si ha ingresado una opción correcta.
                if (type == 1)
                {
                    discount = discount + 2;
                }
                else if (type == 2)
                {
                    discount = discount + 5;
                }
                else if (type == 3)
                {
                    discount = discount + 4;
                }
            }
            else
            {
                Console.WriteLine("Ingrese una opción correcta.");
                Environment.Exit(1);
            }

            Console.Write("Ingrese precio del producto: ");
            // Podriamos valdiar con el tryparse, pero solo lo convertimos ya que no vamos a hacer algo adicional.
            productPrice = double.Parse(Console.ReadLine());

            // Calculamos el valor del descuento.
            discountValue = Math.Round(productPrice * (discount / 100), 2);

            // Calculamos el total, restando el precio del producto con el valor del descuento.
            total = productPrice - discountValue;

            // Realizamos la impresión de nuestros resultados.
            Console.WriteLine("Estimado cliente, el valor final de su producto es el siguiente:");
            Console.WriteLine("Precio:" + productPrice.ToString());
            Console.WriteLine("Descuento (" + discount + "%): " + discountValue.ToString());
            Console.WriteLine("Total: " + total.ToString());


        }   
    }
}

Ejecutamos el código y validamos si todo funciona correctamente.

¿Te funcionó? ¡Felicidades! Vamos por un ejercicio más.

Ejercicio 2. Cree un programa que muestre un mensaje en base a las siguientes condiciones.

Si el promedio final de un alumno es menor o igual que 5, indicar que está «Desaprobado».
Si el promedio final de un alumno es menor o igual que 10, indicar que está «Vacacional».
Si el promedio final de un alumno es menor o igual que 15, indicar que «Requiere mejorar».
Si el promedio final de un alumno es menor o igual que 20, indicar que «Supera las expectativas».
Si el promedio final está fuera del rango de 1 a 20, indicar al usuario que debe ingresar un promedio correcto.

El programa debe pedir el promedio final del alumno, y mostrar su estado.

using System;

namespace CondicionalAnidada2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            double finalProm;
            string state = "Error"; // Inicializamos en vacío.

            // Solicitamos el promedio final del alumno.
            Console.Write("Ingrese el promedio final del alumno: ");
            finalProm = double.Parse(Console.ReadLine());

            // Evaluamos el promedio.
            if (finalProm >= 0)
            {
                if(finalProm <= 5)
                {
                    state = "Desaprobado";
                }
                else
                {
                    if(finalProm <= 10)
                    {
                        state = "Vacacional";
                    }
                    else
                    {
                        if(finalProm <= 15)
                        {
                            state = "Requiere mejorar";
                        }
                        else
                        {
                            if(finalProm <= 20)
                            {
                                state = "Supera las expectativas";
                            }
                            else
                            {
                                Console.WriteLine("Ingrese un promedio correcto.");
                            }
                        }
                    }
                }
            }
            else
            {
                Console.WriteLine("Ingrese un promedio correcto.");
            }

            Console.WriteLine("El estado del alumno es: " + state);
        }
    }
}

El ejercicio se puede resolver de muchas formas, pero he decidido usar IF anidado. Ahora ejecutamos para ver si funciona.

Si no tuviste ningún problema, ¡perfecto! Ahora te toca a ti.

Ejercicio 3. Cree un programa que pida como opciones calcular el área de un cuadrado, de un círculo, de un triángulo y de un trapecio. Luego que pida los datos correspondientes por opción. Validar de que ingrese una opción correcta.

Ejercicio 4. Cree un programa que asigne el número de asiento de un avión, según el tipo de ticket. Ticket turista (Asientos entre 1 al 20), Ticket económico (Asientos entre 21 al 40), Ticket general (Asientos entre 41 al 50) , Ticket business (asientos entre el 51 y 60). Además, por cada clase, el pasajero puede elegir un tipo de menú. Ticket turista (1 tipo de menú), Ticket económico (2 tipos de menú), Ticket general (3 tipos de menú), Ticket business (4 tipos de menú). El programa debe imprimir el número de asiento y el menú elegido por el pasajero.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional IF En C# [Parte 1]

9 de agosto, 2021 Rodolfo Peña5 comentarios

Las condicionales son partes importantes de nuestro programa, gracias a ellos podemos hacer programas inteligentes, complejos y útiles. En esta clase vamos a aprender los conceptos básicos de una condicional y como usarlos dentro de nuestros programas.

¿Qué es una condición? En nuestras vidas siempre tomamos decisiones, desde que despertamos hasta que nos volvemos a dormir por las noches. Nos preguntamos que ropa nos vamos a poner, que vamos a desayunar, que transporte vamos a elegir para llegar al trabajo y un montón de cosas más. Todas esas decisiones nos llevan por muchos caminos diferentes, y por lo tanto, nos traen consecuencias distintas de las otras opciones que podríamos haber elegido. Si tomo el bus de la ruta C, ¿llegaré temprano al trabajo? Probablemente. Si uso traje para la entrevista de trabajo, ¿me aceptarán? No lo sabemos. Lo que si sabemos, es que siempre tomamos una decisión en base a una condición, ¿qué pasa si hago esto? ¿Qué pasa si hago lo otro? Y por cada opción que tengamos para decidir, vamos a encontrar una consecuencia distinta.

En programación es igual, nosotros podemos programar muchos caminos y en base a la decisión que se tome, realizaremos algo que se traduce como una consecuencia. Por ejemplo, si tenemos una página web que es solo para mayores de 18 años, vamos a tener que preguntar si la persona que está ingresando es mayor de edad. Si es mayor, le dejaremos ingresar a la página web, si es menor, le mostraremos un mensaje de advertencia y no lo dejaremos ingresar a la web.

Para programar esas condiciones se usa la condicional IF, a la cual le vamos a programar una condición y si esa condición es verdadera, el programa ejecutará cierto fragmento de código. Opcionalmente podemos programar un «ELSE», el cual se ejecutará cuando la condición sea falsa.

Traduciéndolo a una oración, vamos a tener algo de este estilo: Si (IF) se cumple esta condición, ejecutaremos este fragmento de código, sino (ELSE), ejecutaremos este otro fragmento de código.

Vamos a ver como es la sintaxis en C#

            if (true)
            {
                // Hacemos algo
            }
            else
            {
                // Hacemos otra cosa
            }

En la siguiente tabla, vamos a ver que tipo de evaluación podemos realizar dentro de C# para las condicionales.

Tipo de Evaluación	Signo
Para evaluar si es igual	==
Para evaluar si es diferente	!=
Para evaluar si es mayor	>
Para evaluar si es mayor o igual	>=
Para evaluar si es menor	<
Para evaluar si es menor o igual	<=

Para comprender mejor, vamos a resolver algunos ejercicios.

Ejercicio 1. Cree un programa que permita saber, en base a la nota final del curso de un alumno, si ha aprobado o ha desaprobado. Si la nota es mayor que 5, el alumno ha aprobado, en caso contrario, ha desaprobado.

using System;

namespace CondicionaIF1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            double prom;
            const double limit = 5.0;

            // Solicitamos al usuario que ingrese el promedio
            Console.Write("Ingrese el promedio final del curso: ");
            prom = double.Parse(Console.ReadLine());

            // Evaluamos si el prom es mayor que 5
            if (prom > limit)
            {
               // Entonces debemos mostrar el mensaje de que el alumno ha aprobado.
               Console.WriteLine("El alumno ha aprobado.");
            }
            else
            {
                // En caso contrario, mostramos que el alumno ha desaprobado.
                Console.WriteLine("El alumno ha desaprobado.");
            }
        }
    }
}

Ejecutamos nuestro código y validamos si funciona correctamente.

Ejercicio 2. Cree un programa que valide si el número ingresado es par o impar.

using System;

namespace CondicionalIF2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int number;
            const int numberTwo = 2;

            // Solicitamos al usuario que ingrese un número.
            Console.Write("Ingrese un número: ");
            number = int.Parse(Console.ReadLine());

            // Evaluamos el residuo, si es es 0, el número es par.
            if (number % numberTwo == 0)
            {
                Console.WriteLine("El número ingresado es par.");
            }
            else
            {
                // Sino, es impar.
                Console.WriteLine("El número ingresado es impar.");
            }
        }
    }
}

Ejecutamos…

Espero que se haya entendido el concepto y lo fácil que es implementarlo, vamos con ejercicio un poco más difícil.

Ejercicio 3. Cree un programa que valide la edad actual del usuario. Considerar días y meses, y si, en el momento de la evaluación cumple años, imprimir un mensaje con la felicitación.

using System;

namespace CondicionalIF3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            DateTime birthday;
            DateTime currenDate = DateTime.Now;
            int years;

            // Solicitamos la fecha de nacimiento al usuario.
            Console.Write("Ingrese su fecha de nacimiento en formato dd/mm/yyyy: ");
            // Evaluamos que el usuario haya registrado la fecha en formato correcto.
            if (DateTime.TryParse(Console.ReadLine(), out birthday))
            {
                // Recuerda que la función TryParse retorna un valor booleano verdadera, si la conversión (de texto a fecha) se realiza de manera correcta.
                Console.WriteLine("Fecha correcta.");
            }
            else
            {
                // En esta parte podríamos poner un mensaje de que la fecha es incorrecta, o terminar el programa, pero, por el momento, lo obviaremos.
            }
            

            // Para saber la edad actual de una persona, debemos restar el año de nacimiento con el año actual.
            years = currenDate.Year - birthday.Year;

            // Sin embargo, debemos tener en cuenta los meses, porque es probable que aún no haya cumplido el último año.
            // Vamos a evaluar si el mes de nacimiento es mayor o igual que el mes actual.
            if(birthday.Month >= currenDate.Month)
            {
                // En caso la condición sea verdadera, debemos restarle un año a la edad, ya que aún no cumple el último año.
                years--;
                // Con los dos menos (--) le quitamos una unidad a un número.

                // Ahora debemos evaluar si el mes de nacimiento es igual al mes actual.
                // Si la condición es verdadera, entonces debemos evaluar los días.
                if (birthday.Month == currenDate.Month)
                {
                    // Ahora tenemos que evaluar los días.

                    // Si el día de nacimiento, es menor o igual al día actual, entonces ya cumplió años.
                    if (birthday.Day <= currenDate.Day)
                    {
                        // Si la condición es verdadera, debemos devolverle una unidad a los años.
                        years++;
                        // Con los dos más (++) le agregamos una unidad a un número.

                        // Nos falta saber si el día actual es su cumpleaños.
                        if (birthday.Day == currenDate.Day)
                        {
                            Console.Write("¡Feliz cumpleaños! ");
                        }
                    }
                }
            }

            // Al final, imprimimos la edad del usuario.
            Console.WriteLine("Tu edad actual es: " + years.ToString());
        }
    }
}

Ejecutamos y validamos todas las condiciones que hemos programado, ¡por que son varias! Y sí, es posible poner una condición dentro de otra condición.

Si te sale igual que a mí, ¡felicidades! Ahora te dejaré algunos ejercicios para que puedas practicar.

Ejercicio 4. Cree un programa que solicite al usuario el lado de un cuadrado. Luego le debe pedir una opción al usuario, si elige 1, le debe mostrar el perímetro del cuadrado, si elige 2, le debe mostrar el área del cuadrado.

Ejercicio 5. Cree un programa que solicite la siguiente información: Nombre, sexo, cantidad de hijos y monto total de compra. En base a esa información, se debe realizar lo siguiente. Si el cliente es hombre y no tiene hijos, le debes aplicar un descuento de 2.5% al monto total de compra. Si tiene 1 a más hijos, debes aplicarle un descuento de 5% al monto de compra. Si es mujer y no tiene hijo, debe aplicarle 10% de descuento, si tiene 1 o 2, debes aplicar 15% de descuento y si tiene 3 a más hijos, debes aplicar el 20% de descuento a la compra. El programa debe imprimir «Señor», «Señorita» o «Señora» respectivamente y su nombre. La mujer es señorita si no tiene hijos. Además debe imprimir el subtotal, el descuento y el monto final de compra.

Ejercicio 6. Cree un programa que pida 3 números. Luego debe imprimir cual número es el mayor, el menor y el del medio.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Variables en C# [Parte 6 – Conversiones]

6 de agosto, 202112 de agosto, 2021 Rodolfo PeñaDeja un comentario

En esta clase vamos a aprender a convertir variables de un tipo de dato a otro, por ejemplo, de numérico a texto o viceversa. Para ello, primero tenemos que entender dos conceptos importantes: las conversiones implícitas y explícitas.

Conversiones implícitas

Esto sucede cuando tratas de realizar una conversión que el sistema (el compilador) reconoce como seguro y sabe que no va a producir excepciones de conversión (errores). Por ejemplo, cuando concatenas (unir, juntar) un número a un texto. Por otro lado, si tratas de hacer lo contrario (asignar un valor de texto a una variable numérica), el sistema lo tomará como un error y no te dejará compilar tu programa. Veamos los siguientes ejemplos.

            // En este ejemplo no va a haber ningún problema.
            // El compilador sabe que un valor numérico no puede provocar una excepción (error).
            string value = "hola " + 1;

            // En este ejemplo si hay error.
            // El compilador no sabe que valor le asignarás a la variable numérica, puede ser un número (como en el ejemplo) o una letra cualquiera.
            // Por lo tanto, te pide que hagas una conversión explícita.
            int valueTwo = "1":

¿Por qué en el segundo ejemplo existe el error? Como comentamos al inicio, las variables son espacios de memoria que serán llenados posteriormente (en tiempo de ejecución) por el usuario o por tu propio programa. Por lo tanto, el compilador no sabe que valor va a tener, es posible que tenga una «a» y cuando trate de convertirlo implícitamente, se genere una excepción (error), por esa razón, te pide que lo hagas explícitamente, es decir, que programes una función que valide cuando ese valor de texto es verdaderamente un número para que pueda realizar la conversión sin ningún tipo de problema.

¿Cuándo usar una conversión implícita? Generalmente se puede usar una conversión implícita cuando desees convertir un valor de cualquier tipo de dato a texto, ya que es poco probable que se genere un error, porque básicamente todo se puede convertir a texto: un número entero, un número decimal, una fecha, una valor booleano, etc.

¿Es buena práctica realizar conversiones implícitas? No. Es bastante probable que se produzcan errores que no hayas controlado, o que se pierda información (si conviertes un decimal a entero, pierdes los decimales, por ejemplo). Por lo tanto, siempre es bueno realizar conversiones explícitas.

Conversiones explícitas

Una conversión es explícita cuando le indicas al sistema (compilador) que quieres realizar una conversión y usas una de las funciones preprogramadas que C# tiene para ti. Por ejemplo, en ejercicios anteriores hemos usado la función «parse», la cual nos permite convertir un valor de texto a numérico.

Para realizar conversiones explícitas debemos tener en cuenta que tipo de datos vamos a convertir, puede ser de texto a número, de fecha a texto, de enteros a decimales, etc. A continuación vamos a ver las combinaciones más importantes.

Convertir int, double, bool, char a texto

Para convertir cualquier variable a texto, lo único que tenemos que hacer es agregar la función «ToString()» al final de cada variable.

            // Para convertir de entero a texto
            int valueInt = 10;
            string valueIntToString = valueInt.ToString();

            // Para convertir de decimal a texto
            double valueDouble = 21.14;
            string valueDoubleToString = valueDouble.ToString();

            // Para convertir de booleano a texto
            bool valueBoolean = true;
            string valueBooleanToString = valueBoolean.ToString();

            // Para convertir de char a texto
            char valueChar = 'A';
            string valueCharToString = valueChar.ToString();

Convertir DateTime a texto

Para convertir una fecha a texto tenemos varias opciones, ya que podemos especificar en que formato queremos que nos muestre la fecha.

            /* Para convertir de fecha a texto */

            DateTime valueDateTime = DateTime.Now;
            
            string valueDateTimeToString = valueDateTime.ToString();
            Console.WriteLine("Salida: " + valueDateTimeToString);
            // Salida: 05/08/2021 13:56:07

            string valueDateTimeToShortDateString = valueDateTime.ToShortDateString();
            Console.WriteLine("Salida: " + valueDateTimeToShortDateString);
            // Salida: 05/08/2021

            string valueDateTimeToLongDateString = valueDateTime.ToLongDateString();
            Console.WriteLine("Salida: " + valueDateTimeToLongDateString);
            // Salida: jueves, 5 de agosto de 2021

            string valueDateTimeToShortTimeString = valueDateTime.ToShortTimeString();
            Console.WriteLine("Salida: " + valueDateTimeToShortTimeString);
            // Salida: 13:56

            string valueDataTimeToLongTimeString = valueDateTime.ToLongTimeString();
            Console.WriteLine("Salida: " + valueDataTimeToLongTimeString);
            // Salida: 13:56:07

            /* Aplicando formato */

            // Obtenemos el día del mes, rango: 1 a 31
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatd = valueDateTime.ToString("%d");
            Console.WriteLine("Salida: " + strFormatd);
            // Salida: 5

            // Obtenemos el día del mes, pero agregando un 0 a los números menores de 10
            string strFormatdd = valueDateTime.ToString("dd");
            Console.WriteLine("Salida: " + strFormatdd);
            // Salida: 05

            // Obtenemos el nombre del día de la semana abreviado
            string strFormatddd = valueDateTime.ToString("ddd");
            Console.WriteLine("Salida: " + strFormatddd);
            // Salida: jue.

            // Obtenemos el nombre del día de la semana
            string strFormatdddd = valueDateTime.ToString("dddd");
            Console.WriteLine("Salida: " + strFormatdddd);
            // Salida: jueves

            // Obtenemos la hora en formato 12 horas
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormath = valueDateTime.ToString("%h");
            Console.WriteLine("Salida: " + strFormath);
            // Salida: 1

            // Obtenemos la hora en formato 12 horas con un cero delante a los números menores que 10
            string strFormathh = valueDateTime.ToString("hh");
            Console.WriteLine("Salida: " + strFormathh);
            // Salida: 01

            // Obtenemos la hora en formato 24 horas
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatH = valueDateTime.ToString("%H");
            Console.WriteLine("Salida: " + strFormatH);
            // Salida: 13

            // Obtenemos la hora en formato 24 horas con un cero delante a los números menores que 10
            string strFormatHH = valueDateTime.ToString("HH");
            Console.WriteLine("Salida: " + strFormatHH);
            // Salida: 13

            // Obtenemos los minutos, rango: 0 a 59
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatm = valueDateTime.ToString("%m");
            Console.WriteLine("Salida: " + strFormatm);
            // Salida: 1

            // Obtenemos los minutos con un cero delante de los números menores que 10
            string strFormatmm = valueDateTime.ToString("mm");
            Console.WriteLine("Salida: " + strFormatmm);
            // Salida: 01

            // Obtenemos el mes, rango: 1 a 12
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatM = valueDateTime.ToString("%M");
            Console.WriteLine("Salida: " + strFormatM);
            // Salida: 8

            // Obtenemos el mes, con un cero delante de los números menores que 10
            string strFormatMM = valueDateTime.ToString("MM");
            Console.WriteLine("Salida: " + strFormatMM);
            // Salida: 08

            // Obtenemos el nombre del mes abreviado
            string strFormatMMM = valueDateTime.ToString("MMM");
            Console.WriteLine("Salida: " + strFormatMMM);
            // Salida: Ago.

            // Obtenemos el nombre del mes
            string strFormatMMMM = valueDateTime.ToString("MMMM");
            Console.WriteLine("Salida: " + strFormatMMMM);
            // Salida: Agosto

            // Obtenemos los segundos, rango: 0 a 59
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormats = valueDateTime.ToString("%s");
            Console.WriteLine("Salida: " + strFormats);
            // Salida: 39

            // Obtenemos lo segundos, con un cero delante de los números menores que 10
            string strFormatss = valueDateTime.ToString("ss");
            Console.WriteLine("Salida: " + strFormatss);
            // Salida: 39

            // Obtenemos el valor AM/PM de la hora (solo la primera letra)
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatt = valueDateTime.ToString("%t");
            Console.WriteLine("Salida: " + strFormatt);
            // Salida: p

            // Obtenemos el valor AM/PM de la hora
            string strFormattt = valueDateTime.ToString("tt");
            Console.WriteLine("Salida: " + strFormattt);
            // Salida: p.m.

            // Obtenemos los dos últimos valores del año
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormaty = valueDateTime.ToString("%y");
            Console.WriteLine("Salida: " + strFormaty);
            // Salida: 21
            
            // Obtenemos los dos últimos valores del año, agregando un cero delante si es de un dígito
            string strFormatyy = valueDateTime.ToString("yy");
            Console.WriteLine("Salida: " + strFormatyy);
            // Salida: 21

            // Obtenemos el año en formato de tres dígitos (sólo si el año es menos que 1000)
            string strFormatyyy = valueDateTime.ToString("yyy");
            Console.WriteLine("Salida: " + strFormatyyy);
            // Salida: 2021

            // Obtenemos el año en formato de cuatro dígitos.
            string strFormatyyyy = valueDateTime.ToString("yyyy");
            Console.WriteLine("Salida: " + strFormatyyyy);
            // Salida: 2021

            // Obtenemos el año en formato de cinco dígitos.
            string strFormatyyyyy = valueDateTime.ToString("yyyyy");
            Console.WriteLine("Salida: " + strFormatyyyyy);
            // Salida: 02021

Tenemos muchos formatos para aplicar, y lo mejor de todo, es que podemos combinarlos.

            DateTime dtDateTimeNow = DateTime.Now;

            Console.WriteLine(dtDateTimeNow.ToString("MMMM yyyy"));
            // Salida: Agosto 2021

            Console.WriteLine(dtDateTimeNow.ToString("dddd dd, MMMM, yyyy"));
            // Salida: jueves 05, agosto, 2021

            Console.WriteLine(dtDateTimeNow.ToString("hh:mm tt"));
            // Salida: 02:16 p.m.

            Console.WriteLine(dtDateTimeNow.ToString("HH:mm"));
            // Salida: 14:16

¿Podemos mostrar los días de la semana o meses en otro idioma? Por su puesto, C# toma el idioma por defecto de nuestro servidor o de la computadora donde está instalado el programa, pero también podemos cambiarlo manualmente de la siguiente manera.

            DateTime dtDateTimeValue = DateTime.Now;

            Console.WriteLine(dtDateTimeValue.ToString("dddd", System.Globalization.CultureInfo.CreateSpecificCulture("en-EN")));
            // Salida: Thursday

            Console.WriteLine(dtDateTimeValue.ToString("MMMM", System.Globalization.CultureInfo.CreateSpecificCulture("en-EN")));
            // Salida: August

Podemos especificar el System.Globalization en la parte inicial, luego del «using», para no escribir toda esa parte del código. Si quieres saber más de los idiomas, te recomiendo leer este artículo: https://docs.microsoft.com/en-us/dotnet/api/system.globalization.cultureinfo.getcultures?view=net-5.0

Convertir double, decimal, float a entero

Para convertir de decimal a entero solo tenemos que usar la función de conversión de la clase «int», pero debemos tener en cuenta que perderemos la información de los decimales. Por ejemplo, si convertimos 19.5 a entero, solo obtendremos 19.

            double valueDouble = 19.9;
            decimal valueDecimal = 13.69590m;
            float valueFloat = 19.42344f;

            int intCastFromDouble = (int)valueDouble;
            int intCastFromDecimal = (int)valueDecimal;
            int intCastFromFloat = (int)valueFloat;

            Console.WriteLine("Double to Integer: " + intCastFromDouble.ToString());
            // Double to Integer: 19
            Console.WriteLine("Decimal to Integer: " + intCastFromDecimal.ToString());
            // Decimal to Integer: 13
            Console.WriteLine("Float to Integer: " + intCastFromFloat.ToString());
            // Float to Integer: 19

Si deseas redondear al entero más cercano, lo más recomendable es usar la función Math.Round, recuerda que lo hemos estudiado dos clases atrás.

double valueDouble = 19.9;
int intRound = (int)Math.Round(valueDouble);
Console.WriteLine("Aplicando redondeo: " + intRound.ToString());
// Aplicando redondeo: 20

Convertir texto a entero

Para convertir un texto (string) a entero, tenemos que usar la función «Parse», la cual ya hemos usado muchas veces. Sin embargo, debemos tener en cuenta que se puede producir un excepción (error) si tratamos de convertir un texto que no sea número. Para evitar esos errores, antes de realizar la conversión, se debe hacer una validación, pero ya hablaremos más a fondo de ese tema más adelante, ya que primero debemos aprender a usar el operador «IF».

            string strValue = "12";
            int intCastStringToInteger = int.Parse(strValue);

Convertir fecha, bool a entero

No es posible, o no tiene mucho sentido, realizar este tipo de conversión.

Convertir entero a decimal

Para convertir de entero a decimal, solo debemos de utilizar la función de conversión de double, decimal o float.

            int intValue = 13;

            double dblValue = (double)intValue;
            decimal decValue = (decimal)intValue;
            float fltValue = (float)intValue;

            Console.WriteLine("De entero a double: " + dblValue.ToString());
            // De entero a double: 13
            Console.WriteLine("De entero a decimal: " + decValue.ToString());
            // "De entero a decimal: 13
            Console.WriteLine("De entero a float: " + fltValue.ToString());
            // De entero a float: 13

A simple vista no se ve ningún cambio, ni se agrega el punto decimal, pero realizar esta conversión nos sirve para asegurar de que en nuestros cálculos se consideren los decimales.

Convertir texto a decimal

Para convertir un texto (string) a decimal, tenemos que usar la función «Parse». Sin embargo, debemos tener en cuenta que se puede producir un excepción (error) si tratamos de convertir un texto que no sea número. Para evitar esos errores, antes de realizar la conversión, se debe hacer una validación, pero ya hablaremos más a fondo de ese tema más adelante, ya que primero debemos aprender a usar el operador «IF».

            string strValue = "3.14151658216";

            double dblCastStringToDouble = double.Parse(strValue);
            decimal decCastStringToDecimal = decimal.Parse(strValue);
            float fltCastStringToDecimal = float.Parse(strValue);

            Console.WriteLine("De texto a double: " + dblCastStringToDouble.ToString());
            // De texto a double: 3.14151658216
            Console.WriteLine("De texto a decimal: " + decCastStringToDecimal.ToString());
            // De texto a decimal: 3.14151658216
            Console.WriteLine("De texto a float: " + fltCastStringToDecimal.ToString());
            // De texto a float: 3.1415167

Convertir fecha, bool a decimal.

No es posible, o no tiene mucho sentido, realizar este tipo de conversión.

Convertir de texto a fecha

En la clase anterior vimos como usar los métodos TryParse y Parse de la clase DateTime, te recomienda darle una revisada.

Convertir entero, decimal, bool a fecha

No es posible, o no tiene mucho sentido, realizar este tipo de conversión.

Para concluir, podemos afirmar que lo ideal es realizar siempre conversiones explícitas, esto evitará que se generen excepciones no controlados (errores), que podamos realizar validaciones correctamente y que garanticemos que la información no se va a perder. Así que a partir de ahora en adelante, solo usaremos conversiones explícitas.

Etiqueta: Microsoft

FOR ascendente y descendente

FOR con iterador diferente

FOR anidado

La negación (!)

Conversiones implícitas

Conversiones explícitas

Convertir int, double, bool, char a texto

Convertir DateTime a texto

Convertir double, decimal, float a entero

Convertir texto a entero

Convertir fecha, bool a entero

Convertir entero a decimal

Convertir texto a decimal

Convertir fecha, bool a decimal.

Convertir de texto a fecha

Convertir entero, decimal, bool a fecha