id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
ba412d166b3b2b6386fbbea1d7781def | [
{
"content": "On te donne une fonction polynomiale de deux variables, \\( x \\) et \\( y \\), définie comme suit :\n\n\\[ f(x, y) = 10 + 3x - 20y + 3xy + 21y^2 - 8x^3 - 3xy^2 - 6y^4 + x^3y^2 \\]\n\nTa tâche est d'implémenter une fonction qui calcule la valeur de ce polynôme et son gradient en un point donné \\(... | ["\nassert polynomial_function_and_gradient([0, 0]) == (10, np.array([3, -20]))\n", "\nassert polynomial_function_and_gradient([1, 1]) == (10, np.array([-21, -28]))\n", "\nassert polynomial_function_and_gradient([0.5, 0.5]) == (10.5, np.array([-18.75, -10.25]))\n", "\nassert polynomial_function_and_gradient([0, 1]) == ... |
7d81c32e255d44022d62581b6be0345c | [
{
"content": "On te donne un fichier nommé `students.txt` qui contient une liste d'étudiants et de leurs classes respectives. Chaque ligne du fichier représente une paire étudiant-classe, avec le nom de l'étudiant et la classe séparés par deux-points (`:`). Ta tâche est d'écrire un programme qui lit ce fichier ... | ["\nassert read_student_classes(\"test1.txt\") == [('Alice', 'Art'), ('Bob', 'English')]\n", "\nassert read_student_classes(\"test2.txt\") == [('Charlie', 'Algebra'), ('David', 'Economics')]\n", "\nassert read_student_classes(\"test3.txt\") == [('Eve', 'English'), ('Frank', 'Art')]\n", "\nassert read_student_classes(\"... |
0116bd96ca9f4996147266b238c74c25 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé du nom d'un étudiant (une chaîne de caractères) et d'une liste de ses notes (entiers). Ta tâche est d'écrire une fonction Python qui calcule la moyenne des notes pour chaque étudiant et renvoie un dictionnaire avec le nom de l'étudiant c... | ["\nassert calculate_average_grades([(\"Alice\", [85, 92, 78])]) == {\"Alice\": 85.0}\n", "\nassert calculate_average_grades([(\"Bob\", [88, 90])]) == {\"Bob\": 89.0}\n", "\nassert calculate_average_grades([(\"Charlie\", [74, 80, 78, 85])]) == {\"Charlie\": 79.25}\n", "\nassert calculate_average_grades([(\"David\", [10... |
0a862ece8d329031e7522899b06743bd | [
{
"content": "On te donne une chaîne de caractères au format CamelCase. Ta tâche est d'écrire une fonction `convert_to_snake_case` qui convertit cette chaîne en format snake_case. En snake_case, toutes les lettres sont en minuscules et les mots sont séparés par des tirets bas. Par exemple, la chaîne \"HelloWorl... | ["\nassert convert_to_snake_case(\"HelloWorld\") == \"hello_world\"\n", "\nassert convert_to_snake_case(\"ThisIsASampleString\") == \"this_is_a_sample_string\"\n", "\nassert convert_to_snake_case(\"PythonIsFun\") == \"python_is_fun\"\n", "\nassert convert_to_snake_case(\"convertToSnakeCase\") == \"convert_to_snake_case... |
78a09c2adc4e1ee96cdab5fba74418d1 | [
{
"content": "On te donne un fichier texte nommé `data.txt` contenant plusieurs lignes de texte. Chaque ligne est composée d'un horodatage au format `AAAA-MM-JJ HH:MM:SS` suivi d'une lecture de température en Celsius. Ta tâche est d'écrire une fonction Python `calculate_average_temperature` qui lit le fichier, ... | ["\nassert calculate_average_temperature('data_single_line.txt') == 23.5\n", "\nassert calculate_average_temperature('data_multiple_lines.txt') == 18.25\n", "\nassert calculate_average_temperature('data_empty.txt') == 0.0\n", "\nassert calculate_average_temperature('data_invalid_lines.txt') == 15.0\n", "\nassert calcul... |
a905d0641c3b4be49d126c75fd72020e | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots anglais séparés par des espaces et pouvant inclure de la ponctuation. Ta tâche est de mettre en œuvre une fonction `count_words` qui traite cette chaîne et renvoie un dictionnaire. Le dictionnaire doit associer chaque mot unique (sans ... | ["\nassert count_words(\"Hello, world! Hello, everyone.\") == {'hello': 2, 'world': 1, 'everyone': 1}\n", "\nassert count_words(\"Python is great. Python is fun.\") == {'python': 2, 'is': 2, 'great': 1, 'fun': 1}\n", "\nassert count_words(\"A quick brown fox jumps over the lazy dog.\") == {'a': 1, 'quick': 1, 'brown': ... |
e0a99149258f1990e279970515cf9355 | [
{
"content": "On te donne une liste de noms de fichiers et un entier `num_processes`. Ta tâche est de partitionner la liste des noms de fichiers en `num_processes` blocs de telle sorte que :\n- Aucun bloc ne contienne plus de 50 % du nombre total de fichiers.\n- Chaque bloc maintient l'ordre original des fichie... | ["\nassert divide_files_into_chunks([\"file1.txt\", \"file2.txt\", \"file3.txt\"], 2) == [[\"file1.txt\", \"file2.txt\"], [\"file3.txt\"]]\n", "\nassert divide_files_into_chunks([\"file1.txt\", \"file2.txt\", \"file3.txt\", \"file4.txt\"], 2) == [[\"file1.txt\", \"file2.txt\"], [\"file3.txt\", \"file4.txt\"]]\n", "\nas... |
f0bbd39da7133317a4feedaec94e00b2 | [
{
"content": "On te demande d'implémenter une classe Python `Employee` pour gérer les détails et les opérations des employés. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Attributs :**\n - `name` (str) : Le nom de l'employé.\n - `employee_id` (int) : Un identifiant unique pour l'emp... | ["\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", "\nemp = Emplo... |
fcbac797d422ef998e9f4a0fe82c3984 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui trouve et renvoie le plus petit entier de la liste. La fonction doit fonctionner avec une complexité temporelle de O(n). Si la liste est vide, la fonction doit renvoyer `None`.\n\n**Exemple d'entrée :**\n```\n[5, 2, 9, ... | ["\nassert find_smallest_number([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 1\n", "\nassert find_smallest_number([10, 20, 30, 40, 50]) == 10\n", "\nassert find_smallest_number([-10, -20, -30, -40, -50]) == -50\n", "\nassert find_smallest_number([0, 0, 0, 0, 0]) == 0\n", "\nassert find_smallest_number([100]) == 100\n", "\nass... |
9fcf4ad6085f16b0a8df04fab4a92dcf | [
{
"content": "On te donne un tableau binaire `nums`. Ta tâche est de trouver la plus longue sous-tableau contiguë avec un nombre égal de zéros et de uns. S'il existe plusieurs sous-tableaux de la même longueur, renvoie l'un d'entre eux. Si aucun sous-tableau de ce type n'existe, renvoie un tableau vide. La fonc... | ["\nassert find_max_len([0, 1]) == [0, 1]\n", "\nassert find_max_len([0, 1, 0, 1, 0, 1, 1]) in [[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 1, 0]]\n", "\nassert find_max_len([0, 0, 1, 0, 0, 0, 1, 1]) == [0, 0, 1, 0, 0, 0, 1, 1]\n", "\nassert find_max_len([1, 0, 1, 0, 1, 0, 1]) == [1, 0, 1, 0, 1, 0, 1]\... |
b90ddbf174a8f91e9bebe32248716a67 | [
{
"content": "On te donne deux vecteurs tridimensionnels représentés sous forme de listes. Ta tâche est de mettre en œuvre une fonction `vector_magnitude_difference` qui calcule la différence absolue entre les magnitudes de ces vecteurs. La fonction doit lever une exception `ValueError` si l'une des entrées n'e... | ["\nassert vector_magnitude_difference([1, 2, 3], [4, 5, 6]) == abs(math.sqrt(14) - math.sqrt(77))\n", "\nassert vector_magnitude_difference([0, 0, 0], [0, 0, 0]) == 0\n", "\nassert vector_magnitude_difference([3, 4, 0], [0, 0, 5]) == 1\n", "\nassert vector_magnitude_difference([-1, -1, -1], [1, 1, 1]) == 2 * math.sqrt... |
ec6e898c947ff2e2091b7542af06b87e | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est de mettre en œuvre une fonction `clean_text` qui traite la chaîne selon les règles suivantes :\n1. Convertis tous les caractères majuscules en minuscules.\n2. Supprime tous les espaces en début et en fin de chaîne, ainsi que les espaces... | ["\nassert clean_text(\" This is a TEST string \") == \"this is a test string\"\n", "\nassert clean_text(\"Hello, World!\") == \"hello, world!\"\n", "\nassert clean_text(\" Multiple spaces here! \") == \"multiple spaces here!\"\n", "\nassert clean_text(\"NoSpaces\") == \"nospaces\"\n", "\nassert clean_text(\... |
30978030ea05c2698d2054ff76990637 | [
{
"content": "On te demande d'implémenter la fonction `split_message`, qui traite une chaîne de caractères `message` en fonction d'une liste de `delimiters`. La liste `delimiters` peut contenir des entiers représentant des points de séparation et des tuples représentant des plages de séparation imbriquées. La f... | ["\nassert split_message(\"Hello, World!\", [5, 12], [\"greeting\", \"punctuation\"]) == {\"greeting\": \"Hello\", \"punctuation\": \", World!\"}\n", "\nassert split_message(\"Hello, World!\", [5, 12]) == [\"Hello\", \", World!\"]\n", "\nassert split_message(\"Hello, World!\", None) == \"Hello, World!\"\n", "\nassert s... |
85d461e4d3376846fc0cbd20d42f6d91 | [
{
"content": "Implémente une structure de données pile en utilisant une liste en Python. Ta pile doit prendre en charge les opérations suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élément du sommet de la pile. Si la pile est vide, lève une exception `I... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().peek() == None\n", "\nstack = Stack()\nstack.push(1)\nassert stack.peek() == 1\n", "\nstack = Stack()\nstack.push(1)\nstack.push(2)\nassert stack.pop() == 2\n", "\nstack = Stack()\nstack.push(1)\nstack.push(2)\nstack.pop()\nassert stack.is_empty() == False\n",... |
21b99ffa84e7d19ba71eb837be5d0021 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `find_prime_factors` qui identifie les nombres dans la liste qui sont strictement supérieurs à 100 et strictement inférieurs à 500. Pour chacun de ces nombres, détermine s'ils ont un nombre impair de facteurs premiers distincts. S... | ["\nassert find_prime_factors([101, 103, 107]) == []\n", "\nassert find_prime_factors([105, 106, 107]) == [[3, 5, 7]]\n", "\nassert find_prime_factors([150, 221, 231]) == [[2, 3, 5], [13, 17], [3, 7, 11]]\n", "\nassert find_prime_factors([342, 496]) == [[2, 3, 19]]\n", "\nassert find_prime_factors([100, 500]) == []\n",... |
a57a8bfb942616c2b056b13fbf1eed8d | [
{
"content": "On te demande d'implémenter une fonction `countPrimes(n)` qui détermine efficacement le nombre de nombres premiers inférieurs à un entier donné `n`. Un nombre premier est défini comme un nombre naturel supérieur à 1 qui n'a pas de diviseurs autres que 1 et lui-même. Ta solution doit utiliser l'alg... | ["\nassert countPrimes(10) == 4\n", "\nassert countPrimes(2) == 0\n", "\nassert countPrimes(1) == 0\n", "\nassert countPrimes(0) == 0\n", "\nassert countPrimes(20) == 8\n", "\nassert countPrimes(30) == 10\n", "\nassert countPrimes(100) == 25\n", "\nassert countPrimes(1000) == 168\n", "\nassert countPrimes(10000) == 122... |
52ed947a1443d37645ca2d21c47be6e3 | [
{
"content": "Tu es chargé d'implémenter une classe `Rectangle` en Python qui inclut un constructeur pour initialiser les dimensions du rectangle et une méthode pour calculer son aire. Le constructeur doit valider que la longueur et la largeur sont des nombres positifs, en levant une exception `ValueError` si c... | ["\nassert Rectangle(10, 2).calculate_area() == 20\n", "\nassert Rectangle(7, 7).calculate_area() == 49\n", "\nassert Rectangle(1, 1).calculate_area() == 1\n", "\nassert Rectangle(0.5, 2).calculate_area() == 1.0\n", "\nassert Rectangle(3, 0.5).calculate_area() == 1.5\n", "\nassert Rectangle(100, 100).calculate_area() =... |
a505dcdad2a0de1bdc57d52f85b85244 | [
{
"content": "Implémente une fonction génératrice Python nommée `even_numbers` qui produit une séquence infinie de nombres pairs commençant à 0. Ta fonction doit produire des nombres dans l'ordre croissant, en commençant par 0. Par exemple, les cinq premiers nombres générés doivent être `0, 2, 4, 6, 8`.\n\n**Ex... | ["\nassert next(even_numbers()) == 0\n", "\ngen = even_numbers()\nassert next(gen) == 0 and next(gen) == 2\n", "\ngen = even_numbers()\nassert next(gen) == 0 and next(gen) == 2 and next(gen) == 4\n", "\ngen = even_numbers()\nassert next(gen) == 0 and next(gen) == 2 and next(gen) == 4 and next(gen) == 6\n", "\ngen = eve... |
c480793baad14595dc9a087a0d271211 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction `find_largest_palindrome` qui identifie le palindrome le plus long dans la liste. Un palindrome est défini comme une chaîne de caractères qui se lit de la même manière de gauche à droite et de droite à gauc... | ["\nassert find_largest_palindrome([\"racecar\", \"banana\", \"level\", \"world\"]) == \"racecar\"\n", "\nassert find_largest_palindrome([\"noon\", \"civic\", \"rotor\", \"deified\"]) == \"deified\"\n", "\nassert find_largest_palindrome([\"abc\", \"def\", \"ghi\"]) == None\n", "\nassert find_largest_palindrome([\"a\", ... |
d71fbef87951d37c6a9f9e38c50f078f | [
{
"content": "On te donne une liste contenant jusqu'à 10 entiers positifs. Ton objectif est d'écrire une fonction qui calcule le plus petit commun multiple (PPCM) de tous les entiers de la liste. Si la liste est vide, la fonction doit renvoyer 1. Si un nombre dans la liste n'est pas un entier positif, la foncti... | ["\nassert lcm([2, 3]) == 6\n", "\nassert lcm([4, 5, 6]) == 60\n", "\nassert lcm([7, 3, 2]) == 42\n", "\nassert lcm([1, 2, 3, 4, 5]) == 60\n", "\nassert lcm([10, 15, 20]) == 60\n", "\nassert lcm([]) == 1\n", "\nassert lcm([11]) == 11\n", "\nassert lcm([2, 2, 2, 2]) == 2\n", "\nassert lcm([9, 12, 15]) == 180\n", "\nasse... |
695154d718651e0bbe47db542093c3ff | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ta tâche est de mettre en œuvre une fonction `find_element_index` qui renvoie l'index de la première occurrence de `target` dans `numbers`. Si `target` n'est pas présent dans la liste, la fonction doit renvoyer -1. Tu n'es pas autori... | ["\nassert find_element_index([1, 2, 3, 4, 5], 3) == 2\n", "\nassert find_element_index([10, 20, 30, 40, 50], 20) == 1\n", "\nassert find_element_index([5, 5, 5, 5, 5], 5) == 0\n", "\nassert find_element_index([1, 2, 3, 4, 5], 6) == -1\n", "\nassert find_element_index([], 1) == -1\n", "\nassert find_element_index([7, 8... |
63735f39e52d843fcee4bf8e72493503 | [
{
"content": "On te donne une liste de nombres qui peut inclure la valeur spéciale `None`. Ta tâche est de mettre en œuvre une fonction `average` qui calcule la moyenne des nombres dans la liste. Traite les valeurs `None` comme des zéros, trie la liste par ordre croissant et ignore les nombres dupliqués. Si la ... | ["\nassert average([1, 2, 3, None, 5]) == 2.5\n", "\nassert average([None, None, None]) == 0.0\n", "\nassert average([]) == None\n", "\nassert average([1, 1, 1, 1, 1]) == 1.0\n", "\nassert average([10, 20, 30, 40, 50]) == 30.0\n", "\nassert average([5, 5, 5, 5, 5, None]) == 5.0\n", "\nassert average([1, 2, 2, 3, 4, 4, ... |
48d6be509d449880b3e52a07908f65a1 | [
{
"content": "On te donne une séquence de cours de clôture quotidiens d'une action sous forme de liste d'entiers. Ta tâche est de mettre en œuvre une fonction `calculate_moving_average` qui calcule la moyenne mobile des prix de l'action sur une taille de fenêtre spécifiée. La fonction doit accepter deux paramèt... | ["\nassert calculate_moving_average([1, 2, 3, 4, 5], 2) == [1.5, 2.5, 3.5, 4.5]\n", "\nassert calculate_moving_average([10, 20, 30, 40, 50], 3) == [20.0, 30.0, 40.0]\n", "\nassert calculate_moving_average([5, 5, 5, 5, 5], 5) == [5.0]\n", "\nassert calculate_moving_average([1, 2, 3], 4) == []\n", "\nassert calculate_mov... |
b40d80baa62019fdfb167e7f5d34e43f | [
{
"content": "Tu es chargé de développer une fonction pour une application de traitement de texte. La fonction doit accepter une chaîne de caractères en entrée et renvoyer une nouvelle chaîne de caractères avec tous les mots dupliqués supprimés, tout en conservant l'ordre original de la première occurrence de c... | ["\nassert remove_duplicate_words(\"hello world hello python world\") == \"hello world python\"\n", "\nassert remove_duplicate_words(\"one two three two one\") == \"one two three\"\n", "\nassert remove_duplicate_words(\"a a a a a\") == \"a\"\n", "\nassert remove_duplicate_words(\"unique words only\") == \"unique words ... |
00d45a29d82490761f04b454dc031223 | [
{
"content": "On te demande de développer une fonction nommée `image_specs` qui calcule et formate les dimensions et les tailles de pixels d'une image rectangulaire en fonction de paramètres spécifiques. La fonction doit respecter les spécifications suivantes :\n\n- **Paramètres :**\n - `shape` : Un tuple `(ro... | ["\nassert image_specs((10, 10), 100, 1.0) == \"IMG:10:10:8:8\"\n", "\nassert image_specs((5, 5), 50, 2.0) == \"IMG:5:5:16:16\"\n", "\nassert image_specs((8, 4), 64, 0.5) == \"IMG:8:4:2.0:4.0\"\n", "\nassert image_specs((3, 6), 36, 1.5) == \"IMG:3:6:4.0:2.0\"\n", "\nassert image_specs((1, 1), 100, 1.0) == \"IMG:1:1:80:... |
0c819c6339a7ea6a4148723d11acb5c9 | [
{
"content": "On te demande d'implémenter un système de gestion de bibliothèque simple 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. Si le livre existe déjà (même titre et auteur), ne l'ajoute pas à n... | ["\nassert Library().get_all_books() == []\n", "\nassert Library().search_book(\"Nonexistent Book\") == []\n", "\nlib = Library(); lib.add_book(\"1984\", \"George Orwell\"); assert lib.get_all_books() == [{'title': '1984', 'authors': ['George Orwell']}]\n", "\nlib = Library(); lib.add_book(\"1984\", \"George Orwell\");... |
1c168b3576c2e52dfe33c5e48a7b4015 | [
{
"content": "On te donne un fichier CSV nommé `employees.csv` contenant les colonnes suivantes : `ID`, `Name`, `Department` et `Salary`. Ta tâche est de calculer le salaire moyen pour chaque département et d'afficher les résultats dans un tableau formaté. Le fichier CSV inclut une ligne d'en-tête.\n\n**Format ... | ["\nassert calculate_average_salary('test_employees_1.csv') == None\n", "\nassert calculate_average_salary('test_employees_2.csv') == None\n", "\nassert calculate_average_salary('test_employees_3.csv') == None\n", "\nassert calculate_average_salary('test_employees_empty.csv') == None\n", "\nassert calculate_average_sal... |
2f135f9b3b5457fb6b4d6d40a6158b5b | [
{
"content": "Tu développes un système pour automatiser les demandes de courses. Implémente la fonction `grocery_request` qui prend deux listes en entrée : `items` et `quantities`. Chaque index dans les listes correspond à un article de course spécifique et à sa quantité souhaitée. La fonction doit renvoyer une... | ["\nassert grocery_request([\"apple\"], [1]) == \"Could I please have 1 of apple(s)?\"\n", "\nassert grocery_request([\"banana\", \"orange\"], [2, 3]) == \"Could I please have 2 of banana(s)? Could I please have 3 of orange(s)?\"\n", "\nassert grocery_request([\"milk\", \"bread\", \"eggs\"], [1, 2, 12]) == \"Could I pl... |
69256d832dd82b6dfc28572f17f9e793 | [
{
"content": "On te donne pour tâche de classifier des noms de fichiers en fonction des caractères qu'ils contiennent. Un nom de fichier est considéré comme valide s'il ne contient que des caractères alphanumériques et a une longueur maximale de 100 caractères. Ton travail consiste à écrire une fonction `classi... | ["\nassert classify_filename(\"abc123\") == \"AlphaNumeric (Mixed Case)\"\n", "\nassert classify_filename(\"12345\") == \"Numeric\"\n", "\nassert classify_filename(\"ABC\") == \"AlphaNumeric (Upper Case Only)\"\n", "\nassert classify_filename(\"abc\") == \"Alphabetic\"\n", "\nassert classify_filename(\"abc_def\") == \"... |
41b685f7fadc7fb77e5dbdab6ed35eef | [
{
"content": "On te donne une grille 2D d'entiers où chaque ligne est triée par ordre croissant mais peut être décalée circulairement d'un nombre inconnu de positions. Chaque ligne est garantie d'être plus grande que la précédente. Ta tâche est d'implémenter une fonction qui recherche un entier cible dans cette... | ["\nassert search_in_circular_sorted_grid([[4, 5, 6, 1, 2, 3], [4, 5, 6, 7, 0, 1], [7, 8, 9, 1, 2, 3]], 5) == True\n", "\nassert search_in_circular_sorted_grid([[4, 5, 6, 1, 2, 3], [4, 5, 6, 7, 0, 1], [7, 8, 9, 1, 2, 3]], 10) == False\n", "\nassert search_in_circular_sorted_grid([[1, 2, 3, 4, 5], [2, 3, 4, 5, 1], [3, 4... |
03d6f6d04ecf18804e83ca9d91c0c622 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `calculate_statistics` qui calcule la moyenne, la médiane et le mode de la liste. La fonction doit renvoyer un dictionnaire avec les clés 'mean', 'median' et 'mode'. Utilise le module `statistics` pour tes calculs.\n\n**Entré... | ["\nassert calculate_statistics([1, 2, 2, 3, 4]) == {'mean': 2.4, 'median': 2, 'mode': 2}\n", "\nassert calculate_statistics([1, 1, 2, 3, 4, 4]) == {'mean': 2.5, 'median': 2.5, 'mode': 1}\n", "\nassert calculate_statistics([5]) == {'mean': 5, 'median': 5, 'mode': 5}\n", "\nassert calculate_statistics([1, 2, 3, 4, 5, 6,... |
ac0f7a0435f485b7272fe8f2476d27fd | [
{
"content": "On te demande d'implémenter une fonction `configure_model` qui charge de manière asynchrone un modèle et un fichier de configuration. La fonction doit utiliser la bibliothèque `asyncio` pour les opérations asynchrones et `aiofiles` pour la lecture asynchrone des fichiers. Ton implémentation doit g... | ["\nassert asyncio.run(configure_model(ModelConfig(\"path/to/model\", \"path/to/config.json\"))) is None\n", "\nassert asyncio.run(configure_model(ModelConfig(\"model.bin\", \"config.json\"))) is None\n", "\nassert asyncio.run(configure_model(ModelConfig(\"\", \"\"))) is None\n", "\nassert asyncio.run(configure_model(M... |
bce19e73a5ff9278aaaceb6eb6655f72 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python. La classe doit avoir les attributs suivants : `make`, `model`, `year` et `mileage`. Ton implémentation doit inclure les méthodes suivantes :\n\n- `update_mileage(new_mileage)` : Met à jour le kilométrage de la voiture à `new_mileage` si `new_... | ["\nassert Car(\"Toyota\", \"Corolla\", 2021, 15000).car_description() == \"2021 Toyota Corolla with 15,000 miles\"\n", "\nassert Car(\"Honda\", \"Civic\", 2019, 20000).get_mileage() == 20000\n", "\nassert Car(\"Ford\", \"Mustang\", 2020, 10000).update_mileage(12000) is None\n", "\nassert Car(\"Chevrolet\", \"Impala\",... |
bcd86ab6de7c6177feb9bb5136fc0c30 | [
{
"content": "On te donne une liste de phrases. Ton objectif est d'implémenter une fonction `clean_text` qui traite chaque phrase en remplaçant tous les signes de ponctuation (y compris les tirets bas, les points et les points d'interrogation) par des espaces, en supprimant les espaces au début et à la fin, et ... | ["\nassert clean_text([\"Hello, world!\"]) == [\"Hello world\"]\n", "\nassert clean_text([\"This_is_a_test.\"]) == [\"This is a test\"]\n", "\nassert clean_text([\"What? Is this...\"]) == [\"What Is this\"]\n", "\nassert clean_text([\"Multiple___underscores\"]) == [\"Multiple underscores\"]\n", "\nassert clean_text([\"... |
305abc2a337e146cc214c04832d1b22b | [
{
"content": "On te demande d'écrire une fonction pour valider les adresses e-mail en utilisant des expressions régulières. Ta fonction doit renvoyer `True` si l'adresse e-mail donnée est valide, et `False` sinon. Une adresse e-mail est considérée comme valide si elle respecte le schéma suivant :\n- Commence pa... | ["\nassert is_valid_email(\"example@example.com\") == True\n", "\nassert is_valid_email(\"user.name+tag+sorting@example.com\") == True\n", "\nassert is_valid_email(\"user@sub.example.co.uk\") == True\n", "\nassert is_valid_email(\"user@.com\") == False\n", "\nassert is_valid_email(\"user@domain,com\") == False\n", "\na... |
7a34ea02837352d406aa34bdca7c9544 | [
{
"content": "Tu es chargé d'implémenter une fonction pour générer la suite de Fibonacci jusqu'au nième terme. Pour optimiser le calcul, utilise la mémoïsation. Ta fonction doit renvoyer une liste contenant la suite de Fibonacci jusqu'au nième terme.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 50), représentant l... | ["\nassert fibonacci_sequence(1) == [0]\n", "\nassert fibonacci_sequence(2) == [0, 1]\n", "\nassert fibonacci_sequence(3) == [0, 1, 1]\n", "\nassert fibonacci_sequence(4) == [0, 1, 1, 2]\n", "\nassert fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci_sequence(6) == [0, 1, 1, 2, 3, 5]\n", "\nassert fibona... |
57f6a497d63b855be8ee227fd78230f9 | [
{
"content": "On te donne une liste de villes et une matrice de distances représentant les distances entre chaque paire de villes. Ta tâche est de trouver le chemin le plus court qui visite chaque ville exactement une fois et retourne à la ville de départ. Il s'agit du problème classique du voyageur de commerce... | ["\nassert optimize_route(['A', 'B'], [[0, 1], [1, 0]]) == (['A', 'B', 'A'], 2)\n", "\nassert optimize_route(['A', 'B', 'C'], [[0, 1, 2], [1, 0, 3], [2, 3, 0]]) == (['A', 'B', 'C', 'A'], 6)\n", "\nassert optimize_route(['A', 'B', 'C', 'D'], [[0, 1, 2, 3], [1, 0, 4, 5], [2, 4, 0, 6], [3, 5, 6, 0]]) == (['A', 'B', 'C', '... |
0661b69c0d4fecf0bdf8b41bf6333773 | [
{
"content": "On te donne une chaîne de caractères `input_word` et une liste de chaînes de caractères `word_list`. Ta tâche est de mettre en œuvre une fonction `find_anagrams` qui renvoie un dictionnaire où les clés sont les anagrammes de `input_word` trouvés dans `word_list` et les valeurs sont les nombres d'o... | ["\nassert find_anagrams(\"listen\", [\"enlist\", \"silent\", \"inlets\", \"banana\"]) == [\"enlist\", \"silent\"]\n", "\nassert find_anagrams(\"abc\", [\"cab\", \"bac\", \"bca\", \"xyz\"]) == [\"cab\", \"bac\", \"bca\"]\n", "\nassert find_anagrams(\"hello\", [\"world\", \"hello\", \"olleh\", \"loleh\"]) == [\"hello\",... |
047650b1e163beb589fa016e50810587 | [
{
"content": "On te demande d'implémenter une fonction `read_json_file` qui lit un fichier JSON à partir d'un chemin donné et renvoie son contenu sous forme de dictionnaire Python. Ta fonction doit gérer les cas limites suivants :\n- Le fichier n'existe pas.\n- Le fichier contient du JSON invalide.\n\nTa foncti... | ["\nassert read_json_file(\"non_existent_file.json\") == None\n", "\nassert read_json_file(\"empty_file.json\") == {}\n", "\nassert read_json_file(\"valid_json.json\") == {\"key\": \"value\"}\n", "\nassert read_json_file(\"malformed_json.json\") == None\n", "\nassert read_json_file(\"invalid_path/valid_json.json\") == ... |
aedd9a7277d1cbd710f70c83526d86bf | [
{
"content": "On te donne deux dictionnaires, `d1` et `d2`, où chaque clé est une chaîne de caractères et chaque valeur est une liste de chaînes de caractères. Ta tâche est de créer un nouveau dictionnaire `d3` en fusionnant `d1` et `d2`. Pour chaque clé dans `d3`, la valeur doit être une liste contenant tous l... | ["\nassert merge_dictionaries({'a': ['apple', 'banana'], 'b': ['banana', 'orange']}, {'a': ['banana', 'cherry'], 'b': ['grape'], 'c': ['kiwi']}) == {'a': ['apple', 'banana', 'cherry'], 'b': ['banana', 'orange', 'grape'], 'c': ['kiwi']}\n", "\nassert merge_dictionaries({}, {}) == {}\n", "\nassert merge_dictionaries({'x'... |
4ec1b4b84fc6f7f08d589ccfb8178465 | [
{
"content": "On te donne une grille 2D de taille `m x n` composée de `0` (eau) et de `1` (terre). Une île est définie comme un groupe de `1` connectés (horizontalement ou verticalement). Ta tâche est d'écrire une fonction `count_islands` qui renvoie le nombre d'îles dans la grille.\n\n**Entrée :**\n- La premiè... | ["\nassert count_islands([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == 0\n", "\nassert count_islands([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) == 1\n", "\nassert count_islands([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == 3\n", "\nassert count_islands([[1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 1]]) == 3\n", "\nassert co... |
059c12d8db5ca517ce53b6f3b629d753 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`, qui peuvent avoir des longueurs différentes. Ta tâche est de créer une nouvelle liste, `merged_list`, en fusionnant `list1` et `list2` selon les règles suivantes :\n\n- Si les deux éléments à l'index `i` dans `list1` et `list2` sont non nuls, ... | ["\nassert merge_lists([1, 2, 3], [4, 5, 6]) == [5, 7, 9]\n", "\nassert merge_lists([0, 2, 0], [4, 0, 6]) == [4, 2, 6]\n", "\nassert merge_lists([1, 0, 3], [0, 5, 0]) == [1, 5, 3]\n", "\nassert merge_lists([0, 0, 0], [0, 0, 0]) == []\n", "\nassert merge_lists([1, 2], [3, 4, 5, 6]) == [4, 6, 5, 6]\n", "\nassert merge_li... |
63031ddb8ebddaef1f1d5abfe65cc57e | [
{
"content": "On te demande d'implémenter une fonction `average_score_to_performance_rating(average_score)` qui évalue la performance d'un étudiant en fonction de son score moyen aux tests. La fonction doit gérer à la fois les scores individuels et les itérables de scores. La notation de performance est détermi... | ["\nassert average_score_to_performance_rating(55) == 'Failing'\n", "\nassert average_score_to_performance_rating(65) == 'Needs Improvement'\n", "\nassert average_score_to_performance_rating(75) == 'Satisfactory'\n", "\nassert average_score_to_performance_rating(85) == 'Good'\n", "\nassert average_score_to_performance_... |
36a73f3ca5115026d812ac88520d7dee | [
{
"content": "On te donne une liste de mots homophones ainsi que leurs noms de séries et leurs types de séries correspondants. Le type de série peut être soit 1 (addition) soit 0 (déduction). On te fournit également une liste de chaînes de données, chacune commençant par un horodatage au format \"HH:MM.SS\" ent... | ["\nassert process_homophonic_words([], []) == [{}, {}, {}, {}, {}]\n", "\nassert process_homophonic_words([('Series1', 'right', 1)], ['[12:34.56] right is the way']) == [{'right': ['12:34']}, {'Series1': ['12:34']}, {}, {}, {'Series1': ['right']}]\n", "\nassert process_homophonic_words([('Series1', 'right', 1), ('Seri... |
38983a45372be0dc1c9c2c06ab8108ed | [
{
"content": "On te donne une chaîne de caractères `s` composée de mots séparés par des espaces. Ta tâche est d'écrire une fonction qui inverse chaque mot de la chaîne tout en conservant l'ordre original des mots.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ len(s) ≤ 1000), où les mots sont séparé... | ["\nassert reverse_words(\"hello world\") == \"olleh dlrow\"\n", "\nassert reverse_words(\"python is fun\") == \"nohtyp si nuf\"\n", "\nassert reverse_words(\"reverse each word\") == \"esrever hcae drow\"\n", "\nassert reverse_words(\"a b c\") == \"a b c\"\n", "\nassert reverse_words(\"123 456 789\") == \"321 654 987\"... |
2061ee220f843002a5615d6d9b1faa3f | [
{
"content": "On te demande d'évaluer les performances de différents algorithmes de tri sur un ensemble de données volumineux. Implémente un programme qui génère un ensemble de données de 10 000 entiers aléatoires compris entre 1 et 1 000 000. Ton programme doit trier cet ensemble de données en utilisant les al... | ["\nassert isinstance(bubble_sort([3, 2, 1]), list)\n", "\nassert insertion_sort([1, 3, 2]) == [1, 2, 3]\n", "\nassert selection_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([9, 7, 5, 11, 12, 2, 14, 3, 10, 6]) == [2, 3, 5, 6, 7, 9, 10, 11, 12, 14]\n", "\nassert quick_sort([10, 7, 8, 9, 1, 5]) == [1... |
157a9cf8717f1aaae4190ba6c0016bcb | [
{
"content": "On te donne un fichier texte nommé `log.txt` contenant des entrées de journal, chacune sur une ligne distincte. Chaque entrée de journal est formatée comme `timestamp:message`, où `timestamp` et `message` sont séparés par deux-points. Ta tâche est d'écrire une fonction Python qui lit ce fichier, e... | ["\nassert extract_timestamps('log.txt', 'timestamps.txt') is None\n", "\nassert extract_timestamps('nonexistentfile.txt', 'timestamps.txt') is None\n", "\nassert extract_timestamps('emptyfile.txt', 'timestamps.txt') is None\n", "\nassert extract_timestamps('singleentry.txt', 'timestamps.txt') is None\n", "\nassert ext... |
b087c761b258e6da937598a8a96e9008 | [
{
"content": "On te demande d'implémenter un programme pour gérer une collection de voitures. Chaque voiture est représentée par sa `marque`, son `modèle` et son `année`. Ton objectif est de lire ces informations à partir d'un fichier CSV nommé `cars.csv` et de les stocker sous forme de liste d'objets `Car`. Le... | ["\nassert car_list[0].make == \"Toyota\" and car_list[0].model == \"Corolla\" and car_list[0].year == 2020\n", "\nassert car_list[1].make == \"Honda\" and car_list[1].model == \"Civic\" and car_list[1].year == 2019\n", "\nassert car_list[2].make == \"Ford\" and car_list[2].model == \"Mustang\" and car_list[2].year == ... |
f7fbefd4f2ee99008d601271968de04f | [
{
"content": "On te demande d'implémenter une fonction `optimize_and_cache(f)` qui améliore une fonction donnée `f` en mettant en cache ses résultats en fonction des arguments d'entrée. Le mécanisme de mise en cache doit utiliser un dictionnaire où les clés sont des tuples représentant les arguments de la fonct... | ["\nassert optimize_and_cache(lambda x: x * 2)(5) == 10\n", "\nassert optimize_and_cache(lambda x: x + 3)(5) == 8\n", "\nassert optimize_and_cache(lambda x, y: x + y)(2, 3) == 5\n", "\nassert optimize_and_cache(lambda x, y: x * y)(4, 5) == 20\n", "\nassert optimize_and_cache(lambda x: x ** 2)(3) == 9\n", "\nassert opti... |
a7ec334c222eaccae10eecad99620b21 | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `reverse_number(n)` qui renvoie l'inverse de `n`. Le nombre inversé ne doit pas avoir de zéros non significatifs. Si `n` est en dehors de la plage d'un entier signé 32 bits (c'est-à-dire `[-2^31, 2^31 - 1]`), la fonction doit renvoyer `... | ["\nassert reverse_number(12345) == 54321\n", "\nassert reverse_number(-12345) == -54321\n", "\nassert reverse_number(100000) == 1\n", "\nassert reverse_number(0) == 0\n", "\nassert reverse_number(2**31) == 0\n", "\nassert reverse_number(-2**31) == 0\n", "\nassert reverse_number(1534236469) == 0\n", "\nassert reverse_n... |
714d6b8703d42bdbbbd18dc03af40262 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente un mappage entre un chemin de dépôt et un chemin de gestionnaire, séparés par deux-points (':'). Ta tâche est de construire un dictionnaire où chaque clé est un chemin de dépôt unique et la valeur correspondante est une li... | ["\nassert process_mappings([\"/repo1:/manager1\", \"/repo2:/manager2\"]) == {\"/repo1\": [\"/manager1\"], \"/repo2\": [\"/manager2\"]}\n", "\nassert process_mappings([\"/repo1:/manager1\", \"/repo1:/manager2\"]) == {\"/repo1\": [\"/manager1\", \"/manager2\"]}\n", "\nassert process_mappings([\"/repo1:/manager2\", \"/re... |
0132cf9a5ab946cb5c2178c4e9af660d | [
{
"content": "On te demande d'implémenter une fonction `read_network_connections` qui traite un fichier nommé \"network_connections.txt\". Ce fichier contient des lignes représentant des connexions réseau entre des appareils. Chaque ligne est formatée comme suit :\n\n```\nsource_device_id destination_device_id\... | ["\nassert read_network_connections() == {'A': ['B'], 'B': ['C'], 'C': ['D']}\n", "\nassert read_network_connections() == {'X': ['Y', 'Z'], 'Y': ['W']}\n", "\nassert read_network_connections() == {'1': ['2'], '2': ['3'], '3': ['4'], '4': ['5']}\n", "\nassert read_network_connections() == {'device1': ['device2'], 'devic... |
0a414f629ec0869709e8ff8dc58fc0df | [
{
"content": "Implémente une classe Python nommée `Book` qui encapsule les propriétés d'un livre, notamment son titre, son auteur, son éditeur, son année de publication et son ISBN. La classe doit fournir des méthodes getter et setter pour chaque attribut. De plus, implémente une méthode `get_book_info` qui ren... | ["\nassert Book(\"1984\", \"George Orwell\", \"Secker & Warburg\", \"1949\", \"978-0451524935\").get_book_info() == \"1984 by George Orwell, published by Secker & Warburg in 1949, ISBN: 978-0451524935\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"J.B. Lippincott & Co.\", \"1960\", \"978-0-06-112008-... |
d910fb65b0ce13ee897a4f9c4e1fa761 | [
{
"content": "On te donne une chaîne de caractères qui peut contenir plusieurs ensembles de crochets, y compris les parenthèses `()`, les crochets carrés `[]`, les accolades `{}` et les chevrons `<>`. Ces crochets peuvent être imbriqués et mélangés. Ta tâche est d'écrire une fonction `extract_bracket_expression... | ["\nassert extract_bracket_expression(\"(a*(b+c)) + d - (e/f) + g\") == \"a*(b+c)\"\n", "\nassert extract_bracket_expression(\"no_parentheses\") == \"no_parentheses\"\n", "\nassert extract_bracket_expression(\"unbalanced_parentheses(\") == None\n", "\nassert extract_bracket_expression(\"[a*(b+c)] + d - (e/f) + g\") == ... |
a53ff3666c0f3415024e16e804960871 | [
{
"content": "On te demande d'implémenter une fonction pour valider les numéros de carte de crédit en utilisant l'algorithme de Luhn. Ta fonction doit prendre une chaîne de caractères `card_number` en entrée et renvoyer `True` si le numéro est valide selon l'algorithme de Luhn, et `False` sinon. Un numéro de ca... | ["\nassert validate_credit_card(\"4539 1488 0343 6467\") == False\n", "\nassert validate_credit_card(\"4539148803436467\") == True\n", "\nassert validate_credit_card(\"6011111111111117\") == True\n", "\nassert validate_credit_card(\"5500000000000004\") == True\n", "\nassert validate_credit_card(\"1234567812345670\") ==... |
8e8a553f932f267b023c2ba4c1b8d346 | [
{
"content": "On te donne une chaîne binaire `binary_str`. Ta tâche est d'écrire une fonction `binary_aligner` qui renvoie une nouvelle chaîne binaire dont la longueur est le multiple de 8 le plus proche. Si la longueur de la chaîne d'entrée est déjà un multiple de 8, renvoie-la sans modification. Si un remplis... | ["\nassert binary_aligner('1101010') == '11010100'\n", "\nassert binary_aligner('11010100') == '11010100'\n", "\nassert binary_aligner('1101') == '11010000'\n", "\nassert binary_aligner('1') == '10000000'\n", "\nassert binary_aligner('11111111') == '11111111'\n", "\nassert binary_aligner('1111111') == '11111110'\n", "\... |
ea38db0f2fcecb492d075a862f429979 | [
{
"content": "On te donne un fichier CSV avec les colonnes suivantes : `Name`, `Age` et `Salary`. Ta tâche est d'écrire une fonction Python qui lit ce fichier, filtre les lignes où l'`Age` est inférieur à 18, et calcule le salaire moyen des lignes restantes. Suppose que le fichier CSV est bien formé et que les ... | ["\nassert calculate_average_salary('test1.csv') == 50000.0\n", "\nassert calculate_average_salary('test2.csv') == 0.0\n", "\nassert calculate_average_salary('test3.csv') == 75000.0\n", "\nassert calculate_average_salary('test4.csv') == 60000.0\n", "\nassert calculate_average_salary('test5.csv') == 80000.0\n", "\nasser... |
aca82d43c03c099be45eaf7c930da7a1 | [
{
"content": "Tu es chargé d'implémenter une fonction `clean_filename` qui traite une chaîne de nom de fichier donnée. La fonction doit effectuer les opérations suivantes :\n1. Remplacer tous les espaces et les caractères de ponctuation (à l'exception du point `.`) par des tirets bas `_`.\n2. S'assurer qu'aucun... | ["\nassert clean_filename(\"example file.txt\") == \"example_file.txt\"\n", "\nassert clean_filename(\"example!file.txt\") == \"example_file.txt\"\n", "\nassert clean_filename(\"example file!.txt\") == \"example_file_.txt\"\n", "\nassert clean_filename(\" example file.txt \") == \"example_file.txt\"\n", "\nassert clean... |
c65d898341ddf09ddb2b5be665734493 | [
{
"content": "Tu es chargé de mettre en œuvre une fonctionnalité de recherche pour une vaste collection de livres. Chaque livre est composé de chapitres, et chaque chapitre est composé de pages. Ton objectif est de créer un fichier JSON qui permette aux utilisateurs de rechercher un contenu textuel spécifique d... | ["\nassert generate_search_index([], \"Python\", \"empty_index.json\") is None\n", "\nassert generate_search_index([Book(\"Book 1\", \"Author A\", [Chapter(\"Chapter 1\", [Page(1, \"No search text here.\")])])], \"Python\", \"no_match_index.json\") is None\n", "\nassert generate_search_index([Book(\"Book 1\", \"Author ... |
6f1c04382001fc698d54990aae5128a8 | [
{
"content": "On te donne une chaîne de caractères `s` constituée d'entiers séparés par des espaces. Ta tâche est de déterminer le plus grand palindrome qui peut être formé en réarrangeant les chiffres de ces entiers. Si il n'est pas possible de former un palindrome, renvoie la chaîne de caractères \"No palindr... | ["\nassert largest_palindrome(\"123 321 456\") == \"321123\" or largest_palindrome(\"123 321 456\") == \"213312\"\n", "\nassert largest_palindrome(\"112233\") == \"332211\" or largest_palindrome(\"112233\") == \"321123\"\n", "\nassert largest_palindrome(\"123456789\") == \"No palindrome possible\"\n", "\nassert largest... |
5dd32d7b73532dd3aeb0c8a2eebdddf8 | [
{
"content": "On te demande de concevoir une fonction `combine_error_metrics` qui agrège plusieurs métriques d'erreur en une seule métrique pondérée. La fonction accepte deux paramètres : une liste de poids et une liste de fonctions de métriques d'erreur. Chaque fonction de métrique d'erreur calcule une métriqu... | ["\nassert combine_error_metrics([1.0], [lambda y_true, y_pred: 0.5])([1], [1]) == 0.5\n", "\nassert combine_error_metrics([0.5, 0.5], [lambda y_true, y_pred: 1.0, lambda y_true, y_pred: 2.0])([1], [1]) == 1.5\n", "\nassert combine_error_metrics([1.0, 2.0], [lambda y_true, y_pred: 1.0, lambda y_true, y_pred: 2.0])([1],... |
630c0a4e786ff474ce1753c85bcb873b | [
{
"content": "Tu développes un éditeur de texte avec une fonctionnalité d'annulation. Implémente une fonction `undo` qui traite une séquence d'actions effectuées sur un document. La fonction doit accepter une liste d'actions et un entier `steps` en entrée. Chaque action est une chaîne de caractères qui décrit u... | ["\nassert undo([\"typed 'Hello'\", \"typed 'World'\"], 1) == [\"typed 'Hello'\"]\n", "\nassert undo([\"typed 'Hello'\", \"typed 'World'\"], 2) == []\n", "\nassert undo([\"typed 'Hello'\", \"typed 'World'\"], 3) == []\n", "\nassert undo([], 1) == []\n", "\nassert undo([\"typed 'Hello'\"], 0) == [\"typed 'Hello'\"]\n", ... |
0a45df7e9aad53bf8a132688d104183e | [
{
"content": "On te donne une URL et ta tâche est de concevoir une fonction qui convertit cette URL en un nom de fichier valide en utilisant uniquement les bibliothèques intégrées de Python. Le nom de fichier résultant ne doit pas dépasser 255 caractères. Tous les caractères spécifiques à l'URL (tels que `/`, `... | ["\nassert url_to_filename(\"http://example.com\") == \"http_example.com\"\n", "\nassert url_to_filename(\"https://example.com/path/to/resource\") == \"https_example.com_path_to_resource\"\n", "\nassert url_to_filename(\"http://example.com?query=param&another=one\") == \"http_example.com_query_param_another_one\"\n", "... |
e759f41052e79532a5aa857baf59de62 | [
{
"content": "Étant donné une chaîne de caractères `s` composée de lettres minuscules uniques en anglais, génère toutes les permutations possibles de la chaîne de caractères telles qu'aucun caractère consécutif dans une permutation ne corresponde aux caractères consécutifs de la chaîne de caractères originale `... | ["\nassert generate_permutations(\"a\") == {\"a\"}\n", "\nassert generate_permutations(\"ab\") == {\"ab\", \"ba\"}\n", "\nassert generate_permutations(\"abc\") == {\"abc\", \"acb\", \"bac\", \"bca\", \"cab\", \"cba\"}\n", "\nassert generate_permutations(\"abcd\") == {\"abcd\", \"abdc\", \"acbd\", \"acdb\", \"adbc\", \"... |
542a0a5c86e4f8181b33ba796e91f66c | [
{
"content": "On te donne une chaîne de caractères `code_snippet` représentant un extrait de code Python. Ta tâche est de mettre en œuvre une fonction `is_syntax_valid(code_snippet)` qui détermine si l'extrait de code fourni a une syntaxe Python valide. La fonction doit renvoyer `True` si la syntaxe est correct... | ["\nassert is_syntax_valid(\"def foo():\\n return 42\") == True\n", "\nassert is_syntax_valid(\"def foo():\\nreturn 42\") == False\n", "\nassert is_syntax_valid(\"if True:\\n print('Hello')\") == True\n", "\nassert is_syntax_valid(\"if True:\\nprint('Hello'\") == False\n", "\nassert is_syntax_valid(\"for i in ran... |
b58eeba56cfe7caf3fe92efadf40f8bc | [
{
"content": "On te demande d'implémenter une classe `OrderProcessor` pour gérer une file d'attente de commandes. La classe doit prendre en charge les opérations suivantes :\n\n1. **add_order(order)** : Ajoute une commande à la file d'attente. Chaque commande est représentée comme un dictionnaire avec les clés ... | ["\nassert OrderProcessor().list_orders() == []\n", "\nassert OrderProcessor().remove_order(1) == False\n", "\nprocessor = OrderProcessor()\nprocessor.add_order({'order_id': 1, 'customer_name': 'John Doe', 'amount': 100.00})\nassert processor.list_orders() == [{'order_id': 1, 'customer_name': 'John Doe', 'amount': 100.... |
6b549a2298491954b754b4ed56a42021 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est d'écrire une fonction `find_duplicate_items` qui renvoie une liste contenant tous les éléments qui apparaissent dans les deux listes d'entrée, en préservant le nombre d'occurrences de chaque élément. La fonction ne doit pas utilis... | ["\nassert find_duplicate_items([1, 2, 2, 3, 4], [2, 2, 3, 5]) == [2, 2, 3]\n", "\nassert find_duplicate_items([1, 1, 1, 1], [1, 1, 1]) == [1, 1, 1]\n", "\nassert find_duplicate_items([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_duplicate_items([], [1, 2, 3]) == []\n", "\nassert find_duplicate_items([1, 2, 3], []) ==... |
ef82ad77ad56d7f1a1922e2d52a81869 | [
{
"content": "On te donne une liste d'objets `Student` représentant des élèves d'un district scolaire. Chaque objet `Student` possède une méthode `get_student_property(property_name)` qui renvoie la valeur de la propriété spécifiée pour cet élève. Ta tâche est de filtrer et de renvoyer une liste d'élèves qui on... | ["\nassert filter_students([]) == []\n", "\nassert filter_students([Student()]) == [] if not Student().get_student_property('transferred_within_district') or Student().get_student_property('is_gifted') else [Student()]\n", "\nassert filter_students([Student(), Student()]) == [Student(), Student()] if Student().get_stud... |
e81c4a48a812f1f2a7da1b315718579f | [
{
"content": "On te donne une liste d'entiers, `numbers`, qui est divisée en deux moitiés. La moitié gauche est triée par ordre croissant, et la moitié droite est triée par ordre décroissant. Le point où la liste change son ordre de tri est inconnu. Ta tâche est de trouver l'index de l'entier cible, `target`, d... | ["\nassert find_target_index([1, 2, 3, 4, 5, 3, 2, 1], 4) == 3\n", "\nassert find_target_index([5, 6, 7, 8, 9, 1, 2, 3], 6) == 1\n", "\nassert find_target_index([10, 15, 20, 0, 5], 20) == 2\n", "\nassert find_target_index([1, 3, 5, 7, 9, 11, 2, 0], 0) == 7\n", "\nassert find_target_index([1, 2, 3, 4, 5], 3) == 2\n", "\... |
ff8d469f043923f38a7bf7966ff16a88 | [
{
"content": "On te demande d'implémenter une classe Python nommée `Book` qui modélise un livre avec trois attributs : `title`, `author` et `isbn`. Ta classe doit inclure :\n- Un constructeur qui initialise ces trois attributs.\n- Une méthode `get_info` qui renvoie une chaîne formatée comme \"Title: [title], Au... | ["\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\").get_info() == \"Title: 1984, Author: George Orwell, ISBN: 9780451524935\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"9780060935467\").get_info() == \"Title: To Kill a Mockingbird, Author: Harper Lee, ISBN: 9780060935467\"\n", "\nassert... |
08a0cd919bfe2e0f894a7259d716ae91 | [
{
"content": "On te donne un ensemble de données composé de plusieurs points de données, chacun représenté par une distribution de probabilité sur un ensemble de classes. Chaque distribution de probabilité est un tableau NumPy 1D où le i-ème élément indique la probabilité de la i-ème classe. Ta tâche est d'écri... | ["\nassert predict_classes([np.array([0.1, 0.2, 0.7])]) == [2]\n", "\nassert predict_classes([np.array([0.2, 0.4, 0.4])]) == [1]\n", "\nassert predict_classes([np.array([0.3, 0.3, 0.4])]) == [2]\n", "\nassert predict_classes([np.array([0.4, 0.4, 0.2])]) == [0]\n", "\nassert predict_classes([np.array([0.5, 0.5, 0.5])]) ... |
e3d8c0fe4a1411d02fac9b9d71e67372 | [
{
"content": "On te donne un processus physiologique modélisé en deux étapes. Pour la première étape, tu dois calculer une valeur basée sur l'interaction entre deux composants, `comp_A` et `comp_B`, et deux masques, `mask_A` et `mask_B`. Le calcul est influencé par les constantes `m`, `S`, `w_xm`, et `w_xd`. De... | ["\nassert physiological_process_stage1(1, 1, 1, 1, 1, 1, 1, 1, [], 0) == 0.25\n", "\nassert physiological_process_stage1(2, 2, 2, 2, 2, 2, 2, 2, [1], 0.5) == 0.1111111111111111\n", "\nassert physiological_process_stage1(3, 3, 3, 3, 3, 3, 3, 3, [1, 2], 0.3) == 0.047619047619047616\n", "\nassert physiological_process_st... |
e77a7bd0264a04bac44cc382c6256405 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui réorganise la liste de telle sorte que tous les nombres pairs apparaissent avant tous les nombres impairs, tout en maintenant l'ordre relatif des nombres pairs et impairs au sein de leurs groupes respectifs.\n\n**En... | ["\nassert separate_even_odd([3, 2, 4, 5, 1, 6]) == [2, 4, 6, 3, 5, 1]\n", "\nassert separate_even_odd([1, 3, 5, 7, 9]) == [1, 3, 5, 7, 9]\n", "\nassert separate_even_odd([2, 4, 6, 8, 10]) == [2, 4, 6, 8, 10]\n", "\nassert separate_even_odd([]) == []\n", "\nassert separate_even_odd([11, 22, 33, 44, 55]) == [22, 44, 11,... |
a4e37ba387c03e48010964bef9f18ca6 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier positif `chunk_size`. Ta tâche est d'implémenter une fonction `chunk_counter(numbers, chunk_size)` qui traite la liste en morceaux de taille `chunk_size`. Pour chaque morceau, calcule le nombre d'éléments, la moyenne et l'écart type. Retourne ... | ["\nassert chunk_counter([1, 2, 3, 4, 5, 6], 2) == [([1, 2], 2, 0.5), ([3, 4], 2, 0.5), ([5, 6], 2, 0.5)]\n", "\nassert chunk_counter([1, 2, 3, 4, 5], 3) == [([1, 2, 3], 3, 0.816496580927726), ([4, 5], 2, 0.5)]\n", "\nassert chunk_counter([10, 20, 30, 40, 50], 5) == [([10, 20, 30, 40, 50], 5, 14.142135623730951)]\n", "... |
6882a93862b28ecf6e46b85b6f88d91e | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de déterminer si `n` est un palindrome en base 10 et en base 2. Un nombre est considéré comme un palindrome s'il se lit de la même manière à l'endroit et à l'envers.\n\n**Entrée:**\n- Un seul entier `n` (1 ≤ n ≤ 10^6).\n\n**Sortie:**\n- Affiche un me... | ["\nassert check_palindrome_in_both_bases(9) == \"9 is not a palindrome in both base 10 and base 2.\"\n", "\nassert check_palindrome_in_both_bases(10) == \"10 is not a palindrome in both base 10 and base 2.\"\n", "\nassert check_palindrome_in_both_bases(5) == \"5 is a palindrome in both base 10 and base 2.\"\n", "\nass... |
ca352a95916791e377ed9d9400df7bb0 | [
{
"content": "On te donne une liste de nombres à virgule flottante. Ton objectif est d'implémenter une fonction `calculate_statistics` qui calcule et renvoie un dictionnaire contenant la moyenne arithmétique, la médiane, la variance échantillonnaire non biaisée et l'écart type échantillonnaire non biaisé des no... | ["\nassert calculate_statistics([1.0, 2.0, 3.0, 4.0, 5.0]) == {'mean': 3.0, 'median': 3.0, 'variance': 2.0, 'standard_deviation': 1.4142135623730951}\n", "\nassert calculate_statistics([10.0, 10.0, 10.0]) == {'mean': 10.0, 'median': 10.0, 'variance': 0.0, 'standard_deviation': 0.0}\n", "\nassert calculate_statistics([5... |
031be3f6462b05230b255f8152b9b3ad | [
{
"content": "On te donne une liste de séquences d'ADN, où chaque séquence est une chaîne de caractères composée des nucléotides 'A', 'C', 'G' et 'T'. Ta tâche est d'écrire une fonction qui compte les occurrences de chaque nucléotide dans chaque séquence et renvoie une liste de dictionnaires. Chaque dictionnair... | ["\nassert count_nucleotides([\"ATGCGAT\"]) == [{'A': 3, 'C': 1, 'G': 2, 'T': 1}]\n", "\nassert count_nucleotides([\"ACCGTAT\"]) == [{'A': 2, 'C': 2, 'G': 1, 'T': 2}]\n", "\nassert count_nucleotides([\"GCTATAG\"]) == [{'A': 2, 'C': 1, 'G': 2, 'T': 2}]\n", "\nassert count_nucleotides([\"AAAA\", \"CCCC\", \"GGGG\", \"TTT... |
c4e71e5ea8a5f775dceff73a4d9ffed0 | [
{
"content": "On te demande d'implémenter une fonction `convert_base` qui convertit un entier donné `number` en une représentation sous forme de chaîne dans une base spécifiée. La fonction doit prendre en charge les bases allant de 2 à 36 inclusivement. La fonction doit correctement gérer les nombres négatifs e... | ["\nassert convert_base(10, 2) == \"1010\"\n", "\nassert convert_base(255, 16) == \"FF\"\n", "\nassert convert_base(-15, 2) == \"-1111\"\n", "\nassert convert_base(0, 10) == \"0\"\n", "\nassert convert_base(123456, 36) == \"2N9C\"\n", "\nassert convert_base(1, 36) == \"1\"\n", "\nassert convert_base(100, 10) == \"100\"... |
a7bf98e19c04488b255e776c688169e1 | [
{
"content": "On te donne une structure de dictionnaire hiérarchique où chaque clé est une chaîne de caractères et chaque valeur est soit un autre dictionnaire, soit une chaîne de caractères. Ta tâche est d'écrire une fonction qui renvoie une liste de toutes les chaînes de caractères uniques qui sont des nœuds ... | ["\nassert find_leaf_nodes({'a': 'value1'}) == ['value1']\n", "\nassert find_leaf_nodes({'a': {'b': 'value1', 'c': 'value2'}}) == ['value1', 'value2']\n", "\nassert find_leaf_nodes({'a': {'b': {'c': 'value1'}}}) == ['value1']\n", "\nassert find_leaf_nodes({'a': 'value1', 'b': 'value2'}) == ['value1', 'value2']\n", "\na... |
0fb112c87884bd437b75988bc8a53c75 | [
{
"content": "On te demande d'implémenter une fonction `convert_data` qui effectue une conversion de type sur une valeur donnée. La fonction doit gérer divers types de données et structures, y compris des listes et des tuples imbriqués. La fonction doit respecter les spécifications suivantes :\n\n- **Paramètres... | ["\nassert convert_data(123, str) == '123'\n", "\nassert convert_data('456', int) == 456\n", "\nassert convert_data(None, float) is None\n", "\nassert convert_data([1, 2, 3], list) == [1, 2, 3]\n", "\nassert convert_data((1, 2, 3), tuple) == (1, 2, 3)\n", "\nassert convert_data([1, '2', 3.0], int) == [1, 2, 3]\n", "\na... |
5addbf7a68e27fc7ecb38505a4453a92 | [
{
"content": "On te donne une liste triée de `n` mots distincts par ordre alphabétique et un mot `target`. Ton objectif est d'implémenter une fonction `find_word(word_list, target_word)` qui effectue une recherche binaire pour localiser le `target_word` dans la `word_list`. La fonction doit renvoyer l'index du ... | ["\nassert find_word([\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\"], \"cherry\") == 2\n", "\nassert find_word([\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\"], \"apple\") == 0\n", "\nassert find_word([\"apple\", \"banana\", \"cherry\", \"date\", \"elde... |
4056a4b8cb551a206a86ebc9531f411a | [
{
"content": "On te donne un graphe non orienté représenté sous forme de liste d'adjacence. Ta tâche est d'implémenter une fonction qui effectue une recherche en profondeur (DFS) à partir d'un sommet donné et renvoie une liste de tous les sommets visités dans l'ordre dans lequel ils ont été visités.\n\n**Entrée... | ["\nassert dfs({'A': ['B', 'C'], 'B': ['A'], 'C': ['A']}, 'A') == ['A', 'B', 'C']\n", "\nassert dfs({'A': ['B', 'C'], 'B': ['A', 'D'], 'C': ['A'], 'D': ['B']}, 'A') == ['A', 'B', 'D', 'C']\n", "\nassert dfs({'A': ['B'], 'B': ['C'], 'C': ['D'], 'D': []}, 'A') == ['A', 'B', 'C', 'D']\n", "\nassert dfs({'A': ['B', 'C'], '... |
67744a1378e689196fa91308d88be262 | [
{
"content": "On te donne une liste imbriquée d'entiers de profondeur arbitraire. Ta tâche est d'implémenter une fonction `apply_default_operator` qui aplatit cette liste imbriquée, puis applique un opérateur donné à la liste aplatie. L'opérateur est une fonction qui prend une liste plate d'entiers et renvoie u... | ["\nassert apply_default_operator([1, 2, 3], sum) == 6\n", "\nassert apply_default_operator([1, [2, 3], [4, [5, 6]], 7], sum) == 28\n", "\nassert apply_default_operator([1, [2, [3, [4, [5]]]]], sum) == 15\n", "\nassert apply_default_operator([], sum) == 0\n", "\nassert apply_default_operator([1, [2, [3, [4, [5, []]]]]]... |
b7bc0b691f90dd2d658f7c8eb68ae3f0 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `k`. Ta tâche est d'effectuer une rotation unique du tableau `nums` vers la droite de `k` pas, où `k` est non négatif. La rotation doit suivre ces règles :\n1. Chaque élément du tableau doit être déplacé vers une nouvelle position qui est la som... | ["\nassert unique_rotate([1, 2, 3, 4, 5, 6, 7], 3) == None and nums == [10, 2, 14, 4, 18, 6, 14]\n", "\nassert unique_rotate([1, 2, 3, 4, 5], 2) == None and nums == [10, 2, 12, 4, 10]\n", "\nassert unique_rotate([1, 2, 3], 1) == None and nums == [6, 2, 2]\n", "\nassert unique_rotate([1, 2, 3, 4], 4) == None and nums ==... |
81cd452a26d380530af9c98744ab181a | [
{
"content": "Implémente une classe Python `Movie` avec les spécifications suivantes :\n\n- **Attributs :**\n - `title` : Une chaîne de caractères représentant le titre du film.\n - `year` : Un entier représentant l'année de sortie.\n - `genre` : Une chaîne de caractères représentant le genre du film.\n - `... | ["\nassert Movie(\"Inception\", 2010, \"Sci-Fi\", \"Christopher Nolan\").get_info() == \"Title: Inception\\nYear: 2010\\nGenre: Sci-Fi\\nDirector: Christopher Nolan\\nActors: No actors listed\"\n", "\nassert Movie(\"The Matrix\", 1999, \"Action\", \"Lana Wachowski, Lilly Wachowski\", [\"Keanu Reeves\", \"Laurence Fishb... |
5956be5645c55127eb1b886fa0a123ce | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction `sort_by_length` qui trie ces chaînes par longueur croissante. Si deux chaînes ont la même longueur, elles doivent apparaître dans le même ordre que dans la liste originale.\n\n**Entrée :**\n- Une liste de ... | ["\nassert sort_by_length([\"apple\", \"banana\", \"kiwi\", \"grape\"]) == [\"kiwi\", \"apple\", \"grape\", \"banana\"]\n", "\nassert sort_by_length([\"a\", \"bb\", \"ccc\", \"dddd\"]) == [\"a\", \"bb\", \"ccc\", \"dddd\"]\n", "\nassert sort_by_length([\"hello\", \"world\", \"hi\", \"python\"]) == [\"hi\", \"hello\", \... |
087774d6c426cf3a590eb4a9d659fe6c | [
{
"content": "On te donne une liste de mots. Ton objectif est d'implémenter une fonction qui renvoie un dictionnaire où chaque clé est un mot unique de la liste et la valeur correspondante est la fréquence de ce mot dans la liste.\n\n**Entrée :**\n- Une liste de chaînes de caractères, `word_list`, où chaque cha... | ["\nassert word_frequencies([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\"]) == {\"apple\": 3, \"banana\": 2, \"orange\": 1}\n", "\nassert word_frequencies([\"hello\", \"world\", \"hello\"]) == {\"hello\": 2, \"world\": 1}\n", "\nassert word_frequencies([\"one\", \"two\", \"three\", \"four\", \"fi... |
21b050bfc462b8961df9926b7c95ced6 | [
{
"content": "On te donne une distribution normale caractérisée par sa moyenne `mu` et son écart type `sigma`. Ta tâche est de calculer la probabilité qu'une variable aléatoire tirée de cette distribution se situe dans une plage spécifiée `[a, b]`. La fonction doit gérer à la fois les nombres réels et complexes... | ["\nassert cdf_probability(0, 0, 0, 1) == 0.5\n", "\nassert cdf_probability(-np.inf, np.inf, 0, 1) == 1\n", "\nassert cdf_probability(-np.inf, -np.inf, 0, 1) == 0\n", "\nassert cdf_probability(1, 1, 1, 1) == 0.5\n", "\nassert cdf_probability(-1, 1, 0, 1) == 0.6826894921370859\n", "\nassert cdf_probability(0, 2, 1, 1) =... |
503f8c1a65baff1f923b29897c156ede | [
{
"content": "On te demande d'implémenter un algorithme efficace pour trouver l'inverse multiplicatif d'un nombre `a` modulo `m`. L'inverse multiplicatif de `a` modulo `m` est un nombre `x` tel que `(a * x) % m = 1`. Ta solution doit gérer efficacement les grandes tailles d'entrée. Si l'inverse n'existe pas (c'... | ["\nassert mod_inverse(3, 11) == 4\n", "\nassert mod_inverse(10, 17) == 12\n", "\nassert mod_inverse(10, 13) == 4\n", "\nassert mod_inverse(7, 26) == 15\n", "\nassert mod_inverse(15, 26) == 7\n", "\nassert mod_inverse(1, 2) == 1\n", "\nassert mod_inverse(26513, 32321) == 27593\n", "\nassert mod_inverse(17, 3120) == 275... |
550b24f1cef643cefaa916707d7b0768 | [
{
"content": "Tu développes un système pour assurer l'intégrité des fichiers stockés sur un serveur. Dans le cadre de ce système, tu dois implémenter une fonction qui calcule le checksum SHA-256 pour un fichier donné. Ta tâche est d'écrire une fonction Python `calculate_checksum(file_path)` qui prend une chaîne... | ["\nassert calculate_checksum(\"test_files/empty.txt\") == \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\"\n", "\nassert calculate_checksum(\"test_files/single_byte.txt\") == \"9e107d9d372bb6826bd81d3542a419d6e277d4d731479577a1e63c1f27b8e47e\"\n", "\nassert calculate_checksum(\"test_files/hello_wor... |
f7ff764a208719725a5990d8a98f921f | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ton objectif est de déterminer l'index de la première occurrence de `target` dans `numbers`. Si `target` n'est pas présent dans la liste, retourne `-1`. Ta solution doit être efficace en termes de complexité temporelle.\n\n**Exemple ... | ["\nassert find_first_occurrence([4, 5, 6, 7, 0, 1, 2], 0) == 4\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5], 3) == 2\n", "\nassert find_first_occurrence([10, 20, 30, 40, 50], 10) == 0\n", "\nassert find_first_occurrence([10, 20, 30, 40, 50], 50) == 4\n", "\nassert find_first_occurrence([1, 1, 1, 1, 1], 1) == 0\... |
e9a72aeaef69467581264bfdbdaabe11 | [
{
"content": "On te donne une chaîne de caractères `text` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `most_frequent_words(text, n=1)` qui renvoie une liste des `n` mots les plus fréquents dans le texte. La fonction doit être insensible à la casse et doit ignorer la ponctuation. Si `n` dépass... | ["\nassert most_frequent_words(\"hello world hello\", 1) == [\"hello\"]\n", "\nassert most_frequent_words(\"hello world hello world\", 2) == [\"hello\", \"world\"]\n", "\nassert most_frequent_words(\"a b c a b a\", 3) == [\"a\", \"b\", \"c\"]\n", "\nassert most_frequent_words(\"test test test\", 1) == [\"test\"]\n", "\... |
bea768ba55ca526d41be734661b7b1ea | [
{
"content": "On te donne un ensemble de données où chaque caractéristique a été normalisée dans une plage comprise entre 0 et 1. On te fournit également les limites originales de chaque caractéristique. Ta tâche est d'écrire une fonction qui dénormalise l'ensemble de données. La fonction doit être suffisamment... | ["\nassert np.array_equal(unnormalize_dataset(np.array([[0.5]]), [(0, 10)]), np.array([[5.0]]))\n", "\nassert np.array_equal(unnormalize_dataset(np.array([[0.0, 1.0], [1.0, 0.0]]), [(0, 10), (0, 20)]), np.array([[0.0, 20.0], [10.0, 0.0]]))\n", "\nassert np.array_equal(unnormalize_dataset(np.array([[0.25, 0.75]]), [(0, ... |
7490536b61caca0e1d0355cd404093bb | [
{
"content": "Dans un défi de développement de jeu, tu es chargé d'implémenter une classe `Character` pour gérer les attributs et les actions des personnages du jeu. La classe `Character` doit prendre en charge les fonctionnalités suivantes :\n\n- **Attributs :**\n - `name` : une chaîne de caractères représent... | ["\nassert Character(\"Hero\", 100, 50).name == \"Hero\"\n", "\nassert Character(\"Hero\", 100, 50).health == 100\n", "\nassert Character(\"Hero\", 100, 50).mana == 50\n", "\nchar = Character(\"Hero\", 100, 50); char.attack(20); assert char.health == 80\n", "\nchar = Character(\"Hero\", 100, 50); char.attack(150); asse... |
73b4c678bfb5fc68730c9308e045c5a7 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui supprime tous les éléments dupliqués de la liste tout en conservant l'ordre d'origine des éléments restants.\n\n**Entrée :**\n- Une liste d'entiers `input_list` (1 ≤ len(input_list) ≤ 10^5), où chaque entier est dans la plage ... | ["\nassert remove_duplicates([1, 2, 3, 2, 1]) == [1, 2, 3]\n", "\nassert remove_duplicates(['a', 'b', 'c', 'a', 'b']) == ['a', 'b', 'c']\n", "\nassert remove_duplicates([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert r... |
e01256a4e0d102daa36125411d09b688 | [
{
"content": "On te donne une liste de `n` points dans un plan 2D, où chaque point est représenté comme un tuple `(x, y)`. Ta tâche est de déterminer la distance euclidienne maximale entre deux points quelconques de la liste.\n\n**Entrée :**\n- La première ligne contient un entier `n` (2 ≤ n ≤ 1000), le nombre ... | ["\nassert find_farthest_distance([(0, 0), (1, 1), (3, 4), (-1, -1)]) == 5.0\n", "\nassert find_farthest_distance([(0, 0), (0, 0), (0, 0)]) == 0.0\n", "\nassert find_farthest_distance([(1, 2), (4, 6)]) == 5.0\n", "\nassert find_farthest_distance([(0, 0), (3, 4)]) == 5.0\n", "\nassert find_farthest_distance([(1, 1), (1,... |
8203f6fbac4ed9fe834e1225a0fb75e4 | [
{
"content": "On te donne une machine qui peut produire des articles avec un temps de préparation `T` et un temps de production `M` par article. La machine peut produire jusqu'à `n` articles simultanément. De plus, la machine s'use, augmentant le temps de production `M` de 0,1 % pour chaque cycle après le premi... | ["\nassert calculate_total_time(0, 5, 2, 3, 0.001) == 0\n", "\nassert calculate_total_time(1, 5, 2, 3, 0.001) == 2 + 5/3\n", "\nassert calculate_total_time(3, 5, 2, 3, 0.001) == 2 + 5\n", "\nassert calculate_total_time(4, 5, 2, 3, 0.001) == 2 + 5 + 5.005/3\n", "\nassert calculate_total_time(6, 5, 2, 3, 0.001) == 2 + 5 ... |
85dcdd296c3836b1654ce1c76c12083c | [
{
"content": "On te donne un dictionnaire `adict` où les clés sont des chaînes de caractères et les valeurs sont des entiers. Ta tâche est de mettre en œuvre une fonction `sorted_values_by_key_length(adict)` qui renvoie une liste des valeurs du dictionnaire triées par la longueur de leurs clés correspondantes. ... | ["\nassert sorted_values_by_key_length({\"a\": 1, \"bb\": 2, \"ccc\": 3}) == [1, 2, 3]\n", "\nassert sorted_values_by_key_length({\"abc\": 3, \"de\": 2, \"f\": 1}) == [1, 2, 3]\n", "\nassert sorted_values_by_key_length({\"key\": 10, \"k\": 20, \"keys\": 5}) == [20, 10, 5]\n", "\nassert sorted_values_by_key_length({\"on... |
69ac9a21a3dd91334b70037dddc95042 | [
{
"content": "On te donne une liste de sommets `V` représentant un graphe, où chaque sommet est un entier unique. Ta tâche est de construire une structure de données de type file d'attente qui stocke ces sommets appariés à leurs indices respectifs en base 3. La file d'attente doit maintenir l'ordre des sommets ... | ["\nassert make_queue([5, 12, 7]) == [(5, '0'), (12, '1'), (7, '2')]\n", "\nassert make_queue([1, 2, 3, 4, 5]) == [(1, '0'), (2, '1'), (3, '2'), (4, '10'), (5, '11')]\n", "\nassert make_queue([10, 20, 30, 40, 50, 60]) == [(10, '0'), (20, '1'), (30, '2'), (40, '10'), (50, '11'), (60, '12')]\n", "\nassert make_queue([]) ... |
323de718182d041fad4a32530c3d9e65 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction `remove_vowels` qui traite chaque chaîne de caractères de la liste en supprimant toutes les voyelles (majuscules et minuscules). La fonction doit renvoyer une nouvelle liste contenant les chaînes modifiées.\n\n... | ["\nassert remove_vowels([\"hello\", \"world\", \"python\"]) == ['hll', 'wrld', 'pythn']\n", "\nassert remove_vowels([\"AEIOU\", \"aeiou\"]) == ['', '']\n", "\nassert remove_vowels([\"bcd\", \"fgh\", \"jkl\"]) == ['bcd', 'fgh', 'jkl']\n", "\nassert remove_vowels([\"\"]) == ['']\n", "\nassert remove_vowels([\"a\", \"e\"... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.