Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Apéndice C: Soluciones a Ejercicios

Este apéndice contiene las soluciones completas y comentadas a los ejercicios presentados a lo largo del libro. Cada solución incluye no solo el código, sino también explicaciones detalladas del razonamiento detrás de cada decisión.

💡 Consejo importante: Intenta resolver los ejercicios por tu cuenta antes de consultar estas soluciones. El aprendizaje real ocurre cuando luchas con los problemas y encuentras tus propias soluciones.

📚 Capítulo 4: Variables y Tipos de Datos

🎯 Ejercicio 1: Creando tu almacén personal

Solución completa:

# ================================
# MI ALMACÉN PERSONAL - SOLUCIÓN COMPLETA
# ================================

# Información básica
nombre = "María González"
edad = 28
altura = 1.68  # metros
te_gusta_programar = True

# Variables adicionales (ejemplos creativos)
ciudad_origen = "Guadalajara"
color_favorito = "azul"
num_hermanos = 2
tiene_mascota = True
nombre_mascota = "Luna"
salario_deseado = 45000.0

# Mostrar información usando f-strings
print("=== MI INFORMACIÓN PERSONAL ===")
print(f"Nombre: {nombre}")
print(f"Edad: {edad} años")
print(f"Altura: {altura} metros")
print(f"¿Me gusta programar?: {'Sí' if te_gusta_programar else 'No'}")
print(f"Ciudad de origen: {ciudad_origen}")
print(f"Color favorito: {color_favorito}")
print(f"Número de hermanos: {num_hermanos}")
print(f"¿Tengo mascota?: {'Sí' if tiene_mascota else 'No'}")
if tiene_mascota:
    print(f"Nombre de mi mascota: {nombre_mascota}")
print(f"Salario deseado: ${salario_deseado:,.2f}")

# Realizar cálculos
print("\n=== CÁLCULOS ===")
# Cálculo 1: Edad en meses
edad_en_meses = edad * 12
print(f"Mi edad en meses: {edad_en_meses} meses")

# Cálculo 2: Altura en centímetros
altura_en_cm = altura * 100
print(f"Mi altura en centímetros: {altura_en_cm:.1f} cm")

# Cálculo 3: Años hasta jubilación (asumiendo jubilación a los 65)
edad_jubilacion = 65
anos_hasta_jubilacion = edad_jubilacion - edad
print(f"Años hasta jubilación: {anos_hasta_jubilacion} años")

# Cálculo 4: Salario anual vs mensual
salario_mensual = salario_deseado / 12
print(f"Salario mensual deseado: ${salario_mensual:.2f}")

# Mostrar tipos de variables
print("\n=== TIPOS DE VARIABLES ===")
print(f'Variable "nombre" es de tipo: {type(nombre).__name__}')
print(f'Variable "edad" es de tipo: {type(edad).__name__}')
print(f'Variable "altura" es de tipo: {type(altura).__name__}')
print(f'Variable "te_gusta_programar" es de tipo: {type(te_gusta_programar).__name__}')
print(f'Variable "ciudad_origen" es de tipo: {type(ciudad_origen).__name__}')
print(f'Variable "num_hermanos" es de tipo: {type(num_hermanos).__name__}')
print(f'Variable "salario_deseado" es de tipo: {type(salario_deseado).__name__}')

Explicación de la solución:

  1. Variables diversas: Incluí variables de diferentes tipos para demostrar la versatilidad
  2. F-strings avanzados: Uso condicionales dentro de f-strings para mostrar texto dinámico
  3. Cálculos variados: Incluyo operaciones que son útiles en la vida real
  4. Formateo de números: Uso :,.2f para formatear el salario con comas y 2 decimales
  5. Uso de __name__: Para mostrar nombres de tipo más limpios

🎯 Ejercicio 2: Calculadora de IMC

Solución completa:

# ================================
# CALCULADORA DE IMC - SOLUCIÓN COMPLETA
# ================================

# Datos de la persona
nombre = "Carlos Mendoza"
peso = 75.5  # en kilogramos
altura = 1.78  # en metros

# Cálculo del IMC
imc = peso / (altura ** 2)

