Programmation
Explorez la performance des modeles IA en Programmation. Comparez classements, criteres de notation et benchmarks recents.
Vue d ensemble du genre
Compare la justesse, la qualité et l’utilité pratique du code généré.
Dans ce genre, les capacites surtout observees sont Exactitude, Completude, Qualite du code.
Contrairement a system design, ce genre regarde davantage si le code fonctionne reellement que les choix d architecture de haut niveau.
Un score eleve ici ne garantit ni meilleur jugement produit, ni meilleure architecture, ni meilleures explications pour debutants.
Usages adaptes aux modeles forts dans ce genre
implementation, debogage, refactorisation et aide pratique a la programmation.
Ce que ce genre ne permet pas de juger a lui seul
si le modele est meilleur pour l architecture, les documents pour parties prenantes ou l ideation ouverte.
Classement des modeles forts dans ce genre
Ce classement est trie par score moyen uniquement dans ce genre.
Derniere mise a jour: 23 Mar 2026 17:47
Taux de victoire
Score moyen
Taux de victoire
Score moyen
Taux de victoire
Score moyen
Taux de victoire
Score moyen
Taux de victoire
Score moyen
Taux de victoire
Score moyen
Taux de victoire
Score moyen
Taux de victoire
Score moyen
Taux de victoire
Score moyen
| Modeles classes | Detail | ||||||
|---|---|---|---|---|---|---|---|
| #1 | GPT-5.2 | OpenAI |
100%
|
89
|
6 | 6 | Voir l evaluation et le score de GPT-5.2 |
| #2 | GPT-5 mini | OpenAI |
100%
|
82
|
5 | 5 | Voir l evaluation et le score de GPT-5 mini |
| #3 | GPT-5.4 | OpenAI |
80%
|
86
|
4 | 5 | Voir l evaluation et le score de GPT-5.4 |
| #4 | Claude Opus 4.6 | Anthropic |
33%
|
84
|
1 | 3 | Voir l evaluation et le score de Claude Opus 4.6 |
| #5 | Claude Sonnet 4.6 | Anthropic |
33%
|
76
|
1 | 3 | Voir l evaluation et le score de Claude Sonnet 4.6 |
| #6 | Gemini 2.5 Pro |
0%
|
84
|
0 | 3 | Voir l evaluation et le score de Gemini 2.5 Pro | |
| #7 | Gemini 2.5 Flash |
0%
|
75
|
0 | 3 | Voir l evaluation et le score de Gemini 2.5 Flash | |
| #8 | Gemini 2.5 Flash-Lite |
0%
|
72
|
0 | 3 | Voir l evaluation et le score de Gemini 2.5 Flash-Lite | |
| #9 | Claude Haiku 4.5 | Anthropic |
0%
|
65
|
0 | 3 | Voir l evaluation et le score de Claude Haiku 4.5 |
Ce qui est evalue dans Programmation
Criteres et poids utilises pour ce classement par genre.
Exactitude
35.0%
Ce critere est present pour verifier Exactitude dans la reponse. Il a plus de poids parce que cet aspect influence fortement le resultat global de ce genre.
Completude
20.0%
Ce critere est present pour verifier Completude dans la reponse. Il garde un poids important parce qu il change visiblement la qualite, meme si ce n est pas le seul element qui compte.
Qualite du code
20.0%
Ce critere est present pour verifier Qualite du code dans la reponse. Il garde un poids important parce qu il change visiblement la qualite, meme si ce n est pas le seul element qui compte.
Valeur pratique
15.0%
Ce critere est present pour verifier Valeur pratique dans la reponse. Il est plus legerement pondere parce qu il soutient l objectif principal sans definir a lui seul le genre.
Respect des consignes
10.0%
Ce critere est present pour verifier Respect des consignes dans la reponse. Il est plus legerement pondere parce qu il soutient l objectif principal sans definir a lui seul le genre.
Taches recentes
Programmation
Implémenter un cache LRU concurrent sans verrou global
Implémentez un cache LRU (Least Recently Used) thread-safe en Python qui prend en charge des lectures et écritures concurrentes sans utiliser un verrou global pour chaque opération. Votre implémentation doit satisfaire aux exigences suivantes : 1. **Interface**: Le cache doit prendre en charge ces opérations : - `__init__(self, capacity: int)` — Initialiser le cache avec une capacité maximale donnée (entier positif). - `get(self, key: str) -> Optional[Any]` — Retourner la valeur associée à la clé si elle existe (et la marquer comme récemment utilisée), ou retourner `None` si la clé n'est pas dans le cache. - `put(self, key: str, value: Any) -> None` — Insérer ou mettre à jour la paire clé-valeur. Si le cache dépasse la capacité après l'insertion, évincer l'élément le moins récemment utilisé. - `delete(self, key: str) -> bool` — Supprimer la clé du cache. Retourner `True` si la clé était présente, `False` sinon. - `keys(self) -> List[str]` — Retourner une liste de toutes les clés actuellement dans le cache, ordonnées de la plus récemment utilisée à la moins récemment utilisée. 2. **Concurrence**: Le cache doit être sûr à utiliser depuis plusieurs threads simultanément. Visez une conception qui permet aux lectures concurrentes de progresser sans se bloquer mutuellement quand c'est possible (par exemple, en utilisant des verrous lecture-écriture, des verrous à granularité fine, ou des techniques lock-free). Un mutex global unique qui sérialise chaque opération est considéré comme une solution de base mais sous-optimale. 3. **Exactitude sous contention**: En cas d'accès concurrent, le cache ne doit jamais renvoyer de données obsolètes ou corrompues, ne doit jamais dépasser la capacité annoncée et doit maintenir un ordre LRU cohérent. 4. **Cas limites à gérer**: - Capacité de 1 - `put` avec une clé qui existe déjà (doit mettre à jour la valeur et déplacer en tant que plus récent) - `delete` d'une clé qui n'existe pas - `put` et `get` concurrents sur la même clé - Évictions séquentielles rapides lorsque de nombreux threads insèrent simultanément 5. **Tests**: Inclure une fonction de test `run_tests()` qui démontre la correction de toutes les opérations en scénarios mono-thread et multi-thread. Le test multi-thread doit utiliser au moins 8 threads effectuant un mélange d'opérations `get`, `put` et `delete` sur des clés qui se chevauchent, et doit vérifier (assert) que le cache ne dépasse jamais sa capacité et que `get` ne renvoie jamais une valeur pour une clé qui n'a jamais été insérée. Fournissez votre implémentation complète en Python. N'utilisez que la bibliothèque standard (aucun paquet tiers). Incluez des docstrings et des commentaires expliquant votre stratégie de concurrence et les compromis de conception que vous avez faits.
Programmation
Analyseur avancé de fichiers journaux pour un format personnalisé
Écrivez une fonction Python `parse_log(log_content: str) -> list` qui analyse un fichier journal avec un format personnalisé. La fonction doit prendre le contenu du journal sous forme d'une seule chaîne multilignes et retourner une liste de dictionnaires, où chaque dictionnaire représente une transaction correctement terminée. **Règles du format de journal :** 1. **`START <transaction_id> <timestamp>`** : Marque le début d'une transaction. `transaction_id` est une chaîne sans espaces. `timestamp` est une chaîne au format ISO 8601. 2. **`END <transaction_id> <status> <timestamp>`** : Marque la fin d'une transaction. Le `transaction_id` doit correspondre à une transaction ouverte. `status` est un mot unique (par ex., `SUCCESS`, `FAIL`). 3. **`EVENT <key1>=<value1> <key2>="<value with spaces>" ...`** : Représente un événement au sein de la transaction active en cours. Il se compose d'une ou plusieurs paires clé-valeur. Les valeurs contenant des espaces doivent être entourées de guillemets doubles. 4. **`COMMENT # <any text>`** : Une ligne de commentaire qui doit être ignorée. **Logique de traitement :** * La fonction doit traiter les lignes de manière séquentielle. * Une ligne `EVENT` est associée à la transaction démarrée la plus récente qui n'a pas encore été terminée. * Une transaction n'est considérée complète et valide que si elle a une ligne `START` et une ligne `END` correspondantes avec le même `transaction_id`. * La sortie doit être une liste de dictionnaires. Chaque dictionnaire représente une transaction terminée et doit avoir les clés suivantes : * `transaction_id` (chaîne) * `start_time` (chaîne) * `end_time` (chaîne) * `status` (chaîne) * `events` (une liste de dictionnaires, où chaque dictionnaire intérieur représente les paires clé-valeur d'une ligne `EVENT`). **Gestion des erreurs et cas limites :** * Ignorer toutes les lignes `COMMENT`, les lignes vides ou les lignes malformées qui ne correspondent pas aux formats spécifiés. * Ignorer tout `EVENT` qui survient en dehors d'une transaction active (c.-à-d. avant le premier `START` ou après la fermeture d'une transaction). * Si une nouvelle ligne `START` apparaît avant que la transaction précédente n'ait été fermée par un `END`, la transaction précédente est considérée comme « abandonnée » et doit être rejetée. La nouvelle ligne `START` commence une nouvelle transaction. * Toute transaction encore ouverte à la fin du fichier journal est également considérée comme « abandonnée » et ne doit pas être incluse dans la sortie finale.
Programmation
Implémenter un limiteur de débit concurrent avec fenêtre glissante et files de priorité
Concevez et implémentez en Python un limiteur de débit thread-safe qui prend en charge les fonctionnalités suivantes : 1. **Limitation de débit par fenêtre glissante** : Le limiteur doit utiliser un algorithme de fenêtre glissante (et non des fenêtres fixes) pour suivre le nombre de requêtes. Étant donné un maximum de `max_requests` autorisées sur une période `window_seconds`, il doit déterminer avec précision si une nouvelle requête est autorisée à un instant donné. 2. **Plusieurs niveaux (tiers)** : Le limiteur de débit doit prendre en charge plusieurs niveaux nommés (par exemple, "free", "standard", "premium"), chacun avec sa propre configuration `max_requests` et `window_seconds`. Les clients se voient attribuer un niveau lors de leur enregistrement. 3. **File de priorité pour requêtes différées** : Lorsqu'une requête est limitée par le débit, au lieu de la rejeter simplement, le limiteur doit l'enfiler dans une file de priorité par niveau. Chaque requête possède une priorité entière (nombre inférieur = priorité plus élevée). Le limiteur doit fournir une méthode qui, lorsqu'une capacité se libère, désenfile et traite la requête en attente de plus haute priorité pour un client donné. 4. **Sécurité thread (Thread Safety)** : Toutes les opérations (allow_request, enqueue, dequeue, register_client) doivent être sûres à appeler depuis plusieurs threads simultanément. 5. **Nettoyage** : Fournir une méthode pour supprimer les données de suivi expirées pour les clients qui n'ont pas fait de requêtes dans les `cleanup_threshold_seconds` (configurable). Votre implémentation doit inclure : - Une classe `RateLimiter` avec l'interface décrite. - Une dataclass ou un named tuple `Request` contenant au minimum : `client_id`, `timestamp`, `priority`, et `payload`. - Une gestion appropriée des cas limites : enregistrement de clients en double, requêtes pour des clients non enregistrés, files de priorité vides, modifications concurrentes, et problèmes de précision d'horloge. Écrivez également un script de démonstration (dans le bloc `if __name__ == "__main__"`) qui : - Crée un limiteur de débit avec au moins deux niveaux. - Enregistre plusieurs clients. - Simule une rafale de requêtes provenant de plusieurs threads, montrant certaines autorisées et d'autres enfilées. - Montre des requêtes différées traitées lorsque la capacité se libère. - Affiche des sorties claires montrant la séquence des événements. Expliquez vos choix de conception dans des commentaires, en particulier concernant votre implémentation de la fenêtre glissante, votre choix de primitives de synchronisation, et tout compromis que vous avez fait entre précision et performance.
Programmation
Implémenter un limiteur de débit concurrent avec fenêtre glissante et files de priorité
Concevez et implémentez un limiteur de débit (rate limiter) sûr pour les threads en Python qui prend en charge les fonctionnalités suivantes : 1. **Limitation de débit par fenêtre glissante** : Plutôt que d'utiliser des fenêtres temporelles fixes, implémentez un véritable algorithme de fenêtre glissante. Chaque client (identifié par une chaîne de caractères) est autorisé au maximum `max_requests` requêtes dans toute fenêtre glissante de `window_seconds` secondes. 2. **Niveaux de priorité** : Chaque requête a un niveau de priorité (entier 1-5, où 1 est la priorité la plus élevée). Lorsque la limite est atteinte pour un client, les requêtes de plus basse priorité (numéro plus élevé) doivent être rejetées en premier. Plus précisément, si une nouvelle requête de priorité P arrive et que la fenêtre est pleine, le limiteur doit vérifier s'il existe dans la fenêtre courante une requête ayant une priorité strictement plus basse (numéro plus élevé) que P. Si c'est le cas, le créneau de la requête la plus basse en priorité (numéro le plus élevé) est « révoqué » et la nouvelle requête de priorité supérieure est admise. La requête révoquée doit être enregistrée afin de pouvoir être rapportée. Si aucune requête de priorité inférieure n'existe pour être révoquée, la nouvelle requête est rejetée. 3. **Tolérance de rafale (burst)** : Chaque client peut optionnellement avoir une tolérance de rafale `burst` (par défaut 0). Cela permet jusqu'à `burst` requêtes supplémentaires au-delà de `max_requests` dans une fenêtre, mais uniquement si au moins la moitié de la durée de la fenêtre s'est écoulée depuis la première requête du client dans la fenêtre courante. 4. **Sécurité vis-à-vis des threads** : Le limiteur doit être sûr pour un usage concurrent depuis plusieurs threads. Démontrez cela avec un scénario de test. 5. **Statistiques** : Le limiteur doit suivre des statistiques par client : total de requêtes admises, total rejetées, total révoquées (éjectées par des requêtes de priorité supérieure), et utilisation courante de la fenêtre (en flottant de 0.0 à 1.0). Implémentez l'interface suivante : ```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: '''Override burst allowance for a specific client.''' ... def allow(self, client_id: str, priority: int = 3, timestamp: float = None) -> bool: ''' Vérifie si une requête est autorisée. Si timestamp est None, utiliser l'heure courante. Retourne True si la requête est admise, False si elle est rejetée. ''' ... def get_stats(self, client_id: str) -> dict: ''' Retourne un dict avec les clés : 'admitted', 'rejected', 'revoked', 'utilization' ''' ... def get_revoked_log(self, client_id: str) -> list: ''' Retourne une liste de tuples (timestamp, priority) pour les requêtes révoquées pour le client donné, dans l'ordre chronologique. ''' ... ``` Fournissez une implémentation complète et exécutable ainsi qu'un script de démonstration qui : - Crée un limiteur avec max_requests=5, window_seconds=10.0, default_burst=2 - Simule une séquence de requêtes de deux clients avec des priorités et timestamps variables qui mette en évidence toutes les fonctionnalités (expiration par fenêtre glissante, révocation par priorité, activation du burst, et rejet) - Affiche les statistiques et les journaux de révoqués pour chaque client à la fin - Inclut un bref test multithread avec au moins 4 threads effectuant des requêtes concurrentes Assurez-vous de gérer les cas limites tels que : - Validation de la valeur de priorité (doit être 1-5) - Requêtes arrivant exactement aux limites de la fenêtre - Révocations multiples en séquence - Activation de la tolérance de rafale précisément au marqueur de la moitié de la fenêtre - IDs de client vides ou inconnus dans les requêtes de statistiques
Programmation
Implémenter un cache LRU concurrent sans verrou global
Concevez et implémentez un cache LRU (Least Recently Used) thread-safe en Python qui prend en charge des lectures et écritures concurrentes sans utiliser un verrou global pour chaque opération. Votre implémentation doit satisfaire les exigences suivantes : 1. Le cache a une capacité maximale fixe spécifiée lors de la construction. 2. Il supporte trois opérations : - get(key): Renvoie la valeur associée à la clé, ou None si la clé n'est pas présente. L'accès à une clé doit la marquer comme la plus récemment utilisée. - put(key, value): Insère ou met à jour la paire clé-valeur. Si le cache est à capacité et qu'une nouvelle clé est insérée, l'entrée la moins récemment utilisée doit être évincée. - delete(key): Supprime la clé du cache si elle est présente. Renvoie True si la clé a été trouvée et supprimée, False sinon. 3. Le cache doit être sûr pour une utilisation simultanée depuis plusieurs threads. Les opérations get concurrentes sur des clés différentes ne doivent pas se bloquer mutuellement. Vous devez minimiser la contention — un verrou grossier unique autour de tout n'est pas acceptable. 4. La politique d'éviction doit être strictement LRU : l'entrée qui a été accédée (via get ou put) le moins récemment doit être celle qui est évincée. 5. Gérez les cas limites : capacité de 1, puts concurrents rapides qui déclenchent des évictions, get/put/delete entremêlés sur la même clé depuis différents threads, et capacité nulle ou négative (lever ValueError). Fournissez votre implémentation complète en tant que module Python unique. Incluez une brève explication de votre stratégie de concurrence et pourquoi elle préserve la correction. Incluez également une courte démonstration (dans un bloc main ou une fonction de test) qui crée plusieurs threads effectuant des opérations mixtes get/put/delete et qui affirme que le cache ne dépasse jamais sa capacité et qu'il n'y a pas de corruption des données.
Programmation
Stockage clé-valeur en mémoire avec prise en charge des transactions
Écrivez une classe Python `InMemoryDB` qui implémente un simple magasin de données clé-valeur en mémoire avec prise en charge des transactions imbriquées. La classe doit posséder les méthodes suivantes: - `get(key)`: Retourne la valeur associée à une clé. Si la clé n'existe pas, elle doit retourner `None`. - `set(key, value)`: Définit la valeur pour une clé donnée. Si une transaction est en cours, ce changement ne doit être visible que dans cette transaction jusqu'à ce qu'il soit validé. - `begin()`: Démarre une nouvelle transaction. Les transactions peuvent être imbriquées. - `commit()`: Valide toutes les modifications effectuées dans la transaction courante vers sa transaction parente (ou vers le magasin principal si c'est la transaction la plus externe). S'il n'y a pas de transaction active, elle doit lever une erreur. - `rollback()`: Annule toutes les modifications effectuées dans la transaction courante. S'il n'y a pas de transaction active, elle doit lever une erreur.