id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
a0c46de6eba9fff4d8af2003da69a119 | [
{
"content": "On te demande d'implémenter une classe `Book` (Livre) et une classe `Library` (Bibliothèque) pour gérer une collection de livres. La classe `Book` doit avoir les attributs suivants : `title` (titre), `author` (auteur) et `isbn`. Implémente un constructeur pour définir ces attributs et une méthode ... | ["\nassert Book(\"1984\", \"George Orwell\", \"1234567890\").details() == \"Title: 1984, Author: George Orwell, ISBN: 1234567890\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"0987654321\").details() == \"Title: To Kill a Mockingbird, Author: Harper Lee, ISBN: 0987654321\"\n", "\nassert Book(\"The Gr... |
3a72b9e16377dba00960eaf490ad0624 | [
{
"content": "On te donne une liste de listes `attendance_records`, où chaque liste interne représente la présence des étudiants dans une classe particulière un jour donné. Les étudiants sont identifiés par des identifiants uniques. Ta tâche est de mettre en œuvre une fonction `find_student_position` qui déterm... | ["\nassert find_student_position([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 5, 2) == 1\n", "\nassert find_student_position([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 5, 3) == 1\n", "\nassert find_student_position([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 10, 1) == -1\n", "\nassert find_student_position([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 1, 1... |
fe89f4ccb4347c8ecd82267b4ee4c9c9 | [
{
"content": "On te donne une chaîne de caractères `abbrev` représentant l'abréviation d'un jour de la semaine et un booléen `case_sensitive` indiquant si l'abréviation doit être traitée de manière sensible à la casse. Ta tâche est d'implémenter une fonction `expand_abbreviation` qui renvoie le nom complet du j... | ["\nassert expand_abbreviation(\"mon\", True) == \"Monday\"\n", "\nassert expand_abbreviation(\"MON\", False) == \"Monday\"\n", "\nassert expand_abbreviation(\"tue\", True) == \"Tuesday\"\n", "\nassert expand_abbreviation(\"TUE\", False) == \"Tuesday\"\n", "\nassert expand_abbreviation(\"wed\", True) == \"Wednesday\"\n... |
d737b054b0d962a82d3192fe3e43e97e | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui renvoie la valeur maximale dans la liste si tous les nombres sont non négatifs. Si la liste contient des nombres négatifs, la fonction doit renvoyer la valeur minimale à la place. Si la liste est vide, la fonction doit renvoye... | ["\nassert find_max_or_min([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 9\n", "\nassert find_max_or_min([-3, -1, -4, -1, -5, -9, -2, -6, -5, -3, -5]) == -9\n", "\nassert find_max_or_min([0, 0, 0, 0]) == 0\n", "\nassert find_max_or_min([-1, 0, 1]) == -1\n", "\nassert find_max_or_min([10]) == 10\n", "\nassert find_max_or_min([-... |
d814f8cd71745a94e086a733237ebdc6 | [
{
"content": "On te demande d'implémenter une fonction `format_time_with_precision(tick, format, sub_secs_precision=2)` qui formate un objet datetime donné `tick` selon la chaîne de format `format` spécifiée. La fonction doit gérer les objets datetime avec fuseau horaire en ajoutant le décalage UTC au format `±... | ["\nassert format_time_with_precision(datetime(2023, 10, 5, 14, 30, 45, 123456, timezone.utc), \"%Y-%m-%d %H:%M:%S\") == \"2023-10-05 14:30:45 +00:00\"\n", "\nassert format_time_with_precision(datetime(2023, 10, 5, 14, 30, 45, 123456, timezone(timedelta(hours=-5))), \"%Y-%m-%d %H:%M:%S\") == \"2023-10-05 14:30:45 -05:0... |
710a6cdf84885d304ec0d4f81ae4c884 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères alphanumériques. Ta tâche est de mettre en œuvre une fonction qui extrait toutes les séquences contiguës de chiffres de la chaîne et les renvoie sous forme de liste d'entiers. Par exemple, si la chaîne d'entrée est `\"a1b2c3\"`, la fo... | ["\nassert extract_numbers(\"a1b2c3\") == [1, 2, 3]\n", "\nassert extract_numbers(\"abc\") == []\n", "\nassert extract_numbers(\"123abc456\") == [123, 456]\n", "\nassert extract_numbers(\"a1b2c3d4e5f6g7h8i9j0\") == [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n", "\nassert extract_numbers(\"1234567890\") == [1234567890]\n", "\nasser... |
f23d5fcec7c7f82102bf27a6ed680c66 | [
{
"content": "On te donne une chaîne de caractères multiligne `text`. Ta tâche est d'implémenter la fonction `clean_text` qui traite cette chaîne selon les règles suivantes :\n\n1. Supprime les espaces blancs en début et en fin de chaque ligne.\n2. Remplace toute séquence de deux caractères d'espacement ou plus... | ["\nassert clean_text(\" hello world \") == \"hello world\"\n", "\nassert clean_text(\"line1\\n line2 \\nline3\") == \"line1\\nline2\\nline3\"\n", "\nassert clean_text(\" \\nline1\\n \\nline2\\n \") == \"line1\\nline2\"\n", "\nassert clean_text(\"line1\\n\\nline2\\n\\n\\nline3\") == \"line1\\nline2\\nline3\"... |
4f856738f7b6582d5927b44353a619f5 | [
{
"content": "On te demande d'implémenter un algorithme génétique pour trouver la valeur maximale de la fonction \\( f(x) = x^2 - 5x + 6 \\) dans l'intervalle \\([0, 10]\\). Ton programme doit afficher la valeur de \\( x \\) qui maximise la fonction et la valeur maximale correspondante de la fonction.\n\n**Entr... | ["\nassert 0 <= genetic_algorithm()[0] <= 10\n", "\nassert genetic_algorithm()[1] == f(genetic_algorithm()[0])\n", "\nassert genetic_algorithm()[1] <= 11 # Maximum value of f(x) = x^2 - 5x + 6 in [0, 10] is 11 at x = 0 and x = 10\n", "\nassert genetic_algorithm()[1] >= 0 # Minimum value of f(x) = x^2 - 5x + 6 in [0, ... |
af8fd28f6eb1ca8892216d981c91dba3 | [
{
"content": "On te donne un tableau d'entiers `numbers` et deux entiers `x` et `y`. Ta tâche est de mettre en œuvre une fonction `count_greater` qui renvoie le nombre d'éléments dans `numbers` qui satisfont les conditions suivantes :\n- L'élément est strictement supérieur à `x`.\n- L'élément est inférieur ou é... | ["\nassert count_greater([1, 2, 3, 4, 5], 2, 4) == 1\n", "\nassert count_greater([1, 2, 3, 4, 5], 1, 5) == 3\n", "\nassert count_greater([1, 4, 9, 16, 25], 0, 25) == 0\n", "\nassert count_greater([10, 15, 20, 25, 30], 10, 30) == 4\n", "\nassert count_greater([2, 3, 5, 7, 11], 1, 10) == 5\n", "\nassert count_greater([1,... |
58079763b60705cfce6aa07389ef0323 | [
{
"content": "On te donne une chaîne de caractères `text` contenant un mélange de caractères. Ta tâche est d'écrire une fonction Python qui extrait toutes les adresses e-mail valides de la chaîne en utilisant des expressions régulières. Une adresse e-mail est définie comme une séquence de caractères qui corresp... | ["\nassert extract_emails(\"example@example.com\") == [\"example@example.com\"]\n", "\nassert extract_emails(\"noemails@here.com and another@domain.org\") == [\"noemails@here.com\", \"another@domain.org\"]\n", "\nassert extract_emails(\"Invalid-email@domain, valid.email@domain.com\") == [\"valid.email@domain.com\"]\n",... |
269c4a53f40567262fb8a0e2e678214e | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste originale, en préservant leur ordre d'apparition initial. La fonction doit être efficace et ne doit pas utiliser de fonctions intégrée... | ["\nassert unique_elements([1, 2, 2, 3, 1, 4]) == [1, 2, 3, 4]\n", "\nassert unique_elements([5, 5, 5, 5, 5]) == [5]\n", "\nassert unique_elements([]) == []\n", "\nassert unique_elements([10, 20, 30, 40, 50]) == [10, 20, 30, 40, 50]\n", "\nassert unique_elements([1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) == [1, 2, 3, 4]\n",... |
254cac70d22b2ff166e44034b6cbb69e | [
{
"content": "On te donne un entier positif `num`. Ta tâche est de déterminer si `num` 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 solution doit être optimisée pour la performance, en particulier pour les grandes val... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(9) == False\n", "\nassert is_prime(11) == True\n", "\nassert is_prime(15) == False\n", "\nassert is_prime(17) == True\n", "\nassert is_prime(19) == True\n", "\nass... |
1709f1a31e5aa3ce0ebdae7722a1970d | [
{
"content": "On te demande d'implémenter une classe `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` : une chaîne de caractères représentant le nom de l'employé.\n - `age` : un entier représentan... | ["\nassert Employee(\"John Doe\", 30, \"Developer\", 50000).describe() == \"Employee(Name: John Doe, Age: 30, Position: Developer, Salary: 50000)\"\n", "\nassert Employee(\"Jane Smith\", 25, \"Designer\", 45000).describe() == \"Employee(Name: Jane Smith, Age: 25, Position: Designer, Salary: 45000)\"\n", "\nassert Emplo... |
f2849884fedc90e66cb0c51822375699 | [
{
"content": "On te donne une liste de boîtes englobantes, où chaque boîte englobante est représentée comme une chaîne de caractères au format \"x0,y0,x1,y1\". Ta tâche est de créer une fonction qui génère une clé unique pour chaque boîte englobante en se basant sur ses coordonnées x0 et y1, arrondies à le mult... | ["\nassert process_bounding_boxes([\"12.3,23.6,45.7,67.8\", \"111.1,222.2,333.3,444.4\"]) == {\"10_20\": \"12.3,23.6,45.7,67.8\", \"110_440\": \"111.1,222.2,333.3,444.4\"}\n", "\nassert process_bounding_boxes([\"10,10,20,20\", \"15,5,25,25\"]) == {\"10_20\": \"10.0,5.0,25.0,25.0\"}\n", "\nassert process_bounding_boxes(... |
b8e4072caa8c7b19e875c1bf1e2840a8 | [
{
"content": "On te donne une matrice carrée `A` de taille `n x n` où `n` est un entier positif et tous les éléments de `A` sont des entiers. Ta tâche est de calculer la pseudo-inverse de Moore-Penrose de `A` en utilisant la Décomposition en Valeurs Singulières (SVD). Après avoir calculé la pseudo-inverse, arro... | ["\nassert np.array_equal(compute_pseudoinverse(np.array([[1, 0], [0, 1]])), np.array([[1, 0], [0, 1]]))\n", "\nassert np.array_equal(compute_pseudoinverse(np.array([[2, 0], [0, 2]])), np.array([[1, 0], [0, 1]]))\n", "\nassert np.array_equal(compute_pseudoinverse(np.array([[1, 2], [2, 1]])), np.array([[-1, 2], [2, -1]]... |
8ddfbe4d4184558d46fd7b345fcdc5a4 | [
{
"content": "On te donne deux listes : `items` et `group_indices`. Chaque élément dans `items` est associé à un élément correspondant dans `group_indices`, qui indique le groupe auquel l'élément appartient. Ta tâche est de regrouper les éléments en fonction de leurs indices de groupe. Si un indice de groupe es... | ["\nassert group_items([10, 20, 30], [1, 2, 3]) == [(1, [10]), (2, [20]), (3, [30])]\n", "\nassert group_items([10, 20, 30], [1+2j, 2+3j, 3+4j]) == [(1+2j, [10]), (2+3j, [20]), (3+4j, [30])]\n", "\nassert group_items([10, 20, 30, 40], [1, 1, 2, 2]) == [(1, [10, 20]), (2, [30, 40])]\n", "\nassert group_items([10, 20, 30... |
c972393f496b17626f0c363ab36edf2c | [
{
"content": "On te donne une structure de données arborescente représentant la hiérarchie des fichiers d'un projet logiciel. Chaque nœud de l'arbre correspond à un fichier et possède les attributs suivants :\n- `child` : une liste de nœuds enfants représentant les fichiers qui dépendent du fichier actuel.\n- `... | ["\nassert should_build_node(Node(target=\"file1.txt\", prev_ni=None, child=[])) == True\n", "\nassert should_build_node(Node(target=\"file1.txt\", prev_ni={'target': \"file1.txt\"}, child=[])) == False\n", "\nassert should_build_node(Node(target=\"file1.txt\", prev_ni={'target': \"file2.txt\"}, child=[])) == True\n", ... |
b86e8cb73375660d306224616c4242c9 | [
{
"content": "On te donne pour tâche de calculer la factorielle d'un nombre en utilisant une approche récursive. Cependant, la méthode récursive naïve est inefficace pour les grands nombres en raison de calculs répétés. Pour optimiser cela, implémente une fonction récursive qui utilise la mémoïsation pour stock... | ["\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... |
74d153a295189a275510aa9441eb13c1 | [
{
"content": "On te demande d'implémenter une classe `Matrix` en Python qui supporte les opérations matricielles de base : l'addition, la soustraction et la multiplication. La classe doit être initialisée avec une liste 2D représentant la matrice. Implémente les méthodes suivantes :\n\n- `add(self, other_matrix... | ["\nassert str(Matrix([[1, 2], [3, 4]]) + Matrix([[5, 6], [7, 8]])) == \"6 8\\n10 12\"\n", "\nassert str(Matrix([[1, 2], [3, 4]]) - Matrix([[1, 1], [1, 1]])) == \"0 1\\n2 3\"\n", "\nassert str(Matrix([[1, 2, 3], [4, 5, 6]]) * Matrix([[7, 8], [9, 10], [11, 12]])) == \"58 64\\n139 154\"\n", "\nassert str(Matrix([[1, 0], ... |
92fa7f4f2d91aba6e1c3d4e5beb832a7 | [
{
"content": "On te donne une liste de segments de ligne sur un plan 2D, chacun représenté comme un tuple `(début, fin)`. Ta tâche est de fusionner tous les segments qui se chevauchent et de renvoyer une liste de segments non superposés. Les segments ne sont pas nécessairement triés.\n\n**Entrée :**\n- Une list... | ["\nassert merge_overlapping_segments([(1, 3), (2, 6), (8, 10), (15, 18)]) == [(1, 6), (8, 10), (15, 18)]\n", "\nassert merge_overlapping_segments([(1, 4), (4, 5)]) == [(1, 5)]\n", "\nassert merge_overlapping_segments([(1, 2), (3, 4), (5, 6)]) == [(1, 2), (3, 4), (5, 6)]\n", "\nassert merge_overlapping_segments([(1, 10... |
f41ec5b5a38c1911940599fee843879b | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères incluant des parenthèses `()`, des crochets `[]`, et des accolades `{}`. Ta tâche est de déterminer si la chaîne est équilibrée. Une chaîne est considérée comme équilibrée si chaque symbole ouvrant a un symbole fermant correspondant d... | ["\nassert is_balanced(\"{[()]}\") == True\n", "\nassert is_balanced(\"{[(])}\") == False\n", "\nassert is_balanced(\"{{[[(())]]}}\") == True\n", "\nassert is_balanced(\"((({{{[[[]]]}}})))\") == True\n", "\nassert is_balanced(\"((({{{[[[}}})))\") == False\n", "\nassert is_balanced(\"\") == True\n", "\nassert is_balance... |
39dd5599ee7f2aa67d58eb179bc6fe7c | [
{
"content": "On te demande d'implémenter une fonction qui calcule la somme des carrés des `n` premiers nombres naturels. Ta fonction doit prendre un entier `n` en entrée et renvoyer la somme des carrés de tous les nombres naturels de 1 à `n`.\n\n**Contraintes :**\n- 1 ≤ n ≤ 10^4\n\n**Exemple d'entrée :**\n```\... | ["\nassert sum_of_squares(1) == 1\n", "\nassert sum_of_squares(2) == 5\n", "\nassert sum_of_squares(3) == 14\n", "\nassert sum_of_squares(4) == 30\n", "\nassert sum_of_squares(5) == 55\n", "\nassert sum_of_squares(10) == 385\n", "\nassert sum_of_squares(0) == 0\n", "\nassert sum_of_squares(100) == 338350\n", "\nassert ... |
04020b182a3e4fd53101d7a6b95b6b1d | [
{
"content": "Tu développes une application web et tu dois t’assurer que les entrées utilisateur sont assainies pour prévenir les attaques de Cross-Site Scripting (XSS). Ta tâche est d’implémenter une fonction `sanitize_input` qui traite une chaîne d’entrée donnée selon les règles suivantes :\n\n1. Supprime tou... | ["\nassert sanitize_input(\" <script>alert('XSS')</script> \") == \"<script>alert('XSS')</script>\"\n", "\nassert sanitize_input(\"Hello World\") == \"Hello World\"\n", "\nassert sanitize_input(\" Hello World \") == \"Hello World\"\n", "\nassert sanitize_input(\"This is a test.\") ==... |
910ff8a58f1252b28b23d4e898a37c45 | [
{
"content": "On te donne un arbre binaire complet représenté dans un tableau circulaire. Le nœud racine se trouve à l'index 0, et pour tout nœud à l'index `i`, ses enfants gauche et droit se trouvent aux index `(2*i + 1) % N` et `(2*i + 2) % N` respectivement, où `N` est la longueur du tableau. Ta tâche est de... | ["\nassert find_parent(0) == -1\n", "\nassert find_parent(1) == 0\n", "\nassert find_parent(2) == 0\n", "\nassert find_parent(3) == 1\n", "\nassert find_parent(4) == 1\n", "\nassert find_parent(5) == 2\n", "\nassert find_parent(6) == 2\n", "\nassert find_parent(7) == 3\n", "\nassert find_parent(8) == 3\n", "\nassert fi... |
698d087f1f13a9683c1a66ee6d6375c9 | [
{
"content": "On te donne le nom d'un dépôt GitHub et son propriétaire. Ta tâche est d'écrire un script Python qui utilise la bibliothèque `requests` pour récupérer les commits les plus récents du dépôt spécifié. Ton script doit afficher les messages de commit dans l'ordre dans lequel ils apparaissent dans la r... | ["\nassert fetch_latest_commits(\"octocat\", \"Hello-World\") is None\n", "\nassert fetch_latest_commits(\"octocat\", \"NonExistentRepo\") is None\n", "\nassert fetch_latest_commits(\"NonExistentOwner\", \"Hello-World\") is None\n", "\nassert fetch_latest_commits(\"octocat\", \"\") is None\n", "\nassert fetch_latest_co... |
9f89d8e36e79b5de8d75e0ec737d035b | [
{
"content": "On te demande de développer une fonction pour déterminer le type d'utilisateur qui a effectué un trajet dans un système de vélos en libre-service. Les informations sur le trajet sont fournies sous forme de dictionnaire imbriqué, et la structure du dictionnaire peut varier en fonction de la ville. ... | ["\nassert get_user_type({'usertype': 'Subscriber'}, 'NYC') == 'Subscriber'\n", "\nassert get_user_type({'User Type': 'Customer'}, 'Chicago') == 'Customer'\n", "\nassert get_user_type({'Member Type': 'Registered User'}, 'Washington') == 'Customer'\n", "\nassert get_user_type({'usertype': 'Subscriber', 'User Type': 'Cus... |
f2fdec3ac328f8798389c2acb2baa457 | [
{
"content": "On te donne une grille 3x3 remplie de nombres de 1 à 8, avec un espace vide représenté par 0. Cette grille représente un jeu de puzzle coulissant où le but est de réorganiser les nombres dans leur ordre correct (1-8) en faisant glisser les nombres dans l'espace vide.\n\nImplémente la fonction `mov... | ["\nassert move_right([[1, 2, 3], [4, 0, 5], [6, 7, 8]]) == [[1, 2, 3], [4, 5, 0], [6, 7, 8]]\n", "\nassert move_right([[1, 2, 3], [4, 0, 6], [7, 8, 5]]) == [[1, 2, 3], [4, 0, 6], [7, 8, 5]]\n", "\nassert move_right([[1, 2, 3], [4, 5, 0], [6, 7, 8]]) == [[1, 2, 3], [4, 5, 0], [6, 7, 8]]\n", "\nassert move_right([[1, 2,... |
89849814b27e571301d71f97bf15fe7d | [
{
"content": "On te donne deux chaînes de caractères `s1` et `s2`. Ta tâche est de déterminer si une chaîne est un anagramme palindrome de l'autre. Un anagramme palindrome est défini comme une chaîne qui peut être réarrangée pour former un palindrome. La comparaison doit être insensible à la casse, ignorer les ... | ["\nassert is_palindrome_anagram(\"A man, a plan, a canal, Panama!\", \"A Panama canal plan, a man!\") == True\n", "\nassert is_palindrome_anagram(\"No lemon, no melon\", \"Nolemonnomelon\") == True\n", "\nassert is_palindrome_anagram(\"Was it a car or a cat I saw?\", \"A car or a cat I saw, was it?\") == True\n", "\na... |
2e4671e3f241e3dea21a269e22b230b3 | [
{
"content": "On te donne une chaîne de caractères `coords` représentant une paire de coordonnées au format `X Y`, où `X` et `Y` sont des entiers séparés par un seul espace. Ta tâche est de déterminer si la chaîne d'entrée satisfait les critères suivants :\n\n1. La chaîne ne doit pas commencer ou se terminer pa... | ["\nassert validate_coordinates(\"2 3\") == True\n", "\nassert validate_coordinates(\"11 11\") == True\n", "\nassert validate_coordinates(\"100000 100000\") == False\n", "\nassert validate_coordinates(\"0 0\") == True\n", "\nassert validate_coordinates(\"10 10\") == False\n", "\nassert validate_coordinates(\"12345 6789... |
b6bace76d1ba51398dd8e8de29936faf | [
{
"content": "On te donne deux entiers, `x` et `n`. Ta tâche est de déterminer le plus grand entier composé `y` tel que `y^n` ne dépasse pas `x`. Un nombre composé est un entier positif supérieur à 1 qui n'est pas premier (c'est-à-dire qu'il a des diviseurs autres que 1 et lui-même).\n\n**Entrée :**\n- La premi... | ["\nassert find_root(1000, 2) == 31\n", "\nassert find_root(64, 3) == 3\n", "\nassert find_root(81, 2) == 8\n", "\nassert find_root(1, 1) == None\n", "\nassert find_root(100, 1) == 99\n", "\nassert find_root(16, 4) == 2\n", "\nassert find_root(1000000, 6) == 9\n", "\nassert find_root(49, 2) == 6\n", "\nassert find_root... |
d4015af37320aa8783f11ba8c73b6c13 | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction `find_min_index` qui renvoie l'index de la plus petite valeur dans la liste. Si la plus petite valeur apparaît plusieurs fois, renvoie l'index de sa dernière occurrence. La liste peut contenir des nombres négati... | ["\nassert find_min_index([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 3\n", "\nassert find_min_index([10, 20, 30, 40, 50]) == 0\n", "\nassert find_min_index([-10, -20, -30, -40, -50]) == 4\n", "\nassert find_min_index([5, 5, 5, 5, 5]) == 4\n", "\nassert find_min_index([0, -1, -2, -3, -2, -1, 0]) == 3\n", "\nassert find_min_i... |
766ca7ca5a902a2fb8d0a852b97f66ee | [
{
"content": "On te donne une chaîne de caractères `text` contenant un mélange de caractères. Ta tâche est de mettre en œuvre une fonction `extract_emails` qui identifie et renvoie une liste d'adresses e-mail uniques trouvées dans la chaîne. Les adresses e-mail doivent être renvoyées dans l'ordre de leur premiè... | ["\nassert extract_emails(\"john.doe@example.com\") == [\"john.doe@example.com\"]\n", "\nassert extract_emails(\"jane_doe123@domain.co.uk, john.doe@example.com\") == [\"jane_doe123@domain.co.uk\", \"john.doe@example.com\"]\n", "\nassert extract_emails(\"No emails here!\") == []\n", "\nassert extract_emails(\"john.doe@e... |
fadecf4c18ae75f54afdf9de7a06ba26 | [
{
"content": "On te donne une liste non triée d'entiers. Ta tâche est d'implémenter l'algorithme de tri rapide (quicksort) pour trier la liste par ordre croissant. L'algorithme de tri rapide doit être implémenté dans une fonction nommée `quicksort`. La fonction doit prendre une liste d'entiers en entrée et renv... | ["\nassert quicksort([3, 5, 1, 4, 2, 8, 7, 6]) == [1, 2, 3, 4, 5, 6, 7, 8]\n", "\nassert quicksort([1, 2, 3, 4, 5, 6, 7, 8]) == [1, 2, 3, 4, 5, 6, 7, 8]\n", "\nassert quicksort([8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8]\n", "\nassert quicksort([5, 3, 8, 6, 2, 7, 4, 1]) == [1, 2, 3, 4, 5, 6, 7, 8]\n", "\nasse... |
fb988b9d376445cb7c53b5533b185845 | [
{
"content": "On te demande d'implémenter une classe `Employee` qui gère les détails des employés. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `name` : une chaîne de caractères représentant le nom de l'employé.\n - `salary` : un flottant représentant le salaire de l'empl... | ["\nassert Employee(\"Alice\", 60000, \"HR\").salary == 60000\n", "\nassert Employee(\"Bob\", 70000, \"Marketing\").department == \"Marketing\"\n", "\nassert Employee(\"Charlie\", 80000, \"Engineering\").apply_bonus(10000) or Employee(\"Charlie\", 80000, \"Engineering\").salary == 90000\n", "\nassert Employee(\"David\"... |
f26a24793799b5bb6f0ebf9f94289d5a | [
{
"content": "On te donne une chaîne de caractères `s` et un préfixe `p`. Ta tâche est de traiter la chaîne `s` en la renversant d'abord, puis en remplaçant tous les espaces par des tirets bas dans la chaîne inversée, en ajoutant le préfixe `p` au début de la chaîne modifiée, et enfin en renversant toute la cha... | ["\nassert add_custom_prefix(\"pre_\", \"hello world\") == \"pre_world_hello\"\n", "\nassert add_custom_prefix(\"test_\", \"a b c\") == \"test_c_b_a\"\n", "\nassert add_custom_prefix(\"my_\", \"python is fun\") == \"my_nuf_si_nohtyp\"\n", "\nassert add_custom_prefix(\"code_\", \"open ai\") == \"code_i_a_nepo\"\n", "\na... |
ca327bbf118f1155d70e4f9ccc5079bd | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Détermine si tu peux rendre `str1` égal à `str2` en effectuant au plus une opération de modification. Une opération de modification peut être une insertion, une suppression ou une substitution d'un seul caractère. La comparaison est sensibl... | ["\nassert is_one_edit_or_insert(\"pale\", \"ple\") == True\n", "\nassert is_one_edit_or_insert(\"pales\", \"pale\") == True\n", "\nassert is_one_edit_or_insert(\"pale\", \"bale\") == True\n", "\nassert is_one_edit_or_insert(\"pale\", \"bake\") == False\n", "\nassert is_one_edit_or_insert(\"\uc548\ub155\", \"\uc548\ub8... |
2852c57e9b94c297ca3de31e54b9a8b4 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est de mettre en œuvre une fonction `extract_vowels` qui traite cette chaîne et renvoie une nouvelle chaîne composée uniquement des voyelles présentes dans la chaîne d'origine. La fonction doit être robuste et gérer divers cas, y compris le... | ["\nassert extract_vowels(\"hello world\") == \"eoo\"\n", "\nassert extract_vowels(\"AEIOU\") == \"AEIOU\"\n", "\nassert extract_vowels(\"bcdfg\") == \"\"\n", "\nassert extract_vowels(\"Python Programming\") == \"oOai\"\n", "\nassert extract_vowels(\"\") == \"\"\n", "\nassert extract_vowels(\"12345\") == \"\"\n", "\nas... |
837b5ed1cef970cc03043f1bc870dccb | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction qui renvoie le caractère le plus fréquemment rencontré dans la chaîne. Si plusieurs caractères ont la même fréquence la plus élevée, renvoie le premier rencontré. La fonction doit gérer les cas limites tels qu'une ch... | ["\nassert most_frequent_char(\"abracadabra\") == \"a\"\n", "\nassert most_frequent_char(\"hello world\") == \"l\"\n", "\nassert most_frequent_char(\"test string\") == \"t\"\n", "\nassert most_frequent_char(\"aabbcc\") == \"a\"\n", "\nassert most_frequent_char(\"xyz\") == \"x\"\n", "\nassert most_frequent_char(\"\") ==... |
025f0e9f77025c6ab7a86c81b9394be6 | [
{
"content": "On te donne une liste de séries de données nommées, où chaque série est représentée comme un tuple constitué d'un nom de série (une chaîne de caractères) et d'une liste de nombres. Ta tâche est de mettre en œuvre une fonction `log_transform` qui applique une transformation logarithmique à chaque s... | ["\nassert log_transform([(\"series1\", [10, 100, 1000])]) == [(\"log(series1, 10)\", [1.0, 2.0, 3.0])]\n", "\nassert log_transform([(\"series2\", [1, 2, 3, 4, 5])], base=2) == [(\"log(series2, 2)\", [0.0, 1.0, 1.584962500721156, 2.0, 2.321928094887362])]\n", "\nassert log_transform([(\"series3\", [0, -1, 1, 2, 3])]) =... |
6a73d4939b908425b3604e200d86a2a8 | [
{
"content": "On te donne un arbre binaire avec `n` nœuds, où chaque nœud a une valeur entière unique. Ta tâche est de déterminer si l'arbre binaire est un arbre binaire complet. Un arbre binaire est considéré comme complet si tous les niveaux, sauf éventuellement le dernier, sont complètement remplis, et tous ... | ["\nassert is_complete_tree(None) == True\n", "\nassert is_complete_tree(TreeNode(1)) == True\n", "\nassert is_complete_tree(TreeNode(1, TreeNode(2))) == True\n", "\nassert is_complete_tree(TreeNode(1, TreeNode(2), TreeNode(3))) == True\n", "\nassert is_complete_tree(TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), T... |
9471b0cf91b3208d3e1ac1a6a34ad3c2 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ta tâche est de trouver deux indices distincts `i` et `j` tels que `numbers[i] + numbers[j]` soit égal à `target`. Retourne les indices sous la forme d'un tuple `(i, j)`. Si aucune paire de ce type n'existe, retourne `None`. Note que... | ["\nassert two_sum([2, 7, 11, 15], 9) == (0, 1)\n", "\nassert two_sum([3, 2, 4], 6) == (1, 2)\n", "\nassert two_sum([3, 3], 6) == (0, 1)\n", "\nassert two_sum([1, 2, 3, 4, 5], 10) == (3, 4)\n", "\nassert two_sum([1, 2, 3, 4, 5], 8) == (2, 4)\n", "\nassert two_sum([1, 2, 3, 4, 5], 11) == None\n", "\nassert two_sum([], 0... |
5df8b8a32500c8a0f74e3f615af5abd4 | [
{
"content": "On te demande d'implémenter une fonction `count_vowels` qui traite une chaîne de caractères donnée et renvoie le nombre total de voyelles présentes dans celle-ci. Les voyelles sont définies comme 'a', 'e', 'i', 'o', 'u' en minuscules et en majuscules. Ta fonction doit être robuste et gérer les ent... | ["\nassert count_vowels(\"hello\") == 2\n", "\nassert count_vowels(\"HELLO\") == 2\n", "\nassert count_vowels(\"Python Programming\") == 4\n", "\nassert count_vowels(\"12345\") == 0\n", "\nassert count_vowels(\"!@#$%^&*()\") == 0\n", "\nassert count_vowels(\"\") == 0\n", "\nassert count_vowels(\"aeiouAEIOU\") == 10\n",... |
f59533de5353d0d9b5352a2589ae22b6 | [
{
"content": "On te demande d'implémenter une fonction `read_json_file` qui traite un fichier JSON et renvoie son contenu sous forme de dictionnaire. Ta fonction doit gérer deux cas exceptionnels : lorsque le fichier n'existe pas et lorsque le fichier contient une syntaxe JSON invalide. Dans les deux cas, ta fo... | ["\nassert read_json_file(\"non_existent_file.json\") == {}\n", "\nassert read_json_file(\"valid_json.json\") == {\"key\": \"value\"}\n", "\nassert read_json_file(\"invalid_json.json\") == {}\n", "\nassert read_json_file(\"\") == {}\n", "\nassert read_json_file(\"empty_file.json\") == {}\n", "\nassert read_json_file(\"... |
e4a2481282db1ac90e35476e2cb8611a | [
{
"content": "On te donne un ensemble de données d'images représentées comme une liste de dictionnaires, où chaque dictionnaire contient une image et ses métadonnées. La clé `'image'` contient les données de l'image. Tu dois implémenter une fonction `batch_process_images` qui traite ces images par lots en utili... | ["\nassert batch_process_images([{'image': 'img1', 'label': 'cat'}, {'image': 'img2', 'label': 'dog'}], lambda x: x.upper(), 1, ['label']) == [{'image': 'IMG1'}, {'image': 'IMG2'}]\n", "\nassert batch_process_images([{'image': 'img1', 'label': 'cat'}, {'image': 'img2', 'label': 'dog'}], lambda x: x, 2, []) == [{'image'... |
c85d285cd9fdb1c25bf5cb0c41ad169e | [
{
"content": "On te donne un entier `n` (10 < n < 1 000 000). Ta tâche est d'écrire une fonction `find_largest_palindrome` qui renvoie le plus grand nombre palindrome inférieur à `n`. Un nombre palindrome se lit de la même manière à l'endroit et à l'envers.\n\n**Exemple d'entrée et de sortie :**\n- Entrée : `10... | ["\nassert find_largest_palindrome(1000) == 999\n", "\nassert find_largest_palindrome(100) == 99\n", "\nassert find_largest_palindrome(200) == 191\n", "\nassert find_largest_palindrome(10) == 9\n", "\nassert find_largest_palindrome(11) == 9\n", "\nassert find_largest_palindrome(101) == 99\n", "\nassert find_largest_pal... |
c241131f0135e12ccb5ff8e7ab9ba2a6 | [
{
"content": "Dans un tournoi de type round-robin, chaque équipe affronte chaque autre équipe exactement une fois. Le tournoi est organisé en groupes, où chaque groupe contient un sous-ensemble d'équipes. Pendant chaque tour, les équipes au sein du même groupe s'affrontent. Ta tâche est de simuler un tour du to... | ["\nassert simulate_round_robin_round({'Team A': [], 'Team B': [], 'Team C': []}, [['Team A', 'Team B', 'Team C']]) == {'Team A': ['Team B', 'Team C'], 'Team B': ['Team A', 'Team C'], 'Team C': ['Team A', 'Team B']}\n", "\nassert simulate_round_robin_round({'Team X': [], 'Team Y': [], 'Team Z': []}, [['Team X', 'Team Y... |
2c25f32513c66075962358f63d3daa03 | [
{
"content": "On te donne un tableau d'entiers non négatifs `numbers` et un entier cible `target`. Ta tâche est de déterminer s'il existe une paire d'entiers dans `numbers` dont la somme est égale à `target`. Implémente un algorithme de type diviser pour régner qui divise le tableau en deux moitiés, trie chaque... | ["\nassert divide_and_conquer_sum_pair([1, 2, 3, 4, 5], 9, 5) == (True, (4, 5))\n", "\nassert divide_and_conquer_sum_pair([1, 2, 3, 4, 5], 10, 5) == (False, None)\n", "\nassert divide_and_conquer_sum_pair([5, 5, 5, 5, 5], 10, 5) == (True, (5, 5))\n", "\nassert divide_and_conquer_sum_pair([1, 3, 5, 7, 9], 12, 9) == (Tru... |
0c0625410b975ad30cbb05524207a605 | [
{
"content": "On te donne une liste d'entiers et un entier positif `k`. Ta tâche est d'implémenter une fonction `rotate_list` qui fait pivoter les éléments de la liste vers la droite de `k` positions. Si `k` est supérieur à la longueur de la liste, la rotation doit se poursuivre depuis le début. La fonction doi... | ["\nassert rotate_list([1, 2, 3, 4, 5], 2) == [4, 5, 1, 2, 3]\n", "\nassert rotate_list([], 3) == []\n", "\nassert rotate_list([1, 2, 3], 5) == [2, 3, 1]\n", "\nassert rotate_list(['a', 'b', 'c', 'd'], 1) == ['d', 'a', 'b', 'c']\n", "\nassert rotate_list([True, False, True], 3) == [True, False, True]\n", "\nassert rota... |
b35b1e71d97425679bdca7d0792206a3 | [
{
"content": "On te donne un dictionnaire imbriqué où les clés peuvent correspondre à d'autres dictionnaires ou à des valeurs. Ta tâche est d'écrire une fonction `flatten_dict` qui transforme ce dictionnaire imbriqué en un dictionnaire plat. Les clés du dictionnaire résultant doivent être construites en concaté... | ["\nassert flatten_dict({\"a\": {\"b\": {\"c\": 1}}}) == {\"a_b_c\": 1}\n", "\nassert flatten_dict({\"x\": 1, \"y\": {\"z\": 2}}) == {\"x\": 1, \"y_z\": 2}\n", "\nassert flatten_dict({\"level1\": {\"level2\": {\"level3\": {\"level4\": 5}}}}) == {\"level1_level2_level3_level4\": 5}\n", "\nassert flatten_dict({\"single\"... |
3c2eb1fd18a06bed7e264539f65029ce | [
{
"content": "On te donne une liste d'entiers `numbers`. Ta tâche est d'implémenter une fonction `find_longest_sequence(numbers)` qui identifie la plus longue séquence d'entiers consécutifs dans la liste. S'il existe plusieurs séquences de longueur maximale, renvoie la séquence qui commence par le plus petit en... | ["\nassert find_longest_sequence([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert find_longest_sequence([10, 4, 20, 1, 3, 2]) == [1, 2, 3, 4]\n", "\nassert find_longest_sequence([100, 4, 200, 1, 3, 2]) == [1, 2, 3, 4]\n", "\nassert find_longest_sequence([1, 9, 3, 10, 4, 20, 2]) == [1, 2, 3, 4]\n", "\nassert find_longe... |
f89541ac11cbc95b129b90c6acf9ddb2 | [
{
"content": "On te demande d'implémenter une méthode `save_roi` pour la classe `ImageProcessor`. La classe est conçue pour gérer les tâches de traitement d'image et comprend les attributs suivants :\n- `curr_img` : une référence à l'image actuelle en cours de traitement.\n- `ori_x`, `ori_y` : les coordonnées x... | ["\nassert ImageProcessor(None, 0, 0, 10, 10, 10, 10, set()).save_roi() == True\n", "\nassert ImageProcessor(None, 0, 0, 10, 10, 0, 10, set()).save_roi() == False\n", "\nassert ImageProcessor(None, 0, 0, 10, 10, 10, 0, set()).save_roi() == False\n", "\nassert ImageProcessor(None, 5, 5, 15, 15, 10, 10, {(10, 10)}).save_... |
49a57700b408008c064a4909bd86f340 | [
{
"content": "Tu participes à un concours de programmation où l'on te donne une liste de fonctions, chacune représentant une tâche qui peut être exécutée indépendamment. Ta tâche est d'écrire une fonction `execute_tasks` qui prend cette liste de tâches en entrée et renvoie une liste de résultats obtenus en exéc... | ["\nassert execute_tasks([lambda: 1 + 1, lambda: 2 * 2]) == [2, 4]\n", "\nassert execute_tasks([lambda: 1 / 0, lambda: 3 - 1]) == [None, 2]\n", "\nassert execute_tasks([lambda: \"hello\" + \"world\", lambda: \"test\" * 3]) == [\"helloworld\", \"testtesttest\"]\n", "\nassert execute_tasks([lambda: [1, 2, 3].append(4), l... |
64a5dd8e41d43ebd152151116f3092f9 | [
{
"content": "On te donne une chaîne de caractères `S` et une liste de contextes `C`. Ta tâche est de mettre en œuvre une fonction `translate_with_context` qui renvoie la version traduite de `S` en fonction des contextes fournis et d'un dictionnaire de traduction `T`. La fonction doit gérer jusqu'à 50 contextes... | ["\nassert translate_with_context(\"Hello\", [\"greeting casual lovers\"], {(\"Hello\", \"greeting casual lovers\"): \"Hey\"}) == \"Hey\"\n", "\nassert translate_with_context(\"Hello\", [\"greeting friends\"], {(\"Hello\", \"greeting casual lovers\"): \"Hey\"}) == \"Hello\"\n", "\nassert translate_with_context(\"Hello\... |
ffbf9f28d5043a921a7d987e3425e57b | [
{
"content": "On te donne un jeu de fléchettes carré d'une longueur de côté de 2 unités et une cible circulaire inscrite à l'intérieur, ayant un rayon de 1 unité. Ta tâche est de simuler le processus de lancer `numPoints` fléchettes sur le jeu de fléchettes et d'estimer la valeur de π en utilisant la méthode de... | ["\nassert throw_darts(1000) > 3 and throw_darts(1000) < 3.2\n", "\nassert throw_darts(10000) > 3.1 and throw_darts(10000) < 3.15\n", "\nassert throw_darts(100000) > 3.13 and throw_darts(100000) < 3.15\n", "\nassert throw_darts(1000000) > 3.14 and throw_darts(1000000) < 3.15\n", "\nassert throw_darts(10000000) > 3.141 ... |
815209d2f139913e6e6b7b99ea66715b | [
{
"content": "On te donne un dictionnaire `city_temperatures` où chaque clé est une chaîne de caractères représentant le nom d'une ville, et la valeur est une liste d'entiers représentant les températures enregistrées dans cette ville sur une période donnée. Ta tâche est de mettre en œuvre une fonction `calcula... | ["\nassert calculate_city_averages({'New York': [30, 32, 35, 28, 31]}) == {'New York': 31.2}\n", "\nassert calculate_city_averages({'Los Angeles': [80, 85, 82, 88]}) == {'Los Angeles': 83.75}\n", "\nassert calculate_city_averages({'Chicago': [20, 25, 22, 23, 27]}) == {'Chicago': 23.4}\n", "\nassert calculate_city_avera... |
b4f0103cba600a44829aa56d55620eb8 | [
{
"content": "On te donne un dictionnaire aplati où les clés sont représentées par des chaînes de caractères avec des points (`.`) pour indiquer les structures imbriquées. Ta tâche est de mettre en œuvre une fonction `nest_dict(dictionary: dict) -> dict` qui reconstruit le dictionnaire imbriqué original à parti... | ["\nassert nest_dict({\"a.b\": 1, \"a.c\": 2}) == {\"a\": {\"b\": 1, \"c\": 2}}\n", "\nassert nest_dict({\"x.y.z\": 3, \"x.y.w\": 4}) == {\"x\": {\"y\": {\"z\": 3, \"w\": 4}}}\n", "\nassert nest_dict({\"key\": \"value\"}) == {\"key\": \"value\"}\n", "\nassert nest_dict({\"1.2.3\": 5, \"1.2.4\": 6}) == {\"1\": {\"2\": {... |
9fe50c26f2a949e17a82163c72d75458 | [
{
"content": "On te donne une fonction continue `f(x)` et un intervalle `[a, b]`. Ta tâche est de mettre en œuvre la méthode de la fausse position pour trouver une racine de la fonction dans l'intervalle. La méthode doit ajuster de manière adaptative la largeur de l'intervalle en fonction du taux de convergence... | ["\nassert regula_falsi(lambda x: x**2 - 4, 0, 4) == 2.0\n", "\nassert regula_falsi(lambda x: x**2 - 4, -4, 0) == -2.0\n", "\nassert regula_falsi(lambda x: x**3 - 27, 0, 5) == 3.0\n", "\nassert regula_falsi(lambda x: x**2 - 1, -2, 2) in [-1.0, 1.0]\n", "\nassert regula_falsi(lambda x: x**2 - 1, 0, 2) == 1.0\n", "\nasse... |
f1ddc66514a6cb07ed0c7d5ea000b4c1 | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tableau numpy 2D `im` avec des intensités de pixels allant de 0 à 255. Ta tâche est de mettre en œuvre une fonction `rescale_intensity(im, win)` qui ajuste l'intensité de l'image en fonction d'une fenêtre donnée `win`. La fenêtre `win` ... | ["\nassert np.array_equal(rescale_intensity(np.array([[100, 150], [200, 250]], dtype=np.uint8), (100, 200)), np.array([[0, 127], [255, 255]], dtype=np.uint8))\n", "\nassert np.array_equal(rescale_intensity(np.array([[50, 100], [150, 200]], dtype=np.uint8), (100, 150)), np.array([[0, 0], [0, 255]], dtype=np.uint8))\n", ... |
3aeb5035d0bf1fd5d0075651cd00d717 | [
{
"content": "On te donne un tableau NumPy 2D `X` de forme `(n_rows, n_cols)` où certains éléments sont manquants et représentés par `NaN`. De plus, on te fournit une liste `exclude_cols` contenant les indices des colonnes qui ne doivent pas être traitées. Ta tâche est de mettre en œuvre une fonction `column_av... | ["\nassert np.array_equal(column_average_exclude_array(np.array([[np.nan, 2, 3], [1, np.nan, 3], [1, 2, np.nan]]), [1]), np.array([[np.nan, 2, 3], [1, np.nan, 3], [1, 2, 3]]))\n", "\nassert np.array_equal(column_average_exclude_array(np.array([[np.nan, 2, 3], [1, np.nan, 3], [1, 2, np.nan]]), [0]), np.array([[1.0, 2, 3... |
5ed4d06fbf7131ca8054fb86a49d6577 | [
{
"content": "On te donne deux entiers positifs `n1` et `n2` représentant les longueurs de deux segments non chevauchants d'une droite numérique. On te donne également un entier positif `max_len` représentant la longueur maximale d'une combinaison.\n\nTa tâche est de générer toutes les combinaisons possibles d'... | ["\nassert generate_valid_combinations(3, 4, 3) == [(0, 3), (0, 4), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (0, 3, 4), (0, 3, 6), (0, 4, 5), (1, 3, 4), (1, 3, 5), (1, 4, 6), (2, 3, 4), (2, 3, 6), (2, 4, 5)]\n", "\nassert generate_valid_combinations(2, 2, 2) == [(0, 2), (0, 3), (1... |
20a9c93495a610701420bc5e61dd7dcb | [
{
"content": "On te donne une liste de chemins de fichiers, `file_paths`, et une liste de répertoires, `directories_to_remove`. Ta tâche est d'implémenter une fonction qui filtre les chemins de fichiers de `file_paths` qui se trouvent dans l'un des répertoires listés dans `directories_to_remove`. La fonction do... | ["\nassert remove_file_paths_within_directories([\"/home/user/file1.txt\"], [\"/home/user\"]) == []\n", "\nassert remove_file_paths_within_directories([\"/home/user/file1.txt\"], [\"/home/other\"]) == [\"/home/user/file1.txt\"]\n", "\nassert remove_file_paths_within_directories([\"/home/user/file1.txt\", \"/home/user/f... |
50206551dc03494109fd4a2a50c6286e | [
{
"content": "On te donne deux listes : l'une contenant les noms de langages de programmation et l'autre contenant leurs scores de popularité correspondants. Chaque score de popularité est un entier compris entre 0 et 100, où 0 indique aucune popularité et 100 indique une popularité maximale. Ta tâche est de me... | ["\nassert sort_languages_by_popularity([\"Python\", \"Java\", \"C++\", \"JavaScript\", \"Ruby\"], [85, 80, 50, 90, 60]) == [\"JavaScript\", \"Python\", \"Java\", \"Ruby\", \"C++\"]\n", "\nassert sort_languages_by_popularity([\"Python\", \"Java\", \"C++\"], [100, 100, 100]) == [\"C++\", \"Java\", \"Python\"]\n", "\nass... |
b6b991eada462297f173903c52c8f385 | [
{
"content": "On te donne une liste de noms de fichiers et un dictionnaire qui associe des indices à des étiquettes. Ta tâche est de créer une fonction `map_filenames_to_labels` qui génère un nouveau dictionnaire associant chaque nom de fichier à son étiquette correspondante. Si un nom de fichier apparaît plusi... | ["\nassert map_filenames_to_labels([\"file1.txt\", \"file2.txt\", \"file1.txt\"], {0: \"label1\", 1: \"label2\", 2: \"label3\"}) == {\"file1.txt\": \"label3\", \"file2.txt\": \"label2\"}\n", "\nassert map_filenames_to_labels([\"a.txt\", \"b.txt\", \"c.txt\"], {0: \"alpha\", 1: \"beta\", 2: \"gamma\"}) == {\"a.txt\": \"... |
41073e72c9d288141935c3a84b22ffd4 | [
{
"content": "On te donne deux entiers positifs `n` et `k`. Ta tâche est de trouver le produit des `k` premiers facteurs premiers de `n`. Si `n` a moins de `k` facteurs premiers, renvoie `None`. Tu n'es pas autorisé à utiliser des fonctions ou des bibliothèques intégrées pour la factorisation première ou les op... | ["\nassert prime_factors_product(100, 2) == 10\n", "\nassert prime_factors_product(30, 3) == 30\n", "\nassert prime_factors_product(49, 1) == 7\n", "\nassert prime_factors_product(49, 2) == 49\n", "\nassert prime_factors_product(49, 3) == None\n", "\nassert prime_factors_product(1, 1) == None\n", "\nassert prime_factor... |
6665a056bf76626da12c410a035c3271 | [
{
"content": "On te demande d'implémenter une fonction `validate_pin` qui vérifie si une chaîne de caractères donnée est un code PIN à 4 chiffres valide. Un code PIN valide doit satisfaire les conditions suivantes :\n- Il doit être exactement composé de 4 caractères.\n- Il doit être composé uniquement de chiffr... | ["\nassert validate_pin(\"1234\") == True\n", "\nassert validate_pin(\"4321\") == True\n", "\nassert validate_pin(\"1111\") == False\n", "\nassert validate_pin(\"1221\") == False\n", "\nassert validate_pin(\"123\") == False\n", "\nassert validate_pin(\"12345\") == False\n", "\nassert validate_pin(\"12a4\") == False\n",... |
5013a8f1ceadb57b7739bce9e5e17c6c | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est d'écrire une fonction qui trouve toutes les sous-chaînes palindromiques uniques dans `s` et de les renvoyer sous forme de liste. Une sous-chaîne palindromique est définie comme une sous-chaîne qui se lit de la même manière de gauche à droi... | ["\nassert find_palindromic_substrings(\"ababa\") == ['aba', 'bab', 'ababa', 'a', 'b']\n", "\nassert find_palindromic_substrings(\"racecar\") == ['cec', 'aceca', 'cec', 'racecar', 'e', 'c', 'a']\n", "\nassert find_palindromic_substrings(\"a\") == ['a']\n", "\nassert find_palindromic_substrings(\"aa\") == ['aa', 'a']\n"... |
5e6df9d7a6ba96bf33161167caaa43f2 | [
{
"content": "On te donne une liste de `n` fruits uniques, chacun représenté par une chaîne de caractères. Tu as un panier qui peut contenir au maximum `n // 2` fruits. Ta tâche est de distribuer ces fruits dans le panier de manière à maximiser la variété des fruits dans le panier. Cependant, tu ne peux mettre ... | ["\nassert max_fruits_in_basket([\"apple\", \"banana\", \"cherry\"], [(\"apple\", \"banana\")]) == 1\n", "\nassert max_fruits_in_basket([\"apple\", \"banana\", \"cherry\"], []) == 1\n", "\nassert max_fruits_in_basket([\"apple\", \"banana\", \"cherry\"], [(\"apple\", \"banana\"), (\"banana\", \"cherry\")]) == 1\n", "\na... |
78a924832d7407f1fc1e95f7eac5bd49 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'écrire une fonction qui calcule la fréquence de chaque chaîne de caractères unique dans la liste et renvoie un dictionnaire avec les chaînes de caractères comme clés et leurs fréquences comme valeurs.\n\n**Entrée :**\n- Une liste d... | ["\nassert string_frequency([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"banana\"]) == {\"apple\": 2, \"banana\": 3, \"orange\": 1}\n", "\nassert string_frequency([\"cat\", \"dog\", \"cat\", \"bird\", \"dog\", \"dog\"]) == {\"cat\": 2, \"dog\": 3, \"bird\": 1}\n", "\nassert string_frequency([\"hello\", ... |
245e1ecbd403c6709af7d76126a1f909 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui renvoie une nouvelle liste contenant uniquement les nombres non premiers de la liste originale. Utilise une compréhension de liste pour y parvenir.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 1000),... | ["\nassert filter_out_primes([2, 3, 4, 5, 6]) == [4, 6]\n", "\nassert filter_out_primes([11, 13, 17, 19]) == []\n", "\nassert filter_out_primes([1, 4, 6, 8, 9, 10]) == [1, 4, 6, 8, 9, 10]\n", "\nassert filter_out_primes([0, 1, 2, 3, 4, 5]) == [0, 1, 4]\n", "\nassert filter_out_primes([29, 15, 21, 22, 23, 24]) == [15, 2... |
b46783546cf45f3e5c2cb4f290c9c8aa | [
{
"content": "On te donne une liste d'entiers positifs distincts. Ta tâche est de déterminer s'il est possible de partitionner cette liste en deux sous-ensembles tels que la somme des éléments de chaque sous-ensemble soit égale. Chaque nombre de la liste est unique et inférieur à 1000. Affiche \"True\" si une t... | ["\nassert can_partition([1, 5, 11, 5]) == True\n", "\nassert can_partition([1, 2, 3, 5]) == False\n", "\nassert can_partition([1, 2, 3, 4, 5, 6, 7]) == False\n", "\nassert can_partition([1, 2, 3, 4, 5, 6, 7, 8]) == True\n", "\nassert can_partition([1, 2, 3, 4, 5, 6, 7, 8, 9]) == False\n", "\nassert can_partition([1, 2... |
0a2f0a89788c88ca440bdcdeb204c724 | [
{
"content": "On te demande d'implémenter une fonction `generate_prime(k)` qui génère un nombre premier aléatoire de exactement `k` bits de longueur, où `k` est garanti d'être un multiple de 3. Ta fonction doit utiliser le test de primalité de Miller-Rabin pour vérifier la primalité du nombre généré. Le test de... | ["\nassert isinstance(generate_prime(9), int)\n", "\nassert bin(generate_prime(9)).startswith('0b1')\n", "\nassert len(bin(generate_prime(9))) == 11 # 9 bits + '0b' prefix\n", "\nassert bin(generate_prime(12)).startswith('0b1')\n", "\nassert len(bin(generate_prime(12))) == 14 # 12 bits + '0b' prefix\n", "\nassert bin... |
e0a7a84585ae99c8dce93cb4bf5e7eca | [
{
"content": "Tu participes à un jeu stratégique où deux joueurs négocient sur les gains. Étant donné un tableau `threat_points` représentant les gains minimum acceptables pour chaque joueur et une liste de listes `feasible_points` représentant plusieurs scénarios de gains possibles, ta tâche est de mettre à jo... | ["\nassert update_threat_points([1, 1], [[2, 3], [3, 2], [1, 4]]) == [2, 2]\n", "\nassert update_threat_points([0, 0], [[1, 1], [2, 2], [3, 3]]) == [1, 1]\n", "\nassert update_threat_points([5, 5], [[4, 4], [3, 3], [2, 2]]) == [5, 5]\n", "\nassert update_threat_points([1, 2], [[1, 2], [2, 1], [3, 0]]) == [3, 2]\n", "\n... |
213b3341310345b63be1029a7eef6434 | [
{
"content": "On te donne une liste de fractions, où chaque fraction est représentée comme un tuple de deux entiers (numérateur, dénominateur). Ta tâche est d'écrire une fonction qui prend cette liste de fractions en entrée et renvoie le produit de ces fractions sous la forme d'une seule fraction simplifiée. La... | ["\nassert product_of_fractions([(1, 2), (3, 4)]) == (3, 8)\n", "\nassert product_of_fractions([(1, 2), (2, 1)]) == (1, 1)\n", "\nassert product_of_fractions([(1, 3), (3, 1), (2, 2)]) == (1, 1)\n", "\nassert product_of_fractions([(1, 2), (-3, 4)]) == (-3, 8)\n", "\nassert product_of_fractions([(-1, 2), (-3, 4)]) == (3,... |
24ba31e532c89c193b9b5f4ef0e23eee | [
{
"content": "On te donne une chaîne de caractères `text` composée de caractères alphabétiques, d'espaces et de ponctuation. Ta tâche est d'écrire une fonction `reverse_alternate_characters` qui traite cette chaîne en inversant la casse de chaque caractère alphabétique sur deux, en commençant par le premier car... | ["\nassert reverse_alternate_characters(\"aB cD eF\") == \"Ab cD Ef\"\n", "\nassert reverse_alternate_characters(\"Hello, World!\") == \"HeLlO, WoRlD!\"\n", "\nassert reverse_alternate_characters(\"Python 3.8\") == \"PyThOn 3.8\"\n", "\nassert reverse_alternate_characters(\"12345\") == \"12345\"\n", "\nassert reverse_a... |
78998a34c60c12b138f2a333e132f658 | [
{
"content": "On te donne une liste de six chaînes hexadécimales, chacune représentant un nombre à deux chiffres au format BCD (Binary-Coded Decimal) compacté. Ces chaînes correspondent respectivement à l'année, au mois, au jour, à l'heure, à la minute et à la seconde. Ta tâche est de décoder ces chaînes hexadé... | ["\nassert timeDecode(['a0', '07', '16', '18', '37', '42']) == datetime(2016, 7, 22, 24, 37, 42)\n", "\nassert timeDecode(['00', '01', '01', '00', '00', '00']) == datetime(2000, 1, 1, 0, 0, 0)\n", "\nassert timeDecode(['99', '12', '31', '23', '59', '59']) == datetime(2099, 12, 31, 23, 59, 59)\n", "\nassert timeDecode([... |
3d5304336f5f25a2295398460824d9ee | [
{
"content": "On te demande d'implémenter une fonction `create_unique_elements_set` qui traite un nombre variable d'arguments, qui peuvent inclure des listes imbriquées. Ta fonction doit aplatir récursivement ces arguments pour extraire tous les éléments individuels et renvoyer un ensemble contenant uniquement ... | ["\nassert create_unique_elements_set([1, 2, [3, 4]], [5, 6, [7, 8]], [9, 1, [2, 10]]) == {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n", "\nassert create_unique_elements_set('string', [11, 'string']) == {'string', 11}\n", "\nassert create_unique_elements_set([1, 2, [3, 4]], 'string', [5, 6, [7, 8]], [9, 1, [2, 10]], 'string', [11... |
e1efdd40c4e25d2ea5a217d91c1b3085 | [
{
"content": "On te donne un dictionnaire `d` qui peut contenir des dictionnaires imbriqués. Ta tâche est d'écrire une fonction `swap_keys_values` qui renvoie un nouveau dictionnaire où les clés et les valeurs du dictionnaire original sont échangées. Si le dictionnaire original a des valeurs dupliquées, seule l... | ["\nassert swap_keys_values({\"a\": 1, \"b\": 2, \"c\": 1}) == {1: \"a\", 2: \"b\"}\n", "\nassert swap_keys_values({\"x\": 10, \"y\": 20, \"z\": 10}) == {10: \"x\", 20: \"y\"}\n", "\nassert swap_keys_values({\"m\": \"n\", \"o\": \"p\", \"q\": \"n\"}) == {\"n\": \"m\", \"p\": \"o\"}\n", "\nassert swap_keys_values({\"k\"... |
df7a706920e66e249bfe67faa678e589 | [
{
"content": "Étant donné deux listes d'entiers, écris une fonction pour déterminer l'intersection de ces listes, en veillant à ce que la liste résultante contienne uniquement des éléments uniques. L'ordre des éléments dans la liste de sortie n'a pas d'importance.\n\n**Entrée :**\n- Deux listes d'entiers, `list... | ["\nassert find_intersection([1, 2, 3], [3, 4, 5]) == [3]\n", "\nassert find_intersection([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_intersection([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_intersection([], [1, 2, 3]) == []\n", "\nassert find_intersection([1, 2, 3], []) == []\n", "\nassert find_intersecti... |
938363b2e9d0aa100ad57a533c9b8044 | [
{
"content": "Tu participes à une compétition de science des données où l'on te fournit un ensemble de données contenant des avis clients pour une plateforme de commerce électronique. L'ensemble de données est stocké dans un DataFrame pandas nommé `reviews_df`. Chaque ligne du DataFrame représente un seul avis,... | ["\nassert split_reviews(pd.DataFrame({'review_text': ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'], 'review_rating': [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]}))[0].shape[0] == 8\n", "\nassert split_reviews(pd.DataFrame({'review_text': ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'], 'review_rating': [1, 2, 3, 4, 5, 1, 2... |
86db2a52de5d7151d27ca3c4437d5393 | [
{
"content": "On te donne une expression mathématique représentée sous forme de liste de chaînes de caractères. La liste comprend des nombres (entiers et nombres à virgule flottante), des opérateurs binaires (`+`, `-`, `*`, `/`, `^`) et des opérateurs unaires (signe moins `-`). Les parenthèses `(` et `)` sont u... | ["\nassert evaluate_expression([\"3\", \"+\", \"4\", \"*\", \"2\", \"/\", \"(\", \"1\", \"-\", \"5\", \")\"]) == 3.0\n", "\nassert evaluate_expression([\"10\", \"+\", \"2\", \"*\", \"6\"]) == 22.0\n", "\nassert evaluate_expression([\"100\", \"/\", \"5\", \"*\", \"2\"]) == 40.0\n", "\nassert evaluate_expression([\"5\", ... |
c71eb712d24d7f2378f92aa1beff5abc | [
{
"content": "On te donne un fichier CSV nommé `data.csv` contenant les colonnes suivantes : `name`, `age` et `city`. Ta tâche est d'écrire un programme Python qui lit ce fichier, traite les données en filtrant les lignes où l'âge est inférieur à 18, et convertit les noms de ville en majuscules. Les données tra... | ["\nassert process_and_filter_data('test_input_1.csv', 'test_output_1.csv') is None\n", "\nassert process_and_filter_data('test_input_2.csv', 'test_output_2.csv') is None\n", "\nassert process_and_filter_data('test_input_3.csv', 'test_output_3.csv') is None\n", "\nassert process_and_filter_data('test_input_4.csv', 'tes... |
0fda022b14cbc1caf70f8000a6f6add5 | [
{
"content": "On te donne deux lignes dans un plan 2D. La première ligne est définie par deux points \\((x_0, y_0)\\) et \\((x_1, y_1)\\), et la seconde ligne est définie par un seul point \\((x_2, y_2)\\) et une pente \\(m\\) (où \\(m\\) peut être n'importe quel nombre réel). Ta tâche est d'écrire une fonction... | ["\nassert find_intersection(0, 0, 1, 1, 0.5, 0.5, 1) == -1\n", "\nassert find_intersection(0, 0, 1, 1, 0, 2, 1) == 0\n", "\nassert find_intersection(0, 0, 1, 1, 0, 0, -1) == 0.5\n", "\nassert find_intersection(0, 0, 0, 1, 1, 0, 0) == 0\n", "\nassert find_intersection(1, 1, 2, 2, 3, 3, 1) == -1\n", "\nassert find_inter... |
c9e8c6cf574850963893ef0e77fafa42 | [
{
"content": "On te demande d'implémenter une fonction `harmonic_mean(n)` qui calcule la moyenne harmonique des `n` premiers nombres naturels impairs. La moyenne harmonique `H` de `n` nombres `x1, x2, ..., xn` est définie comme `n / (1/x1 + 1/x2 + ... + 1/xn)`. Ta fonction doit renvoyer le résultat avec une mar... | ["\nassert abs(harmonic_mean(1) - 1.0) < 0.001\n", "\nassert abs(harmonic_mean(2) - 1.333) < 0.001\n", "\nassert abs(harmonic_mean(3) - 1.636) < 0.001\n", "\nassert abs(harmonic_mean(4) - 1.889) < 0.001\n", "\nassert abs(harmonic_mean(5) - 2.083) < 0.001\n", "\nassert abs(harmonic_mean(6) - 2.256) < 0.001\n", "\nassert... |
997f2a4a4a9deeddec477cb3026c56ba | [
{
"content": "On te donne un flux d'entiers `S` et un entier `n`. Ta tâche est de calculer la somme alternée des `n` premiers entiers du flux. La somme alternée est définie comme l'addition du premier nombre, la soustraction du second, l'addition du troisième, et ainsi de suite. Ta solution doit utiliser un esp... | ["\nassert alternating_sum(iter([1, 2, 3, 4, 5]), 5) == 3\n", "\nassert alternating_sum(iter([10, 20, 30, 40, 50]), 3) == 20\n", "\nassert alternating_sum(iter([1, 1, 1, 1, 1]), 5) == 1\n", "\nassert alternating_sum(iter([0, 0, 0, 0, 0]), 5) == 0\n", "\nassert alternating_sum(iter([-1, -2, -3, -4, -5]), 5) == -3\n", "\... |
bfed16020cb46d704bc2feacc3b9e0fd | [
{
"content": "On te demande d'implémenter une fonction `validate_zip_codes` qui traite une liste de chaînes de caractères représentant des codes postaux américains potentiels. Ta fonction doit renvoyer une liste de valeurs booléennes, chacune indiquant si le code postal correspondant dans la liste d'entrée est ... | ["\nassert validate_zip_code([\"12345\"]) == [True]\n", "\nassert validate_zip_code([\"02345\"]) == [False]\n", "\nassert validate_zip_code([\"1234\"]) == [False]\n", "\nassert validate_zip_code([\"123456\"]) == [False]\n", "\nassert validate_zip_code([\"123A5\"]) == [False]\n", "\nassert validate_zip_code([\"54321\"])... |
210caa17c14badec0370e572b1f794e4 | [
{
"content": "On te donne un chemin de fichier vers un fichier texte contenant une liste de phrases, une phrase par ligne. Ta tâche est d'implémenter une fonction `loadAndPreprocessData` qui lit le fichier, supprime les espaces blancs en début et en fin de chaque phrase, convertit tous les caractères en minuscu... | ["\nassert loadAndPreprocessData(\"test1.txt\") == [\"this is a test\", \"another line\", \"yet another sentence\"]\n", "\nassert loadAndPreprocessData(\"test2.txt\") == [\"hello world\", \"python programming\", \"is fun\"]\n", "\nassert loadAndPreprocessData(\"test3.txt\") == [\"no punctuation here\", \"just plain tex... |
01a33448485b3c27598c8c359ef952d8 | [
{
"content": "On te donne trois entiers. Ta tâche est d'écrire une fonction `min_of_three(num1, num2, num3)` qui renvoie le plus petit entier parmi les trois. Si plusieurs entiers sont les plus petits, renvoie celui qui apparaît en premier dans la séquence d'entrée.\n\n**Entrée :**\n- Trois entiers `num1`, `num... | ["\nassert min_of_three(1, 2, 3) == 1\n", "\nassert min_of_three(3, 2, 1) == 1\n", "\nassert min_of_three(2, 1, 3) == 1\n", "\nassert min_of_three(5, 5, 5) == 5\n", "\nassert min_of_three(-1, -2, -3) == -3\n", "\nassert min_of_three(0, 0, 0) == 0\n", "\nassert min_of_three(10, 10, 5) == 5\n", "\nassert min_of_three(7, ... |
d070140da467746ca5ab702d47e1c0f0 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver trois entiers dans `nums` tels que leur somme soit aussi proche que possible de `target`. Retourne la somme de ces trois entiers. Il est garanti que le tableau d'entrée `nums` contient au moins trois entiers et ... | ["\nassert three_sum_closest([-1, 2, 1, -4], 1) == 2\n", "\nassert three_sum_closest([1, 1, 1, 0], -100) == 2\n", "\nassert three_sum_closest([0, 0, 0], 1) == 0\n", "\nassert three_sum_closest([1, 2, 3, 4, 5], 10) == 12\n", "\nassert three_sum_closest([-1, 0, 1, 2, -1, -4], 0) == 0\n", "\nassert three_sum_closest([1, 2... |
dc31af5a2763f352561d33bc77d02f60 | [
{
"content": "On te demande d'implémenter un classificateur Naive Bayes simple pour déterminer si un e-mail est un spam ou non, en fonction de son contenu. Le classificateur doit utiliser la fréquence des mots comme caractéristique. On te fournit deux listes : `train_emails` et `test_emails`, chacune contenant ... | ["\nassert evaluate_accuracy([\"win a free vacation to hawaii\"], [1], prior, likelihood) == 1.0\n", "\nassert evaluate_accuracy([\"reminder to update your account\"], [0], prior, likelihood) == 1.0\n", "\nassert evaluate_accuracy([\"buy one get one free\"], [1], prior, likelihood) == 1.0\n", "\nassert evaluate_accurac... |
fb739c1a59e25f0535842ca3ab7c7222 | [
{
"content": "On te donne un chemin de répertoire et une liste de motifs de fichiers. Ta tâche est de mettre en œuvre une fonction `find_files` qui recherche récursivement dans le répertoire et tous ses sous-répertoires pour trouver les fichiers qui correspondent à l'un des motifs spécifiés. La fonction doit re... | ["\nassert find_files('*.txt', root='test_dir') == ['test_dir/subdir/file1.txt', 'test_dir/file2.txt']\n", "\nassert find_files(['*.py', '*.txt'], root='test_dir') == ['test_dir/subdir/file1.txt', 'test_dir/file2.txt', 'test_dir/script.py']\n", "\nassert find_files('*.md', root='test_dir') == []\n", "\nassert find_file... |
b2c09d8bd746eb5e4f8d98fef750d6c9 | [
{
"content": "On te donne une chaîne de caractères représentant un ensemble d'attributs dans le format suivant : `<nom_attribut attribut1=\"valeur1\" attribut2=\"valeur2\" ... attributN=\"valeurN\">`. Ta tâche est d'écrire une fonction `parse_attributes` qui prend cette chaîne de caractères en entrée et renvoie... | ["\nassert parse_attributes('<tag attr1=\"value1\" attr2=\"value2\">') == ('tag', {'attr1': 'value1', 'attr2': 'value2'})\n", "\nassert parse_attributes('<example attr=\"value with spaces\">') == ('example', {'attr': 'value with spaces'})\n", "\nassert parse_attributes('<test attr1=\"value1\" attr2=\"value2\" attr3=\"v... |
f54ed5bafcf143e3c6d5bdc5d7ab0ad2 | [
{
"content": "On te donne une liste d'intervalles de temps, où chaque intervalle est représenté par un tuple `(heure_de_début, heure_de_fin)`. Les `heure_de_début` et `heure_de_fin` sont des entiers représentant le nombre de minutes après minuit. Par exemple, `(60, 120)` représente l'intervalle de temps entre 1... | ["\nassert merge_intervals([(10, 30), (20, 40), (50, 60)]) == [(10, 40), (50, 60)]\n", "\nassert merge_intervals([(1380, 20), (120, 180), (90, 120)]) == [(90, 200), (1380, 20)]\n", "\nassert merge_intervals([(0, 60), (50, 120)]) == [(0, 120)]\n", "\nassert merge_intervals([(1400, 1440), (0, 40)]) == [(0, 40), (1400, 14... |
9552c7cb3f581fa937e6a4bd20149266 | [
{
"content": "On te donne deux points dans un plan 2D, `P1(x1, y1)` et `P2(x2, y2)`, qui définissent un segment de ligne. Ta tâche est de déterminer si un troisième point `P3(x, y)` se trouve sur ce segment de ligne, en tenant compte du fait que le segment peut être tourné de n'importe quel angle autour de son ... | ["\nassert find_intersection(0, 0, 5, 5, 2.5, 2.5) == True\n", "\nassert find_intersection(0, 0, 5, 5, 10, 10) == False\n", "\nassert find_intersection(1, 1, 4, 4, 2, 2) == True\n", "\nassert find_intersection(1, 1, 4, 4, 5, 5) == False\n", "\nassert find_intersection(0, 0, 0, 5, 0, 2.5) == True\n", "\nassert find_inte... |
8dc1d31110aa59c803b574f36eeb1226 | [
{
"content": "Étant donné deux listes d'entiers, `list1` et `list2`, ta tâche est de déterminer une nouvelle liste qui inclut tous les éléments présents dans `list2` mais pas dans `list1`. La liste résultante doit être triée par ordre décroissant et ne doit pas contenir d'éléments dupliqués.\n\n**Entrée :**\n- ... | ["\nassert find_unique_sorted_desc([1, 2, 3], [3, 4, 5]) == [5, 4]\n", "\nassert find_unique_sorted_desc([10, 20, 30], [30, 40, 50, 60]) == [60, 50, 40]\n", "\nassert find_unique_sorted_desc([], [1, 2, 3]) == [3, 2, 1]\n", "\nassert find_unique_sorted_desc([1, 2, 3], []) == []\n", "\nassert find_unique_sorted_desc([1, ... |
311ef75966b9ad07e2c4346ffdb126b3 | [
{
"content": "On te donne pour tâche d'écrire une fonction `generate_docker_command` qui construit une commande Docker pour exécuter une série de scripts séquentiellement dans un conteneur Docker. La fonction doit prendre deux paramètres : `workdir`, une chaîne de caractères représentant le répertoire de travai... | ["\nassert generate_docker_command(\"/app\", [\"/path/to/script1.sh\"]) == \"docker run --rm -v /path/to/script1.sh:/app/script_0.sh -w /app ubuntu bash -c ./script_0.sh\"\n", "\nassert generate_docker_command(\"/app\", [\"/path/to/script1.sh\", \"/path/to/script2.sh\"]) == \"docker run --rm -v /path/to/script1.sh:/app... |
1b1e2fb186be352fe90475d01432ebc7 | [
{
"content": "On te donne un tenseur 3D `t` de forme `(batch_size, num_features, num_samples)`. Ta tâche est de mettre en œuvre une fonction `find_max_feature_value(t)` qui calcule la valeur maximale de chaque caractéristique sur tous les points de données et les échantillons, mais uniquement pour les indices o... | ["\nassert torch.equal(find_max_feature_value(torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])), torch.tensor([7, 8]))\n", "\nassert torch.equal(find_max_feature_value(torch.tensor([[[1, 1], [1, 1]], [[1, 1], [1, 1]]])), torch.tensor([]))\n", "\nassert torch.equal(find_max_feature_value(torch.tensor([[[1, 2, 3], [4, ... |
953a3cd3aeb65c4e7176fd6e825b5af3 | [
{
"content": "On te donne un nombre représenté sous forme de chaîne de caractères dans une certaine base. Ta tâche est d'écrire une fonction `convert_base` qui convertit ce nombre dans une autre base spécifiée. La fonction doit gérer les bases allant de 2 à 36. Le nombre en entrée et les bases sont fournis en t... | ["\nassert convert_base(\"1010\", 2, 10) == \"10\"\n", "\nassert convert_base(\"10\", 10, 2) == \"1010\"\n", "\nassert convert_base(\"1A\", 16, 10) == \"26\"\n", "\nassert convert_base(\"26\", 10, 16) == \"1A\"\n", "\nassert convert_base(\"0\", 10, 2) == \"0\"\n", "\nassert convert_base(\"FF\", 16, 10) == \"255\"\n", "... |
4377d65b1d346975557a8b3fb809fadd | [
{
"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. Les espaces en début et en fin de chaîne doivent également être ignorés. Retourne `True` si la chaîne est un palindrome, sin... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\n", "\nassert is_palindrome(\" \") == True\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(... |
24b7c1b2312c8d60b3aeb09a7a7de0c0 | [
{
"content": "On te demande de développer un script Python pour traiter un lot de fichiers CSV situés dans un répertoire spécifié. Chaque fichier CSV contient une seule ligne de données avec 50 colonnes, et tous les fichiers partagent la même ligne d'en-tête. Ton script doit lire tous les fichiers CSV, les fusi... | ["\nassert os.path.exists('combined_output.csv') == False # Before running the function, the output file should not exist\n", "\ncombine_csv_files('test_data', 'combined_output.csv'); assert os.path.exists('combined_output.csv') == True # After running the function, the output file should exist\n", "\ncombine_csv_fil... |
ff9642f28ef8670af6830fd21087aa30 | [
{
"content": "On te donne un fichier nommé `example.txt`. Ta tâche est d'écrire un script Python qui lit ce fichier, compte le nombre total de mots, et affiche ce nombre. Suppose que les mots sont séparés par des espaces. Si le fichier n'existe pas, ton programme doit afficher un message approprié.\n\n**Exemple... | ["\nassert count_words_in_file(\"example.txt\") == 10 # Assuming example.txt contains exactly 10 words\n", "\nassert count_words_in_file(\"nonexistentfile.txt\") is None # File does not exist\n", "\nassert count_words_in_file(\"emptyfile.txt\") == 0 # File is empty\n", "\nassert count_words_in_file(\"singleword.txt\... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.