# Determinación de la categoría con lógica detallada
if imc < 18.5:
    categoria = "Bajo peso"
    recomendacion = "Considera consultar a un nutricionista para un plan de alimentación saludable."
    emoji = "🟡"
elif imc < 25:
    categoria = "Peso normal"
    recomendacion = "¡Excelente! Mantén tus hábitos saludables de alimentación y ejercicio."
    emoji = "🟢"
elif imc < 30:
    categoria = "Sobrepeso"
    recomendacion = "Considera incorporar más ejercicio y revisar tu alimentación."
    emoji = "🟠"
else:
    categoria = "Obesidad"
    recomendacion = "Te recomendamos consultar con un profesional de la salud."
    emoji = "🔴"

# Cálculos adicionales
peso_ideal_min = 18.5 * (altura ** 2)
peso_ideal_max = 24.9 * (altura ** 2)

# Mostrar informe completo
print("=== INFORME COMPLETO DE IMC ===")
print(f"Nombre: {nombre}")
print(f"Peso: {peso} kg")
print(f"Altura: {altura} m")
print(f"IMC calculado: {imc:.2f}")
print(f"Categoría: {emoji} {categoria}")
print(f"\nRango de peso ideal para tu altura:")
print(f"  Mínimo: {peso_ideal_min:.1f} kg")
print(f"  Máximo: {peso_ideal_max:.1f} kg")

# Análisis personalizado
if peso < peso_ideal_min:
    diferencia = peso_ideal_min - peso
    print(f"\nPara alcanzar el peso mínimo ideal, necesitarías ganar {diferencia:.1f} kg")
elif peso > peso_ideal_max:
    diferencia = peso - peso_ideal_max
    print(f"\nPara alcanzar el peso máximo ideal, necesitarías perder {diferencia:.1f} kg")
else:
    print(f"\n¡Tu peso está dentro del rango ideal!")

print(f"\nRecomendación: {recomendacion}")

# Información educativa adicional
print("\n=== INFORMACIÓN EDUCATIVA ===")
print("Rangos de IMC:")
print("  < 18.5: Bajo peso")
print("  18.5 - 24.9: Peso normal")
print("  25.0 - 29.9: Sobrepeso")
print("  ≥ 30.0: Obesidad")
print("\nNota: El IMC es una herramienta de orientación. Consulta siempre")
print("con profesionales de la salud para evaluaciones completas.")

Explicación de la solución:

  1. Lógica extendida: Además de calcular el IMC, incluyo recomendaciones personalizadas
  2. Cálculos adicionales: Determino el rango de peso ideal para la altura
  3. Feedback personalizado: El programa da consejos específicos según el resultado
  4. Emojis para claridad: Uso colores emoji para visualizar rápidamente el estado
  5. Información educativa: Incluyo los rangos para que el usuario aprenda

🎯 Ejercicio 3: Conversor de unidades

Solución completa:

# ================================
# CONVERSOR DE UNIDADES - SOLUCIÓN COMPLETA
# ================================

# Distancia en kilómetros
distancia_km = 42.195  # Distancia de un maratón

# Factores de conversión (constantes)
KM_A_METROS = 1000
KM_A_CM = 100000
KM_A_MILLAS = 0.621371
KM_A_PIES = 3280.84
KM_A_YARDAS = 1093.61
KM_A_PULGADAS = 39370.1

# Realizar todas las conversiones
metros = distancia_km * KM_A_METROS
centimetros = distancia_km * KM_A_CM
millas = distancia_km * KM_A_MILLAS
pies = distancia_km * KM_A_PIES
yardas = distancia_km * KM_A_YARDAS
pulgadas = distancia_km * KM_A_PULGADAS

# Mostrar resultados con formato elegante
print("🏃 ========================================")
print("   CONVERSOR DE DISTANCIAS")
print("   (Distancia de un Maratón)")
print("========================================")
print(f"Distancia original: {distancia_km} kilómetros")
print("\n📏 EQUIVALENCIAS:")
print(f"   En metros:      {metros:>12,.2f} m")
print(f"   En centímetros: {centimetros:>12,.0f} cm")
print(f"   En millas:      {millas:>12,.2f} mi")
print(f"   En pies:        {pies:>12,.2f} ft")
print(f"   En yardas:      {yardas:>12,.2f} yd")
print(f"   En pulgadas:    {pulgadas:>12,.0f} in")

