Bucles en Python — ejercicios con FizzBuzz, una inversión que crece, primos y un plan de ahorro (y el break que solo salía de la bandeja)

En un simulacro de FP1 me tocó un ejercicio de buscar: «recorre las bandejas del mostrador y di dónde está el primer croissant de chocolate». Dos bucles, uno dentro de otro, y un break al encontrarlo. Lo entregué tan tranquilo. Al corregirlo, mi programa había encontrado dos «primeros» croissants. El break funcionaba, sí… pero solo sacaba del bucle de la bandeja; el de fuera seguía tan feliz con la siguiente. Lo tienes en «¿Qué falla aquí?», con el arreglo y un dibujo de qué piezas mira cada versión.

Ya tienes la teoría y la práctica de bucles en Python. Ahora te toca a ti: cuatro ejercicios en tres niveles (básico, intermedio y desafío final), tres fragmentos con un fallo escondido, las soluciones comentadas línea a línea y un chuletario para tenerlo todo a mano. Todos los programas usan datos fijos, sin input(), y las salidas que ves son las de su ejecución real.

Cómo usar este artículo

1. Lee el enunciado y la salida esperada, y escribe tu solución en VS Code sin mirar nada más.
2. Si llevas más de 10 minutos atascado, abre la pista (y solo la pista).
3. Compara tu salida con la esperada carácter a carácter: un número de más o de menos suele ser un range mal cerrado.
4. Lee la solución comentada aunque te haya salido bien: muchas veces hay una decisión que no habías pensado.

Nivel básico

Ejercicio 1: FizzBuzz

FizzBuzz es probablemente el ejercicio de programación más famoso del mundo; se usa incluso como filtro en entrevistas de trabajo. Escribe un programa que recorra los números del 1 al 100 y, para cada uno:

• si es divisible por 3 y por 5, escriba FizzBuzz;
• si solo es divisible por 3, Fizz;
• si solo es divisible por 5, Buzz;
• si no, el propio número.

Para que la salida no ocupe 100 líneas, escribe los resultados separados por espacios y salta de línea cada 10 números. Salida esperada:

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 
11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz 
Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 
31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 
41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz 
Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 
61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 
71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz 
Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 
91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz 

Ejercicio 2: Calculadora de interés compuesto

Con el bote de la cafetería se han juntado 1.000 € y se meten en una cuenta al 5 % anual durante 5 años. Con interés compuesto, cada año los intereses se suman al capital y al año siguiente también generan intereses: capital = capital × (1 + interés / 100). Escribe un programa que muestre el capital al final de cada año (redondeado a 2 decimales) con lo que se ha ganado ese año, y al final el capital, el total ganado y la rentabilidad en porcentaje. Salida esperada:

--- Evolución de la inversión ---
Año 1: 1050.00 € (+50.00 €)
Año 2: 1102.50 € (+52.50 €)
Año 3: 1157.62 € (+55.12 €)
Año 4: 1215.50 € (+57.88 €)
Año 5: 1276.28 € (+60.78 €)
Capital final: 1276.28 €
Total ganado: 276.28 €
Rentabilidad: 27.63 %

Nivel intermedio

Ejercicio 3: Generador de números primos

Un número es primo si solo es divisible por 1 y por sí mismo. Escribe un programa que encuentre todos los primos del 2 al 30, los muestre en una línea, diga cuántos hay y cuente cuántas divisiones (%) ha tenido que hacer en total. Salida esperada:

Primos hasta 30: 2 3 5 7 11 13 17 19 23 29 
Total: 10 primos
Divisiones hechas: 45

Desafío final

Ejercicio 4: Simulador de ahorro mensual

La cafetería quiere una cafetera nueva de 10.000 €. Cada mes se ahorran 300 € en una cuenta al 4 % anual. Cada mes, primero se ingresan los 300 € y después se aplica el interés mensual (el anual entre 12), redondeando el saldo a 2 decimales. ¿Cuántos meses hacen falta para llegar al objetivo? Muestra el saldo de los meses del tercer año en adelante (a partir del 25) hasta el mes en que se alcanza, el tiempo en años y meses, lo ahorrado, lo aportado y los intereses. Y si el ahorro mensual fuera 0 o negativo, el programa tiene que avisar en lugar de quedarse colgado. Salida esperada:

