Lógica de programación: qué es, por qué importa y cómo aplicarla

Qué es la lógica de programación (explicado fácil)

La lógica de programación es el conjunto de reglas mentales que usamos para transformar un problema en pasos claros que un programa pueda ejecutar. Un programa no es magia: es una secuencia de instrucciones sincronizadas que siguen un plan para alcanzar un objetivo. En mi caso, antes de tocar cualquier framework, aprendí a pensar en términos de entradas, procesamiento y salidas: ¿qué datos tengo?, ¿qué debo hacer con ellos?, ¿qué quiero obtener?

Piénsalo así: si puedes explicarle a alguien (o a ti mismo) cómo resolver algo paso a paso, ya tienes el 80 % del trabajo. El resto es traducir esos pasos a un lenguaje de programación.

Tres pilares que vas a usar una y otra vez:

• Secuencia: hacer A, luego B, luego C.
• Selección (condiciones): si pasa X, hago Y; si no, hago Z.
• Iteración (bucles): repetir un paso mientras se cumpla una condición.

Un cuarto pilar que te desbloquea problemas más grandes son las funciones: agrupar pasos que resuelven una mini-tarea y poder reutilizarlos.

Mini-test
Imagina que necesitas convertir grados Celsius a Fahrenheit. ¿Qué es entrada, proceso y salida?

• Entrada: temperatura en °C
• Proceso: aplicar fórmula F = C * 9/5 + 32
• Salida: temperatura en °F

Cuando empecé, me ayudó escribir estos tres renglones antes de cualquier línea de código. Me ahorró tiempo y bugs.

De la idea al algoritmo: método paso a paso para resolver problemas

Objetivo: que puedas ir de “tengo un enredo” a “tengo un plan”.

1. Define el objetivo
   “Quiero saber si un número es par.” Objetivo claro y verificable.
2. Identifica entradas y salidas
   Entrada: un número entero. Salida: true/false o un mensaje.
3. Descompón en pasos mínimos

• Tomar el número.
• Calcular numero % 2.
• Si el resto es 0 → es par; si no → impar.

1. Escribe pseudocódigo (lenguaje natural + un poco de estructura)

INICIO
  LEER numero
  SI (numero % 2 == 0) ENTONCES
      IMPRIMIR "par"
  SINO
      IMPRIMIR "impar"
FIN

1. Haz una prueba de mesa (dry run)
   Simula a mano con numero = 7 y numero = 8. En mi experiencia, esta práctica me “blindó” contra sorpresas al ejecutar.
2. Codifica y prueba con varios casos
   Prueba valores límite (0, negativos, muy grandes). Cuando probé por primera vez, me di cuenta de que no había considerado negativos; la prueba de mesa lo habría revelado antes.

Plantillas de pensamiento que uso a diario

• Si-entonces (validaciones, reglas).
• Contar-hasta (bucles controlados por contador).
• Recorrer-colección (listas/arrays: buscar, filtrar, acumular).
• Dividir y conquistar (funciones para subtareas repetibles).

Estructuras de control que debes dominar

Secuencia, selección (if/else, switch) y bucles (for/while)

• If/else: bifurcar la ejecución.
• Switch: muchas opciones sobre el mismo valor.
• For: repetir un número conocido de veces.
• While: repetir mientras una condición sea verdadera.
• For-of / forEach (JS) o for … in (Python): recorrer colecciones.

Ejemplo (JS): decidir precio con descuento simple

const precio = 100;
const esVip = true;

let total = precio;
if (esVip) total = precio * 0.9;

console.log(total); // 90

Ejemplo (Python): bucle controlado por condición

saldo = 50
while saldo > 0:
    print("Comprando... saldo =", saldo)
    saldo -= 15
print("Sin saldo")

En mi caso, interiorizar estas piezas me permitió “leer” cualquier algoritmo ajeno sin conocer el lenguaje al 100 %.

Funciones: dividir para conquistar

Las funciones encapsulan lógica y te permiten reusar y probar por separado.

Pseudocódigo

FUNCION esPar(n):
  RETORNAR (n % 2 == 0)

Python

def es_par(n: int) -> bool:
    return n % 2 == 0