# Comparaciones interesantes
print("\n🎯 COMPARACIONES INTERESANTES:")
print(f"   Un maratón equivale a correr {pies/5280:.1f} millas")
print(f"   O caminar aproximadamente {int(metros/0.75)} pasos (75cm por paso)")
print(f"   Es como {centimetros/30.48:.0f} reglas de 30cm puestas en fila")

# Función reutilizable
def convertir_distancia(km, unidad="todas"):
    """Convierte kilómetros a diferentes unidades"""
    conversiones = {
        "metros": km * 1000,
        "centimetros": km * 100000,
        "millas": km * 0.621371,
        "pies": km * 3280.84,
        "yardas": km * 1093.61,
        "pulgadas": km * 39370.1
    }
    
    if unidad == "todas":
        return conversiones
    else:
        return conversiones.get(unidad, "Unidad no reconocida")

# Ejemplo de uso de la función
print("\n🔧 EJEMPLO DE FUNCIÓN REUTILIZABLE:")
distancia_test = 5.0
resultado = convertir_distancia(distancia_test, "millas")
print(f"{distancia_test} km = {resultado:.2f} millas")

Explicación de la solución:

  1. Constantes con nombres claros: Uso variables en mayúsculas para las constantes
  2. Formateo avanzado: Uso >12,.2f para alinear números a la derecha con comas
  3. Contexto real: Uso la distancia de un maratón para hacer el ejemplo más interesante
  4. Comparaciones útiles: Añado equivalencias que ayudan a visualizar la distancia
  5. Función reutilizable: Creo una función que se puede usar en otros proyectos

🗗️ Capítulo 5: Operadores Matemáticos

🎯 Ejercicio 1: Calculadora de nómina

Solución completa:

# ================================
# CALCULADORA DE NÓMINA - SOLUCIÓN COMPLETA
# ================================

# Datos del empleado
nombre_empleado = "Ana Martínez"
salario_base = 15000  # pesos mensuales
horas_extra = 10     # horas trabajadas extra
pago_por_hora_extra = 150  # pesos por hora extra
bono_productividad = 2000   # pesos
bono_puntualidad = 500      # pesos adicional

# Deducciones (porcentajes)
impuesto_renta = 0.10    # 10%
seguro_social = 0.0625   # 6.25%
seguro_medico = 500      # pesos fijos
fondo_pension = 0.04     # 4%

# CÁLCULOS DE INGRESOS
# Calcular pago por horas extra
pago_extra = horas_extra * pago_por_hora_extra

# Calcular ingresos brutos
ingresos_brutos = salario_base + pago_extra + bono_productividad + bono_puntualidad

# CÁLCULOS DE DEDUCCIONES
# Deducciones porcentuales (se calculan sobre salario base + extras)
base_para_porcentajes = salario_base + pago_extra

deduccion_impuesto = base_para_porcentajes * impuesto_renta
deduccion_seguro_social = base_para_porcentajes * seguro_social
deduccion_pension = base_para_porcentajes * fondo_pension

# Total de deducciones
total_deducciones = (deduccion_impuesto + deduccion_seguro_social + 
                    seguro_medico + deduccion_pension)

# Salario neto
salario_neto = ingresos_brutos - total_deducciones

# GENERAR RECIBO DE NÓMINA
print("💰 " + "=" * 50)
print("           RECIBO DE NÓMINA")
print("=" * 52)
print(f"Empleado: {nombre_empleado}")
print(f"Fecha: {__import__('datetime').datetime.now().strftime('%d/%m/%Y')}")
print("\n💵 INGRESOS:")
print(f"   Salario base:        ${salario_base:>10,.2f}")
print(f"   Horas extra ({horas_extra}h):    ${pago_extra:>10,.2f}")
print(f"   Bono productividad:  ${bono_productividad:>10,.2f}")
print(f"   Bono puntualidad:    ${bono_puntualidad:>10,.2f}")
print(f"   {'-' * 35}")
print(f"   TOTAL BRUTO:         ${ingresos_brutos:>10,.2f}")

