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

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.

Números Primos – Resolviendo Algoritmos en C#

En el vídeo de hoy, te enseñaré a resolver un ejercicio para crear un programa que nos ayude a identificar un número primo. Primero, realizaremos un pequeño análisis de lo que vamos a hacer, luego pasaremos al código y finalmente realizaremos nuestras pruebas. También resolveremos un segundo ejercicio parecido al primero. Recuerda que puedes apoyarnos con tu suscripción al canal, gracias de antemano.


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.

Números Pares – Resolviendo Algoritmos en C#

En esta serie de videos te estaré enseñando a como resolver algunos ejercicios de programación y algoritmos, en el lenguaje de programación de C#, desde los más sencillos hasta los más complejos. ¡Suscríbete!


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.

Arreglos Multidimensionales en C#

En la clase anterior conocimos a los arreglos y definimos a estos como una lista en donde podemos guardar información. Aquellos arreglos también se llaman arreglos unidimensionales, porque su composición solo es de una dimensión (o de una sola lista). En palabras más sencillas, podemos crear arreglos más complejos, o arreglos de varias listas, gracias a esta característica. Para entenderlo un poco mejor, voy a dejar unos gráficos para diferencias la dimensión de los arreglos.

Como pueden observar, los arreglos unidimensionales se caracterizan por tener una sola lista, mientras que los otros por tener más. Los arreglos bidimensionales tienen filas y columnas, y se asemejan mucho a una tabla, y finalmente, los arreglos tridimensionales, es lo mismo que el anterior, pero con un arreglo dentro de cada casillero.

¿Se pueden crear arreglos de más dimensiones? Por supuesto, puedes crear arreglos de dimensiones infinitas, ya que C# te permite guardar un arreglo dentro de otro cuantas veces quieras, pero obviamente, eso sería una mala práctica dentro de la programación. Sin embargo, en el ámbito profesional te encontrarás con casos como esos, en donde tendrás que trabajar con mucha información y muchas listas, pero C# te ayudará a lidiar con esos problemas porque posee elementos más avanzados que aprenderemos más adelante.


Arreglos Bidimensionales

Un arreglo bidimensional es la combinación de listas horizontales con listas verticales, a las cuales las llamaremos filas y columnas respectivamente. Para declarar este tipo de arreglo, es necesario definir en primer lugar la cantidad de filas y luego la cantidad de columnas.

// Declaración simple
string[,] hobbies = new string[3, 4];
// Para declarar un arreglo bidimensional, siempre se considera una coma entre los corchetes
// Y para defiinir el tamaño, primero se considera las filas y luego las columnas

¿Y cómo funcionan los índices en este caso? Para ello vamos a revisar el siguiente gráfico.

Al ser un arreglo bidimensional, vamos a tener dos índices, donde la x representará a nuestras filas y la y a nuestras columnas, como ya he explicado más arriba. Por lo tanto, cada item de nuestro arreglo se identificará con (x,y). Para acceder al primer item, lo haremos con (0,0), mientras que para el último, lo haremos con (2,3). Vamos a llenar nuestro arreglo «hobbies» declarado más arriba, con los datos de nuestro gráfico.

hobbies[0, 0] = "Juan";
hobbies[0, 1] = "Leer";
hobbies[0, 2] = "Escribir";
hobbies[0, 3] = "Cantar";

hobbies[1, 0] = "María";
hobbies[1, 1] = "Jugar";
hobbies[1, 2] = "Bailar";
hobbies[1, 3] = "Leer";

hobbies[2, 0] = "Carlos";
hobbies[2, 1] = "Leer";
hobbies[2, 2] = "Nadar";
hobbies[2, 3] = "Correr";

Ahora imprimiremos todos los valores de nuestro arreglo, para ello, necesitaremos la ayuda de dos for, el primero recorrerá las X y el segundo las Y.

for(int x=0; x < 3; x++)
{
    for(int y=0; y < 4; y++)
    {
        Console.Write($"{hobbies[x, y]} ");
    }
    // Aquí haremos un salto de línea para que se vea más ordenado
    Console.WriteLine();
}

Y el resultado sería el siguiente.

Juan Leer Escribir Cantar
María Jugar Bailar Leer
Carlos Leer Nadar Correr

Como siempre, resolveremos un ejercicio para entender mucho mejor a los arreglos bidimensionales.

Ejercicio 1: Diseñe el siguiente arreglo bidimensional y ordene los números del 1 al 25 en forma de espiral.

