id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
ecb9a99890447a6ee39e6563d698b0f4 | [
{
"content": "On te donne une liste de points dans un espace à n dimensions, où chaque point est représenté comme un tuple d'entiers. Ta tâche est de trouver l'hyperrectangle axis-aligned le plus petit qui englobe tous les points donnés. L'hyperrectangle de délimitation est défini par 2n paramètres : les coordo... | ["\nassert find_bounding_rectangle([(1, 2), (3, 4), (5, 1), (2, 3)]) == [1, 1, 4, 3]\n", "\nassert find_bounding_rectangle([(0, 0), (1, 1), (2, 2)]) == [0, 0, 2, 2]\n", "\nassert find_bounding_rectangle([(5, 5), (5, 5), (5, 5)]) == [5, 5, 0, 0]\n", "\nassert find_bounding_rectangle([(1, 2, 3), (4, 5, 6), (0, 1, 1)]) ==... |
f30bc9a546f3ded5d5b3a55dac90f9b1 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `sum_of_squares` qui calcule la somme des carrés des nombres pairs dans la liste.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 10^3), où chaque entier `x` satisfait -10^3 ≤ x ≤ 10^3.\n\n**Sortie :**\n- Un enti... | ["\nassert sum_of_squares([1, 2, 3, 4, 5]) == 20\n", "\nassert sum_of_squares([2, 4, 6, 8]) == 120\n", "\nassert sum_of_squares([1, 3, 5, 7]) == 0\n", "\nassert sum_of_squares([-2, -4, -6, -8]) == 120\n", "\nassert sum_of_squares([0, 1, 2, 3, 4, 5]) == 20\n", "\nassert sum_of_squares([]) == 0\n", "\nassert sum_of_squar... |
986571720803e11e5a14184912112c3f | [
{
"content": "On te donne deux listes d'entiers, `arr1` et `arr2`. Ta tâche est de mettre en œuvre une fonction `find_common_elements(arr1, arr2)` qui renvoie une liste d'entiers représentant les éléments communs aux deux listes. La fonction doit utiliser des opérations sur les ensembles pour identifier ces élé... | ["\nassert find_common_elements([1, 2, 3], [3, 4, 5]) == [3]\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\nassert find_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert ... |
71ed7d7f3316cb588cd81e0c43c5767c | [
{
"content": "On te donne deux fichiers binaires. Ta tâche est d'écrire une fonction `compare_files` qui prend deux chemins de fichiers en entrée et renvoie `True` si les fichiers sont identiques en contenu et en checksum (en utilisant SHA-256), et `False` sinon. La fonction doit lire les fichiers par blocs de ... | ["\nassert compare_files(\"file1.bin\", \"file1.bin\") == True\n", "\nassert compare_files(\"file1.bin\", \"file2.bin\") == False\n", "\nassert compare_files(\"empty_file.bin\", \"empty_file.bin\") == True\n", "\nassert compare_files(\"file1.bin\", \"different_size_file.bin\") == False\n", "\nassert compare_files(\"fil... |
49bbc12d5e4a9e69bb7a20bdfecee058 | [
{
"content": "On te donne un DataFrame pandas `df` avec diverses colonnes de différents types de données. Ta tâche est de mettre en œuvre une fonction `find_non_numeric_columns(df)` qui renvoie une liste des noms de colonnes dont le type de données n'est pas numérique (c'est-à-dire, ni `int` ni `float`), en exc... | ["\nassert find_non_numeric_columns(pd.DataFrame({'A': [1, 2, 3], 'B': ['x', 'y', 'z'], 'C': [4.0, 4.0, 4.0]})) == ['B']\n", "\nassert find_non_numeric_columns(pd.DataFrame({'X': [1, 2, 3], 'Y': [1.1, 2.2, 3.3], 'Z': ['a', 'a', 'a']})) == []\n", "\nassert find_non_numeric_columns(pd.DataFrame({'P': ['foo', 'bar', 'baz'... |
73d04566e2e5a369aae696af99aff7e9 | [
{
"content": "On te donne deux listes : `distances` et `efficiencies`. La liste `distances` contient les distances (en kilomètres) parcourues par un groupe de véhicules, et la liste `efficiencies` contient le rendement énergétique (en kilomètres par litre) pour chaque véhicule correspondant. Ta tâche est d'écri... | ["\nassert calculate_total_fuel([100, 250, 300, 150], [10, 15, 12, 10]) == 65.83333333333333\n", "\nassert calculate_total_fuel([100, 100, 100], [10, 10, 10]) == 30.0\n", "\nassert calculate_total_fuel([50, 50, 50], [5, 10, 20]) == 12.5\n", "\nassert calculate_total_fuel([0, 0, 0], [10, 15, 20]) == 0.0\n", "\nassert ca... |
18d7af59fc14537bd37a53b2140e7900 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur `__init__` doit accepter six paramètres : `title`, `author`, `isbn`, `publisher`, `publication_year` et `price`. Ces paramètres doivent être utili... | ["\nassert str(Book(\"1984\", \"George Orwell\", \"1234567890\", \"Secker & Warburg\", 1949, 10.99)) == \"Title: 1984, Author: George Orwell, ISBN: 1234567890, Publisher: Secker & Warburg, Publication Year: 1949, Price: 10.99\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"0446310786\", \"J.B. Lippinc... |
791a5474522d432403f0b2209f6296ca | [
{
"content": "On te donne un dictionnaire représentant les notes d'un étudiant dans différentes matières. Chaque matière est associée à une note littérale (A, B, C, D, F). Sur une échelle de 4.0, ces notes correspondent à des points de note (4, 3, 2, 1, 0) respectivement. Ta tâche est d'écrire une fonction `cal... | ["\nassert calculate_gpa({\"Math\": \"A\", \"Science\": \"B\", \"History\": \"C\", \"English\": \"A\"}) == 3.5\n", "\nassert calculate_gpa({\"Math\": \"A\", \"Science\": \"A\", \"History\": \"A\", \"English\": \"A\"}) == 4.0\n", "\nassert calculate_gpa({\"Math\": \"F\", \"Science\": \"F\", \"History\": \"F\", \"English... |
75be73875b5c1de2fac26ae2b53de54f | [
{
"content": "On te demande d'implémenter une fonction `divide_numbers` qui prend deux arguments, `num1` et `num2`, et renvoie le résultat de la division de `num1` par `num2`. Ta fonction doit gérer les erreurs potentielles avec élégance et renvoyer un message d'erreur informatif si une exception se produit. Pl... | ["\nassert divide_numbers(10, 2) == 5.0\n", "\nassert divide_numbers(10, 0) == \"Error: Cannot divide by zero.\"\n", "\nassert divide_numbers(10, -2) == -5.0\n", "\nassert divide_numbers(-10, 2) == -5.0\n", "\nassert divide_numbers(0, 10) == 0.0\n", "\nassert divide_numbers(10, 2.5) == 4.0\n", "\nassert divide_numbers(... |
89e81c449aae439b52cfbf6f29d387b7 | [
{
"content": "On te donne une liste plate d'entiers et deux entiers représentant le nombre de lignes et de colonnes. Ta tâche est de convertir la liste en une matrice 2D avec les dimensions spécifiées. Si la liste ne contient pas suffisamment d'éléments pour remplir la matrice, complète les positions restantes ... | ["\nassert convert_list_to_matrix([1, 2, 3, 4, 5], 2, 3) == [[1, 2, 3], [4, 5, None]]\n", "\nassert convert_list_to_matrix([1, 2, 3, 4, 5, 6], 3, 2) == [[1, 2], [3, 4], [5, 6]]\n", "\nassert convert_list_to_matrix([1, 2, 3], 1, 3) == [[1, 2, 3]]\n", "\nassert convert_list_to_matrix([1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3) ==... |
012efe59b6a66601ab18a2262f9d50f4 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères alphanumériques. Ta tâche est de trouver la longueur de la plus longue sous-chaîne qui contient au plus deux caractères distincts.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10^5), où |s| désigne la longueur de l... | ["\nassert length_of_longest_substring_with_two_distinct(\"aabacbebebe\") == 7\n", "\nassert length_of_longest_substring_with_two_distinct(\"abc\") == 2\n", "\nassert length_of_longest_substring_with_two_distinct(\"aabbcc\") == 2\n", "\nassert length_of_longest_substring_with_two_distinct(\"abac\") == 3\n", "\nassert l... |
0c3084bf00326fb722853e69e59e19df | [
{
"content": "On te donne une liste d'événements, où chaque événement est représenté comme un dictionnaire avec les clés suivantes : 'name', 'start' et 'end'. Les clés 'start' et 'end' contiennent un autre dictionnaire avec les clés 'dateTime' et 'timeZone'. La clé 'dateTime' contient une chaîne de caractères r... | ["\nassert update_event_times([{'name': 'Event1', 'start': {'dateTime': '2023-10-01T10:00:00', 'timeZone': 'UTC'}, 'end': {'dateTime': '2023-10-01T12:00:00', 'timeZone': 'UTC'}}], {'Event1': (30, 'before')}) == [{'name': 'Event1', 'start': {'dateTime': '2023-10-01T09:30:00', 'timeZone': 'UTC'}, 'end': {'dateTime': '202... |
742272ec0497388c5238c26a6a3086c8 | [
{
"content": "On te demande d'implémenter une fonction récursive `fibonacci(n)` qui calcule le nième nombre de Fibonacci. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et pour n > 1, F(n) = F(n-1) + F(n-2). Ta fonction doit renvoyer le nième nombre de Fibonacci pour un entier non négatif `n... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(6) == 8\n", "\nassert fibonacci(7) == 13\n", "\nassert fibonacci(8) == 21\n", "\nassert fibonacci(10) == 55... |
87fa43567b75fe9f6c968c207b1bbb43 | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est d'implémenter une fonction `find_equilibrium_index` qui identifie l'indice d'équilibre du tableau. Un indice d'équilibre est défini comme un indice où la somme des éléments à gauche de l'indice est égale à la somme des éléments à droite de l'indice. S... | ["\nassert find_equilibrium_index([1, 3, 5, 2, 2]) == 2\n", "\nassert find_equilibrium_index([-7, 1, 5, 2, -4, 3, 0]) == 3\n", "\nassert find_equilibrium_index([1, 2, 3, 4, 5]) == -1\n", "\nassert find_equilibrium_index([10, -10]) == 0\n", "\nassert find_equilibrium_index([0, 0, 0, 0, 0]) == 0\n", "\nassert find_equili... |
7532b55593db469d3ec014d41cbd6008 | [
{
"content": "On te donne deux listes d'ensembles, `predicted_labels` et `ground_truth_labels`, représentant les étiquettes prédites et réelles pour un problème de classification binaire. Chaque ensemble contient des attributs d'un e-mail, indiquant s'il s'agit d'un spam ou non. Ta tâche est de mettre en œuvre ... | ["\nassert evaluate_predictions([set(['spam']), set(['cash'])], [set(['spam']), set(['cash'])]) == (2, 0, 0, 0, 1.0, 1.0, 1.0)\n", "\nassert evaluate_predictions([set(['spam']), set(['cash'])], [set(['spam']), set([])]) == (1, 0, 0, 1, 1.0, 0.5, 0.6666666666666666)\n", "\nassert evaluate_predictions([set(['spam']), set... |
c98975a1d9ba5bd88104e056056e14e6 | [
{
"content": "On te donne une grille 2D avec `R` lignes et `C` colonnes, où chaque cellule contient soit `0` soit `1`. De plus, on te fournit un entier `D`. Ta tâche est de déterminer le nombre de sous-matrices rectangulaires 2D distinctes dans la grille qui contiennent exactement `D` uns.\n\n**Entrée :**\n- La... | ["\nassert count_submatrices_with_d_ones([[1, 0, 1], [0, 1, 1], [1, 1, 0]], 3) == 4\n", "\nassert count_submatrices_with_d_ones([[1, 1], [1, 1]], 2) == 5\n", "\nassert count_submatrices_with_d_ones([[0, 0], [0, 0]], 1) == 0\n", "\nassert count_submatrices_with_d_ones([[1, 1, 1], [1, 1, 1], [1, 1, 1]], 4) == 9\n", "\nas... |
b23b9ddd5c6b832d1380b859d611e7a9 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `count_chinese_chars` qui renvoie le nombre de caractères chinois dans la chaîne. Un caractère chinois est défini comme tout caractère Unicode dans la plage de '\\u4e00' à '\\u9fa5'. Ta fonction doit gérer corre... | ["\nassert count_chinese_chars(\"Hello, \u4e16\u754c!\") == 2\n", "\nassert count_chinese_chars(\"\u4f60\u597d\uff0c\u4e16\u754c\uff01\") == 4\n", "\nassert count_chinese_chars(\"12345\") == 0\n", "\nassert count_chinese_chars(\"\") == 0\n", "\nassert count_chinese_chars(\"abcde\") == 0\n", "\nassert count_chinese_char... |
791113cd16e62ba07eadd368612db8bc | [
{
"content": "On te donne un tableau d'entiers `songs` où chaque entier représente la durée d'une chanson en secondes. Ta tâche est de déterminer le nombre de triplets uniques de chansons qui peuvent être joués consécutivement sans aucun espace ou chevauchement, de sorte que la durée totale du triplet soit un m... | ["\nassert numTripletsDivisibleBy120([120, 120, 120]) == 1\n", "\nassert numTripletsDivisibleBy120([60, 60, 60, 60]) == 4\n", "\nassert numTripletsDivisibleBy120([30, 90, 60, 120]) == 2\n", "\nassert numTripletsDivisibleBy120([40, 40, 40, 40, 40, 40]) == 10\n", "\nassert numTripletsDivisibleBy120([10, 20, 30, 40, 50, 6... |
c9727f2787c3b760bddc70fffc992a8d | [
{
"content": "Tu développes une simulation de robot d'indexation web. Implémente une fonction `should_continue_crawl` qui détermine si le robot d'indexation doit continuer son opération en fonction des conditions données. La fonction prend trois paramètres :\n\n- `crawl_history` : Une liste de tuples, où chaque... | ["\nassert should_continue_crawl([(\"http://example.com\", \"2023-10-01 12:00:00\")], \"http://example.com\", 1) == False\n", "\nassert should_continue_crawl([(\"http://example.com\", \"2023-10-01 12:00:00\"), (\"http://example.com/page1\", \"2023-10-01 12:05:00\")], \"http://example.com/page2\", 2) == True\n", "\nasse... |
14ca5330758149ba4b7081cda9b13b53 | [
{
"content": "On te charge de modéliser la dynamique d'une population de lapins dans un écosystème fermé qui subit des perturbations périodiques affectant son taux de croissance. Le taux de croissance est influencé par un facteur saisonnier, \\(\\alpha(t)\\), qui varie de manière sinusoïdale avec le temps \\(t\... | ["\nassert rabbit_growth_rate(0, 500, 0.1, 0.01) == 25.0\n", "\nassert rabbit_growth_rate(3, 500, 0.1, 0.01) == 43.30127018922193\n", "\nassert rabbit_growth_rate(6, 500, 0.1, 0.01) == 0.0\n", "\nassert rabbit_growth_rate(9, 500, 0.1, 0.01) == -43.30127018922193\n", "\nassert rabbit_growth_rate(12, 500, 0.1, 0.01) == -... |
85c1d8dc02af0a1a1b15da21d9fbc50c | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `prime_factor_exponent(n)` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les facteurs premiers de `n` qui apparaissent plus d'une fois dans la factorisation première de `n`, et les valeurs doivent être leurs... | ["\nassert prime_factor_exponent(1) == {}\n", "\nassert prime_factor_exponent(2) == {}\n", "\nassert prime_factor_exponent(4) == {2: 2}\n", "\nassert prime_factor_exponent(6) == {}\n", "\nassert prime_factor_exponent(8) == {2: 3}\n", "\nassert prime_factor_exponent(12) == {2: 2}\n", "\nassert prime_factor_exponent(18) ... |
f8385ada8473febf63c5c7346e883efc | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si `s` est un objet JSON valide. Un objet JSON valide doit être un dictionnaire en Python, ce qui correspond à un objet dans la syntaxe JSON. La fonction doit renvoyer `True` si `s` est un objet JSON valide, et `False` sinon. La ... | ["\nassert is_valid_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}') == True\n", "\nassert is_valid_json('[\"apple\", \"banana\", \"cherry\"]') == False\n", "\nassert is_valid_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"') == False\n", "\nassert is_valid_json('{\"name\": \"John\", \"a... |
fd62e9d33fa61d8afb2b7d45407b004d | [
{
"content": "Tu es un botaniste étudiant la croissance d'une espèce rare de buisson à baies. Le buisson à baies croît en cycles, chaque cycle durant 15 jours. À la fin de chaque cycle, le nombre de baies sur le buisson augmente de manière exponentielle. Plus précisément, le nombre de baies à la fin du `cycle`-... | ["\nassert count_berries(0) == (0, [])\n", "\nassert count_berries(15) == (random.randint(750, 1500), [random.randint(750, 1500)])\n", "\nassert count_berries(30) == (random.randint(750 + 33750, 1500 + 67500), [random.randint(750, 1500), random.randint(33750, 67500)])\n", "\nassert count_berries(45) == (random.randint(... |
d7dcef814efdc9b0901a8e60d94042f7 | [
{
"content": "On te donne un objet JSON imbriqué et un chemin représenté sous forme de chaîne de caractères. Ta tâche est de mettre en œuvre une fonction `get_nested_value(json_obj, path)` qui récupère la valeur de l'objet JSON en utilisant le chemin spécifié. Le chemin est une chaîne de caractères où les clés ... | ["\nassert get_nested_value({\"a\": {\"b\": \"value\"}}, \"a/b\") == \"value\"\n", "\nassert get_nested_value({\"a\": {\"b\": {\"c\": \"value\"}}}, \"a/b/c\") == \"value\"\n", "\nassert get_nested_value({\"a\": {\"b\": {\"c\": {\"d\": \"value\"}}}}, \"a/b/c/d\") == \"value\"\n", "\nassert get_nested_value({\"a\": {\"b\... |
7f6d8a921c53f950a3579e5a8fcea474 | [
{
"content": "On te donne une liste de chaînes de caractères, chacune pouvant contenir des adresses e-mail et des numéros de téléphone mélangés à du texte normal. Ta tâche est d'écrire une fonction `filter_text` qui traite chaque chaîne pour supprimer toutes les adresses e-mail et les numéros de téléphone, en n... | ["\nassert filter_text([\"Contact us at info@example.com or call +1 (123) 456-7890.\"]) == [\"Contact us at or call .\"]\n", "\nassert filter_text([\"Email john.doe123@provider.net or reach out via +44 123 456 7890.\"]) == [\"Email or reach out via .\"]\n", "\nassert filter_text([\"No contact information here just text... |
9ce918c4c7dcea2195c71ce81ff57ea8 | [
{
"content": "On te donne un fichier CSV nommé `books.csv` situé dans le même répertoire que ton script. Le fichier CSV contient des informations sur des livres avec les colonnes suivantes : `title`, `author` et `year`. Ta tâche est d'écrire une fonction Python qui lit ce fichier CSV et renvoie un dictionnaire ... | ["\nassert read_books_csv('empty.csv') == {}\n", "\nassert read_books_csv('single_entry.csv') == {'The Great Gatsby': ('F. Scott Fitzgerald', '1925')}\n", "\nassert read_books_csv('multiple_entries.csv') == {'1984': ('George Orwell', '1949'), 'To Kill a Mockingbird': ('Harper Lee', '1960')}\n", "\nassert read_books_csv... |
99b69cf45ea7fc41cbe3735013dfa5a6 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif `n`. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. Si `n` est négatif, ta fonction doit lever une exception `ValueError` avec ... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(5) == 120\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(3) == 6\n", "\nassert factorial(15) == 1307674368000\n", "\nassert factorial(20) == 2432902008176640000\n", "\ntry:\n factor... |
bd8bae87905587158179c29e045ae5c6 | [
{
"content": "On te demande d'implémenter une fabrique `decorator_chain` en Python qui accepte un nombre variable de décorateurs, les applique dans l'ordre inverse et assure la sécurité des threads pour le décorateur résultant. Ton implémentation doit être capable de gérer toute fonction qui prend des arguments... | ["\nassert multiply(3, 4) == 144\n", "\nassert multiply(0, 5) == 0\n", "\nassert multiply(-2, 3) == 36\n", "\nassert multiply(1, 1) == 1\n", "\nassert multiply(-1, -1) == 1\n", "\nassert multiply(10, 10) == 10000\n", "\nassert multiply(2, 2) == 16\n", "\nassert multiply(5, 0) == 0\n", "\nassert multiply(7, 7) == 2401\n... |
bc116619a99ad74b8760bcd395e7993f | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `largest_prime_factor(n)` qui renvoie le plus grand facteur premier de `n`. La fonction doit avoir une complexité temporelle meilleure que O(n).\n\n**Entrée :**\n- Un entier `n` (2 ≤ n ≤ 10^12)\n\n**Sortie :**\n- Un entier représentant ... | ["\nassert largest_prime_factor(13195) == 29\n", "\nassert largest_prime_factor(2048) == 2\n", "\nassert largest_prime_factor(600851475143) == 6857\n", "\nassert largest_prime_factor(97) == 97\n", "\nassert largest_prime_factor(1) == -1\n", "\nassert largest_prime_factor(2) == 2\n", "\nassert largest_prime_factor(3) ==... |
e7b2c9950efdd35b554ece4bc2039ffd | [
{
"content": "On te donne une structure imbriquée composée d'entiers, de chaînes de caractères, de listes, de tuples, de dictionnaires et d'ensembles. Ta tâche est d'écrire une fonction `flatten_nested_lists(nested_structure)` qui aplatit récursivement cette structure en une seule liste. L'ordre des éléments do... | ["\nassert flatten_nested_lists([1, [2, [3, 4]], \"hello\"]) == [1, 2, 3, 4, \"hello\"]\n", "\nassert flatten_nested_lists((1, (2, (3, 4)), \"hello\")) == [1, 2, 3, 4, \"hello\"]\n", "\nassert flatten_nested_lists([1, {2, 3}, [4, 5]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten_nested_lists({'a': 1, 'b': {'c': 2, 'd': [3,... |
e29820c28bdbc9f16c225b7093d56f90 | [
{
"content": "On te demande de modifier une classe Python `Car` qui possède un attribut `speed` et une méthode `accelerate`. La méthode `accelerate` doit être mise à jour pour accepter un paramètre supplémentaire `delta`, qui spécifie l'incrément de la vitesse de la voiture. Ta tâche est d'implémenter la classe... | ["\nassert Car(0).accelerate(5) is None\n", "\nassert Car(10).accelerate(15).speed == 25\n", "\nassert Car(5).accelerate(0).speed == 5\n", "\nassert Car(20).accelerate(-5).speed == 15\n", "\nassert Car(100).accelerate(100).speed == 200\n", "\nassert Car(0).accelerate(-10).speed == -10\n", "\nassert Car(50).accelerate(5... |
ed8427ebf6086ddd3f7b2b64b642a20e | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tableau numpy 2D `grayscale_image` de dimensions `M x N`, où chaque valeur de pixel est un entier dans la plage `[0, 255]`. Ta tâche est de mettre en œuvre une fonction `apply_custom_threshold` qui applique un seuil personnalisé à l'ima... | ["\nassert np.array_equal(apply_custom_threshold(np.array([[100, 150], [200, 50]]), 100), np.array([[0, 150], [200, 0]]))\n", "\nassert np.array_equal(apply_custom_threshold(np.array([[255, 0], [128, 64]]), 128), np.array([[255, 0], [128, 0]]))\n", "\nassert np.array_equal(apply_custom_threshold(np.array([[50, 50], [50... |
5f3ea81269e00621b76138299bfaed77 | [
{
"content": "On te donne une chaîne de caractères `text` constituée de mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `count_unique_words` qui traite cette chaîne et renvoie un dictionnaire. Le dictionnaire doit associer chaque mot unique (sans tenir compte de la casse ni de la ponc... | ["\nassert count_unique_words(\"Hello, world! Hello, Python world.\") == {'hello': 2, 'world': 2, 'python': 1}\n", "\nassert count_unique_words(\"This is a test. This test is only a test.\") == {'this': 2, 'is': 2, 'a': 2, 'test': 3, 'only': 1}\n", "\nassert count_unique_words(\"One fish, two fish, red fish, blue fish.... |
6537e90b48b6f78338765ae94d4b9dbf | [
{
"content": "On te donne une structure de liste imbriquée contenant divers types d'objets. Ta tâche est de mettre en œuvre une fonction `filter_objects` qui traite cette liste imbriquée et renvoie une liste aplatie contenant uniquement les objets qui sont des instances des types intégrés : `int`, `str`, `float... | ["\nassert filter_objects([1, 2, 3, [4, 5, [6, 7]], \"hello\", [8, \"world\"]]) == [1, 2, 3, 4, 5, 6, 7, \"hello\", 8, \"world\"]\n", "\nassert filter_objects([None, True, False, 3.14, \"string\", [1, 2, [3, 4]], [5, \"nested\", [6, \"deep\"]]]) == [None, True, False, 3.14, \"string\", 1, 2, 3, 4, 5, \"nested\", 6, \"d... |
b631411f2ec10cdf4a9d28cff056fbff | [
{
"content": "On te donne un arbre représenté comme un dictionnaire où chaque clé est un nœud et sa valeur correspondante est une liste de ses nœuds enfants. Ta tâche est de mettre en œuvre une fonction qui effectue un parcours en profondeur (DFS) à partir d'un nœud spécifié et renvoie une liste des nœuds visit... | ["\nassert dfs({1: [2, 3], 2: [4, 5], 3: []}, 1) == [1, 2, 5, 4, 3]\n", "\nassert dfs({1: [2, 3], 2: [4, 5], 3: []}, 2) == [2, 5, 4]\n", "\nassert dfs({1: [2, 3], 2: [4, 5], 3: []}, 3) == [3]\n", "\nassert dfs({1: [2, 3], 2: [4, 5], 3: [6, 7]}, 1) == [1, 2, 5, 4, 3, 6, 7]\n", "\nassert dfs({1: [2, 3], 2: [4, 5], 3: [6,... |
84b1dc8bbe1fa5a1d2c162c1287d8f57 | [
{
"content": "Tu développes un système de menu textuel pour un restaurant. Le système doit afficher une liste de plats avec leurs numéros correspondants. Les utilisateurs peuvent sélectionner un plat en entrant son numéro et fournir des détails supplémentaires tels que la quantité et les demandes spéciales. Le ... | ["\nassert restaurant_menu_system({\"Burger\": 5.99, \"Pizza\": 8.99}) == [\"Burger\", \"1\", \"extra cheese\"]\n", "\nassert restaurant_menu_system({\"Salad\": 7.49, \"Pasta\": 9.99}) == [\"Pasta\", \"2\", \"\"]\n", "\nassert restaurant_menu_system({\"Steak\": 15.99}) == [\"Steak\", \"1\", \"rare\"]\n", "\nassert rest... |
8ad599910121d983459d6c122f35f5bd | [
{
"content": "On te demande d'implémenter la fonction `factorial_sum`, qui calcule la somme des factorielles de tous les entiers de 1 à un entier positif donné `n`. Ton implémentation doit respecter les contraintes de ne pas utiliser de boucles itératives (telles que `for` ou `while`) ou de récursion. Utilise p... | ["\nassert factorial_sum(1) == 1\n", "\nassert factorial_sum(2) == 3\n", "\nassert factorial_sum(3) == 9\n", "\nassert factorial_sum(4) == 33\n", "\nassert factorial_sum(5) == 153\n", "\nassert factorial_sum(6) == 873\n", "\nassert factorial_sum(7) == 5913\n", "\nassert factorial_sum(8) == 46233\n", "\nassert factorial... |
8a03660d1f19efca59700342214294c3 | [
{
"content": "On te donne un ensemble de données de nuages de points 3D, où chaque point est représenté par ses coordonnées 3D (x, y, z) et son vecteur normal correspondant (nx, ny, nz). Ta tâche consiste à écrire une fonction qui fait pivoter un lot de nuages de points en utilisant une matrice de rotation donn... | ["\nassert np.array_equal(rotate_point_cloud(np.array([[[1, 0, 0, 0, 0, 1]]]), np.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]])), np.array([[[0, 1, 0, 0, -1, 0]]]))\n", "\nassert np.array_equal(rotate_point_cloud(np.array([[[0, 1, 0, 1, 0, 0]]]), np.array([[0, 0, 1], [-1, 0, 0], [0, 1, 0]])), np.array([[[0, 0, 1, -1, 0, 0]... |
229bc3f22f69f359a6bb39bd6d69540a | [
{
"content": "On te donne une liste de visages détectés dans une image sous forme de tuples `(fx, fy, fw, fh)`, où `fx` et `fy` désignent les coordonnées du coin supérieur gauche du visage, et `fw` et `fh` représentent la largeur et la hauteur du rectangle englobant du visage, respectivement. Ta tâche est de ca... | ["\nassert get_clothes_coordinates([(10, 20, 90, 110)]) == [(10.0, -155.0, 315.0, 385.0)]\n", "\nassert get_clothes_coordinates([(0, 0, 100, 100)]) == [(-125.0, -125.0, 350.0, 350.0)]\n", "\nassert get_clothes_coordinates([(50, 50, 50, 50)]) == [(12.5, 12.5, 175.0, 175.0)]\n", "\nassert get_clothes_coordinates([(100, 1... |
45e768537a176d42296d9a3c5bd383d7 | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Ta tâche est de déterminer si tu peux rendre les deux chaînes identiques en effectuant exactement une des opérations suivantes : insérer un seul caractère, supprimer un seul caractère, ou remplacer un seul caractère. Ta solution doit s'exéc... | ["\nassert is_one_edit_away(\"pale\", \"ple\") == True\n", "\nassert is_one_edit_away(\"pales\", \"pale\") == True\n", "\nassert is_one_edit_away(\"pale\", \"bale\") == True\n", "\nassert is_one_edit_away(\"pale\", \"bake\") == False\n", "\nassert is_one_edit_away(\"a\", \"b\") == True\n", "\nassert is_one_edit_away(\"... |
26948cc5d72e8034689b9b988edc99de | [
{
"content": "Tu développes un programme de simulation de feux de circulation pour une ville avec plusieurs carrefours. Chaque carrefour a un nombre spécifique de directions, et toutes les directions à un carrefour partagent le même cycle de feux de circulation. Pendant les heures de pointe, la durée pour chaqu... | ["\nassert isinstance(generate_traffic_timings({1: 3}, 30, 7, 18, 1.5), dict)\n", "\nassert all(isinstance(v, dict) for v in generate_traffic_timings({1: 3, 2: 2}, 30, 7, 18, 1.5).values())\n", "\nassert all(isinstance(v, int) for v in generate_traffic_timings({1: 3}, 30, 7, 18, 1.5)[1].values())\n", "\nassert all(v in... |
c1b71ed9e9c10f3cf12d71a39a32ac23 | [
{
"content": "On te donne une liste chaînée simple où chaque nœud contient une valeur entière. Ta tâche est de mettre en œuvre une fonction qui renvoie la valeur du `n`ième nœud à partir de la fin de la liste chaînée qui a un nombre premier comme valeur. S'il y a moins de `n` nœuds à valeur première à partir de... | ["\nassert nth_prime_from_end(ListNode(2, ListNode(3, ListNode(5, ListNode(7, ListNode(11))))), 1) == 11\n", "\nassert nth_prime_from_end(ListNode(2, ListNode(3, ListNode(5, ListNode(7, ListNode(11))))), 2) == 7\n", "\nassert nth_prime_from_end(ListNode(2, ListNode(3, ListNode(5, ListNode(7, ListNode(11))))), 5) == 2\n... |
03b11a36752ca269b4c6e91953df64c6 | [
{
"content": "On te donne une liste de titres de livres, chacun représenté comme une chaîne de caractères. Ta tâche est d'écrire une fonction `capitalize_titles` qui capitalise ces titres selon des règles spécifiques. Les règles de capitalisation sont les suivantes :\n- Le premier et le dernier mot du titre doi... | ["\nassert capitalize_titles([\"the great gatsby\"]) == [\"The Great Gatsby\"]\n", "\nassert capitalize_titles([\"to kill a mockingbird\"]) == [\"To Kill a Mockingbird\"]\n", "\nassert capitalize_titles([\"the catcher in the rye\"]) == [\"The Catcher in the Rye\"]\n", "\nassert capitalize_titles([\"a tale of two cities... |
c8953dc7af258c1458254b40fe995176 | [
{
"content": "On te donne un DataFrame pandas `df` avec diverses colonnes de données. Ta tâche est de mettre en œuvre une fonction `separate_features_labels(df, feature_columns)` qui partitionne le DataFrame en deux DataFrames distincts : `features` et `labels`. Le DataFrame `features` doit inclure toutes les c... | ["\nassert separate_features_labels(pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}), ['B']) == (pd.DataFrame({'A': [1, 2, 3], 'C': [7, 8, 9]}), pd.DataFrame({'B': [4, 5, 6]}))\n", "\nassert separate_features_labels(pd.DataFrame({'X': [10, 20, 30], 'Y': [40, 50, 60], 'Z': [70, 80, 90]}), ['X', 'Z']) == (p... |
7351ec53d75f327d762993d8c5e99154 | [
{
"content": "On te demande d'implémenter une fonction pour gérer un système d'inventaire d'entrepôt. Étant donné un dictionnaire `src` qui représente l'inventaire de l'entrepôt, où les clés sont les noms des articles et les valeurs sont les quantités de chaque article, et une liste `keys` représentant la liste... | ["\nassert pick_items({\"apple\": 10, \"banana\": 5}, [\"apple+2\", \"banana-3\"]) == {\"apple\": 12, \"banana\": 2}\n", "\nassert pick_items({\"apple\": 10, \"banana\": 5}, [\"apple-10\", \"banana-5\"]) == {}\n", "\nassert pick_items({\"apple\": 10, \"banana\": 5}, [\"apple+5\", \"banana+3\"]) == {\"apple\": 15, \"ban... |
cee4f7b7146938c3de71d94465a678c8 | [
{
"content": "Tu es un trader qui a acheté une certaine quantité de cryptomonnaie à un prix donné. Ton objectif est de déterminer la quantité de cryptomonnaie que tu dois vendre à un prix cible, qui est un pourcentage spécifié plus élevé que le prix d'achat, afin d'atteindre le seuil de rentabilité. La platefor... | ["\nassert calculate_break_even_amount(10000, 0.1, 0.05, [0.0025, 0.0025]) == 0.10256410256410256\n", "\nassert calculate_break_even_amount(5000, 0.2, 0.1, [0.001, 0.001]) == 0.22040816326530612\n", "\nassert calculate_break_even_amount(20000, 0.05, 0.03, [0.003, 0.003]) == 0.05153846153846154\n", "\nassert calculate_b... |
a03b9d991e343fb37583a6dc69e9a9f3 | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `find_prime_factors` qui renvoie une liste de tous les facteurs premiers de `n` dans l'ordre croissant. Chaque facteur premier doit apparaître dans la liste autant de fois qu'il divise `n`. Par exemple, si `n` est `12`, la fonction doit... | ["\nassert find_prime_factors(12) == [2, 2, 3]\n", "\nassert find_prime_factors(28) == [2, 2, 7]\n", "\nassert find_prime_factors(1) == []\n", "\nassert find_prime_factors(29) == [29]\n", "\nassert find_prime_factors(100) == [2, 2, 5, 5]\n", "\nassert find_prime_factors(45) == [3, 3, 5]\n", "\nassert find_prime_factors... |
daa4573a49a637832e3c6ed2f43ea076 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif. La factorielle d'un entier non négatif \\( n \\) est le produit de tous les entiers positifs inférieurs ou égaux à \\( n \\). La factorielle de 0 est définie comme étant 1. Ta fonction doit lev... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(3) == 6\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(15) == 1307674368000\n", "\nassert factorial(1) == 1\n", "\ntry: factorial(-1); assert False ex... |
1faa817c0fc0e507c13665b55ebf30b4 | [
{
"content": "On te demande d'implémenter une classe `Product` pour un système de gestion de magasin. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : La classe doit être initialisée avec trois paramètres : `name` (une chaîne de caractères), `price` (un flottant) et `st... | ["\nassert Product(\"Laptop\", 1000, 5).get_details() == {'name': 'Laptop', 'price': 1000, 'stock': 5}\n", "\nassert Product(\"Smartphone\", 500, 10).sell(2) == 1000\n", "\nassert Product(\"Tablet\", 300, 3).sell(5) == -1\n", "\nassert Product(\"Monitor\", 200, 8).add_stock(4) is None and Product(\"Monitor\", 200, 8).s... |
e8ab662c06c94e0a510fdea1e883f041 | [
{
"content": "On te charge d'implémenter un système de transmission de données sécurisé entre deux systèmes. Les données à transmettre sont un objet Python complexe, tel qu'un dictionnaire avec des listes et des dictionnaires imbriqués. Pour garantir la sécurité des données transmises, tu dois utiliser un proce... | ["\nassert decode_and_deserialize(serialize_and_encode({\"key\": \"value\"})) == {\"key\": \"value\"}\n", "\nassert decode_and_deserialize(serialize_and_encode([1, 2, 3, 4, 5])) == [1, 2, 3, 4, 5]\n", "\nassert decode_and_deserialize(serialize_and_encode((1, 2, 3))) == (1, 2, 3)\n", "\nassert decode_and_deserialize(ser... |
ba5fe4d1ba442379da966c3fe03a3b78 | [
{
"content": "On te demande d'implémenter une fonction optimisée pour convertir un entier non négatif en sa représentation binaire en utilisant des opérations au niveau du bit. Plus précisément, utilise l'opérateur ET au niveau du bit (`&`) et l'opérateur de décalage vers la droite (`>>`) pour extraire et trait... | ["\nassert decimal_to_binary_optimized(0) == \"0\"\n", "\nassert decimal_to_binary_optimized(1) == \"1\"\n", "\nassert decimal_to_binary_optimized(2) == \"10\"\n", "\nassert decimal_to_binary_optimized(5) == \"101\"\n", "\nassert decimal_to_binary_optimized(10) == \"1010\"\n", "\nassert decimal_to_binary_optimized(255)... |
9ce20f8105b094071ca932935c083bcc | [
{
"content": "On te donne un dictionnaire où chaque clé est une chaîne de caractères et chaque valeur est également une chaîne de caractères. Ton objectif est d'écrire une fonction `convert_to_uppercase` qui renvoie un nouveau dictionnaire avec les mêmes clés mais toutes les valeurs converties en majuscules.\n\... | ["\nassert convert_to_uppercase({\"name\": \"Alice\", \"position\": \"Engineer\"}) == {\"name\": \"ALICE\", \"position\": \"ENGINEER\"}\n", "\nassert convert_to_uppercase({\"city\": \"new york\", \"country\": \"usa\"}) == {\"city\": \"NEW YORK\", \"country\": \"USA\"}\n", "\nassert convert_to_uppercase({\"greeting\": \... |
1562b052bd03737914e5bcc921f808e3 | [
{
"content": "On te donne une liste de trames provenant d'un match sportif et un objet match. Chaque trame a un `frameid` unique et l'objet match contient des informations sur le match, telles que la fréquence d'images et les attributs de période. Les attributs de période incluent les `frameid` de début et de f... | ["\nassert updated_frames[0]['frameid'] == 5 and updated_frames[0]['period'] == 'first half' and updated_frames[0]['timestamp'] == '0:00.000'\n", "\nassert updated_frames[1]['frameid'] == 7 and updated_frames[1]['period'] == 'first half' and updated_frames[1]['timestamp'] == '0:06.667'\n", "\nassert updated_frames[2]['... |
b3d9fbeebeb96213d6d47b90f3bb23b8 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci en utilisant une approche itérative. La fonction doit être optimisée pour gérer efficacement les grandes valeurs de `n`. La suite de Fibonacci est définie comme suit :\n\n- F(0) = 0\n- F(1) = 1\n- F(n) = F(n-1) + F... | ["\nassert calculate_fibonacci(0) == 0\n", "\nassert calculate_fibonacci(1) == 1\n", "\nassert calculate_fibonacci(2) == 1\n", "\nassert calculate_fibonacci(3) == 2\n", "\nassert calculate_fibonacci(4) == 3\n", "\nassert calculate_fibonacci(5) == 5\n", "\nassert calculate_fibonacci(10) == 55\n", "\nassert calculate_fib... |
fe07830a7fbdee40400092acb10969ed | [
{
"content": "On te demande d'implémenter une fonction `convert_temperature(temp, scale)` qui effectue des conversions de température. Étant donné une température `temp` et son échelle `scale`, ta fonction doit convertir la température en Celsius et renvoyer le résultat. Le paramètre `scale` ne peut être que \"... | ["\nassert convert_temperature(32, \"Fahrenheit\") == 0.0\n", "\nassert convert_temperature(212, \"Fahrenheit\") == 100.0\n", "\nassert convert_temperature(98.6, \"Fahrenheit\") == 37.0\n", "\nassert convert_temperature(0, \"Kelvin\") == -273.15\n", "\nassert convert_temperature(273.15, \"Kelvin\") == 0.0\n", "\nassert... |
99515f4cc66ee6cfeabcd2c557075b3d | [
{
"content": "On te donne un graphe représenté comme un maillage, où les sommets sont connectés par des arêtes et des faces. Le graphe est représenté par un objet `mesh`, qui possède deux méthodes : `adjacentVertsByEdge(vert)` et `adjacentVertsByFace(vert)`. Ces méthodes renvoient une liste de sommets adjacents... | ["\nassert process_mesh(mesh, {1, 2, 3}, {4, 5}) == ({1: {'distance': 0, 'edges': [2, 3]}, 2: {'distance': 1, 'edges': [1]}, 3: {'distance': 1, 'edges': [1]}}, {1: [2, 3], 2: [1, 3], 3: [1, 2]}, {1, 2, 3})\n", "\nassert process_mesh(mesh, {10}, {20}) == ({10: {'distance': 0, 'edges': []}}, {10: []}, set())\n", "\nasser... |
28bc6214eaa8eaca63c959203571683c | [
{
"content": "On te donne une matrice 3x3 représentant une matrice de covariance d'une distribution normale multivariée. Ta tâche est d'écrire une fonction qui calcule le déterminant de cette matrice de covariance sans utiliser d'opérateurs arithmétiques (+, -, *, /). Tu peux utiliser des opérations au niveau d... | ["\nassert determinant_3x3([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == 1\n", "\nassert determinant_3x3([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == 0\n", "\nassert determinant_3x3([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == 0\n", "\nassert determinant_3x3([[2, 0, 0], [0, 2, 0], [0, 0, 2]]) == 8\n", "\nassert determinant_3x3([[1, 1, 1], [... |
523bc3b18941f87346cb68f18b8769c7 | [
{
"content": "On te donne un répertoire racine et ta tâche est de trouver le plus grand sous-répertoire en termes de taille totale de son contenu. La fonction doit parcourir récursivement tous les sous-répertoires dans le répertoire racine donné, calculer la taille totale de chaque sous-répertoire (y compris se... | ["\nassert find_largest_directory(\"/path/to/empty_directory\") == (None, 0)\n", "\nassert find_largest_directory(\"/path/to/single_file_directory\") == (\"single_file.txt\", os.path.getsize(\"/path/to/single_file_directory/single_file.txt\"))\n", "\nassert find_largest_directory(\"/path/to/multiple_files_directory\") ... |
f0983a54f108f141e1ee189dae073567 | [
{
"content": "On te donne un graphe non orienté `G` représenté sous forme de liste d'adjacence, où `G[v]` est une liste de tuples `(adj_v, w)` indiquant qu'il existe une arête du sommet `v` au sommet `adj_v` avec un poids `w`. De plus, on te donne une liste de sommets `V` et un `threshold_weight`. Détermine si ... | ["\nassert is_clique([1, 2, 3], {1: [(2, 5), (3, 6)], 2: [(1, 5), (3, 7)], 3: [(1, 6), (2, 7)]}, 4) == True\n", "\nassert is_clique([1, 2, 3], {1: [(2, 5), (3, 6)], 2: [(1, 5), (3, 7)], 3: [(1, 6), (2, 7)]}, 8) == False\n", "\nassert is_clique([1, 2], {1: [(2, 5)], 2: [(1, 5)]}, 5) == True\n", "\nassert is_clique([1, 2... |
694910c207611dc7bd6660414f2c4cf1 | [
{
"content": "Tu développes un système de gestion de tâches nommé \"TaskMaster\". Ta tâche est d'implémenter une fonction `task_url` qui construit une URL sécurisée pour une tâche donnée. La fonction doit prendre un seul paramètre `task_id`, une chaîne de caractères représentant l'identifiant unique de la tâche... | ["\nassert task_url(\"123\") == \"TaskMaster:///task/123#a665a45920422f9d417e4867efdc4fb8a04a1f3fff1f8a2bdc11697c336b87f5\"\n", "\nassert task_url(\"abc\") == \"TaskMaster:///task/abc#ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad\"\n", "\nassert task_url(\"task123\") == \"TaskMaster:///task/task123#f... |
37a472e0972ca0c28f595aee99e9c100 | [
{
"content": "On te donne une liste d'entiers, `nums`, représentant les tailles des élèves faisant la queue. Ta tâche est de trier la liste par ordre non décroissant en utilisant l'algorithme de tri par insertion. La fonction doit modifier la liste d'entrée `nums` sur place et renvoyer la liste triée ainsi que ... | ["\nassert sort_students([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == ([1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9], 20)\n", "\nassert sort_students([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 45)\n", "\nassert sort_students([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0)\n", "\nassert ... |
c0fa686eefea54a14d6120cda96114cc | [
{
"content": "On te donne une structure JSON représentée comme un dictionnaire de dictionnaires imbriqués. Ta tâche est d'écrire une fonction `flatten_json(json_structure)` qui transforme cette structure en un dictionnaire aplati. Dans le dictionnaire aplati, chaque clé doit être une chaîne de caractères qui re... | ["\nassert flatten_json({\"a\": {\"b\": 1, \"c\": {\"d\": 2}}}) == {\"a_b\": 1, \"a_c_d\": 2}\n", "\nassert flatten_json({\"x\": 1, \"y\": {\"z\": 2}}) == {\"x\": 1, \"y_z\": 2}\n", "\nassert flatten_json({\"level1\": {\"level2\": {\"level3\": {\"level4\": 5}}}}) == {\"level1_level2_level3_level4\": 5}\n", "\nassert fl... |
893517f381cc1c7cde2cd2cb5aabdaf0 | [
{
"content": "On te demande d'implémenter une fonction de hachage personnalisée nommée `custom_hash` pour une chaîne de caractères donnée `s`. La fonction de hachage doit prendre en compte à la fois la valeur ASCII de chaque caractère et sa position dans la chaîne, ainsi que la longueur totale de la chaîne. La ... | ["\nassert custom_hash(\"\") == 0\n", "\nassert custom_hash(\"a\") == 97\n", "\nassert custom_hash(\"abc\") == 1066503\n", "\nassert custom_hash(\"hello\") == 181041835\n", "\nassert custom_hash(\"world\") == 181923210\n", "\nassert custom_hash(\"123\") == 111111\n", "\nassert custom_hash(\"!@#\") == 111111\n", "\nasse... |
4637649ed6d3a40b0f4e997bdd08466f | [
{
"content": "Dans un monde virtuel, un voyageur cherche à rentrer chez lui. Tu dois implémenter une fonction `can_return_home` qui détermine si un voyageur peut atteindre son domicile à partir de sa position actuelle. La fonction accepte deux paramètres : `traveler` et `destination`. L'objet `traveler` a un at... | ["\nassert can_return_home(None, None) == False\n", "\nassert can_return_home(None, object()) == False\n", "\nassert can_return_home(object(), None) == False\n", "\nassert can_return_home(object(), object()) == False\n", "\nassert can_return_home(object(current_location=\"work\"), object(is_home=True)) == False\n", "\n... |
5d7afc36bf16f5eaaf7fa60b1c43a7a0 | [
{
"content": "On te charge de développer une fonction pour un utilitaire de web scraping. Ta fonction doit analyser un document HTML et extraire tous les hyperliens (URL) uniques présents dans le document. La fonction doit utiliser la bibliothèque `BeautifulSoup` pour l'analyse HTML.\n\n**Entrée :**\n- Une chaî... | ["\nassert extract_hyperlinks('<html><body><a href=\"http://example.com\">Example</a></body></html>') == [\"http://example.com\"]\n", "\nassert extract_hyperlinks('<html><body><a href=\"http://example.com\">Example</a><a href=\"http://test.com\">Test</a></body></html>') == [\"http://example.com\", \"http://test.com\"]\... |
f136a1ab68e622dcbfe24975236eb1ec | [
{
"content": "Tu es chargé d'implémenter une classe `Rectangle` en Python. La classe doit avoir les fonctionnalités suivantes :\n- Initialisation avec `length` et `width`.\n- Calcul et retour de l'aire du rectangle.\n- Calcul et retour du périmètre du rectangle.\n- Comparaison de l'aire du rectangle avec celle ... | ["\nassert Rectangle(5, 3).area() == 15\n", "\nassert Rectangle(4, 4).area() == 16\n", "\nassert Rectangle(0, 0).area() == 0\n", "\nassert Rectangle(7, 2).perimeter() == 18\n", "\nassert Rectangle(10, 10).perimeter() == 40\n", "\nassert Rectangle(1, 1).compare(Rectangle(1, 1)) == \"Both rectangles have the same area.\"... |
066fa4ec0883b19c9607570df4e29908 | [
{
"content": "On te donne une chaîne de caractères `ip`. Ta tâche est de déterminer si `ip` est une adresse IPv4 valide. Une adresse IPv4 valide se compose de quatre nombres décimaux, chacun allant de 0 à 255, séparés par des points. Chaque nombre ne doit pas avoir de zéros non significatifs, sauf s'il est exac... | ["\nassert is_valid_ipv4(\"192.168.1.1\") == True\n", "\nassert is_valid_ipv4(\"255.255.255.255\") == True\n", "\nassert is_valid_ipv4(\"0.0.0.0\") == True\n", "\nassert is_valid_ipv4(\"256.100.50.25\") == False\n", "\nassert is_valid_ipv4(\"192.168.1\") == False\n", "\nassert is_valid_ipv4(\"192.168.1.256\") == False\... |
9e2f24722fce5645ce4ca09dbb2c8d6f | [
{
"content": "On te donne la tâche de développer un programme qui vérifie l'intégrité d'un fichier téléchargé en utilisant l'algorithme de hachage SHA-256. Ton programme doit accepter deux entrées : le chemin d'accès au fichier téléchargé et la valeur de hachage attendue au format hexadécimal. Le programme doit... | ["\nassert verify_file_integrity('test_files/test1.bin', 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855') == \"The file is valid.\"\n", "\nassert verify_file_integrity('test_files/test2.bin', 'd41d8cd98f00b204e9800998ecf8427e') == \"The file is invalid.\"\n", "\nassert verify_file_integrity('test_fil... |
d02794d98fb61d21226923c22a66ee4d | [
{
"content": "On te donne une liste de phrases, où chaque phrase est une chaîne de caractères délimitée par des espaces. On te fournit également un modèle de langage `lm` et une liste de mots « rares » `rare_words`. Ta tâche est de mettre en œuvre une fonction `calculate_adjusted_perplexity(lm, sentences, rare_... | ["\nassert calculate_adjusted_perplexity(lm, [\"hello world\"], [\"rare\"]) == 10 ** (-(lm.score(\"hello world\", bos=True, eos=False) / 2))\n", "\nassert calculate_adjusted_perplexity(lm, [\"this is a test\", \"another sentence\"], [\"test\", \"sentence\"]) == 10 ** (-(lm.score(\"this is a test\", bos=True, eos=False)... |
1154c22af547e8b3ae553dcbf7f71864 | [
{
"content": "On te donne une liste d'objets `Student`, où chaque objet `Student` a deux attributs : `grade` et `weight`. L'attribut `grade` est une chaîne de caractères représentant la note qu'un étudiant a reçue pour une tâche particulière, et l'attribut `weight` est un entier représentant le poids de la tâch... | ["\nassert get_average_assignment_weight([Student('A', 10), Student('B', 20), Student('C', 30)]) == 20\n", "\nassert get_average_assignment_weight([Student('A', 100), Student('F', 50)]) == 75\n", "\nassert get_average_assignment_weight([Student('X', 10), Student('Y', 20)]) == 0\n", "\nassert get_average_assignment_weig... |
70b9c645451bd2166577506eafc79ae5 | [
{
"content": "On te donne une liste triée d'entiers `nums` qui peut contenir des éléments dupliqués, et un entier cible `target`. Ta tâche est de trouver l'indice de la dernière occurrence de `target` dans `nums` en utilisant un algorithme de recherche binaire. Si `target` n'existe pas dans `nums`, retourne -1.... | ["\nassert find_last_occurrence([1, 2, 2, 2, 3, 4, 5], 2) == 3\n", "\nassert find_last_occurrence([1, 1, 1, 1, 1, 1, 1], 1) == 6\n", "\nassert find_last_occurrence([1, 2, 3, 4, 5, 6, 7], 7) == 6\n", "\nassert find_last_occurrence([1, 2, 3, 4, 5, 6, 7], 1) == 0\n", "\nassert find_last_occurrence([1, 3, 5, 7, 9], 2) == -... |
b794967ac7e41b4b245b2321baa01de1 | [
{
"content": "On te donne une chaîne de caractères `deck` représentant un jeu de cartes potentiel. Ta tâche est de déterminer si le jeu est valide selon les règles suivantes : le jeu doit consister en exactement 52 cartes distinctes, chaque carte doit être représentée de manière unique sans doublons, et chaque ... | ["\nassert validate_deck('23456789ajqkt' * 4) == True\n", "\nassert validate_deck('223456789ajqkt' * 4) == False\n", "\nassert validate_deck('23456789ajqka' * 4) == False\n", "\nassert validate_deck('23456789ajqkt') == False\n", "\nassert validate_deck('23456789ajqkt' * 5) == False\n", "\nassert validate_deck('23456789... |
8711543f7f39b001d3492c8a0df2e26f | [
{
"content": "On te donne une liste d'intervalles de temps, chacun représenté sous forme de chaîne de caractères au format \"HH:MM:SS\". Ta tâche est d'écrire une fonction qui calcule le temps total en minutes à partir de ces intervalles. Suppose que les secondes intercalaires sont incluses dans les intervalles... | ["\nassert total_time_in_minutes([\"01:20:30\", \"00:45:15\"]) == 85.25\n", "\nassert total_time_in_minutes([\"00:00:00\"]) == 0.0\n", "\nassert total_time_in_minutes([\"23:59:59\"]) == 1439.9833333333333\n", "\nassert total_time_in_minutes([\"00:01:00\", \"00:01:00\"]) == 2.0\n", "\nassert total_time_in_minutes([\"01:... |
9ebe17f4b17b5c3d43a47ec2a01fb97a | [
{
"content": "On te donne deux dictionnaires, `user_config` et `default_config`, ainsi qu'une liste `priorities` contenant des clés. Ta tâche est de fusionner ces dictionnaires dans un nouveau dictionnaire `merged_dict` de telle sorte que :\n- Les clés dans `merged_dict` soient ordonnées selon leur apparition d... | ["\nassert merge_dictionaries({'a': 1, 'b': 2}, {'b': 3, 'c': 4}, ['a', 'b']) == {'a': 1, 'b': 2}\n", "\nassert merge_dictionaries({'x': 10}, {'y': 20, 'z': 30}, ['y', 'z']) == {'y': 20, 'z': 30, 'x': 10}\n", "\nassert merge_dictionaries({}, {'a': 1, 'b': 2}, ['a', 'b']) == {'a': 1, 'b': 2}\n", "\nassert merge_dictiona... |
94ad1fade2e2558bf67a6f242d823132 | [
{
"content": "Étant donné un tableau non trié d'entiers, écris une fonction pour déterminer le deuxième plus petit élément. Si le tableau contient moins de deux éléments distincts, la fonction doit renvoyer `None`.\n\n**Exemple d'entrée :**\n```\n[10, 3, 2, 5, 7, 4]\n```\n\n**Exemple de sortie :**\n```\n3\n```\... | ["\nassert find_second_smallest([1, 2, 3, 4, 5]) == 2\n", "\nassert find_second_smallest([5, 4, 3, 2, 1]) == 2\n", "\nassert find_second_smallest([2, 2, 2, 2, 2]) == None\n", "\nassert find_second_smallest([10]) == None\n", "\nassert find_second_smallest([1, 1, 2, 2, 3, 3]) == 2\n", "\nassert find_second_smallest([100,... |
d0114294fc2652509be385da2cf09812 | [
{
"content": "On te donne deux chaînes de caractères représentant des adresses IPv4 au format \"xxx.xxx.xxx.xxx\". Ta tâche est d'écrire une fonction qui calcule le nombre d'octets différents entre les deux adresses IP. Chaque octet est comparé individuellement.\n\n**Entrée :**\n- Deux chaînes de caractères, `i... | ["\nassert count_ip_differences(\"192.168.1.1\", \"192.168.1.1\") == 0\n", "\nassert count_ip_differences(\"192.168.1.1\", \"192.168.1.2\") == 1\n", "\nassert count_ip_differences(\"192.168.1.1\", \"192.168.2.1\") == 2\n", "\nassert count_ip_differences(\"192.168.1.1\", \"193.168.1.1\") == 1\n", "\nassert count_ip_diff... |
89943bdd143d044dd4884da75e3cd375 | [
{
"content": "On te donne une chaîne de caractères `hex_color` représentant une couleur au format hexadécimal (par exemple, \"#RRGGBB\"). Ta tâche est de mettre en œuvre une fonction `convert_to_rgb` qui convertit cette chaîne en un tuple de trois entiers représentant la couleur au format RVB. La fonction doit ... | ["\nassert convert_to_rgb(\"#1A2B3C\") == (26, 43, 60)\n", "\nassert convert_to_rgb(\"#FFFFFF\") == (255, 255, 255)\n", "\nassert convert_to_rgb(\"#000000\") == (0, 0, 0)\n", "\nassert convert_to_rgb(\"#FF0000\") == (255, 0, 0)\n", "\nassert convert_to_rgb(\"#00FF00\") == (0, 255, 0)\n", "\nassert convert_to_rgb(\"#000... |
97f270159fb07427485cbe504e14d99f | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'écrire une fonction qui renvoie une nouvelle liste contenant uniquement les chaînes de caractères ayant un nombre pair de caractères. L'ordre des chaînes de caractères dans la liste de sortie doit correspondre à leur ordre dans la ... | ["\nassert filter_even_length_strings([\"hello\", \"world\", \"python\", \"is\", \"great\"]) == ['python', 'is']\n", "\nassert filter_even_length_strings([\"even\", \"odd\", \"pair\", \"single\"]) == ['even', 'pair']\n", "\nassert filter_even_length_strings([\"\", \"a\", \"ab\", \"abc\", \"abcd\"]) == ['ab', 'abcd']\n"... |
568d5df427aecfd0c7dfbfae7badc14a | [
{
"content": "On te donne un échiquier 8x8 représenté comme une liste 2D. Ta tâche est de placer 8 reines sur le plateau de manière à ce qu'aucune reine ne menace une autre et qu'aucune reine ne se trouve sur des diagonales adjacentes. La fonction `solve_queens(board)` doit renvoyer une représentation sous form... | ["\nassert solve_queens([['Q', '', '', '', '', '', '', ''],\n ['', '', '', '', '', '', '', ''],\n ['', '', '', '', '', '', '', ''],\n ['', '', '', '', '', '', '', ''],\n ['', '', '', '', '', '', '', ''],\n ['', '', ... |
2c30797696b717a90a6799609b6fa199 | [
{
"content": "On te demande d'implémenter une fonction `countPrimes(n)` qui détermine le nombre de nombres emirps inférieurs à un entier donné `n`. Un nombre emirp est un nombre premier qui, lorsque ses chiffres sont inversés, forme un nombre premier différent. Les nombres premiers palindromiques (par exemple, ... | ["\nassert countPrimes(10) == 3\n", "\nassert countPrimes(20) == 4\n", "\nassert countPrimes(30) == 5\n", "\nassert countPrimes(50) == 8\n", "\nassert countPrimes(100) == 13\n", "\nassert countPrimes(2) == 0\n", "\nassert countPrimes(3) == 0\n", "\nassert countPrimes(11) == 1\n", "\nassert countPrimes(13) == 2\n", "\na... |
ca54672e33519dd4dd22e1a3160ea0cf | [
{
"content": "On te demande d'implémenter une fonction efficace pour déterminer si un nombre donné est premier. Ta fonction doit gérer efficacement les grands nombres. Écris une fonction `is_prime(num)` qui renvoie `True` si `num` est un nombre premier et `False` sinon.\n\n**Entrée :**\n- Un entier `num` (1 ≤ n... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(29) == True\n", "\nassert is_prime(1) == False\n", "\nassert is_prime(0) == False\n", "\nassert is_prime(-7) == False\n", "\nassert is_prime(97) == True\n", "\nass... |
a06b9633828b031ef151458ad35c3178 | [
{
"content": "On te donne une liste `data` contenant des éléments de différents types, notamment des entiers, des nombres à virgule flottante et des chaînes de caractères. Ta tâche est de mettre en œuvre une fonction `find_most_common_element(data)` qui renvoie l'élément le plus fréquemment rencontré dans la li... | ["\nassert find_most_common_element([1, 2, 2, 3, 3, 3, 4]) == 3\n", "\nassert find_most_common_element(['apple', 'banana', 'apple', 'orange', 'banana', 'banana']) == 'banana'\n", "\nassert find_most_common_element([]) == None\n", "\nassert find_most_common_element([1, 1, 2, 2, 3, 3]) == 1\n", "\nassert find_most_common... |
0d38cbe007f647919b2cfc6f548a9e67 | [
{
"content": "On te donne une liste d'entiers représentant les hauteurs de bâtiments consécutifs dans un paysage urbain. Un bâtiment est considéré comme un « pic » si sa hauteur est supérieure à la hauteur moyenne des bâtiments immédiatement avant et après lui. De plus, un bâtiment ne peut être considéré comme ... | ["\nassert find_peaks([3, 5, 7, 5, 3, 6, 8, 7, 6], 5) == [(2, 7), (6, 8)]\n", "\nassert find_peaks([1, 2, 3, 4, 5], 3) == [(4, 5)]\n", "\nassert find_peaks([5, 4, 3, 2, 1], 3) == []\n", "\nassert find_peaks([1, 3, 2, 4, 3, 5, 4], 2) == [(1, 3), (3, 4), (5, 5)]\n", "\nassert find_peaks([10, 20, 15, 25, 30, 5, 35], 15) =... |
5f71fdfc77ec0d5dd44e76c051b118c4 | [
{
"content": "On te donne une chaîne de caractères `input_string`. Ta tâche est d'implémenter une fonction `count_vowels(input_string)` qui compte le nombre d'occurrences de chaque voyelle ('a', 'e', 'i', 'o', 'u' en minuscules et en majuscules) dans la chaîne. La fonction doit renvoyer un dictionnaire où les c... | ["\nassert count_vowels(\"Hello World!\") == {'e': 1, 'o': 2}\n", "\nassert count_vowels(\"Python Programming\") == {'o': 1, 'a': 1, 'i': 2}\n", "\nassert count_vowels(\"AEIOUaeiou\") == {'A': 1, 'E': 1, 'I': 1, 'O': 1, 'U': 1, 'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1}\n", "\nassert count_vowels(\"\") == {}\n", "\nassert... |
1a0a6ee711eefea7d1f5007c4fbd0104 | [
{
"content": "On te donne une date sous la forme d'un tuple `(année, mois, jour)`. Ta tâche est d'écrire une fonction `get_last_day_of_previous_month(date)` qui renvoie un tuple représentant le dernier jour du mois précédent. La fonction doit gérer correctement les années bissextiles et les longueurs de mois va... | ["\nassert get_last_day_of_previous_month((2023, 10, 1)) == (2023, 9, 30)\n", "\nassert get_last_day_of_previous_month((2024, 2, 29)) == (2024, 1, 31)\n", "\nassert get_last_day_of_previous_month((2023, 3, 1)) == (2023, 2, 28)\n", "\nassert get_last_day_of_previous_month((2020, 3, 1)) == (2020, 2, 29)\n", "\nassert get... |
f68c0e217fe2ad0190f589d050848413 | [
{
"content": "On te donne une séquence de nombres. Ta tâche est d'implémenter une fonction `weighted_average` qui calcule la moyenne pondérée de ces nombres. Les poids sont les nombres eux-mêmes. Avant de calculer la moyenne pondérée, assure-toi que tous les nombres sont distincts et triés par ordre croissant. ... | ["\nassert weighted_average(1, 2, 3, 4, 5) == 3.5\n", "\nassert weighted_average(10, 20, 30) == 23.333333333333332\n", "\nassert weighted_average(5) == 5\n", "\nassert weighted_average(0, 1, 2, 3) == 2.0\n", "\nassert weighted_average(-1, 0, 1) == 0.3333333333333333\n", "\nassert weighted_average(1.5, 2.5, 3.5) == 2.83... |
aedf6b1803cd71feaed6d9a7e290faa2 | [
{
"content": "On te donne une liste triée d'entiers `arr` et un entier `target`. Implémente une fonction `binary_search` qui renvoie l'index de l'élément `target` dans la liste. Si `target` n'est pas trouvé, renvoie `-1`.\n\n**Entrée:**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), le nombre d'élé... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([1], 1) == 0\n", "\nassert binary_search(... |
a62651c955a843e369c3099467f0e09d | [
{
"content": "On te donne une liste de tuples `students`, où chaque tuple est composé du nom d'un étudiant (une chaîne de caractères) et de son score (un entier). Ta tâche est de mettre en œuvre une fonction `sort_students(students)` qui trie la liste des étudiants par ordre décroissant en fonction de leurs sco... | ["\nassert sort_students([(\"Alice\", 88), (\"Bob\", 95), (\"Charlie\", 70)]) == [(\"Bob\", 95), (\"Alice\", 88), (\"Charlie\", 70)]\n", "\nassert sort_students([(\"David\", 60), (\"Eve\", 60), (\"Frank\", 60)]) == [(\"David\", 60), (\"Eve\", 60), (\"Frank\", 60)]\n", "\nassert sort_students([(\"Grace\", 100), (\"Heidi... |
306ba9181f602f963d921f8b5b5a4bc4 | [
{
"content": "On te donne deux listes : une liste d'entiers `nums` et une liste d'indices `indices`. Ta tâche est de construire une nouvelle liste `result` telle que l'entier à l'index `i` dans `nums` est inséré à l'index `indices[i]` dans `result`. Si `indices[i]` dépasse la longueur actuelle de `result`, ajou... | ["\nassert create_result([0, 1, 2, 3, 4], [0, 1, 2, 2, 1]) == [0, 4, 1, 2, 3]\n", "\nassert create_result([2, 3, 5, 7, 11], [0, 1, 2, 3, 4]) == [0, 1, 4, 9, 2]\n", "\nassert create_result([1, 4, 9, 16, 25], [0, 1, 2, 3, 4]) == [1, 4, 9, 16, 25]\n", "\nassert create_result([2, 4, 6, 8, 10], [0, 1, 2, 3, 4]) == [0, 4, 1,... |
64c2eb3bb7f7861bc2d867609d3877f7 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de traiter cette chaîne en effectuant les opérations suivantes :\n1. Supprime tous les caractères non alphanumériques.\n2. Convertis toutes les lettres en minuscules.\n3. Remplace les espaces multiples entre les mots par un seul espace.\n4. Su... | ["\nassert clean_string(\"Hello, World! This is a test.\") == \"hello world this is a test\"\n", "\nassert clean_string(\"Python@#Programming123\") == \"pythonprogramming123\"\n", "\nassert clean_string(\" Leading and trailing spaces \") == \"leading and trailing spaces\"\n", "\nassert clean_string(\"Multiple sp... |
8306cc73a11d24338cd0f3a41f6a8fc1 | [
{
"content": "On te demande d'implémenter une fonction `abs_all` qui prend une fonction `f` comme argument. La fonction `f` peut accepter n'importe quel nombre d'arguments positionnels et nommés et renvoie une liste de nombres, qui peut inclure des listes imbriquées de profondeur arbitraire. Ton travail consist... | ["\nassert abs_all(lambda: [-1, -2, -3])() == [1, 2, 3]\n", "\nassert abs_all(lambda x: [x, -x])(-5) == [5, 5]\n", "\nassert abs_all(lambda x, y: [x, y, -x, -y])(3, 4) == [3, 4, 3, 4]\n", "\nassert abs_all(lambda: [[-1, -2], [-3, -4]])() == [[1, 2], [3, 4]]\n", "\nassert abs_all(lambda: [[[-1], [-2, -3]], [[-4, -5], [-... |
e6ccbe99d722103aa1ca453592207876 | [
{
"content": "On te donne une liste de paires de villes, où chaque paire représente un itinéraire de vol direct entre deux villes. La liste est formatée comme suit : `[[\"Ville1\", \"Ville2\"], [\"Ville3\", \"Ville4\"], ...]`. Ta tâche est de transformer cette liste en un nouveau format qui inclut à la fois l'i... | ["\nassert transform_routes([[\"new york\", \"los angeles\"]]) == [\"New York-Los Angeles\", \"Los Angeles-New York\"]\n", "\nassert transform_routes([[\"paris\", \"berlin\"]]) == [\"Paris-Berlin\", \"Berlin-Paris\"]\n", "\nassert transform_routes([[\"tokyo\", \"osaka\"], [\"sydney\", \"melbourne\"]]) == [\"Tokyo-Osaka... |
6ce5c3f49f94e0f142ec693db0f2aa73 | [
{
"content": "On te demande d'implémenter une fonction pour filtrer les avis sur les produits en fonction de leurs évaluations. Étant donné deux listes, `reviews` et `ratings`, où chaque avis correspond à une évaluation, écris une fonction `filter_reviews` qui renvoie une liste d'avis avec des évaluations de 3 ... | ["\nassert filter_reviews([\"Great product!\", \"Not good\", \"Average\", \"Excellent\"], [5, 2, 3, 4]) == [\"Great product!\", \"Average\", \"Excellent\"]\n", "\nassert filter_reviews([\"Terrible\", \"Okay\", \"Good\"], [1, 3, 5]) == [\"Okay\", \"Good\"]\n", "\nassert filter_reviews([\"Bad\", \"Worst\", \"Poor\"], [1,... |
afe70a995db5327d4f34904479027089 | [
{
"content": "Tu participes à une compétition mondiale d'analyse de données urbaines. On te fournit un DataFrame pandas `df` qui consolide des informations provenant de plusieurs sources sur diverses villes du monde. Le DataFrame `df` possède les colonnes suivantes : `city_id`, `city_name`, `country_name`, `pop... | ["\nassert get_city_info(pd.DataFrame({'city_id': [1, 2, 3], 'city_name': ['New York', 'Los Angeles', 'Chicago'], 'country_name': ['USA', 'USA', 'USA'], 'population': [8419000, 3980400, 2716000], 'area': [1413, 1302, 606], 'density': [6025, 3058, 4482]}), 2).equals(pd.DataFrame({'city_id': [2], 'city_name': ['Los Angel... |
331df25fb02f62adf31ed79e83c7e3f3 | [
{
"content": "On te donne une liste de bâtiments, chacun ayant une hauteur spécifique. Tu disposes d'un nombre limité de briques et d'échelles. Ton objectif est de déterminer l'indice du bâtiment le plus éloigné que tu peux atteindre en utilisant les briques et les échelles pour surmonter les différences de hau... | ["\nassert furthestBuilding([4,2,7,6,9,14,12], 5, 1) == 4\n", "\nassert furthestBuilding([4,12,2,7,3,18,20,3,19], 10, 2) == 7\n", "\nassert furthestBuilding([14,3,19,3], 17, 0) == 3\n", "\nassert furthestBuilding([1,5,1,2,3,4,10000], 4, 1) == 4\n", "\nassert furthestBuilding([1,2,3,4,5,6,7,8,9,10], 0, 0) == 0\n", "\nas... |
6d7dda0f512a145af1e31e0b2e70953b | [
{
"content": "On te donne une séquence d'ADN représentée sous forme de chaîne de caractères `dna_sequence` et une liste de mutations `mutations`. Chaque mutation est un tuple `(start, end, insert_sequence)` où `start` et `end` sont des indices dans la séquence d'ADN, et `insert_sequence` est une séquence d'ADN ... | ["\nassert apply_mutations(\"ATCGA\", [(1, 2, \"T\")]) == \"ATTGA\"\n", "\nassert apply_mutations(\"ATCGA\", [(3, 4, \"GG\")]) == \"ATCGGGA\"\n", "\nassert apply_mutations(\"ATCGA\", [(1, 2, \"T\"), (3, 4, \"GG\")]) == \"ATTGGGA\"\n", "\nassert apply_mutations(\"AAAAA\", [(0, 0, \"T\")]) == \"TAAAAA\"\n", "\nassert app... |
0f9c2490ab99a03e8459b40e5a7e98bb | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de déterminer le nombre de sous-tableaux contigus dont la somme est exactement zéro. Un sous-tableau est défini comme une partie contiguë du tableau.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), le nombre d'éléments dans... | ["\nassert count_zero_sum_subarrays([1, 2, -3, 3, 1, -4, 2, 2]) == 4\n", "\nassert count_zero_sum_subarrays([0, 0, 0, 0]) == 10\n", "\nassert count_zero_sum_subarrays([1, 2, 3, 4, 5]) == 0\n", "\nassert count_zero_sum_subarrays([-1, 1]) == 1\n", "\nassert count_zero_sum_subarrays([1, -1, 2, -2, 3, -3]) == 9\n", "\nasse... |
e64c79377029a56f3147fb93c9438f2c | [
{
"content": "On te donne une valeur de température et son échelle (soit Celsius 'C' soit Fahrenheit 'F'). Ton objectif est d'écrire une fonction qui convertit cette température dans l'autre échelle. La conversion doit être précise à quatre décimales près. Si l'échelle d'entrée est la même que l'échelle de sort... | ["\nassert convert_temperature(0, 'C', 'F') == 32.0\n", "\nassert convert_temperature(100, 'C', 'F') == 212.0\n", "\nassert convert_temperature(32, 'F', 'C') == 0.0\n", "\nassert convert_temperature(212, 'F', 'C') == 100.0\n", "\nassert convert_temperature(37, 'C', 'F') == 98.6\n", "\nassert convert_temperature(98.6, '... |
b5d6e9e8d35eb752bbd74dbb4223a533 | [
{
"content": "Tu es chargé de développer une interface en ligne de commande (CLI) en utilisant le module `argparse` de Python. La CLI doit accepter les paramètres suivants :\n- `--name` : un argument de chaîne obligatoire représentant le nom de l'utilisateur.\n- `--age` : un argument entier obligatoire représen... | ["\nassert main(['--name', 'Alice', '--age', '30']) == \"Hello, Alice!\"\n", "\nassert main(['--name', 'Bob', '--age', '25', '--verbose']) == \"Hello, Bob!\\nVerbose mode is enabled. You are 25 years old.\"\n", "\nassert main(['--name', 'Charlie', '--age', '40']) == \"Hello, Charlie!\"\n", "\nassert main(['--name', 'Da... |
10d2357b5730cbe5036343e7669e0cb2 | [
{
"content": "Dans un jeu de pendu, on te donne un `secret_word` et un `guess_word`. Le `secret_word` est le mot à deviner, et le `guess_word` est constitué d'une ou plusieurs lettres devinées par le joueur. Ta tâche est de déterminer si une lettre du `guess_word` est présente dans le `secret_word`.\n\nÉcris un... | ["\nassert is_valid_guess(\"p\", \"python\") == True\n", "\nassert is_valid_guess(\"z\", \"python\") == False\n", "\nassert is_valid_guess(\"pz\", \"python\") == True\n", "\nassert is_valid_guess(\"xyz\", \"python\") == True\n", "\nassert is_valid_guess(\"qrs\", \"python\") == False\n", "\nassert is_valid_guess(\"a\", ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.