Mes 25: 7833.84 €
Mes 26: 8160.95 €
Mes 27: 8489.15 €
Mes 28: 8818.45 €
Mes 29: 9148.84 €
Mes 30: 9480.34 €
Mes 31: 9812.94 €
Mes 32: 10146.65 €
Objetivo alcanzado en 32 meses (2 años y 8 meses)
Ahorrado: 10146.65 € | aportado: 9600.00 €
Intereses: 546.65 €

¿Qué falla aquí?

Tres fragmentos cortos, cada uno con un fallo típico de bucles. Antes de leer la explicación, predice qué imprimen.

Fragmento 1: los días que no cuadran

Queremos sumar las ventas de los días 1 a 10, a 100 € por día:

# Quiero sumar las ventas de los días 1 a 10 (100 € al día)
total = 0
for dia in range(1, 10):
    total += 100
print("Último día sumado:", dia)
print("Total:", total, "€")

¿Qué imprime? Piénsalo antes de seguir.

Salida real:

Último día sumado: 9
Total: 900 €

Faltan 100 €: el día 10 no se ha sumado. range(1, 10) genera del 1 al 9, porque el fin nunca entra. Por eso dia termina valiendo 9 y el total es 9 × 100 = 900.

El arreglo es cambiar el 10 por un 11:

# Arreglado: el fin de range no entra, así que para llegar al 10 hay que poner 11
total = 0
for dia in range(1, 11):
    total += 100
print("Último día sumado:", dia)
print("Total:", total, "€")

Salida:

Último día sumado: 10
Total: 1000 €

Fragmento 2: el primer croissant de chocolate

Este es el de mi anécdota. Las bandejas son textos: cada letra es una pieza (N normal, C chocolate). Queremos el primer croissant de chocolate y parar:

# Busco el PRIMER croissant de chocolate (C) y quiero parar en cuanto lo encuentre
bandejas = ["NNC", "CNC", "NNN"]  # N = normal, C = chocolate
num = 0
for bandeja in bandejas:
    num += 1
    hueco = 0
    for pieza in bandeja:         # un for también recorre un texto, letra a letra
        hueco += 1
        if pieza == "C":
            print(f"Chocolate: bandeja {num}, hueco {hueco}")
            break
print("Búsqueda terminada")

¿Cuántas líneas de «Chocolate» saldrán?

Salida real:

Chocolate: bandeja 1, hueco 3
Chocolate: bandeja 2, hueco 1
Búsqueda terminada

Dos. El break saca del bucle de las piezas (for pieza in bandeja), pero no del de las bandejas: el de fuera da su siguiente vuelta, entra en la bandeja 2 y vuelve a encontrar un chocolate. break solo termina el bucle más interno en el que está. El dibujo compara qué piezas se llegan a mirar con cada versión:

El arreglo: una bandera que el bucle de dentro pone a True y que el de fuera mira después de cada bandeja:

# Arreglado: una bandera avisa al bucle de fuera de que ya hemos terminado
bandejas = ["NNC", "CNC", "NNN"]  # N = normal, C = chocolate
num = 0
encontrado = False
for bandeja in bandejas:
    num += 1
    hueco = 0
    for pieza in bandeja:
        hueco += 1
        if pieza == "C":
            print(f"Chocolate: bandeja {num}, hueco {hueco}")
            encontrado = True
            break                 # sale del bucle de las piezas...
    if encontrado:
        break                     # ...y este, del de las bandejas
print("Búsqueda terminada")

Salida:

Chocolate: bandeja 1, hueco 3
Búsqueda terminada

Fragmento 3: el total que se olvida

Sumar los tickets de la mañana:

# Sumar los tickets de la mañana
tickets = [3.50, 1.20, 4.80]
for ticket in tickets:
    total = 0
    total += ticket
print(f"Total: {total:.2f} €")

¿Cuánto da el total?

Salida real:

Total: 4.80 €

4,80 €: solo el último ticket. total = 0 está dentro del bucle, así que en cada vuelta se reinicia antes de sumar. Al final de la vuelta 3, total vale 0 + 4,80. Lo que se había sumado en las vueltas 1 y 2 se ha perdido.

# Arreglado: el acumulador se crea UNA vez, antes del bucle
tickets = [3.50, 1.20, 4.80]
total = 0
for ticket in tickets:
    total += ticket
print(f"Total: {total:.2f} €")

Salida:

