id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
259fa56a300a43516515eedee9c55bbd | [
{
"content": "On te donne un dictionnaire imbriqué où chaque clé est une chaîne de caractères et chaque valeur est soit une chaîne de caractères, soit un autre dictionnaire imbriqué. Ta tâche est d'écrire une fonction qui aplatit ce dictionnaire imbriqué en un dictionnaire de niveau unique. Les clés dans le dic... | ["\nassert flatten_dict({\"a\": \"b\", \"c\": {\"d\": \"e\"}}) == {\"a\": \"b\", \"c-d\": \"e\"}\n", "\nassert flatten_dict({\"x\": {\"y\": {\"z\": \"w\"}}}, \"_\") == {\"x_y_z\": \"w\"}\n", "\nassert flatten_dict({\"single\": \"value\"}) == {\"single\": \"value\"}\n", "\nassert flatten_dict({}) == {}\n", "\nassert fla... |
b944ae87a5734bf96f2c7c8ea05a63e3 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne est composée d'une combinaison d'alphabets et de nombres. Ta tâche est de trier cette liste dans un ordre \"naturel\". Dans le tri naturel, les nombres à l'intérieur des chaînes sont triés numériquement, et non lexicographiquement. P... | ["\nassert natural_sort([\"z10\", \"z2\", \"z1\"]) == [\"z1\", \"z2\", \"z10\"]\n", "\nassert natural_sort([\"a1\", \"a10\", \"a2\"]) == [\"a1\", \"a2\", \"a10\"]\n", "\nassert natural_sort([\"file10\", \"file2\", \"file1\"]) == [\"file1\", \"file2\", \"file10\"]\n", "\nassert natural_sort([\"item20\", \"item3\", \"ite... |
124f87a4d662d573e647f67441834f37 | [
{
"content": "On te donne une liste de livres, où chaque livre est représenté comme un dictionnaire avec les clés suivantes : 'title', 'author', 'genre' et 'contributors'. La clé 'contributors' contient une liste de dictionnaires, où chaque dictionnaire représente un contributeur au livre et possède les clés su... | ["\nassert get_contributor_names([{'title': 'Book1', 'author': 'Author1', 'genre': 'Fiction', 'contributors': [{'role': 'author', 'name': 'Author1'}]}]) == [['Author1']]\n", "\nassert get_contributor_names([{'title': 'Book2', 'author': 'Author2', 'genre': 'Non-Fiction', 'contributors': [{'role': 'translator', 'name': '... |
287dfd2a30a7be5f17b39059408a960a | [
{
"content": "On te donne une liste d'entiers et un entier positif `chunk_size`. Ta tâche est d'implémenter une fonction `split_into_chunks` qui divise la liste en sous-listes, chacune contenant `chunk_size` éléments. Si la liste ne peut pas être divisée uniformément, la dernière sous-liste doit contenir les él... | ["\nassert split_into_chunks([1, 2, 3, 4, 5, 6, 7, 8, 9], 3) == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", "\nassert split_into_chunks([1, 2, 3, 4, 5, 6, 7, 8, 9], 4) == [[1, 2, 3, 4], [5, 6, 7, 8], [9]]\n", "\nassert split_into_chunks([1, 2, 3, 4, 5, 6, 7, 8], 2) == [[1, 2], [3, 4], [5, 6], [7, 8]]\n", "\nassert split_into... |
db71a036037bb119e638fcb8ccd51d98 | [
{
"content": "Étant donné deux entiers positifs `a` et `b`, écris une fonction pour calculer leur plus petit commun multiple (PPCM) en utilisant l'algorithme euclidien. Ton implémentation ne doit pas utiliser de boucles ou de récursion. Tu peux utiliser le module `math` pour toutes les opérations nécessaires.\n... | ["\nassert lcm(12, 18) == 36\n", "\nassert lcm(5, 7) == 35\n", "\nassert lcm(21, 6) == 42\n", "\nassert lcm(0, 5) == 0\n", "\nassert lcm(15, 0) == 0\n", "\nassert lcm(8, 12) == 24\n", "\nassert lcm(1, 1) == 1\n", "\nassert lcm(100, 25) == 100\n", "\nassert lcm(7, 3) == 21\n", "\nassert lcm(13, 17) == 221\n"] |
3178134735a3691311c6188f9937ad80 | [
{
"content": "On te donne une liste d'images, où chaque image est représentée comme un tableau 3D de valeurs de pixels. Chaque pixel est un tuple de trois ou quatre entiers représentant les valeurs de couleur rouge, verte et bleue, et éventuellement un canal alpha pour la transparence. La plage de chaque valeur... | ["\nassert average_color([]) == (0, 0, 0)\n", "\nassert average_color([[[[255, 0, 0, 255]]]]) == (255, 0, 0)\n", "\nassert average_color([[[[0, 255, 0, 255]]]]) == (0, 255, 0)\n", "\nassert average_color([[[[0, 0, 255, 255]]]]) == (0, 0, 255)\n", "\nassert average_color([[[[255, 255, 255, 255]]]]) == (255, 255, 255)\n"... |
d8ae5a264e59a83fa1f3c21d2387d085 | [
{
"content": "On te donne un tableau `arr` de `n` entiers. On te donne également `m` requêtes, où chaque requête est un triplet d'entiers `(a, b, k)`. Pour chaque requête, tu dois ajouter `k` à tous les éléments du tableau `arr` aux indices premiers compris dans l'intervalle `[a, b]` (inclus). Ta tâche est de d... | ["\nassert process_queries([0, 0, 0, 0, 0], [(0, 4, 1)]) == 1\n", "\nassert process_queries([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [(2, 8, 2)]) == 2\n", "\nassert process_queries([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [(1, 5, 3), (2, 8, 2), (6, 9, 1)]) == 5\n", "\nassert process_queries([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [(0, 9, 1)]) ... |
ea84e534c5244a3c50e5bf4d4dc93d6a | [
{
"content": "On te donne une liste 2D représentant une matrice. Ta tâche est d'écrire une fonction `transpose_matrix(matrix)` qui renvoie la transposée de la matrice donnée. La transposée d'une matrice est obtenue en échangeant ses lignes avec ses colonnes. Ta fonction doit gérer les matrices de n'importe quel... | ["\nassert transpose_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [[1, 4, 7], [2, 5, 8], [3, 6, 9]]\n", "\nassert transpose_matrix([[1, 2], [3, 4], [5, 6]]) == [[1, 3, 5], [2, 4, 6]]\n", "\nassert transpose_matrix([[1, 2, 3], [4, 5, 6]]) == [[1, 4], [2, 5], [3, 6]]\n", "\nassert transpose_matrix([[1]]) == [[1]]\n", "\n... |
fcff10aa64d9368687e38bc9ee78f51f | [
{
"content": "On te demande d'implémenter une fonction Python pour calculer la factorielle d'un entier non négatif donné `n`. Pour améliorer les performances, ta fonction doit utiliser la mémoïsation. Ta fonction doit renvoyer la factorielle de `n`.\n\n**Entrée :**\n- Un seul entier `n` (0 ≤ n ≤ 20).\n\n**Sorti... | ["\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(10) == 3628800\n", "\nassert factorial(15) == 1307674368000\n", "\nass... |
8a31976a7bf2d7354afbdd4886321c8d | [
{
"content": "On te demande d'implémenter une fonction `rename_files_in_directory` qui effectue des opérations de renommage de fichiers de manière concurrente en utilisant soit des threads, soit des processus multiples. La fonction doit renommer tous les fichiers d'un répertoire spécifié en remplaçant leurs ext... | ["\nassert rename_files_in_directory(\"/tmp/testdir\", \".txt\") == 3\n", "\nassert rename_files_in_directory(\"/tmp/testdir\", \".md\") == 2\n", "\nassert rename_files_in_directory(\"/tmp/testdir\", \".log\") == 0\n", "\nassert rename_files_in_directory(\"/tmp/testdir\", \".bak\") == 5\n", "\nassert rename_files_in_di... |
c43bfb7d46c2fa0ec251d830d4fe7459 | [
{
"content": "On te donne une chaîne de caractères `template` et un dictionnaire `kwargs` contenant des paires clé-valeur. Ta tâche est de mettre en œuvre une fonction `custom_html_template` qui remplace les espaces réservés dans le `template` par les valeurs correspondantes de `kwargs`. Avant le remplacement, ... | ["\nassert custom_html_template(\"Hello, <name>!\", {\"name\": \"Alice\"}) == \"Hello, Alice!\"\n", "\nassert custom_html_template(\"Welcome, <user>!\", {\"user\": \"Bob & Charlie\"}) == \"Welcome, Bob & Charlie!\"\n", "\nassert custom_html_template(\"Visit <site> for more info.\", {\"site\": \"example.com\"}) == \... |
3cf477946b4beba6e85ee4fea5971fbf | [
{
"content": "On te donne un dictionnaire `languages_dict` où chaque clé est une chaîne de caractères représentant un langage de programmation et chaque valeur est un entier représentant le nombre de lignes de code écrites dans ce langage. Ta tâche est de créer une fonction `standardize_and_sort_languages` qui ... | ["\nassert standardize_and_sort_languages({\"Python \": 123, \"java\": 456, \"C++\": 789, \"JavaScript \": 101, \" Ruby\": 202, \"Go!\": 303}) == {'c': 789, 'go': 303, 'javascript': 101, 'python': 123, 'ruby': 202}\n", "\nassert standardize_and_sort_languages({\"C#\": 100, \"Python3\": 200, \"Java8\": 300}) == {'c': 10... |
66a573d0d1bf94536d44f9f74ef3a709 | [
{
"content": "On te donne un ensemble de données de taille `data_size` et une taille de lot `batch_size`. Implémente une fonction `get_batch_indices(data_size, batch_index, batch_size, random_data=False, cyclic_data=False)` qui renvoie une liste de `batch_size` indices de l'ensemble de données ainsi que le nomb... | ["\nassert get_batch_indices(10, 0, 3) == ([0, 1, 2], 3)\n", "\nassert get_batch_indices(10, 1, 3) == ([3, 4, 5], 3)\n", "\nassert get_batch_indices(10, 3, 3) == ([9], 1)\n", "\nassert get_batch_indices(10, 3, 3, cyclic_data=True) == ([9, 0, 1], 1)\n", "\nassert get_batch_indices(10, 0, 15, cyclic_data=True) == (list(r... |
90a2f342b4f022a2dacecdda850a16ee | [
{
"content": "On te donne une liste d'entiers `numbers` représentant les longueurs de différentes tables. Ta tâche est de trier ces longueurs par ordre décroissant en fonction de la somme de leurs facteurs premiers. Tu dois créer deux listes supplémentaires : `idx_sorted` et `idx_map_back`.\n\n- `idx_sorted` es... | ["\nassert sort_tables([8, 12, 9, 27, 25]) == ([3, 2, 4, 1, 0], [27, 12, 25, 9, 8], [3, 4, 1, 2, 0])\n", "\nassert sort_tables([2, 3, 5, 7, 11]) == ([0, 1, 2, 3, 4], [2, 3, 5, 7, 11], [0, 1, 2, 3, 4])\n", "\nassert sort_tables([15, 21, 33, 49, 77]) == ([2, 1, 4, 3, 0], [33, 21, 77, 49, 15], [4, 1, 0, 3, 2])\n", "\nasse... |
44f79e67e13a88c9cda9bf6c70ddbee2 | [
{
"content": "On te donne deux vecteurs creux, `v1` et `v2`, représentés sous forme de dictionnaires où les clés sont les indices et les valeurs sont les éléments non nuls correspondants. Ta tâche est de calculer le produit scalaire de ces deux vecteurs efficacement. S'il n'y a pas d'indices non nuls communs, l... | ["\nassert dot_product_sparse({1: 2, 2: 3}, {2: 4, 3: 5}) == 12\n", "\nassert dot_product_sparse({0: 1, 1: 2, 2: 3}, {0: 4, 1: 5, 2: 6}) == 32\n", "\nassert dot_product_sparse({1: 10, 2: 20}, {3: 30, 4: 40}) == 0\n", "\nassert dot_product_sparse({}, {1: 1, 2: 2}) == 0\n", "\nassert dot_product_sparse({1: 1, 2: 2}, {}) ... |
7f7b791754f4b973464fc3b1f9fb69ea | [
{
"content": "On te donne un fichier CSV avec une ligne d'en-tête. Ta tâche est d'écrire une fonction Python qui lit ce fichier et calcule la somme de toutes les valeurs numériques dans la deuxième colonne. Si une valeur dans la deuxième colonne n'est pas un nombre, elle doit être ignorée. La fonction doit renv... | ["\nassert sum_second_column('test1.csv') == 15.0\n", "\nassert sum_second_column('test2.csv') == 0.0\n", "\nassert sum_second_column('test3.csv') == 3.5\n", "\nassert sum_second_column('test4.csv') == 100.0\n", "\nassert sum_second_column('test5.csv') == 2.0\n", "\nassert sum_second_column('test6.csv') == 10.0\n", "\n... |
3b8d380a6b8f7cdd640cd86d558dab5f | [
{
"content": "On te demande d'implémenter une fonction `parse_logfile(log_file_path)` qui traite un fichier journal et organise les entrées du journal en fonction de leurs niveaux de gravité. Chaque entrée de journal est formatée comme `timestamp - severity - message`, où `timestamp` est une chaîne de caractère... | ["\nassert parse_logfile(\"test_log1.txt\") == {'INFO': ['System started'], 'WARNING': ['Low disk space'], 'ERROR': ['System crash']}\n", "\nassert parse_logfile(\"test_log2.txt\") == {'INFO': [], 'WARNING': [], 'ERROR': []}\n", "\nassert parse_logfile(\"test_log3.txt\") == {'INFO': ['System started', 'User logged in']... |
4c79e8bb2ce806215d3be8b1d820d087 | [
{
"content": "On te donne un tableau `nums` contenant `n` nombres distincts pris dans la plage de `0` à `n`. Ta tâche est de trouver le nombre qui manque dans le tableau. Le tableau n'est pas forcément trié.\n\n**Entrée :**\n- La première ligne contient un entier `n` (0 ≤ n ≤ 10^4), la longueur du tableau.\n- L... | ["\nassert find_missing_number([3, 0, 1]) == 2\n", "\nassert find_missing_number([9, 6, 4, 2, 3, 5, 7, 0, 1]) == 8\n", "\nassert find_missing_number([0]) == 1\n", "\nassert find_missing_number([1]) == 0\n", "\nassert find_missing_number([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) == 10\n", "\nassert find_missing_number([10, 9, 8, ... |
20878da6a9cfe359ef5fd4da57499ece | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction récursive `reverse_string` qui renvoie une nouvelle chaîne avec tous les caractères de `s` inversés. La fonction doit gérer les chaînes de n'importe quelle longueur, y compris les chaînes vides.\n\n**Entrée :**\n- Une seu... | ["\nassert reverse_string(\"hello\") == \"olleh\"\n", "\nassert reverse_string(\"world\") == \"dlrow\"\n", "\nassert reverse_string(\"a\") == \"a\"\n", "\nassert reverse_string(\"\") == \"\"\n", "\nassert reverse_string(\"racecar\") == \"racecar\"\n", "\nassert reverse_string(\"Python\") == \"nohtyP\"\n", "\nassert rev... |
55b12dc1d1ec135bda41815e07a415ec | [
{
"content": "On te demande d'implémenter un système simple de gestion de bibliothèque en utilisant une classe Python. Le système doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un livre** : Ajouter un livre à la bibliothèque s'il n'est pas déjà présent.\n2. **Emprunter un livre** : Permettre ... | ["\nassert 'Python Programming' not in library.borrowed_books\n", "\nassert 'Python Programming' in library.available_books\n", "\nlibrary.add_book('Python Programming')\nassert 'Python Programming' in library.available_books\n", "\nlibrary.borrow_book('Python Programming')\nassert 'Python Programming' in library.borro... |
bf15c7a54a4222cf7a9057c905e79095 | [
{
"content": "On te donne une chaîne de caractères `input_string` et une `secret_key`. Ta tâche est de créer une fonction `generate_sha256_id` qui génère un identifiant unique pour la `input_string` en utilisant l'algorithme de hachage SHA-256. La `secret_key` doit être ajoutée à la `input_string` avant le hach... | ["\nassert generate_sha256_id(\"hello\", \"world\") == \"10_2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824\"\n", "\nassert generate_sha256_id(\"openai\", \"gpt\") == \"9_3b8b32ad1e797f06d830745a7a601478fc2d79e8e8d6949e82355f1b1d64627c\"\n", "\nassert generate_sha256_id(\"\", \"secret\") == \"6_5e88489... |
bb7ed8d118aaa03209bcd12c3ec43d3f | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui calcule la somme de tous les nombres pairs de la liste. La fonction doit être à la fois efficace et facile à lire.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^5), où chaque entier `num` s... | ["\nassert sum_of_even_numbers([1, 2, 3, 4, 5, 6]) == 12\n", "\nassert sum_of_even_numbers([2, 4, 6, 8, 10]) == 30\n", "\nassert sum_of_even_numbers([1, 3, 5, 7, 9]) == 0\n", "\nassert sum_of_even_numbers([-2, -4, -6, -8, -10]) == -30\n", "\nassert sum_of_even_numbers([0, 0, 0, 0]) == 0\n", "\nassert sum_of_even_number... |
da8eb40a6869b6b694f11be074992106 | [
{
"content": "On te demande d'implémenter une fonction qui analyse un texte donné et génère un rapport des 10 mots les plus fréquemment rencontrés. La fonction doit ignorer la casse et ne considérer que les caractères alphanumériques comme faisant partie des mots.\n\n**Entrée :**\n- Une seule chaîne de caractèr... | ["\nassert word_frequency_report(\"hello world hello\") == [('hello', 2), ('world', 1)]\n", "\nassert word_frequency_report(\"a a a b b c\") == [('a', 3), ('b', 2), ('c', 1)]\n", "\nassert word_frequency_report(\"one two three four five six seven eight nine ten eleven\") == [('one', 1), ('two', 1), ('three', 1), ('four... |
fd31609c0fe68d252d71d3e049b8b85c | [
{
"content": "On te demande d'implémenter une fonction `check_prime(number)` qui détermine si un entier donné `number` est un nombre premier. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même. Ta fonction doit renvoyer `True` si le nombre est premie... | ["\nassert check_prime(2) == True\n", "\nassert check_prime(3) == True\n", "\nassert check_prime(4) == False\n", "\nassert check_prime(5) == True\n", "\nassert check_prime(9) == False\n", "\nassert check_prime(11) == True\n", "\nassert check_prime(15) == False\n", "\nassert check_prime(17) == True\n", "\nassert check_p... |
644024b371b6011d48ce19b9eae96f8f | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne peut représenter une valeur entière. Ta tâche est de traiter chaque chaîne comme suit :\n- Supprime les espaces blancs en début et en fin de chaîne.\n- Essaie de convertir la chaîne en entier.\n- Si la conversion réussit et que l'ent... | ["\nassert validate_input([\" 42 \", \"-3\", \"hello\", \" 100 \", \" -10 \", \"0\"]) == ([42, 100, 0], ['-3', 'hello', ' -10 '])\n", "\nassert validate_input([\"123\", \" 456 \", \"789\"]) == ([123, 456, 789], [])\n", "\nassert validate_input([\"-1\", \"-2\", \"-3\"]) == ([], ['-1', '-2', '-3'])\n", "\nassert ... |
1867b43545131f5bb7e7fcceda42a43a | [
{
"content": "On te donne un graphe orienté représentant une hiérarchie d'entités, où chaque nœud a un indice et un horodatage uniques. Le graphe est représenté sous forme de liste d'adjacence, où la liste d'adjacence de chaque nœud contient les indices de ses nœuds parents. On te donne également une liste d'ho... | ["\nassert get_ancestor_chain_length([[1], [2], []], 2, 10, 5) == 1\n", "\nassert get_ancestor_chain_length([[1], [2], []], 2, 10, 5, 9) == 1\n", "\nassert get_ancestor_chain_length([[1], [2], []], 2, 10, 5, 11) == 0\n", "\nassert get_ancestor_chain_length([[1], [2], []], 2, 10, 3) == 3\n", "\nassert get_ancestor_chain... |
ad590c3ffd3319be47b177a8b724e4f7 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence telle que la différence entre deux éléments consécutifs quelconques soit exactement égale à 1. La sous-séquence n'a pas besoin d'être contiguë dans la liste d'origine. Par exemple, étant donné la liste `[1, 2, 3,... | ["\nassert longest_consecutive_subsequence([1, 2, 3, 5, 6, 7, 8, 9, 10, 12, 13, 14]) == [5, 6, 7, 8, 9, 10]\n", "\nassert longest_consecutive_subsequence([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert longest_consecutive_subsequence([10, 9, 4, 5, 4, 8, 6]) == [4, 5, 6, 8, 9, 10]\n", "\nassert longest_consecutive_sub... |
31aba6acd35c3bf2c5ab63c500b8570e | [
{
"content": "On te donne une liste de groupes dans une classe, où chaque groupe est représenté par une liste d'identifiants d'étudiants uniques. Ta tâche est d'écrire une fonction Python `find_common_students` qui identifie et renvoie une liste d'identifiants d'étudiants qui sont présents dans chaque groupe. L... | ["\nassert find_common_students([[1, 2, 3], [2, 3, 4], [2, 3, 5]]) == [2, 3]\n", "\nassert find_common_students([[10, 20, 30], [10, 20, 30], [10, 20, 30]]) == [10, 20, 30]\n", "\nassert find_common_students([[1, 2], [3, 4], [5, 6]]) == []\n", "\nassert find_common_students([[1], [1], [1]]) == [1]\n", "\nassert find_com... |
24c8e077b80c9954f0f01d0f839d0cd0 | [
{
"content": "Tu développes un jeu qui nécessite de générer un labyrinthe sur une grille de `n x n`. Chaque cellule de la grille peut être soit un mur (`1`) soit un chemin (`0`). Le joueur commence dans la cellule en haut à gauche de la grille, qui doit toujours être un chemin.\n\nLe labyrinthe est généré en fo... | ["\nassert generate_maze(0, 5) == [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]\n", "\nassert generate_maze(1, 1) == [[0]]\n", "\nassert sum(sum(row) for row in generate_maze(0.5, 10)) <= 30\n", "\nassert generate_maze(0.5, 2)[0][0] == 0\n", "\nassert all(generate_maze(0, 3)[i][j... |
db3f312c362edfc84f42bff8fa55cd12 | [
{
"content": "On te donne un dictionnaire Python représentant un objet JSON. Ta tâche est d'aplatir ce dictionnaire en un dictionnaire à un seul niveau où chaque clé est une chaîne de caractères représentant le chemin JSON vers la valeur correspondante. Par exemple, étant donné l'entrée `{\"a\": {\"b\": {\"c\":... | ["\nassert flatten_dict({\"a\": {\"b\": {\"c\": 1}}}) == {\"a.b.c\": 1}\n", "\nassert flatten_dict({\"a\": {\"b\": 2, \"c\": 3}, \"d\": 4}) == {\"a.b\": 2, \"a.c\": 3, \"d\": 4}\n", "\nassert flatten_dict({\"x\": {\"y\": {\"z\": {\"w\": 5}}}}) == {\"x.y.z.w\": 5}\n", "\nassert flatten_dict({\"key\": \"value\"}) == {\"k... |
f06e1f9b904f7f5f72367345e65d1cb8 | [
{
"content": "On te demande d'implémenter une fonction `extract_emails(text)` qui traite un bloc de texte donné et identifie toutes les adresses e-mail uniques qu'il contient. Une adresse e-mail est considérée comme valide si elle respecte le format suivant : `local-part@domain`. Ici, `local-part` peut consiste... | ["\nassert extract_emails(\"user@example.com\") == [\"user@example.com\"]\n", "\nassert extract_emails(\"user@sub.example.com\") == [\"user@sub.example.com\"]\n", "\nassert extract_emails(\"user@domain.co.uk\") == [\"user@domain.co.uk\"]\n", "\nassert extract_emails(\"user@domain.com, another.user@domain.org\") == [\"u... |
0eb808df5c0ae942d7099608ea73d4b5 | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer l'inventaire d'une bibliothèque. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Propriétés** :\n - `title` : une chaîne de caractères représentant le titre du livre.\n - `author` : une chaîne de caractères représen... | ["\nassert Book(\"1984\", \"George Orwell\", \"1234567890\", 1949, \"Secker & Warburg\", 3).available_copies == 3\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"0987654321\", 1960, \"J.B. Lippincott & Co.\", 0).is_available() == False\n", "\nbook = Book(\"Brave New World\", \"Aldous Huxley\", \"1122334... |
08621ed5a5613c6d71a3483f0f817a53 | [
{
"content": "On te donne un plateau de Sudoku 9x9 partiellement rempli. L'objectif est de remplir les cellules vides de telle sorte que chaque ligne, colonne et grille 3x3 contienne tous les chiffres de 1 à 9 exactement une fois. Implémente une fonction `find_mrv_cell(board)` qui utilise l'heuristique des \"va... | ["\nassert find_mrv_cell({(0, 0): [1, 2, 3], (0, 1): [4, 5, 6]}) == (0, 0)\n", "\nassert find_mrv_cell({(0, 0): [1, 2], (0, 1): [3, 4, 5], (0, 2): [6, 7, 8, 9]}) == (0, 0)\n", "\nassert find_mrv_cell({(0, 0): [1], (0, 1): [2, 3], (0, 2): [4, 5, 6], (0, 3): [7, 8, 9]}) == (0, 0)\n", "\nassert find_mrv_cell({(0, 0): [1, ... |
30d83e5d15fb159f5f0462b66472454b | [
{
"content": "Conçois et implémente un programme Python qui simule une calculatrice simple avec une interface utilisateur graphique (GUI) en utilisant la bibliothèque Tkinter. La calculatrice doit inclure des boutons pour les chiffres 0-9, les opérations de base (+, -, *, /) et un bouton pour effacer l'affichag... | ["\nassert click_button(5) is None and display.get() == '5'\n", "\nassert click_button(3) is None and display.get() == '53'\n", "\nassert click_button('+') is None and display.get() == '53+'\n", "\nassert click_button(2) is None and display.get() == '53+2'\n", "\nassert click_button('=') is None and display.get() == '5... |
852bf9baabf366e02e7149a1b2d161d2 | [
{
"content": "On te donne une liste triée d'entiers `nums` et un entier `target`. Ta tâche est de trouver une paire de nombres dans `nums` qui s'additionnent pour donner `target`, avec la somme d'indices la plus faible possible, en excluant toute paire formée par des éléments consécutifs de la liste. Si aucune ... | ["\nassert find_pair([1, 3, 4, 6, 8, 9], 11) == (3, 8)\n", "\nassert find_pair([1, 2, 3, 4, 5], 9) == (4, 5)\n", "\nassert find_pair([1, 2, 3, 4, 5], 10) == \"No match\"\n", "\nassert find_pair([1, 2, 3, 4, 5, 6], 7) == (1, 6)\n", "\nassert find_pair([1, 2, 3, 4, 5, 6], 12) == (5, 7)\n", "\nassert find_pair([1, 2, 3, 4... |
65466b567cfe412284e6382d149f97c1 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif donné `n`. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. Ta fonction doit s'appeler `factorial` et accepter un seul argument e... | ["\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... |
7e8b6dc99281b24f282fdbe12fb41c11 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver tous les quadruplets uniques dans le tableau qui donnent la somme de `target`. Chaque nombre du tableau ne peut être utilisé qu'une seule fois dans le quadruplet. Les quadruplets doivent être retournés dans un o... | ["\nassert four_sum([1, 0, -1, 0, -2, 2], 0) == [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]\n", "\nassert four_sum([1, 2, 3, 4, 5], 10) == [[1, 2, 3, 4]]\n", "\nassert four_sum([0, 0, 0, 0], 0) == [[0, 0, 0, 0]]\n", "\nassert four_sum([1, 2, 3, 4, 5, 6, 7, 8], 16) == [[1, 2, 7, 6], [1, 3, 5, 7], [1, 4, 5, 6], [2, 3,... |
5660624c89d696208647377e044296e8 | [
{
"content": "Tu développes un algorithme génétique pour faire évoluer une population de chaînes de caractères vers une chaîne cible. L'algorithme commence avec une population initiale de chaînes aléatoires uniques, chacune ayant la même longueur que la chaîne cible. Ta tâche est d'implémenter la fonction `gene... | ["\nassert len(generate_initial_population(5, 3)) == 5\n", "\nassert all(len(individual[1]) == 4 for individual in generate_initial_population(10, 4))\n", "\nassert all(individual[0] == 0 for individual in generate_initial_population(7, 5))\n", "\nassert len(set(individual[1] for individual in generate_initial_populati... |
416b77be9b83d1f1a955ca13e0980e81 | [
{
"content": "On te donne une chaîne de caractères `hex_data` qui contient une séquence de caractères, dont certains sont des chiffres hexadécimaux (0-9, a-f, A-F) et d'autres des caractères non hexadécimaux. Ta tâche est d'écrire une fonction `hex_to_ascii` qui traite cette chaîne en supprimant tous les caract... | ["\nassert hex_to_ascii(\"48656c6c6f20576f726c64\") == \"Hello World\"\n", "\nassert hex_to_ascii(\"48656c6c6f20576f726c6421\") == \"Hello World!\"\n", "\nassert hex_to_ascii(\"48656c6c6f20576f726c642120313233\") == \"Hello World! 123\"\n", "\nassert hex_to_ascii(\"48656c6c6f20576f726c642120313233414243\") == \"Hello W... |
b78ff1055746fdd22fb6223c6ca8ea38 | [
{
"content": "On te donne une chaîne de caractères `s` composée des caractères '(', ')', '{', '}', '[' et ']'. Ta tâche est de déterminer si la chaîne est une séquence de parenthèses valide. Une séquence est valide si :\n- Chaque parenthèse ouvrante a une parenthèse fermante correspondante.\n- Les parenthèses o... | ["\nassert is_valid_parentheses(\"()\") == True\n", "\nassert is_valid_parentheses(\"()[]{}\") == True\n", "\nassert is_valid_parentheses(\"(]\") == False\n", "\nassert is_valid_parentheses(\"([)]\") == False\n", "\nassert is_valid_parentheses(\"{[]}\") == True\n", "\nassert is_valid_parentheses(\"((()))\") == True\n",... |
2d7817efef22420a41a9943727c637f7 | [
{
"content": "On te donne un dictionnaire imbriqué `d` et une liste d'opérations `operations`. Chaque opération est un tuple composé d'un chemin de clé, d'une valeur et d'un séparateur. Le chemin de clé est une chaîne qui représente le chemin vers une clé imbriquée dans le dictionnaire, chaque niveau d'imbricat... | ["\nassert set_nested_values({}, [(\"a.b.c\", 1, \".\")]) == {\"a\": {\"b\": {\"c\": 1}}}\n", "\nassert set_nested_values({\"a\": {\"b\": 1}}, [(\"a.b\", 2, \".\")]) == {\"a\": {\"b\": 2}}\n", "\nassert set_nested_values({\"a\": {\"b\": {\"1\": 1}}}, [(\"a.b.2\", 2, \".\")]) == {\"a\": {\"b\": [None, 1, 2]}}\n", "\nass... |
d9db695f7a135c66fec4ab20f3930f69 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author`, `publisher`, `year_published`, `isbn` et `pages`. Implémente une méthode `summary` qui renvoie une chaîne formatée contenant les détails du livre. De plus, implémente une métho... | ["\nassert Book(\"1984\", \"George Orwell\", \"Secker & Warburg\", 1949, \"9780451524935\", 328).summary() == \"Title: 1984\\nAuthor: George Orwell\\nPublisher: Secker & Warburg\\nYear Published: 1949\\nISBN: 9780451524935\\nPages: 328\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"J.B. Lippincott & ... |
7be0ee04ce3a49151aa81b340987af05 | [
{
"content": "On te demande d'implémenter une fonction `parse_csv` qui traite un fichier CSV. La fonction doit lire le fichier, extraire la ligne d'en-tête et renvoyer une liste de dictionnaires. Chaque dictionnaire doit représenter une ligne du fichier CSV, la ligne d'en-tête servant de clés. Suppose que le fi... | ["\nassert parse_csv(\"test.csv\") == [{'name': 'Alice', 'age': '30', 'city': 'New York'}, {'name': 'Bob', 'age': '25', 'city': 'Los Angeles'}]\n", "\nassert parse_csv(\"empty.csv\") == []\n", "\nassert parse_csv(\"single_row.csv\") == [{'name': 'Charlie', 'age': '35', 'city': 'Chicago'}]\n", "\nassert parse_csv(\"sing... |
0b9e8ad91dc04c6b2fe28f263e9b3734 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères anglais et chinois, y compris la ponctuation. Ta tâche est de mettre en œuvre la fonction `filter_text` qui supprime toute la ponctuation de la chaîne. La fonction doit avoir une complexité temporelle d'au plus O(n), où n est la longu... | ["\nassert filter_text(\"Hello, \u4e16\u754c\uff01This is a test...\u4f60\u597d\uff0c\u4e16\u754c\uff1f\") == \"Hello \u4e16\u754cThis is a test\u4f60\u597d \u4e16\u754c\"\n", "\nassert filter_text(\"No punctuation here\") == \"No punctuation here\"\n", "\nassert filter_text(\"...!!!\") == \"\"\n", "\nassert filter_tex... |
476678a3c1655b783033f37fd757f4c2 | [
{
"content": "On te demande d'implémenter une classe `TreeNode` pour représenter un nœud dans un arbre binaire. Chaque nœud doit stocker une valeur entière et des pointeurs vers ses enfants gauche et droit. Ton implémentation doit inclure un constructeur qui initialise ces propriétés.\n\n**Exemple d'entrée :**\... | ["\nassert TreeNode(10).value == 10\n", "\nassert TreeNode(10).left is None\n", "\nassert TreeNode(10).right is None\n", "\nassert TreeNode(5, TreeNode(3)).left.value == 3\n", "\nassert TreeNode(5, TreeNode(3)).right is None\n", "\nassert TreeNode(5, None, TreeNode(8)).right.value == 8\n", "\nassert TreeNode(5, None, T... |
351429b33330c254e9f1d033cea5c8d0 | [
{
"content": "On te demande d'implémenter une fonction `replace_brands(line, brands, repl=' brand_token ')` qui traite un texte donné pour remplacer les occurrences de noms de marques spécifiés par un jeton. La fonction doit gérer les variations d'espacement, de ponctuation et de casse. De plus, la fonction doi... | ["\nassert replace_brands(\"I love Apple, apple Inc. and APPLE watches!\", ['Apple'], ' brand_token ') == \"I love brand_token , brand_token Inc. and brand_token watches!\"\n", "\nassert replace_brands(\"Samsung and SAMSUNG are great too.\", ['Samsung'], ' brand_token ') == \" brand_token and brand_token are gr... |
288e88aa6a9aae4cd5c68719881e34c5 | [
{
"content": "On te demande d'implémenter une fonction `get_function_ast(stack_depth=2, frame=None) -> ast.FunctionDef` qui récupère l'Arbre de Syntaxe Abstraite (AST) de la fonction qui l'a appelée. La fonction doit être thread-safe et capable de gérer les contextes d'appel asynchrones. Ton implémentation doit... | ["\nassert isinstance(get_function_ast(), ast.FunctionDef)\n", "\nassert get_function_ast(frame=inspect.currentframe()).name == \"get_function_ast\"\n", "\nassert get_function_ast(stack_depth=1, frame=inspect.currentframe()).name == \"test_get_function_ast\"\n", "\nassert get_function_ast(stack_depth=3, frame=inspect.c... |
7267127998455b21644dd6959284f736 | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Ta tâche est d'écrire une fonction Python `find_hamming_distance` qui calcule la distance de Hamming entre ces deux chaînes. La distance de Hamming est définie comme le nombre de positions auxquelles les symboles correspondants sont différe... | ["\nassert find_hamming_distance(\"karolin\", \"kathrin\") == 3\n", "\nassert find_hamming_distance(\"karolin\", \"karolin\") == 0\n", "\nassert find_hamming_distance(\"1011101\", \"1001001\") == 2\n", "\nassert find_hamming_distance(\"GAGCCTACTAACGGGAT\", \"CATCGTAATGACGGCCT\") == 7\n", "\nassert find_hamming_distance... |
523c7c9f1712e94ee6a35e6702ae08ba | [
{
"content": "On te donne une liste d'entiers `numbers`. Ta tâche est de déterminer la longueur de la plus longue sous-séquence où chaque élément est strictement supérieur au précédent, et la différence entre deux éléments consécutifs est un nombre premier.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ ... | ["\nassert longest_increasing_subsequence_length([2, 5, 7, 10, 13]) == 3\n", "\nassert longest_increasing_subsequence_length([3, 6, 9, 12, 15]) == 1\n", "\nassert longest_increasing_subsequence_length([2, 3, 5, 7, 11, 13]) == 6\n", "\nassert longest_increasing_subsequence_length([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 4\n"... |
91021e7706d35a5d2f45832240733d58 | [
{
"content": "On te demande d'implémenter une classe Python `Book` qui possède trois attributs : `title`, `author` et `isbn`. Ton objectif est de créer une méthode de classe `from_json()` qui prend une chaîne JSON en entrée et renvoie une instance de la classe `Book` avec ses attributs définis selon les données... | ["\nassert Book.from_json('{\"title\": \"1984\", \"author\": \"George Orwell\", \"isbn\": \"9780451524935\"}').title == \"1984\"\n", "\nassert Book.from_json('{\"title\": \"1984\", \"author\": \"George Orwell\", \"isbn\": \"9780451524935\"}').author == \"George Orwell\"\n", "\nassert Book.from_json('{\"title\": \"1984\... |
3b0140f8507914c480c889d243e7b777 | [
{
"content": "On te donne un fichier CSV nommé `input.csv` avec les colonnes suivantes : `ID`, `Name`, `Score`. Ta tâche est d'écrire un programme qui lit ce fichier et écrit un nouveau fichier nommé `filtered_output.csv` contenant uniquement les lignes où le `Score` est supérieur à 10. Le fichier CSV est sépar... | ["\nassert filter_csv('test_input.csv', 'test_output.csv') is None\n", "\nassert filter_csv('non_existent_file.csv', 'test_output.csv') is None\n", "\nassert filter_csv('test_input_with_invalid_data.csv', 'test_output.csv') is None\n", "\nassert filter_csv('test_input_with_no_scores.csv', 'test_output.csv') is None\n",... |
a5be60482458e1f34ccaefad5d6c8a6e | [
{
"content": "On te donne un tenseur 3D `states` de forme `(batch, sent_len, dim)`, où `batch` est le nombre d'échantillons dans le lot, `sent_len` est la longueur de chaque phrase, et `dim` est la dimensionnalité de la représentation de l'état. De plus, on te fournit une liste `rephrase_positions` de longueur ... | ["\nassert extract_and_sort_slices(torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]), [1], torch.tensor([3.0, 4.0])).shape == (1, 3, 2)\n", "\nassert torch.equal(extract_and_sort_slices(torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]), [1], torch.tensor([3.0, 4.0])), torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, ... |
3bafaa7837c75e1d3c0105c84d6c8c51 | [
{
"content": "On te donne une liste d'entiers représentant un ensemble de données. Ta tâche est de mettre en œuvre une fonction `remove_outliers` qui traite cet ensemble de données et renvoie une nouvelle liste avec les valeurs aberrantes supprimées. Une valeur aberrante est définie comme une valeur qui est sup... | ["\nassert remove_outliers([10, 12, 12, 13, 12, 14, 13, 15, 100]) == [10, 12, 12, 13, 12, 14, 13, 15]\n", "\nassert remove_outliers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert remove_outliers([1, 1, 1, 1, 1, 1, 1, 1, 1, 100]) == [1, 1, 1, 1, 1, 1, 1, 1, 1]\n", "\nassert remove... |
36e21e2969895a111eaf47ff84be6103 | [
{
"content": "On te donne un point 3D représenté comme une liste `[x, y, z]` et une liste d'angles d'Euler `[theta_x, theta_y, theta_z]` représentant la rotation autour des axes x, y et z, respectivement. Ta tâche est d'implémenter la fonction `rotate_point(point, theta)` qui applique l'inverse de la matrice de... | ["\nassert rotate_point([1, 0, 0], [0, 0, 0]) == [1, 0, 0]\n", "\nassert rotate_point([1, 0, 0], [math.pi/2, 0, 0]) == [1, 0, 0]\n", "\nassert rotate_point([1, 0, 0], [0, math.pi/2, 0]) == [0, 0, 1]\n", "\nassert rotate_point([1, 0, 0], [0, 0, math.pi/2]) == [0, -1, 0]\n", "\nassert rotate_point([0, 1, 0], [math.pi/2, ... |
cd214ccf6a124e9dcda236ab125afad5 | [
{
"content": "On te donne une liste de prix de clôture historiques pour une action. Ta tâche est de calculer l'Indice de Force Relative (RSI) pour l'action en utilisant une taille de fenêtre spécifiée. Le RSI est un oscillateur de momentum qui mesure la vitesse et l'ampleur des mouvements de prix. Il oscille en... | ["\nassert calculate_rsi([100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119]) == [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]\n", "\nassert calculate_rsi([100, 99, 98, 97, 96, 95, 94, 93, 9... |
dccb0fda4c546f3660eff7a4cd375678 | [
{
"content": "On te demande de développer une fonction pour analyser les données XML efficacement. Ta fonction, `extract_elements`, doit accepter une chaîne XML et un nom de balise en tant que paramètres et renvoyer une liste de contenus textuels de tous les éléments correspondant au nom de balise spécifié. Uti... | ["\nassert extract_elements(\"<root><tag>value1</tag><tag>value2</tag></root>\", \"tag\") == [\"value1\", \"value2\"]\n", "\nassert extract_elements(\"<root><child><tag>value1</tag></child><tag>value2</tag></root>\", \"tag\") == [\"value1\", \"value2\"]\n", "\nassert extract_elements(\"<root><tag>value1</tag><child><ta... |
eb3bd6b67f8702710467a2fc6eb88c52 | [
{
"content": "On te demande d'implémenter une classe nommée `Employee` pour gérer les détails des employés dans la base de données d'une entreprise. La classe `Employee` doit prendre en charge les fonctionnalités suivantes :\n\n- **Attributs :**\n - `name` : une chaîne de caractères représentant le nom de l'em... | ["\nassert str(Employee(\"John Doe\", 1, \"Developer\", 50000)) == \"Employee ID: 1, Name: John Doe, Position: Developer, Salary: 50000.00\"\n", "\nassert Employee(\"Jane Smith\", 2, \"Manager\", 60000).salary == 60000\n", "\nassert Employee(\"Alice Johnson\", 3, \"Designer\", 55000).position == \"Designer\"\n", "\nemp... |
dba9e92c6fd7c9266714433e7cc40528 | [
{
"content": "On te donne une liste de `channels`, où chaque channel est représenté comme un dictionnaire avec les clés suivantes :\n- `channel_name` : une chaîne de caractères représentant le nom du channel.\n- `light_group` : une chaîne de caractères représentant le groupe de lumières associé au channel.\n\nT... | ["\nassert get_real_channel_names([{\"channel_name\": \"Living Room\", \"light_group\": \"LGroup1\"}]) == [\"Living_Room_LGroup1\"]\n", "\nassert get_real_channel_names([{\"channel_name\": \"Kitchen_LGroup2\", \"light_group\": \"LGroup2\"}]) == [\"Kitchen_LGroup2\"]\n", "\nassert get_real_channel_names([{\"channel_name... |
c56822aa7cf8f5aa57800498b12fe6ae | [
{
"content": "On te donne un entier positif `end` et une chaîne de caractères `mode` qui peut être soit \"even\" (pair) soit \"odd\" (impair). Ta tâche est de calculer le produit de tous les nombres de Fibonacci distincts, pairs ou impairs, jusqu'à `end`, en excluant tous les nombres qui sont divisibles par 7. ... | ["\nassert fibonacci_product(10, \"even\") == 8\n", "\nassert fibonacci_product(10, \"odd\") == 45\n", "\nassert fibonacci_product(100, \"even\") == 46080\n", "\nassert fibonacci_product(100, \"odd\") == 315\n", "\nassert fibonacci_product(1, \"even\") == 0\n", "\nassert fibonacci_product(1, \"odd\") == 1\n", "\nassert... |
f622e609f85851328ea762f4b24fc638 | [
{
"content": "On te donne la tâche de calculer la force exercée sur un tuyau due à son propre poids lorsqu'il est courbé en un arc de cercle. Le tuyau est défini par son diamètre extérieur (OD) et son diamètre intérieur (ID), tous deux en pouces. La courbure du tuyau est fournie en degrés par 100 pieds. Ton tra... | ["\nassert pipe_force(10, 8, 1) == 17135 * 10 * (1 / 100 * (np.pi / 180)) * (10 ** 2 - 8 ** 2)\n", "\nassert pipe_force(12, 10, 2) == 17135 * 12 * (2 / 100 * (np.pi / 180)) * (12 ** 2 - 10 ** 2)\n", "\nassert pipe_force([10, 12], [8, 10], [1, 2]) == [17135 * 10 * (1 / 100 * (np.pi / 180)) * (10 ** 2 - 8 ** 2), 17135 * ... |
e30024300c268d63ccf9485a63084f2f | [
{
"content": "Tu participes à une compétition de classification binaire. Étant donné deux listes d'entiers, `real_labels` et `predicted_labels`, où chaque entier est soit 1 (positif) soit 0 (négatif), ta tâche est de mettre en œuvre une fonction `custom_f1_score` qui calcule le score F1 des prédictions. Le scor... | ["\nassert custom_f1_score([1, 1, 1], [1, 1, 1]) == 1.0\n", "\nassert custom_f1_score([0, 0, 0], [0, 0, 0]) == 1.0\n", "\nassert custom_f1_score([1, 0, 1], [0, 1, 0]) == 0.0\n", "\nassert custom_f1_score([1, 1, 0, 0], [1, 0, 1, 0]) == 0.5\n", "\nassert custom_f1_score([1, 0, 1, 0], [1, 1, 1, 1]) == 0.5\n", "\nassert cu... |
9c20de69d4f755ec08fdcef890f49c15 | [
{
"content": "On te demande d'implémenter une fonction `validate_parameters` qui vérifie la validité des paramètres fournis par l'utilisateur par rapport à un ensemble de paramètres valides. La fonction doit gérer les structures imbriquées et s'assurer que tous les éléments sont valides. Si les paramètres fourn... | ["\nassert validate_parameters(['red', 'blue'], \"color\", {'red', 'green', 'blue', 'yellow'}) == ['red', 'blue']\n", "\nassert validate_parameters(None, \"color\", {'red', 'green', 'blue', 'yellow'}, ['red', 'blue']) == ['red', 'blue']\n", "\nassert validate_parameters([], \"color\", {'red', 'green', 'blue', 'yellow'}... |
b803b1ddd1abcc1fd9ddaa274baa10c2 | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `get_prime_factors` qui renvoie une liste de ses facteurs premiers. Utilise l'algorithme du crible d'Ératosthène pour trouver tous les nombres premiers jusqu'à la racine carrée de `n`. La fonction doit déterminer efficacement les facteu... | ["\nassert get_prime_factors(28) == [2, 2, 7]\n", "\nassert get_prime_factors(1) == []\n", "\nassert get_prime_factors(2) == [2]\n", "\nassert get_prime_factors(3) == [3]\n", "\nassert get_prime_factors(4) == [2, 2]\n", "\nassert get_prime_factors(100) == [2, 2, 5, 5]\n", "\nassert get_prime_factors(101) == [101]\n", "... |
7071a331fdd121b50d4155d25a51213a | [
{
"content": "Tu es chargé d'implémenter une fonction `generate_html_table` qui construit un tableau HTML à partir d'une liste de dictionnaires. Chaque dictionnaire de la liste représente une ligne du tableau, et les clés du dictionnaire servent d'en-têtes de colonne. Ta fonction doit renvoyer une chaîne de car... | ["\nassert generate_html_table([{\"Name\": \"Alice\", \"Age\": 30}, {\"Name\": \"Bob\", \"Age\": 25}]) == \"<table border='1'>\\n <tr>\\n\t<th>Name</th>\\n\t<th>Age</th>\\n </tr>\\n <tr>\\n\t<td>Alice</td>\\n\t<td>30</td>\\n </tr>\\n <tr>\\n\t<td>Bob</td>\\n\t<td>25</td>\\n </tr>\\n</table>\"\n", "\nassert genera... |
b0716294e0d7070c5c864159b79e0f4e | [
{
"content": "On te donne une liste d'entiers, `numbers`. Implémente un algorithme de tri récursif qui trie la liste en ordre croissant en fonction de la valeur absolue de chaque élément, tout en conservant le signe original de chaque nombre. Ta tâche est d'implémenter une version modifiée de l'algorithme de tr... | ["\nassert recursive_insertion_sort([3, -1, 4, -2, 5]) == [-1, -2, 3, 4, 5]\n", "\nassert recursive_insertion_sort([-5, -3, -1, -4, -2]) == [-5, -4, -3, -2, -1]\n", "\nassert recursive_insertion_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert recursive_insertion_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nas... |
a7a7843a5c20f2e83069b3d18baa431d | [
{
"content": "On te donne une liste de points 3D dans l'espace, où chaque point est représenté comme une liste de trois entiers. Ta tâche est d'écrire une fonction qui calcule la distance totale parcourue par une particule se déplaçant de l'origine (0,0,0) à chacun des points donnés en séquence, puis de retour ... | ["\nassert total_distance([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) == 12.0\n", "\nassert total_distance([[0, 0, 0], [1, 1, 1], [2, 2, 2]]) == 4.898979485566356\n", "\nassert total_distance([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == 4.242640687119286\n", "\nassert total_distance([[0, 0, 0]]) == 0.0\n", "\nassert total_distance([[1... |
5dbb70115d8063680167c22c8cf426a0 | [
{
"content": "Tu développes un système pour gérer le contenu généré par les utilisateurs (CGU) sur une plateforme de médias sociaux. Implémente la fonction `manage_ugc_publication` qui gère la publication, la mise à jour et la suppression de contenu en fonction des paramètres fournis. La fonction doit vérifier ... | ["\nassert manage_ugc_publication(post=True, apply=False, delete=False, action='publish', location='user_profile', propertylist=['title', 'description'], is_primary_publisher=True) == {\"action\": \"publish\", \"status\": \"success\", \"message\": \"Publishing of content was successful.\", \"location\": \"user_profile\... |
f4d1f7e9b01a7d7697065d30d4f736b4 | [
{
"content": "On te donne un DataFrame Pandas `df` avec une colonne nommée `species`. Chaque entrée de cette colonne est un nom d'espèce formaté de telle sorte que la première lettre de chaque mot est en majuscule et les lettres restantes sont en minuscule (par exemple, \"Homo Sapiens\"). Ta tâche est de mettre... | ["\nassert add_species_prefix(pd.DataFrame({'species': ['Homo Sapiens']}), 'species', 'Prefix').equals(pd.DataFrame({'species': ['Prefix Homo Sapiens']}))\n", "\nassert add_species_prefix(pd.DataFrame({'species': ['Canis Lupus']}), 'species', 'Animal').equals(pd.DataFrame({'species': ['Animal Canis Lupus']}))\n", "\nas... |
b145ab406edd886779bc072f6d6d01ad | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author` et `isbn`. Ta classe doit inclure une méthode `info` qui renvoie une chaîne formatée avec les informations du livre au format : `\"Book(title={title}, author={author}, isbn={isb... | ["\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\").info() == \"Book(title=1984, author=George Orwell, isbn=9780451524935)\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"9780060935467\").info() == \"Book(title=To Kill a Mockingbird, author=Harper Lee, isbn=9780060935467)\"\n", "\nassert B... |
b3e55ecf94059683d2ac5c4a419b4311 | [
{
"content": "On te donne deux ensembles ordonnés et non vides de nombres réels, `T1` et `T2`, représentant les horodatages d'événements dans deux systèmes différents. Ta tâche est de calculer la distance totale entre ces deux ensembles d'horodatages sur l'intervalle `[a, b]`. La distance entre un horodatage `t... | ["\nassert total_distance([1.0, 3.0, 5.0], [2.0, 4.0, 6.0], 0.0, 7.0) == 6.0\n", "\nassert total_distance([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], 0.0, 4.0) == 0.0\n", "\nassert total_distance([1.0, 4.0, 7.0], [2.0, 5.0, 8.0], 0.0, 9.0) == 6.0\n", "\nassert total_distance([0.5, 1.5, 2.5], [0.0, 1.0, 2.0], 0.0, 3.0) == 1.5\n",... |
fd519d5a3ae5675952cab663dc4931e7 | [
{
"content": "On te donne une liste de chaînes de caractères non vides. Ta tâche est de mettre en œuvre une fonction `longest_common_prefix` qui détermine le plus long préfixe commun parmi toutes les chaînes de caractères de la liste. S'il n'y a pas de préfixe commun, la fonction doit renvoyer une chaîne vide.\... | ["\nassert longest_common_prefix([\"flower\", \"flow\", \"flight\"]) == \"fl\"\n", "\nassert longest_common_prefix([\"dog\", \"racecar\", \"car\"]) == \"\"\n", "\nassert longest_common_prefix([\"interspecies\", \"interstellar\", \"interstate\"]) == \"inters\"\n", "\nassert longest_common_prefix([\"throne\", \"throne\"]... |
2494668a0d1374f4943e636c8fd36cac | [
{
"content": "On te donne un ensemble de données avec des étiquettes binaires (0 ou 1) et un classificateur binaire entraîné. Le classificateur produit un score de probabilité pour chaque point de données, qui peut être converti en une prédiction binaire en utilisant un seuil. En faisant varier ce seuil, tu peu... | ["\nassert calculate_f1_from_roc([0, 0.5, 1], [0, 0.5, 1], 100, 100) == 0.5\n", "\nassert calculate_f1_from_roc([0, 0.2, 0.4, 0.6, 0.8, 1], [0, 0.2, 0.4, 0.6, 0.8, 1], 50, 50) == 0.6666666666666666\n", "\nassert calculate_f1_from_roc([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1], [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6,... |
25aaad7fb377142b189920f541b62baf | [
{
"content": "On te donne un dictionnaire `d` et une fonction `func`. Ta tâche est d'implémenter une fonction `apply_operation_to_dict_values` qui applique `func` à chaque valeur dans `d`. Si une valeur est un dictionnaire, la fonction doit appliquer récursivement `func` à chaque valeur dans le dictionnaire imb... | ["\nassert apply_operation_to_dict_values({\"a\": 1, \"b\": 2, \"c\": 3}, lambda x: x * 2) == {\"a\": 2, \"b\": 4, \"c\": 6}\n", "\nassert apply_operation_to_dict_values({\"x\": 10, \"y\": 20}, lambda x: x - 5) == {\"x\": 5, \"y\": 15}\n", "\nassert apply_operation_to_dict_values({\"a\": {\"b\": 1, \"c\": 2}, \"d\": 3}... |
1a7980a482c8d95cd976ec299387a6f7 | [
{
"content": "On te donne une expression postfixée composée de nombres à un ou plusieurs chiffres (entiers et nombres à virgule flottante) et d'opérateurs arithmétiques (+, -, *, /, ^). L'opérateur ^ désigne l'exponentiation. Ta tâche est d'évaluer l'expression postfixée en utilisant une pile et de renvoyer le ... | ["\nassert evaluate_postfix(['2', '3', '+']) == 5.0\n", "\nassert evaluate_postfix(['5', '3', '-']) == 2.0\n", "\nassert evaluate_postfix(['4', '2', '*']) == 8.0\n", "\nassert evaluate_postfix(['8', '2', '/']) == 4.0\n", "\nassert evaluate_postfix(['2', '3', '^']) == 8.0\n", "\nassert evaluate_postfix(['1.5', '2', '+']... |
15ade237bb33a21da533b2a953776e45 | [
{
"content": "On te donne un tableau d'entiers `nums` de longueur `n`. Ta tâche est de construire un nouveau tableau `result` tel que `result[i]` soit le produit de tous les éléments dans `nums` sauf `nums[i]`. Tu dois résoudre ce problème sans utiliser la division.\n\n**Contraintes :**\n- `2 <= n <= 10^5`\n- `... | ["\nassert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]\n", "\nassert product_except_self([5, 3, 2, 4, 1]) == [24, 40, 60, 30, 120]\n", "\nassert product_except_self([1, 1, 1, 1]) == [1, 1, 1, 1]\n", "\nassert product_except_self([0, 1, 2, 3]) == [6, 0, 0, 0]\n", "\nassert product_except_self([1, 0, 3, 4]) == [0... |
a585d294b19118735849cd942f7e2336 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le score d'Information Mutuelle (IM) entre deux mots dans un large corpus de données textuelles. Le score d'IM quantifie la dépendance entre l'occurrence de deux mots. Il est défini comme le logarithme (en base 2) du rapport entre la fréquence... | ["\nassert mutual_information(50000, 60000, 500, 100000000) == math.log2(500 / ((50000 / 100000000) * (60000 / 100000000) * 100000000))\n", "\nassert mutual_information(100, 100, 0, 1000) == 0.0\n", "\nassert mutual_information(100, 100, 10, 1000) == math.log2(10 / ((100 / 1000) * (100 / 1000) * 1000))\n", "\nassert mu... |
ab88ed5817a2ecf05ba99c186c928ec7 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction qui identifie le mot le plus courant dans toutes les chaînes. La fonction doit ignorer la ponctuation, les espaces et la casse, en ne considérant que les caractères alphabétiques. Si plusieurs mots partagent la... | ["\nassert most_common_word([\"Hello, world!\", \"Hello, Python world.\", \"Python is great!\"]) == \"hello\"\n", "\nassert most_common_word([\"apple\", \"banana\", \"Apple\", \"banana\", \"BANANA\"]) == \"apple\"\n", "\nassert most_common_word([\"one\", \"two\", \"three\", \"four\", \"five\"]) == \"one\"\n", "\nassert... |
cf9e6b94953aa86e0d31946bd83ece9f | [
{
"content": "On te donne un dictionnaire `data` contenant divers types de valeurs, notamment des entiers, des chaînes de caractères, des listes et des dictionnaires imbriqués. Ta tâche est de mettre en œuvre une fonction `filter_dict` qui construit un nouveau dictionnaire ne contenant que les paires clé-valeur... | ["\nassert filter_dict({'a': 10, 'b': 'hi', 'c': 'hello'}, 2) == {'a': 10, 'c': 'hello'}\n", "\nassert filter_dict({'x': 5, 'y': 'yes', 'z': 'no'}, 1) == {'x': 5, 'y': 'yes', 'z': 'no'}\n", "\nassert filter_dict({'key1': 100, 'key2': 'value', 'key3': [1, 2, 3]}, 5) == {'key1': 100}\n", "\nassert filter_dict({'a': 'shor... |
2da63bd7a4a58541b6cdf5cde66779a1 | [
{
"content": "On te donne un chemin de répertoire. Ta tâche est d'écrire une fonction Python `find_duplicate_files` qui identifie les fichiers dupliqués dans le répertoire et ses sous-répertoires. Deux fichiers sont considérés comme des doublons s'ils ont le même hachage MD5. Ta fonction doit renvoyer une liste... | ["\nassert find_duplicate_files(\"/path/to/empty/dir\") == []\n", "\nassert find_duplicate_files(\"/path/to/dir/with/one/file\") == []\n", "\nassert find_duplicate_files(\"/path/to/dir/with/two/identical/files\") == [('md5hash123', ['/path/to/dir/with/two/identical/files/file1.txt', '/path/to/dir/with/two/identical/fil... |
e3d041123c2d7a079bc89b1b36e3e723 | [
{
"content": "On te donne deux entiers `x` et `y`. Ta tâche est de mettre en œuvre une fonction `get_gcd(x, y)` qui renvoie le plus grand commun diviseur (PGCD) de `x` et `y`. Le PGCD de deux nombres est le plus grand entier positif qui divise les deux nombres sans laisser de reste.\n\n**Entrée :**\n- Deux enti... | ["\nassert get_gcd(48, 18) == 6\n", "\nassert get_gcd(101, 10) == 1\n", "\nassert get_gcd(56, 98) == 14\n", "\nassert get_gcd(270, 192) == 6\n", "\nassert get_gcd(0, 5) == 5\n", "\nassert get_gcd(5, 0) == 5\n", "\nassert get_gcd(0, 0) == 0\n", "\nassert get_gcd(1, 1) == 1\n", "\nassert get_gcd(123456, 789012) == 12\n",... |
0662ed8acae1f329669856c6e5c48a3f | [
{
"content": "Implémente un jeu de Pierre-Feuille-Ciseaux où un utilisateur affronte l'ordinateur. L'ordinateur sélectionne aléatoirement l'une des trois options : pierre, feuille ou ciseaux. Le jeu continue en boucle jusqu'à ce que l'utilisateur décide de quitter en entrant \"quit\". Pour chaque tour, l'utilis... | ["\nassert get_computer_choice() in ['rock', 'paper', 'scissors']\n", "\nassert get_user_choice() in ['rock', 'paper', 'scissors', 'quit'] if (user_input := input(\"Enter your choice (rock, paper, scissors) or 'quit' to exit: \").lower()) in ['rock', 'paper', 'scissors', 'quit'] else False\n", "\nassert determine_winne... |
36d82942708a613aa1d22583872ebf4e | [
{
"content": "On te donne un fichier texte nommé \"data.txt\" contenant des lettres minuscules et de la ponctuation. Ta tâche est d'écrire un programme Python qui lit ce fichier, compte le nombre d'occurrences de chaque mot et affiche les 10 mots les plus fréquents ainsi que leurs décomptes. Le programme doit i... | ["\nassert count_words('empty.txt') == []\n", "\nassert count_words('single_word.txt') == [('example', 1)]\n", "\nassert count_words('stop_words_only.txt') == []\n", "\nassert count_words('repeated_words.txt') == [('word', 3)]\n", "\nassert count_words('ten_unique_words.txt') == [('word1', 1), ('word2', 1), ('word3', 1... |
18e1a57d819f3be5bf3f6c8819a27e21 | [
{
"content": "On te donne deux nombres à virgule flottante : `original_proportion` et `odds_ratio`. La `original_proportion` est une valeur dans la plage [0.0, 1.0], représentant la probabilité qu'un certain événement se produise. Le `odds_ratio` est un nombre à virgule flottante non négatif, représentant le fa... | ["\nassert adjust_proportion(0.5, 1.0) == 0.5\n", "\nassert adjust_proportion(0.2, 2.0) == 0.4\n", "\nassert adjust_proportion(0.8, 0.5) == 0.6666666666666666\n", "\nassert adjust_proportion(0.1, 10.0) == 0.9090909090909091\n", "\nassert adjust_proportion(0.9, 0.1) == 0.5263157894736842\n", "\nassert adjust_proportion(... |
0f23095bf560c94848265cb8bef702ea | [
{
"content": "On te donne deux chaînes de caractères, `s1` et `s2`. Ta tâche est d'écrire une fonction `find_common_substrings` qui renvoie une liste de toutes les sous-chaînes uniques qui sont communes aux deux chaînes `s1` et `s2`. Les sous-chaînes doivent être renvoyées par ordre lexicographique.\n\n**Entrée... | ["\nassert find_common_substrings(\"abcde\", \"bcdeabc\") == ['abc', 'bc', 'bcd', 'bcde', 'c', 'cd', 'cde', 'd', 'de', 'e']\n", "\nassert find_common_substrings(\"hello\", \"yellow\") == ['ello', 'ell', 'el', 'e', 'l', 'll', 'lo']\n", "\nassert find_common_substrings(\"abc\", \"def\") == []\n", "\nassert find_common_su... |
c95235f16cfcefe40491f81596bf25e4 | [
{
"content": "On te donne une liste de livres et un ensemble de mots-clés. Chaque livre est représenté comme un dictionnaire avec les clés 'id', 'title', 'author' et 'description'. Ta tâche est de mettre en œuvre la fonction `rank_books_by_keywords` qui classe et filtre les livres en fonction de leur pertinence... | ["\nassert rank_books_by_keywords([], [\"keyword\"], 1) == []\n", "\nassert rank_books_by_keywords([{\"id\": 1, \"title\": \"Book One\", \"author\": \"Author A\", \"description\": \"Description of book one\"}], [\"book\"], 1) == [1]\n", "\nassert rank_books_by_keywords([{\"id\": 1, \"title\": \"Book One\", \"author\": ... |
dfd6cbde750657a4def0b1e909ca7c3e | [
{
"content": "On te donne une liste de températures quotidiennes en Fahrenheit. Ton objectif est d'implémenter une fonction `calculate_average_temperature` qui calcule la température moyenne en Celsius. La conversion de Fahrenheit en Celsius se fait en utilisant la formule `(Fahrenheit - 32) * 5/9`. Si la liste... | ["\nassert calculate_average_temperature([32, 68, 77]) == 20.0\n", "\nassert calculate_average_temperature([100]) == 37.77777777777778\n", "\nassert calculate_average_temperature([-40, -40]) == -40.0\n", "\nassert calculate_average_temperature([0, 32, 212]) == 40.0\n", "\nassert calculate_average_temperature([]) == Non... |
78db55950a905eb73c22ff72026a046c | [
{
"content": "On te donne deux entiers, `start` et `end`. Ta tâche est de déterminer le nombre d'entiers dans l'intervalle `[start, end]` (inclus) qui sont à la fois des carrés parfaits et des palindromes. Un carré parfait est un entier qui est le carré d'un entier, et un palindrome se lit de la même manière de... | ["\nassert count_square_numbers(0, 100) == 4\n", "\nassert count_square_numbers(1, 1) == 1\n", "\nassert count_square_numbers(4, 4) == 1\n", "\nassert count_square_numbers(9, 9) == 1\n", "\nassert count_square_numbers(10, 100) == 3\n", "\nassert count_square_numbers(-10, 10) == 3\n", "\nassert count_square_numbers(100,... |
009a66f397f9cc81b34896ca5a645b98 | [
{
"content": "On te donne un fichier JSON nommé `data.json` qui contient un tableau de profils d'utilisateurs. Chaque profil d'utilisateur est représenté comme un objet avec les propriétés suivantes :\n- `id` : un identifiant unique pour l'utilisateur (entier).\n- `first_name` : le prénom de l'utilisateur (chaî... | ["\nassert extract_user_info('test_data_1.json') == [{'id': 1, 'full_name': 'John Doe'}, {'id': 2, 'full_name': 'Jane Smith'}]\n", "\nassert extract_user_info('test_data_2.json') == [{'id': 3, 'full_name': 'Alice Johnson'}, {'id': 4, 'full_name': 'Bob Brown'}]\n", "\nassert extract_user_info('test_data_3.json') == [{'i... |
17049559741393156a0f6163725586ee | [
{
"content": "On te donne une fonction univariée `f` et sa dérivée `df`. Implémente une fonction Python `gradient_descent` qui trouve le minimum de `f` en utilisant l'algorithme de descente de gradient. La fonction `f` prend un seul flottant en entrée et renvoie un flottant. La fonction `df` est la dérivée de `... | ["\nassert gradient_descent(lambda x: x**2, lambda x: 2*x, 10, 0.1, 100) == 0.0\n", "\nassert gradient_descent(lambda x: (x-3)**2, lambda x: 2*(x-3), 0, 0.1, 100) == 3.0\n", "\nassert gradient_descent(lambda x: x**4 - 4*x**2 + 4, lambda x: 4*x**3 - 8*x, 1, 0.01, 1000) == 0.0\n", "\nassert gradient_descent(lambda x: x**... |
026a08266c11b8f48fc4c74474d0b5b5 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer le nième nombre de Fibonacci. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Ta fonction doit prendre un entier n en entrée et renvoyer le nième nombre de Fibonacci.\n\n**Entr... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(6) == 8\n", "\nassert fibonacci(7) == 13\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(15) == 6... |
06458405c0a5115aef3b55d94a21f992 | [
{
"content": "On te donne une liste de points dans un espace 2D, où chaque point est représenté comme une liste de deux entiers. Ta tâche est de construire une chaîne de texte Well-Known Text (WKT) pour une géométrie MultiPoint. La chaîne WKT ne doit pas contenir de points dupliqués consécutifs. Ta fonction doi... | ["\nassert construct_multipoint_wkt([[1, 1], [2, 2], [2, 2], [3, 3], [3, 3], [3, 3], [4, 4]]) == 'MULTIPOINT ((1 1), (2 2), (3 3), (4 4))'\n", "\nassert construct_multipoint_wkt([[0, 0], [0, 0], [0, 0]]) == 'MULTIPOINT ((0 0))'\n", "\nassert construct_multipoint_wkt([[5, 5], [6, 6], [7, 7], [8, 8]]) == 'MULTIPOINT ((5 ... |
db38096007fda2c8ba5bd82f56c76850 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `find_longest_palindrome` qui renvoie la plus longue sous-chaîne palindromique dans `s`. Si plusieurs sous-chaînes ont la même longueur maximale, renvoie la première rencontrée. Un palindrome est une chaîne de c... | ["\nassert find_longest_palindrome(\"babad\") == \"bab\"\n", "\nassert find_longest_palindrome(\"cbbd\") == \"bb\"\n", "\nassert find_longest_palindrome(\"a\") == \"a\"\n", "\nassert find_longest_palindrome(\"ac\") == \"a\"\n", "\nassert find_longest_palindrome(\"racecar\") == \"racecar\"\n", "\nassert find_longest_pal... |
c4dcb3bed702a834e95e30a636add5b8 | [
{
"content": "Tu es chargé de créer un système de recommandation de films. Étant donné un ensemble de données de films représentés sous forme de DataFrame Pandas avec les colonnes `title`, `genre`, `release_year` et `rating`, implémente une fonction `generate_recommendation_report(data, genre_filter)` qui génèr... | ["\nassert generate_recommendation_report(pd.DataFrame({\n 'title': ['Movie1', 'Movie2', 'Movie3', 'Movie4', 'Movie5', 'Movie6', 'Movie7', 'Movie8', 'Movie9', 'Movie10', 'Movie11'],\n 'genre': ['Action', 'Action', 'Action', 'Action', 'Action', 'Action', 'Action', 'Action', 'Action', 'Action', 'Action'],\n 'rel... |
996046db1627bae911f5c79691b96070 | [
{
"content": "On te donne deux listes de nombres à virgule flottante, `list1` et `list2`, chacune contenant `n` éléments, ainsi qu’un petit nombre positif `epsilon`. Ta tâche est de déterminer si les éléments correspondants dans `list1` et `list2` sont presque égaux. Deux nombres à virgule flottante sont consid... | ["\nassert check_nearly_equal_lists([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], 0.1) == True\n", "\nassert check_nearly_equal_lists([1.0, 2.0, 3.0], [1.1, 2.1, 3.1], 0.1) == True\n", "\nassert check_nearly_equal_lists([1.0, 2.0, 3.0], [1.2, 2.2, 3.2], 0.1) == False\n", "\nassert check_nearly_equal_lists([0.0, 0.0, 0.0], [0.0, 0.... |
114b67bdabccbf3482afe03790a34ed4 | [
{
"content": "Tu es un physicien chargé de calculer la vitesse du son isentropique dans divers matériaux dans différentes conditions. On te fournit un ensemble de données contenant la densité (ρ) et la température (T) de plusieurs matériaux à différentes pressions (P). Ton objectif est d'écrire une fonction qui... | ["\nassert calculate_isentropic_sound_speed(\"air\", 101325, {(1.225, 293): 101325}, {\"air\": 1.4}) == (343.2938488224544, 0.0)\n", "\nassert calculate_isentropic_sound_speed(\"water\", 101325, {(1000, 293): 101325}, {\"water\": 4.4}) == (298.0232238769531, 0.0)\n", "\nassert calculate_isentropic_sound_speed(\"steel\"... |
1de1652f515236afd70003aec0ca457b | [
{
"content": "On te donne un tableau d'entiers où chaque élément apparaît exactement trois fois, à l'exception d'un élément qui apparaît exactement une fois. Ta tâche est de trouver et de renvoyer l'élément qui apparaît une seule fois. La solution doit avoir une complexité temporelle linéaire et ne doit pas uti... | ["\nassert singleNumber([2, 2, 2, 3, 3, 3, 4]) == 4\n", "\nassert singleNumber([1, 1, 1, 2]) == 2\n", "\nassert singleNumber([0, 0, 0, 100]) == 100\n", "\nassert singleNumber([-1, -1, -1, 5]) == 5\n", "\nassert singleNumber([10, 10, 10, 1]) == 1\n", "\nassert singleNumber([7, 7, 7, 9]) == 9\n", "\nassert singleNumber([... |
c73fa2fa3b2b7d95571dc8084ad8a094 | [
{
"content": "On te donne un dictionnaire où les clés sont les noms de villes et les valeurs sont les températures en Fahrenheit. Ta tâche est d'implémenter une fonction `convert_temperatures` qui convertit toutes les températures en Celsius en utilisant la formule suivante : Celsius = (Fahrenheit - 32) * 5 / 9... | ["\nassert convert_temperatures({\"New York\": 50}) == {\"New York\": 10.0}\n", "\nassert convert_temperatures({\"Los Angeles\": 75}) == {\"Los Angeles\": 23.88888888888889}\n", "\nassert convert_temperatures({\"Chicago\": 30}) == {\"Chicago\": -1.1111111111111112}\n", "\nassert convert_temperatures({\"Houston\": 60}) ... |
ed5f4f5b7682d322c4950665921fcc3b | [
{
"content": "On te donne une chaîne de caractères `url`. Ta tâche est de déterminer si c'est une URL valide. Une URL est considérée comme valide si elle possède à la fois un schéma (par exemple, \"http\", \"https\") et un emplacement réseau (netloc, par exemple, \"www.example.com\"). Implémente une fonction `i... | ["\nassert is_valid_url(\"https://www.example.com/path?query=param#fragment\") == True\n", "\nassert is_valid_url(\"http://example.com\") == True\n", "\nassert is_valid_url(\"ftp://example.com\") == True\n", "\nassert is_valid_url(\"www.example.com\") == False\n", "\nassert is_valid_url(\"https://example\") == True\n",... |
ad678b473649cefbf1f402524e3f65c8 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si elle est un palindrome, en ne considérant que 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\n**... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Hello, World!\") == False\n", "\nassert is... |
cf9d9b8f7d44a3cbb9c148eb21e00114 | [
{
"content": "On te demande d'implémenter une classe `Fraction` en Python qui prenne en charge les opérations arithmétiques de base et la simplification. La classe doit gérer les opérations suivantes :\n\n- **Addition** : Additionner deux fractions.\n- **Soustraction** : Soustraire deux fractions.\n- **Multipli... | ["\nassert str(Fraction(1, 2) + Fraction(1, 2)) == \"1/1\"\n", "\nassert str(Fraction(3, 4) - Fraction(1, 4)) == \"1/2\"\n", "\nassert str(Fraction(2, 3) * Fraction(3, 4)) == \"1/2\"\n", "\nassert str(Fraction(1, 2) / Fraction(1, 4)) == \"2/1\"\n", "\nassert str(Fraction(10, 20)) == \"1/2\"\n", "\nassert str(Fraction(0... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.