12 min Lógica de Programación

Bucles

Imagina que tienes que comprobar los 30 artículos de tu lista de la compra, uno por uno. O que tienes que enviar un mensaje de cumpleaños a cada uno de tus 50 contactos. No vas a escribir la misma instrucción 50 veces, ¿verdad? Los bucles son la herramienta que permite repetir una acción tantas veces como haga falta, sin repetir código.

En la vida real usas bucles constantemente sin darte cuenta: cepillarte cada diente, revisar cada correo de la bandeja de entrada, probar cada llave del llavero hasta que una abra la puerta. Hoy vas a aprender a expresar esas repeticiones en pseudocódigo.

MIENTRAS: repetir mientras se cumpla una condición

El bucle MIENTRAS es como un vigilante obsesivo: comprueba una condición antes de cada repetición. Si la condición es verdadera, ejecuta las instrucciones. Si es falsa, se detiene.

Ejemplo cotidiano: estás llenando un vaso de agua.

MIENTRAS el vaso NO esté lleno HACER
    seguir echando agua
FIN MIENTRAS

cerrar el grifo

La clave está en que la condición cambia con cada repetición. El vaso se va llenando, y en algún momento "el vaso NO está lleno" deja de ser verdadero, y el bucle se detiene.

Ejemplo: la máquina expendedora da el cambio

Compras una bebida de 1,50 euros y pagas con un billete de 5 euros. La máquina tiene que devolverte 3,50 euros en monedas. Así funciona su lógica:

INICIO
    precio = 1.50
    pago = 5.00
    cambio = pago - precio    // cambio = 3.50

    mostrar "Cambio a devolver: " + cambio + " euros"

    MIENTRAS cambio > 0 HACER
        SI cambio >= 2 ENTONCES
            mostrar "Devuelvo moneda de 2 euros"
            cambio = cambio - 2
        SINO SI cambio >= 1 ENTONCES
            mostrar "Devuelvo moneda de 1 euro"
            cambio = cambio - 1
        SINO SI cambio >= 0.50 ENTONCES
            mostrar "Devuelvo moneda de 50 céntimos"
            cambio = cambio - 0.50
        SINO SI cambio >= 0.20 ENTONCES
            mostrar "Devuelvo moneda de 20 céntimos"
            cambio = cambio - 0.20
        SINO SI cambio >= 0.10 ENTONCES
            mostrar "Devuelvo moneda de 10 céntimos"
            cambio = cambio - 0.10
        FIN SI
    FIN MIENTRAS

    mostrar "Cambio completo. ¡Gracias por su compra!"
FIN

Cada vez que el bucle se repite, el cambio disminuye. Cuando llega a 0, el bucle termina. Así es como funciona una máquina de verdad: siempre da la moneda más grande posible primero.

PARA CADA: recorrer una colección

El bucle PARA CADA es diferente. No comprueba una condición: recorre una lista de elementos, uno por uno, de principio a fin. Es como un camarero que va mesa por mesa tomando nota.

lista_compra = ["leche", "pan", "huevos", "tomates", "queso"]

PARA CADA articulo EN lista_compra HACER
    mostrar "Buscar: " + articulo
    SI articulo encontrado ENTONCES
        meter en el carrito
        marcar como comprado
    SINO
        mostrar articulo + " no disponible"
    FIN SI
FIN PARA CADA

mostrar "¡Compra terminada!"

La diferencia fundamental con MIENTRAS:

MIENTRAS: no sabes cuántas veces se va a repetir. Depende de cuándo se cumpla la condición.
PARA CADA: sabes exactamente cuántas veces: una por cada elemento de la lista.

Ejemplo: el portero de la discoteca

Hay una cola de personas esperando para entrar. El portero comprueba el DNI de cada una:

cola = [
    { nombre: "Ana", edad: 22 },
    { nombre: "Luis", edad: 17 },
    { nombre: "María", edad: 30 },
    { nombre: "Pedro", edad: 15 },
    { nombre: "Carmen", edad: 25 }
]

personas_dentro = 0
personas_rechazadas = 0

