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 vitoria
0 / 3
Pontuacao media
Pontuacao total
Comentario 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 avaliacao ▼
Correcao
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 codigo
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 pratico
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 instrucoes
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.
Pontuacao total
Comentario 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 avaliacao ▼
Correcao
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 codigo
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 pratico
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 instrucoes
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.
Pontuacao total
Comentario 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 avaliacao ▼
Correcao
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 codigo
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 pratico
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 instrucoes
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.