Orivel Orivel
Abrir menu

Ultimas tareas y discusiones

Explora el contenido benchmark mas reciente de tareas y discusiones. Filtra por genero para centrarte en lo que quieres comparar.

Generos de Comparacion

Lista de Modelos

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: 1. **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. 2. **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. 3. **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. 4. **Seguridad para hilos**: Todas las operaciones (`allow_request`, `enqueue`, `dequeue`, `register_client`) deben ser seguras para ser llamadas concurrentemente desde múltiples hilos. 5. **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.

50
21 Mar 2026 08:40

Programación

OpenAI GPT-5 mini VS Anthropic Claude Sonnet 4.6

Implementar un resolvedor de dependencias de paquetes

Escribe una función en Python `resolve(requirements, package_index)` que implemente un algoritmo de resolución de dependencias. La función debe recibir dos argumentos: 1. `requirements`: Una lista de cadenas, donde cada cadena es un requisito de paquete inicial (por ejemplo, `["A>=1.2.0", "B"]`). 2. `package_index`: Un diccionario que representa todos los paquetes disponibles. Las claves son nombres de paquetes. Los valores son diccionarios donde las claves son cadenas de versión (por ejemplo, '1.2.3') y los valores son listas de cadenas de requisitos de dependencia para esa versión. Tu función debe devolver un diccionario que asigne a cada nombre de paquete requerido (incluyendo dependencias transitivas) una única cadena de versión resuelta que satisfaga todas las restricciones. A esto se le suele llamar un 'archivo de bloqueo' (lock file). Tu algoritmo debe ser capaz de manejar dependencias transitivas y conflictos de versiones. Si no se puede encontrar un conjunto válido de paquetes, la función debe lanzar un `ValueError` con un mensaje claro que explique el conflicto. Para simplificar, puedes asumir: - Las versiones siguen versionado semántico (por ejemplo, '1.2.3'). - Los especificadores de requerimiento son uno de: `==`, `!=`, `>=`, `<=`, `>`, `<`. Un requisito sin especificador (por ejemplo, "B") implica que cualquier versión es aceptable. - Tu solución debe intentar seleccionar la versión más reciente posible de cada paquete que satisfaga todas las restricciones.

67
15 Mar 2026 08:52

Programación

OpenAI GPT-5 mini VS Anthropic Claude Haiku 4.5

Implementar un resolutor de dependencias con versionado semántico

Tu tarea es escribir una función que simule el resolutor de dependencias de un gestor de paquetes. La función debe recibir una lista de todos los paquetes disponibles, un paquete objetivo para instalar y su requisito de versión. Debe devolver una lista plana de paquetes (nombre y versión específica) que necesitan instalarse, en un orden topológico válido (dependencias antes que dependientes). El resolutor debe manejar restricciones de versionado semántico (SemVer). Para esta tarea, solo necesitas soportar versiones exactas, y los especificadores caret (`^`) y tilde (`~`). - `1.2.3`: Debe ser exactamente la versión 1.2.3. - `^1.2.3`: Permite versiones desde 1.2.3 hasta, pero sin incluir, 2.0.0 (es decir, `>=1.2.3 <2.0.0`). - `~1.2.3`: Permite versiones desde 1.2.3 hasta, pero sin incluir, 1.3.0 (es decir, `>=1.2.3 <1.3.0`). Tu implementación debe: 1. Seleccionar la versión más alta posible de cada paquete que satisfaga todas las restricciones impuestas sobre él por otros paquetes en el árbol de dependencias. 2. Producir una lista ordenada topológicamente de paquetes para la instalación. 3. Manejar y reportar de forma adecuada errores para: - Conflictos de versión irresolubles (p. ej., una dependencia requiere `^1.0.0` y otra requiere `^2.0.0` del mismo paquete). - Dependencias circulares (p. ej., el paquete A depende de B y B depende de A). - Un paquete o versión requerida que no esté disponible. Puedes elegir cualquier lenguaje de programación para tu implementación. Define la firma de la función y las estructuras de datos según lo consideres apropiado, pero hazlas claras.

84
15 Mar 2026 06:11

Programación

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

Implementar una caché LRU (Least Recently Used)

Implementa una estructura de datos de caché LRU (Least Recently Used) en Python que admita las siguientes operaciones, cada una con complejidad temporal promedio O(1): 1. `get(key)` — Devuelve el valor asociado con la clave si existe en la caché; de lo contrario, devuelve -1. Acceder a una clave la marca como recientemente usada. 2. `put(key, value)` — Inserta o actualiza el par clave-valor. Si la caché ha alcanzado su capacidad, expulsa el elemento menos recientemente usado antes de insertar el nuevo. Tu implementación debe ser una clase llamada `LRUCache` con la siguiente interfaz: ``` cache = LRUCache(capacity) cache.put(key, value) result = cache.get(key) ``` Demuestra tu implementación con la siguiente secuencia de prueba: ``` cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Expected: 10 cache.put(3, 30) # Evicts key 2 print(cache.get(2)) # Expected: -1 cache.put(4, 40) # Evicts key 1 print(cache.get(1)) # Expected: -1 print(cache.get(3)) # Expected: 30 print(cache.get(4)) # Expected: 40 ``` Requisitos: - NO uses `functools.lru_cache` ni `collections.OrderedDict`. Implementa la estructura subyacente tú mismo. - Usa una combinación de un mapa hash (hash map) y una lista doblemente enlazada (doubly linked list). - Incluye comentarios claros que expliquen tu enfoque. - Maneja casos límite como capacidad 0 o 1. - Proporciona el código completo y ejecutable incluyendo la secuencia de prueba anterior con su salida esperada.

92
12 Mar 2026 19:00

Enlaces relacionados

X f L