PARA CADA persona EN cola HACER
    mostrar "Comprobando DNI de " + persona.nombre + "..."

    SI persona.edad >= 18 ENTONCES
        mostrar persona.nombre + " puede entrar. ¡Bienvenido!"
        personas_dentro = personas_dentro + 1
    SINO
        mostrar persona.nombre + " tiene " + persona.edad + " años. No puede entrar."
        personas_rechazadas = personas_rechazadas + 1
    FIN SI
FIN PARA CADA

mostrar "Resumen: " + personas_dentro + " entraron, " + personas_rechazadas + " rechazados"

Fíjate en las variables personas_dentro y personas_rechazadas. Son contadores: variables que van sumando uno cada vez que se cumple cierta condición dentro del bucle. Los contadores son una herramienta fundamental cuando trabajas con bucles.

Contadores y acumuladores

Dos patrones que vas a usar constantemente:

Contador: cuenta cuántas veces pasa algo. Suma de 1 en 1.
Acumulador: va sumando valores. Puede sumar cantidades diferentes cada vez.

// Ejemplo: calcular el total de una cuenta de restaurante

platos = [
    { nombre: "Ensalada", precio: 8.50 },
    { nombre: "Pasta carbonara", precio: 12.00 },
    { nombre: "Tarta de queso", precio: 6.50 },
    { nombre: "Café", precio: 1.80 },
    { nombre: "Agua", precio: 2.00 }
]

total = 0              // ACUMULADOR: empieza en 0
numero_platos = 0      // CONTADOR: empieza en 0

PARA CADA plato EN platos HACER
    total = total + plato.precio       // Acumula el precio
    numero_platos = numero_platos + 1  // Cuenta cada plato
    mostrar plato.nombre + " ... " + plato.precio + " euros"
FIN PARA CADA

mostrar "----------------------------"
mostrar "Platos pedidos: " + numero_platos
mostrar "Total: " + total + " euros"
mostrar "Propina sugerida (10%): " + total * 0.10 + " euros"

El acumulador total empieza en 0 y va sumando cada precio. El contador numero_platos empieza en 0 y suma 1 por cada plato. Al final del bucle, tienes el resumen completo.

Bucles infinitos: la trampa mortal

Un bucle infinito ocurre cuando la condición del MIENTRAS nunca deja de ser verdadera. Es como poner la alarma del despertador sin pilas: nunca va a sonar, y tú nunca vas a levantarte.

// MAL: ¡bucle infinito! La condición nunca cambia
numero = 1

MIENTRAS numero > 0 HACER
    mostrar numero
    numero = numero + 1    // numero siempre crece, siempre será > 0
FIN MIENTRAS

// Este programa nunca terminaría. Mostraría 1, 2, 3, 4, 5...
// hasta el infinito (o hasta que se quede sin memoria).

Para evitar bucles infinitos, asegúrate siempre de que:

La condición del bucle pueda volverse falsa en algún momento.
Dentro del bucle, algo cambie que afecte a la condición.
No te olvides de actualizar el contador o la variable de control.

Aquí tienes la versión corregida:

// BIEN: el bucle tiene fin
numero = 1

MIENTRAS numero <= 10 HACER
    mostrar numero
    numero = numero + 1
FIN MIENTRAS

// Muestra: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 y se detiene.

REPETIR HASTA: la variante "al revés"

Existe otra forma de bucle que comprueba la condición al final en vez de al principio. Esto garantiza que el bloque se ejecuta al menos una vez. Es como la diferencia entre mirar el menú antes de sentarte (MIENTRAS) y sentarte primero y luego mirar el menú (REPETIR HASTA).

// Un juego de adivinar un número
numero_secreto = 7
intento = 0

REPETIR
    mostrar "Adivina el número (entre 1 y 10):"
    LEER intento

    SI intento < numero_secreto ENTONCES
        mostrar "¡Demasiado bajo!"
    SINO SI intento > numero_secreto ENTONCES
        mostrar "¡Demasiado alto!"
    FIN SI
HASTA QUE intento = numero_secreto

mostrar "¡Correcto! El número era " + numero_secreto

