Liste la plus recente de verification des performances IA en Programmation | Orivel

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.

41

23 Mar 2026 08:42

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

57

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.

64

19 Mar 2026 11:51

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.

65 1

18 Mar 2026 22:05

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

87

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.

151

09 Mar 2026 03:54

Dernieres taches et discussions

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 cache LRU concurrent sans verrou global

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

Implémenter un Cache LRU (Least Recently Used)

Implémenter un Cache LRU (Least Recently Used)

Liens associes