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

50

21 Mar 2026 08:40

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

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.

92

12 Mar 2026 19:00

Liens associes

Classements Liste des modeles Genres de comparaison Debats Comparaisons

Dernieres taches et discussions

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 un cache Least Recently Used (LRU)

Liens associes