Python para pensadores

Taller diseñado con el corazón de un docente y la mente de un programador.

Reto: "Año bisiesto"

¿Qué es un año bisiesto?

Un año bisiesto es un año que tiene 366 días en lugar de los 365 días normales. Este día adicional se añade al final de febrero (29 de febrero) para corregir el desfase entre nuestro calendario (calendario gregoriano) y el año solar.

¿Por qué necesitamos años bisiestos?

La Tierra tarda aproximadamente 365.2422 días en orbitar alrededor del Sol. Sin los años bisiestos, nuestras estaciones se desfasarían aproximadamente 1 día cada 4 años.

Las 4 reglas del pensamiento computacional

1

Descomposición

Dividimos el problema grande en partes más pequeñas y manejables: entrada del usuario, verificación de divisibilidad y mostrar resultados.

2

Reconocimiento de patrones

Identificamos el patrón en los años bisiestos: se repiten cada 4 años, con excepciones cada 100 años y correcciones cada 400 años.

3

Abstracción

Extraemos las reglas esenciales del problema, ignorando detalles irrelevantes. Nos centramos en las condiciones matemáticas de divisibilidad.

4

Algoritmos

Creamos una serie de pasos ordenados para resolver el problema: un algoritmo que cualquiera pueda seguir para determinar si un año es bisiesto.

Algoritmo para verificar año bisiesto

Sigue estos pasos para determinar si un año es bisiesto:

  1. Obtén el año que quieres verificar
  2. Si el año NO es divisible entre 4 → NO es bisiesto
  3. Si el año es divisible entre 4 pero NO es divisible entre 100 → SÍ es bisiesto
  4. Si el año es divisible entre 100 y también es divisible entre 400 → SÍ es bisiesto
  5. Si el año es divisible entre 100 pero NO es divisible entre 400 → NO es bisiesto

¡Pon a prueba tu comprensión!

¿Cuáles de estos años son bisiestos según las reglas?

Solución en Python

Aquí está el código completo para determinar si un año es bisiesto. Lee los comentarios para entender cada paso:

código_bisiesto.py 
# PROGRAMA PARA VERIFICAR SI UN AÑO ES BISIESTO
# Taller educativo para estudiantes de bachillerato

# 1. SOLICITAR ENTRADA DEL USUARIO
# Pedimos al usuario que ingrese un año
print("==========================================")
print("       VERIFICADOR DE AÑO BISIESTO")
print("==========================================")
print("")

# Obtenemos el año del usuario
anio_texto = input("Ingresa un año: ")

# Convertimos el texto a número
# La función int() convierte texto a número entero
anio = int(anio_texto)

print("")
print("------------------------------------------")
print(f"Analizando el año {anio}...")
print("------------------------------------------")
print("")

# 2. VERIFICAR LAS REGLAS DEL AÑO BISIESTO
# REGLA 1: Verificar si es divisible entre 4
# El operador % devuelve el residuo de una división
# Si el residuo es 0, entonces es divisible
es_divisible_entre_4 = (anio % 4 == 0)

# Mostrar resultado del primer paso
if es_divisible_entre_4:
    print(f"✓ El año {anio} SÍ es divisible entre 4")
else:
    print(f"✗ El año {anio} NO es divisible entre 4")

# REGLA 2: Verificar si es divisible entre 100
es_divisible_entre_100 = (anio % 100 == 0)

if es_divisible_entre_100:
    print(f"✓ El año {anio} SÍ es divisible entre 100")
else:
    print(f"✗ El año {anio} NO es divisible entre 100")

# REGLA 3: Verificar si es divisible entre 400
es_divisible_entre_400 = (anio % 400 == 0)

if es_divisible_entre_400:
    print(f"✓ El año {anio} SÍ es divisible entre 400")
else:
    print(f"✗ El año {anio} NO es divisible entre 400")

print("")
print("------------------------------------------")
print("Aplicando las reglas completas...")
print("------------------------------------------")
print("")

# 3. APLICAR TODAS LAS REGLAS JUNTAS
# Primera condición: NO divisible entre 4
if not es_divisible_entre_4:
    print("→ Según la regla 1: NO es divisible entre 4")
    print(f"→ CONCLUSIÓN: El año {anio} NO es bisiesto")
    
# Segunda condición: Divisible entre 4 pero NO entre 100
elif es_divisible_entre_4 and not es_divisible_entre_100:
    print("→ Según la regla 2: Divisible entre 4 pero NO entre 100")
    print(f"→ CONCLUSIÓN: El año {anio} SÍ es bisiesto")
    
# Tercera condición: Divisible entre 100 y también entre 400
elif es_divisible_entre_100 and es_divisible_entre_400:
    print("→ Según la regla 3: Divisible entre 100 y también entre 400")
    print(f"→ CONCLUSIÓN: El año {anio} SÍ es bisiesto")
    
# Cuarta condición: Divisible entre 100 pero NO entre 400
else:
    print("→ Según la regla 4: Divisible entre 100 pero NO entre 400")
    print(f"→ CONCLUSIÓN: El año {anio} NO es bisiesto")

print("")
print("==========================================")
print("           ANÁLISIS COMPLETADO")
print("==========================================")
print("")

# 4. MOSTRAR RESULTADO FINAL
# Esta parte resume todo en un solo mensaje
if (es_divisible_entre_4 and not es_divisible_entre_100) or (es_divisible_entre_100 and es_divisible_entre_400):
    print("★" * 42)
    print(f"★   ¡EL AÑO {anio} SÍ ES BISIESTO!   ★")
    print("★" * 42)
else:
    print("-" * 42)
    print(f"   El año {anio} NO es bisiesto   ")
    print("-" * 42)

print("")
print("Fin del programa. ¡Gracias por participar!")

Prueba el código con cualquier año

Ingresa un año para verificar si es bisiesto:

Ejercicios para practicar

Para consolidar tu aprendizaje, intenta estos ejercicios:

Ejercicio 1: Modificar el código

Cambia el programa para que pregunte al usuario si quiere verificar otro año sin salir del programa.

Ejercicio 2: Rango de años

Modifica el programa para que muestre todos los años bisiestos en un rango específico (ejemplo: entre 2000 y 2050).

Ejercicio 3: Contador de bisiestos

Crea un programa que cuente cuántos años bisiestos hay en el siglo XXI (entre 2001 y 2100).

Preguntas de reflexión

  1. ¿Por qué crees que la regla del 400 es necesaria?
  2. ¿Qué pasaría si no tuviéramos años bisiestos?
  3. ¿Cómo se relaciona este algoritmo con otros problemas de la vida real?