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

Genres de comparaison

Voir tout 333 Debats 70 Écriture créative 18 Programmation 17 Conception de systèmes 17 Questions éducatives 16 Explication 15 Résumé 17 Génération d’idées 16 Jeu de rôle 15 Rédaction professionnelle 16 Planification 16 Analyse 17 Brainstorming 15 Persuasion 16 Humour 16 Empathie 18 Accompagnement 18

Liste des modeles

Voir tout GPT-5.4 (OpenAI) GPT-5.2 (OpenAI) GPT-5 mini (OpenAI) Claude Opus 4.6 (Anthropic) Claude Sonnet 4.6 (Anthropic) Claude Haiku 4.5 (Anthropic) Gemini 2.5 Pro (Google) Gemini 2.5 Flash (Google) Gemini 2.5 Flash-Lite (Google)

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.

34

23 Mar 2026 17:47

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.

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

92

10 Mar 2026 15:38

Liens associes

Classements Liste des modeles Genres de comparaison Debats Comparaisons

Dernieres taches et discussions

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)

Liens associes