Estructuras de control de repetición

Bucles for: sintaxis y casos de uso

El bucle for es una estructura de control que permite repetir un bloque de instrucciones un número específico de veces. En PseInt, su sintaxis es intuitiva y facilita la iteración sobre rangos definidos de valores.

La sintaxis básica en PseInt es:

Para variable <- valor_inicial Hasta valor_final Con Paso incremento Hacer
    // Instrucciones a ejecutar
Fin Para

Donde:

• variable: controla el número de iteraciones.
• valor_inicial: valor inicial de la variable.
• valor_final: valor hasta el cual se ejecutará el bucle.
• incremento: cantidad en que se incrementa la variable en cada iteración (por defecto es 1).

Por ejemplo, para imprimir los números del 1 al 5:

Para i <- 1 Hasta 5 Hacer
    Escribir "Número: ", i
Fin Para

En Python, el equivalente es:

for i in range(1, 6):
    print("Número:", i)

Es importante notar que en Python, la función range excluye el último valor, por lo que se usa 6 para incluir hasta el 5.

Si se desea controlar el incremento, se puede especificar. Para contar de 2 en 2 hasta 10:

Para i <- 0 Hasta 10 Con Paso 2 Hacer
    Escribir "Contando: ", i
Fin Para

En Python:

for i in range(0, 11, 2):
    print("Contando:", i)

El bucle for también permite decrementos utilizando un paso negativo. Por ejemplo, contar desde 5 hasta 1:

Para i <- 5 Hasta 1 Con Paso -1 Hacer
    Escribir "Cuenta regresiva: ", i
Fin Para

En Python:

for i in range(5, 0, -1):
    print("Cuenta regresiva:", i)

Los casos de uso más comunes del bucle for incluyen:

• Recorrer estructuras de datos: aunque en PseInt las estructuras son básicas, se pueden iterar vectores.
• Ejecutar acciones repetitivas: como cálculos o procesos que requieren iteración.

Ejemplo de sumar los elementos de un vector:

Dimension numeros[5] // reserva espacio para un arreglo (o vector) con 5 posiciones
// Asignación de valores al arreglo
numeros[1] <- 3
numeros[2] <- 5
numeros[3] <- 7
numeros[4] <- 9
numeros[5] <- 11

//Inicialización de la variable suma
suma <- 0
//Se recorre el arreglo numeros desde el índice 1 hasta el 5
Para i <- 1 Hasta 5 Hacer
	// Al iterar, se van añadiendo los valores de cada posición
	suma <- suma + numeros[i]
Fin Para

Escribir "La suma total es: ", suma

En Python, utilizando una lista:

numeros = [3, 5, 7, 9, 11]
suma = 0
for i in range(len(numeros)):
    suma += numeros[i]
print("La suma total es:", suma)

O iterando directamente sobre la lista:

numeros = [3, 5, 7, 9, 11]
suma = sum(numeros)
print("La suma total es:", suma)

Otro uso habitual es en bucles anidados para manejar matrices o generar patrones. Por ejemplo, crear una tabla de multiplicar:

Para i <- 1 Hasta 10 Hacer
    Para j <- 1 Hasta 10 Hacer
        Escribir i, " x ", j, " = ", i * j
    Fin Para
Fin Para

En Python:

for i in range(1, 11):
    for j in range(1, 11):
        print(f"{i} x {j} = {i * j}")

El bucle for ofrece un control preciso sobre las iteraciones, siendo esencial cuando se conoce el número exacto de veces que se debe repetir una acción. Su uso adecuado mejora la eficiencia y la legibilidad del código, aspectos fundamentales en el desarrollo de algoritmos.

Bucles while y do-while: diferencias y aplicaciones

Los bucles while y do-while son estructuras de control que permiten repetir un bloque de instrucciones mientras se cumpla una determinada condición. En PseInt, ambos bucles se utilizan cuando el número de iteraciones no está definido previamente.

La sintaxis básica del bucle while en PseInt es:

Mientras condición Hacer
    // Instrucciones a ejecutar
Fin Mientras

Este bucle evalúa la condición antes de cada iteración. Si la condición es verdadera, ejecuta el bloque de instrucciones; si es falsa, sale del bucle.

Por ejemplo, para solicitar números al usuario hasta que ingrese un valor negativo:

Escribir "Introduzca un número (negativo para salir): "
Leer numero
Mientras numero >= 0 Hacer
    Escribir "El número ingresado es: ", numero
    Escribir "Introduzca otro número (negativo para salir): "
    Leer numero
Fin Mientras

En Python, el equivalente sería:

numero = int(input("Introduzca un número (negativo para salir): "))
while numero >= 0:
    print("El número ingresado es:", numero)
    numero = int(input("Introduzca otro número (negativo para salir): "))

Por otro lado, el bucle do-while en PseInt tiene la siguiente sintaxis:

Repetir
    // Instrucciones a ejecutar
Hasta Que condición

En este caso, el bucle ejecuta el bloque de instrucciones y luego evalúa la condición. Esto garantiza que el bloque se ejecute al menos una vez.

