CLRS Kit Español

clrs-kit-esp es una extensión para Visual Studio Code orientada al soporte de un lenguaje de programación tipo pseudocódigo, fuertemente inspirado en la sintaxis utilizada en el libro Introducción a Algoritmos (CLRS) 4ta Edición.

💻 Inicio rápido

Recomendado

Recursos opcionales que podrían mejorar tu experiencia con esta extensión.

Requisito

Es necesario tener Node.js instalado en el sistema. CLRS Kit Español lo utiliza como entorno de ejecución (Runtime) para correr el código JavaScript generado durante el proceso de transpilación.

Licencia (GPL versión 2.0)

Este proyecto es de código abierto y se distribuye bajo los términos de la licencia GPLv2. Puede ser modificado y distribuido libremente, siempre que se conserve el software resultante bajo la misma licencia.

⌨️ Comandos para VS Code

⚙️ Estado actual (versión 1.5.6)

Lenguaje de programación

• Analizador lexicográfico, analizador sintáctico y analizador semántico.
• Transpilador de CLRS a JavaScript.
• Exportación de archivo transpilado a JavaScript.
• Lanzador de programas CLRS mediante Node.js integrado con VS Code.
• Reporte de errores de sintaxis, semántica y ejecución.
• Biblioteca estándar para manejo de operaciones matemáticas, cadenas, arreglos y archivos.
• Corpus de pruebas de la suite completa.

Herramientas de edición integradas a VS Code

• Configuración del lenguaje con indentación automática y plegado de código.
• Fragmentos (Snippets) predefinidos para la sintaxis.
• Resaltado de sintaxis gramatical (TextMate) y resaltado semántico (Semantic Tokens).
• Analizador estático (Static Analysis) en línea, con subrayado y mensajes en español.
• Autocompletado inteligente (IntelliSense) para variables visibles, parámetros, funciones, biblioteca estándar y palabras reservadas del lenguaje.
• Vista de esquema (Outline), migas de pan (Breadcrumbs), navegación a definiciones (Code Navigation), búsqueda de referencias (Symbol Resolution) y renombrado seguro (Rename Symbol).
• Información de cursor (Hover Information) y ayuda de parámetros (Inlay Hints).

Herramientas de aprendizaje integradas a VS Code

• Visualizador en línea y en tiempo real de costo algorítmico.
• Informe interactivo de complejidad algorítmica, clasificación asintótica, mejor y peor caso, navegación al código, cadena de llamadas y alcance explícito de cada conclusión.
• Visualizador en tiempo real de diagrama de flujo, con minimapa interativo, temas visuales, sincronización bidireccional y reproducción paso a paso de ejecución.
• Exportación de diagramas de flujo en formato SVG.
• Depurador DAP integrado con pausa y continuación (Continue), entrar (Step Into), pasar por encima (Step Over), salir (Step Out) y cancelación (Stop) controlada sobre la ejecución real.
• Puntos de interrupción (Breakpoints) básicos, condicionales, por conteo de impactos, disparados y punto de registro (Logpoints) con expresiones CLRS.
• Estado de depuración con pila de llamadas, parámetros, variables locales, variables globales y valores expandibles.
• Videojuego educativo BROKER.95 (Entorno de aprendizaje gamificado para programación y algoritmia) con escena Kaplay, sistema de terminal simulada, sistema de contratos y economía, sistema de aprendizaje progresivo, sistema de estadísticas y sistema de configuración.

📖 Filosofía del proyecto

El proyecto está diseñado bajo los siguientes principios:

• Implementación de lenguaje tipo pseudocódigo (CLRS) en español.
• Baja fricción para principiantes y alto rigor para avanzados.
• Entorno de observación del código mediante diagramas y análisis.
• Entorno de diseño de algoritmos y prototipado algorítmico.
• Inteligencia artificial (LLM) como tutor de aprendizaje y enseñanza.
• Aprendizaje autodidacta orientado en la progresión y fundamentos.
• Construcción elemental del pensamiento y criterio computacional.

