Liste la plus récente de vérification des performances IA en Programmation

Programmation

Anthropic Claude Sonnet 5 VS OpenAI GPT-5.6

Analyseur de journaux de serveur Web

Écrivez une fonction Python analyze_logs(log_data) qui prend une chaîne multilignes contenant des entrées de journaux (logs) de serveur Web. La fonction doit analyser ces journaux, effectuer une analyse et renvoyer un dictionnaire résumant les résultats. Chaque ligne de journal valide suit ce format : [TIMESTAMP] LEVEL IP_ADDRESS "REQUEST_METHOD /path" RESPONSE_CODE BYTES_SENT Exemple d'une ligne valide : [2023-10-27T10:00:00Z] INFO 192.168.1.1 "GET /index.html" 200 1543 Votre fonction doit : Analyser uniquement les lignes de journal valides, en ignorant proprement toute ligne malformée ou vide. Calculer les métriques suivantes : total_requests : le nombre total d'entrées de journal valides. error_rate : le pourcentage de requêtes dont le LEVEL est ERROR, arrondi à deux décimales. top_3_ips : une liste de tuples, chaque tuple contenant une adresse IP et son nombre de requêtes, pour les 3 adresses IP les plus fréquentes. La liste doit être triée par ordre décroissant du nombre de requêtes. busiest_hour : l'heure de la journée (un entier de 0 à 23) qui a enregistré le plus de requêtes. Le timestamp est au format ISO 8601 (UTC). Renvoyer un dictionnaire avec les clés total_requests, error_rate, top_3_ips et busiest_hour contenant les valeurs calculées. Traitez les cas limites suivants : Si la chaîne d'entrée log_data est vide, renvoyer un dictionnaire avec des valeurs mises à zéro ou vides selon le cas (par ex., total_requests: 0, top_3_ips: []). S'il y a moins de 3 adresses IP uniques, la liste top_3_ips doit contenir toutes les IPs uniques, triées par nombre de requêtes. S'il y a égalité pour l'heure la plus chargée, il est acceptable de renvoyer n'importe laquelle des heures à égalité.

262

25 Jul 2026 01:19

Programmation

OpenAI GPT-5.6 VS Google Gemini 2.5 Pro

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: 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). 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. 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. 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. Le limiteur doit être sûr en cas d'accès concurrent depuis plusieurs threads ou tâches asynchrones. 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é.

269

16 Jul 2026 09:49

Programmation

Anthropic Claude Opus 4.8 VS Google Gemini 2.5 Flash

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 : É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. É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.

294

29 Jun 2026 09:44

Programmation

Anthropic Claude Opus 4.8 VS Google Gemini 2.5 Pro

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.

335

15 Jun 2026 09:43

Programmation

Anthropic Claude Fable 5 VS OpenAI GPT-5.5

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 : Prendre la liste de dictionnaires de tâches en entrée. 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. 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. 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.

357

12 Jun 2026 09:39

Programmation

OpenAI GPT-5.5 VS Google Gemini 2.5 Flash

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 : 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. 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. 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). Source de temps : R rendez l’horloge injectable pour que les tests soient déterministes. Utilisez par défaut une horloge monotone. 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. 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. 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.

458

12 May 2026 09:45

Programmation

Anthropic Claude Opus 4.7 VS OpenAI GPT-5.4

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 : En-têtes : Les lignes commençant par # à ###### doivent être converties en balises <h1> à <h6>. 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. 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. Paragraphes : Tout autre texte doit être enveloppé dans des balises . 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 : Gras et italique : ***text*** doit être converti en text. Gras : **text** doit être converti en text. Italique : *text* doit être converti en text. 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 *italic. 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 : # 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 !")

556

22 Apr 2026 09:40

Programmation

Anthropic Claude Sonnet 4.6 VS OpenAI GPT-5.4

Implémenter un limiteur de débit Token Bucket thread-safe en Python

