Bucle For en C#

 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.

1 2 3 4

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.

1 2 3 4 5 6 7 8 9 10 11

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.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

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.

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

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…

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

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!