En una época donde la construcción de código se delega cada vez más a la inteligencia artificial, el trabajo del humano evoluciona hacia la orquestación estratégica de la toma de decisiones guiada por el criterio y el ingenio.

CLRS Kit Español busca hacer accesible, ejecutable y observable el razonamiento computacional, para que el estudiante no sólo escriba una solución, sino que pueda comprenderla, comprobarla, analizarla y justificarla.

🧮 Características del lenguaje

Comentarios

CLRS admite comentarios de una sola línea mediante //.

// Este es un comentario
escribir "Hola"

Variables y tipos de datos

Las variables en CLRS son dinámicas, débilmente tipadas y mutables.

No existe una declaración separada de variables ni soporte para constantes. La primera asignación mediante = crea la variable y le asigna su valor inicial.

edad = 20
nombre = "Ana"
activo = VERDAD

Las variables no pueden declararse sin un valor inicial.

CLRS admite tres tipos básicos de valores:

Una variable puede cambiar el tipo de valor que almacena durante la ejecución.

dato = 10
dato = "texto"

Ámbito de las variables

Las variables pueden tener ámbito global o ámbito de función.

Las estructuras si, mientras y para no crean ámbitos adicionales.

valor = 10

si valor > 5
    resultado = valor * 2

escribir resultado

Entrada y salida

escribir

La instrucción escribir permite mostrar información en la consola.

Puede utilizarse con:

• valores individuales;
• varias expresiones separadas por comas;
• concatenaciones;
• arreglos completos.

nombre = "Ana"
edad = 20

escribir nombre
escribir "Edad:", edad
escribir "Hola " + nombre

leer

La instrucción leer permite obtener valores desde la consola.

Puede leer una o varias variables en una misma instrucción y determina automáticamente el tipo del valor introducido.

edad = 0
leer edad

También es posible leer varios valores:

a = 0
b = 0

leer a, b

leer asigna valores, pero no declara variables. Por ello, las variables deben existir previamente.

Secuencias de escape

Las cadenas admiten las siguientes secuencias de escape:

Ejemplo:

escribir "Hola\nMundo"

Arreglos

Los arreglos en CLRS son dinámicos.

Su tamaño y número de dimensiones se determinan conforme se utilizan nuevas posiciones.

numeros[0] = 10
numeros[1] = 20
numeros[2] = 30

También pueden utilizarse arreglos multidimensionales:

matriz[0][0] = 10
matriz[0][1] = 20
matriz[1][0] = 30

Es posible asignar arreglos completos entre variables. La asignación copia el contenido correspondiente.

A[0] = 10
A[1] = 20

B = A

Estructuras de selección

CLRS dispone de una única estructura principal de selección: si.

Puede combinarse con sino si y sino.

edad = 20

si edad >= 18
    escribir "Mayor de edad"
sino
    escribir "Menor de edad"

También pueden encadenarse varias condiciones:

calificacion = 85

si calificacion >= 90
    escribir "Excelente"
sino si calificacion >= 70
    escribir "Aprobado"
sino
    escribir "No aprobado"

Los bloques de código se delimitan mediante indentación, por lo que debe mantenerse una estructura consistente.

Operadores

CLRS incluye operadores similares a los utilizados en otros lenguajes de programación.

Aritméticos

+  -  *  /  %  ^

Relacionales

==  !=  <  >  <=  >=

Lógicos

y  o  no

Ejemplo:

si edad >= 18 y activo
    escribir "Acceso permitido"

Estructuras repetitivas

para hasta

La variante hasta incrementa automáticamente la variable de iteración hasta alcanzar el valor final.

para i = 1 hasta 5
    escribir i

Resultado:

1
2
3
4
5

para bajando

La variante bajando realiza el recorrido en sentido descendente.

para i = 5 bajando 1
    escribir i

Resultado:

5
4
3
2
1

mientras

La estructura mientras ejecuta repetidamente un bloque mientras su condición sea verdadera.

i = 1

mientras i <= 5
    escribir i
    i = i + 1

Funciones

Las funciones se definen mediante:

• un identificador;
• una lista de parámetros;
• un bloque de instrucciones.

La convención utilizada en CLRS consiste en escribir los nombres de las funciones en mayúsculas, utilizando _ para separar palabras.

SUMAR(a, b)
    retornar a + b

Las funciones pueden recibir cualquier cantidad de parámetros.

PROMEDIO(a, b, c)
    retornar (a + b + c) / 3

La instrucción retornar permite devolver un valor.

Llamadas a funciones

Una función se invoca utilizando su nombre y sus argumentos:

resultado = SUMAR(10, 20)

Las llamadas también pueden utilizarse directamente dentro de expresiones:

total = SUMAR(10, 20) * 2

Después de una llamada no debe agregarse un bloque indentado, ya que este podría interpretarse como la definición de una función.

Arreglos como parámetros

Las funciones pueden recibir arreglos.

Para indicar que un parámetro es un arreglo se especifica su número de dimensiones:

MOSTRAR(datos[])
    para i = 0 hasta LONG(datos) - 1
        escribir datos[i]

Para arreglos de dos dimensiones:

PROCESAR(matriz[][])

Al realizar la llamada, únicamente se utiliza el identificador del arreglo:

MOSTRAR(numeros)

Función PRINCIPAL

Una función llamada PRINCIPAL puede utilizarse como punto de entrada del programa.

PRINCIPAL()
    escribir "Inicio del programa"

No es necesario invocarla explícitamente.

PRINCIPAL()

se ejecuta automáticamente como punto de inicio del programa.

Ejemplo funcional de código

Algoritmo clásico de ordenamiento burbuja.

BURBUJA(A)
    n = LONG(A)

    para i = 0 hasta n - 2
        para j = 0 hasta n - i - 2
            si A[j] > A[j + 1]
                intercambio = A[j]
                A[j] = A[j + 1]
                A[j + 1] = intercambio

    retornar A

PRINCIPAL()
    A[0] = 5
    A[1] = 2
    A[2] = 9
    A[3] = 1
    A[4] = 6

    escribir "Sin ordenar:"
    escribir A

    escribir "Ordenado:"
    A = BURBUJA(A)
    escribir A

Diagnósticos

Los errores causados por el código CLRS se muestran en español y conservan la ubicación obtenida del código fuente.

CLRS Runtime
────────────────────────
▶ programa.clrs

✕ Error de sintaxis

  Se esperaba «)», pero se encontró «escribir».
  Línea 2, columna 5

────────────────────────
Estado: No ejecutado

📚 Biblioteca estándar de CLRS

La biblioteca estándar de CLRS proporciona funciones integradas para el manejo operaciones matemáticas, cadenas, arreglos y archivos.

📁 Archivos

🔢 Matemáticas

🔤 Cadenas

📦 Arreglos

🔩 Tipos

⚠️ Errores

📊 Análisis algorítmico

CLRS Kit Español incluye herramientas para estudiar el comportamiento teórico de un algoritmo directamente desde el código fuente.

El análisis se divide en dos partes:

1. Análisis de costo: muestra cómo se construye la función de costo a partir de las instrucciones.
2. Análisis de complejidad: simplifica ese costo y determina, cuando es posible, su orden de crecimiento asintótico.

🧮 Análisis de costo

El análisis de costo permite observar cuánto trabajo aporta cada parte de un algoritmo.

Las expresiones se generan automáticamente a partir del Árbol de Sintaxis Abstracta (AST).

Ejemplo:

SUMAR(A[])
    total = 0

    para i = 0 hasta LONG(A) - 1
        total = total + A[i]

    retornar total

El analizador puede reconocer que el cuerpo del ciclo se ejecuta aproximadamente n veces y construir una función de costo a partir de sus instrucciones.

Iteraciones

El analizador intenta determinar cuántas veces se ejecuta cada ciclo.

Ciclos para

Reconoce recorridos ascendentes y descendentes:

para i = 0 hasta n - 1
    escribir i

para i = n bajando 1
    escribir i

Ciclos mientras