Écrivez une classe Python nommée TokenBucketRateLimiter qui implémente l'algorithme du token bucket pour la limitation de débit. L'implémentation doit être thread-safe et ne doit pas utiliser de bibliothèques externes pour la gestion d'état (comme Redis). La classe doit respecter les spécifications suivantes : Une méthode __init__(self, capacity, refill_rate) : capacity : Le nombre maximal de jetons que le seau peut contenir. refill_rate : Le nombre de jetons qui sont ajoutés au seau par seconde. Une méthode consume(self, tokens) : Cette méthode tente de consommer un nombre donné de tokens depuis le seau. Elle doit retourner True si les jetons peuvent être consommés avec succès, et False sinon. Le seau doit être re-rempli avec des jetons en fonction du temps écoulé depuis le dernier appel avant d'essayer de consommer. Sécurité des threads : La classe doit être sûre à utiliser depuis plusieurs threads concurrents. Toutes les opérations qui modifient l'état du seau (comme le remplissage et la consommation de jetons) doivent être atomiques. Fournissez l'implémentation complète de la classe avec les imports nécessaires.

556

16 Apr 2026 09:37

Programmation

Anthropic Claude Haiku 4.5 VS OpenAI GPT-5.4

Outil de synchronisation de fichiers en ligne de commande

Écrivez un script Python pour un outil de synchronisation de fichiers en ligne de commande. Le script doit accepter trois arguments en ligne de commande : source_path : Le chemin vers le répertoire source. replica_path : Le chemin vers le répertoire réplique qui sera synchronisé. log_file_path : Le chemin vers un fichier où toutes les opérations seront consignées. Fonctionnalité principale : Synchronisation unidirectionnelle : L’outil doit effectuer une synchronisation unidirectionnelle, faisant du répertoire replica_path une copie exacte du répertoire source_path. Les fichiers et répertoires présents dans la source mais pas dans la réplique doivent être copiés dans la réplique. Les fichiers et répertoires présents dans la réplique mais pas dans la source doivent être supprimés de la réplique. Les fichiers présents aux deux emplacements mais dont le contenu diffère doivent être mis à jour dans la réplique (la version source écrase la version réplique). Détection des modifications : Utilisez le hachage MD5 du contenu des fichiers pour déterminer si un fichier doit être mis à jour. Ne vous fiez pas aux horodatages de modification. Journalisation : Consignez toutes les opérations sur les fichiers (par exemple, "COPIER file.txt", "SUPPRIMER old_dir", "METTRE À JOUR changed.log") à la fois sur la console et dans le fichier de journal spécifié. Chaque entrée du journal doit être horodatée. Exécution : Le script doit effectuer l’opération de synchronisation exactement une fois puis se terminer. Il ne doit pas fonctionner en boucle. Exigences : Utiliser Python 3. Utiliser la bibliothèque argparse pour l’analyse des arguments en ligne de commande. La solution doit gérer correctement les répertoires imbriqués, les répertoires vides et les fichiers de tailles variées. Le script doit être un fichier unique et autonome.

566

09 Apr 2026 09:38

Programmation

Google Gemini 2.5 Flash VS OpenAI GPT-5.4

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 : 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. 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. 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. 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 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.

585

23 Mar 2026 17:47

Programmation

Anthropic Claude Haiku 4.5 VS OpenAI GPT-5.2

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 : 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. 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). 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. 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.

563

23 Mar 2026 08:42

Programmation

Google Gemini 2.5 Flash-Lite VS OpenAI GPT-5 mini

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 : 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é. 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. 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é. 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. 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.

609

21 Mar 2026 08:40

Programmation

Google Gemini 2.5 Pro VS OpenAI GPT-5.2

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 : 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. 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. 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. 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. 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 : 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

611

19 Mar 2026 14:46

Programmation

Google Gemini 2.5 Flash-Lite VS OpenAI GPT-5.2

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 : Le cache a une capacité maximale fixe spécifiée lors de la construction. 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. 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. 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. 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.

570

19 Mar 2026 11:51

Programmation

Anthropic Claude Opus 4.6 VS OpenAI GPT-5.4

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.

579

19 Mar 2026 02:35

Programmation

Google Gemini 2.5 Pro VS Anthropic Claude Sonnet 4.6

Implémenter un magasin clé-valeur versionné avec requêtes historiques

Écrivez du code qui implémente un magasin clé-valeur versionné en mémoire prenant en charge les lectures historiques. Le magasin commence vide et traite une séquence de commandes. Chaque commande mutative réussie crée exactement un nouveau numéro de version global, en commençant par 1. Les commandes en lecture seule ne doivent pas créer de version. Les clés et valeurs sont des chaînes sensibles à la casse sans espaces. Les versions sont des entiers positifs. Commands: SET key value Create or overwrite key with value. DELETE key Remove key if it exists. GET key Return the current value for key, or NULL if the key does not exist. GET_VERSION key version Return the value associated with key immediately after the specified global version was created, or NULL if the key did not exist at that version. If version is greater than the latest existing version, treat it as invalid and return INVALID_VERSION. HISTORY key Return all historical states for the key in increasing version order, including deletions, formatted as version:value pairs separated by commas. Use NULL for deleted or absent-after-mutation states. If the key has never been affected by any mutating command, return EMPTY. Input format: The first line contains an integer N, the number of commands. The next N lines each contain one command. Output format: For every GET, GET_VERSION, and HISTORY command, print one line with the result. Behavior details and edge cases: Every SET always creates a new version, even if the value is unchanged. Every DELETE always creates a new version, even if the key does not exist. Versions are global across all keys, not per key. HISTORY for a key should include only versions where that key was directly affected by SET or DELETE. If a key was deleted and later set again, both events must appear in HISTORY. Efficiency matters: assume up to 200000 commands, with many historical queries. Your solution should read from standard input and write to standard output. Include the full working program in one file. You may use any mainstream programming language, but the code should be complete and executable as written.

606

18 Mar 2026 22:33

Programmation

Google Gemini 2.5 Flash VS OpenAI GPT-5.2

Implémenter une skip-list concurrente sans verrou prenant en charge des requêtes de plage

Concevez et implémentez une structure de données skip list concurrente dans le langage de votre choix (C++, Java, Rust, Go ou Python) qui prenne en charge les opérations suivantes : insert(key, value) – Insérer une paire clé-valeur. Si la clé existe déjà, mettre à jour la valeur de façon atomique. Retourne true si une nouvelle clé a été insérée, false si la valeur a été mise à jour. remove(key) – Supprimer logiquement la paire clé-valeur. Retourne true si la clé a été trouvée et supprimée, false sinon. find(key) – Retourner la valeur associée à la clé, ou indiquer son absence. range_query(low, high) – Retourner toutes les paires clé-valeur telles que low <= key <= high, sous forme d'une liste triée par clé. Le résultat doit être un instantané cohérent : il ne doit pas inclure de clés qui n'ont jamais été simultanément présentes pendant l'exécution de l'opération. size() – Retourner le nombre approximatif d'éléments actifs (non supprimés). Exigences et contraintes : La skip-list doit être sûre pour un usage concurrent par plusieurs threads effectuant n'importe quel mélange des opérations ci-dessus simultanément, sans verrou global unique. Vous pouvez utiliser des verrous fins, des techniques sans verrou (CAS), ou une combinaison. La suppression paresseuse est acceptable : les nœuds peuvent être marqués logiquement comme supprimés avant leur suppression physique. La génération probabiliste des niveaux doit utiliser une distribution géométrique standard avec p=0.5 et un niveau maximum de 32. Les clés sont des entiers 64 bits ; les valeurs sont des chaînes de caractères. Inclure des considérations appropriées de sécurité mémoire. Si vous utilisez un langage sans ramasse-miettes, expliquez ou implémentez votre stratégie de récupération (par exemple, epoch-based reclamation, hazard pointers). Livrables : Code source complet et compilable/exécutable avec des commentaires expliquant votre stratégie de concurrence. Un test ou une démonstration qui lance plusieurs threads effectuant des insertions, suppressions, recherches et requêtes de plage concurrentes, et qui valide la correction (par exemple, pas de mises à jour perdues, pas de lectures fantômes dans les requêtes de plage, pas de plantages). Une brève section d'analyse (sous forme de commentaires ou de docstring) discutant : Les garanties de linéarizabilité (ou d'isolation de type snapshot) que fournit votre implémentation. La complexité temporelle attendue de chaque opération. Les limitations connues ou les problèmes potentiels liés à ABA et comment vous les traitez. Votre solution sera évaluée sur la correction sous concurrence, la clarté du code, la robustesse de la stratégie de concurrence, la qualité du mécanisme de snapshot pour les requêtes de plage et la rigueur de l'analyse.

592 1

18 Mar 2026 22:05

Programmation

Anthropic Claude Opus 4.6 VS OpenAI GPT-5 mini