El jugador siempre hace al menos un intento. El bucle se repite HASTA QUE adivine el número. En un MIENTRAS, tendríamos que escribir la lógica de forma diferente para asegurar ese primer intento.

Ejemplo completo: control de inventario

Un almacén necesita revisar su inventario y generar un informe. Combina PARA CADA con contadores y acumuladores:

inventario = [
    { producto: "Camisetas", cantidad: 150, precio: 15.99 },
    { producto: "Pantalones", cantidad: 3, precio: 39.99 },
    { producto: "Zapatillas", cantidad: 0, precio: 59.99 },
    { producto: "Gorras", cantidad: 45, precio: 12.50 },
    { producto: "Bufandas", cantidad: 2, precio: 22.00 },
    { producto: "Calcetines", cantidad: 200, precio: 5.99 }
]

productos_ok = 0
productos_bajo_stock = 0
productos_agotados = 0
valor_total_inventario = 0

mostrar "=== INFORME DE INVENTARIO ==="

PARA CADA item EN inventario HACER
    valor_producto = item.cantidad * item.precio
    valor_total_inventario = valor_total_inventario + valor_producto

    SI item.cantidad = 0 ENTONCES
        mostrar "[AGOTADO] " + item.producto
        productos_agotados = productos_agotados + 1
    SINO SI item.cantidad < 10 ENTONCES
        mostrar "[REPONER] " + item.producto + " - Solo quedan " + item.cantidad
        productos_bajo_stock = productos_bajo_stock + 1
    SINO
        mostrar "[OK] " + item.producto + " - " + item.cantidad + " unidades"
        productos_ok = productos_ok + 1
    FIN SI
FIN PARA CADA

mostrar "=== RESUMEN ==="
mostrar "Productos OK: " + productos_ok
mostrar "Productos a reponer: " + productos_bajo_stock
mostrar "Productos agotados: " + productos_agotados
mostrar "Valor total del inventario: " + valor_total_inventario + " euros"

Resumen

MIENTRAS: repite mientras una condición sea verdadera. Úsalo cuando no sabes cuántas veces necesitas repetir.
PARA CADA: recorre una lista de elementos uno por uno. Úsalo cuando tienes una colección definida.
REPETIR HASTA: ejecuta al menos una vez y luego comprueba la condición.
Contadores: cuentan cuántas veces pasa algo (suman de 1 en 1).
Acumuladores: suman valores variables (precios, puntos, etc.).
Bucles infinitos: asegúrate siempre de que la condición pueda cambiar.

En la siguiente lección aprenderemos sobre funciones: cómo dividir un problema grande en trozos pequeños y reutilizables. Es la diferencia entre un cocinero que improvisa y uno que sigue recetas.

Con papel y bolígrafo, escribe el pseudocódigo para un reproductor de música que hace lo siguiente:

Tienes una lista de canciones. Cada canción tiene un título, un artista y una duración en segundos.
El reproductor recorre TODAS las canciones de la lista usando un bucle PARA CADA.
Para cada canción, muestra: "Reproduciendo: [título] - [artista] ([duración] segundos)".
Usa un acumulador para ir sumando la duración total.
Usa un contador para saber cuántas canciones se han reproducido.
Al terminar, muestra el total de canciones reproducidas y la duración total en formato legible (minutos y segundos). Pista: los minutos son la división entera de los segundos entre 60, y los segundos restantes son el resto de esa división.

Lista de canciones de ejemplo: "Bohemian Rhapsody" (354s), "Hotel California" (390s), "Billie Jean" (294s), "Smells Like Teen Spirit" (301s), "Imagine" (183s).

Pistas

Empieza definiendo la lista de canciones con título, artista y duración. Inicializa duracion_total = 0 y canciones_reproducidas = 0 antes del bucle. Dentro del PARA CADA, suma la duración de cada canción al acumulador y suma 1 al contador. Al final, para convertir segundos a minutos: minutos = duracion_total / 60 (parte entera) y segundos_restantes = duracion_total MÓDULO 60.

Anterior Condicionales

Siguiente Funciones