También reconoce progresiones sencillas.

Crecimiento aditivo

i = 0

mientras i < n
    i = i + 1

El número de iteraciones crece linealmente con n.

Reducción multiplicativa

i = n

mientras i > 1
    i = i / 2

El número de iteraciones crece logarítmicamente.

También se reconocen algunas transformaciones equivalentes:

i = PISO(i / 2)

i = REDONDEA(i / 2)

Cuando el costo no puede determinarse

El analizador utiliza un criterio conservador.

Si no puede demostrar cuántas veces se ejecuta una estructura, la cantidad se conserva como desconocida:

?

Esto puede ocurrir, por ejemplo, cuando:

• el límite cambia dentro del ciclo;
• la actualización depende de una condición;
• el paso no puede determinarse;
• no puede demostrarse la terminación;
• intervienen funciones cuyo efecto no puede analizarse.

El analizador evita asumir automáticamente que un ciclo realiza n iteraciones cuando no existe evidencia suficiente.

Llamadas entre funciones

El costo puede propagarse entre funciones propias del programa.

PROCESAR(A[])
    ORDENAR(A)
    retornar A

El análisis conserva:

• la función llamada;
• los parámetros utilizados;
• los argumentos reales;
• el costo transferido entre funciones.

Los parámetros que no participan en la complejidad no afectan innecesariamente el resultado.

📈 Análisis de complejidad

El análisis de complejidad utiliza las expresiones de costo para estudiar cómo crece el trabajo del algoritmo conforme aumenta el tamaño de la entrada.

El informe puede analizar cada función de manera independiente.

Interpretación de los resultados

El informe distingue diferentes tipos de conclusiones.

Cuando el resultado no puede justificarse, la interfaz muestra:

No determinado

Simplificación asintótica

El clasificador puede:

• eliminar constantes;
• ignorar coeficientes constantes;
• combinar productos;
• reconocer ciclos anidados;
• seleccionar términos dominantes;
• conservar diferentes variables cuando existen varias medidas de entrada.

Por ejemplo:

3n² + 5n + 8

se clasifica como:

O(n²)

Complejidad multivariable

Cuando un algoritmo depende de varias entradas independientes, el análisis puede conservar diferentes variables.

Por ejemplo:

PROCESAR(A[], B[])

puede producir una clasificación como:

O(n + m)

donde n representa el tamaño de A y m el tamaño de B.

Complejidades reconocidas

El analizador puede determinar automáticamente muchas familias comunes:

Sumatorias y ciclos dependientes

El analizador también puede reconocer algunas sumatorias cuyo número de iteraciones depende del índice.

Por ejemplo:

para i = 1 hasta n
    para j = 1 hasta n / i
        escribir j

La suma:

n/1 + n/2 + n/3 + ... + n/n

puede clasificarse como:

O(n log n)

Cuando la forma de la sumatoria no puede demostrarse de manera segura, el resultado permanece como No determinado.

Funciones recursivas

Las funciones recursivas se estudian mediante sus relaciones de recurrencia.

El analizador puede reconocer reducciones como:

T(n - 1)
T(n / 2)
2T(n / 2)
T(√n)

y algunas estructuras más complejas.

Según el caso, puede utilizar métodos como:

Ejemplos que pueden reconocerse:

T(n) = T(n - 1) + O(1)

T(n) = 2T(n / 2) + O(n)

T(n) = T(√n) + O(1)

En el último caso puede obtenerse:

O(log log n)

cuando las condiciones necesarias pueden demostrarse.

Recursión mutua

El analizador también estudia grupos de funciones que se llaman entre sí.

A(n)
    B(n - 1)

B(n)
    A(n - 1)

Estas relaciones se analizan mediante el grafo de llamadas.

Si el sistema no puede demostrar una reducción válida, un caso base o una familia de recurrencia soportada, el resultado permanece como:

No determinado

Informe de complejidad

El botón Mostrar informe de complejidad algorítmica abre una vista dedicada al análisis de las funciones del documento.

Cada función puede mostrar:

1. Función de costo
2. Simplificación algebraica
3. Conclusión asintótica
4. Verificación del resultado

Las expresiones matemáticas se muestran mediante KaTeX.

Cuando intervienen varias funciones, el informe puede mostrar también la cadena de llamadas utilizada para obtener el resultado.

PRINCIPAL
   ↓
ORDENAR
   ↓
PARTICIONAR

Desde el informe es posible regresar a la declaración correspondiente mediante Ir al código fuente.

Mejor y peor caso

Cuando la estructura del algoritmo permite distinguir diferentes comportamientos, el informe presenta por separado:

Mejor caso

y

Peor caso

Cada resultado indica además si se trata de:

• una cota ajustada;
• una cota superior o inferior;
• un resultado condicionado;
• una cota conservadora;
• un resultado no determinado.

Alcance del análisis

El análisis es deliberadamente conservador.

Una complejidad sólo se presenta cuando existe evidencia suficiente para justificarla. Algunos algoritmos, ciclos o recurrencias pueden permanecer como No determinado si su comportamiento no puede demostrarse automáticamente.

El análisis automático no sustituye el razonamiento manual. Su objetivo es proporcionar una referencia visual y ayudar a comprender cómo el código se relaciona con su función de costo y su crecimiento asintótico.

🗺️ Generador de diagramas de flujo

El generador de diagramas de flujo convierte automáticamente el código CLRS en una representación visual del flujo del programa.

El diagrama se abre dentro de Visual Studio Code y permanece sincronizado con el archivo mientras trabajas.

Abrir el diagrama

Puedes abrirlo desde:

• Paleta de comandos → Mostrar diagrama de flujo

El diagrama aparecerá en un panel junto al editor.

Sincronización con el código

El diagrama se actualiza automáticamente cuando modificas el archivo.

También se sincroniza con la posición del cursor:

• La instrucción actual se resalta en el diagrama.
• Al seleccionar un nodo, el editor puede llevarte a su línea correspondiente.
• No es necesario regenerar manualmente el diagrama después de cada cambio.

Esto permite utilizar el diagrama como una representación visual del código mientras programas.

Diagramar sólo una parte del código

Si seleccionas un fragmento antes de abrir el generador, se crea un diagrama únicamente para esa selección.

Esto resulta útil para estudiar:

• una función;
• un ciclo;
• un condicional;
• una sección concreta de un programa grande.

El contenido seleccionado permanece como ámbito del diagrama durante esa sesión.

Elementos compatibles

El generador reconoce las principales estructuras de CLRS.

Las funciones se muestran como subgrafos independientes, facilitando la lectura de programas con varias funciones.

Apariencia

El diagrama puede adaptarse visualmente desde su barra de herramientas.

El tema predeterminado es VS Code, por lo que utiliza los colores del tema activo del editor.

Esto permite que el diagrama se adapte automáticamente a:

• temas claros;
• temas oscuros;
• temas de alto contraste.

También están disponibles otros estilos:

Los cambios se aplican inmediatamente.

Dirección del flujo

Puedes cambiar la orientación del diagrama.

La orientación se aplica tanto al flujo principal como a las funciones.

Navegación

El diagrama puede explorarse de forma interactiva.

Entre las acciones disponibles se encuentran:

• acercar y alejar con zoom;
• desplazar el diagrama;
• ajustar todo el contenido al panel;
• centrar el nodo actual;
• abrir una instrucción directamente en el editor;
• navegar entre nodos mediante teclado;
• consultar la línea y columna de una instrucción.

Esto facilita trabajar con diagramas grandes sin perder la referencia del código original.

Buscar nodos

El campo Buscar nodo… permite localizar contenido dentro del diagrama.

La búsqueda puede encontrar:

• texto de instrucciones;
• identificadores;
• tipos de nodo;
• referencias.

No distingue entre mayúsculas, minúsculas o tildes.

Controles disponibles:

Las coincidencias se resaltan y la coincidencia activa se centra automáticamente.

Mostrar sólo una parte del flujo

La opción Flujo visible permite seleccionar qué parte del programa quieres visualizar.

