id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
ca1382708650d64c77622c7ed2d6c59f | [
{
"content": "On te donne une tâche de configuration d'un pipeline de traitement de données où tu dois analyser les arguments de ligne de commande en deux dictionnaires distincts : un pour les paramètres de prétraitement et un autre pour les paramètres de l'algorithme. Chaque argument est fourni sous forme de l... | ["\nassert parse_arguments([\"prep_input\", \"True\", \"algo_threshold\", \"0.5\"]) == ({\"prep_input\": True}, {\"algo_threshold\": 0.5})\n", "\nassert parse_arguments([\"prep_output\", \"False\", \"algo_iterations\", \"100\"]) == ({\"prep_output\": False}, {\"algo_iterations\": 100.0})\n", "\nassert parse_arguments([... |
23199654fe7e55de79777e0bbae1533f | [
{
"content": "On te demande de développer un modèle d'apprentissage automatique pour prédire l'espèce d'un animal en fonction de ses caractéristiques. L'ensemble de données comprend divers attributs tels que l'espèce, le poids, la taille et d'autres caractéristiques. Ton programme doit gérer les valeurs manquan... | ["\nassert train_model(RandomForestClassifier(random_state=42), np.array([[1, 2], [3, 4]]), np.array([0, 1]))[1] == \"Random Forest\"\n", "\nassert train_model(AdaBoostClassifier(random_state=42), np.array([[1, 2], [3, 4]]), np.array([0, 1]))[1] == \"AdaBoost\"\n", "\nassert isinstance(train_model(RandomForestClassifie... |
4e0bf03c2a2244ffb9da513bda6b2ac1 | [
{
"content": "On te donne deux listes, `values` et `weights`, chacune contenant `n` entiers. Ta tâche est de mettre en œuvre une fonction `weighted_mean` qui calcule la moyenne arithmétique pondérée de la liste `values`, où chaque valeur est multipliée par son poids correspondant de la liste `weights`. La fonct... | ["\nassert weighted_mean([1, 2, 3], [1, 1, 1]) == 2.0\n", "\nassert weighted_mean([10, 20, 30], [1, 2, 3]) == 23.333333333333332\n", "\nassert weighted_mean([1, 1, 1, 1], [1, 1, 1, 1]) == 1.0\n", "\nassert weighted_mean([100, 200, 300], [1, 2, 3]) == 233.33333333333334\n", "\nassert weighted_mean([1, 2, 3, 4, 5], [5, 4... |
ed10165c91bd818275c9ed649034da56 | [
{
"content": "On te donne une liste de `2n` entiers représentant les dimensions d'un hyperrectangle à `n` dimensions. La liste est structurée de telle sorte que les deux premiers entiers représentent le début et la fin de la première dimension, les deux suivants représentent le début et la fin de la deuxième di... | ["\nassert adjust_dimensions([10, 20, 50, 60], 10) == [9.0, 18.0, 51.0, 62.0]\n", "\nassert adjust_dimensions([0, 0, 100, 100], 5) == [-2.5, -2.5, 102.5, 102.5]\n", "\nassert adjust_dimensions([1, 1, 2, 2], 50) == [0.25, 0.25, 1.75, 1.75]\n", "\nassert adjust_dimensions([10, 20, 30, 40, 50, 60], 20) == [8.0, 16.0, 32.0... |
0dba72380c8a9631e19bcdc37f0f2ee3 | [
{
"content": "On te demande d'implémenter une fonction pour valider un numéro de carte de crédit en utilisant l'algorithme de Luhn. Ta fonction doit accepter une chaîne de caractères représentant le numéro de carte de crédit et renvoyer `True` si le numéro est valide selon l'algorithme de Luhn, et `False` sinon... | ["\nassert validate_credit_card(\"4532015112830366\") == True\n", "\nassert validate_credit_card(\"1234567812345670\") == False\n", "\nassert validate_credit_card(\"6771744244471143\") == True\n", "\nassert validate_credit_card(\"49927398716\") == True\n", "\nassert validate_credit_card(\"49927398717\") == False\n", "\... |
7515253cd144c72dee8298a625da4b7e | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ton objectif est de déterminer la plus longue sous-chaîne palindromique dans `s`. Une sous-chaîne palindromique se lit de la même manière de gauche à droite et de droite à gauche. Écris une fonction `lon... | ["\nassert longest_palindrome(\"babad\") == \"bab\" or longest_palindrome(\"babad\") == \"aba\"\n", "\nassert longest_palindrome(\"cbbd\") == \"bb\"\n", "\nassert longest_palindrome(\"a\") == \"a\"\n", "\nassert longest_palindrome(\"ac\") == \"a\" or longest_palindrome(\"ac\") == \"c\"\n", "\nassert longest_palindrome(... |
826b53d9d4eba4810bfd85c537834495 | [
{
"content": "On te demande d'implémenter une fonction qui calcule la température potentielle équivalente (θe) d'une parcelle d'air. La fonction doit prendre trois paramètres : la température (T) en Kelvin, la pression (P) en hPa et la température au point de rosée (Td) en Kelvin. La fonction doit tenir compte ... | ["\nassert equivalent_potential_temperature(290.0, 850.0, 275.0) == potential_temperature(290.0 * (1 + 0.61 * mixing_ratio(850.0, 275.0)), 850.0)\n", "\nassert equivalent_potential_temperature(288.0, 1000.0, 288.0) == 288.0\n", "\nassert equivalent_potential_temperature(300.0, 1013.25, 290.0) > 300.0\n", "\nassert equi... |
f0885b6e25f76bd09f3c95b456c69dfa | [
{
"content": "Tu es chargé de traiter une liste d'enregistrements d'employés. Chaque enregistrement est représenté comme un dictionnaire avec les clés `name`, `department` et `salary`. Ton objectif est d'agréger le salaire total pour chaque département. Implémente la fonction `group_employees_by_department(empl... | ["\nassert group_employees_by_department([{'name': 'Alice', 'department': 'Engineering', 'salary': 80000}, {'name': 'Bob', 'department': 'Engineering', 'salary': 90000}]) == {'Engineering': 170000}\n", "\nassert group_employees_by_department([{'name': 'Charlie', 'department': 'HR', 'salary': 70000}, {'name': 'David', '... |
8ca4cbcf7eddc3e22f4892e20724aea6 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'écrire une fonction `find_longest_palindrome(text)` qui renvoie la plus longue sous-chaîne palindromique dans `text`. S'il existe plusieurs sous-chaînes de longueur maximale identique, renvoie celle qui apparaît en premier.\n\n**Entré... | ["\nassert find_longest_palindrome(\"babad\") == \"bab\" or find_longest_palindrome(\"babad\") == \"aba\"\n", "\nassert find_longest_palindrome(\"cbbd\") == \"bb\"\n", "\nassert find_longest_palindrome(\"a\") == \"a\"\n", "\nassert find_longest_palindrome(\"ac\") == \"a\" or find_longest_palindrome(\"ac\") == \"c\"\n",... |
13829eec4622718657b0682d419b9b96 | [
{
"content": "On te demande d'implémenter une fonction `is_prime(n)` qui détermine si un entier donné `n` est un nombre premier. La fonction doit renvoyer `True` si `n` est premier, et `False` sinon. Ta solution doit être optimisée pour les grandes valeurs de `n`.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 10^18... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(29) == True\n", "\nassert is_prime(1) == False\n", "\nassert is_prime(0) == False\n", "\nassert is_prime(-7) == False\n", "\nassert is_prime(97) == True\n", "\nass... |
7297d2c56bc62ad31ce7b9d63295b1a0 | [
{
"content": "On te donne deux listes d'entiers, `team1_scores` et `team2_scores`, représentant les scores de deux équipes dans un jeu. De plus, on te fournit une liste de paires, `matched_players`, où chaque paire consiste en des indices indiquant les joueurs appariés des deux équipes. Ta tâche est de mettre e... | ["\nassert score_difference([10, 20, 30], [15, 25, 35], [(0, 0), (1, 1), (0, 0), (2, 2)]) == {(0, 0): 10, (1, 1): 5, (2, 2): 5}\n", "\nassert score_difference([5, 15, 25], [10, 20, 30], [(0, 0), (1, 1), (2, 2)]) == {(0, 0): 5, (1, 1): 5, (2, 2): 5}\n", "\nassert score_difference([1, 2, 3], [3, 2, 1], [(0, 2), (1, 1), (... |
d225f361fcceb3f9facbb31e59cb043e | [
{
"content": "On te donne une liste d'entiers `A`. Détermine si la liste peut être triée par ordre non décroissant en supprimant au plus un élément. Si c'est possible, retourne `True`; sinon, retourne `False`.\n\n**Contraintes :**\n- La longueur de la liste `A` est comprise entre 1 et 1000.\n- Chaque élément de... | ["\nassert is_almost_sorted([1, 2, 3, 4, 5]) == True\n", "\nassert is_almost_sorted([5, 4, 3, 2, 1]) == False\n", "\nassert is_almost_sorted([1, 3, 2, 4, 5]) == True\n", "\nassert is_almost_sorted([1, 2, 4, 3, 5]) == True\n", "\nassert is_almost_sorted([1, 2, 3, 5, 4]) == True\n", "\nassert is_almost_sorted([1, 2, 3, 4... |
ab09c659e0045df6e904d31791c1d458 | [
{
"content": "On te demande d'implémenter une simulation simple de compte bancaire. Le compte bancaire commence avec un solde initial de 100 $. Ton programme doit définir une classe `BankAccount` avec les méthodes suivantes :\n\n- `deposit(amount)` : Ajoute le montant spécifié au solde du compte. Lève une `Valu... | ["\nassert BankAccount().check_balance() == 100\n", "\nassert BankAccount(200).check_balance() == 200\n", "\nassert BankAccount().deposit(50) or BankAccount().check_balance() == 150\n", "\nassert BankAccount().withdraw(50) or BankAccount().check_balance() == 50\n", "\nassert BankAccount().deposit(100) or BankAccount().... |
3003c7ba5b18a6873f0b4158adf56049 | [
{
"content": "On te demande d'implémenter une fonction récursive efficace pour calculer le nième nombre de Fibonacci. Pour optimiser la fonction, tu dois utiliser la mémoïsation pour stocker les nombres de Fibonacci déjà calculés et éviter les calculs redondants. Ta fonction doit gérer les entrées entières non ... | ["\nassert fib_recursive(0) == 0\n", "\nassert fib_recursive(1) == 1\n", "\nassert fib_recursive(2) == 1\n", "\nassert fib_recursive(3) == 2\n", "\nassert fib_recursive(4) == 3\n", "\nassert fib_recursive(5) == 5\n", "\nassert fib_recursive(10) == 55\n", "\nassert fib_recursive(20) == 6765\n", "\nassert fib_recursive(3... |
ef06d41e8c49bf5be3cbcfe283e51374 | [
{
"content": "On te donne une grille 2D représentant un labyrinthe où chaque cellule est soit un mur ('#') soit un chemin ('.'). La position de départ d'un rat dans le labyrinthe est spécifiée par les coordonnées (i, j). Le rat peut se déplacer dans quatre directions : haut, bas, gauche et droite, mais ne peut ... | ["\nassert is_rat_on_edge([['#', '.', '#'], ['.', '.', '.'], ['#', '.', '#']], 1, 1) == True\n", "\nassert is_rat_on_edge([['#', '#', '#'], ['#', '.', '#'], ['#', '#', '#']], 1, 1) == False\n", "\nassert is_rat_on_edge([['.', '.', '.'], ['.', '.', '.'], ['.', '.', '.']], 0, 0) == True\n", "\nassert is_rat_on_edge([['.'... |
789cb1761a6b9e369661198f9a25122b | [
{
"content": "On te donne une liste non triée d'entiers. Implémente une fonction récursive `merge_sort` qui trie la liste par ordre croissant en utilisant l'algorithme de tri fusion. Ta fonction doit gérer les listes de n'importe quelle taille, y compris les listes vides et les listes avec un seul élément.\n\n*... | ["\nassert merge_sort([38, 27, 43, 3, 9, 82, 10]) == [3, 9, 10, 27, 38, 43, 82]\n", "\nassert merge_sort([5, 2, 9, 1, 5, 6]) == [1, 2, 5, 5, 6, 9]\n", "\nassert merge_sort([1]) == [1]\n", "\nassert merge_sort([]) == []\n", "\nassert merge_sort([7, 7, 7, 7]) == [7, 7, 7, 7]\n", "\nassert merge_sort([10, 9, 8, 7, 6, 5, 4... |
6c33461e6c20426e301286745f9f6c90 | [
{
"content": "On te donne deux entiers, `a` et `b`. Ta tâche est d'écrire une fonction Python qui calcule et renvoie la somme de leurs valeurs absolues.\n\n**Entrée :**\n- Deux entiers `a` et `b` (-10^9 ≤ a, b ≤ 10^9)\n\n**Sortie :**\n- Un entier représentant la somme des valeurs absolues de `a` et `b`.\n\n**Ex... | ["\nassert sum_of_absolute_values(5, 3) == 8\n", "\nassert sum_of_absolute_values(-5, 3) == 8\n", "\nassert sum_of_absolute_values(5, -3) == 8\n", "\nassert sum_of_absolute_values(-5, -3) == 8\n", "\nassert sum_of_absolute_values(0, 0) == 0\n", "\nassert sum_of_absolute_values(0, 5) == 5\n", "\nassert sum_of_absolute_v... |
4d663c1e5de6ffdedba7e024c01ef742 | [
{
"content": "Jane a lancé une entreprise de confection de couvertures pour bébés personnalisées. Pour gérer efficacement son inventaire, elle a besoin d'un programme. Implémente une solution basée sur les classes Python avec deux classes : `BlanketItem` et `Inventory`. La classe `BlanketItem` doit avoir des at... | ["\nassert isinstance(BlanketItem(\"small\", \"red\", 25), BlanketItem)\n", "\nassert BlanketItem(\"small\", \"red\", 25).__repr__() == \"BlanketItem(size='small', color='red', price=25)\"\n", "\ninventory = Inventory(); inventory.add_item(BlanketItem(\"medium\", \"blue\", 35)); assert len(inventory.items) == 1\n", "\n... |
97fd2d19e82aa0e24365c061af655f66 | [
{
"content": "Tu participes à une compétition d'apprentissage automatique où l'on te fournit une matrice creuse `weights` représentant la matrice de poids optimale pour un modèle de régression linéaire et un tableau 2D `inputs` représentant les entrées d'entraînement. Ta tâche est d'écrire une fonction `compute... | ["\nassert compute_predictions(csr_matrix([[1]]), np.array([[1]])) == np.array([[1]])\n", "\nassert np.array_equal(compute_predictions(csr_matrix([[2]]), np.array([[3]])), np.array([[6]]))\n", "\nassert np.array_equal(compute_predictions(csr_matrix([[0]]), np.array([[5]])), np.array([[0]]))\n", "\nassert np.array_equal... |
0817dfaa4544c1c4eb29a47fdceadaa7 | [
{
"content": "On te donne pour tâche d'implémenter une fonction pour établir une connexion HTTPS sécurisée à un serveur distant. Ta fonction doit gérer les erreurs de connexion en essayant de se reconnecter jusqu'à un nombre de fois spécifié. La fonction doit s'assurer que toute communication réseau est chiffré... | ["\nassert connect_to_secure_server('https://example.com', 1) in [True, False]\n", "\nassert connect_to_secure_server('https://nonexistentwebsite123456789.com', 1) == False\n", "\nassert connect_to_secure_server('https://httpbin.org/status/200', 1) == True\n", "\nassert connect_to_secure_server('https://httpbin.org/sta... |
4257a5b423afa71f84969340623ef339 | [
{
"content": "On te donne un fichier sérialisé contenant les distributions de probabilité a priori et a posteriori pour un ensemble de classes. Ta tâche est d'écrire un programme qui charge ces données et calcule la divergence de Renyi d'ordre 2 entre les distributions a priori et a posteriori. La divergence de... | ["\nassert renyi_divergence(2, np.array([0.5, 0.5]), np.array([0.5, 0.5])) == 0.0\n", "\nassert renyi_divergence(2, np.array([1.0, 0.0]), np.array([0.5, 0.5])) == float('inf')\n", "\nassert renyi_divergence(2, np.array([0.25, 0.75]), np.array([0.5, 0.5])) == 0.1438410362034397\n", "\nassert renyi_divergence(2, np.array... |
171489968f9fdf1752aed614211e45b3 | [
{
"content": "On te donne la tâche de développer un programme qui lit un fichier contenant des mots et leurs scores de sentiment correspondants. Chaque mot est associé à un score de sentiment allant de -1 à 1, où -1 indique un sentiment négatif, 1 indique un sentiment positif et 0 indique un sentiment neutre. L... | ["\nassert load_sentiment_scores('test1.txt') == {'happy': 0.8, 'sad': -0.6, 'neutral': 0.0}\n", "\nassert load_sentiment_scores('test2.txt') == {'love': 0.9, 'hate': -0.9, 'okay': 0.1}\n", "\nassert calculate_sentence_sentiments([\"I am happy!\"], {'happy': 0.8}) == [0.8]\n", "\nassert calculate_sentence_sentiments([\... |
e813974e7931f103b545a1efddf31a4d | [
{
"content": "On te donne une liste non triée d'entiers et un entier positif `k`. Ta tâche est de concevoir un algorithme efficace pour trouver les `k` plus petits éléments de la liste et de les renvoyer dans l'ordre trié.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), le nombre d'é... | ["\nassert find_k_smallest_elements([7, 10, 4, 3, 20, 15], 3) == [3, 4, 7]\n", "\nassert find_k_smallest_elements([1, 2, 3, 4, 5], 2) == [1, 2]\n", "\nassert find_k_smallest_elements([5, 4, 3, 2, 1], 3) == [1, 2, 3]\n", "\nassert find_k_smallest_elements([10, 22, 5, 75, 65, 80], 4) == [5, 10, 22, 65]\n", "\nassert find... |
3b796fa9075567a2b6ef114cf6b14f2d | [
{
"content": "On te donne un tableau d'entiers `numbers` et un entier `target`. Ta tâche est de trouver toutes les paires d'indices uniques `(i, j)` telles que `numbers[i] + numbers[j] == target` et `i < j`. Retourne ces paires sous forme de liste de tuples. Si aucune paire de ce type n'existe, retourne une lis... | ["\nassert find_indices_of_sum([2, 7, 11, 15], 9) == [(0, 1)]\n", "\nassert find_indices_of_sum([3, 2, 4], 6) == [(1, 2)]\n", "\nassert find_indices_of_sum([3, 3], 6) == [(0, 1)]\n", "\nassert find_indices_of_sum([1, 2, 3, 4, 5], 9) == [(3, 4)]\n", "\nassert find_indices_of_sum([1, 2, 3, 4, 5], 10) == []\n", "\nassert ... |
51cc6d5d60c221cbce01f52e7c6a6c10 | [
{
"content": "On te demande d'implémenter une fonction `generate_alternating_chars(n, patterns)` qui construit une chaîne de caractères de longueur `n` en se basant sur une série de motifs alternés. Chaque motif est défini par un tuple contenant un caractère et le nombre de fois où il doit apparaître consécutiv... | ["\nassert generate_alternating_chars(5, [('a', 1), ('b', 1)]) == \"ababa\"\n", "\nassert generate_alternating_chars(10, [('a', 2), ('b', 3)]) == \"aabbaabbaa\"\n", "\nassert generate_alternating_chars(7, [('x', 3), ('y', 2)]) == \"xxxyyxx\"\n", "\nassert generate_alternating_chars(0, [('a', 2), ('b', 3)]) == \"\"\n", ... |
3588a30ee213164d4e097a4024121e3c | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui simule des opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur doit accepter un numéro de compte et un solde initial facultatif (par défaut 0.0).\... | ["\nassert BankAccount(\"12345\").get_balance() == 0.0\n", "\nassert BankAccount(\"12345\", 100.0).get_balance() == 100.0\n", "\nassert BankAccount(\"12345\").get_account_number() == \"12345\"\n", "\naccount = BankAccount(\"12345\", 100.0)\naccount.deposit(50.0)\nassert account.get_balance() == 150.0\n", "\naccount = B... |
89c2e92474e59c59ab5aa996227381b9 | [
{
"content": "On te donne un ensemble de données constitué de `n` points de données, chacun représenté comme un tuple `(x, y)`, où `x` est la caractéristique d'entrée et `y` est la sortie cible. Ta tâche est de mettre en œuvre une fonction qui calcule l'Erreur Quadratique Moyenne (MSE) pour un modèle linéaire d... | ["\nassert mean_square_error([(1, 2), (2, 4), (3, 6)], 2, 0) == 0.0\n", "\nassert mean_square_error([(1, 1), (2, 2), (3, 3)], 1, 1) == 1.0\n", "\nassert mean_square_error([(0, 0), (1, 1), (2, 2)], 1, 0) == 0.0\n", "\nassert mean_square_error([(1, 3), (2, 5), (3, 7)], 2, 1) == 0.0\n", "\nassert mean_square_error([(1, 2)... |
857f0fef29862aa05b225fa8b3471484 | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `count_unique_words` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les mots uniques trouvés dans la chaîne d'entrée, et les valeurs doivent être l... | ["\nassert count_unique_words(\"hello world hello\") == {\"hello\": 2, \"world\": 1}\n", "\nassert count_unique_words(\"one two three two one\") == {\"one\": 2, \"two\": 2, \"three\": 1}\n", "\nassert count_unique_words(\"a a a a a\") == {\"a\": 5}\n", "\nassert count_unique_words(\"python is great and python is fun\")... |
ddf2030e6bd28631112e6b53a0dbe0ed | [
{
"content": "On te demande de traiter un ensemble de données de produits provenant d'une plateforme de commerce électronique stocké dans un fichier CSV. Le fichier CSV comprend les colonnes suivantes : 'product_id', 'product_name', 'category', 'price' et 'quantity_sold'. Ton objectif est de mettre en œuvre une... | ["\nassert filter_products('test_products.csv', 'Electronics', 1000) == 'filtered_products.csv'\n", "\nassert filter_products('test_products.csv', 'Books', 50, sort_by='quantity_sold', sort_descending=True) == 'filtered_products.csv'\n", "\nassert filter_products('test_products.csv', 'Clothing', 200, sort_by='price', s... |
65f9d84b8bd5b876d0c5eab460ddc90a | [
{
"content": "On te demande de déboguer une fonction Python nommée `add_numbers`. Cette fonction est censée calculer la somme de deux entiers, `a` et `b`, et renvoyer le résultat. Cependant, l'implémentation actuelle ajoute incorrectement `a` deux fois à `b`. Ta mission est d'identifier et de corriger l'erreur ... | ["\nassert add_numbers(2, 3) == 5\n", "\nassert add_numbers(-1, 1) == 0\n", "\nassert add_numbers(0, 0) == 0\n", "\nassert add_numbers(100, 200) == 300\n", "\nassert add_numbers(-5, -5) == -10\n", "\nassert add_numbers(1.5, 2.5) == 4.0\n", "\nassert add_numbers(-3.5, 2.5) == -1.0\n", "\nassert add_numbers(1000000, 1) =... |
152d16043dfefa41b40cc772b072f33e | [
{
"content": "On te donne une chaîne de caractères multiligne `sentence`. Ton objectif est d'écrire une fonction `compress_spaces(sentence: str) -> str` qui traite la chaîne selon les règles suivantes :\n- Remplace tous les caractères d'espacement consécutifs dans chaque ligne par un seul espace.\n- Supprime to... | ["\nassert compress_spaces(\" This is a test sentence \") == \"This is a test sentence\"\n", "\nassert compress_spaces(\"Hello World\") == \"Hello World\"\n", "\nassert compress_spaces(\" Leading and trailing spaces \") == \"Leading and trailing spaces\"\n", "\nassert compress_spaces(\"Multiple\\n lines... |
aafcf2e772248a4bf2411d135615aab8 | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est d'implémenter une fonction `find_consecutive_sequence(s)` qui identifie la première occurrence d'une séquence de trois caractères identiques ou plus consécutifs dans la chaîne, sans tenir compte de la casse. Si une telle séquence existe, r... | ["\nassert find_consecutive_sequence(\"aaabbb\") == \"a\"\n", "\nassert find_consecutive_sequence(\"aabbcc\") == False\n", "\nassert find_consecutive_sequence(\"AAABBB\") == \"a\"\n", "\nassert find_consecutive_sequence(\"AaAaAa\") == \"a\"\n", "\nassert find_consecutive_sequence(\"abcde\") == False\n", "\nassert find_... |
648303c08c35cfbe70d2edf95cf58dfd | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `count_vowels` qui renvoie un dictionnaire avec les clés \"a\", \"e\", \"i\", \"o\", \"u\" et leurs valeurs correspondantes comme le nombre de chaque voyelle dans la chaîne. La fonction doit être insensible à la cass... | ["\nassert count_vowels(\"Hello World\") == {'a': 0, 'e': 1, 'i': 0, 'o': 2, 'u': 0}\n", "\nassert count_vowels(\"AEIOU\") == {'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1}\n", "\nassert count_vowels(\"abcdefghijklmnopqrstuvwxyz\") == {'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1}\n", "\nassert count_vowels(\"Python Programming\")... |
3a2684c32cffba0786002bb58f0626f9 | [
{
"content": "On te donne un ensemble de points dans le plan 2D. Ta tâche est de déterminer le rayon minimum et maximum d'un anneau enveloppant qui contient tous les points donnés. Un anneau est défini comme une région en forme de anneau délimitée par deux cercles concentriques. Le rayon de l'anneau est la diff... | ["\nassert annulus_radii([(0, 0), (1, 0)]) == (0.5, 1.0, 0.5)\n", "\nassert annulus_radii([(0, 0), (0, 1), (1, 0), (1, 1)]) == (0.5, math.sqrt(2), math.sqrt(2) - 0.5)\n", "\nassert annulus_radii([(1, 1), (1, 1), (1, 1)]) == (0.0, 0.0, 0.0)\n", "\nassert annulus_radii([(0, 0), (0, 2), (2, 0), (2, 2)]) == (math.sqrt(2), ... |
4a6b63e26eea33be8a06452f1eb20dce | [
{
"content": "On te donne un ensemble de données d'articles scientifiques, chacun représenté comme un dictionnaire avec les clés \"title\" (titre), \"authors\" (auteurs), \"abstract\" (résumé) et \"keywords\" (mots-clés). Ta tâche est de mettre en œuvre une fonction `search_papers` qui prend une liste d'article... | ["\nassert search_papers(paper_data, \"python\", 1) == [\"Python is a great language for scripting, web applications, and data science.\"]\n", "\nassert search_papers(paper_data, \"python great\", 2) == [\"Python is a great language for scripting, web applications, and data science.\"]\n", "\nassert search_papers(paper... |
78952a7256d466b62a0b1da1e5468017 | [
{
"content": "Implémente une table de hachage en Python qui gère les collisions en utilisant le chaînage. Ta table de hachage doit prendre en charge les opérations suivantes :\n- `insert(key, value)` : Insère une paire clé-valeur dans la table de hachage. Si la clé existe déjà, mets à jour sa valeur.\n- `search... | ["\nassert ht.search(\"key1\") == \"value1\"\n", "\nassert ht.search(\"key2\") == \"value2\"\n", "\nassert ht.search(\"key3\") == \"value3\"\n", "\nassert ht.search(\"key10\") == \"value10\"\n", "\nassert ht.search(\"nonexistent_key\") == None\n", "\nassert ht.delete(\"key2\") == True\n", "\nassert ht.search(\"key2\") ... |
2065289572d1b7784bf125beac25ac22 | [
{
"content": "Dans une version simplifiée du poker, tu reçois une main de exactement 5 cartes. Chaque carte est représentée comme un tuple, où le premier élément est le rang (2-10, J, Q, K, A) et le second élément est la couleur (cœurs, carreaux, trèfles, piques). Les rangs sont représentés par des entiers (2-1... | ["\nassert calculate_hand_score([(10, 'hearts'), (10, 'diamonds'), (10, 'clubs'), (10, 'spades'), (5, 'hearts')]) == 17\n", "\nassert calculate_hand_score([(7, 'hearts'), (7, 'diamonds'), (7, 'clubs'), (5, 'hearts'), (5, 'diamonds')]) == 8\n", "\nassert calculate_hand_score([(7, 'hearts'), (7, 'diamonds'), (5, 'hearts'... |
376ef9fbc585c2f7c9a2da27349029d5 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `reduce_sum(numbers)` qui calcule la somme de tous les entiers de la liste en utilisant la fonction `functools.reduce()` de Python. Cependant, tu n'es pas autorisé à utiliser les opérations arithmétiques intégrées (addition, ... | ["\nassert reduce_sum([1, 2, 3, 4]) == 10\n", "\nassert reduce_sum([0, 0, 0, 0]) == 0\n", "\nassert reduce_sum([10, 20, 30, 40]) == 100\n", "\nassert reduce_sum([-1, -2, -3, -4]) == -10\n", "\nassert reduce_sum([100, 200, 300]) == 600\n", "\nassert reduce_sum([1]) == 1\n", "\nassert reduce_sum([-1]) == -1\n", "\nassert... |
0604f52e20d84a8a5cf3c0e508a201d4 | [
{
"content": "On te donne un score brut compris entre -95 et 95 et tu dois calculer la note finale sur une échelle de 0 à 100 en utilisant une transformation linéaire par morceaux. La transformation est définie par les points (-95, 0), (-25, 25), (25, 50), (75, 75) et (95, 100). Si le score brut est inférieur à... | ["\nassert calculate_final_grade(-100) == 0\n", "\nassert calculate_final_grade(-95) == 0\n", "\nassert calculate_final_grade(-50) == 6\n", "\nassert calculate_final_grade(-25) == 25\n", "\nassert calculate_final_grade(0) == 50\n", "\nassert calculate_final_grade(25) == 50\n", "\nassert calculate_final_grade(50) == 62\... |
81677fe4810246e63fe6bc17eb6ebf93 | [
{
"content": "On te donne une chaîne de caractères représentant un format de données structuré. La chaîne est composée de plusieurs lignes, où le niveau d'indentation de chaque ligne indique sa hiérarchie. Ta tâche est d'analyser cette chaîne et de construire un dictionnaire. Chaque paramètre, indiqué par une l... | ["\nassert parse_structured_data(\" param1: unit1 [default1]\\n This is a description for param1.\") == {'param1': {'long_name': 'This is a description for param1.', 'unit': 'unit1', 'default_value': 'default1'}}\n", "\nassert parse_structured_data(\" param2:\\n This is a long name or description for pa... |
dc3f37dcc1081a59271c78bdfc1837d5 | [
{
"content": "On te donne un carré centré sur un point `(x_center, y_center)` avec une longueur de côté spécifiée `side_length`. Ta tâche est d'écrire une fonction `squarePixels(center, side_length)` qui renvoie une liste de coordonnées de pixels uniques qui se trouvent sur le périmètre du carré. La fonction do... | ["\nassert squarePixels((0, 0), 1) == [(0, 0)]\n", "\nassert squarePixels((0, 0), 2) == [(0, 1), (1, 0), (0, -1), (-1, 0)]\n", "\nassert squarePixels((1, 1), 3) == [(0, 2), (1, 2), (2, 2), (2, 1), (2, 0), (1, 0), (0, 0), (0, 1)]\n", "\nassert squarePixels((2, 2), 4) == [(0, 4), (1, 4), (2, 4), (3, 4), (4, 4), (4, 3), (... |
a4d371ba48845fc2f683f6532c02506a | [
{
"content": "On te donne un objet JSON en entrée. Ta tâche est d'écrire une fonction Python qui parcourt récursivement l'objet JSON et convertit toutes les valeurs de chaîne en majuscules. L'objet JSON peut contenir des dictionnaires et des listes imbriqués. Ta fonction doit renvoyer l'objet JSON modifié.\n\n*... | ["\nassert convert_strings_to_uppercase({\"name\": \"Alice\"}) == {\"name\": \"ALICE\"}\n", "\nassert convert_strings_to_uppercase({\"details\": {\"city\": \"Wonderland\", \"occupation\": \"Adventurer\"}}) == {\"details\": {\"city\": \"WONDERLAND\", \"occupation\": \"ADVENTURER\"}}\n", "\nassert convert_strings_to_uppe... |
d5919b567098f9f4e31ac4a743612ac5 | [
{
"content": "On te donne une liste de fonctions, à la fois synchrones et asynchrones. Ta tâche est d'implémenter la fonction `call_functions` qui traite cette liste et renvoie une liste de résultats. Si une fonction est asynchrone, elle doit être attendue. Si une fonction lève une exception, le résultat pour c... | ["\nassert asyncio.run(call_functions([async_function])) == [\"async result\"]\n", "\nassert asyncio.run(call_functions([sync_function])) == [\"sync result\"]\n", "\nassert asyncio.run(call_functions([faulty_function])) == [None]\n", "\nassert asyncio.run(call_functions([faulty_async_function])) == [None]\n", "\nassert... |
ae6c0a4197459ad7ac6332f172ef60b5 | [
{
"content": "On te donne une liste contenant jusqu'à 20 éléments uniques. Ton objectif est d'écrire une fonction qui génère tous les sous-ensembles possibles de cette liste, y compris l'ensemble vide et la liste originale elle-même. Les sous-ensembles doivent être représentés sous forme de tuples, et l'ordre d... | ["\nassert generate_subsets([]) == [()]\n", "\nassert generate_subsets([1]) == [(), (1,)]\n", "\nassert generate_subsets([1, 2]) == [(), (1,), (2,), (1, 2)]\n", "\nassert generate_subsets([1, 2, 3]) == [(), (1,), (2,), (1, 2), (3,), (1, 3), (2, 3), (1, 2, 3)]\n", "\nassert generate_subsets(['a', 'b']) == [(), ('a',), (... |
b6f3a106b9fcf85039ab8f686968930e | [
{
"content": "On te donne une liste d'atomes, où chaque atome est représenté comme une liste contenant le nom de l'atome, le numéro de résidu et les coordonnées x, y, z. Ta tâche est de mettre en œuvre une fonction qui traite cette liste et une liste de numéros de résidus, en renvoyant un dictionnaire. Le dicti... | ["\nassert get_ca_atoms_distance([['CA', 1, 1.0, 0.0, 0.0], ['CA', 2, 0.0, 1.0, 0.0]], [1, 2]) == {1: [(1.0, 0.0, 0.0)], 2: [(0.0, 1.0, 0.0)]}\n", "\nassert get_ca_atoms_distance([['CA', 1, 0.0, 0.0, 0.0], ['CA', 2, 3.0, 4.0, 0.0]], [1, 2]) == {1: [(0.0, 0.0, 0.0)], 2: [(3.0, 4.0, 0.0)]}\n", "\nassert get_ca_atoms_dist... |
08e4cbddaf05af346fbb88e9c0fbac47 | [
{
"content": "On te demande d'implémenter une classe Python `Person` qui modélise une personne avec un prénom et un nom de famille. Ta classe doit avoir une méthode d'initialisation qui accepte deux paramètres : `first_name` et `last_name`. De plus, tu dois implémenter une méthode `get_full_name` qui renvoie le... | ["\nassert Person(\"John\", \"Doe\").get_full_name() == \"John Doe\"\n", "\nassert Person(\"Jane\", \"Smith\").get_full_name() == \"Jane Smith\"\n", "\nassert Person(\"Alice\", \"\").get_full_name() == \"Alice \"\n", "\nassert Person(\"\", \"Johnson\").get_full_name() == \" Johnson\"\n", "\nassert Person(\"Michael\", \... |
1be6885214538cd438e8f8e214e0932a | [
{
"content": "Tu es chargé d'implémenter une classe Python `Employee` pour gérer les détails et les opérations des employés. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Un employé est initialisé avec un `name`, un `position` et un `salary`.\n- **Give Raise** : Une ... | ["\nassert Employee(\"John Doe\", \"Developer\", 50000).name == \"John Doe\"\n", "\nassert Employee(\"Jane Smith\", \"Manager\", 75000).position == \"Manager\"\n", "\nassert Employee(\"Alice Johnson\", \"Analyst\", 60000).salary == 60000\n", "\nemp = Employee(\"Bob Brown\", \"Intern\", 30000)\nemp.give_raise(5000)\nass... |
a6c9945adb5309318a4ee5b641a38fb3 | [
{
"content": "On te donne un problème de générateur de grille non uniforme. Implémente une fonction `generate_non_uniform_grid` qui prend trois paramètres : `axis`, `viewport` et un `offset` optionnel. L'`axis` est une liste de listes, où chaque sous-liste contient des nombres complexes et éventuellement des va... | ["\nassert generate_non_uniform_grid([[1+0j, 2+0j, \"...\", 4+0j]], [0.5+0j]) == [((0.5, 0.0), (1.0, 0.0), (1.4142135623730951, 0.0), (2.0, 0.0))]\n", "\nassert generate_non_uniform_grid([[1+0j, 2+0j, \"...\", 4+0j]], [0.5+0j], [1+0j]) == [((1.5, 0.0), (2.0, 0.0), (2.414213562373095, 0.0), (3.0, 0.0))]\n", "\nassert ge... |
e88ead22baad82d0393ea906d911d7a7 | [
{
"content": "On te donne une chaîne de caractères `input_string` qui contient plusieurs paires nombre-unité séparées par des virgules (par exemple, '3 jours, 5 heures, 10 minutes'). Ta tâche est d'implémenter la fonction `extract_number_from_string(input_string)` qui extrait tous les nombres de la chaîne et le... | ["\nassert extract_number_from_string('3 days, 5 hours, 10 minutes') == [3, 5, 10]\n", "\nassert extract_number_from_string('1 day, 2 hours, 3 minutes') == [1, 2, 3]\n", "\nassert extract_number_from_string('100 apples, 200 bananas, 300 oranges') == [100, 200, 300]\n", "\nassert extract_number_from_string('') == []\n",... |
c74a51ea181fc3a1789270780160d4cc | [
{
"content": "On te donne une chaîne de caractères `s` et un caractère délimiteur `d`. Ton objectif est d'écrire une fonction `convert_delimiter` qui traite la chaîne `s` en remplaçant toutes les occurrences consécutives du caractère délimiteur `d` par un seul tiret bas (`_`). Si l'entrée `s` n'est pas une chaî... | ["\nassert convert_delimiter(\"apple|banana|cherry\", \"|\") == \"apple_banana_cherry\"\n", "\nassert convert_delimiter(\"apple,banana,cherry\", \",\") == \"apple_banana_cherry\"\n", "\nassert convert_delimiter(\"applebananacherry\", \"|\") == \"applebananacherry\"\n", "\nassert convert_delimiter(float(\"nan\"), \"|\")... |
836fa45e9aaf1f1eb59253508eb90230 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier maximum `max_num`. Ta tâche est d'écrire une fonction `format_numbers` qui formate chaque nombre de la liste en une chaîne entre crochets, en s'assurant que toutes les chaînes entre crochets sont remplies d'espaces à droite pour correspondre à... | ["\nassert format_numbers([5, 123, -7, 42], 123) == [' [5]', '[123]', '[-7]', ' [42]']\n", "\nassert format_numbers([0, 1, 2, 3], 3) == ['[0]', '[1]', '[2]', '[3]']\n", "\nassert format_numbers([-10, -20, -30], -10) == ['[-10]', '[-20]', '[-30]']\n", "\nassert format_numbers([100, 200, 300], 300) == ['[100]', '[200]', ... |
15dab9beacda4d18cda416d4f53045ef | [
{
"content": "On te donne deux tableaux, `predicted_sizes` et `real_sizes`, chacun de longueur `n`, représentant les tailles prédites et réelles de `n` cascades, respectivement. Ta tâche est de calculer l'erreur absolue relative moyenne entre les tailles prédites et réelles des cascades, en excluant toute casca... | ["\nassert compute_average_absolute_relative_error([15, 25, 35, 5], [10, 20, 30, 8]) == 1/6\n", "\nassert compute_average_absolute_relative_error([10, 20, 30], [10, 20, 30]) == 0\n", "\nassert compute_average_absolute_relative_error([15, 25, 35], [10, 20, 30]) == 1/2\n", "\nassert compute_average_absolute_relative_erro... |
a142ac0fb399401d63b786337c18a100 | [
{
"content": "On te demande d'implémenter une fonction pour déterminer le nombre de sièges occupés dans une salle de cinéma. La salle de cinéma est représentée comme une grille 2D, où chaque cellule est soit vide (indiquée par '.') soit occupée par un client (indiquée par '#'). Ta fonction doit parcourir la gri... | ["\nassert count_occupied_seats([['.', '.', '.'], ['.', '.', '.'], ['.', '.', '.']]) == 0\n", "\nassert count_occupied_seats([['#', '#', '#'], ['#', '#', '#'], ['#', '#', '#']]) == 9\n", "\nassert count_occupied_seats([['#', '.', '.'], ['.', '#', '.'], ['.', '.', '#']]) == 3\n", "\nassert count_occupied_seats([['.', '.... |
18c0c4599778cba97078741eb1de9fc5 | [
{
"content": "Dans le jeu \"Capture the Flag\", les joueurs s'affrontent sur une grille de 6x6. Chaque cellule de la grille peut être vide, contenir un drapeau blanc, un drapeau noir ou un marqueur neutre. La grille est représentée comme une chaîne multiligne, chaque ligne correspondant à une rangée. Les cellul... | ["\nassert find_flag_positions(\",,,,,,\\n,,,,,,\\n,,,,,,\\n,,,,,,\\n,,,,,,\\n,,,,,,\") == ((), (), ())\n", "\nassert find_flag_positions(\"O,,,,,\\n,,,,,\\n,,,,,\\n,,,,,\\n,,,,,\\n,,,,,\") == (((1, 1),), (), ())\n", "\nassert find_flag_positions(\",,,,,\\n,,,,,\\n,,,,,\\n,,,,,\\n,,,,,\\n,,,,,X\") == ((), (), ((6, 6),)... |
c2dd009aa8ff013d3b9b2d57df725bbb | [
{
"content": "On te donne une chaîne de caractères `text` et une chaîne de caractères `limit`. Le `limit` spécifie le nombre maximal de mots (`w`) et/ou de caractères (`c`) que la chaîne de sortie doit contenir. Ta tâche est de mettre en œuvre une fonction `truncate_text` qui tronque le `text` d'entrée selon le... | ["\nassert truncate_text(\"Hello world!\", \"5w\") == \"Hello world!\"\n", "\nassert truncate_text(\"Hello world!\", \"5c\") == \"Hello\"\n", "\nassert truncate_text(\"This is a test.\", \"2w\") == \"This is\"\n", "\nassert truncate_text(\"This is a test.\", \"10c\") == \"This is a\"\n", "\nassert truncate_text(\"One t... |
27cd22de16f8ecf0952b1b8525925858 | [
{
"content": "Tu développes une fonction pour générer un URI personnalisé pour un service cloud nommé \"CloudLog\". Le service possède deux versions : une version d'essai gratuite et une version payante, chacune avec des configurations URI distinctes. Ta tâche est d'implémenter la fonction `build_cloudlog_uri` ... | ["\nassert build_cloudlog_uri(\"example.com\") == \"https://paid-example.com:443/logs/upload\"\n", "\nassert build_cloudlog_uri(\"example.com\", trial_version=True) == \"https://trial-example.com:8088/logs/upload\"\n", "\nassert build_cloudlog_uri(\"example.com\", port=\"80\") == \"https://paid-example.com:80/logs/uplo... |
29bb032eca43e9f3a726fb5b2d1defd8 | [
{
"content": "On te donne une fonction `validate_input` qui vérifie si une entrée donnée satisfait certaines conditions. La fonction doit gérer les dictionnaires imbriqués dans le paramètre `input_data`, en traitant chaque dictionnaire imbriqué comme une portée distincte. Les conditions ne doivent s'appliquer q... | ["\nassert validate_input({'a': 10}, [('a', '>', 5)]) == False\n", "\nassert validate_input({'a': 10}, [('a', '<', 5)]) == True\n", "\nassert validate_input({'a': 10}, [('a', '==', 10)]) == False\n", "\nassert validate_input({'a': 10}, [('a', '!=', 10)]) == True\n", "\nassert validate_input({'a': 10, 'b': {'c': 20}}, [... |
777e3c9d10b059cae7937e7ae361f39b | [
{
"content": "On te donne une chaîne JSON représentant une liste de dictionnaires. Chaque dictionnaire contient des paires clé-valeur représentant une ligne de données. Ta tâche est de mettre en œuvre une fonction `parse_json_to_csv` qui convertit cette chaîne JSON en fichier CSV. Le fichier CSV doit être écrit... | ["\nassert parse_json_to_csv('[{\"name\": \"Alice\", \"age\": 30, \"city\": \"New York\"}]', 'test1.csv') is None\n", "\nassert parse_json_to_csv('[{\"name\": \"Alice\", \"age\": 30, \"city\": \"New York\"}, {\"name\": \"Bob\", \"age\": 25, \"city\": \"Los Angeles\"}]', 'test2.csv') is None\n", "\nassert parse_json_to_... |
b5d67aca6499cd698ef66c05f3c389bc | [
{
"content": "Implémente une classe Python `BankAccount` qui simule un système de compte bancaire simple. La classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation** : Le constructeur `__init__` doit accepter le nom du titulaire du compte et un solde initial facultatif. Si le solde initi... | ["\nassert BankAccount(\"Alice\").get_balance() == 0\n", "\nassert BankAccount(\"Bob\", 100).get_balance() == 100\n", "\nassert BankAccount(\"Charlie\", 50).deposit(50) or BankAccount(\"Charlie\", 50).get_balance() == 100\n", "\nassert BankAccount(\"David\", 200).withdraw(100) or BankAccount(\"David\", 200).get_balance... |
c8d6a639979bf5045718a97dfa420af2 | [
{
"content": "On te donne un dictionnaire `commodity_data` représentant des données de séries temporelles pour l'offre et la demande d'une certaine matière première. Les clés du dictionnaire sont des horodatages (en secondes depuis l'époque Unix), et les valeurs sont des tuples contenant les valeurs d'offre et ... | ["\nassert calculate_surplus_deficit({1609459200: (100, 80)}) == {1609459200: 20}\n", "\nassert calculate_surplus_deficit({1609459200: (50, 70)}) == {1609459200: -20}\n", "\nassert calculate_surplus_deficit({1609459200: (100, 100)}) == {1609459200: 0}\n", "\nassert calculate_surplus_deficit({1609459200: (0, 0)}) == {16... |
8d8e2d7d0fa71acd217c436f6825fc8f | [
{
"content": "On te demande d'implémenter une classe `Car` en Python qui modélise une voiture avec les attributs `make`, `model` et `year`. Ta classe doit inclure des méthodes pour définir et obtenir ces attributs, ainsi qu'une méthode `display_info` qui affiche les informations de la voiture au format : \"Car ... | ["\nassert Car(\"Toyota\", \"Corolla\", 2021).get_make() == \"Toyota\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2021).get_model() == \"Corolla\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2021).get_year() == 2021\n", "\ncar = Car(\"Honda\", \"Civic\", 2019)\ncar.set_make(\"Toyota\")\nassert car.get_make() == \"Toyota... |
7dc53aedbc936ed645a5320986adc1d8 | [
{
"content": "On te charge d'implémenter une fonction `filter_attributes(obj)` qui traite un objet et renvoie un dictionnaire contenant uniquement ses attributs publics. La fonction doit exclure tous les attributs qui commencent par un tiret bas (`_`), tous les attributs qui ont un attribut `_sa_adapter` ou `_s... | ["\nassert filter_attributes(type('Test', (object,), {'a': 1, '_b': 2})) == {'a': 1}\n", "\nassert filter_attributes(type('Test', (object,), {'x': 'hello', 'y': 'world', '_z': 'hidden'})) == {'x': 'hello', 'y': 'world'}\n", "\nassert filter_attributes(type('Test', (object,), {'nested': type('Nested', (object,), {'a': 1... |
0f40b34f0ff46aa16179509977ce67eb | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de déterminer si `n` est un carré parfait. Un carré parfait est un entier qui est le carré d'un entier. Par exemple, 1, 4, 9, 16 sont des carrés parfaits, mais 2, 3, 5, 10 ne le sont pas. Ta solution doit être efficace et capable de gérer de très gra... | ["\nassert is_perfect_square(0) == True\n", "\nassert is_perfect_square(1) == True\n", "\nassert is_perfect_square(4) == True\n", "\nassert is_perfect_square(9) == True\n", "\nassert is_perfect_square(16) == True\n", "\nassert is_perfect_square(25) == True\n", "\nassert is_perfect_square(2) == False\n", "\nassert is_pe... |
67fa111728d7ac1c344bc8934101f608 | [
{
"content": "On te demande d'implémenter une fonction de conversion de devises. Étant donné un montant et deux codes de devise, ta fonction doit convertir le montant de la devise source vers la devise cible en utilisant des taux de change prédéfinis. Les taux de change sont les suivants : `{'USD': 1.0, 'EUR': ... | ["\nassert convert_currency(100, 'USD', 'EUR') == 85.0\n", "\nassert convert_currency(50, 'EUR', 'USD') == 58.82352941176471\n", "\nassert convert_currency(200, 'GBP', 'JPY') == 29333.333333333332\n", "\nassert convert_currency(110, 'JPY', 'GBP') == 0.8571428571428571\n", "\nassert convert_currency(100, 'USD', 'USD') =... |
5bc72aa3997ec8528b2b983cfcd4d5c4 | [
{
"content": "On te demande d'implémenter une fonction `extract_json` qui traite une chaîne de réponse JSONP (JSON avec Padding). La réponse JSONP peut contenir plusieurs callbacks au format `callbackName({JSON_CONTENT});`. Ta fonction doit extraire et renvoyer le contenu JSON sous forme de dictionnaire Python ... | ["\nassert extract_json('callback({\\\"key\\\": \\\"value\\\"});') == {\"key\": \"value\"}\n", "\nassert extract_json('callbackOne({\\\"key\\\": \\\"value\\\"});callbackTwo({\\\"another_key\\\": \\\"another_value\\\"});', 'callbackOne') == {\"key\": \"value\"}\n", "\nassert extract_json('callbackOne({\\\"key\\\": \\\"v... |
a6cd6c92759c55cb93efbc3cf1efda20 | [
{
"content": "On te donne une liste d'intervalles, où chaque intervalle est représenté par une paire d'entiers (début, fin). Ces intervalles indiquent la disponibilité d'une ressource. Ta tâche est de déterminer le nombre maximal de ressources disponibles à un moment donné.\n\n**Entrée :**\n- Une liste d'interv... | ["\nassert max_resources_available([(1, 4), (3, 6), (5, 7), (8, 10)]) == 3\n", "\nassert max_resources_available([(1, 3), (2, 5), (4, 6)]) == 2\n", "\nassert max_resources_available([(1, 2), (3, 4), (5, 6)]) == 1\n", "\nassert max_resources_available([(1, 10), (2, 9), (3, 8), (4, 7)]) == 4\n", "\nassert max_resources_a... |
b24b86324c0d665a7de357aa73233505 | [
{
"content": "On te donne une liste de `n` points dans un plan 2D, où chaque point est représenté comme une liste de deux entiers `[x, y]`. Ta tâche est de mettre en œuvre une fonction `find_midpoint(points)` qui renvoie le point milieu du segment de ligne formé par le premier et le dernier point de la liste si... | ["\nassert find_midpoint([[0, 0], [1, 1], [2, 2]]) == [1.0, 1.0]\n", "\nassert find_midpoint([[1, 2], [3, 4], [5, 6]]) == [3.0, 4.0]\n", "\nassert find_midpoint([[0, 0], [0, 1], [0, 2]]) == [0.0, 1.0]\n", "\nassert find_midpoint([[1, 1], [2, 2], [3, 3], [4, 4]]) == [2.5, 2.5]\n", "\nassert find_midpoint([[1, 1], [2, 3]... |
496c3532d336dd1cd06e1c263cc24a65 | [
{
"content": "Tu développes une simulation pour un système d'acquisition de données utilisé dans la recherche scientifique. Le système comprend un module d'oscilloscope qui enregistre des données lors de la réception de déclencheurs. Le module d'oscilloscope ne doit traiter les déclencheurs que pendant des inte... | ["\nassert DataAcquisitionSystem(5, 10, 2).num_records == 5\n", "\nassert DataAcquisitionSystem(5, 10, 2).period == 10\n", "\nassert DataAcquisitionSystem(5, 10, 2).phase == 2\n", "\nassert len(DataAcquisitionSystem(0, 10, 2).records) == 0\n", "\nassert len(DataAcquisitionSystem(1, 10, 2).simulate_acquisition()) is Non... |
d39963cf9808d389de54fcbfc5026e89 | [
{
"content": "On te donne une liste de `n` entiers. Ta tâche est de déterminer le nombre minimum d'échanges adjacents nécessaires pour trier la liste par ordre croissant.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 1000), le nombre d'éléments dans la liste.\n- La deuxième ligne contient... | ["\nassert min_swaps_to_sort([4, 5, 6, 3, 2, 1]) == 9\n", "\nassert min_swaps_to_sort([1, 2, 3, 4, 5, 6]) == 0\n", "\nassert min_swaps_to_sort([6, 5, 4, 3, 2, 1]) == 15\n", "\nassert min_swaps_to_sort([1, 3, 5, 2, 4, 6]) == 3\n", "\nassert min_swaps_to_sort([10, 19, 6, 3, 5]) == 5\n", "\nassert min_swaps_to_sort([1]) =... |
125b7fcc1e3fffa347ce07d6f86dfcae | [
{
"content": "On te donne une chaîne de caractères `s` et une sous-chaîne `sub`. Ta tâche est de trouver tous les indices de début des occurrences de `sub` dans `s`. Si `sub` n'apparaît pas dans `s`, renvoie une liste vide.\n\n**Entrée :**\n- La première ligne contient la chaîne de caractères `s` (1 ≤ |s| ≤ 10^... | ["\nassert find_substring_occurrences(\"abracadabra\", \"abra\") == [0, 7]\n", "\nassert find_substring_occurrences(\"hello world\", \"world\") == [6]\n", "\nassert find_substring_occurrences(\"aaaa\", \"aa\") == [0, 1, 2]\n", "\nassert find_substring_occurrences(\"abcabcabc\", \"abc\") == [0, 3, 6]\n", "\nassert find_... |
517e1efd93b0084aa6f1eb0d861fffb9 | [
{
"content": "Tu es chargé d'implémenter une fonction `clean_filename` qui traite une chaîne de caractères donnée pour la rendre appropriée pour une utilisation en tant que nom de fichier. La fonction doit respecter les règles suivantes :\n\n1. Convertir l'ensemble de la chaîne en minuscules.\n2. Remplacer tous... | ["\nassert clean_filename(\"Caf\u00e9 M\u00fcnchner_123\") == \"cafe_munchner_123\"\n", "\nassert clean_filename(\"HELLO WORLD\") == \"hello_world\"\n", "\nassert clean_filename(\" Leading and trailing spaces \") == \"leading_and_trailing_spaces\"\n", "\nassert clean_filename(\"___Multiple___underscores___\") == \"mu... |
34f5cfe76677c3b53f43170c54922782 | [
{
"content": "On te demande d'implémenter une fonction `convert_case` qui traite une chaîne de caractères donnée en convertissant tous les caractères majuscules en minuscules correspondantes et vice versa. La fonction doit gérer à la fois les caractères ASCII et Unicode, en se concentrant particulièrement sur l... | ["\nassert convert_case(\"Hello, World!\") == \"hELLO, wORLD!\"\n", "\nassert convert_case(\"\u039d\u0399\u0393\u039f, \u03a3\u039a\u0399\u0391\u03a4!\") == \"\u03bd\u03b9\u03b3\u03bf, \u03c3\u03ba\u03b9\u03b1\u03c4!\"\n", "\nassert convert_case(\"hello, world!\") == \"HELLO, WORLD!\"\n", "\nassert convert_case(\"\u03b... |
2e459f998072e908fbf9916fab9e902b | [
{
"content": "On te donne un chemin de répertoire. Ta tâche est d'écrire une fonction Python qui liste tous les fichiers dans le répertoire spécifié et affiche leur taille en octets. La fonction doit gérer les cas où le répertoire n'existe pas ou n'est pas un répertoire. Suppose que le chemin du répertoire est ... | ["\nassert list_files_and_sizes('/nonexistent/directory') == None\n", "\nassert list_files_and_sizes('/home/user/documents') == None\n", "\nassert list_files_and_sizes('/home/user') == None\n", "\nassert list_files_and_sizes('') == None\n", "\nassert list_files_and_sizes('/home/user/documents/') == None\n", "\nassert l... |
f56a47bcaaddf34ff07cd080820e7de5 | [
{
"content": "On te donne une liste d'entiers représentant l'utilisation de la mémoire de divers processus au fil du temps. Chaque triplet de la liste est constitué d'un identifiant de processus, d'un horodatage et de l'utilisation de la mémoire du processus en octets à ce moment-là. Ta tâche est de calculer l'... | ["\nassert calculate_memory_usage([1, 1000, 1000000, 2, 2000, 2000000, 3, 3000, 3000000]) == (6000000, 8589843588)\n", "\nassert calculate_memory_usage([1, 1000, 0, 2, 2000, 0, 3, 3000, 0]) == (0, 8589934592)\n", "\nassert calculate_memory_usage([1, 1000, 8589934592]) == (8589934592, 0)\n", "\nassert calculate_memory_u... |
36589870216c5fecaed4edbc114acf9c | [
{
"content": "On te donne une chaîne de caractères `filename` représentant le nom d'un fichier CSV. Le nom de fichier suit le format `product-<product_name>-<product_id>.csv`, où `<product_name>` est composé de caractères alphanumériques et de tirets, et `<product_id>` est un entier positif en base-36 (utilisan... | ["\nassert extract_product_id(\"product-sample-1A.csv\") == 26\n", "\nassert extract_product_id(\"product-example-10.csv\") == 36\n", "\nassert extract_product_id(\"product-test-ZZ.csv\") == 1295\n", "\nassert extract_product_id(\"product-item-100.csv\") == 1296\n", "\nassert extract_product_id(\"product-gadget-ABC.csv... |
1c10790fde9e0bbcd34670dc96d9ce62 | [
{
"content": "On te donne un dictionnaire `data` et une chaîne de caractères `prefix`. Ta tâche est d'implémenter une fonction `extract_sequential_values(data, prefix)` qui extrait les valeurs du dictionnaire dont les clés commencent par le `prefix` donné suivi d'un entier positif. La fonction doit renvoyer une... | ["\nassert extract_sequential_values({'a1': 'apple', 'a2': 'banana', 'a3': 'cherry'}, 'a') == ['apple', 'banana', 'cherry']\n", "\nassert extract_sequential_values({'b1': 'dog', 'b3': 'cat'}, 'b') == ['dog', 'dog', 'cat']\n", "\nassert extract_sequential_values({'c2': 'fish', 'c4': 'bird'}, 'c') == [None, 'fish', 'fish... |
622fb22869bd8b960d9277b25dafc283 | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est de déterminer s'il est possible de diviser la liste en trois sous-listes contiguës non vides telles que chaque sous-liste ait la même somme. Retourne `True` si une telle division est possible, sinon retourne `False`. La liste peut contenir des e... | ["\nassert can_split_into_three_sublists_with_equal_sum([1, 2, 1, 2, 1, 2, 1]) == True\n", "\nassert can_split_into_three_sublists_with_equal_sum([0, 0, 0, 0]) == True\n", "\nassert can_split_into_three_sublists_with_equal_sum([1, -1, 1, -1, 1, -1]) == False\n", "\nassert can_split_into_three_sublists_with_equal_sum([3... |
f60a33ba208af85600c634ad0d3c419a | [
{
"content": "On te donne un rectangle plus grand de dimensions 1x1 unité. Ta tâche est de mettre en œuvre une fonction qui calcule les coordonnées d'un rectangle plus petit centré à l'intérieur de ce rectangle plus grand. Les dimensions du rectangle plus petit sont fournies en tant que paramètres d'entrée. Si ... | ["\nassert centered_rectangle(0.5, 0.5) == {'x': 0.25, 'y': 0.25, 'width': 0.5, 'height': 0.5}\n", "\nassert centered_rectangle(1.0, 1.0) == {'x': 0.0, 'y': 0.0, 'width': 1.0, 'height': 1.0}\n", "\nassert centered_rectangle(0.2, 0.3) == {'x': 0.4, 'y': 0.35, 'width': 0.2, 'height': 0.3}\n", "\nassert centered_rectangle... |
39f7687001dba26c1195f628fca97f09 | [
{
"content": "On te donne un objet workbook, une plage de lignes à fusionner et le nom d'une feuille de calcul. Ta tâche est de créer une fonction qui génère une nouvelle feuille de calcul avec le nom spécifié dans le workbook. La fonction doit fusionner la plage de lignes spécifiée dans la première colonne et ... | ["\nassert create_and_format_worksheet(openpyxl.Workbook(), (1, 2), \"Sheet1\").title == \"Sheet1\"\n", "\nassert create_and_format_worksheet(openpyxl.Workbook(), (1, 2), \"Sheet2\")[\"A1\"].value == \"ABC Corp\"\n", "\nassert create_and_format_worksheet(openpyxl.Workbook(), (1, 2), \"Sheet3\")[\"A2\"].value == \"Case ... |
9e9f808ab04ce2966332f417bda1d431 | [
{
"content": "Tu développes une simulation pour un moteur à turbine à gaz et tu dois calculer le rapport des chaleurs spécifiques (γ) du fluide de travail en fonction de la température de stagnation (T0in) avant le mélangeur à buses. Le rapport des chaleurs spécifiques (γ) peut être approximé en utilisant la fo... | ["\nassert calculate_specific_heat_ratio(1500, 28.97) == 1.39746855\n", "\nassert calculate_specific_heat_ratio(1000, 28.97) == 1.40466855\n", "\nassert calculate_specific_heat_ratio(500, 28.97) == 1.41186855\n", "\nassert calculate_specific_heat_ratio(2000, 28.97) == 1.38426855\n", "\nassert calculate_specific_heat_ra... |
c1005336db4d74e8eb245a7ae0acd8ce | [
{
"content": "On te confie la tâche d'implémenter une fonction pour déterminer l'emplacement d'un appareil dans un réseau en fonction de sa clé primaire réseau (nePk). Le nePk est une chaîne de caractères formatée comme \"X.NE\", où X est un entier non négatif. Ta fonction doit renvoyer un dictionnaire contenan... | ["\nassert get_location_association(\"1.NE\") == {\"nePk\": \"1.NE\", \"locationId\": 101, \"locationName\": \"Location 1\"}\n", "\nassert get_location_association(\"2.NE\") == {\"nePk\": \"2.NE\", \"locationId\": 202, \"locationName\": \"Location 2\"}\n", "\nassert get_location_association(\"3.NE\") == {\"nePk\": \"3.... |
849633277d0c9a91e4f8f7b65049c4f4 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction `find_palindromes` qui renvoie une liste de chaînes de caractères qui sont des palindromes. Une chaîne de caractères est considérée comme un palindrome si, après avoir converti tous les caractères en minusc... | ["\nassert find_palindromes([\"A man, a plan, a canal, Panama\"]) == [\"A man, a plan, a canal, Panama\"]\n", "\nassert find_palindromes([\"racecar\", \"hello\", \"No 'x' in Nixon\"]) == [\"racecar\", \"No 'x' in Nixon\"]\n", "\nassert find_palindromes([\"Was it a car or a cat I saw?\", \"Not a palindrome\"]) == [\"Was... |
9bf7ae61e486272541614dd0e20d2af8 | [
{
"content": "On te donne une liste d'entiers `numbers` contenant au moins trois éléments. Ta tâche est de mettre en œuvre une fonction `find_highest_product_of_three(numbers)` qui calcule le produit maximal de trois nombres distincts quelconques de la liste.\n\n**Entrée :**\n- Une liste d'entiers `numbers` où ... | ["\nassert find_highest_product_of_three([1, 10, -5, 1, -100]) == 5000\n", "\nassert find_highest_product_of_three([1, 2, 3]) == 6\n", "\nassert find_highest_product_of_three([-10, -20, -30, -40]) == -6000\n", "\nassert find_highest_product_of_three([-10, 20, -30, 40]) == 12000\n", "\nassert find_highest_product_of_thr... |
b1d2439595744bcf178bc312b049754f | [
{
"content": "On te donne un intervalle `[début, fin]`. Ta tâche est d'écrire une fonction Python qui identifie tous les nombres premiers dans cet intervalle, inclusivement. La fonction doit renvoyer une liste de ces nombres premiers.\n\n**Entrée :**\n- Deux entiers `début` et `fin` (1 ≤ début ≤ fin ≤ 10^3)\n\n... | ["\nassert find_primes_in_range(10, 50) == [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n", "\nassert find_primes_in_range(1, 10) == [2, 3, 5, 7]\n", "\nassert find_primes_in_range(20, 30) == [23, 29]\n", "\nassert find_primes_in_range(0, 1) == []\n", "\nassert find_primes_in_range(14, 16) == []\n", "\nassert find_prim... |
9940914366552374dea68c224c80da2b | [
{
"content": "On te donne un ensemble de données d'images représentées sous forme de DataFrame pandas `df`. Chaque ligne du DataFrame correspond à une image avec les attributs suivants :\n\n- `time_idx` : le point temporel auquel l'image a été capturée.\n- `channel_idx` : l'indice de canal de l'image.\n- `slice... | ["\nassert get_image_files(df, time_idx=1, channel_idx=0, slice_idx=-1) == ['image B', 'image A']\n", "\nassert get_image_files(df, time_idx=2, channel_idx=0, slice_idx=1) == ['image C']\n", "\nassert get_image_files(df, time_idx=2, channel_idx=0, slice_idx=2) == ['image D']\n", "\nassert get_image_files(df, time_idx=1... |
d03ebc1e550009fa92d879f83a016c0c | [
{
"content": "On te donne une liste de mots, `needles`, et un grand texte, `haystack`, représenté comme une liste de phrases. Ta tâche est d'écrire une fonction qui compte le nombre d'occurrences de chaque mot dans `needles` à l'intérieur de `haystack`. La fonction doit être insensible à la casse et ignorer les... | ["\nassert count_occurrences([\"word\"], [\"word\"]) == {\"word\": 1}\n", "\nassert count_occurrences([\"word\"], [\"Word\", \"word\", \"WORD\"]) == {\"word\": 3}\n", "\nassert count_occurrences([\"test\"], [\"this is a test\", \"another test\"]) == {\"test\": 2}\n", "\nassert count_occurrences([\"example\"], [\"exampl... |
2e9149516b42afa5fb6bc55aba5e09d6 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui renvoie une liste de tuples. Chaque tuple doit contenir un entier de la liste et sa fréquence. La liste de tuples doit être triée principalement par la fréquence des entiers par ordre décroissant. Si deux entiers on... | ["\nassert number_frequency([1, 3, 2, 3, 4, 1, 1]) == [(1, 3), (3, 2), (2, 1), (4, 1)]\n", "\nassert number_frequency([5, 5, 5, 5, 5]) == [(5, 5)]\n", "\nassert number_frequency([1, 2, 3, 4, 5]) == [(1, 1), (2, 1), (3, 1), (4, 1), (5, 1)]\n", "\nassert number_frequency([]) == []\n", "\nassert number_frequency([7, 7, 7,... |
3ca8388353aaf33c5894cfc89ad1be8f | [
{
"content": "On te donne une chaîne de caractères `path` représentant un chemin de fichier dans une structure de répertoires hiérarchique. Le chemin commence par un nombre arbitraire de segments de répertoire racine, suivi de `project_id`, `dataset_id` et `table_id` aux troisième, quatrième et cinquième niveau... | ["\nassert extract_table_info(\"/root/project_id/dataset_id/table_id\") == (\"project_id\", \"dataset_id\", \"table_id\")\n", "\nassert extract_table_info(\"/root/another_root/project_id/dataset_id/table_id\") == (\"project_id\", \"dataset_id\", \"table_id\")\n", "\nassert extract_table_info(\"/root/path/to/project_id/... |
8db6cdf1a5df181abfa88df1bfdd6ffa | [
{
"content": "On te demande d'implémenter une classe `InventoryManager` pour gérer une collection de produits dans un inventaire. La classe doit prendre en charge les opérations suivantes :\n\n- **Ajouter un produit** : Ajouter un nouveau produit à l'inventaire. Si l'ID du produit existe déjà, ne l'ajoute pas e... | ["\nassert InventoryManager().add_product(1, {\"name\": \"Laptop\", \"price\": 1000}) is None\n", "\nassert InventoryManager().get_product(1) == \"Product ID 1 not found.\"\n", "\nassert InventoryManager().list_products() == []\n", "\ninventory = InventoryManager()\ninventory.add_product(1, {\"name\": \"Laptop\", \"pri... |
5068279a0f6bf108ff52f6a5afe2341a | [
{
"content": "On te demande d'implémenter une fonction d'activation personnalisée nommée `piecewise_linear(z, data)` pour un réseau neuronal. Cette fonction doit présenter un comportement non linéaire basé sur la distribution des données d'entrée. Plus précisément, pour une entrée donnée `z`, la fonction doit r... | ["\nassert np.array_equal(piecewise_linear(np.array([0.1, 0.2, 0.3]), np.array([0.1, 0.2, 0.3, 0.4, 0.5])), np.array([0.1, 0.2, 0.3]))\n", "\nassert np.array_equal(piecewise_linear(np.array([0.4, 0.5, 0.6]), np.array([0.1, 0.2, 0.3, 0.4, 0.5])), np.array([0.8, 1.0, 1.2]))\n", "\nassert np.array_equal(piecewise_linear(n... |
6b97e479690c9ad34ca0484fa53b707f | [
{
"content": "On te donne un dictionnaire `user_activity_dict` où chaque clé est un identifiant utilisateur et chaque valeur est le nombre d'activités effectuées par cet utilisateur sur une plateforme. Ta tâche est de calculer la proportion d'activités effectuées par chaque utilisateur par rapport au nombre tot... | ["\nassert calculate_activity_proportions({'user1': 3, 'user2': 7, 'user3': 10, 'user4': 4, 'user5': 5}) == {'user2': 0.4117647058823529, 'user3': 0.5882352941176471, 'user5': 0.0}\n", "\nassert calculate_activity_proportions({'user1': 5, 'user2': 5, 'user3': 5}) == {'user1': 0.3333333333333333, 'user2': 0.333333333333... |
4d7409f3fdc8ca3dbd829717d3bdb778 | [
{
"content": "On te demande d'implémenter un système simple de gestion d'inventaire en Python. Le système doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un produit** : Ajouter une quantité spécifiée d'un produit à l'inventaire. Si le produit existe déjà, augmenter sa quantité.\n2. **Supprimer... | ["\nassert inventory.products == {}\n", "\ninventory.add_product(\"apple\", 10); assert inventory.products[\"apple\"] == 10\n", "\ninventory.add_product(\"apple\", 5); assert inventory.products[\"apple\"] == 15\n", "\ninventory.remove_product(\"apple\", 5); assert inventory.products[\"apple\"] == 10\n", "\ninventory.re... |
c22070ac7fcc6c639d7e4239eba7bf3d | [
{
"content": "On te donne deux listes d'entiers distincts, `numbers` et `thresholds`. La liste `thresholds` est triée par ordre croissant. Pour chaque nombre dans la liste `numbers`, détermine son indice de compartiment. L'indice de compartiment pour un nombre est la position du premier seuil dans la liste `thr... | ["\nassert bin_index([10, 20, 30], [3, 5, 7, 11, 13, 17, 19]) == [3, 4, 5]\n", "\nassert bin_index([1, 2, 3], [2, 3, 5, 7, 11]) == [0, 0, 1]\n", "\nassert bin_index([4, 6, 8], [2, 3, 5, 7, 11]) == [2, 2, 3]\n", "\nassert bin_index([15, 25, 35], [3, 5, 7, 11, 13, 17, 19]) == [3, 4, 5]\n", "\nassert bin_index([20, 25, 30... |
1c9c5035dcb17b44b4ecd906981ffe69 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui calcule la médiane de la liste. La fonction doit gérer correctement les listes de longueur paire et impaire.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 10^5), où chaque entier `x` satisfait -10^9 ≤... | ["\nassert find_median([1, 3, 2]) == 2\n", "\nassert find_median([1, 2, 3, 4]) == 2.5\n", "\nassert find_median([7]) == 7\n", "\nassert find_median([1, 2, 3, 4, 5, 6, 7, 8, 9]) == 5\n", "\nassert find_median([10, 20, 30, 40, 50]) == 30\n", "\nassert find_median([5, 3, 8, 9, 2]) == 5\n", "\nassert find_median([1, 1, 1, ... |
877543df9e51a38ad472640028f148b8 | [
{
"content": "Dans un espace 3D, une matrice de transformation homogène est représentée comme une matrice 4x4 qui peut inclure une translation, une rotation et une mise à l'échelle uniforme. Ta tâche est d'écrire une fonction qui extrait la composante de translation de cette matrice. La fonction doit renvoyer u... | ["\nassert extract_translation([[1, 0, 0, 5], [0, 1, 0, 3], [0, 0, 1, -2], [0, 0, 0, 1]]) == [5, 3, -2]\n", "\nassert extract_translation([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) == [0, 0, 0]\n", "\nassert extract_translation([[2, 0, 0, 10], [0, 2, 0, 20], [0, 0, 2, 30], [0, 0, 0, 1]]) == [10, 20, 30]\... |
902400fa5f11a5c30fb87166c10e4bc0 | [
{
"content": "On te demande d'implémenter une fonction qui lit un fichier JSON à partir d'un chemin de fichier donné et renvoie les données sous forme de dictionnaire Python. Ta fonction doit gérer l'ouverture et la fermeture du fichier automatiquement.\n\n**Signature de la fonction :**\n```python\ndef read_jso... | ["\nassert read_json_file('test1.json') == {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}\n", "\nassert read_json_file('test2.json') == {\"employees\": [{\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Bob\", \"age\": 30}]}\n", "\nassert read_json_file('test3.json') == {\"fruits\": [\"apple\", \"banana\", \"... |
d6cc0a572d5d4349c3b481f8a0a04377 | [
{
"content": "On te demande d'implémenter une fonction `calculate_wave_amplitude` qui calcule l'amplitude d'une onde sinusoïdale à un moment précis. L'onde sinusoïdale est caractérisée par une fréquence donnée et commence avec un déphasage de π/4 radians. L'amplitude est déterminée par la formule suivante :\n\n... | ["\nassert calculate_wave_amplitude(1, 0) == math.sin(math.pi / 4)\n", "\nassert calculate_wave_amplitude(1, 0.25) == math.sin(math.pi * 2 * 0.25 + math.pi / 4)\n", "\nassert calculate_wave_amplitude(2, 0.5) == math.sin(math.pi * 2 * 2 * 0.5 + math.pi / 4)\n", "\nassert calculate_wave_amplitude(0, 10) == math.sin(math.... |
a17a851f460f0b36de131d4a34d01e87 | [
{
"content": "On te donne une chaîne de caractères `S`. Ta tâche est de la convertir en un slug adapté à une URL. Le slug doit respecter les critères suivants :\n- Convertir tous les caractères en minuscules.\n- Remplacer tous les espaces par des tirets.\n- Supprimer tous les caractères non alphanumériques, à l... | ["\nassert to_slug(\"Hello, World!\") == \"hello-world\"\n", "\nassert to_slug(\"This is a test.\") == \"this-is-a-test\"\n", "\nassert to_slug(\"Python@3.9\") == \"python39\"\n", "\nassert to_slug(\"Spaces and-tabs\") == \"spaces-and-tabs\"\n", "\nassert to_slug(\"Special #$%&*() Characters\") == \"special-characte... |
2f53e410a06445554f518ac679ea05a2 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif donné. Ta fonction doit gérer les entrées invalides avec élégance en levant une exception `ValueError` si l'entrée est négative.\n\n**Entrée :**\n- Un seul entier `n` (0 ≤ n ≤ 20).\n\n**Sortie :... | ["\nassert factorial_recursive(0) == 1\n", "\nassert factorial_recursive(1) == 1\n", "\nassert factorial_recursive(5) == 120\n", "\nassert factorial_recursive(7) == 5040\n", "\nassert factorial_recursive(10) == 3628800\n", "\nassert factorial_recursive(3) == 6\n", "\nassert factorial_recursive(15) == 1307674368000\n", ... |
ff2de53dc50bf433ee8748bd4d120dcc | [
{
"content": "On te donne deux dictionnaires, `dict1` et `dict2`. Ta tâche est d'implémenter une fonction `deep_merge` qui renvoie un nouveau dictionnaire qui est le résultat d'une fusion profonde des deux dictionnaires d'entrée. Si une clé existe dans les deux dictionnaires et que les valeurs correspondantes s... | ["\nassert deep_merge({}, {}) == {}\n", "\nassert deep_merge({'a': 1}, {'b': 2}) == {'a': 1, 'b': 2}\n", "\nassert deep_merge({'a': {'x': 1}}, {'a': {'y': 2}}) == {'a': {'x': 1, 'y': 2}}\n", "\nassert deep_merge({'a': {'x': 1}}, {'a': {'x': 2}}) == {'a': {'x': 2}}\n", "\nassert deep_merge({'a': 1, 'b': 2}, {'b': 3, 'c'... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.