Lista más reciente de verificación de rendimiento de IA en Programación

Programación

Anthropic Claude Sonnet 5 VS OpenAI GPT-5.6

Analizador de registros del servidor web

Escriba una función de Python analyze_logs(log_data) que reciba una cadena multilínea que contenga entradas de registro del servidor web. La función debe analizar estos registros, realizar un análisis y devolver un diccionario que resuma los resultados. Cada línea de registro válida sigue este formato: [TIMESTAMP] LEVEL IP_ADDRESS "REQUEST_METHOD /path" RESPONSE_CODE BYTES_SENT Ejemplo de una línea válida: [2023-10-27T10:00:00Z] INFO 192.168.1.1 "GET /index.html" 200 1543 Su función debe: Analizar únicamente las líneas de registro válidas, ignorando de forma elegante cualquier línea malformada o vacía. Calcular las siguientes métricas: total_requests: El recuento total de entradas de registro válidas. error_rate: El porcentaje de solicitudes con un LEVEL de ERROR, redondeado a dos decimales. top_3_ips: Una lista de tuplas, donde cada tupla contiene una dirección IP y su recuento de solicitudes, para las 3 IP más frecuentes. La lista debe estar ordenada en orden descendente por recuento de solicitudes. busiest_hour: La hora del día (un entero de 0 a 23) que tuvo más solicitudes. La marca de tiempo está en formato ISO 8601 (UTC). Devolver un diccionario con las claves total_requests, error_rate, top_3_ips y busiest_hour que contenga los valores calculados. Maneje los siguientes casos límite: Si la cadena de entrada log_data está vacía, devuelva un diccionario con valores a cero o vacíos según corresponda (por ejemplo, total_requests: 0, top_3_ips: []). Si hay menos de 3 direcciones IP únicas, la lista top_3_ips debe contener todas las IP únicas, ordenadas por recuento. Si hay un empate por la hora con más actividad, es aceptable devolver cualquiera de las horas empatadas.

262

25 Jul 2026 01:19

Programación

OpenAI GPT-5.6 VS Google Gemini 2.5 Pro

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: 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). 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. 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. 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. El limitador debe ser seguro bajo acceso concurrente desde múltiples hilos o tareas async. 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.

269

16 Jul 2026 09:49

Programación

Anthropic Claude Opus 4.8 VS Google Gemini 2.5 Flash

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: 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. 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.

294

29 Jun 2026 09:44

Programación

Anthropic Claude Opus 4.8 VS Google Gemini 2.5 Pro

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.

335

15 Jun 2026 09:43

Programación

Anthropic Claude Fable 5 VS OpenAI GPT-5.5

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: Recibir la lista de diccionarios de tareas como entrada. 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. Detectar y manejar dependencias circulares. Si se encuentra un ciclo, debe lanzar un ValueError con un mensaje descriptivo. Detectar y manejar casos donde un ID de dependencia no corresponde a ninguna tarea existente. Esto también debe lanzar un ValueError.

357

12 Jun 2026 09:39

Programación

OpenAI GPT-5.5 VS Google Gemini 2.5 Flash

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: 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. 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. 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). Fuente de tiempo: Haz que el reloj sea inyectable para que las pruebas sean deterministas. Usa por defecto un reloj monotónico. 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. 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. 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.

457

12 May 2026 09:45

Programación

Anthropic Claude Opus 4.7 VS OpenAI GPT-5.4

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: Encabezados: Las líneas que comienzan con # hasta ###### deben convertirse en etiquetas <h1> a <h6>. 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. 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. Párrafos: Cualquier otro texto debe envolverse en etiquetas . 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: Negrita y cursiva: ***text*** debe convertirse en text. Negrita: **text** debe convertirse en text. Cursiva: *text* debe convertirse en text. 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 *italic. 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: # 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!")

556

22 Apr 2026 09:40

Programación

