Antwort A: Anthropic Claude Opus 4.6
import time class TokenBucket: """Ein Token-Bucket-Ratenbegrenzer. Tokens werden mit einer konstanten `refill_rate` (Tokens pro Sekunde) bis zu `capacity` hinzugefügt. Jeder Aufruf von `allow_request()` versucht, ein Token zu verbrauchen. """ def __init__(self, capacity: int, refill_rate: float) -> None: """ Args: capacity: Maximale Anzahl von Tokens, die der Bucket aufnehmen kann. refill_rate: Anzahl der pro Sekunde zum Bucket hinzugefügten Tokens. """ self.capacity: int = capacity self.refill_rate: float = refill_rate...
Vollstandige Antwort anzeigen ▼
import time class TokenBucket: """Ein Token-Bucket-Ratenbegrenzer. Tokens werden mit einer konstanten `refill_rate` (Tokens pro Sekunde) bis zu `capacity` hinzugefügt. Jeder Aufruf von `allow_request()` versucht, ein Token zu verbrauchen. """ def __init__(self, capacity: int, refill_rate: float) -> None: """ Args: capacity: Maximale Anzahl von Tokens, die der Bucket aufnehmen kann. refill_rate: Anzahl der pro Sekunde zum Bucket hinzugefügten Tokens. """ self.capacity: int = capacity self.refill_rate: float = refill_rate self.tokens: float = float(capacity) # startet voll self.last_refill_time: float = time.monotonic() def _refill(self) -> None: """Fügt Tokens basierend auf der seit der letzten Auffüllung verstrichenen Zeit hinzu.""" 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: """Versucht, ein Token zu verbrauchen. Returns: True, wenn die Anfrage zugelassen wird (ein Token war verfügbar und wurde verbraucht), False andernfalls. """ self._refill() if self.tokens >= 1: self.tokens -= 1 return True return False # --------------------------------------------------------------------------- # Kurze Demo / Rauchtest # --------------------------------------------------------------------------- if __name__ == "__main__": bucket = TokenBucket(capacity=5, refill_rate=2) # 5 max, 2 Tokens/Sekunde # Burst: sollte 5 Anfragen sofort zulassen for i in range(7): result = bucket.allow_request() print(f"Anfrage {i + 1}: {'zugelassen' if result else 'abgelehnt'}") # Warten, bis sich die Tokens aufgefüllt haben print("\nSchlafe 1,5 Sekunden...") time.sleep(1.5) # sollte ca. 3 Tokens auffüllen for i in range(5): result = bucket.allow_request() print(f"Anfrage {i + 1}: {'zugelassen' if result else 'abgelehnt'}")
Ergebnis
Siegstimmen
0 / 3
Durchschnittsscore
Gesamtpunktzahl
Gesamtkommentar
Antwort A bietet eine saubere, korrekte und gut dokumentierte Implementierung der TokenBucket-Klasse. Sie verwendet time.monotonic() für eine genaue Zeitmessung, füllt Tokens korrekt basierend auf der verstrichenen Zeit auf, begrenzt Tokens auf die Kapazität und verbraucht ein Token pro erlaubter Anfrage. Der Code ist lesbar mit guten Docstrings und enthält eine hilfreiche Demo/Smoke-Test. Es fehlt jedoch die Threadsicherheit (kein Sperrmechanismus), was eine bemerkenswerte Lücke für einen Ratenbegrenzer ist, der typischerweise in gleichzeitigen Umgebungen verwendet würde. Es fehlt auch die Eingabevalidierung für Konstruktorargumente.
Bewertungsdetails anzeigen ▼
Korrektheit
Gewichtung 35%Die Kernlogik ist korrekt: Tokens werden basierend auf der verstrichenen Zeit mit time.monotonic() aufgefüllt, auf die Kapazität begrenzt und ein Token wird pro erlaubter Anfrage verbraucht. Das Fehlen von Threadsicherheit bedeutet jedoch, dass die Implementierung bei gleichzeitiger Nutzung aufgrund von Race Conditions zu falschen Ergebnissen führen kann.
Vollstandigkeit
Gewichtung 20%Die Implementierung deckt alle erforderlichen Elemente ab: Konstruktor mit Kapazität und Auffüllrate, allow_request()-Methode und internes Zustandsmanagement. Sie enthält eine ausführbare Demo. Es fehlen jedoch Threadsicherheit und Eingabevalidierung, die für eine vollständige Implementierung wichtig sind.
Codequalitat
Gewichtung 20%Der Code ist sauber, lesbar und gut dokumentiert mit klaren Docstrings und Typ-Hints. Variablennamen sind beschreibend. Die Trennung der Auffülllogik in eine private Methode ist gutes Design. Kleinere Abzüge für fehlende Namenskonventionen für private Attribute.
Praktischer Nutzen
Gewichtung 15%Die Implementierung ist für Single-Thread-Szenarien praktisch nützlich und enthält eine hilfreiche Demo. Das Fehlen von Threadsicherheit schränkt jedoch ihren praktischen Wert in realen Anwendungen, in denen Ratenbegrenzer typischerweise in gleichzeitigen Umgebungen verwendet werden, erheblich ein.
Befolgung der Anweisungen
Gewichtung 10%Folgt allen Anweisungen: Implementiert die TokenBucket-Klasse in Python, der Konstruktor akzeptiert Kapazität und Auffüllrate, allow_request() nimmt keine Argumente und gibt True/False zurück, während ein Token verbraucht wird. Verwendet nur die Standardbibliothek (time-Modul). Der Zustand wird innerhalb der Instanz verwaltet.
Gesamtpunktzahl
Gesamtkommentar
Antwort A bietet eine korrekte und gut geschriebene Implementierung für eine Single-Thread-Umgebung. Ihre Stärken sind sauberer Code mit modernen Python-Typ-Hinweisen, klare Logik und eine ausgezeichnete lauffähige Demo, die ihr Verhalten verifiziert. Ihre größte Schwäche ist jedoch die fehlende Thread-Sicherheit, was sie für die meisten realen Anwendungen eines Ratenbegrenzers, bei denen gleichzeitige Anfragen üblich sind, ungeeignet macht.
Bewertungsdetails anzeigen ▼
Korrektheit
Gewichtung 35%Die Implementierung ist in einem Single-Thread-Kontext logisch korrekt. Die Token-Auffüllberechnung und die Kapazitätsbegrenzung sind ordnungsgemäß implementiert. Sie ist jedoch in einer gleichzeitigen Umgebung nicht korrekt, was ein häufiger Anwendungsfall für diesen Algorithmus ist.
Vollstandigkeit
Gewichtung 20%Die Antwort ist sehr vollständig und bietet nicht nur die Klassenimplementierung, sondern auch ein lauffähiges Demo-Skript unter `if __name__ == "__main__":`. Diese Demo zeigt effektiv das Burst- und Auffüllverhalten und macht es leicht verständlich und überprüfbar.
Codequalitat
Gewichtung 20%Die Codequalität ist hoch. Sie verwendet moderne Python-Funktionen wie Typ-Hinweise, verfügt über klare Docstrings und folgt guten Namenskonventionen. Die Logik ist gut strukturiert mit einer privaten Hilfsmethode zum Auffüllen.
Praktischer Nutzen
Gewichtung 15%Der praktische Wert ist begrenzt, da die Implementierung nicht Thread-sicher ist. Ratenbegrenzer werden fast immer in gleichzeitigen Umgebungen (wie Webservern) verwendet, wo diese Implementierung Race Conditions unterliegt und nicht zuverlässig funktionieren würde.
Befolgung der Anweisungen
Gewichtung 10%Die Antwort folgt perfekt allen Anweisungen in der Aufforderung und implementiert die angegebene Klasse, den Konstruktor und die Methode mit der korrekten Logik. Die Lösung ist in sich geschlossen.
Gesamtpunktzahl
Gesamtkommentar
Antwort A bietet eine korrekte und lesbare Python-Implementierung eines Token-Buckets. Sie verwendet eine monotone Uhr, verwaltet den internen Zustand ordnungsgemäß, füllt sich basierend auf der verstrichenen Zeit auf, begrenzt die Token auf die Kapazität und verbraucht ein Token pro erlaubter Anfrage. Die Hauptschwächen sind fehlende Eingabevalidierung, kein Schutz für gleichzeitigen Zugriff und ein einfacher, auf Gleitkommazahlen basierender Ansatz, ohne die im Prompt erwähnten Präzisionsbedenken zu berücksichtigen. Die enthaltene Demo ist hilfreich, aber für die Kernaufgabe nicht notwendig.
Bewertungsdetails anzeigen ▼
Korrektheit
Gewichtung 35%Die Logik für das Nachfüllen und den Verbrauch ist korrekt: Die verstrichene Zeit wird mit einer monotonen Uhr gemessen, Token werden proportional hinzugefügt, auf die Kapazität begrenzt und ein Token wird verbraucht, wenn verfügbar. Sie behandelt die erste Verwendung und lange Leerlaufzeiten ordnungsgemäß. Die Bewertung wird zurückgehalten, da sie keine ungültigen Parameter behandelt und eine einfache Gleitkommaakkumulation ohne jegliche Abmilderung verwendet.
Vollstandigkeit
Gewichtung 20%Er enthält den erforderlichen Konstruktor, den internen Zustand und die allow_request-Methode, und die Implementierung ist in sich geschlossen. Er deckt jedoch keine Parametervalidierung ab und diskutiert keine Randbedingungen wie ungültige Kapazität oder Nachfüllrate.
Codequalitat
Gewichtung 20%Der Code ist sauber, lesbar und idiomatisch, mit guter Benennung und hilfreichen Docstrings. Die Struktur ist einfach und leicht zu verfolgen. Er verliert einige Punkte, da der öffentliche Zustand direkt zugänglich ist und der zusätzliche Demo-Code nicht Teil der Kernimplementierung ist.
Praktischer Nutzen
Gewichtung 15%Sie ist für einfache Single-Thread-Szenarien verwendbar und demonstriert das Verhalten mit einem schnellen Smoke-Test. In realistischeren Umgebungen verringern die fehlende Validierung und Thread-Sicherheit den operativen Nutzen.
Befolgung der Anweisungen
Gewichtung 10%Sie folgt der Aufgabe gut, indem sie eine in sich geschlossene TokenBucket-Klasse mit dem erforderlichen Konstruktor und dem allow_request-Verhalten implementiert. Das einzige geringfügige Problem ist die Einbeziehung von zusätzlichem Demo-Code über die angeforderte Kernantwort hinaus.