Resposta A: Anthropic Claude Opus 4.6
import time
class TokenBucket:
"""Um limitador de taxa de balde de tokens.
Os tokens são adicionados a uma `refill_rate` (tokens por segundo) constante até
a `capacity`. Cada chamada para `allow_request()` tenta consumir um token.
"""
def __init__(self, capacity: int, refill_rate: float) -> None:
"""
Args:
capacity: Número máximo de tokens que o balde pode conter.
refill_rate: Número de tokens adicionados ao balde por segundo.
"""
self.capacity: int = capacity
self.refill_rate: float = refill_rate
self.tokens: float =...
Mostrar resposta completa ▼
import time
class TokenBucket:
"""Um limitador de taxa de balde de tokens.
Os tokens são adicionados a uma `refill_rate` (tokens por segundo) constante até
a `capacity`. Cada chamada para `allow_request()` tenta consumir um token.
"""
def __init__(self, capacity: int, refill_rate: float) -> None:
"""
Args:
capacity: Número máximo de tokens que o balde pode conter.
refill_rate: Número de tokens adicionados ao balde por segundo.
"""
self.capacity: int = capacity
self.refill_rate: float = refill_rate
self.tokens: float = float(capacity) # começa cheio
self.last_refill_time: float = time.monotonic()
def _refill(self) -> None:
"""Adiciona tokens com base no tempo decorrido desde o último reabastecimento."""
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:
"""Tenta consumir um token.
Returns:
True se a solicitação for permitida (um token estava disponível e foi consumido),
False caso contrário.
"""
self._refill()
if self.tokens >= 1:
self.tokens -= 1
return True
return False
---------------------------------------------------------------------------
Demonstração rápida / teste de fumaça
---------------------------------------------------------------------------
if name == "main":
bucket = TokenBucket(capacity=5, refill_rate=2) # 5 máx, 2 tokens/seg
# Rajada: deve permitir 5 solicitações imediatamente
for i in range(7):
result = bucket.allow_request()
print(f"Solicitação {i + 1}: {'permitida' if result else 'negada'}")
# Espera um pouco para os tokens serem reabastecidos
print("\nDormindo 1.5 segundos...")
time.sleep(1.5) # deve reabastecer ~3 tokens
for i in range(5):
result = bucket.allow_request()
print(f"Solicitação {i + 1}: {'permitida' if result else 'negada'}")
Resultado
Votos de vitória
0 / 3
Pontuação média
Pontuação total
Comentário geral
A Resposta A fornece uma implementação limpa, correta e bem documentada da classe TokenBucket. Utiliza time.monotonic() para um tempo preciso, reabastece corretamente os tokens com base no tempo decorrido, limita os tokens à capacidade e consome um token por solicitação permitida. O código é legível, com boas docstrings e inclui uma demonstração/teste de fumaça útil. No entanto, falta segurança de thread (nenhum mecanismo de bloqueio), o que é uma omissão notável para um limitador de taxa que seria tipicamente usado em ambientes concorrentes. Também falta validação de entrada para os argumentos do construtor.
Ver detalhes da avaliação ▼
Correção
Peso 35%A lógica principal está correta: os tokens são reabastecidos com base no tempo decorrido usando time.monotonic(), limitados à capacidade e um token é consumido por solicitação permitida. No entanto, a falta de segurança de thread significa que a implementação pode produzir resultados incorretos em uso concorrente devido a condições de corrida.
Completude
Peso 20%A implementação abrange todos os elementos necessários: construtor com capacidade e taxa de reabastecimento, método allow_request() e gerenciamento de estado interno. Inclui uma demonstração executável. No entanto, faltam segurança de thread e validação de entrada, que são importantes para uma implementação completa.
Qualidade do código
Peso 20%O código é limpo, legível e bem documentado com docstrings claras e dicas de tipo. Os nomes das variáveis são descritivos. A separação da lógica de reabastecimento em um método privado é um bom design. Dedução menor pela falta de convenções de nomenclatura de atributos privados.
Valor prático
Peso 15%A implementação é praticamente útil para cenários de thread única e inclui uma demonstração útil. No entanto, a falta de segurança de thread limita significativamente seu valor prático em aplicações do mundo real onde os limitadores de taxa são tipicamente usados em ambientes concorrentes.
Seguimento de instruções
Peso 10%Segue todas as instruções: implementa a classe TokenBucket em Python, o construtor aceita capacidade e taxa de reabastecimento, allow_request() não aceita argumentos e retorna True/False enquanto consome um token. Usa apenas a biblioteca padrão (módulo time). O estado é gerenciado dentro da instância.
Pontuação total
Comentário geral
A Resposta A fornece uma implementação correta e bem escrita para um ambiente de thread única. Seus pontos fortes são código limpo com dicas de tipo Python modernas, lógica clara e uma excelente demonstração executável que verifica seu comportamento. No entanto, sua principal fraqueza é a falta de segurança de thread, o que a torna inadequada para a maioria das aplicações do mundo real de um limitador de taxa, onde requisições concorrentes são comuns.
Ver detalhes da avaliação ▼
Correção
Peso 35%A implementação é logicamente correta para um contexto de thread única. O cálculo de reabastecimento de tokens e a limitação de capacidade são implementados corretamente. No entanto, não é correta em um ambiente concorrente, que é um caso de uso comum para este algoritmo.
Completude
Peso 20%A resposta é muito completa, fornecendo não apenas a implementação da classe, mas também um script de demonstração executável em `if __name__ == "__main__":`. Esta demonstração mostra efetivamente o comportamento de rajada e reabastecimento, tornando-a fácil de entender e verificar.
Qualidade do código
Peso 20%A qualidade do código é alta. Utiliza recursos modernos do Python, como dicas de tipo, possui docstrings claras e segue boas convenções de nomenclatura. A lógica é bem estruturada com um método auxiliar privado para reabastecimento.
Valor prático
Peso 15%O valor prático é limitado porque a implementação não é segura para threads. Limitadores de taxa são quase sempre usados em ambientes concorrentes (como servidores web), onde esta implementação estaria sujeita a condições de corrida e não funcionaria de forma confiável.
Seguimento de instruções
Peso 10%A resposta segue perfeitamente todas as instruções do prompt, implementando a classe, construtor e método especificados com a lógica correta. A solução é autocontida.
Pontuação total
Comentário geral
A Resposta A fornece uma implementação Python correta e legível de um token bucket. Utiliza um relógio monotónico, rastreia o estado interno corretamente, reabastece com base no tempo decorrido, limita os tokens à capacidade e consome um token por pedido permitido. As principais fraquezas são a falta de validação de entrada, nenhuma proteção para acesso concorrente e uma abordagem básica baseada em ponto flutuante sem abordar as preocupações de precisão mencionadas na solicitação. A demonstração incluída é útil, mas não necessária para a tarefa principal.
Ver detalhes da avaliação ▼
Correção
Peso 35%A lógica de reabastecimento e consumo está correta: o tempo decorrido é medido com um relógio monotónico, os tokens são adicionados proporcionalmente, limitados à capacidade e um token é consumido quando disponível. Lida corretamente com o primeiro uso e longos períodos de inatividade. A pontuação é prejudicada porque não aborda parâmetros inválidos e usa acumulação direta de ponto flutuante sem qualquer mitigação.
Completude
Peso 20%Inclui o construtor necessário, o estado interno e o método allow_request, e a implementação é autocontida. No entanto, não cobre a validação de parâmetros nem discute condições de contorno, como capacidade inválida ou taxa de reabastecimento.
Qualidade do código
Peso 20%O código é limpo, legível e idiomático, com boa nomenclatura e docstrings úteis. A estrutura é simples e fácil de seguir. Perde alguns pontos porque o estado público é exposto diretamente e o código de demonstração extra não faz parte da implementação principal.
Valor prático
Peso 15%É utilizável para cenários simples de thread única e demonstra o comportamento com um teste rápido. Em cenários mais realistas, a falta de validação e segurança de thread reduz a utilidade operacional.
Seguimento de instruções
Peso 10%Segue bem a tarefa implementando uma classe TokenBucket autocontida com o construtor e o comportamento allow_request necessários. O único pequeno problema é a inclusão de código de demonstração extra além da resposta principal solicitada.