Anthropic Claude Sonnet 4.6 VS OpenAI GPT-5.4

Implementar un limitador de tasa Token Bucket seguro para subprocesos en Python

Escribe una clase en Python llamada TokenBucketRateLimiter que implemente el algoritmo Token Bucket para limitar la tasa. La implementación debe ser segura para subprocesos (thread-safe) y no debe usar ninguna biblioteca externa para la gestión del estado (como Redis). La clase debe tener las siguientes especificaciones: Un __init__(self, capacity, refill_rate) método: capacity: El número máximo de tokens que el cubo puede contener. refill_rate: El número de tokens que se añaden al cubo por segundo. Un consume(self, tokens) método: Este método intenta consumir un número dado de tokens del cubo. Debe devolver True si los tokens pueden consumirse con éxito, y False en caso contrario. Antes de intentar consumir, el cubo debe rellenarse con tokens en función del tiempo transcurrido desde la última llamada. Seguridad para subprocesos: La clase debe ser segura para usarse desde múltiples hilos concurrentes. Todas las operaciones que modifican el estado del cubo (como rellenar y consumir tokens) deben ser atómicas. Proporcione la implementación completa de la clase con las importaciones necesarias.

556

16 Apr 2026 09:37

Programación

Anthropic Claude Haiku 4.5 VS OpenAI GPT-5.4

Herramienta de sincronización de archivos desde la línea de comandos

Escribe un script en Python para una herramienta de sincronización de archivos desde la línea de comandos. El script debe aceptar tres argumentos de línea de comandos: source_path: La ruta al directorio fuente. replica_path: La ruta al directorio réplica que se sincronizará. log_file_path: La ruta a un archivo donde se registrarán todas las operaciones. Funcionalidad principal: Sincronización unidireccional: La herramienta debe realizar una sincronización unidireccional, haciendo que el directorio replica_path sea una copia exacta del directorio source_path. Archivos y directorios presentes en la fuente pero no en la réplica deben copiarse a la réplica. Archivos y directorios presentes en la réplica pero no en la fuente deben eliminarse de la réplica. Archivos presentes en ambas ubicaciones pero con contenido diferente deben actualizarse en la réplica (la versión de la fuente sobrescribe la de la réplica). Detección de cambios: Usar el hash MD5 del contenido de los archivos para determinar si un archivo necesita ser actualizado. No confiar en las marcas de tiempo de modificación. Registro (logging): Registrar todas las operaciones sobre archivos (por ejemplo, "COPIAR file.txt", "ELIMINAR old_dir", "ACTUALIZAR changed.log") tanto en la consola como en el archivo de registro especificado. Cada entrada de registro debe llevar una marca de tiempo. Ejecución: El script debe realizar la operación de sincronización exactamente una vez y luego salir. No debe ejecutarse en un bucle. Requisitos: Usar Python 3. Usar la biblioteca argparse para el análisis de argumentos de línea de comandos. La solución debe manejar correctamente directorios anidados, directorios vacíos y archivos de diversos tamaños. El script debe ser un único archivo autocontenido.

566

09 Apr 2026 09:38

Programación

Google Gemini 2.5 Flash VS OpenAI GPT-5.4

Implementar una caché LRU concurrente sin bloqueo global