Este ejercicio, si bien es cierto, parece un poco complejo, pero en realidad es bastante simple. Lo primero que tenemos que saber es como ir «pintando» cada lado del arreglo de manera individual. Por ejemplo, ¿cómo rellenamos de números la parte superior de nuestro arreglo? Para ello tenemos que tener en cuenta los índices y comenzar a jugar con ellos. La parte superior siempre tendrá como índice el x=0, mientras que la Y irá cambiando a medida que recorremos el arreglo con nuestro for. Para la parte inferior de nuestro arreglo, nuestro índice será x = [número total de filas] – 1, y la Y seguirá dependiendo de nuestro for. Si queremos pintar de manera vertical, tendremos que poner los valores al revés, por ejemplo, si queremos pintar la primera columna, el valor de X dependerá del for, mientras que la y=0, porque es la primera columna. Si queremos pintar la última, el valor de y será igual a y = [número total de columnas] – 1. Si queremos pintar de abajo hacia arriba, o de derecha a izquierda, recuerden que podemos poner nuestro for en viceversa. Probablemente toda esta explicación sea un poco confusa, pero lo entenderemos mejor con el ejemplo. Ahora les pondré un gráfico para saber como va a funcionar nuestro código.

Muy bien, si aún no se entiende la solución, vamos a ver como queda en nuestro código.

// Declaramos las variables para definir filas y columnas
// Para este ejercicio lo vamos a dejar en 5 para ambos
// Ya que el arreglo es de 5 x 5
int row = 5;
int column = 5;
// Definimos nuestro arreglo poniendo las filas primero y luego las columnas
int[,] spiral = new int[row, column];
// Definimos el contador, esta variable me ayudará a pintar los casilleros del arreglo
int count = 1;

// Para empezar, vamos a llenar nuestro arreglo de ceros
// Digamos que es una manera de "inicializarlo"

for (int x = 0; x < row; x++)
{
    for(int y = 0; y < column; y++)
    {
        spiral[x, y] = 0;
    }
}

// Ahora comienza los bueno...
// Para resolver este ejercicio, vamos a ir rellenando nuestro arreglo con los números de la manera que nos han pedido
// Primero se empieza por la parte superior, luego por la parte derecha, después la parte inferior, y finalmente la parte izquierda
// Luego tiene que repetirse el proceso a manera de bucle, pero ya no vamos a pintar todo, sino los espacios restantes.
// ¿Cómo identificar los espacios que no están pintados? Fácil, vamos a preguntar con un IF si están en 0.
// ¿Hasta cuando debemos repetir el bucle? Hasta que nuestro contador (count) haya llegado a su límite, que es 25 (o el valor de filas por columas)

// Declaramos nuestra variable que nos ayudará a pintar desde arriba
int top = 0;
// Declaramos nuestra variable que nos ayudará a pintar desde abajo
int bottom = row - 1;
// Declaramos nuestra variable que nos ayudará a pintar desde la derecha
int left = 0;
// Declaramos nuestra variable que nos ayudará a pintar desde la izquierda
int right = column - 1;

// Con el while crearemos el bucle para que este se ejecute hasta que count llegue a su límite.
while (count <= row * column)
{
    // Pintamos la parte superior
    for (int i = 0; i < column; i++)
    {
        // Validamos si el casillero está libre
        if (spiral[top, i] == 0)
        {
            // Las filas se mantienen estáticas y solo cambia el valor de i
            spiral[top, i] = count;
            // Actualizamos el count
            count++;
        }
    }
    // Aumentamos en 1 nuestra variable top para el siguiente bucle
    top++;

    // Pinta la parte derecha
    for (int i = 0; i < row; i++)
    {
        if (spiral[i, right] == 0)
        {
            // Las columnas se mantienen estáticas
            spiral[i, right] = count;
            count++;
        }
    }
    // Reducimos en 1 nuestra variable right para el siguiente bucle
    right--;

    // Pintamos la parte inferior
    // Según el orden del espiral, ahora debemos recorrer en viceversa
    // Declaramos nuestro for descendiente, este empezará desde el número de columnas - 1 y terminará en 0
    for (int i = column - 1; i >= 0; i--)
    {
        if (spiral[bottom, i] == 0)
        {
            // Las filas se mantienen estáticas
            spiral[bottom, i] = count;
            count++;
        }
    }
    // Reducimos en 1 nuestra variable bottom para el siguiente bucle
    bottom--;

    // Pintamos la parte izquierda
    // For descendente porque tenemos que recorrer de abajo hacia arriba
    for (int i = row - 1; i >= 0; i--)
    {
        if (spiral[i, left] == 0)
        {
            // Las columnas se mantienen estáticas
            spiral[i, left] = count;
            count++;
        }
    }
    // Aumentamos en 1 nuestra variable left para el siguiente bucle
    left++;
}

// Al final solo nos queda imprimir el arreglo y mostrarle al usuario
for (int x = 0; x < row; x++)
{
    for (int y = 0; y < column; y++)
    {
        Console.Write($"{spiral[x, y]} ");
    }
    Console.WriteLine();
}