Total: 9.50 €

Comprobación: 3,50 + 1,20 + 4,80 = 9,50 €.

Soluciones comentadas

Solución del ejercicio 1: FizzBuzz

# Nivel básico · Ejercicio 1: FizzBuzz del 1 al 100, diez por línea
for i in range(1, 101):           # 101 para que el 100 entre
    if i % 3 == 0 and i % 5 == 0: # PRIMERO el caso doble: si no, el 15 se quedaría en "Fizz"
        texto = "FizzBuzz"
    elif i % 3 == 0:
        texto = "Fizz"
    elif i % 5 == 0:
        texto = "Buzz"
    else:
        texto = str(i)            # el número tal cual, como texto
    print(texto, end=" ")         # todo en la misma línea...
    if i % 10 == 0:
        print()                   # ...hasta llegar a un múltiplo de 10

Por qué está hecho así:

• El orden de las condiciones. El 15 es divisible por 3 y por 5. Si la primera pregunta fuera i % 3 == 0, el 15 entraría ahí, escribiría «Fizz» y los elif de debajo ni se mirarían. Por eso el caso doble va primero. Otra forma equivalente: i % 15 == 0 (divisible por 3 y por 5 es lo mismo que divisible por 15).
• Una variable texto y un solo print. Cada rama solo decide qué texto toca; el print está una vez, al final. Si mañana cambias el formato, lo cambias en un sitio.
• str(i). En las otras ramas texto es un texto; así las cuatro ramas dejan el mismo tipo en la variable.
• El salto de línea. end=" " mantiene todo en la misma línea, y if i % 10 == 0: print() salta en el 10, el 20… El print() vacío solo imprime el salto.

Comprobación de la primera línea: 3 y 6 y 9 → Fizz; 5 y 10 → Buzz; el resto, números. En la segunda línea, el 15 → FizzBuzz.

Solución del ejercicio 2: Interés compuesto

# Nivel básico · Ejercicio 2: interés compuesto año a año
capital_inicial = 1000.0
interes = 5.0                     # % anual
años = 5

capital = capital_inicial         # el capital que va creciendo (el inicial no se toca)
print("--- Evolución de la inversión ---")
for año in range(1, años + 1):    # sabemos cuántos años: for
    anterior = capital            # se guarda ANTES de actualizar, para la ganancia del año
    capital = round(capital * (1 + interes / 100), 2)
    ganancia = round(capital - anterior, 2)
    print(f"Año {año}: {capital:.2f} € (+{ganancia:.2f} €)")

total = round(capital - capital_inicial, 2)
print(f"Capital final: {capital:.2f} €")
print(f"Total ganado: {total:.2f} €")
print(f"Rentabilidad: {total / capital_inicial * 100:.2f} %")

Por qué está hecho así:

• for y no while: sabemos que son 5 años.
• capital y capital_inicial separados: capital va cambiando, pero al final necesitamos el inicial para calcular lo ganado y la rentabilidad.
• anterior se guarda al principio de la vuelta: después de capital = … el valor viejo ya no existe. Sin anterior, no podríamos saber cuánto se ganó ese año.
• round(…, 2) en cada año, como haría un banco: el siguiente año calcula sobre el capital ya redondeado.

Traza vuelta a vuelta:

¿Por qué el año 3 se redondea a 1157,62 y no a 1157,63? Porque 1157,625 no se puede guardar exacto en un float: en memoria es algo como 1157,62499999…, y round lo redondea hacia abajo. Es el mismo problema de los floats que vimos en variables y tipos de datos. La rentabilidad: 276,28 / 1000 × 100 = 27,63 %.

Solución del ejercicio 3: Números primos

# Nivel intermedio · Ejercicio 3: números primos hasta n
n = 30
primos = []
comprobaciones = 0                # cuántas divisiones hace en total

for numero in range(2, n + 1):    # bucle exterior: cada candidato
    es_primo = True               # inocente hasta que se demuestre lo contrario
    for divisor in range(2, int(numero ** 0.5) + 1):   # basta con llegar a la raíz
        comprobaciones += 1
        if numero % divisor == 0:
            es_primo = False
            break                 # ya hay un divisor: no hace falta seguir con ESTE número
    if es_primo:
        primos.append(numero)

texto = ""
for p in primos:
    texto += str(p) + " "
