Buenas en este artículo vamos a aprender sentencias repetitivas, estas nos sirven para ejecutar un bloque de código cuantas veces lo necesitemos en la lógica.

Contenido Relacionado

Sentencia Para (for)

La sentencia Para casi siempre va a tener esta estructura:

Para (Iniciar un a variable; sentencia condicional; incrementar la variable)
    Bloque de codigo
FinPara

Lo que vamos a tener básicamente es una variable inicial que usualmente es Numérica (int) que se va a comparar con otro número en la sentencia condicional para ver si continúa repitiendo el código o no si es verdadera la sentencia entonces incrementamos el valor inicial ejecuta el código y vuelve directo a la sentencia condicional para repetir el proceso.

en el caso de Pseudocodigo lo vamos a ver un poco diferente mas similar a esto:

Para variable_numerica<-valor_inicial Hasta valor_final Con Paso paso Hacer
	secuencia_de_acciones
Fin Para

Vamos a usar un ejemplo más claro para que vean como funciona.

Algoritmo Sentencias_Repetitivas
	Para inicio<-0 Hasta 10 Con Paso 1 Hacer
		Mostrar inicio
	Fin Para
FinAlgoritmo

Deberíamos tener un resultado como este.

*** Ejecución Iniciada. ***
0
1
2
3
4
5
6
7
8
9
10
*** Ejecución Finalizada. ***

Bien, expliquemos como es que funcionó esto. Para inicio<-0 Hasta 10 Con Paso 1 Hacer, nosotros iniciamos la variable inicio con valor 0 y le decimos que llegue Hasta el valor 10 y la parte que dice Con Paso 1 quiere decir que va a ir sumando solamente 1 por cada vez que vuelva a entrar al bloque de código, por eso es que vemos como incremento la variable inicio del 0 al 10. Si vamos modificando los parámetros se pueden obtener diferentes formas de ejecutar o repetir un bloque de código.

Sentencia Mientras (while)

La sentencias Mientras o while a diferencia de la anterior solo va a iterar o repetir cuando una condición sea verdadera antes de entrar y en la ejecución del bloque de código que tenga dentro es decir antes de ejecutarse la sentencia mientras ya deberíamos tener un valor o una condición que nos permita entrar y una vez se ejecute dentro el bloque de código tiene que ser capaz de modificar ese valor para poder terminar la sentencia Mientas, veamos un ejemplo.

Algoritmo Sentencias_Repetitivas
	esValido<- Verdadero
	Mientras esValido Hacer
		Mostrar "Dentro de la sentencia mientras"
		esValido <- Falso
	Fin Mientras
FinAlgoritmo

Como vemos primero declaramos una variable con valor booleano que es lo que devuelve una sentencia condicional, una vez dentro ejecutamos nuestro código y antes de finalizar cambiamos el valor de nuestra variable a Falso para que pueda salir de esta sentencia, esto se hace por que si no cambiamos el valor la sentencia se va a quedar ejecutando infinitamente llamado bucle infinito. Veamos otro ejemplo.

Algoritmo Sentencias_Repetitivas
	num <- 0
	Mientras num < 10 Hacer
		Mostrar num
                num = num + 1
	Fin Mientras
FinAlgoritmo

Este ejemplo de forma diferente hace algo parecido al primer ejemplo con la sentencia Para solo que mostramos números del 0 al 9 como notamos iniciamos la variable num con valor 0 y al ejecutar la sentencia decimos mientras num sea menor que 10 hacer y dentro de la lógica incrementamos en uno la variable num y así ira incrementando hasta que llegue a 10 es menor que 10 ? como esa sentencia no se va a cumplir ahí es donde termina la sentencia mientras. Al igual que el anterior es importante incrementar o asegurarnos que nuestra lógica va a cambiar las variables para que la sentencia termine para no tener un bucle infinito.

Sentencia Repetir hasta que

Esta sentencia es muy similar a Mientras con la única diferencia la primera vez va a entrar directo a la lógica que tenga dentro y luego va a la sentencia condicional para saber si continúa o no, tiene que ser Verdadera para terminar la sentencia.

	Repetir
		secuencia_de_acciones
	Hasta Que expresion_logica

Como vemos esta sentencia nos permite entrar directamente a la lógica y luego decidir cuando termina.

Veamos el ejemplo de la secuencia de números con esta sentencia.

Algoritmo Sentencias_Repetitivas
	num <- 0
	Repetir
		Mostrar num
		num = num + 1
	Hasta Que num > 10
FinAlgoritmo

Cuando ejecuten verán que tienen el mismo resultado que las sentencias anteriores.

Una variante de ‘Repetir hasta que' es una llamada ‘Repetir mientras' o 'Hacer Mientras‘ básicamente es lo mismo pero para que salga de esta sentencia se necesitaría que en la comparación lógica sea falsa.

Bueno eso fue todo con respecto a las sentencias repetitivas Espero les haya gustado, nos vemos.