Programmation
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.
Programmation : GPT-5 mini prend la 1re place, mais la meilleure moyenne finit 4e
Anthropic
OpenAI
OpenAI
Score moyen par modele
Notre ponderation
Sur 37 réponses de code évaluées, le classement est mené par GPT-5 mini : moyenne de 8,22 sur 5 échantillons, 5 premières places et 100 % de victoires. C'est à la fois le mieux classé et l'un des mieux étayés ici, un sans-faute au coût de la gamme légère. Juste derrière, Claude Opus 4.8 occupe la 2e place avec 8,07 sur seulement 2 échantillons et un parcours parfait à 100 %, à lire donc comme un signal fort mais encore provisoire.
Moyenne et classement divergent nettement, car le taux de victoires (premières places en duel) pèse davantage que la moyenne brute. GPT-5.5 affiche la meilleure moyenne du genre, 8,9, et n'est pourtant que 4e, car sur 2 échantillons il n'en a gagné qu'1, soit 50 % de victoires. GPT-5.4, à l'inverse, apporte la plus grande base de preuves, 8 échantillons, avec 8,41 de moyenne, 6 premières places et 75 % de victoires à la 3e place. L'avance du leader sur le 2e n'est que de 0,15 point : le sommet est donc très serré.
Le cas le plus net d'une bonne moyenne enterrée par un faible face-à-face est Gemini 2.5 Pro : moyenne de 7,95, au-dessus du milieu de tableau, mais 6e place avec 0 % de victoires sur 4 échantillons. Claude Sonnet 4.6 mène le milieu avec 7,7 (50 % sur 4 échantillons, 5e place), à 0,5 à 1,2 point du groupe GPT-5. Les gammes plus légères et rapides sont en dessous : Gemini 2.5 Flash-Lite (7,17), Gemini 2.5 Flash (6,84) et Claude Haiku 4.5 (6,48) accusent 1,0 à 1,7 point de retard sur le leader. La Justesse étant la mieux pondérée (35), devant Complétude et Qualité du code (20 chacune), ces écarts traduisent une justesse plus faible sur les tâches difficiles, pas seulement le style.
La principale réserve est la taille d'échantillon. Claude Opus 4.8 et GPT-5.5 reposent sur 2 échantillons chacun et la plupart se situent entre 3 et 8 : les moyennes peuvent donc bouger avec quelques prompts. L'écart de 1,74 point entre le premier et le dernier est réel, mais l'ordre fin au sein du groupe à 8 points (GPT-5.5, GPT-5.4, GPT-5 mini, Claude Opus 4.8) reste provisoire. Ce sont des mesures dépendantes des conditions, non un verdict sur le meilleur modèle de code en général.
En bref
Pour coder de façon fiable aujourd'hui, GPT-5 mini est le choix le plus défendable : 1re place avec 100 % de victoires sur 5 échantillons au coût de la gamme légère. GPT-5.4 est l'option haut de gamme la mieux étayée (8,41 sur 8 échantillons), tandis que la moyenne record de 8,9 de GPT-5.5 et la 2e place de Claude Opus 4.8 reposent toutes deux sur 2 échantillons : à considérer comme prometteuses mais non prouvées.
Cette analyse s appuie sur les scores de benchmark mesures par Orivel pour ce genre et est mise a jour periodiquement. Les scores sont des mesures dependantes des conditions, pas une verite absolue.
Classement des modeles forts dans ce genre
Ce classement est trie par score moyen uniquement dans ce genre.
Derniere mise a jour: 16 Jul 2026 09:49
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 | Claude Fable 5 | Anthropic |
100%
|
91
|
1 | 1 | Voir l evaluation et le score de Claude Fable 5 |
| #2 | GPT-5.6 NOUVEAU | OpenAI |
100%
|
86
|
1 | 1 | Voir l evaluation et le score de GPT-5.6 |
| #3 | GPT-5 mini | OpenAI |
100%
|
82
|
5 | 5 | Voir l evaluation et le score de GPT-5 mini |
| #4 | Claude Opus 4.8 | Anthropic |
100%
|
81
|
2 | 2 | Voir l evaluation et le score de Claude Opus 4.8 |
| #5 | GPT-5.5 | OpenAI |
50%
|
89
|
1 | 2 | Voir l evaluation et le score de GPT-5.5 |
| #6 | Claude Sonnet 4.6 | Anthropic |
50%
|
77
|
2 | 4 | Voir l evaluation et le score de Claude Sonnet 4.6 |
| #7 | Gemini 2.5 Pro |
0%
|
74
|
0 | 5 | Voir l evaluation et le score de Gemini 2.5 Pro | |
| #8 | Gemini 2.5 Flash-Lite |
0%
|
72
|
0 | 3 | Voir l evaluation et le score de Gemini 2.5 Flash-Lite | |
| #9 | Gemini 2.5 Flash |
0%
|
68
|
0 | 5 | Voir l evaluation et le score de Gemini 2.5 Flash |
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
Limiteur de débit avec fenêtre glissante et quotas multi‑locataires équitables
Implémentez une bibliothèque de limitation de débit réutilisable dans un langage de votre choix (Python, Go, TypeScript, Java ou Rust) qui applique des quotas de requêtes par client en utilisant un algorithme à fenêtre glissante, ainsi qu'une politique de partage équitable entre plusieurs locataires. Exigences fonctionnelles: 1. Fournir une classe ou un module avec une méthode telle que allow(tenant_id, client_id, now_ms) qui retourne si une requête est autorisée et, lorsqu'elle est refusée, combien de millisecondes il reste avant que la prochaine requête soit autorisée (retry_after_ms). 2. Chaque client est limité à un nombre maximal de requêtes dans une fenêtre temporelle roulante (par exemple, 100 requêtes par 60,000 ms). La configuration doit être ajustable par locataire. 3. Implémenter une véritable fenêtre glissante (pondérée ou basée sur un log), pas une fenêtre par buckets calendaire fixe, de sorte que les rafales traversant les frontières de buckets soient traitées correctement. 4. Ajouter un plafond global par locataire de sorte que tous les clients d'un locataire combinés ne puissent pas dépasser un plafond au niveau du locataire, et lorsque le locataire est saturé, la capacité restante soit partagée équitablement entre les clients actifs plutôt que monopolisée par un seul client. 5. Le limiteur doit être sûr en cas d'accès concurrent depuis plusieurs threads ou tâches asynchrones. 6. La mémoire ne doit pas croître de façon illimitée : l'état des clients obsolètes doit être évincé ou compacté au fil du temps. Livrables: - L'implémentation complète avec une API publique claire et une documentation inline des décisions clés. - Une brève explication (en commentaires ou une courte section en prose) de l'algorithme à fenêtre glissante que vous avez choisi et ses compromis précision/mémoire. - Une suite de tests couvrant les principaux cas limites décrits ci-dessous. Cas limites à traiter explicitement dans le code et les tests: - Requêtes exactement à la frontière de la fenêtre. - Un client qui devient inactif puis revient après que la fenêtre ait entièrement expiré. - Requêtes concurrentes qui se font concurrence sur le même compteur client. - Horloge qui recule ou timestamps dupliqués. - Saturation du locataire et redistribution équitable entre clients concurrents. - Éviction de l'état client obsolète sans supprimer les clients actifs. Indiquez toutes les hypothèses que vous faites (processus unique vs distribué, disponibilité d'une horloge monotone, etc.). Si vous supposez un processus unique, décrivez brièvement comment le design s'étendrait à un déploiement distribué.
Programmation
Implémenter un simulateur déterministe de carnet d'ordres limite
Écrivez une solution Python 3.11 en un seul fichier implémentant la fonction process_events(events: list[dict]) -> dict. N'utilisez pas de paquets externes. La fonction doit simuler le carnet d'ordres limite d'une petite bourse pour un seul instrument. Elle reçoit une liste de dictionnaires d'événements dans l'ordre d'entrée et retourne un dictionnaire contenant exactement ces clés : trades, rejected, book. Types d'événements : 1. Événement nouvel ordre : Champs requis : type="new", id, side, order_type, qty. side est "buy" ou "sell". order_type est "limit" ou "market". qty est un entier positif. Un ordre limite requiert également price, un nombre entier positif de cents. Champ optionnel tif est le time-in-force : "GTC", "IOC" ou "FOK". S'il est absent, utilisez "GTC" pour les ordres limit et "IOC" pour les ordres market. Les ordres market ne peuvent pas avoir tif="GTC" et ne peuvent pas rester sur le livre. 2. Événement d'annulation : Champs requis : type="cancel", id. Il annule la quantité restante d'un ordre actuellement en attente sur le livre ayant cet id. Règles d'appariement : - Le livre contient bids et asks. Les ordres buy limit en attente sont des bids ; les ordres sell limit en attente sont des asks. - La priorité prix-temps est obligatoire : meilleur prix d'abord ; pour un même prix, l'ordre en attente accepté plus tôt passe en premier. - Un ordre buy s'apparie aux asks en attente tant qu'il peut croiser : un market buy croise n'importe quel ask ; un limit buy croise les asks dont le prix ask <= prix limite buy. - Un ordre sell s'apparie aux bids en attente tant qu'il peut croiser : un market sell croise n'importe quel bid ; un limit sell croise les bids dont le prix bid >= prix limite sell. - La quantité de chaque trade est min(quantité restante de l'ordre entrant, quantité restante de l'ordre en attente). - Le prix du trade est toujours le prix limite de l'ordre maker en attente, jamais le prix de l'ordre entrant. - Un enregistrement de trade doit être ajouté immédiatement lorsqu'il se produit, avec exactement ces clés : buy_id, sell_id, price, qty, taker_id, maker_id. - Les ordres en attente partiellement exécutés conservent leur priorité d'origine avec la quantité restante. Les ordres entièrement exécutés quittent le livre. Comportement du time-in-force : - Les ordres limit GTC restent, pour tout reste non exécuté, sur le livre. - Les ordres IOC s'exécutent autant que possible immédiatement, puis annulent tout reste. - Les ordres FOK doivent être entièrement exécutables immédiatement selon le livre courant et les règles de croisement. Sinon, ils ne produisent aucun trade et ne changent pas le livre. S'ils sont entièrement exécutables, exécutez-les normalement. Les ordres FOK ne restent jamais sur le livre. Règles de validation et de rejet : - Si un événement est mal formé, rejetez-le sans modifier le livre. Ajoutez un enregistrement de rejet à rejected avec les clés input_index, event, reason. La raison peut être une courte chaîne lisible par un humain. - Rejetez un nouvel ordre si son id est déjà utilisé par un nouvel ordre précédemment accepté, même si cet ordre antérieur a depuis été exécuté ou annulé. - Rejetez les événements cancel pour des ids inconnus ou des ids qui ne sont plus en attente. - Rejetez les qty et price non entiers, nuls ou négatifs. En Python, bool ne doit pas être accepté comme entier pour ces champs. - Ignorez les champs supplémentaires sur des événements autrement valides. Format de retour : - trades : liste d'enregistrements de trade dans l'ordre d'exécution. - rejected : liste d'enregistrements de rejet dans l'ordre d'entrée. - book : un dictionnaire avec les clés bids et asks. - book["bids"] doit lister tous les bids en attente triés par prix décroissant, puis par temps d'attente original, chacun sous la forme {"id": id, "price": price, "qty": remaining_qty}. - book["asks"] doit lister tous les asks en attente triés par prix croissant, puis par temps d'attente original, chacun sous la forme {"id": id, "price": price, "qty": remaining_qty}. Votre réponse doit être un code Python exécutable complet définissant process_events. Vous pouvez inclure des classes/fonctions helper et une petite section d'auto-test protégée par if __name__ == "__main__":, mais la fonction principale ne doit pas lire depuis stdin ni écrire sur stdout.
Programmation
Implémenter l'application atomique d'un JSON Patch en Python
Écrivez une implémentation Python 3.11 d'une fonction nommée apply_json_patch(document, patch) qui applique une séquence d'opérations de type JSON Patch à une valeur compatible JSON et retourne la valeur patchée. Le document d'entrée peut être n'importe quelle combinaison de dict, list, str, int, float, bool et None. Le patch est une liste de dictionnaires d'opérations. L'implémentation ne doit pas muter le document original ni aucun objet imbriqué accessible depuis celui-ci. Si une opération est invalide, la fonction doit lever une exception personnalisée nommée JsonPatchError et laisser le document original inchangé. Les opérations prises en charge sont add, remove, replace, move, copy et test. Utilisez des chemins JSON Pointer avec des jetons séparés par des slash, où la chaîne vide identifie l'ensemble du document, les jetons décodent ~1 en / et ~0 en ~, et toute autre utilisation de ~ est invalide. Pour les objets, un jeton de chemin est une clé. Pour les tableaux, un jeton de chemin doit être un entier non négatif sans zéros en tête sauf le jeton unique 0 ; pour add seulement, le jeton final peut être - pour ajouter à la fin. L'opération add insère dans les tableaux à un index de 0 à len(array), ajoute pour -, définit une clé d'objet, ou remplace l'ensemble du document pour le chemin vide. L'opération remove exige que la cible existe et la supprime. L'opération replace exige que la cible existe et la remplace. L'opération move exige from et path, supprime la valeur à from et l'ajoute à path, et doit rejeter le déplacement d'une valeur vers l'un de ses propres descendants. L'opération copy exige from et path et effectue une copie profonde (deep-copy) de la valeur source vers la cible. L'opération test exige value et ne réussit que si la cible courante est profondément égale (deeply equal) à value, y compris l'égalité Python normale pour les nombres et l'égalité exacte pour les chaînes, les booléens et None. Chaque dictionnaire d'opération doit contenir exactement les champs requis pour cette opération plus le champ op ; les champs inconnus ou manquants sont des erreurs. La fonction doit être déterministe, raisonnablement efficace et ne reposer que sur la bibliothèque standard Python. Incluez toutes les fonctions ou classes auxiliaires nécessaires. N'écrivez pas de programme en ligne de commande et n'utilisez pas de paquets externes.
Programmation
Implémenter un ordonnanceur de tâches basé sur les dépendances en Python
Écrivez une fonction ou une classe Python qui planifie une liste de tâches en fonction de leurs dépendances. L'ordonnanceur doit déterminer l'ordre dans lequel les tâches peuvent être exécutées, en regroupant les tâches qui peuvent s'exécuter en parallèle. L'entrée sera une liste de dictionnaires, où chaque dictionnaire représente une tâche avec les clés suivantes : - `id` : un identifiant unique de type chaîne pour la tâche. - `name` : un nom de la tâche sous forme de chaîne. - `dependencies` : une liste d'identifiants (chaînes) des tâches qui doivent être terminées avant que cette tâche puisse commencer. Votre implémentation doit : 1. Prendre la liste de dictionnaires de tâches en entrée. 2. Retourner un plan d'exécution valide sous forme d'une liste de listes. Chaque liste interne représente un "lot" (batch) de tâches qui peuvent être exécutées simultanément. L'ordre des lots représente l'ordre d'exécution séquentiel. L'ordre des identifiants de tâches au sein d'un lot n'a pas d'importance. 3. Détecter et gérer les dépendances circulaires. Si un cycle est détecté, la fonction doit lever une `ValueError` avec un message descriptif. 4. Détecter et gérer les cas où un identifiant de dépendance ne correspond à aucune tâche existante. Cela doit également lever une `ValueError`.
Programmation
Limiteur de débit avec fenêtre glissante et tolérance de rafale
Concevez et implémentez un limiteur de débit sûr pour les threads dans un langage de votre choix (Python, Go, Java, TypeScript ou Rust) qui prend en charge les exigences suivantes : 1. **Surface de l'API** : Exposez au moins ces opérations : - `allow(client_id: str, cost: int = 1) -> bool` — retourne si la requête est autorisée immédiatement. - `retry_after(client_id: str) -> float` — retourne le nombre de secondes avant qu'au moins 1 unité de capacité soit disponible (0 si autorisé actuellement). - Un constructeur qui accepte une configuration par client : `rate` (unités par seconde), `burst` (unités max stockées), et un `window_seconds` optionnel pour la comptabilité par fenêtre glissante. 2. **Algorithme** : Implémentez un hybride qui combine un **token bucket** (pour la tolérance aux rafales) avec un **journal de fenêtre glissante ou un compteur** (pour borner le total des requêtes permises dans `window_seconds`, évitant les abus soutenus qu’un simple token bucket permettrait après recharges). Une requête n’est autorisée que si les deux contrôles passent. Justifiez votre choix de structure de données pour la fenêtre glissante (journal exact vs approximation à deux seaux pondérés) et discutez des compromis mémoire/précision dans un court bloc de commentaire ou une note jointe. 3. **Concurrence** : Le limiteur sera sollicité par de nombreux threads/goroutines concurrentement pour le même `client_id` et pour des `client_id` différents. Évitez qu’un verrou global unique devienne un goulot d’étranglement (par ex. verrous par client ou lock striping). Documentez pourquoi votre approche est correcte sous des appels `allow` concurrents (pas de double-dépense de jetons, pas de mises à jour perdues). 4. **Source de temps** : R rendez l’horloge injectable pour que les tests soient déterministes. Utilisez par défaut une horloge monotone. 5. **Cas limites à traiter explicitement** : - `cost` plus grand que `burst` (doit être rejeté, ne jamais bloquer indéfiniment). - Horloge reculant ou pauses longues (par ex. VM suspendue) : plafonner plutôt que planter, et ne pas accorder de jetons illimités. - Première requête pour un client nouveau (initialisation paresseuse). - Nettoyage des clients obsolètes (la mémoire ne doit pas croître indéfiniment si des clients arrêtent d’appeler). - Jetons fractionnaires / timing sous-millisecondes. 6. **Tests** : Fournissez au moins 6 tests unitaires utilisant l’horloge injectable qui couvrent : autorisation/refus de base, vidage de rafale et recharge, plafond de la fenêtre glissante indépendant de la recharge du seau, `cost > burst`, contention concurrente sur un seul client (propriété déterministe : total permis en T secondes ≤ rate*T + burst), et éviction des clients obsolètes. 7. **Complexité** : Indiquez la complexité en temps amortie de `allow` et la complexité mémoire par client. Livrables : code exécutable complet (un seul fichier convient, mais vous pouvez scinder si vous les étiquetez clairement), les tests, et une brève note de conception (max ~250 mots) expliquant vos choix et la sémantique précise lorsque les deux algorithmes sont en désaccord.
Programmation
Convertisseur d'un sous-ensemble Markdown vers HTML
Écrivez une fonction Python `markdown_to_html(markdown_text: str) -> str` qui convertit une chaîne contenant un sous-ensemble spécifique de Markdown en sa représentation HTML correspondante. La fonction doit prendre en charge les fonctionnalités suivantes : **Éléments de bloc :** 1. **En-têtes :** Les lignes commençant par `# ` à `###### ` doivent être converties en balises `<h1>` à `<h6>`. 2. **Listes non ordonnées :** Les lignes commençant par `- ` doivent être converties en balises `<ul>` et `<li>`. Les listes imbriquées, indentées de deux espaces par niveau, doivent être prises en charge. Une liste se termine par une ligne vide ou un autre élément de bloc. 3. **Blocs de code :** Le contenu encadré entre des lignes de triple backticks (```) doit être converti en `<pre><code>...</code></pre>`. Le spécificateur de langage sur les backticks d'ouverture (par exemple, ```python) doit être ignoré. Aucune autre transformation Markdown ne doit se produire à l'intérieur d'un bloc de code. 4. **Paragraphes :** Tout autre texte doit être enveloppé dans des balises `<p>`. Les lignes consécutives de texte appartiennent au même paragraphe. Les paragraphes sont séparés par une ou plusieurs lignes vides. **Éléments en ligne :** 1. **Gras et italique :** `***text***` doit être converti en `<strong><em>text</em></strong>`. 2. **Gras :** `**text**` doit être converti en `<strong>text</strong>`. 3. **Italique :** `*text*` doit être converti en `<em>text</em>`. **Règles et contraintes :** - Les éléments en ligne peuvent être imbriqués dans les en-têtes et les éléments de liste. - Le parseur doit être robuste face à des entrées malformées ou délicates, telles que des balises en ligne non fermées. Par exemple, `*italic` doit être rendu comme `<p>*italic</p>`. - L'ordre de priorité pour les éléments en ligne est `***`, puis `**`, puis `*`. - Supposerez que l'entrée est une unique chaîne multilignes. - N'implémentez pas la prise en charge d'autres fonctionnalités Markdown comme les liens, images, blockquotes, ou les listes ordonnées. - Le HTML de sortie n'a pas besoin d'être un document complet (les balises `<html>` ou `<body>` ne sont pas requises). **Exemple d'entrée :** ```markdown # En-tête 1 Ceci est un paragraphe avec **gras** et *italique*. Ceci est le même paragraphe. - Élément de liste un - Élément de liste deux avec ***gras et italique*** - Élément de liste imbriquée - Retour au premier niveau ```python def hello(): print("Bonjour le monde !") ``` ```