10 min Lógica de Programación

Resolver problemas como un programador

La diferencia entre un programador junior y uno senior no es que el senior conozca más lenguajes o más funciones. Es que el senior tiene un método para resolver problemas. Cuando le pones un problema delante, no empieza a escribir código como un loco. Se sienta, piensa, planifica y LUEGO programa. En esta lección vas a aprender ese método.

La metodología de 4 pasos

Este enfoque viene de George Pólya, un matemático que en 1945 publicó "Cómo plantear y resolver problemas". Su método funciona igual de bien para ecuaciones matemáticas que para programación:

Entender el problema
Planificar la solución
Ejecutar el plan
Verificar el resultado

Parece obvio, ¿no? Pero te sorprendería saber cuánta gente se salta el paso 1 y 2 y se lanza directamente al 3. Es como salir de viaje sin saber a dónde vas ni qué ruta tomar.

Paso 1: Entender el problema

Antes de resolver nada, tienes que asegurarte de que entiendes exactamente qué te están pidiendo. Para eso, hazte estas preguntas:

¿Cuáles son las entradas? ¿Qué datos me dan?
¿Cuáles son las salidas? ¿Qué resultado esperan?
¿Qué restricciones hay? ¿Hay límites, reglas o casos especiales?
¿Puedo dar un ejemplo concreto? Con números y datos reales

Vamos a practicarlo con un problema real: diseñar el sistema de un parking.

// PASO 1: Entender el problema del parking

ENTRADAS:
- Capacidad máxima del parking (por ejemplo, 50 plazas)
- Vehículos que entran y salen
- Hora de entrada y hora de salida de cada vehículo

SALIDAS:
- Saber si hay plazas disponibles
- Calcular cuánto debe pagar cada vehículo al salir
- Mostrar cuántas plazas quedan libres

RESTRICCIONES:
- No pueden entrar más coches de los que caben
- La tarifa es 2€ por hora (mínimo 1 hora)
- Se cobra la hora completa (si estás 1 hora y 10 min, pagas 2 horas)

EJEMPLO CONCRETO:
- Parking de 3 plazas (para simplificar)
- Entra coche A a las 10:00 → quedan 2 plazas
- Entra coche B a las 10:30 → queda 1 plaza
- Entra coche C a las 11:00 → quedan 0 plazas
- Intenta entrar coche D → "Parking completo"
- Sale coche A a las 12:15 → estuvo 2h 15min → paga 3 horas = 6€
  → queda 1 plaza libre

Paso 2: Planificar la solución

Ahora que entiendes el problema, toca diseñar la solución. Aquí hay tres estrategias clave:

Descomponer en sub-problemas

Un problema grande es simplemente un montón de problemas pequeños pegados. Tu trabajo es separarlos. Es como montar un mueble de IKEA: no intentas montarlo de golpe, sigues los pasos uno a uno.

// PASO 2: Descomponer el problema del parking en sub-problemas

Sub-problema 1: Registrar la entrada de un vehículo
    - Comprobar si hay plazas libres
    - Registrar la matrícula y la hora de entrada
    - Reducir el contador de plazas disponibles

Sub-problema 2: Registrar la salida de un vehículo
    - Buscar el vehículo por su matrícula
    - Calcular el tiempo que estuvo aparcado
    - Calcular el importe a pagar
    - Aumentar el contador de plazas disponibles

Sub-problema 3: Calcular el precio
    - Calcular la diferencia de horas entre entrada y salida
    - Redondear hacia arriba (hora incompleta = hora completa)
    - Multiplicar por la tarifa

Sub-problema 4: Consultar estado del parking
    - Mostrar plazas ocupadas y disponibles
    - Listar los vehículos aparcados actualmente

Identificar patrones

Muchos problemas se parecen a otros que ya resolviste. El parking es básicamente una lista donde añades y eliminas elementos, con un límite máximo. Si ya sabes trabajar con listas (lección anterior), ya tienes medio problema resuelto.

Elegir las herramientas adecuadas

Para cada sub-problema, decide qué necesitas: ¿variables? ¿listas? ¿funciones? ¿bucles? ¿condicionales?

// Herramientas para el parking:

Variables:
    - capacidadMaxima (número)
    - plazasOcupadas (número)

Listas:
    - matriculas[] (las matrículas de los coches aparcados)
    - horasEntrada[] (la hora de entrada de cada coche)