print("\n📉 DEDUCCIONES:")
print(f"   Impuesto renta (10%): ${deduccion_impuesto:>9,.2f}")
print(f"   Seguro social (6.25%): ${deduccion_seguro_social:>8,.2f}")
print(f"   Seguro médico:       ${seguro_medico:>10,.2f}")
print(f"   Fondo pensión (4%):  ${deduccion_pension:>10,.2f}")
print(f"   {'-' * 35}")
print(f"   TOTAL DEDUCCIONES:   ${total_deducciones:>10,.2f}")

print("\n💰 RESUMEN:")
print(f"   SALARIO NETO:        ${salario_neto:>10,.2f}")

# Análisis adicional
porcentaje_deducciones = (total_deducciones / ingresos_brutos) * 100
print(f"\n📊 ANÁLISIS:")
print(f"   Porcentaje deducido:  {porcentaje_deducciones:>10.1f}%")
print(f"   Efectivo a recibir:   {100 - porcentaje_deducciones:>10.1f}%")

# Proyección anual
salario_anual_neto = salario_neto * 12
print(f"\n📅 PROYECCIÓN ANUAL:")
print(f"   Salario neto anual:  ${salario_anual_neto:>11,.2f}")

print("=" * 52)

Explicación de la solución:

  1. Estructura profesional: El código está organizado en secciones claras
  2. Cálculos precisos: Distingo entre deducciones porcentuales y fijas
  3. Formateo profesional: El recibo se ve como uno real
  4. Análisis adicional: Incluyo porcentajes y proyecciones anuales
  5. Documentación clara: Cada sección está bien comentada

🎯 Ejercicio 2: Distribución de productos

Solución completa:

# ================================
# DISTRIBUCIÓN DE PRODUCTOS - SOLUCIÓN COMPLETA
# ================================

productos_totales = 1847
productos_por_caja = 24
peso_por_caja = 5.5  # kg

# Cálculos principales
cajas_completas = productos_totales // productos_por_caja
productos_sueltos = productos_totales % productos_por_caja
peso_total_cajas = cajas_completas * peso_por_caja

# Cálculos adicionales
productos_empacados = cajas_completas * productos_por_caja
eficiencia_empacado = (productos_empacados / productos_totales) * 100

# Si empacamos los productos sueltos en una caja adicional
cajas_totales_necesarias = cajas_completas + (1 if productos_sueltos > 0 else 0)
peso_total_con_caja_parcial = cajas_totales_necesarias * peso_por_caja

print("📦 " + "=" * 50)
print("      ANÁLISIS DE DISTRIBUCIÓN DE PRODUCTOS")
print("=" * 52)
print(f"Productos totales recibidos: {productos_totales:,} unidades")
print(f"Capacidad por caja: {productos_por_caja} unidades")
print(f"Peso por caja: {peso_por_caja} kg")

print("\n📊 RESULTADOS DE EMPACADO:")
print(f"   Cajas completas formadas: {cajas_completas:,} cajas")
print(f"   Productos en cajas:       {productos_empacados:,} unidades")
print(f"   Productos sueltos:        {productos_sueltos} unidades")
print(f"   Eficiencia de empacado:   {eficiencia_empacado:.1f}%")

print("\n⚖️ PESO Y LOGÍSTICA:")
print(f"   Peso de cajas completas:  {peso_total_cajas:.1f} kg")
print(f"   Cajas necesarias total:   {cajas_totales_necesarias} cajas")
print(f"   Peso total estimado:      {peso_total_con_caja_parcial:.1f} kg")

# Análisis de optimización
print("\n🎯 ANÁLISIS DE OPTIMIZACIÓN:")
if productos_sueltos > 0:
    porcentaje_sueltos = (productos_sueltos / productos_por_caja) * 100
    print(f"   La última caja estará {porcentaje_sueltos:.1f}% llena")
    
    if productos_sueltos >= productos_por_caja / 2:
        print(f"   ✅ Recomendación: Empacar en caja adicional")
    else:
        print(f"   ⚠️  Considerar: Los {productos_sueltos} productos sueltos ocupan poco espacio")
