Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/carlosgomezc7/plataforma_aprendizaje/llms.txt

Use this file to discover all available pages before exploring further.

La Plataforma Educativa Personalizada implementa tres categorías de algoritmos, cada una elegida por su idoneidad para el problema específico que resuelve. Quick Sort maneja el ordenamiento dinámico de sugerencias de cursos priorizando relevancia, porque su estrategia divide y vencerás ofrece rendimiento promedio O(n log n) sin necesidad de estructuras auxiliares. Búsqueda Binaria localiza cursos por ID en O(log n) aprovechando que la lista puede ordenarse previamente. Recursión recorre el árbol implícito de dependencias de módulos de forma natural y legible, reflejando directamente la estructura jerárquica del problema. Juntos, estos tres algoritmos cubren las operaciones más frecuentes de la plataforma: sugerir, encontrar y narrar.

​
Quick Sort

​
Estrategia divide y vencerás

Quick Sort divide el arreglo en torno a un pivote central (el elemento ubicado en arr[len(arr) // 2]) y particiona los elementos en tres grupos: los mayores al pivote, los iguales y los menores. Luego aplica el mismo proceso de forma recursiva a los subgrupos izquierdo y derecho, concatenando los resultados al final. Al usar el elemento del medio como pivote, se evita el peor caso en arreglos ya ordenados que afecta a las implementaciones que siempre eligen el primer o último elemento.

​
Complejidad temporal

CasoComplejidad
Caso promedioO(n log n)
Caso peorO(n²)

​
Detalle clave

La función ordena de forma descendente según el campo clave, con valor por defecto "relevancia". Esto significa que el curso con mayor índice de relevancia aparece primero en la lista de sugerencias mostrada al estudiante.

​
Implementación

def quicksort_cursos(arr, clave="relevancia"):
    if len(arr) <= 1:
        return arr
    pivote = arr[len(arr) // 2]
    izq = [x for x in arr if x[clave] > pivote[clave]]
    medio = [x for x in arr if x[clave] == pivote[clave]]
    der = [x for x in arr if x[clave] < pivote[clave]]
    return quicksort_cursos(izq, clave) + medio + quicksort_cursos(der, clave)
La función puede reutilizarse con otras claves numéricas del esquema de curso (por ejemplo "dificultad") pasando el argumento clave correspondiente.

​
Búsqueda Binaria

​
Prerrequisito: lista ordenada por ID

La Búsqueda Binaria solo funciona sobre una secuencia ordenada. Antes de ejecutar la búsqueda, la aplicación ordena la lista de cursos de forma ascendente por ID mediante sorted(cursos, key=lambda x: x['id']). Este paso extra tiene un coste O(n log n), pero se amortiza completamente si se realizan múltiples búsquedas sobre la misma lista.

​
Complejidad temporal

CasoComplejidad
Caso promedioO(log n)
Caso peorO(log n)
A diferencia de una búsqueda lineal O(n), la búsqueda binaria descarta la mitad de los elementos en cada iteración, lo que la hace significativamente más rápida a medida que crece el catálogo de cursos.

​
Implementación

def busqueda_binaria_curso(arr, id_curso):
    inicio = 0
    fin = len(arr) - 1
    while inicio <= fin:
        medio = (inicio + fin) // 2
        if arr[medio]['id'] == id_curso:
            return arr[medio]
        elif arr[medio]['id'] < id_curso:
            inicio = medio + 1
        else:
            fin = medio - 1
    return None
La función retorna el diccionario completo del curso si lo encuentra, o None si el ID no existe en el catálogo.

​
Recursividad

​
Recorrido en profundidad (DFS) sobre el árbol de dependencias

La función recuperar_historial_recursivo realiza un recorrido en profundidad (Depth-First Search) sobre el árbol implícito de dependencias de módulos. En cada llamada, procesa el módulo actual, luego desciende recursivamente a cada uno de sus sub-módulos antes de retornar al nivel superior. Caso base: si modulo_actual no está en el diccionario historial_completo, la función no tiene sub-módulos que recorrer y retorna solo la cadena con el módulo formateado, terminando esa rama de la recursión. Caso recursivo: si modulo_actual es una clave en historial_completo, la función itera sobre cada sub-módulo de su lista e invoca recuperar_historial_recursivo con nivel + 1, incrementando la indentación para reflejar la profundidad en el árbol.

​
Indentación dinámica

El parámetro nivel controla la indentación visual: por cada nivel de profundidad, se anteponen dos espacios adicionales (" " * nivel), produciendo una representación en texto del árbol que es legible directamente en la interfaz de la aplicación.

​
Implementación

def recuperar_historial_recursivo(modulo_actual, historial_completo, nivel=0):
    resultado = "  " * nivel + f"- Módulo Completado: {modulo_actual}\n"
    if modulo_actual in historial_completo:
        for sub_modulo in historial_completo[modulo_actual]:
            resultado += recuperar_historial_recursivo(sub_modulo, historial_completo, nivel + 1)
    return resultado
Para el diccionario de ejemplo de la aplicación, la salida sería: 
- Módulo Completado: Proyecto Final
  - Módulo Completado: Desarrollo Backend
    - Módulo Completado: Bases de Datos
    - Módulo Completado: Lógica de Programación
  - Módulo Completado: Desarrollo Frontend
    - Módulo Completado: Diseño UI/UX

​
Complejidad temporal comparativa

AlgoritmoCaso promedioCaso peorVentaja
Quick SortO(n log n)O(n²)Ordenamiento en memoria, sin dependencias
Búsqueda BinariaO(log n)O(log n)Búsqueda rápida en listas ordenadas
Recursividad (DFS)O(n)O(n)Traversal natural de árboles
Quick Sort con pivote central (elemento del medio del arreglo) evita el caso peor O(n²) en arreglos ya ordenados que afecta a implementaciones con pivote fijo en el extremo. En el uso típico de la plataforma, donde el catálogo de cursos se carga desde JSON y puede estar en cualquier orden, el pivote central ofrece una distribución de particiones consistentemente equilibrada.

Build docs developers (and LLMs) love

Get started for freeTalk to us