Funciones:
    - registrarEntrada(matricula, hora)
    - registrarSalida(matricula, hora)
    - calcularPrecio(horaEntrada, horaSalida)
    - consultarEstado()

Condicionales:
    - ¿Hay plazas disponibles?
    - ¿Existe esta matrícula en el parking?

Bucles:
    - Buscar un coche por matrícula en la lista

Paso 3: Ejecutar el plan

Ahora sí: escribe el pseudocódigo. Como ya tienes el plan, esto es básicamente "traducir" cada sub-problema a pseudocódigo. Fíjate en cómo cada función corresponde a un sub-problema del paso anterior:

INICIO
    capacidadMaxima = 50
    plazasOcupadas = 0
    matriculas = []
    horasEntrada = []
FIN

FUNCION registrarEntrada(matricula, hora)
    SI plazasOcupadas >= capacidadMaxima ENTONCES
        MOSTRAR "Parking completo. No hay plazas disponibles"
        DEVOLVER FALSO
    FIN SI

    AÑADIR matriculas, matricula
    AÑADIR horasEntrada, hora
    plazasOcupadas = plazasOcupadas + 1

    plazasLibres = capacidadMaxima - plazasOcupadas
    MOSTRAR "Bienvenido. Plazas disponibles: " + plazasLibres
    DEVOLVER VERDADERO
FIN FUNCION

FUNCION registrarSalida(matricula, horaSalida)
    // Buscar el coche
    posicion = -1
    PARA i = 1 HASTA LONGITUD(matriculas) HACER
        SI matriculas[i] == matricula ENTONCES
            posicion = i
        FIN SI
    FIN PARA

    SI posicion == -1 ENTONCES
        MOSTRAR "No se encontró el vehículo " + matricula
        DEVOLVER FALSO
    FIN SI

    // Calcular precio
    horasAparcado = horaSalida - horasEntrada[posicion]
    precio = calcularPrecio(horasAparcado)

    // Eliminar el coche de las listas
    ELIMINAR matriculas, posicion
    ELIMINAR horasEntrada, posicion
    plazasOcupadas = plazasOcupadas - 1

    MOSTRAR "Vehículo: " + matricula
    MOSTRAR "Tiempo: " + horasAparcado + " horas"
    MOSTRAR "Total a pagar: " + precio + "€"
    DEVOLVER VERDADERO
FIN FUNCION

FUNCION calcularPrecio(horas)
    tarifaPorHora = 2
    // Redondear hacia arriba: 2.3 horas → 3 horas
    horasFacturadas = REDONDEAR_ARRIBA(horas)
    SI horasFacturadas < 1 ENTONCES
        horasFacturadas = 1
    FIN SI
    DEVOLVER horasFacturadas * tarifaPorHora
FIN FUNCION

FUNCION consultarEstado()
    plazasLibres = capacidadMaxima - plazasOcupadas
    MOSTRAR "=== Estado del Parking ==="
    MOSTRAR "Capacidad total: " + capacidadMaxima
    MOSTRAR "Plazas ocupadas: " + plazasOcupadas
    MOSTRAR "Plazas libres: " + plazasLibres

    SI LONGITUD(matriculas) > 0 ENTONCES
        MOSTRAR "Vehículos aparcados:"
        PARA i = 1 HASTA LONGITUD(matriculas) HACER
            MOSTRAR "  - " + matriculas[i] + " (desde las " + horasEntrada[i] + ")"
        FIN PARA
    FIN SI
FIN FUNCION

Paso 4: Verificar el resultado

Tu solución no está terminada hasta que la pruebas. Y no basta con probar el "caso feliz" (todo sale bien). Tienes que probar también los casos borde: situaciones extremas o raras que podrían romper tu código.

// PASO 4: Verificar con diferentes escenarios

// Caso normal: entrada y salida correcta
registrarEntrada("1234ABC", 10)    // OK, entra
registrarSalida("1234ABC", 12)     // 2 horas → 4€ ✓

// Caso borde: parking lleno
// (simular que las 50 plazas están ocupadas)
registrarEntrada("9999ZZZ", 10)    // "Parking completo" ✓

// Caso borde: coche que no existe
registrarSalida("0000XXX", 15)     // "No se encontró" ✓

// Caso borde: menos de 1 hora
registrarEntrada("5678DEF", 10)
registrarSalida("5678DEF", 10.5)   // 0.5 horas → mínimo 1h → 2€ ✓