else:
    print(f"   ✅ Perfecto: No hay productos sueltos")

# Cálculos de transporte
print("\n🚛 ESTIMACIÓN DE TRANSPORTE:")
camion_capacidad = 1000  # kg
camiones_necesarios = peso_total_con_caja_parcial / camion_capacidad
print(f"   Para camión de {camion_capacidad}kg: {camiones_necesarios:.2f} camiones")
print(f"   Camiones enteros necesarios: {int(camiones_necesarios) + (1 if camiones_necesarios % 1 > 0 else 0)}")

print("=" * 52)

Explicación de la solución:

  1. Uso correcto de operadores: // para cajas completas, % para sobrantes
  2. Análisis completo: No solo respondo las preguntas, sino que agrego insights útiles
  3. Eficiencia de empacado: Calculo qué porcentaje de productos se empaca eficientemente
  4. Recomendaciones prácticas: Doy consejos sobre qué hacer con productos sueltos
  5. Extensión logística: Incluyo cálculos de transporte que serían útiles en la realidad

📚 Capítulo 6: Estructuras de Control

🎯 Ejercicio: Sistema de clasificación de productos

Solución completa:

# ================================
# SISTEMA DE CLASIFICACIÓN DE PRODUCTOS
# ================================

# Simulación de productos del almacén
productos = [
    {"codigo": "LAP001", "nombre": "Laptop Gaming", "precio": 1299.99, "stock": 5},
    {"codigo": "MOU001", "nombre": "Mouse Inalámbrico", "precio": 29.99, "stock": 50},
    {"codigo": "TEC001", "nombre": "Teclado Mecánico", "precio": 89.99, "stock": 25},
    {"codigo": "MON001", "nombre": "Monitor 4K", "precio": 399.99, "stock": 8},
    {"codigo": "AUD001", "nombre": "Auriculares Gaming", "precio": 79.99, "stock": 15},
    {"codigo": "CAM001", "nombre": "Cámara Web HD", "precio": 49.99, "stock": 3},
    {"codigo": "IMP001", "nombre": "Impresora Láser", "precio": 199.99, "stock": 0},
    {"codigo": "TAB001", "nombre": "Tablet 10 pulgadas", "precio": 299.99, "stock": 12}
]

# Contadores para estadísticas
total_productos = len(productos)
productos_premium = 0
productos_economicos = 0
productos_stock_bajo = 0
productos_sin_stock = 0
valor_total_inventario = 0

# Listas para categorización
lista_premium = []
lista_economicos = []
lista_stock_critico = []
lista_sin_stock = []

print("🏪 " + "=" * 60)
print("        SISTEMA DE CLASIFICACIÓN DE PRODUCTOS")
print("=" * 62)

# Procesar cada producto
for producto in productos:
    codigo = producto["codigo"]
    nombre = producto["nombre"]
    precio = producto["precio"]
    stock = producto["stock"]
    
    # Calcular valor del inventario
    valor_producto = precio * stock
    valor_total_inventario += valor_producto
    
    # Clasificación por precio
    if precio >= 200:
        categoria_precio = "Premium"
        productos_premium += 1
        lista_premium.append(producto)
        emoji_precio = "💰"
    elif precio >= 50:
        categoria_precio = "Medio"
        emoji_precio = "🟡"
    else:
        categoria_precio = "Económico"
        productos_economicos += 1
        lista_economicos.append(producto)
        emoji_precio = "🟢"
    
    # Clasificación por stock
    if stock == 0:
        categoria_stock = "Sin stock"
        productos_sin_stock += 1
        lista_sin_stock.append(producto)
        emoji_stock = "🔴"
    elif stock <= 5:
        categoria_stock = "Stock crítico"
        productos_stock_bajo += 1
        lista_stock_critico.append(producto)
        emoji_stock = "🟠"
    elif stock <= 15:
        categoria_stock = "Stock bajo"
        emoji_stock = "🟡"
    else:
        categoria_stock = "Stock normal"
        emoji_stock = "🟢"
    
    # Mostrar información del producto
    print(f"{codigo} | {nombre:<20} | ${precio:>7.2f} | {stock:>3} und")
    print(f"        {emoji_precio} {categoria_precio:<10} | {emoji_stock} {categoria_stock}")
    print(f"        Valor inventario: ${valor_producto:,.2f}")
    print("-" * 62)