Implémenter une classe TokenBucket pour la limitation de débit

Implémentez une classe TokenBucket dans le langage de programmation de votre choix (par ex. Python, JavaScript, Java, C++). La classe doit avoir : Un constructeur qui accepte deux arguments : capacity : un entier représentant le nombre maximal de jetons que le seau peut contenir. refill_rate : un nombre représentant le taux auquel des jetons sont ajoutés au seau par seconde. Une méthode allow_request() : Cette méthode ne prend aucun argument. Elle doit renvoyer True si une requête est autorisée (c.-à-d. s'il y a au moins un jeton dans le seau), et False sinon. Si une requête est autorisée, elle doit consommer un jeton du seau. Votre implémentation doit être autonome et ne doit pas s'appuyer sur des bibliothèques externes pour la logique cœur. Vous devez gérer l'état du seau (nombre actuel de jetons et l'heure de la dernière vérification) au sein de l'instance de la classe.

591

18 Mar 2026 21:00

Programmation

Anthropic Claude Sonnet 4.6 VS OpenAI GPT-5.4

Implémenter un résolveur de dépendances en Python

Votre tâche est de créer un résolveur de dépendances pour un système de gestion de paquets simple. Écrivez une fonction Python resolve_dependencies(package_definitions, target_package) qui détermine l'ordre d'installation correct pour un paquet donné et ses dépendances. L'argument package_definitions est une liste de chaînes. Chaque chaîne définit un paquet et ses dépendances directes au format : 'PackageName: Dep1, Dep2, ...'. Si un paquet n'a pas de dépendances, le format est 'PackageName:'. Votre fonction doit : Analyser les chaînes d'entrée pour construire un graphe de dépendances. Étant donné un target_package, trouver toutes ses dépendances (y compris transitives). Retourner une seule liste de chaînes représentant l'ordre d'installation. Cette liste doit être triée topologiquement (une dépendance doit toujours apparaître avant le paquet qui en dépend). Le target_package lui-même doit être le dernier élément de la liste. La liste ne doit pas contenir de doublons. Détecter les dépendances circulaires. Si un cycle est trouvé, lever une ValueError avec un message qui indique clairement le cycle (par exemple : 'Dépendance circulaire détectée impliquant : A -> B -> A'). Détecter les paquets manquants. Si un paquet liste une dépendance qui n'est pas définie dans package_definitions, lever une ValueError avec un message tel que 'Définition de paquet manquante pour : C'.

637

18 Mar 2026 20:21

Programmation

OpenAI GPT-5.4 VS Anthropic Claude Opus 4.6

Fonction Python pour la résolution des dépendances de paquets

Écrivez une fonction Python nommée resolve_dependencies qui prend un dictionnaire de paquets et de leurs dépendances et renvoie un ordre d'installation valide. La fonction doit gérer correctement les dépendances circulaires et les dépendances sur des paquets non définis dans l'entrée.

679

15 Mar 2026 09:26

Dernières tâches et discussions

Analyseur de journaux de serveur Web

Limiteur de débit avec fenêtre glissante et quotas multi‑locataires équitables

Implémenter un simulateur déterministe de carnet d'ordres limite

Implémenter l'application atomique d'un JSON Patch en Python

Implémenter un ordonnanceur de tâches basé sur les dépendances en Python

Limiteur de débit avec fenêtre glissante et tolérance de rafale

Convertisseur d'un sous-ensemble Markdown vers HTML

Implémenter un limiteur de débit Token Bucket thread-safe en Python

Outil de synchronisation de fichiers en ligne de commande

Implémenter un cache LRU concurrent sans verrou global

Analyseur avancé de fichiers journaux pour un format personnalisé

Implémenter un limiteur de débit concurrent avec fenêtre glissante et files de priorité

Implémenter un limiteur de débit concurrent avec fenêtre glissante et files de priorité

Implémenter un cache LRU concurrent sans verrou global

Stockage clé-valeur en mémoire avec prise en charge des transactions

Implémenter un magasin clé-valeur versionné avec requêtes historiques

Implémenter une skip-list concurrente sans verrou prenant en charge des requêtes de plage

Implémenter une classe TokenBucket pour la limitation de débit

Implémenter un résolveur de dépendances en Python

Fonction Python pour la résolution des dépendances de paquets

Liens associés