Implementa una caché LRU (Least Recently Used) segura para subprocesos en Python que admita lecturas y escrituras concurrentes sin usar un bloqueo global para cada operación. Tu implementación debe cumplir los siguientes requisitos: Interfaz: La caché debe soportar estas operaciones: __init__(self, capacity: int) — Inicializa la caché con una capacidad máxima dada (entero positivo). get(self, key: str) -> Optional[Any] — Devuelve el valor asociado a la clave si existe (y lo marca como utilizado recientemente), o devuelve None si la clave no está en la caché. put(self, key: str, value: Any) -> None — Inserta o actualiza el par clave-valor. Si la caché excede la capacidad después de la inserción, expulsa el elemento menos recientemente usado. delete(self, key: str) -> bool — Elimina la clave de la caché. Devuelve True si la clave estaba presente, False en caso contrario. keys(self) -> List[str] — Devuelve una lista de todas las claves actualmente en la caché, ordenadas desde la más recientemente usada hasta la menos recientemente usada. Concurrencia: La caché debe ser segura para ser usada desde múltiples hilos simultáneamente. Apunta a un diseño que permita que las lecturas concurrentes procedan sin bloquearse entre sí cuando sea posible (por ejemplo, utilizando locks de lectura/escritura, bloqueo fino por fragmentos, o técnicas lock-free). Un mutex global único que serialice cada operación se considera una solución básica pero subóptima. Corrección bajo contención: Bajo acceso concurrente, la caché nunca debe devolver datos obsoletos o corrompidos, nunca debe exceder su capacidad indicada y debe mantener un orden LRU consistente. Casos límite a manejar: Capacidad de 1 put con una clave que ya existe (debe actualizar el valor y moverla a la más reciente) delete de una clave que no existe put y get concurrentes sobre la misma clave Evicciones secuenciales rápidas cuando muchos hilos insertan simultáneamente Pruebas: Incluye una función de prueba run_tests() que demuestre la corrección de todas las operaciones tanto en escenarios mono-hilo como multi-hilo. La prueba multi-hilo debe usar al menos 8 hilos que realicen una mezcla de operaciones get, put y delete sobre claves superpuestas, y debe afirmar que la caché nunca excede la capacidad y que get nunca devuelve un valor para una clave que nunca fue insertada. Proporciona tu implementación completa en Python. Usa únicamente la biblioteca estándar (sin paquetes de terceros). Incluye docstrings y comentarios que expliquen tu estrategia de concurrencia y cualquier compensación de diseño que hayas hecho.

585

23 Mar 2026 17:47

Programación

Anthropic Claude Haiku 4.5 VS OpenAI GPT-5.2

Analizador avanzado de archivos de registro para un formato personalizado

Escribe una función de Python parse_log(log_content: str) -> list que analice un archivo de registro con un formato personalizado. La función debe recibir el contenido del registro como una única cadena multilínea y devolver una lista de diccionarios, donde cada diccionario representa una transacción completada con éxito. Reglas del formato de registro: START <transaction_id> <timestamp>: Marca el inicio de una transacción. transaction_id es una cadena sin espacios. timestamp es una cadena con formato ISO 8601. END <transaction_id> <status> <timestamp>: Marca el final de una transacción. El transaction_id debe coincidir con una transacción abierta. status es una sola palabra (p. ej., SUCCESS, FAIL). EVENT <key1>=<value1> <key2>="<value with spaces>" ...: Representa un evento dentro de la transacción activa actual. Consiste en uno o más pares clave-valor. Los valores que contienen espacios deben ir entre comillas dobles. COMMENT # <any text>: Una línea de comentario que debe ser ignorada. Lógica de procesamiento: La función debe procesar las líneas secuencialmente. Una línea EVENT se asocia con la transacción iniciada más recientemente que aún no ha terminado. Una transacción sólo se considera completa y válida si tiene una línea START y una línea END que coincidan en el mismo transaction_id. La salida debe ser una lista de diccionarios. Cada diccionario representa una transacción completada y debe tener las siguientes claves: transaction_id (cadena) start_time (cadena) end_time (cadena) status (cadena) events (una lista de diccionarios, donde cada diccionario interno representa los pares clave-valor de una línea EVENT). Manejo de errores y casos límite: Ignorar cualquier línea COMMENT, líneas en blanco o líneas malformadas que no coincidan con los formatos especificados. Ignorar cualquier EVENT que ocurra fuera de una transacción activa (es decir, antes del primer START o después de que una transacción se haya cerrado). Si aparece una nueva línea START antes de que la transacción anterior se haya cerrado con un END, la transacción anterior se considera "abandonada" y debe descartarse. La nueva línea START inicia una nueva transacción. Cualquier transacción que permanezca abierta al final del archivo de registro también se considera "abandonada" y no debe incluirse en la salida final.

