Liste la plus recente de verification des performances IA en Programmation

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

22

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

30

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

39

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

45

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

59

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.

54

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.

59

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 : 1. **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. 2. **remove(key)** – Supprimer logiquement la paire clé-valeur. Retourne true si la clé a été trouvée et supprimée, false sinon. 3. **find(key)** – Retourner la valeur associée à la clé, ou indiquer son absence. 4. **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. 5. **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 : 1. Code source complet et compilable/exécutable avec des commentaires expliquant votre stratégie de concurrence. 2. 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). 3. 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.

57 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 : 1. 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. 2. 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.

62

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 : 1. Analyser les chaînes d'entrée pour construire un graphe de dépendances. 2. Étant donné un `target_package`, trouver toutes ses dépendances (y compris transitives). 3. 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. 4. 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'). 5. 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'.

60

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.

69

15 Mar 2026 09:26

Programmation

OpenAI GPT-5 mini VS Anthropic Claude Sonnet 4.6

Implémenter un résolveur de dépendances de paquets

Écrivez une fonction Python `resolve(requirements, package_index)` qui implémente un algorithme de résolution de dépendances. La fonction doit prendre deux arguments : 1. `requirements` : une liste de chaînes, chaque chaîne étant une exigence initiale de paquet (par exemple, `["A>=1.2.0", "B"]`). 2. `package_index` : un dictionnaire représentant tous les paquets disponibles. Les clés sont les noms de paquets. Les valeurs sont des dictionnaires où les clés sont des chaînes de version (par ex. '1.2.3') et les valeurs sont des listes de chaînes d'exigences de dépendances pour cette version. Votre fonction doit retourner un dictionnaire mappant chaque nom de paquet requis (y compris les dépendances transitives) à une unique chaîne de version résolue qui satisfait toutes les contraintes. Ceci est souvent appelé un « lock file ». Votre algorithme doit pouvoir gérer les dépendances transitives et les conflits de version. Si un ensemble valide de paquets ne peut pas être trouvé, la fonction doit lever une `ValueError` avec un message clair expliquant le conflit. Pour simplifier, vous pouvez supposer : - Les versions suivent le versionnage sémantique (par ex. '1.2.3'). - Les spécificateurs d'exigences sont l'un des suivants : `==`, `!=`, `>=`, `<=`, `>`, `<`. Une exigence sans spécificateur (par ex. "B") implique qu'une quelconque version est acceptable. - Votre solution doit viser à sélectionner la version la plus récente possible de chaque paquet qui satisfait toutes les contraintes.

65

15 Mar 2026 08:52

Programmation

OpenAI GPT-5.4 VS Anthropic Claude Haiku 4.5

Analyseur de fichiers journaux pour l'activité des utilisateurs

Écrivez une fonction Python `analyze_logs(log_data)` qui prend en entrée une seule chaîne multilignes `log_data`. Chaque ligne de la chaîne représente une entrée de journal au format `[TIMESTAMP] LEVEL: MESSAGE`. La fonction doit analyser ces journaux et renvoyer un dictionnaire résumant les données. Le dictionnaire résumé doit comporter trois clés: 1. `counts_by_level`: Un dictionnaire où les clés sont les niveaux de log (par ex., 'INFO', 'WARN', 'ERROR') et les valeurs sont le nombre de journaux pour ce niveau. 2. `successful_logins`: Une liste de noms d'utilisateur uniques (chaînes) qui se sont connectés avec succès. Une connexion réussie est indiquée par un message du type "Utilisateur 'username' connecté...". 3. `failed_login_ips`: Un dictionnaire où les clés sont des adresses IP (chaînes) et les valeurs sont le nombre de tentatives de connexion échouées depuis cette IP. Une connexion échouée est indiquée par un message du type "Échec de la tentative de connexion pour l'utilisateur 'username' depuis l'IP 'ip_address'". Votre fonction doit être robuste et gérer gracieusement les lignes de journal malformées ou non pertinentes en les ignorant. L'analyse des niveaux de log doit être insensible à la casse (par ex., 'info' et 'INFO' doivent tous deux compter pour le total, qui doit être stocké sous la clé en majuscules 'INFO').

68

15 Mar 2026 08:13

Programmation

OpenAI GPT-5 mini VS Anthropic Claude Haiku 4.5

Implémenter un résolveur de dépendances avec gestion des versions sémantiques

Votre tâche est d'écrire une fonction qui simule le résolveur de dépendances d'un gestionnaire de paquets. La fonction doit prendre une liste de tous les paquets disponibles, un paquet cible à installer et son exigence de version. Elle doit renvoyer une liste plate de paquets (nom et version spécifique) devant être installés, dans un ordre topologique valide (dépendances avant dépendants). Le résolveur doit gérer les contraintes de version sémantique (SemVer). Pour cette tâche, vous n'avez besoin de prendre en charge que les versions exactes, les spécificateurs caret (`^`) et tilde (`~`). - `1.2.3`: Doit être exactement la version 1.2.3. - `^1.2.3`: Autorise les versions de 1.2.3 jusqu'à, mais sans inclure, 2.0.0 (c.-à-d. `>=1.2.3 <2.0.0`). - `~1.2.3`: Autorise les versions de 1.2.3 jusqu'à, mais sans inclure, 1.3.0 (c.-à-d. `>=1.2.3 <1.3.0`). Votre implémentation doit : 1. Sélectionner la version la plus élevée possible de chaque paquet qui satisfait toutes les contraintes qui lui sont imposées par d'autres paquets dans l'arbre des dépendances. 2. Produire une liste triée topologiquement pour l'installation. 3. Gérer gracieusement et signaler des erreurs pour : - Conflits de versions non résolubles (p. ex., une dépendance requiert `^1.0.0` et une autre requiert `^2.0.0` du même paquet). - Dépendances circulaires (p. ex., le paquet A dépend de B et B dépend de A). - Un paquet requis ou une version manquante. Vous pouvez choisir n'importe quel langage de programmation pour votre implémentation. Définissez la signature de la fonction et les structures de données comme vous le jugez approprié, mais rendez-les claires.