Puedes mostrar:

• todo el programa;
• flujo principal;
• flujo global;
• una función concreta.

Cuando una función se muestra de forma aislada, la sincronización con el código sigue funcionando.

Si exportas el diagrama en ese momento, sólo se exportará el flujo visible.

Minimapa

El minimapa muestra una vista general del diagrama.

Permite:

• conocer qué parte del diagrama estás observando;
• seguir el zoom y desplazamiento;
• moverte rápidamente haciendo clic en otra zona.

Puede mostrarse u ocultarse desde la barra de herramientas.

Visualización de la ejecución

El diagrama también puede mostrar el recorrido real de un programa mientras se ejecuta.

Con el diagrama abierto, utiliza:

• Ejecutar código CLRS

La ejecución continúa realizándose normalmente en la terminal integrada.

Por lo tanto, características como:

• leer;
• escribir;
• errores de ejecución;

mantienen su comportamiento habitual.

Durante la ejecución

El diagrama muestra visualmente el recorrido realizado por el programa.

Esto permite observar el algoritmo como una secuencia de pasos reales.

Revisar la traza

Después o durante la ejecución puedes revisar el recorrido mediante los controles inferiores.

Entre las acciones disponibles se encuentran:

• ir al primer paso;
• paso anterior;
• reproducir;
• pausar;
• paso siguiente;
• regresar al paso más reciente.

La reproducción admite diferentes velocidades:

0.5×
1×
2×

Cuando estás situado en el paso más reciente, los nuevos eventos pueden seguirse en vivo.

La traza corresponde al código ejecutado

La traza pertenece exactamente a la versión del archivo que fue ejecutada.

Si modificas el código después de la ejecución, la traza anterior se descarta para evitar mostrar pasos que ya no corresponden con el nuevo programa.

El diagrama y el depurador funcionan de manera independiente.

Límite de la traza

Por seguridad, el panel conserva como máximo:

10 000 pasos

Si el programa supera esta cantidad, la ejecución continúa normalmente, pero el diagrama indica que la traza fue limitada.

Exportar el diagrama

Los diagramas pueden exportarse como archivos SVG.

Utiliza:

• Paleta de comandos → Exportar diagrama de flujo SVG

Después selecciona la ubicación y el nombre del archivo.

El formato SVG puede ampliarse sin perder calidad.

Es especialmente útil para:

• documentación;
• reportes;
• presentaciones;
• tareas;
• proyectos académicos.

Exportación de vistas parciales

Si estás visualizando únicamente una función o un flujo específico, la exportación genera solamente esa parte del diagrama.

Esto permite crear diagramas individuales de funciones sin tener que modificar el código fuente.

Consideraciones

• Los diagramas se generan a partir del Árbol de Sintaxis Abstracta (AST) del programa.
• El código debe ser sintácticamente válido para poder generar el diagrama.
• Las funciones se organizan automáticamente como subgrafos.
• La vista se mantiene sincronizada con el documento mientras trabajas.
• El diagrama de ejecución normal y el depurador funcionan de forma independiente.
• Si el código cambia, las trazas antiguas se descartan para evitar mostrar información incorrecta.

Uso práctico

El generador puede utilizarse principalmente para tres tareas:

El objetivo del generador no es sustituir la lectura del código, sino hacer visible su estructura y su ejecución de una forma más fácil de seguir.

🎮 BROKER.95

BROKER.95 es un videojuego educativo integrado en CLRS Kit Español.

Su objetivo es convertir la práctica de programación en una experiencia basada en contratos, progresión, recompensas, riesgo y aprendizaje. El código continúa escribiéndose normalmente en el editor de Visual Studio Code.

Puedes abrirlo mediante:

• Paleta de comandos → Jugar BROKER.95
• El botón con icono de mando disponible en documentos .clrs

CIPHER

Dentro del juego interactúas con CIPHER, una inteligencia artificial que participa como:

• generador de contratos;
• tutor durante la resolución;
• asistente para dudas;
• evaluador de entregas.