# Mostrar estadísticas generales
print("\n📊 ESTADÍSTICAS GENERALES:")
print(f"   Total de productos:     {total_productos}")
print(f"   Productos premium:      {productos_premium} ({productos_premium/total_productos*100:.1f}%)")
print(f"   Productos económicos:   {productos_economicos} ({productos_economicos/total_productos*100:.1f}%)")
print(f"   Con stock crítico:      {productos_stock_bajo} ({productos_stock_bajo/total_productos*100:.1f}%)")
print(f"   Sin stock:              {productos_sin_stock} ({productos_sin_stock/total_productos*100:.1f}%)")
print(f"   Valor total inventario: ${valor_total_inventario:,.2f}")

# Alertas importantes
print("\n⚠️  ALERTAS IMPORTANTES:")
if productos_sin_stock > 0:
    print(f"   🔴 {productos_sin_stock} productos SIN STOCK:")
    for prod in lista_sin_stock:
        print(f"      - {prod['nombre']} ({prod['codigo']})")

if productos_stock_bajo > 0:
    print(f"   🟠 {productos_stock_bajo} productos con STOCK CRÍTICO:")
    for prod in lista_stock_critico:
        print(f"      - {prod['nombre']} ({prod['codigo']}): {prod['stock']} unidades")

# Recomendaciones
print("\n💡 RECOMENDACIONES:")
if productos_sin_stock > 0:
    print("   1. Reabastecer inmediatamente productos sin stock")
if productos_stock_bajo > 0:
    print("   2. Programar reabastecimiento para productos con stock crítico")
if productos_premium > productos_economicos:
    print("   3. Considerar promoción de productos premium")
else:
    print("   3. Considerar expandir línea de productos premium")

print("=" * 62)

Explicación de la solución:

  1. Estructuras anidadas: Uso if/elif/else para múltiples categorizaciones
  2. Bucles con lógica compleja: Cada iteración realiza múltiples cálculos y clasificaciones
  3. Contadores y acumuladores: Mantengo estadísticas durante el procesamiento
  4. Listas de categorización: Guardo productos en listas según sus características
  5. Sistema de alertas: Genero recomendaciones basadas en los datos

✨ Notas Importantes

🎯 Cómo usar este apéndice efectivamente

  1. Antes de ver la solución: Intenta resolver el ejercicio completamente
  2. Compara tu solución: Ve las diferencias entre tu enfoque y el propuesto
  3. Entiende el razonamiento: Lee las explicaciones, no solo el código
  4. Experimenta: Modifica las soluciones para entender mejor cómo funcionan
  5. Aplica conceptos: Usa las técnicas aprendidas en tus propios proyectos

📝 Patrones comunes en las soluciones

  • Validación de datos: Siempre verifico que los datos sean válidos
  • Formateo profesional: Uso formateo avanzado para salidas legibles
  • Cálculos adicionales: Añado análisis que serían útiles en la vida real
  • Manejo de errores: Considero casos especiales y situaciones límite
  • Documentación: Comento el código para explicar decisiones no obvias

🚀 Siguientes pasos

Despues de revisar estas soluciones:

  1. Intenta variaciones: Modifica los ejercicios con diferentes datos
  2. Combina conceptos: Usa técnicas de varios ejercicios juntas
  3. Crea tus propios ejercicios: Diseña problemas similares
  4. Busca optimizaciones: ¿Puedes hacer el código más eficiente?
  5. Añade funcionalidades: Extiende las soluciones con nuevas características

💫 Recuerda: No hay una única forma “correcta” de resolver un problema en programación. Estas soluciones representan un enfoque, pero tu solución puede ser igualmente válida si resuelve el problema eficientemente.