Programmierung
Vergleicht Korrektheit, Qualität und Praxistauglichkeit des erzeugten Codes.
In diesem Genre werden vor allem Faehigkeiten wie Korrektheit, Vollstandigkeit, Codequalitat betrachtet.
Anders als system design geht es hier staerker darum, ob der Code wirklich funktioniert als um Architekturentscheidungen auf hohem Niveau.
Ein hoher Wert hier garantiert weder besseres Produkturteil noch bessere Architektur oder bessere Erklaerungen fuer Einsteiger.
Wofuer starke Modelle in diesem Genre gut geeignet sind
Implementierung, Debugging, Refactoring und praktische Programmierunterstuetzung.
Was dieses Genre allein nicht zeigen kann
ob das Modell besser fuer Architektur, Stakeholder-Dokumente oder offene Ideation geeignet ist.
Programmierung: GPT-5 mini holt Platz 1, doch der höchste Schnitt steht auf Platz 4
Anthropic
OpenAI
Anthropic
Durchschnittswert je Modell
Gewichtung
Über 37 bewertete Coding-Antworten führt GPT-5 mini das Ranking an: 8,22 Schnitt über 5 Stichproben, 5 erste Plätze und 100 % Siegquote. Damit ist es zugleich das bestplatzierte und eines der am besten belegten Modelle hier – ein klarer Durchmarsch zu Kosten der leichten Klasse. Direkt dahinter steht Claude Opus 4.8 auf Platz 2 mit 8,07 über nur 2 Stichproben und makelloser 100-%-Bilanz, also eher als starkes, aber noch vorläufiges Signal zu lesen.
Durchschnitt und Rang weichen deutlich voneinander ab, weil die Siegquote (direkte erste Plätze) das Ranking stärker bestimmt als der reine Schnitt. GPT-5.5 erzielt mit 8,9 den höchsten Schnitt des Genres und steht dennoch nur auf Platz 4, weil es über 2 Stichproben nur 1 gewann, eine Siegquote von 50 %. GPT-5.4 dagegen trägt die größte Evidenzbasis, 8 Stichproben, mit 8,41 Schnitt, 6 ersten Plätzen und 75 % Siegquote auf Platz 3. Der Vorsprung des Spitzenreiters auf Platz 2 beträgt nur 0,15 Punkte, die Spitze ist also eng.
Der klarste Fall eines guten Schnitts, den ein schwaches direktes Duell begräbt, ist Gemini 2.5 Pro: 7,95 Schnitt, über dem Mittelfeld, aber Platz 6 bei 0 % Siegquote über 4 Stichproben. Claude Sonnet 4.6 führt das Mittelfeld mit 7,7 an (50 % über 4 Stichproben, Platz 5), rund 0,5 bis 1,2 Punkte hinter der GPT-5-Gruppe. Die leichteren, schnelleren Klassen liegen tiefer: Gemini 2.5 Flash-Lite (7,17), Gemini 2.5 Flash (6,84) und Claude Haiku 4.5 (6,48) liegen 1,0 bis 1,7 Punkte hinter dem Spitzenreiter. Da Korrektheit mit 35 am höchsten gewichtet ist, vor Vollständigkeit und Codequalität (je 20), deuten diese Abstände auf schwächere Korrektheit bei den schwereren Aufgaben hin, nicht bloß auf Stil.
Der größte Vorbehalt ist die Stichprobengröße. Claude Opus 4.8 und GPT-5.5 beruhen auf je 2 Stichproben, die meisten liegen bei 3 bis 8, sodass die Schnitte mit wenigen Prompts schwanken können. Die Spanne von 1,74 Punkten zwischen Erstem und Letztem ist real, doch die Feinordnung innerhalb des 8-Punkte-Clusters (GPT-5.5, GPT-5.4, GPT-5 mini, Claude Opus 4.8) ist als vorläufig zu lesen. Es sind bedingungsabhängige Messwerte, kein Urteil darüber, welches Modell insgesamt am besten programmiert.
Fazit
Für verlässliches Programmieren heute ist GPT-5 mini die am besten begründbare Wahl: Platz 1 mit 100 % Siegquote über 5 Stichproben zu Kosten der leichten Klasse. GPT-5.4 ist die am gründlichsten belegte Oberklasse-Option (8,41 über 8 Stichproben), während der genrehöchste Schnitt von 8,9 bei GPT-5.5 und der zweite Platz von Claude Opus 4.8 beide auf 2 Stichproben beruhen – also als vielversprechend, aber unbewiesen zu behandeln.
Diese Analyse basiert auf den von Orivel gemessenen Benchmark-Werten fuer dieses Genre und wird regelmaessig aktualisiert. Die Werte sind bedingungsabhaengige Messungen, keine absolute Wahrheit.
Ranking starker Modelle in diesem Genre
Dieses Ranking ist nach dem Durchschnittsscore nur innerhalb dieses Genres sortiert.
Zuletzt aktualisiert: 29 Jun 2026 09:44
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
| Gerankte Modelle | Detail | ||||||
|---|---|---|---|---|---|---|---|
| #1 | Claude Fable 5 | Anthropic |
100%
|
91
|
1 | 1 | Bewertung und Punktzahl von Claude Fable 5 ansehen |
| #2 | GPT-5 mini | OpenAI |
100%
|
82
|
5 | 5 | Bewertung und Punktzahl von GPT-5 mini ansehen |
| #3 | Claude Opus 4.8 | Anthropic |
100%
|
81
|
2 | 2 | Bewertung und Punktzahl von Claude Opus 4.8 ansehen |
| #4 | GPT-5.5 | OpenAI |
50%
|
89
|
1 | 2 | Bewertung und Punktzahl von GPT-5.5 ansehen |
| #5 | Claude Sonnet 4.6 | Anthropic |
50%
|
77
|
2 | 4 | Bewertung und Punktzahl von Claude Sonnet 4.6 ansehen |
| #6 | Gemini 2.5 Pro |
0%
|
80
|
0 | 4 | Bewertung und Punktzahl von Gemini 2.5 Pro ansehen | |
| #7 | Gemini 2.5 Flash-Lite |
0%
|
72
|
0 | 3 | Bewertung und Punktzahl von Gemini 2.5 Flash-Lite ansehen | |
| #8 | Gemini 2.5 Flash |
0%
|
68
|
0 | 5 | Bewertung und Punktzahl von Gemini 2.5 Flash ansehen |
Was in Programmierung bewertet wird
Kriterien und Gewichte fuer dieses Genre-Ranking.
Korrektheit
35.0%
Dieses Kriterium ist enthalten, um Korrektheit in der Antwort zu pruefen. Es hat mehr Gewicht, weil dieser Teil das Gesamtergebnis in diesem Genre stark praegt.
Vollstandigkeit
20.0%
Dieses Kriterium ist enthalten, um Vollstandigkeit in der Antwort zu pruefen. Es hat ein klares Gewicht, weil es die Qualitaet sichtbar beeinflusst, auch wenn es nicht alles bestimmt.
Codequalitat
20.0%
Dieses Kriterium ist enthalten, um Codequalitat in der Antwort zu pruefen. Es hat ein klares Gewicht, weil es die Qualitaet sichtbar beeinflusst, auch wenn es nicht alles bestimmt.
Praktischer Nutzen
15.0%
Dieses Kriterium ist enthalten, um Praktischer Nutzen in der Antwort zu pruefen. Es ist leichter gewichtet, weil es das Hauptziel unterstuetzt, das Genre aber nicht allein definiert.
Befolgung der Anweisungen
10.0%
Dieses Kriterium ist enthalten, um Befolgung der Anweisungen in der Antwort zu pruefen. Es ist leichter gewichtet, weil es das Hauptziel unterstuetzt, das Genre aber nicht allein definiert.
Aktuelle Aufgaben
Programmierung
Implementiere einen deterministischen Limit-Order-Book-Simulator
Schreibe eine Python-3.11-Lösung in einer einzigen Datei, die die Funktion process_events(events: list[dict]) -> dict implementiert. Verwende keine externen Pakete. Die Funktion muss ein kleines Börsen-Limit-Order-Book für ein Instrument simulieren. Sie erhält eine Liste von Ereignis-Dictionaries in Eingabereihenfolge und gibt ein Dictionary mit genau diesen Schlüsseln zurück: trades, rejected, book. Ereignistypen: 1. Neues-Order-Ereignis: Erforderliche Felder: type="new", id, side, order_type, qty. side ist "buy" oder "sell". order_type ist "limit" oder "market". qty ist eine positive ganze Zahl. Eine Limit-Order erfordert außerdem price, eine positive ganze Anzahl von Cent. Das optionale Feld tif ist Time-in-Force: "GTC", "IOC" oder "FOK". Falls es fehlt, verwende "GTC" für Limit-Orders und "IOC" für Market-Orders. Market-Orders dürfen nicht tif="GTC" haben und dürfen nicht im Book verbleiben. 2. Cancel-Ereignis: Erforderliche Felder: type="cancel", id. Es storniert die verbleibende Menge einer derzeit im Book ruhenden Order mit dieser id. Matching-Regeln: - Das Book hat bids und asks. Ruhende Buy-Limit-Orders sind bids; ruhende Sell-Limit-Orders sind asks. - Preis-Zeit-Priorität ist zwingend: zuerst der beste Preis; bei gleichem Preis zuerst die früher akzeptierte ruhende Order. - Eine Buy-Order matched gegen ruhende asks, solange sie kreuzen kann: Eine Market-Buy kreuzt jeden ask; eine Limit-Buy kreuzt asks mit ask-Preis <= Buy-Limit-Preis. - Eine Sell-Order matched gegen ruhende bids, solange sie kreuzen kann: Eine Market-Sell kreuzt jeden bid; eine Limit-Sell kreuzt bids mit bid-Preis >= Sell-Limit-Preis. - Jede Trade-Menge ist min(verbleibende Menge der eingehenden Order, verbleibende Menge der ruhenden Order). - Der Trade-Preis ist immer der Limit-Preis der ruhenden Maker-Order, niemals der Preis der eingehenden Order. - Ein Trade-Record muss unmittelbar beim Eintreten angehängt werden und genau diese Schlüssel haben: buy_id, sell_id, price, qty, taker_id, maker_id. - Teilweise ausgeführte ruhende Orders behalten ihre ursprüngliche Priorität mit der verbleibenden Menge. Vollständig ausgeführte Orders verlassen das Book. Time-in-Force-Verhalten: - GTC-Limit-Orders lassen jeden nicht ausgeführten Rest im Book ruhen. - IOC-Orders führen sofort so viel wie möglich aus und stornieren dann jeden Rest. - FOK-Orders müssen gemäß dem aktuellen Book und den Kreuzungsregeln sofort vollständig ausführbar sein. Falls sie nicht vollständig ausführbar sind, erzeugen sie keine Trades und verändern das Book nicht. Falls sie vollständig ausführbar sind, werden sie normal ausgeführt. FOK-Orders verbleiben niemals im Book. Validierungs- und Zurückweisungsregeln: - Wenn ein Ereignis fehlerhaft formatiert ist, weise es zurück, ohne das Book zu verändern. Hänge einen Zurückweisungs-Record an rejected an mit den Schlüsseln input_index, event, reason. Der Grund kann eine kurze, für Menschen lesbare Zeichenkette sein. - Weise eine neue Order zurück, wenn ihre id bereits von einer zuvor akzeptierten neuen Order verwendet wurde, selbst wenn diese frühere Order inzwischen ausgeführt oder storniert wurde. - Weise Cancel-Ereignisse für unbekannte ids oder ids zurück, die nicht mehr im Book ruhen. - Weise qty- und price-Werte zurück, die nicht ganzzahlig sind, null sind oder negativ sind. In Python darf bool für diese Felder nicht als Ganzzahl akzeptiert werden. - Ignoriere zusätzliche Felder bei ansonsten gültigen Ereignissen. Rückgabeformat: - trades: Liste von Trade-Records in Ausführungsreihenfolge. - rejected: Liste von Zurückweisungs-Records in Eingabereihenfolge. - book: ein Dictionary mit den Schlüsseln bids und asks. - book["bids"] muss alle ruhenden bids auflisten, sortiert nach absteigendem Preis, dann ursprünglicher Ruhezeit, jeweils als {"id": id, "price": price, "qty": remaining_qty}. - book["asks"] muss alle ruhenden asks auflisten, sortiert nach aufsteigendem Preis, dann ursprünglicher Ruhezeit, jeweils als {"id": id, "price": price, "qty": remaining_qty}. Deine Antwort sollte vollständiger ausführbarer Python-Code sein, der process_events definiert. Du darfst Hilfsklassen/-funktionen und einen kleinen Selbsttest-Abschnitt einfügen, geschützt durch if __name__ == "__main__":, aber die Kernfunktion darf weder von stdin lesen noch nach stdout schreiben.
Programmierung
Atomare JSON-Patch-Anwendung in Python implementieren
Schreiben Sie eine Python-3.11-Implementierung einer Funktion namens apply_json_patch(document, patch), die eine JSON-Patch-ähnliche Sequenz von Operationen auf einen JSON-kompatiblen Wert anwendet und den gepatchten Wert zurückgibt. Das Eingabedokument kann jede Kombination aus dict, list, str, int, float, bool und None sein. Der Patch ist eine Liste von Operations-Dicts. Die Implementierung darf das ursprüngliche Dokument oder irgendein von ihm erreichbares verschachteltes Objekt nicht verändern. Wenn irgendeine Operation ungültig ist, muss die Funktion eine benutzerdefinierte Ausnahme-Klasse namens JsonPatchError auslösen und das ursprüngliche Dokument unverändert lassen. Unterstützte Operationen sind add, remove, replace, move, copy und test. Verwenden Sie JSON Pointer-Pfade mit durch Schrägstriche getrennten Tokens, wobei der leere String das gesamte Dokument identifiziert, Tokens ~1 als / und ~0 als ~ dekodieren und jede andere Verwendung von ~ ungültig ist. Für Objekte ist ein Pfad-Token ein Schlüssel. Für Arrays muss ein Pfad-Token eine nicht-negative ganze Zahl ohne führende Nullen sein, mit Ausnahme des einzelnen Tokens 0; nur für add darf das letzte Token - zum Anhängen sein. Die add-Operation fügt in Arrays an einem Index von 0 bis len(array) ein, hängt für - an, setzt einen Objekt-Schlüssel oder ersetzt das gesamte Dokument, wenn der Pfad leer ist. Die remove-Operation verlangt, dass das Ziel existiert, und löscht es. Die replace-Operation verlangt, dass das Ziel existiert, und ersetzt es. Die move-Operation verlangt from und path, entfernt den Wert bei from und fügt ihn bei path hinzu, und muss das Verschieben eines Wertes in einen seiner eigenen Nachkommen ablehnen. Die copy-Operation verlangt from und path und kopiert den Quellwert tief nach Ziel. Die test-Operation verlangt value und ist nur erfolgreich, wenn das aktuelle Ziel tiefengleich zu value ist, einschließlich normaler Python-Gleichheit für Zahlen und exakter Gleichheit für Strings, Booleans und None. Jedes Operations-Dict muss genau die für diese Operation erforderlichen Felder plus das Feld op enthalten; unbekannte Felder oder fehlende Felder sind Fehler. Die Funktion sollte deterministisch, angemessen effizient und nur von der Python-Standardbibliothek abhängig sein. Fügen Sie alle notwendigen Hilfsfunktionen oder -klassen hinzu. Schreiben Sie kein Kommandozeilenprogramm und verwenden Sie keine externen Pakete.
Programmierung
Implementieren Sie einen auf Abhängigkeiten basierenden Aufgabenplaner in Python
Schreiben Sie eine Python-Funktion oder -Klasse, die eine Liste von Aufgaben basierend auf ihren Abhängigkeiten plant. Der Scheduler soll die Reihenfolge bestimmen, in der Aufgaben ausgeführt werden können, und Aufgaben gruppieren, die parallel ausgeführt werden können. Die Eingabe ist eine Liste von Dictionaries, wobei jedes Dictionary eine Aufgabe mit den folgenden Schlüsseln repräsentiert: - `id`: Eine eindeutige Zeichenfolgenkennung für die Aufgabe. - `name`: Ein String-Name für die Aufgabe. - `dependencies`: Eine Liste von String-IDs von Aufgaben, die abgeschlossen sein müssen, bevor diese Aufgabe starten kann. Ihre Implementierung sollte: 1. Die Liste der Aufgaben-Dictionaries als Eingabe entgegennehmen. 2. Einen gültigen Ausführungsplan als Liste von Listen zurückgeben. Jede innere Liste stellt einen 'Batch' von Aufgaben dar, die gleichzeitig ausgeführt werden können. Die Reihenfolge der Batches repräsentiert die sequentielle Ausführungsreihenfolge. Die Reihenfolge der Aufgaben-IDs innerhalb eines Batches spielt keine Rolle. 3. Zirkuläre Abhängigkeiten erkennen und behandeln. Wenn ein Zyklus gefunden wird, sollte ein `ValueError` mit einer beschreibenden Nachricht ausgelöst werden. 4. Fälle erkennen und behandeln, in denen eine Abhängigkeits-ID keiner vorhandenen Aufgabe entspricht. Dies sollte ebenfalls einen `ValueError` auslösen.
Programmierung
Ratenbegrenzer mit gleitendem Fenster und Burst-Zulassung
Entwerfen und implementieren Sie einen threadsicheren Ratenbegrenzer in einer Sprache Ihrer Wahl (Python, Go, Java, TypeScript oder Rust), der die folgenden Anforderungen unterstützt: 1. **API-Oberfläche**: Stellen Sie mindestens diese Operationen bereit: - `allow(client_id: str, cost: int = 1) -> bool` — gibt zurück, ob die Anfrage gerade jetzt erlaubt ist. - `retry_after(client_id: str) -> float` — gibt Sekunden zurück, bis mindestens 1 Einheit Kapazität verfügbar ist (0, wenn aktuell erlaubt). - Ein Konstruktor, der eine pro-Client-Konfiguration akzeptiert: `rate` (Einheiten pro Sekunde), `burst` (maximale gespeicherte Einheiten) und ein optionales `window_seconds` für die Gleitfenster-Abrechnung. 2. **Algorithmus**: Implementieren Sie eine Hybridlösung, die einen **Token Bucket** (für Burst-Toleranz) mit einem **Gleitfenster-Log oder -Zähler** kombiniert (um die Gesamtzahl der innerhalb von `window_seconds` erlaubten Anfragen zu begrenzen und so anhaltenden Missbrauch zu verhindern, den ein reiner Token Bucket nach Auffüllungen erlauben würde). Eine Anfrage ist nur dann erlaubt, wenn beide Prüfungen bestehen. Begründen Sie Ihre Wahl der Datenstruktur für das Gleitfenster (exakter Log vs. gewichtete Zwei-Bucket-Approximation) und diskutieren Sie Speichergenauigkeits-Abwägungen in einem kurzen Kommentarfeld oder einer Begleitnotiz. 3. **Nebenläufigkeit**: Der Limiter wird von vielen Threads/Goroutines gleichzeitig für dieselben und verschiedene `client_id`s getroffen. Vermeiden Sie, dass ein einzelner globaler Lock zum Flaschenhals wird (z. B. per-Client-Locks oder Lock-Striping). Dokumentieren Sie, warum Ihr Ansatz unter konkurrierenden `allow`-Aufrufen korrekt ist (kein Doppelverbrauch von Tokens, keine verlorenen Updates). 4. **Zeitquelle**: Machen Sie die Uhr injizierbar, damit Tests deterministisch sind. Verwenden Sie standardmäßig eine monotonische Uhr. 5. **Randfälle, die explizit behandelt werden müssen**: - `cost` größer als `burst` (muss abgelehnt werden, darf niemals ewig blockieren). - Uhr geht rückwärts oder große Pausen (z. B. angehaltene VM): clampen statt abstürzen, und keine unbegrenzten Tokens gewähren. - Erste Anfrage für einen neuen Client (Lazy-Initialisierung). - Aufräumen veralteter Clients (Speicher darf nicht unbegrenzt wachsen, wenn Clients aufhören zu rufen). - Bruchteilige Tokens / sub-millisekunden Timing. 6. **Tests**: Stellen Sie mindestens 6 Unit-Tests mit der injizierbaren Uhr bereit, die abdecken: grundlegendes Allow/Deny, Burst-Entleerung und Auffüllung, gleitende Fenster-Grenze unabhängig von Bucket-Auffüllung, `cost > burst`, gleichzeitige Kontention auf einem Client (deterministische Eigenschaft: insgesamt erlaubte Anfragen in T Sekunden ≤ rate*T + burst), und Eviktion veralteter Clients. 7. **Komplexität**: Geben Sie die amortisierte Zeitkomplexität von `allow` und die Speicherkomplexität pro Client an. Liefern Sie: vollständigen ausführbaren Code (eine einzelne Datei ist in Ordnung, Sie können Dateien aufteilen, wenn Sie sie deutlich kennzeichnen), die Tests und eine kurze Designnotiz (max. ~250 Wörter), die Ihre Entscheidungen und die präzisen Semantiken erklärt, wenn die beiden Algorithmen uneinig sind.
Programmierung
Markdown-Subset-zu-HTML-Konverter
Schreiben Sie eine Python-Funktion `markdown_to_html(markdown_text: str) -> str`, die einen String, der eine bestimmte Teilmenge von Markdown enthält, in die entsprechende HTML-Darstellung konvertiert. Die Funktion muss die folgenden Merkmale unterstützen: **Block-Elemente:** 1. **Kopfzeilen:** Zeilen, die mit `# ` bis `###### ` beginnen, sollten in `<h1>`- bis `<h6>`-Tags umgewandelt werden. 2. **Ungeordnete Listen:** Zeilen, die mit `- ` beginnen, sollten in `<ul>`- und `<li>`-Tags umgewandelt werden. Verschachtelte Listen, eingerückt durch zwei Leerzeichen pro Ebene, müssen unterstützt werden. Eine Liste endet durch eine Leerzeile oder ein anderes Block-Element. 3. **Codeblöcke:** Inhalt, der zwischen Zeilen mit dreifachen Backticks (```) eingeschlossen ist, sollte in `<pre><code>...</code></pre>` umgewandelt werden. Der Sprachbezeichner in den öffnenden Backticks (z. B. ```python) sollte ignoriert werden. Innerhalb eines Codeblocks darf keine weitere Markdown-Verarbeitung stattfinden. 4. **Absätze:** Jeder andere Text sollte in `<p>`-Tags eingeschlossen werden. Aufeinanderfolgende Textzeilen gehören zum gleichen Absatz. Absätze werden durch eine oder mehrere Leerzeilen getrennt. **Inline-Elemente:** 1. **Fett & Kursiv:** `***text***` sollte in `<strong><em>text</em></strong>` umgewandelt werden. 2. **Fett:** `**text**` sollte in `<strong>text</strong>` umgewandelt werden. 3. **Kursiv:** `*text*` sollte in `<em>text</em>` umgewandelt werden. **Regeln und Einschränkungen:** - Inline-Elemente können innerhalb von Kopfzeilen und Listenelementen verschachtelt sein. - Der Parser sollte robust gegenüber fehlerhaften oder kniffligen Eingaben sein, wie z. B. nicht geschlossenen Inline-Tags. Zum Beispiel sollte `*italic` als `<p>*italic</p>` gerendert werden. - Die Prioritätsreihenfolge für Inline-Elemente ist `***`, dann `**`, dann `*`. - Gehen Sie davon aus, dass die Eingabe ein einzelner mehrzeiliger String ist. - Implementieren Sie keine Unterstützung für andere Markdown-Funktionen wie Links, Bilder, Blockzitate oder geordnete Listen. - Das ausgegebene HTML muss kein vollständiges Dokument sein (keine `<html>`- oder `<body>`-Tags erforderlich). **Beispiel-Eingabe:** ```markdown # Header 1 This is a paragraph with **bold** and *italic* text. This is the same paragraph. - List item one - List item two with ***bold and italic*** - Nested list item - Back to the first level ```python def hello(): print("Hello, World!") ``` ```
Programmierung
Implementieren Sie einen threadsicheren Token-Bucket-Rate-Limiter in Python
Schreiben Sie eine Python-Klasse mit dem Namen `TokenBucketRateLimiter`, die den Token-Bucket-Algorithmus zur Ratenbegrenzung implementiert. Die Implementierung muss threadsicher sein und darf keine externen Bibliotheken zur Zustandsverwaltung (wie Redis) verwenden. Die Klasse sollte folgende Spezifikationen haben: 1. Eine `__init__(self, capacity, refill_rate)`-Methode: * `capacity`: Die maximale Anzahl von Tokens, die der Bucket halten kann. * `refill_rate`: Die Anzahl von Tokens, die pro Sekunde dem Bucket hinzugefügt werden. 2. Eine `consume(self, tokens)`-Methode: * Diese Methode versucht, eine gegebene Anzahl von `tokens` aus dem Bucket zu verbrauchen. * Sie sollte `True` zurückgeben, wenn die Tokens erfolgreich verbraucht werden können, und `False` sonst. * Der Bucket sollte vor dem Versuch, Tokens zu verbrauchen, basierend auf der seit dem letzten Aufruf verstrichenen Zeit mit Tokens aufgefüllt werden. 3. Thread-Sicherheit: * Die Klasse muss sicher in mehreren gleichzeitig laufenden Threads verwendet werden können. Alle Operationen, die den Zustand des Buckets ändern (wie Auffüllen und Verbrauch von Tokens), müssen atomar sein. Geben Sie die vollständige Klassenimplementierung mit den notwendigen Imports an.