id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
0f081f390b6a54017dc41590e3953adf | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction `reverse_words` qui inverse l'ordre des mots dans la chaîne. Les mots dans la chaîne inversée doivent être séparés par un seul espace.\n\n**Entrée :**\n- Une seule chaîne de cara... | ["\nassert reverse_words(\"Hello world this is a test\") == \"test a is this world Hello\"\n", "\nassert reverse_words(\"Python is fun\") == \"fun is Python\"\n", "\nassert reverse_words(\"OpenAI GPT-4\") == \"GPT-4 OpenAI\"\n", "\nassert reverse_words(\"a b c d e\") == \"e d c b a\"\n", "\nassert reverse_words(\"singl... |
de6655ea55ab245e4c9ab18de3dea052 | [
{
"content": "On te donne une chaîne de caractères `equation` représentant une équation mathématique simple avec un seul opérateur, soit l'addition (`+`) soit la soustraction (`-`), et deux opérandes. Les opérandes sont des nombres à virgule flottante en notation scientifique. Ta tâche est d'écrire une fonction... | ["\nassert invert_equation(\"3.5 + 2.1\") == \"3.5 - 2.1\"\n", "\nassert invert_equation(\"7.0 - 3.2e1\") == \"7.0 + -3.2e1\"\n", "\nassert invert_equation(\"0.0 + 0.0\") == \"0.0 + 0.0\"\n", "\nassert invert_equation(\"1.23e-4 - 5.67e-5\") == \"1.23e-4 + -5.67e-5\"\n", "\nassert invert_equation(\"100 +50\") == \"100 -... |
add49acb8a8ac3a4be839c695a14d25d | [
{
"content": "On te donne une chaîne de caractères `input_string` et un dictionnaire `encoding_scheme` qui associe les caractères à leurs représentations binaires correspondantes. Implémente une fonction `custom_encoder` qui encode la chaîne `input_string` en utilisant le `encoding_scheme` fourni. Les caractère... | ["\nassert custom_encoder(\"abc\", {'a': '00', 'b': '01', 'c': '10'}) == \"000110\"\n", "\nassert custom_encoder(\"hello\", {'h': '100', 'e': '101', 'l': '110', 'o': '111'}) == \"100101110110111\"\n", "\nassert custom_encoder(\"test\", {'t': '11', 'e': '00', 's': '10'}) == \"110010\"\n", "\nassert custom_encoder(\"xyz\... |
19494c3a4737d912726e475c94286899 | [
{
"content": "On te demande d'implémenter une fonction `volume_of_spheroid` qui calcule le volume d'un sphéroïde étant donné ses rayons équatoriaux et polaires. La fonction doit gérer les valeurs d'entrée dans la plage de 0,01 à 1000,0 pour les deux rayons. Si les valeurs d'entrée sont en dehors de cette plage,... | ["\nassert volume_of_spheroid(1.0, 1.0) == (4.0 / 3.0) * math.pi * 1.0 ** 2 * 1.0\n", "\nassert volume_of_spheroid(0.01, 0.01) == (4.0 / 3.0) * math.pi * 0.01 ** 2 * 0.01\n", "\nassert volume_of_spheroid(1000.0, 1000.0) == (4.0 / 3.0) * math.pi * 1000.0 ** 2 * 1000.0\n", "\nassert volume_of_spheroid(500.0, 250.0) == (4... |
dc5ef7125f34d7047c6af3eec362911a | [
{
"content": "Implémente une classe Python nommée `Book` avec une méthode d'initialisation qui accepte trois paramètres : `title`, `author` et `year`. `title` et `author` doivent être des chaînes de caractères, et `year` doit être un entier. La classe doit également inclure une méthode `summary` qui renvoie une... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).summary() == \"Title: 1984, Author: George Orwell, Year: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).summary() == \"Title: To Kill a Mockingbird, Author: Harper Lee, Year: 1960\"\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzger... |
9c9162a82552969c8ae499220e8a4f47 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction `filter_words` qui traite chaque chaîne de caractères de la liste selon les règles suivantes :\n- Supprime tous les caractères non alphabétiques.\n- Supprime les espaces blancs en début et en fin de chaîne.... | ["\nassert filter_words([\"hello world\", \"123abc\", \"!@#\"]) == [\"helloworld\", \"abc\"]\n", "\nassert filter_words([\"Python3.8\", \"is\", \"awesome!\"]) == [\"Python\", \"is\", \"awesome\"]\n", "\nassert filter_words([\" Leading and trailing spaces \", \" \"]) == [\"Leadingandtrailingspaces\"]\n", "\nassert fi... |
06ec94fcf977f1588324882a40faeb1a | [
{
"content": "Étant donné un tableau d'entiers distincts `a` et un entier positif `k`, ta tâche est de trouver le `k`-ième plus petit élément du tableau. Le tableau aura au moins `k` éléments.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), le nombre d'éléments dans le tableau.\n- La... | ["\nassert kth_smallest_element([5, 3, 1, 6, 2], 3) == 3\n", "\nassert kth_smallest_element([10, 20, 30, 40, 50], 1) == 10\n", "\nassert kth_smallest_element([10, 20, 30, 40, 50], 5) == 50\n", "\nassert kth_smallest_element([7, 10, 4, 3, 20, 15], 4) == 10\n", "\nassert kth_smallest_element([12, 3, 5, 7, 19], 2) == 5\n"... |
c14dfd2339f0ae92975176b180331a83 | [
{
"content": "On te donne une liste d'entiers `arr` qui peut contenir des doublons et des nombres négatifs. Ta tâche est de mettre en œuvre une fonction qui renvoie les `k` plus petits entiers de la liste. Les entiers doivent être renvoyés par ordre croissant.\n\n**Entrée :**\n- La première ligne contient un en... | ["\nassert k_smallest_integers([7, 10, 4, 3, 20, 15], 3) == [3, 4, 7]\n", "\nassert k_smallest_integers([1, 2, 3, 4, 5], 2) == [1, 2]\n", "\nassert k_smallest_integers([5, 4, 3, 2, 1], 3) == [1, 2, 3]\n", "\nassert k_smallest_integers([-1, -2, -3, -4, -5], 4) == [-5, -4, -3, -2]\n", "\nassert k_smallest_integers([10, 2... |
353d6332816d84f1c948c3e30a30f7d2 | [
{
"content": "Tu gères un compte bancaire qui commence avec un solde de 0. On te donne une liste de transactions, où chaque transaction est représentée comme un tuple contenant un montant entier et une chaîne de caractères indiquant le type de transaction (\"dépôt\" ou \"retrait\"). Ta tâche est de calculer le ... | ["\nassert process_transactions([(100, \"deposit\"), (50, \"withdraw\"), (200, \"deposit\")]) == 250\n", "\nassert process_transactions([(50, \"withdraw\"), (100, \"deposit\")]) == 50\n", "\nassert process_transactions([(100, \"deposit\"), (100, \"deposit\"), (100, \"deposit\")]) == 300\n", "\nassert process_transactio... |
43574f39b05ebb4165ba94cbc8a85730 | [
{
"content": "On te donne une simulation simple d'un écosystème impliquant deux espèces : des prédateurs et des proies. L'écosystème commence avec un nombre spécifié de prédateurs et de proies. À chaque itération, la population de chaque espèce change selon les règles suivantes :\n\n- Si le nombre de proies est... | ["\nassert simulate_ecosystem(0, 0, 10) == (0, 0)\n", "\nassert simulate_ecosystem(10, 10, 0) == (10, 10)\n", "\nassert simulate_ecosystem(100, 100, 1) == (100, 100) or (simulate_ecosystem(100, 100, 1)[0] + simulate_ecosystem(100, 100, 1)[1] <= 500)\n", "\nassert simulate_ecosystem(10, 100, 100)[0] + simulate_ecosystem... |
c7678fde8d5a0a0b02f3e6a5957e9f5c | [
{
"content": "On te demande d'implémenter une fonction `generate_usage_string` qui construit une chaîne d'utilisation pour un outil en ligne de commande basée sur la spécification d'arguments fournie. La fonction doit respecter le format suivant :\n\n```\ncommand --arg ARG [--opt OPT] [VAR ...] [--KWARGS ...]\n... | ["\nassert generate_usage_string(\"cmd\", {'args': ['x'], 'annotations': {'x': int}}) == \"cmd x:int\"\n", "\nassert generate_usage_string(\"cmd\", {'args': ['x', 'y'], 'defaults': [1], 'annotations': {'x': int, 'y': float}}) == \"cmd x:int [y:float]\"\n", "\nassert generate_usage_string(\"cmd\", {'varargs': 'args', 'a... |
6243d077ef5ed007c99e6b42d5d3ae89 | [
{
"content": "On te donne pour tâche de créer une fonction Python qui met en place une structure de fichiers personnalisée pour le projet d'un utilisateur. La fonction doit utiliser un objet `tmpdir_factory` pour créer un répertoire principal nommé avec la chaîne de caractères \"custom_project\". À l'intérieur ... | ["\nassert os.path.exists(setup_custom_file_structure(tmpdir_factory, 0))\n", "\nassert os.path.exists(os.path.join(setup_custom_file_structure(tmpdir_factory, 10), \"main_file.txt\"))\n", "\nassert os.path.exists(os.path.join(setup_custom_file_structure(tmpdir_factory, 10), \"sub_directory\", \"sub_file.txt\"))\n", "\... |
9cf27449eafbc339892d0e8924bb5cb4 | [
{
"content": "On te demande de créer un emploi du temps pour un groupe d'étudiants. Chaque étudiant a une liste de cours préférés par ordre de préférence. Ton objectif est d'affecter chaque étudiant à l'un de leurs cours préférés. Il est garanti qu'il n'y a pas de conflits et que chaque étudiant peut être affec... | ["\nassert schedule_students({'Alice': ['Math', 'Science'], 'Bob': ['Science', 'History']}) == {'Alice': 'Math', 'Bob': 'Science'}\n", "\nassert schedule_students({'Charlie': ['Math', 'History'], 'David': ['Science', 'Math']}) == {'Charlie': 'Math', 'David': 'Science'}\n", "\nassert schedule_students({'Eve': ['Art'], '... |
47e2417852620f2b4b32813b864313c0 | [
{
"content": "On te donne une liste d'orbitales, chacune représentée comme un tuple `(group_id, system_index)`. Le `group_id` indique le groupe auquel l'orbitale appartient, et le `system_index` indique le système dans lequel l'orbitale réside. Les numéros d'orbitale ne sont pas uniques entre différents groupes... | ["\nassert transform_orbitals([(1, 0), (2, 0), (1, 1), (2, 1), (3, 1), (1, 2)], [1, 2, 3], ['System1', 'System2', 'System3']) == [[['System1', 'System1']], [['System2', 'System2']], [['System3', 'System3']]]\n", "\nassert transform_orbitals([(1, 0), (1, 0), (2, 0), (2, 1), (3, 1)], [1, 2, 3], ['System1', 'System2']) ==... |
ed800651185f08675b19bb95cb4ab6fa | [
{
"content": "On te donne une chaîne de caractères `text` et un entier `start`. Ta tâche est de déterminer si le caractère à l'index `start` dans la chaîne `text` fait partie d'une phrase entre parenthèses. Une phrase entre parenthèses est définie comme toute séquence de caractères enfermée entre des parenthèse... | ["\nassert is_in_parenthetical(10, \"John (who is a doctor) went to the store\") == True\n", "\nassert is_in_parenthetical(5, \"John (who is a doctor) went to the store\") == False\n", "\nassert is_in_parenthetical(25, \"John (who is a doctor) went to the store\") == False\n", "\nassert is_in_parenthetical(0, \"(This i... |
85f8e8ba02499d8bbaa2dd2911f60398 | [
{
"content": "On te donne un arbre binaire où chaque nœud contient un seul caractère. Ta tâche est d'effectuer une traversée préfixée de l'arbre et de renvoyer une liste de tous les nœuds qui contiennent une voyelle, triée par ordre décroissant de leur fréquence dans l'arbre. Si deux voyelles ont la même fréque... | ["\nassert pre_order_traversal(TreeNode('a')) == ['a']\n", "\nassert pre_order_traversal(TreeNode('b')) == []\n", "\nassert pre_order_traversal(TreeNode('a', TreeNode('e'), TreeNode('i'))) == ['a', 'i', 'e']\n", "\nassert pre_order_traversal(TreeNode('a', TreeNode('a'), TreeNode('a'))) == ['a']\n", "\nassert pre_order_... |
20e8fb16278c8b669af9b2112fc42fc6 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé de deux entiers. Ta tâche est de mettre en œuvre une fonction qui filtre tous les tuples où le deuxième élément est inférieur à 5. La fonction doit renvoyer une nouvelle liste contenant uniquement les tuples qui répondent aux critères.\n... | ["\nassert filter_tuples([(1, 10), (2, 4), (3, 7), (4, 2), (5, 8)]) == [(1, 10), (3, 7), (5, 8)]\n", "\nassert filter_tuples([(1, 3), (2, 2), (3, 1)]) == []\n", "\nassert filter_tuples([(1, 5), (2, 5), (3, 5)]) == [(1, 5), (2, 5), (3, 5)]\n", "\nassert filter_tuples([]) == []\n", "\nassert filter_tuples([(10, 10), (20,... |
63c221b293a288db59aeb414e288b9e0 | [
{
"content": "On te demande d'implémenter une fonction `parse_file_path(file_path)` qui traite les chemins de fichiers d'une manière compatible avec les systèmes Windows et Unix. La fonction doit gérer les chemins avec des barres obliques (`/`) et des barres obliques inverses (`\\`), ignorer les espaces blancs ... | ["\nassert parse_file_path(\" C:\\\\Users\\\\Example\\\\Documents\\\\file.txt \") == ('C:', '\\\\Users\\\\Example\\\\Documents', 'file.txt')\n", "\nassert parse_file_path(\" /home/user/documents/file.txt \") == ('', '/home/user/documents', 'file.txt')\n", "\nassert parse_file_path(\" C:/Users/Example/Documents/fil... |
aaa2a23a24fd93455e968225fc105ce9 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation (`__init__`)** : Créer un nouveau compte bancaire avec un solde initial de zéro.\n- **Dépôt (`deposit`)** : Ajouter un montant spécifié au solde du comp... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount().deposit(100) is None\n", "\nassert BankAccount().withdraw(0) is None\n", "\naccount = BankAccount(); account.deposit(100); assert account.get_balance() == 100\n", "\naccount = BankAccount(); account.deposit(100); account.withdraw(50); assert accoun... |
8aa3a942fa24b1452bca55227b19031c | [
{
"content": "On te demande d'implémenter une classe Python nommée `Employee` pour gérer les données des employés. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur doit accepter quatre paramètres : `name` (une chaîne de caractères), `employee_id` (un ent... | ["\nassert Employee(\"John Doe\", 123, \"HR\", 50000).name == \"John Doe\"\n", "\nassert Employee(\"John Doe\", 123, \"HR\", 50000).employee_id == 123\n", "\nassert Employee(\"John Doe\", 123, \"HR\", 50000).department == \"HR\"\n", "\nassert Employee(\"John Doe\", 123, \"HR\", 50000).salary == 50000\n", "\nassert Empl... |
39c9ff4fe41f7537e41737f8a830fff5 | [
{
"content": "On te demande d'implémenter une fonction `calculate_discounted_price(price, discount)` qui calcule le prix final d'un article après avoir appliqué un pourcentage de réduction donné. La fonction doit accepter deux paramètres : le prix initial de l'article et le pourcentage de réduction. Elle doit r... | ["\nassert calculate_discounted_price(100, 20) == 80.0\n", "\nassert calculate_discounted_price(250, 15) == 212.5\n", "\nassert calculate_discounted_price(0, 10) == 0.0\n", "\nassert calculate_discounted_price(100, 0) == 100.0\n", "\nassert calculate_discounted_price(100, 100) == 0.0\n", "\nassert calculate_discounted_... |
24a86968fe30658c0d15f24ea90febf8 | [
{
"content": "On te demande d'implémenter une classe Python `Employee` pour gérer les dossiers des employés. La classe doit répondre aux spécifications suivantes :\n\n- Implémente un constructeur `__init__` qui accepte trois paramètres : `name` (une chaîne de caractères), `employee_id` (un entier) et `position`... | ["\nassert Employee.company_name == \"Tech Solutions Inc.\"\n", "\nassert Employee(\"Alice\", 12345, \"Manager\").name == \"Alice\"\n", "\nassert Employee(\"Bob\", 67890, \"Developer\").employee_id == 67890\n", "\nassert Employee(\"Charlie\", 54321, \"Designer\").position == \"Designer\"\n", "\nassert Employee.validate... |
74194affac4fce3add0f77b4f19afc5e | [
{
"content": "On te donne une chaîne de caractères `id_string` qui représente un identifiant suivant un format spécifique : `[prefixYYYY-MM-DDsuffix]`. Ici, `prefix` est composé de lettres minuscules, `YYYY` est une année à quatre chiffres, `MM` est un mois à deux chiffres, et `DD` est un jour à deux chiffres. ... | ["\nassert parse_id(\"[abc2023-01-01xyz]\") == (\"abc\", 2023, 1, 1, \"xyz\")\n", "\nassert parse_id(\"[prefix2022-12-31suffix]\") == (\"prefix\", 2022, 12, 31, \"suffix\")\n", "\nassert parse_id(\"[a2021-06-15b]\") == (\"a\", 2021, 6, 15, \"b\")\n", "\nassert parse_id(\"[test2020-02-29]\") == (None, None, None, None, ... |
4b68b222d9bf1821270982193614feb1 | [
{
"content": "Étant donnés deux entiers positifs `n` et `k`, ta tâche est de déterminer la `k`-ième permutation lexicographiquement la plus petite des `n` premiers nombres naturels. La valeur de `n` peut être aussi grande que 10^4.\n\n**Entrée :**\n- La première ligne contient deux entiers `n` et `k` (1 ≤ n ≤ 1... | ["\nassert getKthPermutation(1, 1) == \"1\"\n", "\nassert getKthPermutation(2, 1) == \"12\"\n", "\nassert getKthPermutation(2, 2) == \"21\"\n", "\nassert getKthPermutation(3, 1) == \"123\"\n", "\nassert getKthPermutation(3, 2) == \"132\"\n", "\nassert getKthPermutation(3, 3) == \"213\"\n", "\nassert getKthPermutation(3... |
827a57e056e8e67674fbb4cc47a27eda | [
{
"content": "On te donne une grille 2D de taille `m x n` composée de `0` et de `1`. Chaque `1` représente de la terre, et chaque `0` représente de l'eau. Une île est définie comme un groupe de terres adjacentes (horizontalement, verticalement ou en diagonale) entourées d'eau. Ta tâche est de déterminer le nomb... | ["\nassert find_number_of_islands([[1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 1]]) == 3\n", "\nassert find_number_of_islands([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) == 0\n", "\nassert find_number_of_islands([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, ... |
c68fd4eec4ff2b3b3a36fc19cef68e52 | [
{
"content": "On te donne une liste non triée d'entiers `numbers` et un entier positif `k`. Ta tâche est de mettre en œuvre une fonction `find_kth_largest` qui renvoie le k-ième plus grand élément de la liste. Il est garanti que `1 <= k <= len(numbers)`.\n\n**Exemple d'entrée :**\n```\nnumbers = [3, 2, 1, 5, 6,... | ["\nassert find_kth_largest([3, 2, 1, 5, 6, 4], 2) == 5\n", "\nassert find_kth_largest([3, 2, 3, 1, 2, 4, 5, 5, 6], 4) == 4\n", "\nassert find_kth_largest([1], 1) == 1\n", "\nassert find_kth_largest([7, 7, 7, 7, 7, 7, 7], 3) == 7\n", "\nassert find_kth_largest([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 10) == 1\n", "\nassert fin... |
cf25b257982f0f0fd3f233e7e1459de8 | [
{
"content": "On te donne une grille 2D représentant un plan de ville où chaque cellule est soit un bâtiment ('1') soit un espace vide ('0'). Ta tâche est de générer trois nouvelles grilles basées sur la grille d'entrée :\n\n1. La première grille doit marquer toutes les cellules qui ont un espace vide à leur dr... | ["\nassert create_grids([['1', '1', '0'], ['0', '1', '0'], ['1', '0', '0']]) == ([[0, 1, 0], [1, 1, 0], [1, 1, 0]], [[1, 0, 1], [0, 1, 0], [0, 0, 0]], [[0, 1, 0], [1, 1, 0], [1, 1, 0]])\n", "\nassert create_grids([['1', '0'], ['0', '1']]) == ([[1, 0], [1, 0]], [[0, 1], [0, 0]], [[1, 0], [1, 0]])\n", "\nassert create_gr... |
544f012e27bd1bb0a89719c57a8d5de4 | [
{
"content": "On te donne une chaîne de caractères `text` et deux indices entiers `index1` et `index2`. Ta tâche est de mettre en œuvre une fonction `encryptionSwap` qui échange les caractères aux positions `index1` et `index2` dans la chaîne si les deux caractères sont alphabétiques et différents. Si l'un des ... | ["\nassert encryptionSwap(\"hello\", 1, 3) == \"hlleo\"\n", "\nassert encryptionSwap(\"world\", 0, 4) == \"dlrow\"\n", "\nassert encryptionSwap(\"python\", 2, 3) == \"pythno\"\n", "\nassert encryptionSwap(\"example\", 1, 1) == \"example\"\n", "\nassert encryptionSwap(\"example\", 1, 5) == \"examlpe\"\n", "\nassert encr... |
3eaa4af949ea39895cdedbecc702efc4 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif. La factorielle d'un entier non négatif \\( n \\) est le produit de tous les entiers positifs inférieurs ou égaux à \\( n \\). La factorielle de 0 est définie comme 1.\n\n**Entrée :**\n- Un seul... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(2) == 2\n", "\nassert factorial(3) == 6\n", "\nassert factorial(4) == 24\n", "\nassert factorial(5) == 120\n", "\nassert factorial(6) == 720\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factor... |
142f9bee5575128c65cfbe1bc5e21071 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour compter le nombre de nombres premiers inférieurs ou égaux à un entier donné `n`. Ta solution doit utiliser la méthode du crible d'Ératosthène.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 10^6)\n\n**Sortie :**\n- Un entier représentant le nombre... | ["\nassert count_primes(10) == 4\n", "\nassert count_primes(1) == 0\n", "\nassert count_primes(0) == 0\n", "\nassert count_primes(2) == 1\n", "\nassert count_primes(19) == 8\n", "\nassert count_primes(20) == 8\n", "\nassert count_primes(30) == 10\n", "\nassert count_primes(100) == 25\n", "\nassert count_primes(101) == ... |
a4f5759dc7789a2a8a57722f3037cd0f | [
{
"content": "On te donne un fichier JSON nommé `students.json` qui contient un tableau d'enregistrements d'étudiants. Chaque enregistrement d'étudiant est un objet avec les champs suivants : `id` (entier), `name` (chaîne de caractères), `email` (chaîne de caractères) et `scores` (tableau d'entiers représentant... | ["\nassert calculate_and_sort_student_scores('test1.json') == [{'id': 1, 'name': 'Alice', 'email': 'alice@example.com', 'scores': [90, 85, 95], 'average_score': 90.0}, {'id': 2, 'name': 'Bob', 'email': 'bob@example.com', 'scores': [70, 80, 85], 'average_score': 78.33333333333333}, {'id': 3, 'name': 'Charlie', 'email': ... |
2081e2004365c1fe22a150fb4fd758f7 | [
{
"content": "On te demande d'implémenter une application simple de liste de tâches en utilisant les principes de la programmation orientée objet. Ton programme doit prendre en charge les opérations suivantes :\n\n1. **Ajouter une tâche** : Ajouter une nouvelle tâche à la liste de tâches. Si la tâche est vide, ... | ["\nassert ToDoList().tasks == []\n", "\ntodo = ToDoList(); todo.add_task(\"Buy milk\"); assert todo.tasks == [\"Buy milk\"]\n", "\ntodo = ToDoList(); todo.add_task(\"Buy milk\"); todo.add_task(\"Read book\"); assert todo.tasks == [\"Buy milk\", \"Read book\"]\n", "\ntodo = ToDoList(); todo.add_task(\"Buy milk\"); todo... |
e609b4b0f0ed932f40b19bf39f80f029 | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Ta tâche est de mettre en œuvre une fonction `calculate_similarity` qui calcule l'indice de similarité de Jaccard entre ces deux chaînes. L'indice de similarité de Jaccard est défini comme la taille de l'intersection divisée par la taille d... | ["\nassert calculate_similarity(\"hello world\", \"hello world\") == 1.0\n", "\nassert calculate_similarity(\"hello world\", \"world hello\") == 1.0\n", "\nassert calculate_similarity(\"hello world\", \"hi there\") == 0.0\n", "\nassert calculate_similarity(\"a b c\", \"a b c d e f\") == 0.5\n", "\nassert calculate_simi... |
449b8d4618f8b77b83e5565e351cb8b2 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_largest_even` qui prend cette liste en entrée et renvoie le plus grand nombre pair présent dans la liste. S'il n'y a pas de nombres pairs dans la liste, la fonction doit renvoyer `None`.\n\n**Exemple d'entrée :**\n```\n... | ["\nassert find_largest_even([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 6\n", "\nassert find_largest_even([1, 3, 5, 7, 9]) == None\n", "\nassert find_largest_even([2, 4, 6, 8, 10]) == 10\n", "\nassert find_largest_even([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == 10\n", "\nassert find_largest_even([]) == None\n", "\nassert find_larg... |
4bc960624c63b2e116c7559f680d5aef | [
{
"content": "On te donne une grille rectangulaire de cellules, où chaque cellule est identifiée par une combinaison unique d'une lettre (colonne) et d'un nombre (ligne). La lettre correspond à l'indice de la colonne, en commençant par 'A' pour la première colonne, 'B' pour la deuxième colonne, et ainsi de suit... | ["\nassert get_cell_id('A1', [5, 4]) == 0\n", "\nassert get_cell_id('B3', [5, 4]) == 6\n", "\nassert get_cell_id('C4', [5, 4]) == 11\n", "\nassert get_cell_id('E4', [5, 4]) == 19\n", "\nassert get_cell_id('F1', [5, 4]) == None\n", "\nassert get_cell_id('A5', [5, 4]) == None\n", "\nassert get_cell_id('Z9', [26, 9]) == 2... |
5c625bb3143c6428f9f46a215699aad0 | [
{
"content": "On te donne une image rectangulaire représentée comme un tableau numpy 2D ou 3D `pixel_data`. Ta tâche est d'extraire une sous-image carrée du centre avec une longueur de côté égale à la plus petite dimension de l'image originale. La fonction doit gérer les images avec différentes profondeurs de c... | ["\nassert extract_square_sub_image(np.array([[1, 2], [3, 4]])).shape == (2, 2)\n", "\nassert np.array_equal(extract_square_sub_image(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))\n", "\nassert extract_square_sub_image(np.random.randint(0, 256, size=(50, 100, 3), dtype=np.ui... |
9b6b79d2a6a87e9fc3fe2ca05203a2b5 | [
{
"content": "On te donne la tâche d'écrire un script Python qui traite un fichier CSV pour calculer la valeur moyenne d'une colonne spécifiée. Ton script doit être exécuté via des arguments en ligne de commande, où le premier argument est le chemin d'accès au fichier CSV et le second argument est le nom de la ... | ["\nassert calculate_average(\"test.csv\", \"age\") == None # Assuming test.csv has an 'age' column with numeric values\n", "\nassert calculate_average(\"test.csv\", \"non_existent_column\") == None # Assuming test.csv does not have a 'non_existent_column'\n", "\nassert calculate_average(\"non_existent_file.csv\", \"... |
29fb18444b46438dc9c06aebc39f1496 | [
{
"content": "On te donne une liste d'entiers distincts. Ta tâche est d'écrire une fonction `generate_permutations` qui génère toutes les permutations possibles de la liste donnée. La fonction doit renvoyer une liste de tuples, où chaque tuple représente une permutation unique de la liste d'entrée. Tu es autori... | ["\nassert generate_permutations([1, 2, 3]) == [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]\n", "\nassert generate_permutations(['a', 'b', 'c']) == [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]\n", "\nassert generate_permutations([1]) == [(1... |
6abe5f7adfce9fc97e0b5b1a08e500a0 | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente les coordonnées d'un point dans un plan 2D. Ta tâche est de déterminer le point qui est le plus éloigné de l'origine (0, 0). La distance entre deux points \\((x_1, y_1)\\) et \\((x_2, y_2)\\) est calculée en utilisant la formule de distan... | ["\nassert farthest_from_origin([(1, 2), (3, 4), (-1, -1), (5, 5)]) == (5, 5)\n", "\nassert farthest_from_origin([(0, 0), (0, 0), (0, 0)]) == (0, 0)\n", "\nassert farthest_from_origin([(1, 1), (2, 2), (3, 3)]) == (3, 3)\n", "\nassert farthest_from_origin([(-3, -4), (3, 4), (0, 0)]) == (-3, -4)\n", "\nassert farthest_fr... |
5bf313cfb47917cbb77ef916e2173d0b | [
{
"content": "On te demande d'implémenter une fonction `calculate(op, a, b)` qui effectue des opérations arithmétiques en fonction de l'opérateur `op` et des opérandes `a` et `b`. La fonction doit prendre en charge les opérations suivantes : addition (`+`), soustraction (`-`), multiplication (`*`) et division (... | ["\nassert calculate('+', 5, 3) == 8\n", "\nassert calculate('-', 10, 4) == 6\n", "\nassert calculate('*', 6, 7) == 42\n", "\nassert calculate('/', 8, 2) == 4.0\n", "\nassert calculate('/', 8, 0) == None\n", "\nassert calculate('^', 2, 3) == None\n", "\nassert calculate('+', -5, -3) == -8\n", "\nassert calculate('-', 0... |
31afca500ece8bfdba324ee108e05f63 | [
{
"content": "On te demande d'implémenter une fonction `generate_report(data)` pour un système d'analyse des ventes. La fonction accepte une liste de dictionnaires, où chaque dictionnaire contient des données de vente avec les clés suivantes : 'product', 'quantity' et 'price'. Ton objectif est de calculer et de... | ["\nassert generate_report([{'product': 'apple', 'quantity': 10, 'price': 0.5}]) == {'total_sales': 5.0, 'total_quantity': 10, 'average_price': 0.5}\n", "\nassert generate_report([{'product': 'banana', 'quantity': 5, 'price': 0.3}, {'product': 'orange', 'quantity': 3, 'price': 0.7}]) == {'total_sales': 3.6, 'total_quan... |
62992dc5fa6233a90013d3d39d56b4cb | [
{
"content": "On te donne une liste de cours de bourse pour une entreprise spécifique, où chaque cours correspond au cours de clôture de l'action pour ce jour-là. Ta tâche est de déterminer le profit maximal qui aurait pu être réalisé en achetant l'action à son prix le plus bas et en la vendant à son prix le pl... | ["\nassert max_profit([100, 102, 101, 105, 107, 106, 108], 1, 7, 100) == 8.0\n", "\nassert max_profit([100, 102, 101, 105, 107, 106, 108], 1, 7, 101) == 7.920792079207921\n", "\nassert max_profit([100, 102, 101, 105, 107, 106, 108], 2, 5, 102) == 4.901960784313725\n", "\nassert max_profit([100, 102, 101, 105, 107, 106,... |
7b63d52a50b9d23d2fc878bb41e16901 | [
{
"content": "On te donne un fichier nommé `distances.txt` qui contient des informations sur les distances entre divers points dans un espace 2D. Chaque ligne du fichier est formatée comme `<point_a> <point_b> <distance>`, où `<point_a>` et `<point_b>` sont des coordonnées entières sous la forme `x,y`, et `<dis... | ["\nassert filter_distances(\"test_distances.txt\", 5) == [(10.0, (1, 2), (4, 6)), (8.0, (0, 0), (6, 6))]\n", "\nassert filter_distances(\"test_distances.txt\", 15) == [(10.0, (1, 2), (4, 6))]\n", "\nassert filter_distances(\"test_distances.txt\", 20) == []\n", "\nassert filter_distances(\"test_distances.txt\", 0) == [... |
8d276028ad45dfcdc99fe9c4030a5d55 | [
{
"content": "On te donne une matrice de dimensions R x C où chaque cellule contient un entier non négatif représentant le poids de cette cellule. Ta tâche est de trouver le chemin du coin supérieur gauche (1, 1) au coin inférieur droit (R, C) avec le poids total minimum. Tu ne peux te déplacer que vers la droi... | ["\nassert min_weight_path([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == 15\n", "\nassert min_weight_path([[1, 3, 1], [1, 5, 1], [4, 2, 1]]) == 7\n", "\nassert min_weight_path([[1, 2], [3, 4]]) == 6\n", "\nassert min_weight_path([[1]]) == 1\n", "\nassert min_weight_path([[1, 2, 3], [6, 5, 4], [7, 8, 9]]) == 15\n", "\nassert mi... |
8a8c9cb3c39be25f52f0cd35e9ee34be | [
{
"content": "On te demande d'implémenter une fonction `tokenize_special_chars` qui traite une chaîne de caractères donnée `text` en utilisant une fonction tokenizer fournie `tokenizer`. La fonction doit renvoyer une liste de tokens selon les règles suivantes :\n\n- Chaque token de la liste de sortie doit être ... | ["\nassert tokenize_special_chars(\"hello world\", lambda c: [c]) == ['h', 'e', 'l', 'l', 'o', '[BLANK]', 'w', 'o', 'r', 'l', 'd']\n", "\nassert tokenize_special_chars(\"abc\", lambda c: ['[INV]']) == ['[INV]', '[INV]', '[INV]']\n", "\nassert tokenize_special_chars(\"abc\", lambda c: []) == ['[INV]', '[INV]', '[INV]']\... |
77808335d66a8101888ab3d3b155897c | [
{
"content": "On te demande de concevoir un point de terminaison d'API RESTful qui fournit des informations météorologiques pour une ville spécifiée. Le point de terminaison doit accepter le nom d'une ville en tant que paramètre de requête et renvoyer une réponse JSON contenant la température, l'humidité et la ... | ["\nassert get_weather() == jsonify({'error': 'City parameter is required'}), 400\n", "\nassert get_weather(city=\"NonExistentCity\") == jsonify({'error': 'City not found'}), 404\n", "\nassert get_weather(city=\"London\")['json']['city'] == \"London\"\n", "\nassert isinstance(get_weather(city=\"London\")['json']['tempe... |
3e437a2ed11d66384966f4cc7d2d0a7a | [
{
"content": "On te donne les résultats d'une analyse statistique des scores des élèves à deux examens différents. L'analyse te fournit la statistique t et le nombre total d'élèves ayant passé les examens. De plus, on te fournit une liste de valeurs p correspondant à la statistique t pour chaque paire d'examens... | ["\nassert calculate_correlation(2.5, 30, [0.02]) == (0.4678284338945363, True)\n", "\nassert calculate_correlation(1.5, 20, [0.15]) == (0.3273268353539886, False)\n", "\nassert calculate_correlation(0, 10, [0.5]) == (0.0, False)\n", "\nassert calculate_correlation(3.0, 15, [0.01]) == (0.5547001962252291, True)\n", "\n... |
03b2c1f2a8ba6d12756e5545927ff443 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui supprime tous les entiers en double de la liste tout en préservant l'ordre d'origine des entiers restants.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^5), où chaque entier est dans la plage [-10... | ["\nassert remove_duplicates([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 2, 2, 3, 3]) == [1, 2, 3]\n", "\nassert remove_duplicates([5, 4, 3, 2, 1]) == [5, 4, 3, 2, 1]\n", "\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5, 5, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([]) == []\... |
a140817dbb91d4cca9bfd20c46baa149 | [
{
"content": "On te donne un entier `n`. Ta tâche est de déterminer si `n` est un facteur premier de 120 et aussi un facteur de la somme des 10 premiers entiers positifs. Un facteur premier est un facteur qui est aussi un nombre premier.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 120)\n\n**Sortie :**\n- Retourne... | ["\nassert is_prime_factor_of_120(2) == True\n", "\nassert is_prime_factor_of_120(3) == True\n", "\nassert is_prime_factor_of_120(5) == False\n", "\nassert is_prime_factor_of_120(7) == False\n", "\nassert is_prime_factor_of_120(10) == False\n", "\nassert is_prime_factor_of_120(11) == False\n", "\nassert is_prime_factor... |
f028302b769676769a238e91b75808ad | [
{
"content": "On te donne un processus géométrique aléatoire modifié où une série d'essais de Bernoulli indépendants sont menés jusqu'à ce que le premier succès se produise. Chaque essai a une probabilité de succès `p`. Le nombre d'essais nécessaires pour obtenir le premier succès est une variable aléatoire `X`... | ["\nassert simulate_geometric_process(0.5, 0.5) == 0\n", "\nassert simulate_geometric_process(0.25, 0.5) == 0\n", "\nassert simulate_geometric_process(0.75, 0.5) == 1\n", "\nassert simulate_geometric_process(0.99, 0.5) == 6\n", "\nassert simulate_geometric_process(0.01, 0.9) == 0\n", "\nassert simulate_geometric_proces... |
0a67835cd849522be0368a91955430c3 | [
{
"content": "On te demande d'implémenter une fonction nommée `is_server_online` qui détermine la disponibilité d'un serveur en envoyant une requête HEAD à une URL donnée. La fonction doit renvoyer `True` si le serveur répond avec un code d'état de 200, indiquant que le serveur est en ligne. Pour tout autre cod... | ["\nassert is_server_online(\"http://example.com\") == True\n", "\nassert is_server_online(\"https://example.com\") == True\n", "\nassert is_server_online(\"http://nonexistentwebsite123456789.com\") == False\n", "\nassert is_server_online(\"https://httpstat.us/200\") == True\n", "\nassert is_server_online(\"https://htt... |
0f8afab6af2e09bfd9a415eb5c9e64fc | [
{
"content": "On te donne une chaîne JSON bien formée représentant un livre. Ta tâche est d'analyser la chaîne JSON et d'extraire le titre, l'auteur et l'année de publication. Après avoir extrait les informations, renvoie une chaîne formatée dans le format \"Title: {title}, Author: {author}, Publication Year: {... | ["\nassert extract_book_info('{\"title\": \"1984\", \"author\": \"George Orwell\", \"publication_year\": 1949}') == \"Title: 1984, Author: George Orwell, Publication Year: 1949\"\n", "\nassert extract_book_info('{\"title\": \"Pride and Prejudice\", \"author\": \"Jane Austen\", \"publication_year\": 1813}') == \"Title: ... |
d632b6c934a06638b3464283cbe1cadb | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est d'implémenter une fonction `find_longest_palindrome(s)` qui renvoie la plus longue sous-chaîne palindromique dans `s`. La fonction doit utiliser une approche de force brute avec une complexité temporelle de O(N^2).\n\n**Contraintes :**\n- ... | ["\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",... |
25db12016688c337a5a92343918982ed | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui classifie ces entiers en deux catégories : premiers et non premiers. La fonction doit renvoyer deux listes distinctes contenant les nombres premiers et non premiers, respectivement.\n\n**Entrée :**\n- Une liste d'entier... | ["\nassert classify_numbers([2, 3, 4, 5, 16, 17, 18, 19]) == ([2, 3, 5, 17, 19], [4, 16, 18])\n", "\nassert classify_numbers([1, 0, -1, -5]) == ([], [1, 0, -1, -5])\n", "\nassert classify_numbers([29, 31, 37, 41]) == ([29, 31, 37, 41], [])\n", "\nassert classify_numbers([4, 6, 8, 9, 10]) == ([], [4, 6, 8, 9, 10])\n", "... |
d7101ecc1300d914e3ac5b7562493751 | [
{
"content": "On te donne un tableau trié d'entiers `arr` et un entier cible `target`. Ta tâche est de mettre en œuvre un algorithme de recherche binaire pour trouver l'indice de `target` dans le tableau. Si `target` n'est pas trouvé dans le tableau, retourne `-1`.\n\n**Entrée :**\n- La première ligne contient ... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([1], 1) == 0\n", "\nassert binary_search(... |
2a5d0910eba71ac6d621b8cb06c51e1a | [
{
"content": "On te donne une liste d'éléments, où chaque élément peut être une chaîne de caractères ou un élément non-chaîne (par exemple, un entier). Ta tâche est de traiter les éléments non-chaîne comme des séquences de leurs caractères individuels et de concaténer ces séquences en une seule liste de caractè... | ["\nassert find_overlapping_subsequences(['a', 'b', 'c', 'd'], 3) == [('a', 'b', 'c'), ('b', 'c', 'd')]\n", "\nassert find_overlapping_subsequences(['a', 123, 'c', 'd'], 3) == [('a', '1', '2'), ('1', '2', '3'), ('2', '3', 'c'), ('3', 'c', 'd')]\n", "\nassert find_overlapping_subsequences(['hello', 'world'], 2) == [('h'... |
df4b07a9da873db3e217067ed7f7884c | [
{
"content": "On te donne une liste de chaînes de caractères `words`. Ton objectif est d'implémenter une fonction `sort_and_remove_duplicates(words)` qui traite cette liste en supprimant toutes les chaînes de caractères en double, puis en triant les chaînes restantes par ordre alphabétique. La fonction doit ren... | ["\nassert sort_and_remove_duplicates([\"apple\", \"banana\", \"apple\", \"orange\"]) == [\"apple\", \"banana\", \"orange\"]\n", "\nassert sort_and_remove_duplicates([\"zebra\", \"dog\", \"cat\", \"dog\"]) == [\"cat\", \"dog\", \"zebra\"]\n", "\nassert sort_and_remove_duplicates([\"hello\", \"world\", \"hello\", \"worl... |
3cd8472546ccb83f8c4bc27163799bc4 | [
{
"content": "On te donne une image de dimensions `h_in` x `w_in` et une taille de patch `k`. Implémente la fonction `calculate_complexity` qui calcule la complexité computationnelle d'une opération de patchification 2D. La fonction doit gérer les cas où `h_in` et `w_in` ne sont pas divisibles par `k` en rempli... | ["\nassert calculate_complexity(14, 14, 2, 16, True) == (3136, 257, 196)\n", "\nassert calculate_complexity(15, 15, 3, 10, False) == (1500, 90, 100)\n", "\nassert calculate_complexity(10, 10, 5, 20, True) == (800, 501, 80)\n", "\nassert calculate_complexity(8, 8, 4, 32, False) == (512, 512, 64)\n", "\nassert calculate_... |
3a2f097492aee2fcdc8d6ed430545a2c | [
{
"content": "On te donne une liste de tuples, où chaque tuple contient le nom d'une personne (chaîne de caractères), son âge (entier) et son score (flottant). Ta tâche est d'écrire un programme Python qui trie cette liste en fonction d'une clé spécifiée par l'utilisateur. La clé peut être 'name' (nom), 'age' (... | ["\nassert sort_tuples_by_key([(\"Alice\", 30, 88.5), (\"Bob\", 25, 92.3)]) == [(\"Bob\", 25, 92.3), (\"Alice\", 30, 88.5)]\n", "\nassert sort_tuples_by_key([(\"Alice\", 30, 88.5), (\"Bob\", 25, 92.3)]) == [(\"Alice\", 30, 88.5), (\"Bob\", 25, 92.3)]\n", "\nassert sort_tuples_by_key([(\"Alice\", 30, 88.5), (\"Bob\", 25... |
10a3e12f0a5977f1d4ba07190815520a | [
{
"content": "On te donne une chaîne de caractères `S` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer le nombre de sous-chaînes alternées dans `S` qui ont une longueur d'au moins 3. Une sous-chaîne alternée est définie comme une sous-chaîne où aucun caractère adjacent n'est ide... | ["\nassert count_alternating_substrings(\"aabbaaabb\") == 7\n", "\nassert count_alternating_substrings(\"abc\") == 1\n", "\nassert count_alternating_substrings(\"ab\") == 0\n", "\nassert count_alternating_substrings(\"a\") == 0\n", "\nassert count_alternating_substrings(\"ababab\") == 10\n", "\nassert count_alternating... |
f09b6c9bb624756cf10ef8aaf46bce1e | [
{
"content": "On te donne deux entiers `a` et `n`. Ta tâche est de trouver l'inverse modulaire multiplicatif de `a` modulo `n`, qui est un entier `x` tel que `(a * x) % n == 1`. Si un tel entier n'existe pas, renvoie `None`. Implémente la fonction `find_modular_inverse(a, n)` efficacement sans utiliser les fonc... | ["\nassert find_modular_inverse(3, 11) == 4\n", "\nassert find_modular_inverse(10, 17) == 12\n", "\nassert find_modular_inverse(10, 20) == None\n", "\nassert find_modular_inverse(1, 1) == 0\n", "\nassert find_modular_inverse(7, 26) == 15\n", "\nassert find_modular_inverse(15, 26) == 7\n", "\nassert find_modular_inverse... |
f9e8cfbf7cc959a60d21e3c3af623470 | [
{
"content": "On te donne une liste d'animaux et de leurs catégories correspondantes. Ta tâche est d'implémenter une fonction `animal_to_one_hot` qui prend le nom d'un animal en entrée et renvoie un vecteur d'encodage one-hot représentant sa catégorie. Les catégories sont 'mammal', 'bird', 'reptile', 'fish' et ... | ["\nassert animal_to_one_hot('dog') == [1, 0, 0, 0, 0]\n", "\nassert animal_to_one_hot('sparrow') == [0, 1, 0, 0, 0]\n", "\nassert animal_to_one_hot('snake') == [0, 0, 1, 0, 0]\n", "\nassert animal_to_one_hot('salmon') == [0, 0, 0, 1, 0]\n", "\nassert animal_to_one_hot('frog') == [0, 0, 0, 0, 1]\n", "\nassert animal_to... |
caedd18b1fe7d98536f9694fa3cc3487 | [
{
"content": "Implémente une classe Python `Employee` avec les spécifications suivantes :\n\n- **Attributs :**\n - `name` : Une chaîne de caractères représentant le nom de l'employé.\n - `employee_id` : Un entier représentant l'identifiant de l'employé.\n - `salary` : Un flottant représentant le salaire de l... | ["\nassert Employee(\"John Doe\", 12345, 50000.0).name == \"John Doe\"\n", "\nassert Employee(\"John Doe\", 12345, 50000.0).employee_id == 12345\n", "\nassert Employee(\"John Doe\", 12345, 50000.0).salary == 50000.0\n", "\nemp = Employee(\"Jane Smith\", 67890, 60000.0)\nemp.give_raise(10000)\nassert emp.salary == 70000... |
7bb388c416ab79d8ad6613a8c88e292c | [
{
"content": "On te donne une liste de caractères `existing_chars`. Ta tâche est d'implémenter une fonction `unique_character_input(existing_chars: list) -> str` qui demande à l'utilisateur d'entrer une chaîne de caractères de manière répétée. La fonction doit vérifier si l'un des caractères de la chaîne d'entr... | ["\nassert unique_character_input(['a', 'b', 'c'], ['abc', 'def']) == 'def'\n", "\nassert unique_character_input(['x', 'y', 'z'], ['xyz', 'uvw']) == 'uvw'\n", "\nassert unique_character_input(['1', '2', '3'], ['123', '456']) == '456'\n", "\nassert unique_character_input(['a', 'b'], ['ab', 'cd', 'ef']) == 'ef'\n", "\nas... |
b369e3a279ca94ed41edd2d4c6e1217c | [
{
"content": "On te demande d'implémenter une fonction `word_frequency` qui traite un flux de données textuelles. L'entrée est un itérable (par exemple, un objet fichier ou un générateur) qui produit des lignes de texte. Ta fonction doit renvoyer un dictionnaire où les clés sont les mots uniques dans le texte e... | ["\nassert word_frequency([\"Hello, world!\", \"Hello again.\"]) == {\"hello\": 2, \"world\": 1, \"again\": 1}\n", "\nassert word_frequency([\"This is a test.\", \"This test is only a test.\"]) == {\"this\": 2, \"is\": 2, \"a\": 2, \"test\": 3, \"only\": 1}\n", "\nassert word_frequency([\"Python, Python, Python!\"]) ==... |
f91cddfa422516ae44aae0b843be6cb6 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction `find_common_elements` qui renvoie une liste contenant les éléments communs entre `list1` et `list2`. La fonction doit être efficace, avec une complexité temporelle de O(n + m), où n et m sont les l... | ["\nassert find_common_elements([1, 2, 3, 4], [3, 4, 5, 6]) == [3, 4]\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\nassert find_common_elements([], []) == []\n", "\nassert find_common_... |
83b54bef5b6109c018cdadaeec2a380d | [
{
"content": "On te donne pour tâche de traiter les points de code Unicode pour la sérialisation JSON. Implémente une fonction `filter_special_characters(codepoint)` qui prend un entier `codepoint` en entrée. Si le `codepoint` est un caractère spécial qui nécessite un échappement JSON, incrémente-le de 1 jusqu'... | ["\nassert filter_special_characters(31) == 32\n", "\nassert filter_special_characters(34) == 35\n", "\nassert filter_special_characters(92) == 93\n", "\nassert filter_special_characters(0xD800) == 0xDFFF + 1\n", "\nassert filter_special_characters(0xFDD0) == 0xFDEF + 1\n", "\nassert filter_special_characters(0xFFFE) =... |
37125a748c602f7e09ed68ac37f1e11b | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si `s` est un palindrome, en considérant uniquement les caractères alphanumériques et en ignorant la casse. Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"hello world\") == False\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_pali... |
5fdb0f25da6617ae2a705ce0f7ca44d8 | [
{
"content": "Tu développes un système pour traiter les données provenant d'un dispositif capteur. Le dispositif transmet des données sous forme de chaîne de caractères, chaque segment étant séparé par le caractère \"|\". L'un de ces segments contient des relevés de capteur encodés au format JSON. Chaque objet ... | ["\nassert process_sensor_data(\"device_id|{\\\"ch1\\\":\\\"123\\\",\\\"ch2\\\":\\\"456\\\",\\\"ch3\\\":\\\"789\\\"}|timestamp\") == {\"ch1\": 123, \"ch2\": 456, \"ch3\": 789}\n", "\nassert process_sensor_data(\"device_id|{\\\"ch1\\\":\\\"123\\\",\\\"ch2\\\":\\\"abc\\\",\\\"ch3\\\":\\\"789\\\"}|timestamp\") == {\"ch1\"... |
f03bfbaf7d63153ad1ea60953d26955f | [
{
"content": "On te donne une liste d'entiers `nums` et un entier non négatif `k`. Ta tâche est de faire pivoter la liste vers la droite de `k` pas sur place. La rotation doit être effectuée de telle sorte que les `k` derniers éléments de la liste soient déplacés au début, et que les éléments restants soient dé... | ["\nassert nums == [5, 6, 7, 1, 2, 3, 4]\n", "\nnums = [1, 2, 3, 4, 5, 6, 7]; k = 0; rotate_list(nums, k); assert nums == [1, 2, 3, 4, 5, 6, 7]\n", "\nnums = [1, 2, 3, 4, 5, 6, 7]; k = 7; rotate_list(nums, k); assert nums == [1, 2, 3, 4, 5, 6, 7]\n", "\nnums = [1, 2, 3, 4, 5, 6, 7]; k = 14; rotate_list(nums, k); assert... |
5cf17704d101d29d1bc87df6e75ee324 | [
{
"content": "On te demande d'implémenter un algorithme pour trouver tous les nombres premiers jusqu'à une limite donnée `n`. Ton programme doit déterminer efficacement la primalité des nombres en utilisant la méthode du crible d'Ératosthène.\n\n**Entrée :**\n- Un entier `n` (2 ≤ n ≤ 10^6), représentant la limi... | ["\nassert sieve_of_eratosthenes(10) == [2, 3, 5, 7]\n", "\nassert sieve_of_eratosthenes(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert sieve_of_eratosthenes(1) == []\n", "\nassert sieve_of_eratosthenes(2) == [2]\n", "\nassert sieve_of_eratosthenes(0) == []\n", "\nassert sieve_of_eratosthenes(30) == [2, 3, 5, 7, 11,... |
ec3f62e7c83a3bafd1894b96a1c5c987 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui filtre les nombres pairs de cette liste et renvoie une nouvelle liste contenant uniquement ces nombres pairs.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 1000), où chaque entier `num` satisfait -1000 ≤... | ["\nassert filter_even_numbers([1, 2, 3, 4, 5, 6]) == [2, 4, 6]\n", "\nassert filter_even_numbers([11, 22, 33, 44, 55]) == [22, 44]\n", "\nassert filter_even_numbers([0, -2, -3, -4, -5]) == [0, -2, -4]\n", "\nassert filter_even_numbers([]) == []\n", "\nassert filter_even_numbers([1, 3, 5, 7, 9]) == []\n", "\nassert fil... |
2160a2c6c617a7477b49e813eef4031c | [
{
"content": "Tu organises une série de réunions, chacune définie par une heure de début et une heure de fin. Pour accueillir toutes les réunions, tu dois déterminer le nombre minimum de salles de conférence nécessaires. Chaque personne ne peut pas utiliser la même salle pour des réunions consécutives. Étant do... | ["\nassert minMeetingRooms([[0, 30],[5, 10],[15, 20]]) == 2\n", "\nassert minMeetingRooms([[7,10],[2,4]]) == 1\n", "\nassert minMeetingRooms([[1,5],[8,9],[8,9]]) == 2\n", "\nassert minMeetingRooms([[1,3],[2,6],[8,10],[15,18]]) == 2\n", "\nassert minMeetingRooms([[1,2],[2,3],[3,4]]) == 1\n", "\nassert minMeetingRooms([[... |
b223819049b6022e8eaae81c7add59ee | [
{
"content": "On te donne une grille 2D représentant une carte où le drone peut se déplacer. Le drone part d'une position spécifique `(x, y)` et peut se déplacer dans l'une des quatre directions cardinales (haut, bas, gauche, droite) dans une plage spécifiée définie par le \"facteur de tremblement\". Le facteur... | ["\nassert simulate_drone_movement((0, 0), 1, [[0, 0], [0, 0]]) in [(0, 1), (1, 0)]\n", "\nassert simulate_drone_movement((1, 1), 1, [[0, 0, 0], [0, 1, 0], [0, 0, 0]]) in [(0, 1), (1, 0), (1, 2), (2, 1)]\n", "\nassert simulate_drone_movement((2, 2), 1, [[0, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0]]) in [(1, 2... |
951f85627467ff2149d226dcd21dde06 | [
{
"content": "On te donne une liste de nœuds, `all_nodes`, et deux réseaux, `fabric_A` et `fabric_B`. Chaque réseau est représenté comme une liste de connexions, où chaque connexion est un dictionnaire avec les clés `'node1'`, `'node2'`, et `'quality'`. Chaque nœud est représenté comme une chaîne de caractères,... | ["\nassert unconnected_nodes(['a', 'b', 'c'], [{'node1': 'a', 'node2': 'b', 'quality': 6}], []) == ['c']\n", "\nassert unconnected_nodes(['x', 'y', 'z'], [{'node1': 'x', 'node2': 'y', 'quality': 4}], [{'node1': 'y', 'node2': 'z', 'quality': 7}]) == ['x']\n", "\nassert unconnected_nodes(['m', 'n', 'o'], [{'node1': 'm', ... |
1cd97588190afd6743fd1cf45b5b5613 | [
{
"content": "On te donne une fonction continue `f(x)` et un intervalle `[a, b]`. Implémente la méthode de la sécante dans une fonction `find_root(f, a, b, eps)` qui trouve une racine de `f(x)` dans `[a, b]` en utilisant seulement deux points initiaux. La fonction doit renvoyer la racine si elle converge en 100... | ["\nassert find_root(lambda x: x**2 - 4, 1, 3, 1e-5) == 2.0\n", "\nassert find_root(lambda x: x**2 - 4, -3, -1, 1e-5) == -2.0\n", "\nassert find_root(lambda x: math.sin(x), 2, 4, 1e-5) == math.pi\n", "\nassert find_root(lambda x: math.cos(x) - x, 0, 1, 1e-5) is not None\n", "\nassert find_root(lambda x: x**3 - 2*x**2 +... |
220134762f7ae8dcc83c933ff81cbe1f | [
{
"content": "On te donne une liste triée d'entiers `nums` et un entier cible `target`. Ta tâche est de déterminer les indices de début et de fin de l'entier cible dans la liste. Si la cible n'est pas présente dans la liste, renvoie `[-1, -1]`. Implémente la fonction `find_range(nums, target)` qui effectue cett... | ["\nassert find_range([1, 2, 2, 2, 3, 4, 5], 2) == [1, 3]\n", "\nassert find_range([1, 2, 3, 4, 5, 6, 7], 5) == [4, 4]\n", "\nassert find_range([1, 2, 3, 4, 5, 6, 7], 8) == [-1, -1]\n", "\nassert find_range([], 1) == [-1, -1]\n", "\nassert find_range([1, 1, 1, 1, 1, 1, 1], 1) == [0, 6]\n", "\nassert find_range([1, 3, 5... |
14d419973621b9c308031e7c01ada76d | [
{
"content": "On te donne un fichier texte contenant du texte brut. Ta tâche est d'écrire un programme qui lit ce fichier, compte la fréquence de chaque mot, et affiche les 10 mots les plus courants ainsi que leurs fréquences. Les mots sont définis comme des séquences de caractères alphanumériques et sont insen... | ["\nassert count_words_in_file('test1.txt') == None\n", "\nassert count_words_in_file('test2.txt') == None\n", "\nassert count_words_in_file('empty.txt') == None\n", "\nassert count_words_in_file('single_word.txt') == None\n", "\nassert count_words_in_file('punctuation.txt') == None\n", "\nassert count_words_in_file('m... |
d4bdbc932dbc20d084fd7768211e4b10 | [
{
"content": "On te donne une chaîne de caractères `time` représentant une heure au format `HH:MM` ou `HH:MM:SS`. Les heures, les minutes et les secondes peuvent ou non avoir des zéros en tête. Ta tâche est de formater la chaîne de caractères de manière à ce que chaque composant (heures, minutes, secondes) ait ... | ["\nassert time_formatter(\"6:32\") == \"06:32\"\n", "\nassert time_formatter(\"12:4\") == \"12:04\"\n", "\nassert time_formatter(\"9:5\") == \"09:05\"\n", "\nassert time_formatter(\"6:32:15\") == \"06:32:15\"\n", "\nassert time_formatter(\"12:4:5\") == \"12:04:05\"\n", "\nassert time_formatter(\"9:5:6\") == \"09:05:06... |
74eb1bb29547b701becd8e1d5d0cf69e | [
{
"content": "On te donne une liste de noms de disques et une liste de noms de partitions. Chaque disque possède un identifiant unique, et chaque partition est associée à exactement un disque. Ta tâche est d'écrire une fonction qui prend un nom de partition en entrée et renvoie l'identifiant unique du disque au... | ["\nassert get_disk_id(\"Disk1\", \"partitiona\", disk_associations) == 'D1'\n", "\nassert get_disk_id(\"Disk2\", \"PartitionC\", disk_associations) == 'D2'\n", "\nassert get_disk_id(\"Disk3\", \"partitiond\", disk_associations) == 'D3'\n", "\nassert get_disk_id(\"Disk4\", \"partitione\", disk_associations) == 'D4'\n",... |
f5e216f70385274cab699b61f9e0cdc7 | [
{
"content": "On te demande d'implémenter une fonction `convert_to_html` qui transforme une liste de chaînes de caractères en une liste non ordonnée HTML. Chaque chaîne de caractères de la liste doit être encapsulée dans un élément de liste HTML. La fonction doit renvoyer la chaîne HTML complète représentant la... | ["\nassert convert_to_html([\"Item 1\", \"Item 2\", \"Item 3\"]) == \"<ul>\\n\\t<li>Item 1</li>\\n\\t<li>Item 2</li>\\n\\t<li>Item 3</li>\\n</ul>\"\n", "\nassert convert_to_html([]) == \"<ul>\\n</ul>\"\n", "\nassert convert_to_html([\"Single Item\"]) == \"<ul>\\n\\t<li>Single Item</li>\\n</ul>\"\n", "\nassert convert_t... |
e33f83306f526716949b7c499234e2d6 | [
{
"content": "On te donne une liste d'entiers. Implémente une fonction `calculate_average` qui calcule la moyenne de tous les entiers positifs de la liste. S'il n'y a pas d'entiers positifs, la fonction doit renvoyer `None`. Ta solution doit être efficace et gérer les cas limites de manière appropriée.\n\n**Exe... | ["\nassert calculate_average([1, 2, 3, 4, 5]) == 3.0\n", "\nassert calculate_average([-1, -2, -3, -4, -5]) == None\n", "\nassert calculate_average([0, 0, 0, 0]) == None\n", "\nassert calculate_average([10, -10, 20, -20, 30]) == 20.0\n", "\nassert calculate_average([5]) == 5.0\n", "\nassert calculate_average([-5, 0, 5])... |
91508943bb2bd78031b1b3670debaed7 | [
{
"content": "On te donne une chaîne de caractères `text` de 100 000 caractères maximum. Ta tâche est de mettre en œuvre une fonction `replace_special_characters` qui remplace toutes les occurrences du tiret (-), du tiret cadratin (–) et du tiret long (—) par un caractère espace. La fonction doit être optimisée... | ["\nassert replace_special_characters(\"hello-world\") == \"hello world\"\n", "\nassert replace_special_characters(\"hello\u2013world\") == \"hello world\"\n", "\nassert replace_special_characters(\"hello\u2014world\") == \"hello world\"\n", "\nassert replace_special_characters(\"hello-world\u2013again\u2014here\") == ... |
18a1c6334e4d157e138d42c32786ee8f | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est d'implémenter une fonction qui renvoie le produit maximal de trois nombres quelconques du tableau. Le tableau peut contenir des entiers positifs et négatifs.\n\n**Contraintes :**\n- La longueur du tableau `nums` est comprise entre 3 et 10^4.\n-... | ["\nassert maximum_product_of_three([1, 10, -5, 1, -100]) == 5000\n", "\nassert maximum_product_of_three([1, 2, 3]) == 6\n", "\nassert maximum_product_of_three([-10, -10, 5, 2]) == 500\n", "\nassert maximum_product_of_three([-1, -2, -3, -4]) == -6\n", "\nassert maximum_product_of_three([0, 2, 3, 5]) == 30\n", "\nassert... |
8262765e4900f7525666b2e6855c7e25 | [
{
"content": "On te charge d'analyser les statistiques d'une plateforme de réseaux sociaux. Les données sont fournies sous forme de dictionnaire `data` où chaque clé est un nom d'utilisateur et la valeur est un autre dictionnaire contenant les clés suivantes :\n\n- `\"most_liked\"` : Une liste de trois publicat... | ["\nassert get_top_posts(data, \"Alice\") == ([\"post1\", \"post2\", \"post3\"], [\"post4\", \"post5\"], [\"post6\", \"post7\"])\n", "\nassert get_top_posts(data, \"Bob\") == ([], [], [])\n", "\nassert get_top_posts({}, \"Alice\") == ([], [], [])\n", "\nassert get_top_posts({\"Charlie\": {\"most_liked\": [\"post1\"], \... |
8c61e29b99b419bdcaca71e7cd59723d | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_palindromes` qui calcule la somme de tous les nombres palindromiques inférieurs à `n`. Un nombre palindromique se lit de la même manière de gauche à droite et de droite à gauche. Par exemple, si `n` est 100, les nombres pa... | ["\nassert find_palindromes(10) == 45\n", "\nassert find_palindromes(20) == 100\n", "\nassert find_palindromes(100) == 495\n", "\nassert find_palindromes(1) == 0\n", "\nassert find_palindromes(0) == 0\n", "\nassert find_palindromes(11) == 45\n", "\nassert find_palindromes(101) == 540\n", "\nassert find_palindromes(1000... |
e33414b37cc83d32a7b98c211d9e1a9e | [
{
"content": "On te donne une liste de chaînes de caractères `sentences`. Ta tâche est de mettre en œuvre une fonction `count_words` qui renvoie un dictionnaire. Chaque clé du dictionnaire doit être un mot unique provenant des phrases, et la valeur correspondante doit être le nombre de fois que ce mot apparaît ... | ["\nassert count_words([\"Hello world!\", \"Hello there.\", \"World of wonders.\"]) == {'hello': 2, 'world': 2, 'there': 1, 'of': 1, 'wonders': 1}\n", "\nassert count_words([\"Python, Python, Python!\"]) == {'python': 3}\n", "\nassert count_words([\"A quick brown fox.\", \"The quick brown fox jumps over the lazy dog.\"... |
9da3693a072f55868d0fea1c046113b2 | [
{
"content": "Implémente une classe Python nommée `Book` qui encapsule les propriétés d'un livre : `title`, `author`, `publication_year` et `genre`. La classe doit fournir des méthodes getter et setter pour chaque propriété. De plus, implémente une méthode `get_summary` qui renvoie une chaîne formatée résumant ... | ["\nassert Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\").get_title() == \"1984\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\").get_author() == \"George Orwell\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\").get_publication_year() == 1949\n", "\nassert Book(\"1984\"... |
7b9a4851233044f6f64e813a5c5a2a41 | [
{
"content": "On te donne un entier positif `n`. Implémente une fonction `digit_sum(n)` qui calcule la somme des chiffres de `n`. Si cette somme est supérieure ou égale à 10, incrémente la somme du nombre de chiffres dans `n` et calcule récursivement la somme des chiffres de la nouvelle somme jusqu'à ce que le ... | ["\nassert digit_sum(99) == 3\n", "\nassert digit_sum(123) == 6\n", "\nassert digit_sum(456) == 15\n", "\nassert digit_sum(789) == 24\n", "\nassert digit_sum(1000) == 1\n", "\nassert digit_sum(111) == 6\n", "\nassert digit_sum(9) == 9\n", "\nassert digit_sum(12345) == 21\n", "\nassert digit_sum(111111) == 12\n", "\nass... |
82514505c6c2a7e02f0a5c99477d68f9 | [
{
"content": "On te demande d'analyser les performances de divers dispositifs de refroidissement. Chaque dispositif de refroidissement est soumis à plusieurs essais, et les résultats sont stockés dans un dataframe `df`. Chaque ligne du dataframe correspond à un seul essai, et les colonnes sont les suivantes :\n... | ["\nassert calculate_efficiency(pd.DataFrame({\n 'device_name': ['A', 'A', 'B', 'B'],\n 'Q_c (kW)': [10, 20, 15, 25],\n 'device_work (kW)': [5, 10, 6, 12],\n 'fan_work (kW)': [1, 2, 1, 2]\n})).equals(pd.DataFrame({\n 'device_name': ['A', 'A', 'B', 'B'],\n 'normalized_COP': [0.0, 1.0, 0.0, 1.0]\n}))\n"... |
bab16fb76d689d69537360b789bb02a5 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de créer une nouvelle liste où chaque élément est la somme de ses voisins dans la liste originale. Pour les premier et dernier éléments, considère uniquement leur voisin unique.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 10^3), où cha... | ["\nassert sum_of_neighbors([1, 2, 3, 4]) == [3, 6, 7, 7]\n", "\nassert sum_of_neighbors([10, 20, 30]) == [20, 40, 20]\n", "\nassert sum_of_neighbors([5]) == []\n", "\nassert sum_of_neighbors([1, 1, 1, 1, 1]) == [1, 2, 2, 2, 1]\n", "\nassert sum_of_neighbors([0, 0, 0, 0]) == [0, 0, 0, 0]\n", "\nassert sum_of_neighbors(... |
a6a11510e981de69afa8474888dd6de3 | [
{
"content": "On te donne un fichier CSV contenant des cours boursiers historiques. Le fichier CSV a le format suivant :\n\n```\nDate,Symbol1,Symbol2,Symbol3,...\n```\n\nTa tâche est d'écrire une fonction `process_csv(file_path)` qui lit le fichier CSV et renvoie un dictionnaire où chaque clé est une date et la... | ["\nassert process_csv('test1.csv') == {'2023-01-01': {'AAPL': 150.0, 'GOOGL': 2800.0}, '2023-01-02': {'AAPL': 151.0, 'GOOGL': 2810.0}}\n", "\nassert process_csv('test2.csv') == {'2023-01-01': {'AMZN': 3500.0, 'MSFT': 300.0}, '2023-01-02': {'AMZN': 3510.0, 'MSFT': 301.0}}\n", "\nassert process_csv('test3.csv') == {'202... |
aca84bc036c3b244d054cf2a01fed1f6 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence croissante dans la liste. Une sous-séquence croissante est définie comme une séquence où chaque élément est supérieur au précédent. S'il existe plusieurs sous-séquences de longueur maximale identique, retourne l'... | ["\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 18]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7, 7, 7]) == [7]\n", "\nassert longest_increasing_subsequence([1, 2, 3, 4, 5]) == [1, 2, 3, ... |
f537b6d08fe32eb03125b3bf9a774176 | [
{
"content": "On te donne une liste 2D `matrix` composée d'entiers et/ou de nombres à virgule flottante. Ton objectif est d'implémenter une fonction `matrix_round_sum(matrix)` qui effectue les opérations suivantes :\n\n1. Vérifie que `matrix` est une liste 2D où chaque élément est soit un entier, soit un flotta... | ["\nassert matrix_round_sum([[1, 2, 3], [4, 5, 6]]) == 21\n", "\nassert matrix_round_sum([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]]) == 22\n", "\nassert matrix_round_sum([[1.5, 2.5], [3.5, 4.5]]) == 12\n", "\nassert matrix_round_sum([[0, 0, 0], [0, 0, 0]]) == 0\n", "\nassert matrix_round_sum([[100]]) == 100\n", "\nassert matri... |
88bf615eeb7bdddb062f206aaa91492f | [
{
"content": "On te donne une liste d'entiers représentant l'altitude des points d'un paysage. L'eau s'écoule des altitudes plus élevées vers les altitudes plus basses jusqu'à ce qu'elle ne puisse plus s'écouler vers le bas. Pour chaque point du paysage, détermine la quantité d'eau qui s'y accumulera après que ... | ["\nassert calculate_water([3, 2, 1, 3, 2, 1, 2, 3]) == [0, 1, 2, 0, 1, 2, 1, 0]\n", "\nassert calculate_water([1, 2, 3, 4, 5]) == [0, 0, 0, 0, 0]\n", "\nassert calculate_water([5, 4, 3, 2, 1]) == [0, 0, 0, 0, 0]\n", "\nassert calculate_water([2, 1, 2]) == [0, 1, 0]\n", "\nassert calculate_water([1, 0, 1]) == [0, 1, 0]... |
4ab8a68931853b4a3d92de34ab88c1f4 | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots anglais séparés par des espaces et de la ponctuation. Ta tâche est de mettre en œuvre une fonction `word_frequencies` qui renvoie un dictionnaire avec la fréquence de chaque mot dans le texte, en excluant les mots vides anglais courant... | ["\nassert word_frequencies(\"The quick brown fox jumps over the lazy dog.\") == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nassert word_frequencies(\"The dog was not amused. The dog was sleeping.\") == {'dog': 2, 'was': 2, 'not': 1, 'amused': 1, 'sleeping': 1}\n", "\nassert wo... |
4a8d1cfc31edb8d58b7bb56417b8d04b | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de calculer efficacement la somme des `n` premiers nombres naturels. Pour ce faire, utilise une formule mathématique au lieu d'une approche itérative.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^9).\n\n**Sortie :**\n- Affiche la somme des `n` p... | ["\nassert sum_of_natural_numbers(1) == 1\n", "\nassert sum_of_natural_numbers(5) == 15\n", "\nassert sum_of_natural_numbers(10) == 55\n", "\nassert sum_of_natural_numbers(100) == 5050\n", "\nassert sum_of_natural_numbers(0) == 0\n", "\nassert sum_of_natural_numbers(1000) == 500500\n", "\nassert sum_of_natural_numbers(... |
323b2684b1dd19874b18dee4d90f07fa | [
{
"content": "On te donne une liste d'adresses IP en notation décimale pointée. Ta tâche est de classifier chaque adresse IP dans l'une des cinq classes (A, B, C, D, E) en fonction de la plage numérique de son premier octet. De plus, identifie toutes les adresses IP invalides. Retourne un dictionnaire avec le n... | ["\nassert classify_ip_addresses([\"192.168.1.1\"]) == {'A': 0, 'B': 0, 'C': 1, 'D': 0, 'E': 0, 'Invalid': 0}\n", "\nassert classify_ip_addresses([\"10.0.0.1\"]) == {'A': 1, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'Invalid': 0}\n", "\nassert classify_ip_addresses([\"172.16.0.1\"]) == {'A': 0, 'B': 1, 'C': 0, 'D': 0, 'E': 0, 'I... |
001db8e958457ab6dfb0e6c509e9b19a | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `fibonacci_sum_iteration(n)` qui calcule la somme des `n` premiers nombres de Fibonacci. La fonction doit fonctionner avec un espace constant et avoir une complexité temporelle de O(n).\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ ... | ["\nassert fibonacci_sum_iteration(0) == 0\n", "\nassert fibonacci_sum_iteration(1) == 1\n", "\nassert fibonacci_sum_iteration(2) == 1\n", "\nassert fibonacci_sum_iteration(3) == 2\n", "\nassert fibonacci_sum_iteration(4) == 4\n", "\nassert fibonacci_sum_iteration(5) == 7\n", "\nassert fibonacci_sum_iteration(6) == 12\... |
12947b113ee3e80776f74f3374ee45ec | [
{
"content": "On te donne une liste de points 4D dans l'espace, représentés comme une liste de tuples, où chaque tuple contient quatre entiers. Ta tâche est de trouver les deux points qui ont la distance de Mahalanobis maximale entre eux. La distance de Mahalanobis est calculée en utilisant une matrice de covar... | ["\nassert max_mahalanobis_distance([(1, 1, 1, 1), (2, 2, 2, 2)]) == 0\n", "\nassert max_mahalanobis_distance([(1, 0, 0, 0), (0, 1, 0, 0)]) == float('inf')\n", "\nassert max_mahalanobis_distance([(1, 2, 3, 4), (4, 3, 2, 1)]) == np.sqrt(30)\n", "\nassert max_mahalanobis_distance([(1, 1, 1, 1), (1, 1, 1, 2)]) == 1\n", "\... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.