print(f"Primos hasta {n}: {texto}")
print(f"Total: {len(primos)} primos")
print(f"Divisiones hechas: {comprobaciones}")

Por qué está hecho así:

• La bandera es_primo se pone a True al principio de cada vuelta de fuera. Cada candidato empieza «inocente». Si la pusieras antes del bucle de fuera, en cuanto un número no fuera primo (el 4), todos los demás quedarían marcados como no primos.
• El break corta el bucle de los divisores en cuanto aparece uno: el 30 ya se sabe que no es primo al dividir entre 2, no hace falta probar 3, 4 y 5. Por eso hay 45 divisiones y no muchas más.
• Hasta la raíz cuadrada: si un número tiene un divisor mayor que su raíz, también tiene uno menor (por ejemplo, 28 = 2 × 14), y ese ya lo habríamos encontrado. int(numero ** 0.5) + 1 es el + 1 de siempre del range.
• Para 2 y 3, el bucle de dentro está vacío (range(2, 2)): no da vueltas, la bandera sigue en True y se dan como primos, que es correcto.

Así se ve dónde actúa el break en cada número:

Zoom a los dos bucles:

for numero in range(2, n + 1):    # bucle exterior: cada candidato
    es_primo = True               # inocente hasta que se demuestre lo contrario
    for divisor in range(2, int(numero ** 0.5) + 1):   # basta con llegar a la raíz
        comprobaciones += 1
        if numero % divisor == 0:
            es_primo = False
            break                 # ya hay un divisor: no hace falta seguir con ESTE número
    if es_primo:
        primos.append(numero)

Solución del ejercicio 4: Simulador de ahorro

# Desafío final · Ejercicio 4: ¿cuántos meses hasta llegar al objetivo?
objetivo = 10000.0
ahorro_mensual = 300.0
interes_anual = 4.0               # %

if ahorro_mensual <= 0:           # con 0 € al mes el while no acabaría nunca
    print("Error: el ahorro mensual tiene que ser mayor que 0")
else:
    interes_mensual = interes_anual / 12 / 100
    balance = 0.0
    mes = 0
    aportado = 0.0
    while balance < objetivo:     # no sabemos cuántos meses: while
        mes += 1
        balance += ahorro_mensual                          # 1.º se ingresa el mes
        balance = round(balance * (1 + interes_mensual), 2) # 2.º se aplica el interés
        aportado += ahorro_mensual
        if mes > 24:              # solo enseñamos los últimos meses
            print(f"Mes {mes}: {balance:.2f} €")

    años = mes // 12
    resto = mes % 12
    print(f"Objetivo alcanzado en {mes} meses ({años} años y {resto} meses)")
    print(f"Ahorrado: {balance:.2f} € | aportado: {aportado:.2f} €")
    print(f"Intereses: {balance - aportado:.2f} €")

Por qué está hecho así:

• El if antes del while: con ahorro_mensual <= 0 el saldo nunca crecería y balance < objetivo sería True para siempre. Se comprueba antes de entrar, no dentro.
• while y no for: no sabemos cuántos meses hacen falta; eso es justo lo que queremos averiguar.
• El orden dentro de la vuelta: primero se ingresa y luego se aplica el interés, como dice el enunciado. Al revés saldría otro número de meses (los 300 € del mes no generarían interés ese mes).
• mes empieza en 0 y se suma al principio de la vuelta: así, al salir del bucle, mes vale exactamente el número de meses que se han simulado.
• if mes > 24 dentro del bucle: decide qué meses se imprimen sin necesidad de guardar el historial.

Zoom al bucle:

while balance < objetivo:     # no sabemos cuántos meses: while
    mes += 1
    balance += ahorro_mensual                          # 1.º se ingresa el mes
    balance = round(balance * (1 + interes_mensual), 2) # 2.º se aplica el interés
    aportado += ahorro_mensual
    if mes > 24:              # solo enseñamos los últimos meses
        print(f"Mes {mes}: {balance:.2f} €")

Comprobación: 32 meses son 32 // 12 = 2 años y 32 % 12 = 8 meses. Aportado: 32 × 300 = 9.600 €. Intereses: 10.146,65 − 9.600 = 546,65 €. En el mes 31 el saldo (9.812,94 €) todavía no llega a 10.000, así que el bucle da una vuelta más; en el 32 lo supera y la condición 10146.65 < 10000.0 ya es False.