JavaScript

const esPar = n => n % 2 === 0;

Algoritmos básicos con ejemplos (pseudocódigo, Python y JS)

FizzBuzz y variantes (contar, filtrar, condiciones)

Problema: imprimir del 1 al N. Si el número es múltiplo de 3 → “Fizz”, de 5 → “Buzz”, de ambos → “FizzBuzz”.

Pseudocódigo

LEER N
PARA i DESDE 1 HASTA N:
  SI i%3==0 Y i%5==0: IMPRIMIR "FizzBuzz"
  SINO SI i%3==0:     IMPRIMIR "Fizz"
  SINO SI i%5==0:     IMPRIMIR "Buzz"
  SINO:               IMPRIMIR i

Python

def fizzbuzz(n: int):
    for i in range(1, n+1):
        out = ""
        if i % 3 == 0: out += "Fizz"
        if i % 5 == 0: out += "Buzz"
        print(out or i)

fizzbuzz(20)

JavaScript

function fizzbuzz(n){
  for (let i = 1; i <= n; i++) {
    let out = "";
    if (i % 3 === 0) out += "Fizz";
    if (i % 5 === 0) out += "Buzz";
    console.log(out || i);
  }
}
fizzbuzz(20);

Errores típicos

• Evaluar i%3==0 && i%5==0 al final (doble impresión).
• Usar else if de forma que se salte combinaciones.
• Off-by-one: empezar en 0 o terminar en n mal.

Cuando lo practiqué, me forcé a escribir primero el pseudocódigo: redujo la tasa de errores en condiciones compuestas.

Máximo y promedio de una lista (recorridos y acumuladores)

Pseudocódigo

INICIO
  LISTA numeros
  max = -infinito
  suma = 0
  PARA cada x en numeros:
    SI x > max: max = x
    suma = suma + x
  promedio = suma / longitud(numeros)
  IMPRIMIR max, promedio
FIN

Python

def max_y_promedio(nums: list[float]) -> tuple[float, float]:
    assert nums, "lista vacía"
    maximo = nums[0]
    suma = 0
    for x in nums:
        if x > maximo: maximo = x
        suma += x
    return maximo, suma / len(nums)

print(max_y_promedio([3, 7, 2, 9, 4]))

JavaScript

function maxYPromedio(nums){
  if (!nums.length) throw new Error("lista vacía");
  let max = nums[0], suma = 0;
  for (const x of nums){
    if (x > max) max = x;
    suma += x;
  }
  return { max, promedio: suma / nums.length };
}
console.log(maxYPromedio([3,7,2,9,4]));

Errores típicos

• Iniciar max en 0 (falla con números negativos).
• Dividir por 0 en lista vacía.
• Variables que “recuerdan” valores de iteraciones previas sin reiniciar.

En mi caso, me acostumbré a probar datos con negativos y con un único elemento. Eso detecta media docena de bugs en 2 minutos.

Validación simple (contraseñas, rangos, reglas)

Reglas de ejemplo: longitud ≥ 8, al menos 1 dígito y 1 letra.

Pseudocódigo

FUNCION esContraseniaValida(s):
  SI longitud(s) < 8: RETORNAR FALSO
  tieneLetra = FALSO
  tieneDigito = FALSO
  PARA cada c en s:
    SI esLetra(c): tieneLetra = VERDADERO
    SI esDigito(c): tieneDigito = VERDADERO
  RETORNAR (tieneLetra Y tieneDigito)

Python

def es_contrasenia_valida(s: str) -> bool:
    if len(s) < 8: return False
    tiene_letra = any(ch.isalpha() for ch in s)
    tiene_digito = any(ch.isdigit() for ch in s)
    return tiene_letra and tiene_digito

JavaScript

const esContraseniaValida = s =>
  s.length >= 8 && /[A-Za-z]/.test(s) && /\d/.test(s);

Errores típicos

• Reglas ambiguas (¿se permite símbolo?).
• Verificar solo una condición.
• No normalizar mayúsculas/minúsculas cuando aplica.

Cuando lo implementé por primera vez, olvidé probar cadenas vacías y espacios; desde entonces siempre agrego casos límite a mi lista de pruebas.