563

23 Mar 2026 08:42

Programación

Google Gemini 2.5 Flash-Lite VS OpenAI GPT-5 mini

Implementar un limitador de tasa concurrente con ventana deslizante y colas de prioridad

Diseña e implementa un limitador de tasa (rate limiter) en Python que sea seguro para hilos (thread-safe) y que admita las siguientes características: Limitación de tasa con ventana deslizante: El limitador debe usar un algoritmo de ventana deslizante (no ventanas fijas) para hacer el seguimiento del número de solicitudes. Dado un máximo de max_requests permitido dentro de un periodo de window_seconds segundos, debe determinar con precisión si una nueva solicitud está permitida en cualquier momento. Múltiples niveles: El limitador debe soportar múltiples niveles con nombre (por ejemplo, "free", "standard", "premium"), cada uno con su propia configuración de max_requests y window_seconds. Los clientes se asignan a un nivel al registrarse. Cola de prioridad para solicitudes diferidas: Cuando una solicitud queda limitada por la tasa, en lugar de rechazarla simplemente, el limitador debe encolarla en una cola de prioridad por nivel. Cada solicitud tiene una prioridad entera (número menor = mayor prioridad). El limitador debe proporcionar un método que, cuando haya capacidad disponible, desencole y procese la solicitud en espera de mayor prioridad para un cliente dado. Seguridad para hilos: Todas las operaciones (allow_request, enqueue, dequeue, register_client) deben ser seguras para ser llamadas concurrentemente desde múltiples hilos. Limpieza: Proporciona un método para eliminar los datos de seguimiento expirados de clientes que no hayan realizado solicitudes en los últimos cleanup_threshold_seconds (configurable). Tu implementación debe incluir: Una clase RateLimiter con la interfaz descrita. Un dataclass Request o namedtuple que contenga como mínimo: client_id, timestamp, priority y payload. Manejo adecuado de casos límite: registro duplicado de clientes, solicitudes para clientes no registrados, colas de prioridad vacías, modificaciones concurrentes y problemas de precisión del reloj. Asimismo, escribe un script de demostración (en el bloque if __name__ == "__main__") que: Crea un limitador de tasa con al menos dos niveles. Registra varios clientes. Simula una ráfaga de solicitudes desde múltiples hilos, mostrando que algunas son permitidas y otras quedan encoladas. Muestra cómo las solicitudes diferidas se procesan cuando se libera capacidad. Imprime una salida clara que muestre la secuencia de eventos. Explica tus decisiones de diseño en comentarios, especialmente en lo relativo a tu implementación de la ventana deslizante, la elección de primitivos de sincronización y los compromisos que hayas hecho entre precisión y rendimiento.

609

21 Mar 2026 08:40

Programación

Google Gemini 2.5 Pro VS OpenAI GPT-5.2

Implementar un limitador de tasa concurrente con ventana deslizante y colas de prioridad

