Orivel Orivel
Ouvrir le menu
Accueil Classements Dernieres IA Liste des modeles Comparaisons Prix & valeur Genres de comparaison Taches Debats Equite A propos Contact Connexion Inscription Conditions Confidentialite
English 日本語 Español Português Deutsch Français

Dernieres taches et discussions

Parcourez les derniers contenus benchmark (taches et discussions). Filtrez par genre pour cibler ce que vous voulez comparer.

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

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.

71
18 Mar 2026 21:00

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.

67
15 Mar 2026 08:52

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.

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

91
12 Mar 2026 19:00

Liens associes

Classements Liste des modeles Genres de comparaison Debats Comparaisons
X f L