Cuestionario tipo examen

Ahora ponte a prueba como en el examen. Los cuestionarios de FP1 son así: 15 preguntas en 20 minutos (16 en 30 en el de Secuencias), casi todas de respuesta única (cada fallo resta un tercio de lo que vale la pregunta) y muchas de «¿qué imprime este código?», con algún hueco, relacionar o verdadero o falso. Aquí tienes 13 preguntas originales sobre bucles. Contesta sin ejecutar nada, pulsa Comprobar y lee la explicación de cada una. Estas preguntas son también el banco del simulacro de teoría de FP1, que las mezclará con las de los demás temas.

x = 0
i = 1
while i < 5:
    x += i
    i += 1
print(x)

for i in range(3):
    for j in range(4):
        print("hola")

for n in range(1, 10):
    if n % 4 == 0:
        break
    print(n, end=" ")

s = 0
for n in range(1, 8):
    if n % 2 == 0:
        continue
    s += n
print(s)

i = 10
while i > 0:
    print(i)
i -= 1

n = 1
while n < 100:
    n = n * 3
print(n)

cuenta = 0
for c in "Gran Canaria":
    if c == "a":
        cuenta += 1
print(cuenta)

mayor = 0
for n in [4, 17, 9, 23, 8]:
    if n > mayor:
        mayor = n
print(mayor)

for n in [3, 7, 11]:
    if n % 2 == 0:
        print("hay un par")
        break
else:
    print("ninguno es par")

Míralo paso a paso en Python Tutor

En pythontutor.com, con Python 3, puedes ver el fallo del fragmento 2 en directo. Pega esta versión corta:

# Para Python Tutor: el break que solo sale del bucle de dentro
bandejas = ["NNC", "CNC", "NNN"]
num = 0
for bandeja in bandejas:
    num += 1
    hueco = 0
    for pieza in bandeja:
        hueco += 1
        if pieza == "C":
            print(num, hueco)
            break
print("fin")

Salida:

1 3
2 1
fin

Qué observar paso a paso:

1. En la primera bandeja, pieza va tomando «N», «N» y «C»: un for sobre un texto recorre sus letras.
2. Cuando pieza vale «C», se imprime 1 3 y la flecha salta del break a la línea del for bandeja de fuera, no al print("fin").
3. num pasa a 2 y hueco vuelve a 0: el bucle de fuera sigue como si nada.
4. En la bandeja 2 el chocolate está en el primer hueco: segundo print (2 1) y segundo break.
5. La bandeja 3 se recorre entera (no hay «C») y por fin se imprime fin. Ahora prueba la versión con bandera y mira cómo la flecha sale de los dos bucles.

Chuletario: Bucles en Python

Lo esencial en 30 segundos: for cuando sabes cuántas vueltas habrá (recorre una secuencia o un range); while cuando no lo sabes (repite mientras la condición sea True, y algo dentro tiene que hacerla falsa). range nunca incluye el fin. break sale del bucle (solo del más interno); continue salta al siguiente elemento. Los acumuladores se preparan antes del bucle.

Plantillas de los ejercicios:

• FizzBuzz: for i in range(1, 101): + if i % 3 == 0 and i % 5 == 0: primero → 10 líneas de 10.
• Interés compuesto: anterior = capital → capital = round(capital * (1 + interes / 100), 2) → 1276.28 € en 5 años.
• Primos: bandera es_primo = True por candidato + for divisor in range(2, int(n ** 0.5) + 1) + break → 10 primos hasta 30, 45 divisiones.
• Ahorro: if ahorro <= 0 antes + while balance < objetivo: + mes // 12 y mes % 12 → 32 meses.

Antes de entregar, pregúntate:

1. ¿Sé cuántas vueltas da cada bucle? ¿He elegido for o while por eso?
2. En cada while, ¿qué línea acerca la condición a False, y se ejecuta en todas las vueltas?
3. ¿Los range llegan exactamente hasta donde quiero (el fin no entra)?
4. ¿Mis acumuladores se inicializan antes del bucle y con el valor correcto (0, 1 o "")?

Si te ha quedado alguna duda, vuelve a la teoría de bucles o repasa la práctica. Y si ya lo tienes, el siguiente tema son las funciones en Python: lo que hoy repetimos con bucles, mañana lo guardaremos con nombre propio.

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →