100 Días de Código en Python — Día 14: Proyecto Higher Lower (Mayor o Menor)

El método del curso para resolver problemas grandes#

flowchart LR
    A[Dividir el problema grande<br/>en problemas pequeños] --> B[Hacer una lista de tareas]
    B --> C[Elegir la tarea más fácil]
    C --> D[Dividirla en comentarios<br/>dentro del código]
    D --> E[Escribir código<br/>bajo los comentarios]
    E --> F[Ejecutar]
    F --> G{¿Funciona?}
    G -- No --> H[Corregir] --> F
    G -- Sí --> I[Tachar la tarea] --> C

"Esta es la verdadera habilidad de los programadores: tomar algo inmensamente complejo, dividirlo en problemas más pequeños y abordarlos del más fácil al más difícil."

Consejo de estudio de cierre del curso: si en algún ejercicio tuviste que mirar la solución, no fallaste. Asegúrate de entenderla y luego agenda en tu calendario rehacer ese ejercicio dentro de una semana, sin ayuda.

Prerequisito general: Días 1 a 13. En especial: listas de diccionarios (Día 9), funciones con return (Día 10), while con bandera (Días 6 y 7) y depuración (Día 13).

🎯 Objetivo de aprendizaje#

• Observar un programa terminado y deducir todos los subproblemas que lo componen.

📝 Ejercicio original del curso: juega y haz tu lista#

Enunciado: juega la versión final al menos 10 veces, observando qué pasa cuando aciertas, cuando fallas y qué se repite. Luego escribe tu lista de tareas.

La lista que construye el curso (compárala con la tuya después de hacer la tuya):

1. Mostrar el arte: el logo y el "VS".
2. Generar cuentas al azar a partir de los datos.
3. Dar formato a los datos de la cuenta para mostrarlos.
4. Pedir al usuario que adivine.
5. Verificar si acertó, obteniendo los seguidores de cada cuenta y usando un if.
6. Darle retroalimentación.
7. Llevar el puntaje.
8. Hacer que el juego se repita.
9. Que la cuenta B pase a ser la A en la siguiente ronda.
10. "Limpiar" la pantalla entre rondas.

"Si llegaste hasta aquí y lograste identificar todos los problemas que necesitas resolver, ya puedes considerarte exitoso."

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: ordena tu lista de la tarea más fácil a la más difícil y justifica el orden.
• 🟡 Reto 2: convierte tu lista en un diagrama de flujo.
• 🟠 Reto 3: para la tarea más difícil de tu lista, escribe los comentarios que pondrías en el código (sin código todavía), como recomienda el curso.
• 🔴 Reto 4: juega la versión web original y haz una lista de las diferencias con la versión del curso. ¿Qué funcionalidades agregarías y cuánto trabajo crees que costaría cada una?

📖 Explicación conceptual#

El archivo inicial del curso trae game_data.py, con una variable data: una lista de diccionarios (Día 9). Todos los diccionarios tienen las mismas cuatro claves:

data = [
    {
        "name": "Nombre de la cuenta",
        "follower_count": 215,          # en millones
        "description": "Futbolista",
        "country": "Portugal",
    },
    # ... más cuentas
]

El curso dice, por ejemplo, que Cristiano Ronaldo tenía 215 millones de seguidores "al menos en el momento en que recopilé los datos". Estos datos cambian con el tiempo. Además, los archivos game_data.py y art.py del curso no están incluidos entre los materiales suministrados, así que tendrás que crear tu propio conjunto de datos (ver la nota técnica).

Importar de otros archivos (Días 4 y 7):

from game_data import data
from art import logo, vs
import random

Elegir cuentas al azar:

account_a = random.choice(data)
account_b = random.choice(data)
if account_a == account_b:
    account_b = random.choice(data)

🛠️ Nota técnica (verificada): con if, la cuenta se vuelve a elegir una sola vez, y puede volver a salir repetida. En una simulación con 5 cuentas, alrededor del 4 % de las rondas mostraron la misma cuenta dos veces. Corrección: usar while account_a == account_b:.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: crea un game_data.py propio con al menos 10 elementos de un tema que te interese, con la misma estructura de cuatro claves.
• 🟡 Reto 2: imprime el nombre de todas las cuentas recorriendo la lista con un for.
• 🟠 Reto 3: encuentra, con un bucle y sin usar max, la cuenta con más seguidores de tus datos (Día 5).
• 🔴 Reto 4: ¿qué pasa si dos cuentas tienen exactamente el mismo número de seguidores? Busca si ocurre en tus datos y piensa qué debería hacer el juego (ver la Etapa 4).

📝 Ejercicio original del curso: format_data#

El curso lo resuelve así: primero escribe el código para la cuenta A. Al notar que tendría que repetirlo para la cuenta B, lo convierte en una función con return y docstring:

def format_data(account):
    """Recibe los datos de una cuenta y devuelve un texto listo para imprimir."""
    account_name = account["name"]
    account_descr = account["description"]
    account_country = account["country"]
    return f"{account_name}, {account_descr}, de {account_country}"

Uso: print(f"Compara A: {format_data(account_a)}."), luego print(vs) y después print(f"Contra B: {format_data(account_b)}.").

Lección del curso: "cuando te repites, crea una función". Y no muestres follower_count, porque eso revelaría la respuesta.

⚠️ Errores frecuentes#

• Claves mal escritas: account["Name"] produce KeyError. El curso recomienda copiar y pegar las claves.
• Imprimir dentro de la función: si format_data imprime en lugar de devolver, no se puede usar dentro de una f-string (Día 10).

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: cambia el formato a Nombre (descripción, país).
• 🟡 Reto 2: ajusta el artículo según el país (de Colombia, de Estados Unidos) o evita el problema reformulando la frase.
• 🟠 Reto 3: agrega una clave "categoria" a tus datos y muéstrala con un emoji (⚽ deportes, 🎵 música…) usando un diccionario de emojis.
• 🔴 Reto 4: escribe format_data(account, mostrar_seguidores=False), con un parámetro por defecto, para poder reutilizarla en la pantalla final mostrando los seguidores.

📖 La tabla de decisiones del curso#

La lógica "¿acertó?" depende de dos cosas: qué eligió el usuario y cuál cuenta tiene más seguidores. El curso la dibuja como una tabla de 2 × 2:

De la versión larga a la corta (el curso muestra las dos):

# Versión larga (fácil de perderse)
if a_followers > b_followers and guess == "a":
    return True
elif ...  # cuatro casos

# Versión corta del curso
def check_answer(user_guess, a_followers, b_followers):
    """Recibe la elección del usuario y los seguidores; devuelve True si acertó."""
    if a_followers > b_followers:
        return user_guess == "a"
    else:
        return user_guess == "b"

return user_guess == "a" devuelve directamente el resultado de la comparación: True o False. El curso admite que "es un poco alucinante" y recomienda seguirlo con el depurador.

La entrada se normaliza con .lower() para aceptar tanto A como a.

🛠️ Nota técnica (verificada):

• Empate: si ambas cuentas tienen los mismos seguidores, el else da como correcta solo la B.
• Entrada inválida: si el usuario escribe c, se toma como respuesta incorrecta y el juego termina.

Mejoras: decide una regla justa para los empates (por ejemplo, que ambas respuestas sean correctas) y valida la entrada con el kit del Día 13 (pedir_opcion).

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: escribe las 4 pruebas de la tabla de decisiones y 2 pruebas de empate, llamando check_answer con valores fijos.
• 🟡 Reto 2: implementa una regla para los empates y pruébala.
• 🟠 Reto 3: escribe una versión de check_answer en una sola línea con operadores lógicos. ¿Es más legible o menos?
• 🔴 Reto 4: agrega un modo "difícil" en el que el usuario, además de elegir, debe estimar la diferencia de seguidores. Gana 2 puntos si su estimación está a menos del 20 % del valor real.

📖 Explicación conceptual#

Retroalimentación y puntaje: score = 0 antes del bucle. Si acierta: score += 1 y "¡Correcto! Puntaje actual: X". Si falla: "Lo siento, es incorrecto. Puntaje final: X".

¿Qué parte se repite? El curso lo analiza así: el puntaje inicial no se repite; elegir cuentas, mostrarlas, preguntar y verificar sí se repiten. La bandera game_should_continue = True se vuelve False cuando el usuario falla.

"B pasa a ser A" (la parte más ingeniosa). Jugando a ser el computador (Día 13):

account_b = random.choice(data)     # ANTES del bucle: solo la primera vez

while game_should_continue:
    account_a = account_b           # la B anterior pasa a ser la nueva A
    account_b = random.choice(data) # nueva B
    while account_a == account_b:   # (mejora de esta adaptación)
        account_b = random.choice(data)
    ...

Limpiar la pantalla: justo después de la respuesta del usuario, print("\n" * 20) y volver a imprimir el logo.

⚠️ Errores frecuentes#

• score = 0 dentro del bucle: el puntaje se reinicia en cada ronda. Es el acumulador reiniciado del Día 5.
• Elegir la cuenta A al azar dentro del bucle: se pierde el efecto "B pasa a ser A".
• La primera account_b dentro del bucle: en la primera ronda, account_a = account_b produce NameError.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: muestra en cada ronda el número de ronda además del puntaje.
• 🟡 Reto 2: evita que ninguna cuenta se repita en toda la partida, llevando una lista de cuentas ya usadas.
• 🟠 Reto 3: cuando el usuario falle, muestra los seguidores de A y B para que vea por cuánto se equivocó.
• 🔴 Reto 4: ¿qué pasa si se acaban las cuentas disponibles (Reto 2)? Diseña el final "¡Completaste todas las cuentas!" y pruébalo con un conjunto de datos de solo 4 elementos.

Requisitos funcionales#

1. Logo al inicio y después de cada ronda.
2. Compara A: [cuenta], el arte "VS" y Contra B: [cuenta], sin mostrar los seguidores.
3. Pregunta "¿Quién tiene más seguidores? Escribe 'A' o 'B'", sin importar mayúsculas.
4. Si acierta: puntaje + 1, mensaje y nueva ronda en la que B pasa a ser A.
5. Si falla: mensaje con el puntaje final y fin del juego.

Restricciones técnicas#

Módulos propios (game_data.py, art.py), una lista de diccionarios, funciones con return (format_data, check_answer), un while con bandera y un acumulador.

Pruebas#

(Usa un game_data.py de prueba con valores que controles.)

🧪 Prueba y depuración#

Este código tiene cuatro errores:

score = 0
game_should_continue = True
while game_should_continue:
    account_a = account_b
    account_b = random.choice(data)
    print(f"Compara A: {format_data(account_a)}.")
    print(vs)
    print(f"Contra B: {format_data(account_b)}.")
    guess = input("¿Quién tiene más seguidores? 'A' o 'B': ")
    a_follower_count = account_a["follower_count"]
    b_follower_count = account_b["followers"]
    is_correct = check_answer(guess, a_follower_count, b_follower_count)
    if is_correct:
        score = 1
        print(f"¡Correcto! Puntaje actual: {score}.")
    else:
        print(f"Lo siento, es incorrecto. Puntaje final: {score}.")

(Pistas: una variable que no existe en la primera ronda, un .lower() que falta, una clave equivocada y un acumulador que no acumula. Y aunque no es un error de sintaxis: ¿cuándo termina el juego?)

⭐ Extensión del proyecto#

• Guardar el récord de la sesión y un menú "¿Jugar otra vez?".
• Limpiar la pantalla de verdad con os.system("cls" if os.name == "nt" else "clear").
• Mostrar al final la lista de cuentas en las que acertaste.

Situación#

Reutiliza exactamente el mismo motor del juego, pero con datos de Colombia para repasar Ciencias Sociales, por ejemplo: la población de los departamentos, la altura de montañas o volcanes, o la longitud de los ríos.

Requisitos#

1. Investigar los datos en fuentes oficiales (por ejemplo DANE, IGAC o IDEAM) y citar la fuente y el año en un comentario al inicio de datos_colombia.py.
2. Mantener la estructura de lista de diccionarios, adaptando las claves (por ejemplo, "nombre", "valor", "unidad" y "region").
3. Cambiar solo los textos y los datos: la lógica (check_answer, "B pasa a ser A") no debería cambiar.
4. Al final de cada ronda, mostrar el valor real de ambos elementos, porque el objetivo es aprender.

⚠️ Este tutorial no trae datos listos a propósito: buscar, verificar y citar la información es parte del ejercicio. Usa siempre fuentes oficiales y fechas recientes.

Pregunta de análisis#

¿Cuántas líneas de la lógica tuviste que cambiar? Si fueron muchas, ¿qué podrías haber diseñado mejor en tu versión original?

Mayor o Menor: Edición del Colegio#

Situación problema#

El consejo estudiantil quiere un juego para la semana cultural que ponga a prueba el conocimiento de los estudiantes sobre temas del colegio y de Colombia, con varias categorías y un modo para dos jugadores.

Pregunta orientadora#

¿Cómo construir un programa completo, robusto y extensible combinando todo lo aprendido en el nivel principiante?

Requerimientos#

Etapas de desarrollo (con el método del curso)#

1. Jugar la versión del Día 14 y escribir tu lista de tareas del proyecto integrador.
2. Ordenar las tareas de la más fácil a la más difícil.
3. Para cada tarea: comentarios → código → ejecutar → corregir → tachar.
4. Pruebas finales con una tabla de al menos 12 casos.

Entregables#

• Código en al menos 4 archivos: principal, datos, arte y entradas.py.
• Lista de tareas y diagrama de flujo.
• Tabla de pruebas y bitácora de depuración.
• Demostración en clase y una reflexión escrita: ¿qué aprendiste en los 14 días? ¿Qué concepto necesitas repasar antes del nivel intermedio? (Aplica el consejo del curso: agenda ese repaso en tu calendario.)

Criterios técnicos de funcionamiento#

• Ninguna entrada del usuario detiene el programa.
• Los elementos no se repiten durante una partida y el juego maneja bien el caso en que se agotan.
• En el modo de dos jugadores, los turnos, las vidas y los puntajes se calculan correctamente (verificados con una partida documentada paso a paso).
• No aparece la palabra global y las constantes están en mayúsculas.