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.