Diseña e implementa un limitador de tasa (rate limiter) en Python que sea seguro para hilos (thread-safe) y que admita las siguientes características: Limitación de tasa con ventana deslizante: En lugar de usar ventanas de tiempo fijas, implementa un algoritmo de ventana deslizante real. Cada cliente (identificado por una clave de tipo cadena) puede realizar como máximo max_requests solicitudes dentro de cualquier ventana móvil de window_seconds segundos. Niveles de prioridad: Cada solicitud tiene un nivel de prioridad (entero 1-5, donde 1 es la prioridad más alta). Cuando se alcanza el límite de tasa para un cliente, las solicitudes de menor prioridad (número mayor) deben rechazarse primero. Específicamente, si llega una nueva solicitud con prioridad P y la ventana está llena, el limitador debe comprobar si existe alguna solicitud en la ventana actual con prioridad estrictamente menor (número mayor) que P. Si es así, se "revoca" la solicitud de prioridad más baja (mayor número) y se admite la nueva solicitud de mayor prioridad. La solicitud revocada debe registrarse para que pueda informarse. Si no existe ninguna solicitud de menor prioridad para revocar, la nueva solicitud se rechaza. Permiso de ráfaga (Burst Allowance): Cada cliente puede opcionalmente tener una asignación de ráfaga burst (por defecto 0). Esto permite hasta burst solicitudes adicionales por encima de max_requests en una ventana, pero sólo si al menos la mitad de la duración de la ventana ha transcurrido desde la primera solicitud del cliente en la ventana actual. Seguridad para hilos (Thread Safety): El limitador de tasa debe ser seguro para uso concurrente desde múltiples hilos. Demuestra esto con un escenario de prueba. Estadísticas: El limitador debe rastrear estadísticas por cliente: total de solicitudes admitidas, total rechazadas, total revocadas (removidas por solicitudes de mayor prioridad) y utilización actual de la ventana (como un float de 0.0 a 1.0). Implementa la siguiente interfaz: class RateLimiter: def __init__(self, max_requests: int, window_seconds: float, default_burst: int = 0): ... def set_client_burst(self, client_id: str, burst: int) -> None: """Override burst allowance for a specific client.""" ... def allow(self, client_id: str, priority: int = 3, timestamp: float = None) -> bool: """ Check if a request is allowed. If timestamp is None, use current time. Returns True if the request is admitted, False if rejected. """ ... def get_stats(self, client_id: str) -> dict: """ Return a dict with keys: 'admitted', 'rejected', 'revoked', 'utilization' """ ... def get_revoked_log(self, client_id: str) -> list: """ Return a list of (timestamp, priority) tuples for revoked requests for the given client, in chronological order. """ ... Proporciona una implementación completa y ejecutable junto con un script de demostración que: Cree un limitador con max_requests=5, window_seconds=10.0, default_burst=2 Simule una secuencia de solicitudes de dos clientes con prioridades y marcas de tiempo variables que ejerciten todas las características (expiración por ventana deslizante, revocación por prioridad, activación de ráfaga y rechazo) Imprima las estadísticas y los registros de revocación para cada cliente al final Incluya una breve prueba multihilo con al menos 4 hilos realizando solicitudes concurrentes Asegúrate de manejar casos límite tales como: Validación del valor de prioridad (debe ser 1-5) Solicitudes que llegan exactamente en los límites de la ventana Múltiples revocaciones en secuencia Activación de la asignación de ráfaga exactamente en el punto de la mitad de la ventana IDs de cliente vacíos o desconocidos en consultas de estadísticas

611

19 Mar 2026 14:46

Programación

Google Gemini 2.5 Flash-Lite VS OpenAI GPT-5.2

Implementar una caché LRU concurrente sin bloqueo

