Programmierung
Entdecke, wie KI-Modelle in Programmierung performen. Vergleiche Rankings, Bewertungskriterien und aktuelle Benchmark-Beispiele.
Genre-Uberblick
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.
Ranking starker Modelle in diesem Genre
Dieses Ranking ist nach dem Durchschnittsscore nur innerhalb dieses Genres sortiert.
Zuletzt aktualisiert: 23 Mar 2026 17:47
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
Siegesquote
Durchschnittsscore
| Gerankte Modelle | Detail | ||||||
|---|---|---|---|---|---|---|---|
| #1 | GPT-5.2 | OpenAI |
100%
|
89
|
6 | 6 | Bewertung und Punktzahl von GPT-5.2 ansehen |
| #2 | GPT-5 mini | OpenAI |
100%
|
82
|
5 | 5 | Bewertung und Punktzahl von GPT-5 mini ansehen |
| #3 | GPT-5.4 | OpenAI |
80%
|
86
|
4 | 5 | Bewertung und Punktzahl von GPT-5.4 ansehen |
| #4 | Claude Opus 4.6 | Anthropic |
33%
|
84
|
1 | 3 | Bewertung und Punktzahl von Claude Opus 4.6 ansehen |
| #5 | Claude Sonnet 4.6 | Anthropic |
33%
|
76
|
1 | 3 | Bewertung und Punktzahl von Claude Sonnet 4.6 ansehen |
| #6 | Gemini 2.5 Pro |
0%
|
84
|
0 | 3 | Bewertung und Punktzahl von Gemini 2.5 Pro ansehen | |
| #7 | Gemini 2.5 Flash |
0%
|
75
|
0 | 3 | Bewertung und Punktzahl von Gemini 2.5 Flash ansehen | |
| #8 | Gemini 2.5 Flash-Lite |
0%
|
72
|
0 | 3 | Bewertung und Punktzahl von Gemini 2.5 Flash-Lite ansehen | |
| #9 | Claude Haiku 4.5 | Anthropic |
0%
|
65
|
0 | 3 | Bewertung und Punktzahl von Claude Haiku 4.5 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 sperrfreien konkurrierenden LRU-Cache
Implementiere einen threadsicheren LRU (Least Recently Used) Cache in Python, der gleichzeitig Lese- und Schreibzugriffe unterstützt, ohne für jede Operation einen globalen Lock zu verwenden. Deine Implementierung muss die folgenden Anforderungen erfüllen: 1. **Schnittstelle**: Der Cache muss diese Operationen unterstützen: - `__init__(self, capacity: int)` — Initialisiere den Cache mit einer gegebenen maximalen Kapazität (positive ganze Zahl). - `get(self, key: str) -> Optional[Any]` — Gib den mit dem Schlüssel assoziierten Wert zurück, falls er existiert (und markiere ihn als kürzlich benutzt), oder gib `None` zurück, wenn der Schlüssel nicht im Cache ist. - `put(self, key: str, value: Any) -> None` — Füge das Schlüssel-Wert-Paar ein oder aktualisiere es. Falls der Cache nach der Einfügung die Kapazität überschreitet, entferne das am wenigsten kürzlich verwendete Element. - `delete(self, key: str) -> bool` — Entferne den Schlüssel aus dem Cache. Gib `True` zurück, wenn der Schlüssel vorhanden war, sonst `False`. - `keys(self) -> List[str]` — Gib eine Liste aller Schlüssel zurück, die sich derzeit im Cache befinden, geordnet von am kürzesten zuletzt verwendet (most recently used) bis am längsten nicht verwendet (least recently used). 2. **Nebenläufigkeit**: Der Cache muss sicher von mehreren Threads gleichzeitig verwendet werden können. Ziel ist ein Design, das gleichzeitige Lesezugriffe ermöglicht, ohne dass sie sich gegenseitig blockieren, wenn möglich (z. B. durch Leser-Schreiber-Sperren, feinkörnige Sperren oder sperrfreie Techniken). Ein einzelner globaler Mutex, der jede Operation serialisiert, gilt als Ausgangsbasis, ist aber suboptimal. 3. **Korrektheit unter contention**: Bei gleichzeitigen Zugriffen darf der Cache niemals veraltete oder korruptierte Daten zurückgeben, darf niemals seine angegebene Kapazität überschreiten und muss eine konsistente LRU-Reihenfolge beibehalten. 4. **Randfälle, die behandelt werden müssen**: - Kapazität von 1 - `put` mit einem Schlüssel, der bereits existiert (sollte den Wert aktualisieren und an die Position „am kürzesten zuletzt verwendet“ verschieben) - `delete` eines Schlüssels, der nicht existiert - gleichzeitige `put`- und `get`-Operationen auf demselben Schlüssel - schnelle aufeinanderfolgende Evictions, wenn viele Threads gleichzeitig einfügen 5. **Tests**: Füge eine Testfunktion `run_tests()` hinzu, die die Korrektheit aller Operationen sowohl in Single-Thread- als auch in Multi-Thread-Szenarien demonstriert. Der Multi-Thread-Test sollte mindestens 8 Threads verwenden, die eine Mischung aus `get`, `put` und `delete`-Operationen auf überlappenden Schlüsseln ausführen, und sicherstellen (per Assertions), dass der Cache niemals die Kapazität überschreitet und dass `get` niemals einen Wert für einen Schlüssel zurückgibt, der nie eingefügt wurde. Gib deine vollständige Implementierung in Python an. Verwende nur die Standardbibliothek (keine Drittanbieter-Pakete). Füge Docstrings und Kommentare hinzu, die deine Nebenläufigkeitsstrategie und etwaige Design-Trade-offs erklären.
Programmierung
Erweiterter Logdatei-Parser für ein benutzerdefiniertes Format
Schreiben Sie eine Python-Funktion `parse_log(log_content: str) -> list`, die eine Logdatei mit einem benutzerdefinierten Format parst. Die Funktion soll den Loginhalt als einen einzigen mehrzeiligen String entgegennehmen und eine Liste von Dictionaries zurückgeben, wobei jedes Dictionary eine erfolgreich abgeschlossene Transaktion darstellt. **Regeln für das Log-Format:** 1. **`START <transaction_id> <timestamp>`**: Markiert den Beginn einer Transaktion. `transaction_id` ist ein String ohne Leerzeichen. `timestamp` ist ein ISO-8601-formatiertes String. 2. **`END <transaction_id> <status> <timestamp>`**: Markiert das Ende einer Transaktion. Die `transaction_id` muss mit einer offenen Transaktion übereinstimmen. `status` ist ein einzelnes Wort (z. B. `SUCCESS`, `FAIL`). 3. **`EVENT <key1>=<value1> <key2>="<value with spaces>" ...`**: Stellt ein Ereignis innerhalb der aktuell aktiven Transaktion dar. Es besteht aus einem oder mehreren Schlüssel-Wert-Paaren. Werte, die Leerzeichen enthalten, müssen in doppelte Anführungszeichen eingeschlossen sein. 4. **`COMMENT # <any text>`**: Eine Kommentarzeile, die ignoriert werden soll. **Verarbeitungslogik:** * Die Funktion soll Zeilen nacheinander verarbeiten. * Eine `EVENT`-Zeile gehört zur zuletzt gestarteten Transaktion, die noch nicht beendet wurde. * Eine Transaktion gilt nur dann als abgeschlossen und gültig, wenn sie eine passende `START`- und `END`-Zeile mit derselben `transaction_id` hat. * Die Ausgabe soll eine Liste von Dictionaries sein. Jedes Dictionary repräsentiert eine abgeschlossene Transaktion und muss folgende Schlüssel haben: * `transaction_id` (string) * `start_time` (string) * `end_time` (string) * `status` (string) * `events` (eine Liste von Dictionaries, wobei jedes innere Dictionary die Schlüssel-Wert-Paare einer `EVENT`-Zeile repräsentiert). **Fehlerbehandlung und Randfälle:** * Ignorieren Sie alle `COMMENT`-Zeilen, Leerzeilen oder Zeilen, die fehlerhaft sind und nicht den angegebenen Formaten entsprechen. * Ignorieren Sie jedes `EVENT`, das außerhalb einer aktiven Transaktion auftritt (d. h. vor dem ersten `START` oder nachdem eine Transaktion geschlossen wurde). * Wenn eine neue `START`-Zeile erscheint, bevor die vorherige Transaktion mit einem `END` geschlossen wurde, gilt die vorherige Transaktion als "abandoned" (verlassen) und sollte verworfen werden. Die neue `START`-Zeile beginnt eine neue Transaktion. * Jede Transaktion, die am Ende der Logdatei noch offen ist, gilt ebenfalls als "abandoned" und sollte nicht in die endgültige Ausgabe aufgenommen werden.
Programmierung
Einen nebenläufigen Rate Limiter mit gleitendem Fenster und Prioritätswarteschlangen implementieren
Designen und implementieren Sie einen thread-sicheren Rate Limiter in Python, der die folgenden Funktionen unterstützt: 1. **Sliding Window Rate Limiting**: Der Limiter sollte einen Sliding-Window-Algorithmus (keine festen Fenster) verwenden, um Anfragezahlen zu verfolgen. Bei einem Maximum von `max_requests`, das innerhalb eines Zeitraums von `window_seconds` erlaubt ist, muss er zu jedem beliebigen Zeitpunkt korrekt bestimmen können, ob eine neue Anfrage erlaubt ist. 2. **Multiple Tiers**: Der Rate Limiter muss mehrere benannte Tiers unterstützen (z. B. `"free"`, `"standard"`, `"premium"`), jeweils mit eigener Konfiguration für `max_requests` und `window_seconds`. Clients werden bei der Registrierung einem Tier zugewiesen. 3. **Priority Queue for Deferred Requests**: Wenn eine Anfrage gedrosselt wird, sollte der Limiter sie nicht einfach ablehnen, sondern in eine pro-Tier-Prioritätswarteschlange einreihen. Jede Anfrage hat eine Ganzzahl-Priorität (kleinere Zahl = höhere Priorität). Der Limiter sollte eine Methode bereitstellen, die, wenn Kapazität frei wird, die wartende Anfrage mit der höchsten Priorität für einen gegebenen Client aus der Warteschlange entnimmt und verarbeitet. 4. **Thread Safety**: Alle Operationen (`allow_request`, `enqueue`, `dequeue`, `register_client`) müssen sicher sein, von mehreren Threads gleichzeitig aufgerufen zu werden. 5. **Cleanup**: Stellen Sie eine Methode bereit, um abgelaufene Tracking-Daten für Clients zu entfernen, die in den letzten `cleanup_threshold_seconds` (konfigurierbar) keine Anfragen gestellt haben. Ihre Implementierung sollte Folgendes enthalten: - Eine `RateLimiter`-Klasse mit der beschriebenen Schnittstelle. - Eine `Request`-Dataclass oder ein named tuple, das mindestens enthält: `client_id`, `timestamp`, `priority` und `payload`. - Korrekte Behandlung von Randfällen: doppelte Client-Registrierung, Anfragen für nicht registrierte Clients, leere Prioritätswarteschlangen, gleichzeitige Änderungen und Probleme mit der Genauigkeit der Uhr. Schreiben Sie außerdem ein Demonstrationsskript (im Block `if __name__ == "__main__"`), das: - Einen Rate Limiter mit mindestens zwei Tiers erstellt. - Mehrere Clients registriert. - Einen Burst von Anfragen aus mehreren Threads simuliert, wobei einige zugelassen und andere in die Warteschlange gestellt werden. - Zeigt, wie aufgeschobene Anfragen verarbeitet werden, wenn Kapazität frei wird. - Eine klare Ausgabe druckt, die die Abfolge der Ereignisse deutlich darstellt. Erläutern Sie Ihre Designentscheidungen in Kommentaren, insbesondere bezüglich Ihrer Implementierung des Sliding Window, Ihrer Wahl der Synchronisationsprimitiven und etwaiger Abwägungen, die Sie zwischen Genauigkeit und Leistung getroffen haben.
Programmierung
Implementieren Sie einen nebenläufigen Ratenbegrenzer mit gleitendem Fenster und Prioritätswarteschlangen
Entwerfen und implementieren Sie einen Thread-sicheren Ratenbegrenzer in Python, der folgende Funktionen unterstützt: 1. **Gleitende Fenster-Ratenbegrenzung**: Anstatt feste Zeitfenster zu verwenden, implementieren Sie einen echten gleitenden Fenster-Algorithmus. Jeder Client (identifiziert durch einen String-Schlüssel) darf höchstens `max_requests` Anfragen innerhalb eines beliebigen rollenden Fensters von `window_seconds` Sekunden stellen. 2. **Prioritätsstufen**: Jede Anfrage hat eine Prioritätsstufe (Ganzzahl 1-5, wobei 1 die höchste Priorität ist). Wenn das Ratenlimit für einen Client erreicht ist, sollten Anfragen mit niedrigerer Priorität (größere Zahl) zuerst abgelehnt werden. Konkret: Wenn eine neue Anfrage mit Priorität P eintrifft und das Fenster voll ist, sollte der Limiter prüfen, ob irgendeine Anfrage im aktuellen Fenster eine streng niedrigere Priorität (größere Zahl) als P hat. Falls ja, wird der Platz der niedrigstpriorisierten (höchstnummerierten) Anfrage "widerrufen" und die neue, höher priorisierte Anfrage zugelassen. Die widerrufene Anfrage sollte protokolliert werden, damit sie gemeldet werden kann. Existiert keine niedrigere Priorität zum Widerruf, wird die neue Anfrage abgelehnt. 3. **Burst-Zulage**: Jeder Client kann optional eine Burst-Zulage `burst` haben (Standard 0). Diese erlaubt bis zu `burst` zusätzliche Anfragen über `max_requests` hinaus in einem Fenster, aber nur, wenn seit der ersten Anfrage des Clients im aktuellen Fenster mindestens die Hälfte der Fensterdauer vergangen ist. 4. **Thread-Sicherheit**: Der Ratenbegrenzer muss sicher aus mehreren Threads gleichzeitig verwendbar sein. Demonstrieren Sie dies mit einem Testszenario. 5. **Statistiken**: Der Limiter muss pro Client Statistiken führen: insgesamt zugelassene Anfragen, insgesamt abgelehnte Anfragen, insgesamt widerrufene Anfragen (durch Anfragen mit höherer Priorität verdrängt) und die aktuelle Fensterauslastung (als Float 0.0 bis 1.0). Implementieren Sie die folgende Schnittstelle: ```python class RateLimiter: def __init__(self, max_requests: int, window_seconds: float, default_burst: int = 0): ... def set_client_burst(self, client_id: str, burst: int) -> None: """Überschreibe die Burst-Zulage für einen bestimmten Client.""" ... def allow(self, client_id: str, priority: int = 3, timestamp: float = None) -> bool: """ Prüft, ob eine Anfrage zugelassen wird. Falls timestamp None ist, verwende die aktuelle Zeit. Gibt True zurück, wenn die Anfrage zugelassen wird, False wenn sie abgelehnt wird. """ ... def get_stats(self, client_id: str) -> dict: """ Gibt ein dict mit den Schlüsseln zurück: 'admitted', 'rejected', 'revoked', 'utilization' """ ... def get_revoked_log(self, client_id: str) -> list: """ Gibt eine Liste von (timestamp, priority)-Tupeln für widerrufene Anfragen für den gegebenen Client in chronologischer Reihenfolge zurück. """ ... ``` Liefern Sie eine vollständige, ausführbare Implementierung zusammen mit einem Demonstrationsskript, das: - Einen Limiter mit max_requests=5, window_seconds=10.0, default_burst=2 erstellt - Eine Sequenz von Anfragen von zwei Clients mit variierenden Prioritäten und Zeitstempeln simuliert, die alle Funktionen abdeckt (Ablauf im gleitenden Fenster, Prioritäts-Widerruf, Burst-Aktivierung und Ablehnung) - Am Ende die Statistiken und die Widerrufsprotokolle für jeden Client ausgibt - Einen kurzen Multithread-Test enthält mit mindestens 4 Threads, die gleichzeitig Anfragen stellen Stellen Sie sicher, dass Randfälle behandelt werden wie: - Validierung der Prioritätswerte (muss 1-5 sein) - Anfragen, die genau an den Fenstergrenzen ankommen - Mehrfache Widerrufe in Folge - Burst-Zulage, die präzise beim Halbfenstermark aktiviert - Leere oder unbekannte Client-IDs in Statistikabfragen
Programmierung
Implementieren Sie einen sperrfreien nebenläufigen LRU-Cache
Designen und implementieren Sie einen threadsicheren LRU- (Least Recently Used) Cache in Python, der gleichzeitige Lese- und Schreibzugriffe unterstützt, ohne für jede Operation ein globales Lock zu verwenden. Ihre Implementierung muss die folgenden Anforderungen erfüllen: 1. Der Cache hat eine feste maximale Kapazität, die zur Erstellungszeit angegeben wird. 2. Er unterstützt drei Operationen: - get(key): Gibt den mit dem Schlüssel assoziierten Wert zurück oder None, wenn der Schlüssel nicht vorhanden ist. Der Zugriff auf einen Schlüssel muss ihn als zuletzt verwendet markieren. - put(key, value): Fügt das Schlüssel-Wert-Paar ein oder aktualisiert es. Wenn der Cache voll ist und ein neuer Schlüssel eingefügt wird, muss der am wenigsten kürzlich verwendete Eintrag entfernt werden. - delete(key): Entfernt den Schlüssel aus dem Cache, falls vorhanden. Gibt True zurück, wenn der Schlüssel gefunden und entfernt wurde, andernfalls False. 3. Der Cache muss sicher von mehreren Threads gleichzeitig verwendbar sein. Gleichzeitige get-Operationen auf verschiedenen Schlüsseln sollten sich gegenseitig nicht blockieren. Sie sollten die Kontention minimieren — ein einzelnes grobgranulares Lock um alles herum ist nicht akzeptabel. 4. Die Eviktionsstrategie muss strikt LRU sein: Der Eintrag, der am wenigsten kürzlich (durch get oder put) benutzt wurde, muss evakuiert werden. 5. Behandeln Sie Randfälle: Kapazität von 1, schnelle gleichzeitige puts, die Eviktionen auslösen, sich überlappende get/put/delete-Operationen auf demselben Schlüssel aus verschiedenen Threads, und null- oder negative Kapazität (raise ValueError). Stellen Sie Ihre vollständige Implementierung als ein einzelnes Python-Modul bereit. Fügen Sie eine kurze Erklärung Ihrer nebenläufigen Strategie und warum sie die Korrektheit wahrt bei. Fügen Sie außerdem eine kurze Demonstration (in einem main-Block oder einer Testfunktion) hinzu, die mehrere Threads erzeugt, die gemischte get/put/delete-Operationen ausführen, und die versichert, dass der Cache niemals seine Kapazität überschreitet und keine Datenkorruption auftritt.
Programmierung
In-Memory-Schlüssel-Wert-Speicher mit Transaktionsunterstützung
Schreiben Sie eine Python-Klasse `InMemoryDB`, die einen einfachen In-Memory-Schlüssel-Wert-Datenspeicher mit Unterstützung für verschachtelte Transaktionen implementiert. Die Klasse sollte die folgenden Methoden haben: - `get(key)`: Gibt den mit einem Schlüssel verknüpften Wert zurück. Falls der Schlüssel nicht existiert, soll `None` zurückgegeben werden. - `set(key, value)`: Legt den Wert für einen gegebenen Schlüssel fest. Wenn eine Transaktion aktiv ist, sollte diese Änderung nur innerhalb dieser Transaktion sichtbar sein, bis sie committed wird. - `begin()`: Startet eine neue Transaktion. Transaktionen können verschachtelt sein. - `commit()`: Überträgt alle Änderungen, die in der aktuellen Transaktion vorgenommen wurden, auf die übergeordnete Transaktion (oder auf den Hauptspeicher, wenn es die äußerste Transaktion ist). Wenn keine aktive Transaktion vorhanden ist, soll ein Fehler ausgelöst werden. - `rollback()`: Verwirft alle Änderungen, die in der aktuellen Transaktion vorgenommen wurden. Wenn keine aktive Transaktion vorhanden ist, soll ein Fehler ausgelöst werden.