// Caso borde: parking vacío
consultarEstado()                   // "0 plazas ocupadas, 50 libres" ✓

// Caso borde: hora exacta
registrarEntrada("1111AAA", 10)
registrarSalida("1111AAA", 13)     // Exactamente 3 horas → 6€ ✓

Los casos borde son donde se esconden la mayoría de los bugs. Un buen programador siempre piensa: "¿Qué pasa si la lista está vacía? ¿Qué pasa si el número es 0? ¿Qué pasa si el usuario introduce algo inesperado?"

Errores comunes de principiantes

Después de ver a cientos de estudiantes aprender a programar, estos son los errores que se repiten una y otra vez:

Empezar a "programar" sin entender el problema. Si no puedes explicar en una frase qué hace tu programa, no lo has entendido.
No descomponer. Intentar resolver todo de golpe en vez de dividir en partes pequeñas. Si tu pseudocódigo tiene más de 30 líneas sin funciones, probablemente necesitas descomponer más.
No probar con casos borde. Tu programa funciona con los datos "normales" pero se rompe con una lista vacía, un número negativo o un texto inesperado.
Copiar sin entender. Copiar una solución de otro sitio sin entender cada línea. Si no puedes explicar qué hace cada línea, no la has aprendido.
No hacer dry run. "Me parece que funciona" no es suficiente. Traza la ejecución con datos reales y verifica cada paso.
Variables con nombres crípticos. Usar x, temp, dato en vez de precioTotal, plazasLibres, nombreUsuario. Los nombres claros hacen que tu pseudocódigo se explique solo.

Resumen del método

┌──────────────────────────────────────────────────────────┐
│                 MÉTODO DE 4 PASOS                        │
├──────────────┬───────────────────────────────────────────┤
│ 1. ENTENDER  │ ¿Qué me piden? ¿Entradas? ¿Salidas?     │
│              │ ¿Restricciones? ¿Puedo dar un ejemplo?   │
├──────────────┼───────────────────────────────────────────┤
│ 2. PLANIFICAR│ Descomponer en sub-problemas             │
│              │ Identificar patrones conocidos            │
│              │ Elegir herramientas (variables, listas..) │
├──────────────┼───────────────────────────────────────────┤
│ 3. EJECUTAR  │ Escribir pseudocódigo paso a paso        │
│              │ Una función por sub-problema              │
│              │ Nombres claros y descriptivos             │
├──────────────┼───────────────────────────────────────────┤
│ 4. VERIFICAR │ Probar con datos normales                │
│              │ Probar casos borde y extremos             │
│              │ Hacer dry run con papel y boli            │
└──────────────┴───────────────────────────────────────────┘

En la siguiente lección te espera el ejercicio final: tres problemas reales donde tendrás que aplicar todo lo aprendido en esta sección. Variables, condicionales, bucles, funciones, listas y el método de 4 pasos, todo junto.

Aplica el método completo de 4 pasos para diseñar un sistema de préstamo de libros. La biblioteca tiene estas reglas:

Cada socio puede tener máximo 3 libros prestados a la vez
El préstamo dura 14 días. Si se devuelve tarde, hay una multa de 0.50€ por día de retraso
Un libro solo puede estar prestado a una persona a la vez

Debes entregar, usando papel y bolígrafo:

Paso 1 (Entender): lista de entradas, salidas, restricciones y un ejemplo concreto con datos reales
Paso 2 (Planificar): sub-problemas identificados, herramientas necesarias (variables, listas, funciones)
Paso 3 (Ejecutar): pseudocódigo completo con funciones para: prestarLibro, devolverLibro, calcularMulta y consultarPrestamos
Paso 4 (Verificar): al menos 5 escenarios de prueba, incluyendo casos borde (socio con 3 libros intenta sacar otro, libro ya prestado, devolución con retraso, devolución a tiempo)

Pistas

Para el paso 1, piensa en qué datos necesitas de cada libro (título, si está disponible o no) y de cada socio (nombre, cuántos libros tiene prestados). Para el paso 2, los sub-problemas principales son: prestar, devolver, calcular multa y consultar estado. Para los casos borde del paso 4, no olvides: ¿qué pasa si el socio no existe? ¿Qué pasa si intenta devolver un libro que no tiene? ¿Qué pasa si devuelve exactamente el día 14?

Anterior Pseudocódigo y diagramas de flujo

Siguiente Ejercicio final