Diseña e implementa una caché LRU (Least Recently Used) en Python que sea segura para hilos (thread-safe) y que admita lecturas y escrituras concurrentes sin usar un bloqueo global para cada operación. Tu implementación debe satisfacer los siguientes requisitos: La caché tiene una capacidad máxima fija especificada en el momento de la construcción. Soporta tres operaciones: get(key): Devuelve el valor asociado con la clave, o None si la clave no está presente. Acceder a una clave debe marcarla como la más recientemente usada. put(key, value): Inserta o actualiza el par clave-valor. Si la caché está a capacidad y se inserta una clave nueva, debe expulsarse la entrada menos recientemente usada. delete(key): Elimina la clave de la caché si está presente. Devuelve True si la clave se encontró y se eliminó, False en caso contrario. La caché debe ser segura para su uso desde múltiples hilos simultáneamente. Las operaciones get concurrentes sobre claves distintas no deberían bloquearse entre sí. Debes minimizar la contención: un único bloqueo de grano grueso alrededor de todo no es aceptable. La política de expulsión debe ser estrictamente LRU: la entrada que haya sido accedida (vía get o put) hace más tiempo debe ser la que se expulse. Maneja casos límite: capacidad de 1, put concurrentes rápidos que desencadenen expulsiones, get/put/delete entrelazados sobre la misma clave desde distintos hilos, y capacidad cero o negativa (lanza ValueError). Proporciona tu implementación completa como un único módulo Python. Incluye una breve explicación de tu estrategia de concurrencia y por qué preserva la corrección. También incluye una breve demostración (en un bloque main o una función de prueba) que genere múltiples hilos que realicen operaciones mixtas get/put/delete y que verifique (mediante aserciones) que la caché nunca supera su capacidad y que no se produce corrupción de datos.

570

19 Mar 2026 11:51

Programación

Anthropic Claude Opus 4.6 VS OpenAI GPT-5.4

Almacén de pares clave-valor en memoria con soporte para transacciones

Escribe una clase de Python InMemoryDB que implemente un sencillo almacén de datos en memoria de clave-valor con soporte para transacciones anidadas. La clase debe tener los siguientes métodos: get(key): Devuelve el valor asociado a una clave. Si la clave no existe, debe devolver None. set(key, value): Establece el valor para una clave dada. Si hay una transacción en curso, este cambio solo debe ser visible dentro de esa transacción hasta que se confirme (commit). begin(): Inicia una nueva transacción. Las transacciones pueden anidarse. commit(): Confirma todos los cambios realizados en la transacción actual a la transacción padre (o al almacén principal si es la transacción más externa). Si no hay ninguna transacción activa, debe lanzar un error. rollback(): Descarta todos los cambios realizados en la transacción actual. Si no hay ninguna transacción activa, debe lanzar un error. context: El desafío clave es gestionar el estado a través de transacciones anidadas. Un rollback debe deshacer únicamente los cambios realizados en la transacción no confirmada más reciente. Un commit debe fusionar los cambios de la transacción actual en el ámbito de la transacción padre. Solo cuando la transacción más externa se confirme, los cambios se vuelven permanentes en el almacén de datos principal. Example usage: db = InMemoryDB() # No transaction print(db.get("a")) # Expected: None db.set("a", 10) print(db.get("a")) # Expected: 10 # Transaction db.begin() db.set("a", 20) print(db.get("a")) # Expected: 20 # Nested transaction db.begin() db.set("a", 30) print(db.get("a")) # Expected: 30 # Rollback nested db.rollback() print(db.get("a")) # Expected: 20 # Commit outer db.commit() print(db.get("a")) # Expected: 20 # Error cases try: db.commit() # No transaction active except Exception as e: print(f"Error: {e}")

579

19 Mar 2026 02:35

Programación

Google Gemini 2.5 Pro VS Anthropic Claude Sonnet 4.6

Implementar un almacén de clave-valor versionado con consultas históricas

Escriba código que implemente un almacén de clave-valor versionado en memoria que soporte lecturas históricas. El almacén comienza vacío y procesa una secuencia de comandos. Cada comando mutador exitoso crea exactamente un nuevo número de versión global, empezando desde 1. Los comandos de solo lectura no deben crear una versión. Las claves y los valores son cadenas sensibles a mayúsculas y minúsculas sin espacios. Las versiones son enteros positivos. Commands: SET key value Create or overwrite key with value. DELETE key Remove key if it exists. GET key Return the current value for key, or NULL if the key does not exist. GET_VERSION key version Return the value associated with key immediately after the specified global version was created, or NULL if the key did not exist at that version. If version is greater than the latest existing version, treat it as invalid and return INVALID_VERSION. HISTORY key Return all historical states for the key in increasing version order, including deletions, formatted as version:value pairs separated by commas. Use NULL for deleted or absent-after-mutation states. If the key has never been affected by any mutating command, return EMPTY. Input format: The first line contains an integer N, the number of commands. The next N lines each contain one command. Output format: For every GET, GET_VERSION, and HISTORY command, print one line with the result. Behavior details and edge cases: Every SET always creates a new version, even if the value is unchanged. Every DELETE always creates a new version, even if the key does not exist. Versions are global across all keys, not per key. HISTORY for a key should include only versions where that key was directly affected by SET or DELETE. If a key was deleted and later set again, both events must appear in HISTORY. Efficiency matters: assume up to 200000 commands, with many historical queries. Your solution should read from standard input and write to standard output. Include the full working program in one file. You may use any mainstream programming language, but the code should be complete and executable as written.

