La característica común que comparten las estructuras repetitivas que hemos conocido hasta ahora es que el número de repeticiones de cada ciclo es relativamente indeterminado. Como ya estudiamos, en algunas de estas estructuras, dependiendo del cumplimiento de ciertas condiciones, el ciclo puede no repetirse ni una sola vez o puede repetirse muchísimas veces. Sin embargo puede que no sepamos cuántas veces se va a repetir el ciclo una vez que lo iniciemos.
 |
| Usando incrementos sucesivos, podemos lograr repeticiones de código. |
Pero para aquellos casos en los que la cantidad de repeticiones del ciclo sea una cantidad cierta y conocida desde antes de iniciar la repetición, existe la estructura repetitiva desde, cuya sintaxis es la siguiente:
desde variable_de control <- valor_inicial hasta valor_final hacer
sentencias
fin_desde
La estructura desde comienza con un valor inicial de la variable de control y es entonces que se ejecutan las sentencias que forman el cuerpo del ciclo. La variable de control entonces se incrementa en uno automáticamente y, si este nuevo valor no excede al final, se ejecutan de nuevo las acciones. Por lo tanto, las acciones que forman el cuerpo del ciclo se ejecutan para cada valor de la variable de control, desde el valor inicial hasta el valor final, con el incremento de uno en uno.
El incremento de la variable de control siempre es 1, a menos que se indique expresamente lo contrario. De requerir un incremento distinto a uno, lo expresaríamos del siguiente modo:
desde variable_de control <- valor_inicial hasta valor_final incremento <valor> hacer
sentencias
fin_desde
Si el valor inicial de la variable de control es menor que el valor final, los incrementos deben ser positivos, ya que en caso contrario la secuencia de acciones no se ejecutaría. De igual modo, si el valor inicial es mayor que el valor final, el incremento debe ser negativo, es decir, sería un decremento. En este último caso, la estructura desde se representaría de este modo:
desde variable_de control <- valor_inicial hasta valor_final decremento <valor> hacer
sentencias
fin_desde
Mira estos ejemplos:
1. Escribir un programa que muestre todos los números pares que hay entre 1 y 100.
algoritmo Pares
var
entero: num
inicio
desde num <- 1 hasta 100 hacer
si (num mod 2 = 0) entonces
escribir (num)
fin_si
fin_desde
fin
En este ejemplo, usamos la estructura desde para recorrer todos los números entre 1 y 100, aunque sólo escribimos en pantalla los que son pares, es decir, aquellos en los que num mod 2 es igual a 0.
Aquí puedes probar cómo funciona el algoritmo escrito en C#:
2. Escribir un programa que muestre todos los números impares que hay entre 1 y 100
algoritmo Impares
var
entero: num
inicio
desde num <- 1 hasta 100 incremento 2 hacer
escribir (num)
fin_desde
fin
En este caso hemos usado un incremento de 2 para poder mostrar los números impares. Mira el código en C#:
3. Escribir un programa que muestre los números pares que hay entre 1 y 100 en orden descendente
algoritmo Pares_Desc
var
entero: num
inicio
desde num <- 100 hasta 1 decremento 1 hacer
si (num mod 2 = 0) entonces
escribir (num)
fin_si
fin_desde
fin
Para este algoritmo usamos un decremento de modo que los números pares se muestren en orden inverso. Ahora iniciamos nuestro conteo desde el 100 y vamos descendiendo de 1 en 1 hasta terminar en 1.
Este es el programa corriendo en C#:
Como podemos observar, la estructura desde nos sirve muy bien para aquellas situaciones en las que el número de repeticiones que deseamos hacer es cierto y conocido. En cualquiera de estos ejemplos bien podríamos modificar los valores inicial y final para determinar cuántas veces debe repetirse el ciclo. Si bien el número de repeticiones es conocido, también hay maneras de interrumpir la repetición y lograr que el ciclo termine anticipadamente, pero eso lo estudiaremos a fondo en las siguientes lecciones. Por ahora toca practicar esta nueva estructura. ¡Hasta la próxima!
ACTIVIDADES DE APRENDIZAJE
- Escribe un programa que imprima en pantalla las primeras 5 potencias de 2. es decir, 21=2, 22=4, 23=8, etc.
- Modifica el programa anterior para que ahora sea el usuario quien indique qué número servirá como base y cuántas potencias desea mostrar.
- Escribe un programa que escriba en pantalla la tabla de multiplicar de un número dado por el usuario. Por ejemplo, si el usuario introduce un 3, el programa deberá mostrar la tabla del 3:3x1 = 3, 3x2 = 6, 3x3 = 9, etc.
- El factorial de un número n (representado como n!) se define como la multiplicación en secuencia de todos los números que hay entre 1 y n. Por ejemplo, 5! = 5x4x3x2x1, 7! = 7x6x5x4x3x2x1. Escribe un programa que calcule el factorial de un número dado por el usuario.
Enlace: Índice del curso
