Fundamentos de Programación: Algoritmos y Pensamiento Lógico

¡Desarrolla el pensamiento algorítmico! En este tutorial avanzado te guiaré paso a paso para que aprendas a pensar como un programador, crear algoritmos eficientes y resolver problemas de manera lógica.

Objetivo: Aprender a desarrollar el pensamiento algorítmico, implementar algoritmos básicos, comprender la complejidad algorítmica y aplicar técnicas de resolución de problemas en Python.

Paso 1: ¿Qué es un algoritmo?

Un algoritmo es una secuencia de pasos lógicos para resolver un problema. Es como una receta de cocina: ingredientes → pasos → resultado.

# Ejemplo: Algoritmo para hacer café
def hacer_cafe(tipo, azucar):
    pasos = [
        "Calentar agua",
        "Poner café en la prensa",
        f"Verter agua sobre el café {tipo}",
        "Esperar 4 minutos",
        "Empujar prensa lentamente",
        f"Añadir {azucar} cucharadas de azúcar" if azucar > 0 else "Sin azúcar",
        "Servir en taza"
    ]
    return pasos

# Ejecutar el algoritmo
receta = hacer_cafe("colombiano", 2)
for paso in receta:
    print(f"Paso {receta.index(paso) + 1}: {paso}")

Paso 2: Tipos de datos y operadores

Operadores aritméticos

# Operaciones matemáticas básicas
a = 10
b = 3

print(f"Suma: {a + b}")        # 13
print(f"Resta: {a - b}")       # 7
print(f"Multiplicación: {a * b}") # 30
print(f"División: {a / b}")    # 3.333...
print(f"División entera: {a // b}") # 3
print(f"Módulo: {a % b}")      # 1 (resto de la división)
print(f"Potencia: {a ** b}")   # 1000

Operadores de comparación

# Comparaciones que devuelven True o False
x = 5
y = 10

print(f"¿x es igual a y? {x == y}")    # False
print(f"¿x es diferente de y? {x != y}") # True  
print(f"¿x es mayor que y? {x > y}")   # False
print(f"¿x es menor que y? {x < y}")    # True
print(f"¿x es mayor o igual? {x >= 5}") # True
print(f"¿x es menor o igual? {x <= 4}") # False

Operadores lógicos

# Combinar condiciones
edad = 25
tiene_licencia = True
es_noche = False

# AND: Todas deben ser True
puede_conducir = edad >= 18 and tiene_licencia
print(f"Puede conducir: {puede_conducir}")  # True

# OR: Al menos una debe ser True
necesita_luces = es_noche or edad > 70
print(f"Necesita luces: {necesita_luces}")  # False

# NOT: Invertir el valor
no_puede_conducir = not puede_conducir
print(f"No puede conducir: {no_puede_conducir}")  # False

Paso 3: Estructuras de control avanzadas

Switch-case (Python 3.10+)

# Estructura match-case (similar a switch)
def clasificar_dia(dia):
    match dia.lower():
        case "lunes" | "martes" | "miércoles" | "jueves" | "viernes":
            return "Día laboral"
        case "sábado" | "domingo":
            return "Fin de semana"
        case _:
            return "Día no válido"

# Probamos la función
print(clasificar_dia("Sábado"))    # Fin de semana
print(clasificar_dia("Martes"))    # Día laboral

Bucles anidados

# Tabla de multiplicar con bucles anidados
print("Tablas de multiplicar del 1 al 5:")
print("    ", end="")
for i in range(1, 6):
    print(f"{i:4}", end="")
print("\n" + "=" * 25)

for fila in range(1, 6):
    print(f"{fila:2} |", end="")
    for columna in range(1, 6):
        resultado = fila * columna
        print(f"{resultado:4}", end="")
    print()

Paso 4: Funciones avanzadas

Parámetros por defecto y keyword arguments

# Función con parámetros por defecto
def crear_perfil(nombre, edad, ciudad="Desconocida", es_premium=False):
    return {
        "nombre": nombre,
        "edad": edad,
        "ciudad": ciudad,
        "es_premium": es_premium
    }

# Diferentes formas de llamar la función
perfil1 = crear_perfil("Ana", 25)  # Usa valores por defecto
perfil2 = crear_perfil("Carlos", 30, "Madrid", True)  # Todos los parámetros
perfil3 = crear_perfil(edad=28, nombre="Laura", es_premium=True)  # Keyword arguments

print(perfil1)
print(perfil2)
print(perfil3)

Funciones lambda (anónimas)

# Funciones pequeñas y rápidas
cuadrado = lambda x: x ** 2
print(f"Cuadrado de 5: {cuadrado(5)}")  # 25

