Respuesta A: Anthropic Claude Opus 4.6
import time class TokenBucket: """Un limitador de velocidad de cubo de tokens. Los tokens se agregan a una `refill_rate` (tokens por segundo) constante hasta `capacity`. Cada llamada a `allow_request()` intenta consumir un token. """ def __init__(self, capacity: int, refill_rate: float) -> None: """ Args: capacity: Número máximo de tokens que el cubo puede contener. refill_rate: Número de tokens agregados al cubo por segundo. """ self.capacity: int = capacity self.refill_rate: float = refill_rate self.tokens: float = f...
Mostrar respuesta completa ▼
import time class TokenBucket: """Un limitador de velocidad de cubo de tokens. Los tokens se agregan a una `refill_rate` (tokens por segundo) constante hasta `capacity`. Cada llamada a `allow_request()` intenta consumir un token. """ def __init__(self, capacity: int, refill_rate: float) -> None: """ Args: capacity: Número máximo de tokens que el cubo puede contener. refill_rate: Número de tokens agregados al cubo por segundo. """ self.capacity: int = capacity self.refill_rate: float = refill_rate self.tokens: float = float(capacity) # comienza lleno self.last_refill_time: float = time.monotonic() def _refill(self) -> None: """Agrega tokens según el tiempo transcurrido desde el último relleno.""" now = time.monotonic() elapsed = now - self.last_refill_time tokens_to_add = elapsed * self.refill_rate self.tokens = min(self.capacity, self.tokens + tokens_to_add) self.last_refill_time = now def allow_request(self) -> bool: """Intenta consumir un token. Returns: True si la solicitud se permite (un token estaba disponible y se consumió), False en caso contrario. """ self._refill() if self.tokens >= 1: self.tokens -= 1 return True return False # --------------------------------------------------------------------------- # Demostración rápida / prueba de humo # --------------------------------------------------------------------------- if __name__ == "__main__": bucket = TokenBucket(capacity=5, refill_rate=2) # 5 máx., 2 tokens/seg # Ráfaga: debería permitir 5 solicitudes inmediatamente for i in range(7): result = bucket.allow_request() print(f"Solicitud {i + 1}: {'permitida' if result else 'denegada'}") # Esperar un poco para que los tokens se rellenen print("\nDurmiendo 1.5 segundos...") time.sleep(1.5) # debería rellenar ~3 tokens for i in range(5): result = bucket.allow_request() print(f"Solicitud {i + 1}: {'permitida' if result else 'denegada'}")
Resultado
Votos ganadores
0 / 3
Puntuacion media
Puntuacion total
Comentario general
La respuesta A proporciona una implementación limpia, correcta y bien documentada de la clase TokenBucket. Utiliza time.monotonic() para una temporización precisa, rellena correctamente los tokens en función del tiempo transcurrido, limita los tokens a la capacidad y consume un token por solicitud permitida. El código es legible, con buenos docstrings, e incluye una útil demostración/prueba de humo. Sin embargo, carece de seguridad de hilos (no hay mecanismo de bloqueo), lo cual es una omisión notable para un limitador de velocidad que normalmente se usaría en entornos concurrentes. También carece de validación de entrada para los argumentos del constructor.
Ver detalle de evaluacion ▼
Correccion
Peso 35%La lógica central es correcta: los tokens se recargan en función del tiempo transcurrido utilizando time.monotonic(), se limitan a la capacidad y se consume un token por solicitud permitida. Sin embargo, la falta de seguridad de hilos significa que la implementación podría producir resultados incorrectos en el uso concurrente debido a condiciones de carrera.
Integridad
Peso 20%La implementación cubre todos los elementos requeridos: constructor con capacidad y tasa de recarga, método allow_request() y gestión del estado interno. Incluye una demostración ejecutable. Sin embargo, carece de seguridad de hilos y validación de entrada, que son importantes para una implementación completa.
Calidad del codigo
Peso 20%El código es limpio, legible y está bien documentado con docstrings claros y anotaciones de tipo. Los nombres de las variables son descriptivos. La separación de la lógica de recarga en un método privado es un buen diseño. Deducción menor por la falta de convenciones de nomenclatura de atributos privados.
Valor practico
Peso 15%La implementación es prácticamente útil para escenarios de un solo hilo e incluye una demostración útil. Sin embargo, la falta de seguridad de hilos limita significativamente su valor práctico en aplicaciones del mundo real donde los limitadores de velocidad se usan típicamente en entornos concurrentes.
Seguimiento de instrucciones
Peso 10%Sigue todas las instrucciones: implementa la clase TokenBucket en Python, el constructor acepta capacidad y tasa_de_recarga, allow_request() no toma argumentos y devuelve True/False mientras consume un token. Utiliza solo la biblioteca estándar (módulo time). El estado se gestiona dentro de la instancia.
Puntuacion total
Comentario general
La respuesta A proporciona una implementación correcta y bien escrita para un entorno de un solo hilo. Sus puntos fuertes son el código limpio con sugerencias de tipos de Python modernas, una lógica clara y una excelente demostración ejecutable que verifica su comportamiento. Sin embargo, su principal debilidad es la falta de seguridad en los hilos, lo que la hace inadecuada para la mayoría de las aplicaciones del mundo real de un limitador de velocidad donde las solicitudes concurrentes son comunes.
Ver detalle de evaluacion ▼
Correccion
Peso 35%La implementación es lógicamente correcta para un contexto de un solo hilo. El cálculo de recarga de tokens y la limitación de capacidad se implementan correctamente. Sin embargo, no es correcta en un entorno concurrente, que es un caso de uso común para este algoritmo.
Integridad
Peso 20%La respuesta es muy completa, proporcionando no solo la implementación de la clase sino también un script de demostración ejecutable en `if __name__ == "__main__":`. Esta demostración muestra eficazmente el comportamiento de ráfaga y recarga, lo que facilita su comprensión y verificación.
Calidad del codigo
Peso 20%La calidad del código es alta. Utiliza características modernas de Python como sugerencias de tipos, tiene docstrings claros y sigue buenas convenciones de nomenclatura. La lógica está bien estructurada con un método auxiliar privado para la recarga.
Valor practico
Peso 15%El valor práctico es limitado porque la implementación no es segura en cuanto a hilos. Los limitadores de velocidad se utilizan casi siempre en entornos concurrentes (como servidores web), donde esta implementación estaría sujeta a condiciones de carrera y no funcionaría de manera fiable.
Seguimiento de instrucciones
Peso 10%La respuesta sigue perfectamente todas las instrucciones del prompt, implementando la clase, el constructor y el método especificados con la lógica correcta. La solución es autónoma.
Puntuacion total
Comentario general
La respuesta A proporciona una implementación de Python correcta y legible de un bucket de tokens. Utiliza un reloj monotónico, rastrea el estado interno correctamente, se recarga en función del tiempo transcurrido, limita los tokens a la capacidad y consume un token por solicitud permitida. Las principales debilidades son la falta de validación de entrada, la ausencia de protección para el acceso concurrente y un enfoque básico basado en flotantes sin abordar las preocupaciones de precisión mencionadas en la indicación. La demostración incluida es útil pero no necesaria para la tarea principal.
Ver detalle de evaluacion ▼
Correccion
Peso 35%La lógica de recarga y consumo es correcta: el tiempo transcurrido se mide con un reloj monotónico, los tokens se agregan proporcionalmente, se limitan a la capacidad y se consume un token cuando está disponible. Maneja el primer uso y los períodos de inactividad prolongados correctamente. La puntuación se ve afectada porque no aborda parámetros inválidos y utiliza una acumulación de punto flotante directa sin ninguna mitigación.
Integridad
Peso 20%Incluye el constructor requerido, el estado interno y el método allow_request, y la implementación es autocontenida. Sin embargo, no cubre la validación de parámetros ni discute condiciones extremas como capacidad o tasa de recarga inválidas.
Calidad del codigo
Peso 20%El código es limpio, legible e idiomático, con buenos nombres y docstrings útiles. La estructura es simple y fácil de seguir. Pierde algunos puntos porque el estado público se expone directamente y el código de demostración adicional no forma parte de la implementación principal.
Valor practico
Peso 15%Es utilizable para escenarios simples de un solo hilo y demuestra el comportamiento con una prueba rápida. En entornos más realistas, la falta de validación y seguridad de hilos reduce la utilidad operativa.
Seguimiento de instrucciones
Peso 10%Sigue bien la tarea al implementar una clase TokenBucket autocontenida con el comportamiento requerido del constructor y allow_request. El único pequeño problema es la inclusión de código de demostración adicional más allá de la respuesta principal solicitada.