Sí, un poco largo, pero no es tan difícil de entender, sin embargo, este código se puede mejorar, es decir, se puede hacer más legible y reducir muchas líneas para que no se vea tan grande. Eso se puede hacer a través de los métodos de C#, que ya estudiaremos más adelante. Ahora vamos a compilar nuestro código para ver como quedó todo.

1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

A pesar de que nuestro código lo hayamos construido para crear un arreglo de 5 * 5, este funciona para cualquier tamaño que le pongamos a nuestro arreglo, puedes probar cambiando los valores de las variables row y column.


Arreglos Tridimensionales

Si nuestro arreglo bidimensional tenía forma de tabla, este tipo de arreglo tiene forma de un cubo, es decir, ahora tendremos que declarar una variable más (Z) que vendría a ser la profundidad. Ahora vamos a ver como se declara este arreglo en C#.

// Declaración simple
string[,,] students = new string[2, 3, 4];
// Al ser un arreglo tridimenisonal, separamos con dos comas
// El primer valor serían las filas, luego las columnas y finalmente la profundidad

Ahora vamos a imaginar que cada fila es un alumno, cada columna una materia y finalmente la profundidad que vendría a ser la nota de cada materia. Con esos datos vamos a llenar nuestro arreglo.

// Alumnos de 5to
// Alumnos de sección A
students[0, 0, 0] = "Juan";
students[0, 0, 1] = "Marco";
students[0, 0, 2] = "Karen";
students[0, 0, 3] = "Denis";
// Alumnos de sección B
students[0, 1, 0] = "Jhon";
students[0, 1, 1] = "Larry";
students[0, 1, 2] = "Ringo";
students[0, 1, 3] = "Vilma";
// Alumnos de sección C
students[0, 2, 0] = "Gasper";
students[0, 2, 1] = "Jota";
students[0, 2, 2] = "Dina";
students[0, 2, 3] = "Pedro";

// Alumnos de 6to
// Alumnos de sección A
students[1, 0, 0] = "Joan";
students[1, 0, 1] = "Carlos";
students[1, 0, 2] = "Esther";
students[1, 0, 3] = "Vania";
// Alumnos de sección B
students[1, 1, 0] = "Kiara";
students[1, 1, 1] = "Stan";
students[1, 1, 2] = "Steph";
students[1, 1, 3] = "Carl";
// Alumnos de sección C
students[1, 2, 0] = "George";
students[1, 2, 1] = "Ben";
students[1, 2, 2] = "Andy";
students[1, 2, 3] = "Gloria";

El listado de estudiantes lo hemos separados por grado, que vendrían a ser las X o las filas, las secciones que vendrían a ser las Y o las columnas y los nombres que vendría a ser la Z o la profundidad. Finalmente, vamos a ver como recorrer este arreglo para imprimirlo.

for (int x=0; x < 2; x++)
{
    for (int y=0; y < 3; y++)
    {
        for (int z = 0; z < 4; z++)
        {
            Console.Write($"{students[x, y, z]} ");
        }
        Console.WriteLine();
    }
    Console.WriteLine();
}

El resultado sería el siguiente:

Juan Marco Karen Denis
Jhon Larry Ringo Vilma
Gasper Jota Dina Pedro

Joan Carlos Esther Vania
Kiara Stan Steph Carl
George Ben Andy Gloria

Para este tipo de arreglo no vamos a realizar ningún ejercicio, además de que no se me ocurre ninguno (pero me pueden dejar alguno en los comentarios si desean), así que pasaremos directamente a los ejercicios propuestos. Como nota, en el ámbito profesional, nunca he tenido necesidad de usar este tipo de arreglo.


Ejercicio 2: Cree un programa que genere un arreglo bidimensional de 5 * 5 y ordene los números en forma de zig zag.

1 2 6 7 15
3 5 8 14 16
4 9 13 17 22
10 12 18 21 23
11 19 20 24 25

Ejercicio 3: Cree un programa que genere un arreglo bidimensional de 12 * 12 y rellénalo con todos los valores de la tabla de multiplicar del 1 al 12.

Ejercicio 4: Cree un programa que genere un arreglo bidimensional de 3 * 3 y rellénalo de número aleatorios entre el 1 y el 9, pero que estos no se repitan, tampoco deben estar ordenados, como un sudoku.

¡Con eso hemos terminado la clase de hoy!


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.

Arreglos en C#

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!


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.

Bucle While en C#

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!

Bucle FOR descendiente en C# [Parte 2]

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.


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!

Bucle FOR en C# [Parte 1]

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í:

0123
0123
0123
0123
0123
0123
0123
0123

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.

Condicional SWITCH en C#

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.

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.

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

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ógicaCondición 1Condición 2Condición NResultado
YVVVV
YVVFF
YVFFF
YFFFF
OVVVV
OVVFV
OVFFV
OFFFF
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.


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.