# Útiles para ordenamiento
personas = [
    {"nombre": "Ana", "edad": 25},
    {"nombre": "Carlos", "edad": 30},
    {"nombre": "Laura", "edad": 22}
]

# Ordenar por edad
personas_ordenadas = sorted(personas, key=lambda persona: persona["edad"])
print("Ordenado por edad:", personas_ordenadas)

# Filtrar mayores de 25
mayores = filter(lambda persona: persona["edad"] > 25, personas)
print("Mayores de 25:", list(mayores))

Paso 5: Manejo de archivos

Leer y escribir archivos

# Escribir en un archivo
with open("diario.txt", "w", encoding="utf-8") as archivo:
    archivo.write("Mi diario personal\n")
    archivo.write("==================\n")
    archivo.write("Hoy aprendí a programar en Python.\n")
    archivo.write("¡Fue un día productivo!\n")

# Leer de un archivo
print("Contenido del diario:")
with open("diario.txt", "r", encoding="utf-8") as archivo:
    contenido = archivo.read()
    print(contenido)

# Leer línea por línea
print("\nLínea por línea:")
with open("diario.txt", "r", encoding="utf-8") as archivo:
    for numero_linea, linea in enumerate(archivo, 1):
        print(f"Línea {numero_linea}: {linea.strip()}")

Paso 6: Programación defensiva

Validación de entradas

def obtener_edad():
    while True:
        try:
            edad = int(input("Por favor ingresa tu edad: "))
            if 0 <= edad <= 120:
                return edad
            else:
                print("Por favor ingresa una edad válida (0-120)")
        except ValueError:
            print("¡Eso no es un número válido! Intenta nuevamente.")

def obtener_email():
    while True:
        email = input("Ingresa tu email: ")
        if "@" in email and "." in email:
            return email
        else:
            print("Por favor ingresa un email válido")

# Probamos las funciones
edad_valida = obtener_edad()
email_valido = obtener_email()
print(f"Edad: {edad_valida}, Email: {email_valido}")

Paso 7: Algoritmos comunes

Búsqueda lineal

def busqueda_lineal(lista, objetivo):
    """Busca un elemento en una lista"""
    for indice, elemento in enumerate(lista):
        if elemento == objetivo:
            return indice
    return -1  # No encontrado

# Ejemplo de uso
numeros = [4, 2, 7, 1, 9, 5]
objetivo = 7
resultado = busqueda_lineal(numeros, objetivo)

if resultado != -1:
    print(f"El número {objetivo} está en la posición {resultado}")
else:
    print(f"El número {objetivo} no está en la lista")

Ordenamiento burbuja

def ordenamiento_burbuja(lista):
    """Ordena una lista usando el algoritmo burbuja"""
    n = len(lista)
    # Hacer múltiples pasadas
    for i in range(n):
        # Últimos i elementos ya están en su lugar
        for j in range(0, n - i - 1):
            # Intercambiar si el elemento actual es mayor que el siguiente
            if lista[j] > lista[j + 1]:
                lista[j], lista[j + 1] = lista[j + 1], lista[j]
    return lista

# Probamos el algoritmo
numeros_desordenados = [64, 34, 25, 12, 22, 11, 90]
numeros_ordenados = ordenamiento_burbuja(numeros_desordenados.copy())
print(f"Original: {numeros_desordenados}")
print(f"Ordenado: {numeros_ordenados}")

Paso 8: Complejidad algorítmica

Notación Big O

# O(1) - Tiempo constante
def primer_elemento(lista):
    return lista[0]  # Siempre toma el mismo tiempo

# O(n) - Tiempo lineal  
def suma_lista(lista):
    total = 0
    for numero in lista:  # El tiempo crece con el tamaño de la lista
        total += numero
    return total

# O(n²) - Tiempo cuadrático
def todos_los_pares(lista):
    pares = []
    for i in lista:        # Loop anidado = n * n = n²
        for j in lista:
            pares.append((i, j))
    return pares

# Ejemplo de diferentes complejidades
pequena_lista = list(range(10))
gran_lista = list(range(1000))

print("O(1):", primer_elemento(gran_lista))
print("O(n):", suma_lista(pequena_lista))
# print("O(n²):", len(todos_los_pares(pequena_lista)))  # ¡Cuidado con listas grandes!

Paso 9: Proyecto completo - Sistema de gestión de tareas

