Programación
Compara la corrección, la calidad y la utilidad práctica del código generado.
En este genero, las capacidades que mas se intentan medir son Correccion, Integridad, Calidad del codigo.
A diferencia de system design, aqui pesa mas si el codigo realmente funciona que las decisiones de arquitectura de alto nivel.
Una puntuacion alta aqui no garantiza mejor juicio de producto, mejor arquitectura ni mejores explicaciones para principiantes.
Para que sirve un modelo fuerte en este genero
implementacion, depuracion, refactorizacion y apoyo practico al programar.
Lo que este genero por si solo no alcanza a mostrar
si el modelo es mejor para arquitectura, documentos para stakeholders o ideacion abierta.
Programación: GPT-5 mini logra el puesto 1, pero la media más alta queda 4.º
Anthropic
OpenAI
OpenAI
Puntuacion media por modelo
Como ponderamos
Sobre 37 respuestas de programación evaluadas, el liderato es de GPT-5 mini: media de 8,22 sobre 5 muestras, 5 primeros puestos y un 100 % de victorias. Es a la vez el mejor clasificado y uno de los mejor respaldados aquí, una barrida limpia a coste de gama ligera. Justo detrás, Claude Opus 4.8 ocupa el puesto 2 con 8,07 sobre solo 2 muestras y un registro perfecto del 100 %, así que conviene leerlo como una señal fuerte pero todavía provisional.
La media y el orden divergen con fuerza, porque la tasa de victorias (primeros puestos directos) pesa más que la media bruta. GPT-5.5 firma la media más alta del género, 8,9, y aun así queda 4.º, porque sobre 2 muestras solo ganó 1, un 50 % de victorias. GPT-5.4, en cambio, aporta el mayor volumen de evidencia, 8 muestras, con media de 8,41, 6 primeros puestos y un 75 % de victorias en el puesto 3. La ventaja del líder sobre el 2.º es de solo 0,15 puntos, así que la cima está muy apretada.
El caso más claro de buena media hundida por un flojo cara a cara es Gemini 2.5 Pro: media de 7,95, por encima de la zona media, pero puesto 6 con un 0 % de victorias sobre 4 muestras. Claude Sonnet 4.6 lidera el centro con 7,7 (50 % sobre 4 muestras, puesto 5), por detrás del grupo GPT-5 entre 0,5 y 1,2 puntos. Las gamas más ligeras quedan más abajo: Gemini 2.5 Flash-Lite (7,17), Gemini 2.5 Flash (6,84) y Claude Haiku 4.5 (6,48) están entre 1,0 y 1,7 puntos del líder. Con la Corrección ponderada al máximo (35), por delante de Completitud y Calidad de código (20 cada una), esas brechas apuntan a una corrección más débil en las tareas difíciles, no solo al estilo.
La mayor salvedad es el tamaño de muestra. Claude Opus 4.8 y GPT-5.5 se apoyan en 2 muestras cada uno y la mayoría se mueven entre 3 y 8, así que las medias pueden oscilar con unos pocos prompts. La diferencia de 1,74 puntos entre el primero y el último es real, pero el orden fino dentro del grupo de 8 puntos (GPT-5.5, GPT-5.4, GPT-5 mini, Claude Opus 4.8) debe leerse como provisional. Son medidas dependientes de las condiciones, no un veredicto sobre qué modelo programa mejor en general.
En resumen
Para programar con garantías hoy, GPT-5 mini es la elección más defendible: puesto 1 con un 100 % de victorias sobre 5 muestras a coste de gama ligera. GPT-5.4 es la opción de gama alta mejor evidenciada (8,41 sobre 8 muestras), mientras que la media récord de 8,9 de GPT-5.5 y el puesto 2 de Claude Opus 4.8 se apoyan ambos en 2 muestras, así que tómalos como prometedores pero no probados.
Este analisis se basa en las puntuaciones de benchmark medidas por Orivel para este genero y se actualiza periodicamente. Las puntuaciones son medidas que dependen de las condiciones, no una verdad absoluta.
Ranking de modelos fuertes en este genero
Este ranking se ordena por la puntuacion media solo dentro de este genero.
Ultima actualizacion: 16 Jul 2026 09:49
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
Tasa de victoria
Puntuacion media
| Modelos clasificados | Detalle | ||||||
|---|---|---|---|---|---|---|---|
| #1 | Claude Fable 5 | Anthropic |
100%
|
91
|
1 | 1 | Ver la evaluacion y la puntuacion de Claude Fable 5 |
| #2 | GPT-5.6 NUEVO | OpenAI |
100%
|
86
|
1 | 1 | Ver la evaluacion y la puntuacion de GPT-5.6 |
| #3 | GPT-5 mini | OpenAI |
100%
|
82
|
5 | 5 | Ver la evaluacion y la puntuacion de GPT-5 mini |
| #4 | Claude Opus 4.8 | Anthropic |
100%
|
81
|
2 | 2 | Ver la evaluacion y la puntuacion de Claude Opus 4.8 |
| #5 | GPT-5.5 | OpenAI |
50%
|
89
|
1 | 2 | Ver la evaluacion y la puntuacion de GPT-5.5 |
| #6 | Claude Sonnet 4.6 | Anthropic |
50%
|
77
|
2 | 4 | Ver la evaluacion y la puntuacion de Claude Sonnet 4.6 |
| #7 | Gemini 2.5 Pro |
0%
|
74
|
0 | 5 | Ver la evaluacion y la puntuacion de Gemini 2.5 Pro | |
| #8 | Gemini 2.5 Flash-Lite |
0%
|
72
|
0 | 3 | Ver la evaluacion y la puntuacion de Gemini 2.5 Flash-Lite | |
| #9 | Gemini 2.5 Flash |
0%
|
68
|
0 | 5 | Ver la evaluacion y la puntuacion de Gemini 2.5 Flash |
Que se evalua en Programación
Criterios y pesos usados para este ranking por genero.
Correccion
35.0%
Este criterio se incluye para comprobar Correccion en la respuesta. Tiene mas peso porque este aspecto cambia mucho el resultado global del genero.
Integridad
20.0%
Este criterio se incluye para comprobar Integridad en la respuesta. Tiene un peso importante porque afecta la calidad de forma visible, aunque no sea lo unico que importa.
Calidad del codigo
20.0%
Este criterio se incluye para comprobar Calidad del codigo en la respuesta. Tiene un peso importante porque afecta la calidad de forma visible, aunque no sea lo unico que importa.
Valor practico
15.0%
Este criterio se incluye para comprobar Valor practico en la respuesta. Tiene menos peso porque acompana el objetivo principal, pero no define por si solo este genero.
Seguimiento de instrucciones
10.0%
Este criterio se incluye para comprobar Seguimiento de instrucciones en la respuesta. Tiene menos peso porque acompana el objetivo principal, pero no define por si solo este genero.
Tareas recientes
Programación
Limitador de tasa con ventana deslizante y cuotas justas multi-tenant
Implementa una biblioteca reutilizable de limitación de tasa en un lenguaje de tu elección (Python, Go, TypeScript, Java o Rust) que haga cumplir cuotas de solicitudes por cliente usando un algoritmo de ventana deslizante, además de una política de reparto justo entre múltiples tenants. Requisitos funcionales: 1. Proporciona una clase o módulo con un método como allow(tenant_id, client_id, now_ms) que devuelva si una solicitud está permitida y, cuando se deniegue, cuántos milisegundos faltan hasta que se permita la siguiente solicitud (retry_after_ms). 2. Cada cliente está limitado a un número máximo de solicitudes dentro de una ventana de tiempo deslizante (por ejemplo, 100 requests per 60,000 ms). La configuración debe ser ajustable por tenant. 3. Implementa una verdadera ventana deslizante (ponderada o basada en registro), no una ventana de cubos fijos por calendario, de modo que los picos que cruzan los límites de los cubos se manejen correctamente. 4. Añade un límite global por tenant de modo que todos los clientes de un tenant combinados no puedan exceder un techo a nivel de tenant, y cuando el tenant esté saturado, la capacidad restante se comparta de forma justa entre los clientes activos en lugar de ser monopolizada por un solo cliente. 5. El limitador debe ser seguro bajo acceso concurrente desde múltiples hilos o tareas async. 6. La memoria no debe crecer de forma ilimitada: el estado obsoleto de clientes debe expulsarse o compactarse con el tiempo. Entregables: - La implementación completa con una API pública clara y documentación en línea de las decisiones clave. - Una breve explicación (en comentarios o una sección en prosa corta) del algoritmo de ventana deslizante que elegiste y sus concesiones de precisión/memoria. - Un conjunto de pruebas que cubra los casos límite principales descritos a continuación. Casos límite a tratar explícitamente en el código y las pruebas: - Solicitudes exactamente en el límite de la ventana. - Un cliente que queda inactivo y luego vuelve después de que la ventana haya transcurrido por completo. - Solicitudes concurrentes en carrera contra el mismo contador de cliente. - Reloj que va hacia atrás o marcas de tiempo duplicadas. - Saturación del tenant y redistribución justa entre clientes en competencia. - Expulsión de estado obsoleto de clientes sin eliminar clientes activos. Indica cualquier suposición que hagas (single-process vs distributed, disponibilidad de reloj monotónico, etc.). Si asumes un solo proceso, describe brevemente cómo se extendería el diseño a un despliegue distribuido.
Programación
Implementar un simulador determinista de libro de órdenes límite
Escribe una solución de un solo archivo en Python 3.11 que implemente la función process_events(events: list[dict]) -> dict. No uses paquetes externos. La función debe simular un pequeño libro de órdenes límite de un intercambio para un único instrumento. Recibe una lista de diccionarios de eventos en el orden de entrada y devuelve un diccionario con exactamente estas claves: trades, rejected, book. Tipos de evento: 1. Evento de nueva orden: Required fields: type="new", id, side, order_type, qty. side es "buy" o "sell". order_type es "limit" o "market". qty es un entero positivo. Una orden limit también requiere price, un número entero positivo de céntimos. Campo opcional tif es time-in-force: "GTC", "IOC", o "FOK". Si está ausente, use "GTC" para órdenes limit y "IOC" para órdenes market. Las órdenes market no pueden tener tif="GTC" y no pueden quedarse en el libro. 2. Evento de cancelación: Required fields: type="cancel", id. Cancela la cantidad restante de una orden resting actualmente en el libro con ese id. Reglas de emparejamiento: - El libro tiene bids y asks. Las órdenes limit de compra resting son bids; las órdenes limit de venta resting son asks. - La prioridad precio-tiempo es obligatoria: mejor precio primero; para el mismo precio, la orden resting aceptada antes va primero. - Una orden buy casa con asks resting mientras pueda cruzar: una market buy cruza cualquier ask; una limit buy cruza asks con ask price <= buy limit price. - Una orden sell casa con bids resting mientras pueda cruzar: una market sell cruza cualquier bid; una limit sell cruza bids con bid price >= sell limit price. - La cantidad de cada trade es min(cantidad restante del entrante, cantidad restante del resting). - El precio del trade es siempre el price limit de la orden maker resting, nunca el precio de la orden entrante. - Debe adjuntarse inmediatamente un registro de trade cuando ocurra, con exactamente estas claves: buy_id, sell_id, price, qty, taker_id, maker_id. - Las órdenes resting parcialmente ejecutadas conservan su prioridad original con la cantidad restante. Las órdenes completamente ejecutadas salen del libro. Comportamiento time-in-force: - Las órdenes limit GTC descansan (rest) cualquier resto no ejecutado en el libro. - Las órdenes IOC se ejecutan tanto como sea posible inmediatamente, luego cancelan cualquier resto. - Las órdenes FOK deben ser completamente llenables inmediatamente según el libro actual y las reglas de cruce. Si no son completamente llenables, no producen trades y no cambian el libro. Si son completamente llenables, se ejecutan normalmente. Las órdenes FOK nunca descansan en el libro. Reglas de validación y rechazo: - Si un evento está malformado, recházalo sin cambiar el libro. Adjunta un registro de rechazo a rejected con claves input_index, event, reason. La reason puede ser una cadena corta y legible por humanos. - Rechaza una nueva orden si su id ya fue usado por cualquier orden new previamente aceptada, incluso si esa orden anterior ya se ejecutó por completo o fue cancelada. - Rechaza eventos cancel para ids desconocidos o ids que ya no estén resting. - Rechaza qty y price que no sean enteros, cero o negativos. En Python, bool no debe ser aceptado como entero para estos campos. - Ignora campos extra en eventos que por lo demás sean válidos. Formato de retorno: - trades: lista de registros de trade en orden de ejecución. - rejected: lista de registros de rechazo en orden de entrada. - book: un diccionario con claves bids y asks. - book["bids"] debe listar todos los bids resting ordenados por precio descendente, luego por tiempo de resting original, cada uno como {"id": id, "price": price, "qty": remaining_qty}. - book["asks"] debe listar todos los asks resting ordenados por precio ascendente, luego por tiempo de resting original, cada uno como {"id": id, "price": price, "qty": remaining_qty}. Tu respuesta debe ser código Python ejecutable completo que defina process_events. Puedes incluir clases/funciones auxiliares y una pequeña sección de auto-prueba protegida por if __name__ == "__main__":, pero la función principal no debe leer desde stdin ni escribir en stdout.
Programación
Implementar la aplicación atómica de JSON Patch en Python
Escribe una implementación en Python 3.11 de una función llamada apply_json_patch(document, patch) que aplique una secuencia de operaciones al estilo JSON Patch a un valor compatible con JSON y devuelva el valor parcheado. El documento de entrada puede ser cualquier combinación de dict, list, str, int, float, bool y None. El parche es una lista de diccionarios de operaciones. La implementación no debe mutar el documento original ni ningún objeto anidado accesible desde él. Si alguna operación es inválida, la función debe lanzar una excepción personalizada llamada JsonPatchError y dejar el documento original sin cambios. Las operaciones soportadas son add, remove, replace, move, copy y test. Usa rutas JSON Pointer con tokens separados por barras (slash), donde la cadena vacía identifica el documento entero, los tokens decodifican ~1 como / y ~0 como ~, y cualquier otro uso de ~ es inválido. Para objetos, un token de ruta es una clave. Para arrays, un token de ruta debe ser un entero no negativo sin ceros a la izquierda excepto el token único 0; solo para add, el token final puede ser - para añadir al final. La operación add inserta en arrays en un índice de 0 hasta len(array), añade al final con '-', establece una clave en un objeto, o reemplaza el documento completo si la ruta es la cadena vacía. La operación remove requiere que el objetivo exista y lo elimina. La operación replace requiere que el objetivo exista y lo reemplaza. La operación move requiere from y path, elimina el valor en from y lo añade en path, y debe rechazar mover un valor dentro de uno de sus propios descendientes. La operación copy requiere from y path y copia profundamente (deep-copy) el valor de origen al destino. La operación test requiere value y tiene éxito solo si el objetivo actual es igual en profundidad a value, incluyendo la igualdad normal de Python para números y la igualdad exacta para cadenas, booleanos y None. Cada diccionario de operación debe contener exactamente los campos requeridos para esa operación además del campo op; campos desconocidos o faltantes son errores. La función debe ser determinista, razonablemente eficiente y depender únicamente de la biblioteca estándar de Python. Incluye cualquier función o clase auxiliar necesaria. No escribas un programa de línea de comandos ni uses paquetes externos.
Programación
Implementar un planificador de tareas basado en dependencias en Python
Escribe una función o clase en Python que programe una lista de tareas en función de sus dependencias. El planificador debe determinar el orden en que las tareas pueden ejecutarse, agrupando las tareas que pueden ejecutarse en paralelo. La entrada será una lista de diccionarios, donde cada diccionario representa una tarea con las siguientes claves: - `id`: Un identificador único de tipo cadena para la tarea. - `name`: Un nombre de tipo cadena para la tarea. - `dependencies`: Una lista de IDs (cadenas) de tareas que deben completarse antes de que esta tarea pueda comenzar. Tu implementación debe: 1. Recibir la lista de diccionarios de tareas como entrada. 2. Devolver un plan de ejecución válido como una lista de listas. Cada lista interna representa un "lote" de tareas que pueden ejecutarse concurrentemente. El orden de los lotes representa el orden de ejecución secuencial. El orden de los IDs de tareas dentro de un lote no importa. 3. Detectar y manejar dependencias circulares. Si se encuentra un ciclo, debe lanzar un `ValueError` con un mensaje descriptivo. 4. Detectar y manejar casos donde un ID de dependencia no corresponde a ninguna tarea existente. Esto también debe lanzar un `ValueError`.
Programación
Limitador de tasa con ventana deslizante y tolerancia a ráfagas
Diseña e implementa un limitador de tasa seguro para hilos en un lenguaje de tu elección (Python, Go, Java, TypeScript o Rust) que admita los siguientes requisitos: 1. **Superficie de API**: Expón al menos estas operaciones: - `allow(client_id: str, cost: int = 1) -> bool` — devuelve si la solicitud está permitida en este momento. - `retry_after(client_id: str) -> float` — devuelve los segundos hasta que haya disponible al menos 1 unidad de capacidad (0 si actualmente está permitida). - Un constructor que acepte configuración por cliente: `rate` (unidades por segundo), `burst` (máximo de unidades almacenadas), y un `window_seconds` opcional para la contabilidad de ventana deslizante. 2. **Algoritmo**: Implementa un híbrido que combine un **token bucket** (para tolerancia a ráfagas) con un **registro o contador de ventana deslizante** (para acotar el total de solicitudes permitidas dentro de `window_seconds`, evitando el abuso sostenido que un token bucket puro permitiría tras las recargas). Una solicitud se permite solo si ambas comprobaciones se superan. Justifica tu elección de estructura de datos para la ventana deslizante (registro exacto vs. aproximación ponderada de dos cubos) y analiza los compromisos de memoria/precisión en un bloque corto de comentarios o una nota adjunta. 3. **Concurrencia**: El limitador recibirá llamadas concurrentes de muchos hilos/goroutines para los mismos y distintos `client_id`. Evita que un único bloqueo global se convierta en un cuello de botella (p. ej., bloqueos por cliente o lock striping). Documenta por qué tu enfoque es correcto bajo llamadas concurrentes a `allow` (sin doble gasto de tokens, sin actualizaciones perdidas). 4. **Fuente de tiempo**: Haz que el reloj sea inyectable para que las pruebas sean deterministas. Usa por defecto un reloj monotónico. 5. **Casos límite que deben manejarse explícitamente**: - `cost` mayor que `burst` (debe rechazarse, nunca bloquear para siempre). - El reloj retrocede o hay pausas largas (p. ej., una VM suspendida): limita en lugar de fallar, y no concedas tokens sin límite. - Primera solicitud de un cliente nuevo (inicialización diferida). - Limpieza de clientes obsoletos (la memoria no debe crecer sin límite si los clientes dejan de llamar). - Tokens fraccionales / temporización por debajo del milisegundo. 6. **Pruebas**: Proporciona al menos 6 pruebas unitarias usando el reloj inyectable que cubran: permitir/denegar básico, agotamiento de ráfaga y recarga, límite de ventana deslizante independiente de la recarga del bucket, `cost > burst`, contención concurrente sobre un cliente (propiedad determinista: total permitido en T segundos ≤ rate*T + burst), y expulsión de clientes obsoletos. 7. **Complejidad**: Indica la complejidad temporal amortizada de `allow` y la complejidad de memoria por cliente. Entrega: código completo y ejecutable (un solo archivo está bien, pero puedes dividirlo en archivos si los etiquetas claramente), las pruebas y una breve nota de diseño (máx. ~250 palabras) que explique tus elecciones y la semántica precisa cuando los dos algoritmos discrepan.
Programación
Convertidor de un subconjunto de Markdown a HTML
Escribe una función en Python `markdown_to_html(markdown_text: str) -> str` que convierta una cadena que contiene un subconjunto específico de Markdown en su representación HTML correspondiente. La función debe soportar las siguientes características: **Elementos de bloque:** 1. **Encabezados:** Las líneas que comienzan con `# ` hasta `###### ` deben convertirse en etiquetas `<h1>` a `<h6>`. 2. **Listas no ordenadas:** Las líneas que comienzan con `- ` deben convertirse en `<ul>` y `<li>` tags. Las listas anidadas, indentadas por dos espacios por nivel, deben ser soportadas. Una lista termina con una línea en blanco o con un elemento de bloque diferente. 3. **Bloques de código:** El contenido encerrado entre líneas de tres backticks (```) debe convertirse a `<pre><code>...</code></pre>`. El especificador de lenguaje en los backticks de apertura (por ejemplo, ```python) debe ser ignorado. No debe aplicarse ningún otro procesamiento de Markdown dentro de un bloque de código. 4. **Párrafos:** Cualquier otro texto debe envolverse en etiquetas `<p>`. Líneas consecutivas de texto pertenecen al mismo párrafo. Los párrafos se separan por una o más líneas en blanco. **Elementos en línea:** 1. **Negrita y cursiva:** `***text***` debe convertirse en `<strong><em>text</em></strong>`. 2. **Negrita:** `**text**` debe convertirse en `<strong>text</strong>`. 3. **Cursiva:** `*text*` debe convertirse en `<em>text</em>`. **Reglas y restricciones:** - Los elementos en línea pueden anidarse dentro de encabezados y elementos de lista. - El parser debe ser robusto ante entradas malformadas o engañosas, como etiquetas en línea sin cerrar. Por ejemplo, `*italic` debe renderizarse como `<p>*italic</p>`. - El orden de precedencia para los elementos en línea es `***`, luego `**`, luego `*`. - Asuma que la entrada es una única cadena con varias líneas. - No implemente soporte para ninguna otra característica de Markdown como enlaces, imágenes, citas en bloque o listas ordenadas. - El HTML de salida no necesita ser un documento completo (no se requieren etiquetas `<html>` o `<body>`). Ejemplo de entrada: ```markdown # Header 1 This is a paragraph with **bold** and *italic* text. This is the same paragraph. - List item one - List item two with ***bold and italic*** - Nested list item - Back to the first level ```python def hello(): print("Hello, World!") ``` ```