606

18 Mar 2026 22:33

Programación

Google Gemini 2.5 Flash VS OpenAI GPT-5.2

Implementar una skip list concurrente sin bloqueo con consultas por rango

Diseña e implementa una estructura de datos skip list concurrente en el lenguaje de tu elección (C++, Java, Rust, Go o Python) que admita las siguientes operaciones: insert(key, value) – Inserta un par clave-valor. Si la clave ya existe, actualiza el valor de forma atómica. Devuelve true si se insertó una clave nueva, false si se actualizó. remove(key) – Elimina lógicamente el par clave-valor. Devuelve true si la clave se encontró y fue eliminada, false en caso contrario. find(key) – Devuelve el valor asociado a la clave, o indica ausencia. range_query(low, high) – Devuelve todos los pares clave-valor donde low <= key <= high, como una lista ordenada por clave. El resultado debe ser una instantánea consistente: no debe incluir claves que nunca estuvieron presentes simultáneamente durante la ejecución de la operación. size() – Devuelve el número aproximado de elementos activos (no eliminados). Requisitos y restricciones: La skip list debe ser segura para uso concurrente por múltiples hilos que ejecuten cualquier mezcla de las operaciones anteriores simultáneamente, sin un bloqueo global único. Puedes usar bloqueo de grano fino, técnicas sin bloqueo (CAS) o una combinación. La eliminación perezosa es aceptable: los nodos pueden marcarse lógicamente como eliminados antes de su remoción física. La generación probabilística de niveles debe usar una distribución geométrica estándar con p=0.5 y un nivel máximo de 32. Las claves son enteros de 64 bits; los valores son cadenas. Incluye consideraciones adecuadas de seguridad de memoria. Si usas un lenguaje sin recolector de basura, explica o implementa tu estrategia de recuperación de memoria (por ejemplo, reclamación basada en épocas (epoch-based reclamation), hazard pointers). Entregables: Código fuente completo, compilable/ejecutable, con comentarios que expliquen tu estrategia de concurrencia. Una prueba o demostración que lance múltiples hilos ejecutando inserciones, eliminaciones, búsquedas y consultas por rango concurrentes, y valide la corrección (por ejemplo, sin actualizaciones perdidas, sin lecturas fantasma en las consultas por rango, sin fallos). Una sección breve de análisis (como comentarios o un docstring) que discuta: Las garantías de linealizabilidad (o aislamiento por instantánea) que proporciona tu implementación. La complejidad temporal esperada de cada operación. Limitaciones conocidas o posibles problemas ABA y cómo los abordas. Tu solución será evaluada en corrección bajo concurrencia, claridad del código, solidez de la estrategia de concurrencia, calidad del mecanismo de instantánea para consultas por rango y exhaustividad del análisis.

592 1

18 Mar 2026 22:05

Programación

Anthropic Claude Opus 4.6 VS OpenAI GPT-5 mini

Implementar una clase TokenBucket para un limitador de tasa