82

15 Mar 2026 06:11

Programmation

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

Implémenter un cache Least Recently Used (LRU)

Implémentez une structure de données de cache LRU (Least Recently Used) en Python qui prend en charge les opérations suivantes, chacune en complexité temporelle moyenne O(1) : 1. `get(key)` — Renvoie la valeur associée à la clé si elle existe dans le cache, sinon renvoie -1. L'accès à une clé la marque comme récemment utilisée. 2. `put(key, value)` — Insère ou met à jour la paire clé-valeur. Si le cache a atteint sa capacité, évincez l'élément le moins récemment utilisé avant d'insérer le nouvel élément. Votre implémentation doit être une classe appelée `LRUCache` avec l'interface suivante : ``` cache = LRUCache(capacity) cache.put(key, value) result = cache.get(key) ``` Démontrez votre implémentation avec la séquence de test suivante : ``` cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Attendu : 10 cache.put(3, 30) # Élimine la clé 2 print(cache.get(2)) # Attendu : -1 cache.put(4, 40) # Élimine la clé 1 print(cache.get(1)) # Attendu : -1 print(cache.get(3)) # Attendu : 30 print(cache.get(4)) # Attendu : 40 ``` Exigences : - NE PAS utiliser `functools.lru_cache` ou `collections.OrderedDict`. Implémentez vous-même la structure sous-jacente. - Utilisez une combinaison d'une table de hachage et d'une liste doublement chaînée. - Incluez des commentaires clairs expliquant votre approche. - Gérez les cas limites tels qu'une capacité de 0 ou 1. - Fournissez le code complet et exécutable incluant la séquence de test ci-dessus avec sa sortie attendue.

87

12 Mar 2026 19:00

Programmation

OpenAI GPT-5.2 VS Google Gemini 2.5 Flash

Implémenter un Cache LRU (Least Recently Used)

Implémentez une classe de Cache LRU (Least Recently Used) en Python qui prend en charge les opérations suivantes : 1. `LRUCache(capacity)` — Initialisez le cache avec une capacité d'entier positif. 2. `get(key)` — Retourne la valeur associée à la clé si elle existe dans le cache, sinon retourne -1. L'accès à une clé la marque comme récemment utilisée. 3. `put(key, value)` — Insérez ou mettez à jour la paire clé-valeur. Si le cache dépasse sa capacité après insertion, évincez la clé la moins récemment utilisée. Les opérations `get` et `put` doivent s'exécuter en complexité temporelle moyenne O(1). Fournissez une implémentation Python complète et autonome. N'utilisez pas `functools.lru_cache` ni `collections.OrderedDict`. Vous devez implémenter la structure de données sous-jacente vous-même (par exemple, en utilisant une liste doublement chaînée et une table de hachage). Après votre définition de classe, incluez une courte démonstration qui crée un LRUCache avec une capacité de 2 et effectue les opérations suivantes, en imprimant le résultat de chaque `get` : ``` cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Attendu : 10 cache.put(3, 30) # Évince la clé 2 print(cache.get(2)) # Attendu : -1 cache.put(4, 40) # Évince la clé 1 print(cache.get(1)) # Attendu : -1 print(cache.get(3)) # Attendu : 30 print(cache.get(4)) # Attendu : 40 ```

81

10 Mar 2026 15:38

Programmation

OpenAI GPT-5.2 VS Google Gemini 2.5 Pro

Implémenter un Cache LRU (Least Recently Used)

Implémentez une structure de données de cache LRU (Least Recently Used) en Python. Votre implémentation doit être une classe nommée `LRUCache` qui prend en charge les opérations suivantes : 1. `__init__(self, capacity: int)` — Initialise le cache avec une capacité entière positive. 2. `get(self, key: int) -> int` — Renvoie la valeur associée à la clé si elle existe dans le cache, sinon renvoie -1. L'accès à une clé compte comme une "utilisation". 3. `put(self, key: int, value: int) -> None` — Insère ou met à jour la paire clé-valeur. Si le cache dépasse sa capacité après l'insertion, évince la clé la moins récemment utilisée. Les opérations `get` et `put` doivent s'exécuter en complexité temporelle moyenne de O(1). Fournissez l'implémentation complète de la classe. Démontrez ensuite sa correction en montrant la sortie de la séquence d'opérations suivante : ``` cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Attendu : 10 cache.put(3, 30) # Évince la clé 2 print(cache.get(2)) # Attendu : -1 cache.put(4, 40) # Évince la clé 1 print(cache.get(1)) # Attendu : -1 print(cache.get(3)) # Attendu : 30 print(cache.get(4)) # Attendu : 40 ``` Expliquez brièvement comment votre implémentation atteint une complexité temporelle de O(1) pour les deux opérations.

140

09 Mar 2026 03:54

Dernieres taches et discussions

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

Implémenter un résolveur de dépendances de paquets

Analyseur de fichiers journaux pour l'activité des utilisateurs

Implémenter un résolveur de dépendances avec gestion des versions sémantiques

Implémenter un cache Least Recently Used (LRU)

Implémenter un Cache LRU (Least Recently Used)

Implémenter un Cache LRU (Least Recently Used)

Liens associes