class SistemaTareas:
    def __init__(self):
        self.tareas = []
        self.contador_id = 1

    def agregar_tarea(self, descripcion, prioridad="media"):
        tarea = {
            "id": self.contador_id,
            "descripcion": descripcion,
            "prioridad": prioridad,
            "completada": False
        }
        self.tareas.append(tarea)
        self.contador_id += 1
        print(f"Tarea '{descripcion}' agregada con ID {tarea['id']}")

    def mostrar_tareas(self):
        if not self.tareas:
            print("No hay tareas pendientes")
            return

        print("\n--- Lista de Tareas ---")
        for tarea in self.tareas:
            estado = "✓" if tarea["completada"] else " "
            print(f"{tarea['id']}. [{estado}] {tarea['descripcion']} ({tarea['prioridad']})")

    def completar_tarea(self, id_tarea):
        for tarea in self.tareas:
            if tarea["id"] == id_tarea:
                tarea["completada"] = True
                print(f"Tarea {id_tarea} marcada como completada")
                return
        print(f"No se encontró la tarea con ID {id_tarea}")

    def eliminar_tarea(self, id_tarea):
        self.tareas = [t for t in self.tareas if t["id"] != id_tarea]
        print(f"Tarea {id_tarea} eliminada")

# Usamos el sistema
mi_sistema = SistemaTareas()
mi_sistema.agregar_tarea("Aprender Python", "alta")
mi_sistema.agregar_tarea("Hacer ejercicio", "media")
mi_sistema.agregar_tarea("Leer un libro", "baja")

mi_sistema.mostrar_tareas()
mi_sistema.completar_tarea(1)
mi_sistema.mostrar_tareas()

Paso 10: Próximos pasos en tu journey

Roadmap de aprendizaje

1. Fundamentos sólidos → Algoritmos y estructuras de datos
2. Proyectos prácticos → Aplicar lo aprendido
3. Frameworks y librerías → Django, React, etc.
4. Bases de datos → SQL y NoSQL
5. DevOps y deployment → Git, Docker, cloud

Recursos recomendados

• Libros: "Python Crash Course", "Automate the Boring Stuff"
• Plataformas: freeCodeCamp, Codecademy, LeetCode
• Comunidades: Stack Overflow, Reddit r/learnprogramming
• Proyectos: Crear tu portfolio personal

Paso 11: Ejercicios de práctica

# Ejercicio 1: Calculadora de Fibonacci
def fibonacci(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]

    secuencia = [0, 1]
    for i in range(2, n):
        siguiente = secuencia[i-1] + secuencia[i-2]
        secuencia.append(siguiente)
    return secuencia

# Ejercicio 2: Contador de Palabras
def contar_palabras(texto):
    palabras = texto.split()
    return len(palabras)

# Ejercicio 3: Validador de Contraseñas
def validar_password(password):
    if len(password) < 8:
        return False
    if not any(c.isupper() for c in password):
        return False
    if not any(c.islower() for c in password):
        return False
    if not any(c.isdigit() for c in password):
        return False
    return True

# Probamos los ejercicios
print("Fibonacci(10):", fibonacci(10))
print("Palabras en texto:", contar_palabras("Hola mundo desde Python"))
print("Password válido:", validar_password("Python123"))

Recursos y plataformas

Plataformas de aprendizaje:

• freeCodeCamp: Cursos gratuitos
• Codecademy: Aprendizaje interactivo
• Coursera/edX: Cursos universitarios

Práctica con ejercicios:

• LeetCode: Problemas de programación
• HackerRank: Desafíos de código
• Codewars: Retos divertidos

Conclusión

¡Felicidades! Has desarrollado significativamente tu pensamiento algorítmico. Practica estos conceptos diariamente y construye proyectos que desafíen tu lógica.

Para más tutoriales sobre algoritmos y estructuras de datos, visita nuestra sección de tutoriales.

¡Con estos conocimientos ya puedes resolver problemas de manera algorítmica!

💡 Tip Importante

📝 Mejores Prácticas para Desarrollo de Algoritmos

Para crear algoritmos eficientes y correctos, considera estos consejos esenciales:

• Entiende el problema: Antes de codificar, asegúrate de comprender completamente el problema
• Piensa en casos extremos: Considera casos límite como listas vacías, valores nulos, números negativos
• Analiza la complejidad: Evalúa el rendimiento de tu algoritmo con notación Big O
• Prueba sistemáticamente: Crea casos de prueba que cubran diferentes escenarios
• Documenta tu lógica: Explica el razonamiento detrás de cada paso del algoritmo
• Busca optimizaciones: Siempre pregunta si hay una manera más eficiente de resolver el problema
• Reutiliza código: Crea funciones reutilizables para operaciones comunes
• Mantén la simplicidad: Un algoritmo simple y correcto es mejor que uno complejo y propenso a errores

📚 Documentación: Revisa recursos sobre algoritmos en GeeksforGeeks y LeetCode

¡Estos consejos te ayudarán a convertirte en un programador que piensa algorítmicamente!