Implementa una clase TokenBucket en el lenguaje de programación de tu elección (por ejemplo, Python, JavaScript, Java, C++). La clase debe tener: Un constructor que acepte dos argumentos: capacity: Un entero que representa el número máximo de tokens que el cubo puede contener. refill_rate: Un número que representa la tasa a la que se añaden tokens al cubo por segundo. Un método allow_request(): Este método no toma argumentos. Debe devolver True si se permite una solicitud (es decir, si hay al menos un token en el cubo), y False en caso contrario. Si se permite una solicitud, debe consumir un token del cubo. Tu implementación debe ser autocontenida y no debe depender de librerías externas para la lógica principal. Debes gestionar el estado del cubo (número actual de tokens y el tiempo de la última comprobación) dentro de la instancia de la clase.

591

18 Mar 2026 21:00

Programación

Anthropic Claude Sonnet 4.6 VS OpenAI GPT-5.4

Implementar un resolvedor de dependencias en Python

Se le ha encomendado crear un resolvedor de dependencias para un sistema simple de gestión de paquetes. Escriba una función Python resolve_dependencies(package_definitions, target_package) que determine el orden correcto de instalación para un paquete dado y sus dependencias. El argumento package_definitions es una lista de cadenas. Cada cadena define un paquete y sus dependencias directas en el formato: 'PackageName: Dep1, Dep2, ...'. Si un paquete no tiene dependencias, el formato es 'PackageName:'. Su función debe: Analizar las cadenas de entrada para construir un grafo de dependencias. Dado un target_package, encontrar todas sus dependencias (incluyendo las transitivas). Devolver una única lista de cadenas que represente el orden de instalación. Esta lista debe estar ordenada topológicamente (una dependencia debe aparecer siempre antes que el paquete que depende de ella). El target_package en sí debe ser el último elemento de la lista. La lista no debe contener duplicados. Detectar dependencias circulares. Si se encuentra un ciclo, lanzar un ValueError con un mensaje que indique claramente el ciclo (por ejemplo, 'Se detectó una dependencia circular que involucra: A -> B -> A'). Detectar paquetes faltantes. Si un paquete lista una dependencia que no está definida en package_definitions, lanzar un ValueError con un mensaje como 'Falta la definición del paquete para: C'.

637

18 Mar 2026 20:21

Programación

OpenAI GPT-5.4 VS Anthropic Claude Opus 4.6

Función de Python para la resolución de dependencias de paquetes

Escribe una función de Python llamada resolve_dependencies que tome un diccionario de paquetes y sus dependencias y devuelva un orden de instalación válido. La función debe manejar correctamente las dependencias circulares y las dependencias hacia paquetes que no estén definidos en la entrada.

679

15 Mar 2026 09:26

Últimas tareas y discusiones

Analizador de registros del servidor web

Limitador de tasa con ventana deslizante y cuotas justas multi-tenant

Implementar un simulador determinista de libro de órdenes límite

Implementar la aplicación atómica de JSON Patch en Python

Implementar un planificador de tareas basado en dependencias en Python

Limitador de tasa con ventana deslizante y tolerancia a ráfagas

Convertidor de un subconjunto de Markdown a HTML

Implementar un limitador de tasa Token Bucket seguro para subprocesos en Python

Herramienta de sincronización de archivos desde la línea de comandos

Implementar una caché LRU concurrente sin bloqueo global

Analizador avanzado de archivos de registro para un formato personalizado

Implementar un limitador de tasa concurrente con ventana deslizante y colas de prioridad

Implementar un limitador de tasa concurrente con ventana deslizante y colas de prioridad

Implementar una caché LRU concurrente sin bloqueo

Almacén de pares clave-valor en memoria con soporte para transacciones

Implementar un almacén de clave-valor versionado con consultas históricas

Implementar una skip list concurrente sin bloqueo con consultas por rango

Implementar una clase TokenBucket para un limitador de tasa

Implementar un resolvedor de dependencias en Python

Función de Python para la resolución de dependencias de paquetes

Enlaces relacionados