Búsqueda lineal y conteo de ocurrencias

Problema: ¿está objetivo en la lista? ¿y cuántas veces?

Python

def esta_y_cuantas(nums, objetivo):
    count = 0
    for x in nums:
        if x == objetivo:
            count += 1
    return (count > 0), count

print(esta_y_cuantas([1,3,3,7,3,9], 3))  # (True, 3)

JavaScript

function estaYCuantas(nums, objetivo){
  let count = 0;
  for (const x of nums) if (x === objetivo) count++;
  return { esta: count > 0, count };
}
console.log(estaYCuantas([1,3,3,7,3,9], 3)); // {esta:true, count:3}

Errores típicos

• Cortar el bucle al primer hallazgo cuando necesitas todas las ocurrencias.
• Comparar con == cuando requieres igualdad estricta (=== en JS).
• No contemplar tipos mezclados (número vs string “3”).

Errores típicos de lógica y cómo evitarlos

Condiciones mal planteadas, off-by-one y bucles infinitos

• Condición invertida: usar > donde iba >=. Solución: prueba con valores de borde (ej., 0, 1, N, N-1).
• Off-by-one: recorrer 0..n cuando necesitabas 0..n-1. Solución: dibuja rápidamente la línea de índices y marca inicio/fin.
• Bucle infinito: olvidar actualizar la variable de control. Solución: identa y marca la actualización; revisa con la prueba de mesa.

Orden de operaciones y estados intermedios

• Asignar antes de calcular (o viceversa) puede romper la lógica.
• Estados no inicializados: variables sin valor inicial “arrastran ruido”.
• Mutaciones colaterales: cambiar una lista mientras la recorres.

Checklist rápida que me salvó muchas veces

• ¿Tengo entradas, proceso y salidas escritos?
• ¿Probé borde inferior y superior?
• ¿Puedo explicar el algoritmo en 30 segundos? Si no, está muy acoplado: divide en funciones.

Cómo practicar todos los días (y medir tu progreso)

Rutina 20-30-10: leer, diseñar, codificar

• 20 min leer: toma 1 concepto (p. ej., bucles) y 2 ejemplos.
• 30 min diseñar: 2 problemas con pseudocódigo + prueba de mesa.
• 10 min codificar: implementa en tu lenguaje favorito.

Lista de ejercicios graduados y retos semanales

• Día 1–2: Condiciones (par/impar, mayor de edad, tarifas).
• Día 3–4: Bucles (sumatoria, factorial, tablas de multiplicar).
• Día 5–6: Listas (máximo, promedio, filtros).
• Día 7: Reto (validación y búsqueda combinadas).

En mi experiencia, practicar antes de aprender un framework me dio una base que hizo que cualquier lenguaje “me suene lógico”. La lógica es la gramática; el lenguaje es solo la sintaxis.

Conclusión: lo que me hubiera gustado saber cuando empecé

La lógica de programación es el cimiento. Si dominas secuencia, condiciones, bucles y funciones, cualquier lenguaje te parecerá un cambio de acento, no de idioma. En mi caso, entender que un programa “solo sigue instrucciones claras para cumplir una meta” me quitó miedo y me hizo avanzar más rápido. Empieza por escribir el plan (pseudocódigo), valida con pruebas de mesa, y recién después codifica. Repite el ciclo con problemas cada vez un poco más complejos y, cuando menos lo notes, estarás resolviendo retos reales con soltura.

FAQs

¿Cuál es la diferencia entre lógica de programación y algoritmo?
La lógica es la forma de pensar; el algoritmo es el plan detallado (los pasos) que surge de esa forma de pensar.

¿Puedo practicar lógica sin saber un lenguaje?
Sí: con pseudocódigo, diagramas de flujo y pruebas de mesa. Luego traduces a cualquier lenguaje.

¿Qué estructuras de control aprendo primero?
If/else y for/while. Son el 90 % de los casos. Después funciones.

¿Cómo depuro cuando “parece correcto” pero no funciona?
Haz una traza: imprime estados clave, prueba valores de borde y verifica condiciones intermedias.