Reponse A: Anthropic Claude Opus 4.6
import time class TokenBucket: """Un limiteur de débit de type "token bucket". Les jetons sont ajoutés à un `refill_rate` (jetons par seconde) constant, jusqu'à la `capacity`. Chaque appel à `allow_request()` tente de consommer un jeton. """ def __init__(self, capacity: int, refill_rate: float) -> None: """ Args: capacity: Nombre maximum de jetons que le seau peut contenir. refill_rate: Nombre de jetons ajoutés au seau par seconde. """ self.capacity: int = capacity self.refill_rate: float = refill_rate self.tokens: flo...
Afficher la reponse complete ▼
import time class TokenBucket: """Un limiteur de débit de type "token bucket". Les jetons sont ajoutés à un `refill_rate` (jetons par seconde) constant, jusqu'à la `capacity`. Chaque appel à `allow_request()` tente de consommer un jeton. """ def __init__(self, capacity: int, refill_rate: float) -> None: """ Args: capacity: Nombre maximum de jetons que le seau peut contenir. refill_rate: Nombre de jetons ajoutés au seau par seconde. """ self.capacity: int = capacity self.refill_rate: float = refill_rate self.tokens: float = float(capacity) # commence plein self.last_refill_time: float = time.monotonic() def _refill(self) -> None: """Ajoute des jetons en fonction du temps écoulé depuis le dernier remplissage.""" 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: """Tente de consommer un jeton. Returns: True si la requête est autorisée (un jeton était disponible et a été consommé), False sinon. """ self._refill() if self.tokens >= 1: self.tokens -= 1 return True return False # --------------------------------------------------------------------------- # Démonstration rapide / test de fumée # --------------------------------------------------------------------------- if __name__ == "__main__": bucket = TokenBucket(capacity=5, refill_rate=2) # 5 max, 2 jetons/sec # Rafale : devrait autoriser 5 requêtes immédiatement for i in range(7): result = bucket.allow_request() print(f"Requête {i + 1}: {'autorisée' if result else 'refusée'}") # Attendre un peu pour que les jetons se rechargent print("\nEndormissement pendant 1,5 seconde...") time.sleep(1.5) # devrait recharger environ 3 jetons for i in range(5): result = bucket.allow_request() print(f"Requête {i + 1}: {'autorisée' if result else 'refusée'}")
Resultat
Votes gagnants
0 / 3
Score moyen
Score total
Commentaire global
La réponse A fournit une implémentation propre, correcte et bien documentée de la classe TokenBucket. Elle utilise time.monotonic() pour une synchronisation précise, recharge correctement les jetons en fonction du temps écoulé, limite les jetons à la capacité et consomme un jeton par requête autorisée. Le code est lisible avec de bonnes docstrings et inclut une démo/un test de fumée utile. Cependant, il manque la sécurité des threads (aucun mécanisme de verrouillage), ce qui est une omission notable pour un limiteur de débit qui serait généralement utilisé dans des environnements concurrents. Il manque également la validation des entrées pour les arguments du constructeur.
Afficher le detail de l evaluation ▼
Exactitude
Poids 35%La logique principale est correcte : les jetons sont rechargés en fonction du temps écoulé à l'aide de time.monotonic(), limités à la capacité, et un jeton est consommé par requête autorisée. Cependant, le manque de sécurité des threads signifie que l'implémentation pourrait produire des résultats incorrects en cas d'utilisation concurrente en raison de conditions de concurrence.
Completude
Poids 20%L'implémentation couvre tous les éléments requis : constructeur avec capacité et taux de recharge, méthode allow_request() et gestion de l'état interne. Elle inclut une démo exécutable. Cependant, il manque la sécurité des threads et la validation des entrées, qui sont importantes pour une implémentation complète.
Qualite du code
Poids 20%Le code est propre, lisible et bien documenté avec des docstrings claires et des annotations de type. Les noms de variables sont descriptifs. La séparation de la logique de recharge dans une méthode privée est une bonne conception. Petite déduction pour le manque de conventions de nommage des attributs privés.
Valeur pratique
Poids 15%L'implémentation est pratiquement utile pour les scénarios mono-thread et inclut une démo utile. Cependant, le manque de sécurité des threads limite considérablement sa valeur pratique dans les applications du monde réel où les limiteurs de débit sont généralement utilisés dans des environnements concurrents.
Respect des consignes
Poids 10%Suit toutes les instructions : implémente la classe TokenBucket en Python, le constructeur accepte la capacité et le taux de recharge, allow_request() ne prend aucun argument et renvoie True/False tout en consommant un jeton. Utilise uniquement la bibliothèque standard (module time). L'état est géré dans l'instance.
Score total
Commentaire global
La réponse A fournit une implémentation correcte et bien écrite pour un environnement monothread. Ses points forts sont un code propre avec des indications de type Python modernes, une logique claire et une excellente démo exécutable qui vérifie son comportement. Cependant, sa principale faiblesse est le manque de sécurité des threads, ce qui la rend inadaptée à la plupart des applications réelles d'un limiteur de débit où les requêtes concurrentes sont courantes.
Afficher le detail de l evaluation ▼
Exactitude
Poids 35%L'implémentation est logiquement correcte pour un contexte monothread. Le calcul du rechargement des jetons et la limitation de la capacité sont correctement implémentés. Cependant, elle n'est pas correcte dans un environnement concurrent, ce qui est un cas d'utilisation courant pour cet algorithme.
Completude
Poids 20%La réponse est très complète, fournissant non seulement l'implémentation de la classe mais aussi un script de démonstration exécutable sous `if __name__ == "__main__":`. Cette démo présente efficacement le comportement de rafale et de rechargement, la rendant facile à comprendre et à vérifier.
Qualite du code
Poids 20%La qualité du code est élevée. Il utilise des fonctionnalités Python modernes comme les indications de type, possède des docstrings claires et suit de bonnes conventions de nommage. La logique est bien structurée avec une méthode d'aide privée pour le rechargement.
Valeur pratique
Poids 15%La valeur pratique est limitée car l'implémentation n'est pas thread-safe. Les limiteurs de débit sont presque toujours utilisés dans des environnements concurrents (comme les serveurs web), où cette implémentation serait sujette à des conditions de concurrence et ne fonctionnerait pas de manière fiable.
Respect des consignes
Poids 10%La réponse suit parfaitement toutes les instructions de l'invite, implémentant la classe, le constructeur et la méthode spécifiés avec la logique correcte. La solution est autonome.
Score total
Commentaire global
La réponse A fournit une implémentation Python correcte et lisible d'un seau à jetons. Elle utilise une horloge monotone, suit correctement l'état interne, se remplit en fonction du temps écoulé, plafonne les jetons à la capacité et consomme un jeton par requête autorisée. Les principales faiblesses sont l'absence de validation des entrées, l'absence de protection pour l'accès concurrent et une approche basique basée sur des nombres à virgule flottante sans aborder les problèmes de précision mentionnés dans la consigne. La démo incluse est utile mais pas nécessaire pour la tâche principale.
Afficher le detail de l evaluation ▼
Exactitude
Poids 35%La logique de remplissage et de consommation est correcte : le temps écoulé est mesuré avec une horloge monotone, les jetons sont ajoutés proportionnellement, plafonnés à la capacité, et un jeton est consommé lorsqu'il est disponible. Il gère correctement la première utilisation et les longues périodes d'inactivité. Le score est limité car il n'aborde pas les paramètres invalides et utilise une accumulation simple en virgule flottante sans aucune atténuation.
Completude
Poids 20%Il inclut le constructeur requis, l'état interne et la méthode allow_request, et l'implémentation est autonome. Cependant, il ne couvre pas la validation des paramètres ni n'aborde les conditions limites telles qu'une capacité ou un taux de remplissage invalides.
Qualite du code
Poids 20%Le code est propre, lisible et idiomatique, avec une bonne nomenclature et des docstrings utiles. La structure est simple et facile à suivre. Il perd quelques points car l'état public est directement exposé et le code de démonstration supplémentaire ne fait pas partie de l'implémentation principale.
Valeur pratique
Poids 15%Il est utilisable pour des scénarios simples à thread unique et démontre le comportement avec un test rapide. Dans des contextes plus réalistes, le manque de validation et de sécurité des threads réduit son utilité opérationnelle.
Respect des consignes
Poids 10%Il suit bien la tâche en implémentant une classe TokenBucket autonome avec le constructeur et le comportement allow_request requis. Le seul léger problème est l'inclusion de code de démonstration supplémentaire au-delà de la réponse principale demandée.