Utilizando el mismo ejemplo con do-while:

Repetir
    Escribir "Introduzca un número (negativo para salir): "
    Leer numero
    Si numero >= 0 Entonces
        Escribir "El número ingresado es: ", numero
    Fin Si
Hasta Que numero < 0

En Python, dado que no existe una estructura do-while nativa, se puede emular de la siguiente manera:

while True:
    numero = int(input("Introduzca un número (negativo para salir): "))
    if numero < 0:
        break
    print("El número ingresado es:", numero)

La diferencia principal entre ambos bucles radica en el momento en que se evalúa la condición:

• En el bucle while, la condición se evalúa antes de ejecutar el bloque. Si la condición es falsa desde el inicio, el bloque no se ejecuta.
• En el bucle do-while, la condición se evalúa después de ejecutar el bloque, garantizando al menos una ejecución.

Una aplicación práctica del bucle do-while es en la validación de entradas, donde se necesita solicitar al usuario al menos una vez:

Repetir
    Escribir "Ingrese una contraseña de al menos 6 caracteres: "
    Leer contraseña
Hasta Que Longitud(contraseña) >= 6
Escribir "Contraseña aceptada."

En Python, la validación se puede realizar así:

while True:
    contraseña = input("Ingrese una contraseña de al menos 6 caracteres: ")
    if len(contraseña) >= 6:
        break
print("Contraseña aceptada.")

Es fundamental prestar atención a las condiciones para evitar bucles infinitos. Asegurarse de que las variables dentro del bucle modifiquen la condición es clave para el correcto funcionamiento del programa.

En resumen, elegir entre while y do-while depende de si es necesario que el bloque de instrucciones se ejecute antes o después de evaluar la condición. Comprender esta diferencia es esencial para controlar el flujo de ejecución y garantizar que el programa funcione según lo esperado.

Control de flujo dentro de bucles (break, continue)

En ocasiones, es necesario alterar el flujo normal de un bucle para cumplir ciertos requerimientos en nuestros algoritmos. En PseInt, contamos con las sentencias Salir y Continuar, que permiten modificar el comportamiento de los bucles de manera controlada.

La sentencia Salir se utiliza para interrumpir la ejecución de un bucle antes de que la condición haya finalizado. Al ejecutar Salir, el programa abandona inmediatamente el bucle en el que se encuentra y continúa con las instrucciones siguientes. Esto es útil cuando se detecta una condición que hace innecesario continuar con las iteraciones restantes.

Por ejemplo, supongamos que necesitamos buscar un número específico en una lista y, una vez encontrado, queremos detener la búsqueda. El siguiente código en PseInt ilustra este caso:

Dimension numeros[5]
numeros[1] <- 3
numeros[2] <- 7
numeros[3] <- 5
numeros[4] <- 9
numeros[5] <- 2

objetivo <- 5
encontrado <- Falso

Para i <- 1 Hasta 5 Hacer
    Si numeros[i] = objetivo Entonces
        Escribir "Número encontrado en la posición: ", i
        encontrado <- Verdadero
        Salir
    Fin Si
Fin Para

Si No encontrado Entonces
    Escribir "Número no encontrado en la lista."
Fin Si

En Python, el equivalente sería:

numeros = [3, 7, 5, 9, 2]
objetivo = 5
encontrado = False

for i in range(len(numeros)):
    if numeros[i] == objetivo:
        print("Número encontrado en la posición:", i + 1)
        encontrado = True
        break
if not encontrado:
    print("Número no encontrado en la lista.")

Por otro lado, la sentencia Continuar permite saltar a la siguiente iteración del bucle, omitiendo el resto de instrucciones dentro del ciclo actual. Esta herramienta es útil cuando, bajo ciertas condiciones, deseamos evitar la ejecución de determinadas instrucciones, pero sin abandonar el bucle por completo.

En la versión estándar de PSeInt, no existe una instrucción llamada Continuar (o Continue) equivalente al continue de lenguajes como Python o C. Dado que Continue no está disponible, se puede emular su comportamiento mediante una simple condición que “salte” la parte restante del bucle. Por ejemplo, si solo quieres imprimir números pares, puedes escribir:

Definir i Como Entero

Para i <- 1 Hasta 10 Hacer
	Si (i mod 2) = 0 Entonces
		Escribir "Número par: ", i
	Fin Si
	// Si no es par, simplemente no se hace nada
Fin Para

En Python, esto se representaría así:

for i in range(1, 11):
    if i % 2 != 0:
        continue
    print("Número par:", i)

Es importante utilizar Salir y Continuar con precaución, ya que un uso indiscriminado puede dificultar la comprensión del código y generar complicaciones en el flujo lógico del programa. Sin embargo, cuando se aplican de manera adecuada, estas sentencias pueden mejorar la eficiencia y legibilidad de los algoritmos.

Además, estas sentencias son compatibles con los distintos tipos de bucles existentes. Tanto en bucles Para, Mientras como en Repetir - Hasta Que, podemos emplear Salir y Continuar para controlar el flujo interno según las necesidades específicas de nuestras aplicaciones.