CIPHER puede ayudarte a comprender errores y orientar tu solución, pero el progreso del juego depende de los resultados obtenidos al resolver los contratos.

Contratos

Los contratos representan problemas de programación que debes resolver utilizando CLRS.

Cada contrato puede incluir:

• descripción del problema;
• requerimientos;
• casos de prueba;
• recompensa potencial;
• nivel de riesgo.

El flujo principal es:

OBTENER CONTRATO
       ↓
ACEPTAR
       ↓
PROGRAMAR EN CLRS
       ↓
REVISAR
       ↓
ENTREGAR
       ↓
RESULTADO Y RECOMPENSA

Los contratos pueden abarcar desde ejercicios elementales hasta problemas algorítmicos más avanzados.

Riesgo y recompensa

Los contratos pueden tener diferentes niveles de riesgo:

Una mejor resolución puede producir una mayor recompensa.

El juego también mantiene elementos como:

• saldo;
• alerta;
• contratos completados;
• contratos fallidos;
• estadísticas;
• progreso.

Aprendizaje

BROKER.95 incluye un modo de aprendizaje estructurado en dos rutas:

Programación está disponible desde el inicio.

Algoritmia se desbloquea después de completar la ruta de Programación.

Ruta de aprendizaje

Cada ruta se presenta como un recorrido progresivo formado por secciones y lecciones.

Las lecciones pueden incluir:

• objetivo;
• explicación;
• ejemplos en CLRS;
• conceptos nuevos;
• notas;
• ejercicios prácticos.

El progreso se conserva y las lecciones se desbloquean de forma secuencial.

Ejercicios educativos

Desde una lección puedes solicitar un ejercicio relacionado con los conocimientos estudiados hasta ese momento.

Los ejercicios:

• mantienen una dificultad reducida;
• utilizan conocimientos ya introducidos;
• evitan conceptos futuros;
• se evalúan principalmente por su funcionamiento;
• pueden recomendar herramientas de CLRS como apoyo, pero nunca exigirlas.

Ayuda durante un contrato

BROKER.95 dispone de varias formas de interactuar con CIPHER.

ai -ask está pensado para resolver dudas sin entregar ni evaluar todavía el contrato.

Terminal de BROKER.95

El juego incluye una terminal propia para administrar contratos.

Algunos comandos principales son:

El código sigue en Visual Studio Code

BROKER.95 no incluye un editor de código independiente.

Los programas se escriben directamente en archivos .clrs utilizando el editor habitual de Visual Studio Code.

Esto permite utilizar junto al juego las demás herramientas de CLRS Kit Español, como:

• diagnósticos;
• ejecución;
• depuración;
• diagramas de flujo;
• análisis algorítmico.

BROKER.95 funciona como una capa de práctica y aprendizaje alrededor del entorno normal de CLRS, no como un sustituto del editor.

Modelos de IA

CIPHER puede utilizar diferentes proveedores de IA o un modelo local.

Entre las opciones disponibles se encuentran:

• OpenAI;
• Groq;
• Gemini;
• DeepSeek;
• Ollama local.

La configuración se realiza desde el propio panel de BROKER.95.

Se recomienda ampliamente un modelo igual o superior a 7B de parámetros para una experiencia rápida y respuestas precisas.

Progreso persistente

La partida conserva automáticamente información como:

• dinero;
• alerta;
• contratos;
• estadísticas;
• progreso educativo;
• mejores resultados.

El progreso de Programación y Algoritmia se mantiene de forma independiente.

Objetivo de BROKER.95

BROKER.95 busca transformar la práctica repetida de programación en una experiencia más motivadora mediante:

APRENDER
   ↓
RECIBIR UN RETO
   ↓
PROGRAMAR
   ↓
COMPROBAR
   ↓
RECIBIR RETROALIMENTACIÓN
   ↓
MEJORAR
   ↓
PROGRESAR

La idea central no es sustituir el aprendizaje tradicional, sino ofrecer un entorno donde practicar programación y algoritmia mediante problemas concretos, progresión y retroalimentación continua.