id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
54ca6e7caf1fb6c04cae0e98f7677cce | [
{
"content": "On te donne une chaîne de configuration où chaque paire clé-valeur est séparée par un espace, et la clé et la valeur sont séparées par un signe égal (=). Les clés et les valeurs peuvent contenir des espaces, des guillemets et représenter plusieurs types de données, notamment des entiers, des nombr... | ["\nassert parse_config_string('key1=\"a value\" key2=123 key3=45.67 key4=True') == {'key1': 'a value', 'key2': 123, 'key3': 45.67, 'key4': True}\n", "\nassert parse_config_string('name=\"John Doe\" age=30 height=5.9 is_student=False') == {'name': 'John Doe', 'age': 30, 'height': 5.9, 'is_student': False}\n", "\nassert... |
be8915965c154912c6ac9eaf7a8066c5 | [
{
"content": "On te donne un tableau trié d'entiers `nums` qui a été tourné un nombre inconnu de fois et peut contenir des doublons. Ta tâche est de déterminer l'index d'un entier cible `target` dans ce tableau tourné. Si la cible n'est pas présente, retourne `-1`.\n\n**Entrée :**\n- La première ligne contient ... | ["\nassert search([4,5,6,7,0,1,2], 0) == 4\n", "\nassert search([4,5,6,7,0,1,2], 3) == -1\n", "\nassert search([1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1], 2) == 13\n", "\nassert search([2,2,2,0,1,1,2], 0) == 3\n", "\nassert search([1,3,1,1,1], 3) == 1\n", "\nassert search([1,0,1,1,1], 0) == 1\n", "\nassert search([1,1,1,1... |
3f31a04dadd25060b6b9bd62a481a0ee | [
{
"content": "On te donne plusieurs cas de test. Chaque cas de test consiste en une chaîne de caractères et un caractère. Pour chaque cas de test, détermine le nombre de fois que le caractère apparaît dans la chaîne et affiche le résultat.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 100... | ["\nassert count_occurrences(\"hello\", \"l\") == 2\n", "\nassert count_occurrences(\"world\", \"z\") == 0\n", "\nassert count_occurrences(\"aaaaa\", \"a\") == 5\n", "\nassert count_occurrences(\"abcabcabc\", \"b\") == 3\n", "\nassert count_occurrences(\"!@#$%^&*()\", \"!\") == 1\n", "\nassert count_occurrences(\"missi... |
b7c9e8b8a3f1df5f2bd7f8fad98fa66e | [
{
"content": "On te donne un dictionnaire `book_sales` où chaque clé est un titre de livre (une chaîne de caractères) et chaque valeur est le nombre de copies vendues (un entier). Ta tâche est de mettre en œuvre une fonction `top_selling_books(book_sales: Dict[str, int], num_books: int) -> List[str]` qui renvoi... | ["\nassert top_selling_books({\"Book A\": 10, \"Book B\": 20, \"Book C\": 15}, 2) == [\"Book B\", \"Book C\"]\n", "\nassert top_selling_books({\"Book A\": 10, \"Book B\": 10, \"Book C\": 10}, 3) == [\"Book A\", \"Book B\", \"Book C\"]\n", "\nassert top_selling_books({\"Book A\": 30, \"Book B\": 20, \"Book C\": 10}, 1) ... |
785b8474af60179b88eaf25f19f1b3c0 | [
{
"content": "On te donne un tableau `nums` contenant `n` nombres distincts dans la plage `[0, n]`. Ta tâche est de trouver le nombre qui manque dans le tableau. Le tableau n'est pas nécessairement trié.\n\n**Entrée :**\n- Un tableau d'entiers `nums` de longueur `n` où chaque élément est un entier unique dans l... | ["\nassert find_missing_number([3, 0, 1]) == 2\n", "\nassert find_missing_number([9, 6, 4, 2, 3, 5, 7, 0, 1]) == 8\n", "\nassert find_missing_number([0]) == 1\n", "\nassert find_missing_number([1]) == 0\n", "\nassert find_missing_number([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, ... |
b16ebcbfee4dee6fca2fb7f5414f30e3 | [
{
"content": "On te donne une liste de tâches, où chaque tâche est représentée comme un dictionnaire contenant un 'id', un 'status' et des 'metadata'. Le dictionnaire 'metadata' inclut un champ 'labels', qui est une liste de chaînes de caractères représentant les étiquettes associées à la tâche. Ta tâche est de... | ["\nassert get_task_labels([{'id': 1, 'status': 'completed', 'metadata': {'labels': ['bug', 'urgent']}}], 1) == ['bug', 'urgent']\n", "\nassert get_task_labels([{'id': 2, 'status': 'pending', 'metadata': {'labels': ['enhancement']}}], 2) == ['enhancement']\n", "\nassert get_task_labels([{'id': 3, 'status': 'in progress... |
08a5de2786053f7c971677e1bb667bba | [
{
"content": "On te donne deux chemins de fichiers en entrée. Ta tâche est de mettre en œuvre une fonction `detect_encoding_difference` qui lit les 100 premiers octets de chaque fichier et détermine si les types d'encodage des deux fichiers sont différents. Si les fichiers sont plus petits que 100 octets, lis l... | ["\nassert detect_encoding_difference('utf8_file.txt', 'utf8_file.txt') == False\n", "\nassert detect_encoding_difference('utf8_file.txt', 'utf16_file.txt') == True\n", "\nassert detect_encoding_difference('utf8_file.txt', 'gbk_file.txt') == True\n", "\nassert detect_encoding_difference('utf16_file.txt', 'utf16_file.tx... |
a5caf3a0a449ec9b7426cac7456565b8 | [
{
"content": "On te demande d'implémenter une fonction `validate_input` qui interagit avec l'utilisateur pour obtenir une entrée entière valide. La fonction doit inviter l'utilisateur de manière répétée avec un `prompt` donné jusqu'à ce qu'un entier valide provenant d'une liste prédéfinie `valid_integers` soit ... | ["\nassert validate_input(\"Enter a number: \", [1, 2, 3]) in [1, 2, 3]\n", "\nassert validate_input(\"Choose 4, 5, or 6: \", [4, 5, 6]) in [4, 5, 6]\n", "\nassert validate_input(\"Pick a number between 7 and 9: \", [7, 8, 9]) in [7, 8, 9]\n", "\nassert validate_input(\"Select 10 or 11: \", [10, 11]) in [10, 11]\n", "\... |
c80ec62806470f9c01ef5857dc856a0b | [
{
"content": "On te donne une chaîne de caractères `text` et une liste de caractères `chars`. Ta tâche est de mettre en œuvre une fonction `count_characters` qui renvoie une liste d'entiers. Le i-ème élément de la liste doit représenter le nombre de fois que le i-ème caractère dans `chars` apparaît dans `text`.... | ["\nassert count_characters(\"hello world\", ['l', 'o']) == [3, 2]\n", "\nassert count_characters(\"programming\", ['p', 'r', 'g']) == [1, 2, 2]\n", "\nassert count_characters(\"mississippi\", ['i', 's']) == [4, 4]\n", "\nassert count_characters(\"python\", ['x', 'y', 'z']) == [0, 0, 0]\n", "\nassert count_characters(\... |
aab024a76d4830cc0f4ca47eab829715 | [
{
"content": "On te demande d'implémenter une fonction `generate_report` en Python. La fonction doit traiter une liste de transactions financières, chacune représentée comme un tuple `(date, catégorie, montant)`, et produire un rapport formaté. Le rapport doit inclure une ligne d'en-tête avec les noms de colonn... | ["\nassert generate_report([(\"2021-01-01\", \"Groceries\", 120.50), (\"2021-01-02\", \"Utilities\", 75.00)]) == \"Date,Category,Amount\\n2021-01-01,Groceries,120.5\\n2021-01-02,Utilities,75.0\\nTotal,,195.5\"\n", "\nassert generate_report([(\"2022-02-15\", \"Entertainment\", 50.00), (\"2022-02-16\", \"Entertainment\",... |
bbae9c002784e3c325923b2798c9f034 | [
{
"content": "On te donne un entier `n`. Ta tâche est de générer toutes les combinaisons de `n` paires de parenthèses qui sont bien formées. Une chaîne de parenthèses bien formée est une chaîne où chaque parenthèse ouvrante '(' a une parenthèse fermante correspondante ')' et elles sont correctement imbriquées.\... | ["\nassert generate_parentheses(0) == ['']\n", "\nassert generate_parentheses(1) == ['()']\n", "\nassert generate_parentheses(2) == ['()()', '(())']\n", "\nassert generate_parentheses(3) == ['()()()', '()(())', '(())()', '((()))']\n", "\nassert generate_parentheses(4) == ['()()()()', '()()(())', '()(())()', '()((()))',... |
f9d42f688361923340c80bf0f64b5791 | [
{
"content": "On te donne un échiquier 8x8 représenté comme une grille 2D. Chaque cellule de la grille peut contenir une pièce désignée par un seul caractère : 'K' pour cavalier, 'Q' pour reine et '0' pour une cellule vide. Ta tâche est de déterminer le nombre de collisions qui se produiraient si une reine deva... | ["\nassert queen_collisions((0, 4), chessboard) == 0\n", "\nassert queen_collisions((1, 1), chessboard) == 1\n", "\nassert queen_collisions((1, 5), chessboard) == 1\n", "\nassert queen_collisions((4, 4), chessboard) == 0\n", "\nassert queen_collisions((0, 0), chessboard) == 1\n", "\nassert queen_collisions((7, 7), ches... |
ea9caa84523c379b6c1480c5e39ff2b2 | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est d'implémenter une fonction qui vérifie si le tableau est trié par ordre non décroissant. Si c'est le cas, renvoie un nouveau tableau avec les éléments triés par ordre croissant. Si le tableau n'est pas trié, renvoie un tableau vide.\n\n**Entrée :**\n-... | ["\nassert sort_if_non_decreasing([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert sort_if_non_decreasing([5, 4, 3, 2, 1]) == []\n", "\nassert sort_if_non_decreasing([1, 1, 1, 1, 1]) == [1, 1, 1, 1, 1]\n", "\nassert sort_if_non_decreasing([1, 2, 2, 3, 4]) == [1, 2, 2, 3, 4]\n", "\nassert sort_if_non_decreasing([10]) =... |
00d99fa178a6d91bed324166ea54cc19 | [
{
"content": "On te donne une liste de tâches, chacune représentée comme un dictionnaire avec les clés suivantes : `task_id`, `task_name`, `task_status` et `task_result`. Le `task_status` peut être l'un des suivants : `pending`, `in_progress` ou `completed`. Pour les tâches avec un `task_status` de `completed`,... | ["\nassert process_tasks([{'task_id': 1, 'task_name': 'Task A', 'task_status': 'completed', 'task_result': 'Success'}]) == None\n", "\nassert process_tasks([{'task_id': 2, 'task_name': 'Task B', 'task_status': 'in_progress', 'task_result': None}]) == None\n", "\nassert process_tasks([{'task_id': 3, 'task_name': 'Task C... |
595e1d95339bcf2922dccfb2c0dbe802 | [
{
"content": "Étant donné deux listes d'entiers, `list1` et `list2`, ta tâche est de mettre en œuvre une fonction `find_common_elements(list1, list2)` qui renvoie une liste d'entiers uniques qui sont présents à la fois dans `list1` et `list2`. L'ordre des éléments dans la liste résultante doit correspondre à le... | ["\nassert find_common_elements([1, 2, 3, 4], [3, 4, 5, 6]) == [3, 4]\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\nassert find_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "... |
6dbd7a2c3cea52a08030dd4ff91f49e7 | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `width` : Un entier représentant la largeur du rectangle.\n - `height` : Un entier représentant la hauteur du rectangle.\n\n- **Méthodes :**\n - `area... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).perimeter() == 20\n", "\nassert Rectangle(0, 0).area() == 0\n", "\nassert Rectangle(10, 2).perimeter() == 24\n", "\nassert Rectangle(7, 3).area() == 21\n", "\nassert Rectangle(1, 1).perimeter() == 4\n", "\nassert Rectangle(15, 10).area() == 150\n", "... |
5ca848de7277cad4b4d4ac132b78db5a | [
{
"content": "On te donne une grille 2D d'entiers. Ta tâche est de trouver la longueur du chemin le plus long dans la grille où chaque étape du chemin doit se déplacer vers une cellule adjacente (haut, bas, gauche ou droite) et la valeur dans la cellule suivante doit être strictement supérieure à la valeur dans... | ["\nassert longest_increasing_path([[9, 9, 4], [6, 6, 8], [2, 1, 1]]) == 4\n", "\nassert longest_increasing_path([[3, 4, 5], [3, 2, 6], [2, 2, 1]]) == 4\n", "\nassert longest_increasing_path([[1]]) == 1\n", "\nassert longest_increasing_path([[1, 2], [4, 3]]) == 3\n", "\nassert longest_increasing_path([[1, 2, 3], [6, 5,... |
67ee8d033036cc04131afd1a9dd78875 | [
{
"content": "Implémente l'algorithme de tri par fusion pour trier un tableau d'entiers par ordre croissant. Ta fonction doit prendre un tableau en entrée et renvoyer le tableau trié. Le tableau d'entrée peut contenir jusqu'à 10^5 éléments, chacun allant de -10^9 à 10^9.\n\n**Exemple d'entrée :**\n```\n[12, 11,... | ["\nassert merge_sort([38, 27, 43, 3, 9, 82, 10]) == [3, 9, 10, 27, 38, 43, 82]\n", "\nassert merge_sort([5, 2, 4, 6, 1, 3]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([]) == []\n", "\nassert me... |
72deae2196354c1927cc8cde9aa5cba8 | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est d'écrire une fonction `generate_permutations` qui génère toutes les permutations uniques de la chaîne `s`. La fonction doit renvoyer une liste de chaînes de caractères, où chaque chaîne est une permutation unique de `s`. L'ordre des permut... | ["\nassert generate_permutations(\"a\") == [\"a\"]\n", "\nassert generate_permutations(\"ab\") == [\"ab\", \"ba\"]\n", "\nassert generate_permutations(\"abc\") == [\"abc\", \"acb\", \"bac\", \"bca\", \"cab\", \"cba\"]\n", "\nassert generate_permutations(\"aabb\") == [\"aabb\", \"abab\", \"abba\", \"baab\", \"baba\", \"... |
1982b9063e95c4631dbac7ba4ef922da | [
{
"content": "On te donne un entier positif représentant un identifiant d'étudiant. Ta tâche est de formater cet identifiant selon les règles suivantes :\n1. Convertis l'identifiant d'étudiant en chaîne de caractères.\n2. Si la chaîne est plus courte que 8 caractères, ajoute des zéros en tête pour qu'elle fasse... | ["\nassert format_student_id(123) == \"00021300\"\n", "\nassert format_student_id(4567) == \"04567000\"\n", "\nassert format_student_id(89) == \"00089000\"\n", "\nassert format_student_id(12345678) == \"12348765\"\n", "\nassert format_student_id(987654321) == \"12349876\"\n", "\nassert format_student_id(1111) == \"0001... |
924c6890bf74027d0a39884f5cd36a07 | [
{
"content": "On te donne un tableau d'entiers `nums` qui peut contenir des éléments en double. Ta tâche est de trouver tous les sous-ensembles possibles de `nums` tels que chaque sous-ensemble inclue au moins une occurrence de chaque nombre distinct dans `nums` et que la somme des éléments de chaque sous-ensem... | ["\nassert subsets_with_prime_sum([2, 3, 2]) == [[2, 3, 2]]\n", "\nassert subsets_with_prime_sum([1, 2, 3]) == [[1, 2], [2, 3]]\n", "\nassert subsets_with_prime_sum([4, 5, 6]) == []\n", "\nassert subsets_with_prime_sum([2, 2, 3, 3]) == [[2, 2, 3, 3]]\n", "\nassert subsets_with_prime_sum([1, 1, 1, 1]) == []\n", "\nasser... |
142dd322677dac3413e712d42b4f5ae8 | [
{
"content": "On te donne une chaîne de caractères `s` composée de parenthèses `()`, d'accolades `{}` et de crochets `[]`. 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 elle a un nombre égal de parenthèses ouvrantes et fermantes, et si les parenthèses sont... | ["\nassert is_balanced(\"(()())\") == True\n", "\nassert is_balanced(\"())(\") == False\n", "\nassert is_balanced(\"{[()]}\") == True\n", "\nassert is_balanced(\"{[(])}\") == False\n", "\nassert is_balanced(\"{{[[(())]]}}\") == True\n", "\nassert is_balanced(\"((()))\") == True\n", "\nassert is_balanced(\")(\") == Fals... |
7c2dad2e00e2000902bb96d65b255b42 | [
{
"content": "On te donne un chemin de fichier. Ta tâche est d'écrire une fonction Python `generate_compression_ratio` qui calcule le taux de compression du fichier lorsqu'il est compressé à l'aide de la bibliothèque gzip. Le taux de compression est défini comme le rapport de la taille du fichier original à la ... | ["\nassert generate_compression_ratio(\"test_files/test1.txt\") == 1.0 # Assuming test1.txt is already compressed or incompressible\n", "\nassert generate_compression_ratio(\"test_files/test2.txt\") > 1.0 # Assuming test2.txt is compressible\n", "\nassert generate_compression_ratio(\"test_files/test3.txt\") > 1.0 # ... |
9d7a48b81dce0f1e2e1913cd7257cd8d | [
{
"content": "On te donne une liste de températures en Fahrenheit. Ta tâche est d'écrire une fonction Python `convert_to_celsius` qui convertit chaque température en Celsius et renvoie une nouvelle liste avec les températures converties. Chaque température convertie doit être arrondie à deux décimales.\n\n**Ent... | ["\nassert convert_to_celsius([32]) == [0.0]\n", "\nassert convert_to_celsius([212]) == [100.0]\n", "\nassert convert_to_celsius([98.6]) == [37.0]\n", "\nassert convert_to_celsius([77]) == [25.0]\n", "\nassert convert_to_celsius([50]) == [10.0]\n", "\nassert convert_to_celsius([-40]) == [-40.0]\n", "\nassert convert_to... |
4e1cb54721b2af06afc5d5751d8b29b4 | [
{
"content": "On te donne un tableau 1D d'entiers représentant un signal. Ta tâche est de mettre en œuvre une fonction qui applique un filtre passe-bas à ce tableau en utilisant un filtre de moyenne mobile avec une taille de fenêtre fixe de 5. La fonction doit renvoyer le tableau filtré. Le tableau filtré ne do... | ["\nassert moving_average_filter([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [3.0, 4.0, 5.0, 6.0, 7.0]\n", "\nassert moving_average_filter([10, 20, 30, 40, 50]) == [30.0]\n", "\nassert moving_average_filter([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) == [1.0, 1.0, 1.0, 1.0, 1.0]\n", "\nassert moving_average_filter([1, 2, 3, 4, 5]) == [3.0... |
66c8e40c13bffa8daa3750b11b1b295d | [
{
"content": "On te donne une grille 2D représentant un plan de ville où chaque cellule est soit un bâtiment ('B') soit une route ('R'). Ta tâche est de trouver le chemin le plus court d'un point de départ donné à un point de destination, en te déplaçant uniquement à travers les cellules routières et uniquement... | ["\nassert shortest_path([['R', 'R', 'B', 'R'], ['R', 'B', 'R', 'R'], ['R', 'R', 'R', 'B'], ['B', 'R', 'R', 'R']], (0, 0), (3, 3)) == [(0, 0), (0, 1), (1, 1), (2, 1), (2, 2), (3, 2), (3, 3)]\n", "\nassert shortest_path([['R', 'R', 'R'], ['R', 'B', 'R'], ['R', 'R', 'R']], (0, 0), (2, 2)) == [(0, 0), (0, 1), (0, 2), (1, ... |
e1ee781e23bebf4c45ee7a5cc731721e | [
{
"content": "On te donne une liste d'entiers représentant les températures quotidiennes sur une semaine. Ta tâche est de mettre en œuvre une fonction `calculate_average_temperature(temperatures)` qui calcule la température moyenne. Si la liste est vide, la fonction doit renvoyer 0. Ta solution doit être effica... | ["\nassert calculate_average_temperature([72, 75, 79, 80, 73, 68, 74]) == 74.0\n", "\nassert calculate_average_temperature([30, 30, 30, 30, 30, 30, 30]) == 30.0\n", "\nassert calculate_average_temperature([100, 0, 100, 0, 100, 0, 100]) == 50.0\n", "\nassert calculate_average_temperature([-10, -20, -30, -40, -50, -60, -... |
43dcda700c4ca4c0c1d28bbb1309eb48 | [
{
"content": "Tu es chargé d'implémenter une fonction pour calculer le chiffre de contrôle d'un format de numéro d'identification fictif inspiré du numéro d'identification personnel suédois (personnummer). Le format est [YY][MM][JJ]-[NNN], où [YY] sont les deux derniers chiffres de l'année de naissance, [MM] es... | ["\nassert get_luhn_check_digit(\"991231-123\") == 4\n", "\nassert get_luhn_check_digit(\"000101123\") == 4\n", "\nassert get_luhn_check_digit(\"991231123\") == 4\n", "\nassert get_luhn_check_digit(\"991331123\") == None # Invalid date\n", "\nassert get_luhn_check_digit(\"991231-12\") == None # Too few digits\n", "\n... |
7843528dfabe94142f3e6121cce117ee | [
{
"content": "On te donne une chaîne de caractères `s` au format kebab-case, où les mots sont séparés par des tirets (`-`). Ta tâche est de convertir cette chaîne au format pascal-case. En pascal-case, le premier mot doit être en minuscules et la première lettre de chaque mot suivant doit être en majuscules. Tu... | ["\nassert convert_case(\"hello-world\") == \"helloWorld\"\n", "\nassert convert_case(\"convert-this-string\") == \"convertThisString\"\n", "\nassert convert_case(\"python-is-fun\") == \"pythonIsFun\"\n", "\nassert convert_case(\"kebab-case-to-pascal-case\") == \"kebabCaseToPascalCase\"\n", "\nassert convert_case(\"sin... |
5ba2a8f7b4fc12e5a23bbb78d53394d2 | [
{
"content": "On te donne une chaîne de caractères `text` contenant des adresses et d'autres informations. Ta tâche est d'extraire tous les codes postaux américains valides de cette chaîne. Un code postal américain valide est un nombre à cinq chiffres qui peut être suivi d'un tiret et d'un nombre à quatre chiff... | ["\nassert extract_us_zip_codes(\"NY 10001\") == [\"10001\"]\n", "\nassert extract_us_zip_codes(\"CA 90001-1234\") == [\"90001-1234\"]\n", "\nassert extract_us_zip_codes(\"TX 78701 TX 78701\") == [\"78701\"]\n", "\nassert extract_us_zip_codes(\"TX 78701-5678 TX 78701-5678\") == [\"78701-5678\"]\n", "\nassert extract_us... |
4201992250f42b1269d7595db5c7898e | [
{
"content": "On te donne un tableau d'entiers qui peut contenir des doublons. Ta tâche est d'écrire une fonction récursive qui génère tous les sous-tableaux uniques du tableau donné. Un sous-tableau est défini comme un segment contigu du tableau. La fonction doit renvoyer une liste de tous les sous-tableaux un... | ["\nassert unique_subarrays([1, 2, 2]) == [[], [1], [2], [1, 2], [2, 2], [1, 2, 2]]\n", "\nassert unique_subarrays([1, 1, 1]) == [[], [1], [1, 1], [1, 1, 1]]\n", "\nassert unique_subarrays([1, 2, 3]) == [[], [1], [2], [3], [1, 2], [2, 3], [1, 2, 3]]\n", "\nassert unique_subarrays([]) == [[]]\n", "\nassert unique_subarr... |
c16167cb2cb954cb59d0c1c8292d8412 | [
{
"content": "On te donne un entier positif $n$. Ta tâche est d'écrire une fonction Python qui calcule le $n$ième nombre de Fibonacci en utilisant une approche itérative. La suite de Fibonacci est définie comme suit : $F(0) = 0$, $F(1) = 1$, et $F(n) = F(n-1) + F(n-2)$ pour $n \\geq 2$.\n\n**Entrée :**\n- Un se... | ["\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(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) ==... |
2325e2531e4836f4e5f93326b80871c1 | [
{
"content": "On te demande d'implémenter une fonction `calculate_cumulative_reward_v2` pour un scénario d'apprentissage par renforcement. La fonction doit calculer la récompense cumulée actualisée pour chaque étape effectuée par un agent dans un environnement. La fonction accepte trois paramètres :\n\n- `max_l... | ["\nassert torch.allclose(calculate_cummulate_reward_v2(3, 1.0, [1, 2, 3]), torch.tensor([1.0, 3.0, 6.0]))\n", "\nassert torch.allclose(calculate_cummulate_reward_v2(4, 0.5, [1, 1, 1, 1]), torch.tensor([1.0, 1.5, 1.75, 1.875]))\n", "\nassert torch.allclose(calculate_cummulate_reward_v2(5, 0.9, [0, 0, 0, 0, 0]), torch.t... |
70da3c6146a00c3ed4e6600e084a7037 | [
{
"content": "On te demande d'implémenter la fonction `format_sentence`. Cette fonction doit traiter une chaîne de caractères donnée `sentence` en la divisant en fonction d'un `delimiter` spécifié. Si la `sentence` contient plusieurs occurrences consécutives du `delimiter`, elles doivent être traitées comme un ... | ["\nassert format_sentence(\"hello,world\", \",\") == \"hello world\"\n", "\nassert format_sentence(\"hello,,world\", \",\") == \"hello world\"\n", "\nassert format_sentence(\"hello,,,world\", \",\") == \"hello world\"\n", "\nassert format_sentence(\"hello...world\", \".\") == \"hello world\"\n", "\nassert format_sente... |
1e8aa685cf0372a83055018ffc380842 | [
{
"content": "On te donne une chaîne de caractères représentant une date et une heure au format MS-DOS. La chaîne est composée de deux entiers séparés par un espace. Le premier entier encode le jour, le mois et l'année, tandis que le second entier encode l'heure, la minute et la seconde. Ta tâche est de convert... | ["\nassert convert_ms_dos_datetime(\"3224 12345\") == datetime(1985, 7, 14, 15, 25, 30)\n", "\nassert convert_ms_dos_datetime(\"2124 11111\") == datetime(1981, 1, 1, 10, 33, 34)\n", "\nassert convert_ms_dos_datetime(\"7681 54321\") == datetime(1984, 2, 29, 22, 45, 42)\n", "\nassert convert_ms_dos_datetime(\"1 0\") == d... |
a2ee915a58c5424df2c2244f89f00439 | [
{
"content": "On te donne deux chaînes de caractères, `s1` et `s2`. Ta tâche est de calculer la similarité entre ces deux chaînes en utilisant la formule suivante :\n\n\\[ \\text{similarité} = 1 - \\left(\\frac{\\text{distance\\_d'édition}}{\\text{longueur\\_maximale}}\\right) \\]\n\noù `distance_d'édition` est... | ["\nassert calculate_similarity(\"abc\", \"abc\") == 1.0\n", "\nassert calculate_similarity(\"abc\", \"abcd\") == 0.75\n", "\nassert calculate_similarity(\"abc\", \"def\") == 0.0\n", "\nassert calculate_similarity(\"\", \"\") == 1.0\n", "\nassert calculate_similarity(\"a\", \"b\") == 0.0\n", "\nassert calculate_similar... |
53af1658415c29f4247cd7b717bb3963 | [
{
"content": "On te demande d'implémenter une fonction pour générer la suite de Fibonacci jusqu'au n-ième nombre en utilisant une approche itérative. La suite de Fibonacci est une série de nombres où chaque nombre est la somme des deux nombres précédents, commençant généralement par 0 et 1. Ta fonction doit pre... | ["\nassert fibonacci_sequence(0) == []\n", "\nassert fibonacci_sequence(1) == [0]\n", "\nassert fibonacci_sequence(2) == [0, 1]\n", "\nassert fibonacci_sequence(3) == [0, 1, 1]\n", "\nassert fibonacci_sequence(4) == [0, 1, 1, 2]\n", "\nassert fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci_sequence(6) ... |
0dd50cf4c9968584e762117ac3a9d2d0 | [
{
"content": "On te donne deux matrices, `A` et `B`, chacune ayant des dimensions de `n x m`. Ta tâche est d'écrire une fonction `matrix_multiplication(A, B)` qui effectue la multiplication élément par élément de ces matrices. La fonction doit gérer efficacement les grandes matrices sans dépasser les limites de... | ["\nassert (matrix_multiplication(np.array([[1, 2], [3, 4]]), np.array([[5, 6], [7, 8]])) == np.array([[5, 12], [21, 32]])).all()\n", "\nassert (matrix_multiplication(np.array([[0, 0], [0, 0]]), np.array([[1, 2], [3, 4]])) == np.array([[0, 0], [0, 0]])).all()\n", "\nassert (matrix_multiplication(np.array([[1, 1], [1, 1... |
5adf415be1e271d9b7a126bf0684e472 | [
{
"content": "Tu participes à une compétition de machine learning où l'on te fournit un modèle d'apprentissage profond pré-entraîné pour la classification d'images. Le modèle a été entraîné pendant un certain nombre d'époques, et le processus d'entraînement a été sauvegardé à différents points de contrôle. Ta t... | ["\nassert update_training_state({'early_stopping_criteria': 3}, None, {'epoch_index': 0, 'model_filename': 'model.pth', 'dev_loss': [0.5], 'early_stopping': False, 'early_stopping_step': 0, 'early_stopping_best_val': 0.5})['early_stopping'] == False\n", "\nassert update_training_state({'early_stopping_criteria': 3}, N... |
51c73d5260f1b7413924c1870b11de65 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `add_numbers` qui calcule la somme de tous les entiers positifs uniques dans la liste. Si la liste contient des entiers négatifs dupliqués, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers `numbers... | ["\nassert add_numbers([1, 2, 3, 4, 5]) == 15\n", "\nassert add_numbers([-1, -2, -3, -4, -5]) is None\n", "\nassert add_numbers([1, -1, 2, -2, 3, -3]) is None\n", "\nassert add_numbers([1, 1, 2, 2, 3, 3]) == 6\n", "\nassert add_numbers([-1, 2, -2, 3, 4, 5]) == 14\n", "\nassert add_numbers([0, 0, 0, 0]) == 0\n", "\nasse... |
43b63254445bcf67ac2e7865cd5e6072 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver et de renvoyer le deuxième plus grand nombre unique de la liste. Si la liste ne contient pas au moins deux nombres uniques, renvoie `None`.\n\n**Exemple d'entrée :**\n```\n[3, 1, 4, 4, 5, 5, 2]\n```\n\n**Exemple de sortie :**\n```\n4\n```\n\... | ["\nassert second_largest([3, 1, 4, 4, 5, 5, 2]) == 4\n", "\nassert second_largest([10, 20, 20, 30, 30]) == 20\n", "\nassert second_largest([1, 2, 3, 4, 5]) == 4\n", "\nassert second_largest([5, 5, 5, 5, 5]) == 5\n", "\nassert second_largest([100]) == 100\n", "\nassert second_largest([1, 1, 2, 2, 3, 3, 4, 4]) == 3\n", ... |
0cc49e19568ebbfc819c0ac4ea71540c | [
{
"content": "On te demande d'implémenter la fonction `calculate_arm_lengths` pour gérer efficacement jusqu'à 10 000 positions et rotations cibles pour un bras robotique. La fonction doit calculer les longueurs de trois bras nécessaires pour positionner l'effecteur terminal à la `target_position` spécifiée avec... | ["\nassert calculate_arm_lengths(np.array([0, 0, 0]), np.array([3, 4, 0]), np.eye(3)) == 5.0\n", "\nassert calculate_arm_lengths(np.array([1, 1, 1]), np.array([4, 5, 6]), np.eye(3)) == np.sqrt(27)\n", "\nassert calculate_arm_lengths(np.array([0, 0, 0]), np.array([0, 0, 0]), np.eye(3)) == 0.0\n", "\nassert calculate_arm... |
7e969866f448baed1c06d303c2e1fe6f | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui renvoie le nombre de mots distincts dans la chaîne. Les mots sont considérés sans tenir compte de la casse et la ponctuation doit être ignorée.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10^5), c... | ["\nassert count_distinct_words(\"Hello, world! Hello, Universe!\") == 3\n", "\nassert count_distinct_words(\"Python, python, PYTHON!\") == 1\n", "\nassert count_distinct_words(\"A quick brown fox jumps over the lazy dog.\") == 8\n", "\nassert count_distinct_words(\"To be or not to be, that is the question.\") == 10\n"... |
bd3b73c95638ac653ea0111b70c53e69 | [
{
"content": "On te donne une fonction `is_palindrome(s)` qui vérifie si une chaîne de caractères `s` est un palindrome. Une chaîne est considérée comme un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche. Ta tâche est d'écrire une suite de tests unitaires complète pour cett... | ["\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"level\") == True\n", "\nassert is_palindrome(\"\") == True\n", "\nassert is_palindrome(\"hello\") == False\n", "\nassert is_palindrome(\"world\") == False\n", "\nassert is_palindrome(\"test\") == False\n", "\nassert is_palindrome(\"a\") == True... |
b3672784cb46353ac283aacbd19b9c41 | [
{
"content": "On te donne un dictionnaire représentant le dossier scolaire d'un étudiant, où les clés sont les noms des matières et les valeurs sont les notes obtenues par l'étudiant dans ces matières. Ta tâche est de trier le dictionnaire par notes par ordre décroissant et de le convertir en une chaîne formaté... | ["\nassert sort_and_convert_to_json({'Math': 88, 'Science': 92, 'History': 78, 'Art': 95, 'Physical Education': 82}) == '{\\n \"Art\": 95,\\n \"Science\": 92,\\n \"Math\": 88,\\n \"Physical Education\": 82,\\n \"History\": 78\\n}'\n", "\nassert sort_and_convert_to_json({'English': 70, 'Math': 80, 'Scienc... |
bd61ace5f2e9af539c89d7d56ff1bf94 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres majuscules et minuscules. Ta tâche est de réorganiser les caractères de la chaîne pour former le palindrome sensible à la casse le plus long possible. Chaque caractère utilisé dans le palindrome doit apparaître au moins trois fois, à l'e... | ["\nassert longest_case_sensitive_palindrome(\"AabbcccAAaabb\") == \"Aaabbbcccbaaa\"\n", "\nassert longest_case_sensitive_palindrome(\"abc\") == \"\"\n", "\nassert longest_case_sensitive_palindrome(\"aaabbbccc\") == \"aaabbbcccbaaa\"\n", "\nassert longest_case_sensitive_palindrome(\"aabbcc\") == \"\"\n", "\nassert long... |
89ab7015e72d92100289951723d4272a | [
{
"content": "On te demande d'implémenter une fonction `sanitize_input(input_string)` qui traite une chaîne de caractères donnée selon les règles suivantes :\n- Convertis tous les caractères alphabétiques en minuscules.\n- Supprime tous les caractères spéciaux à l'exception des espaces, des tirets (-), des unde... | ["\nassert sanitize_input(\"Hello, World!\") == \"hello world\"\n", "\nassert sanitize_input(\" Python3.8 \") == \"python3.8\"\n", "\nassert sanitize_input(\"Special_Characters-Here!\") == \"special_characters-here\"\n", "\nassert sanitize_input(\"NoSpecialChars\") == \"nospecialchars\"\n", "\nassert sanitize_input(\... |
afb51680ee296101ee46a4a96c5015e0 | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python. La classe doit encapsuler les propriétés d'un rectangle, en particulier sa largeur et sa hauteur, et fournir des méthodes pour calculer son aire et son périmètre, mettre à l'échelle ses dimensions et le comparer à d'autres rectangles po... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).perimeter() == 20\n", "\nassert Rectangle(2, 3).scale(2) is None and Rectangle(2, 3).width == 4 and Rectangle(2, 3).height == 6\n", "\nassert Rectangle(1, 1) == Rectangle(1, 1)\n", "\nassert Rectangle(2, 3) != Rectangle(3, 2)\n", "\nassert str(Rectan... |
4a48d1b35b2829e9c01b5dca475c2e27 | [
{
"content": "On te demande d'implémenter une fonction `classify_emails` qui utilise un modèle d'apprentissage automatique pré-entraîné pour classifier une liste d'adresses e-mail comme étant soit \"spam\", soit \"légitime\". La fonction doit utiliser une fonction `predict_label` fournie qui prend une seule adr... | ["\nassert classify_emails([\"example@example.com\"]) == [\"legitimate\"]\n", "\nassert classify_emails([\"spam@spam.com\"]) == [\"spam\"]\n", "\nassert classify_emails([\"legit@legit.com\", \"spam@spam.com\"]) == [\"legitimate\", \"spam\"]\n", "\nassert classify_emails([\"user1@domain.com\", \"user2@domain.com\"]) == ... |
fac493b72e26b437b0c24601159399d7 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui simule des opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n- **Dépôt** : Ajouter un montant spécifié au solde du compte. L'opération de dépôt ne doit réussir que si le montant est pos... | ["\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount(100).check_balance() == 100\n", "\nassert BankAccount().deposit(50) == True\n", "\nassert BankAccount().deposit(-10) == False\n", "\nassert BankAccount(100).withdraw(50) == True\n", "\nassert BankAccount(100).withdraw(150) == False\n", "\nassert Ba... |
ce81f3bd7e5306c8efd1b703dab5ff48 | [
{
"content": "On te demande d'implémenter une fonction `probable_prime(n, k)` en Python. Cette fonction doit déterminer si un nombre `n` est probablement premier en utilisant une version modifiée du test de primalité de Miller-Rabin. Au lieu d'utiliser des bases aléatoires, le test doit utiliser les `k` premier... | ["\nassert probable_prime(2, 5) == True\n", "\nassert probable_prime(3, 5) == True\n", "\nassert probable_prime(5, 5) == True\n", "\nassert probable_prime(7, 5) == True\n", "\nassert probable_prime(11, 5) == True\n", "\nassert probable_prime(15, 5) == False\n", "\nassert probable_prime(17, 5) == True\n", "\nassert prob... |
f2108749512c9cb2f2f7044ae837455f | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de déterminer si la liste représente une vallée en considérant uniquement les entiers non négatifs. Une vallée est définie comme une séquence de nombres où il y a un seul élément minimum qui est strictement entouré de nombres croissants des deux côtés.... | ["\nassert is_valley([3, 2, 1, 0, 1, 2, 3]) == True\n", "\nassert is_valley([5, 4, 3, 2, 1, 0, 1, 2]) == False\n", "\nassert is_valley([1, 2, 3, 4, 5]) == False\n", "\nassert is_valley([5, 4, 3, 2, 1]) == False\n", "\nassert is_valley([1, 2, 1]) == True\n", "\nassert is_valley([1, 0, 1]) == True\n", "\nassert is_valley... |
fcac680058fa91c758d98b8e80b90f87 | [
{
"content": "On te demande d'implémenter une fonction `getFilePath(file)` qui navigue dans une structure arborescente représentant un système de fichiers. Chaque nœud de l'arbre est soit un `FileNode` soit un `DirectoryNode`. Le `FileNode` représente un fichier et contient un attribut `name` et un attribut `pa... | ["\nassert getFilePath(None) == \"None\"\n", "\nassert getFilePath(FileNode(\"file1\", None)) == \"/file1\"\n", "\nassert getFilePath(FileNode(\"file2\", DirectoryNode(\"dir1\", None, []))) == \"/dir1/file2\"\n", "\nassert getFilePath(FileNode(\"file3\", DirectoryNode(\"dir2\", DirectoryNode(\"dir1\", None, []), []))) ... |
fd968100fda9c115ba2077b4976de9a8 | [
{
"content": "On te donne une liste de `n` éléments à afficher dans une grille. L'objectif est de déterminer le nombre optimal de colonnes de sorte que la différence entre le nombre maximum et le nombre minimum d'éléments par colonne soit minimisée. Les contraintes sont les suivantes :\n- Si `n` est inférieur o... | ["\nassert optimal_columns([1, 2, 3, 4, 5]) == (5, 1)\n", "\nassert optimal_columns([1, 2, 3, 4, 5, 6]) == (3, 2)\n", "\nassert optimal_columns([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == (5, 2)\n", "\nassert optimal_columns([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) == (5, 3)\n", "\nassert optimal_columns([1, 2, 3]) == (3, 1)\n", "... |
22973fcb4a0e5a994467744011e1f1a6 | [
{
"content": "On te donne une liste de chaînes de caractères `phrases`. Ta tâche est de mettre en œuvre une fonction `find_longest_palindrome(phrases)` qui identifie et renvoie la plus longue sous-chaîne palindromique de l'une des chaînes de caractères de la liste. S'il y a plusieurs sous-chaînes palindromiques... | ["\nassert find_longest_palindrome([\"racecar\", \"banana\", \"civic\", \"level\", \"rotor\", \"kayak\"]) == \"racecar\"\n", "\nassert find_longest_palindrome([\"noon\", \"madam\", \"refer\", \"deified\"]) == \"deified\"\n", "\nassert find_longest_palindrome([\"abc\", \"def\", \"ghi\"]) == \"\"\n", "\nassert find_longe... |
d45dfedccfd0e154e7d0090fea2587a6 | [
{
"content": "Tu développes un programme de fidélité pour un magasin de détail. Le programme calcule le nombre de points de fidélité qu'un client gagne en fonction de ses montants d'achat cumulés sur une année. Chaque dollar dépensé rapporte au client 1 point de fidélité. De plus, si le volume des ventes mensue... | ["\nassert calculate_loyalty_points([100, 200, 300], [500000, 1500000, 2500000]) == 120\n", "\nassert calculate_loyalty_points([50, 50, 50], [1000000, 1000000, 1000000]) == 15\n", "\nassert calculate_loyalty_points([10, 20, 30], [900000, 1100000, 1200000]) == 6\n", "\nassert calculate_loyalty_points([1000, 2000, 3000],... |
b29fd80c06e20cf115fbe4a4986775b3 | [
{
"content": "On te demande d'implémenter une fonction `generate_query` qui construit un dictionnaire de requête pour un utilisateur spécifique dans une base de données. La fonction doit accepter les paramètres suivants :\n- `user_id` : une chaîne de caractères représentant l'identifiant unique de l'utilisateur... | ["\nassert generate_query(\"user123\", True, 404) == {'user_id': 'user123', 'refresh': True, 'ignore': 404}\n", "\nassert generate_query(\"user456\", False, 500) == {'user_id': 'user456', 'refresh': False, 'ignore': 500}\n", "\nassert generate_query(\"user789\", True, 403, [\"user123\", \"user456\"]) == {'user_id': 'us... |
d40bbddb2e7979158e6b879555d1df26 | [
{
"content": "On te demande d'implémenter une fonction qui encode des données pour une requête HTTP POST multipart. La fonction doit accepter un dictionnaire où les clés sont les noms des champs et les valeurs sont soit des chaînes de caractères, soit des tuples (nom de fichier, contenu, checksum) pour le téléc... | ["\nassert encode_multipart_form_data({'field1': 'value1'})[0].startswith('------WebKitFormBoundary')\n", "\nassert encode_multipart_form_data({'field1': 'value1'})[0].endswith('--\\r\\n')\n", "\nassert 'Content-Disposition: form-data; name=\"field1\"' in encode_multipart_form_data({'field1': 'value1'})[0]\n", "\nasser... |
ea08cf6684af069d855ebade2848eaf6 | [
{
"content": "On te donne deux entiers positifs, `i` et `j`. Ta tâche est de calculer la longueur de la séquence de Collatz pour chaque entier dans l'intervalle `[i, j]` inclus. La séquence de Collatz est définie comme suit :\n\n- Si le nombre `n` est pair, le nombre suivant dans la séquence est `n / 2`.\n- Si ... | ["\nassert collatz_sequence_length(1, 1) == [1]\n", "\nassert collatz_sequence_length(1, 5) == [1, 2, 8, 3, 6]\n", "\nassert collatz_sequence_length(2, 2) == [2]\n", "\nassert collatz_sequence_length(3, 3) == [8]\n", "\nassert collatz_sequence_length(4, 4) == [3]\n", "\nassert collatz_sequence_length(5, 5) == [6]\n", "... |
809f3867855798b7e08eda5aea130de2 | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction qui compte le nombre de mots uniques dans la chaîne, en ignorant la sensibilité à la casse et la ponctuation.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10^... | ["\nassert count_unique_words(\"Hello, hello world!\") == 2\n", "\nassert count_unique_words(\"Python, python, PYTHON!\") == 1\n", "\nassert count_unique_words(\"This is a test. This test is only a test.\") == 6\n", "\nassert count_unique_words(\"One fish, two fish, red fish, blue fish.\") == 5\n", "\nassert count_uniq... |
29bcd40edfc2206fc28c835beb756a39 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de déterminer l'intersection de ces deux listes, y compris les valeurs dupliquées, après avoir supprimé tous les nombres premiers des deux listes. L'intersection résultante doit être triée par ordre décroissant.\n\n**Entrée :**\n-... | ["\nassert intersection_non_primes([2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 7], [5, 6, 7, 8, 9, 10, 11, 12, 7]) == [10, 10, 8, 7, 7, 6]\n", "\nassert intersection_non_primes([2, 3, 5, 7, 11], [2, 3, 5, 7, 11]) == []\n", "\nassert intersection_non_primes([4, 6, 8, 9, 10], [4, 6, 8, 9, 10]) == [10, 9, 8, 6, 4]\n", "\nassert inte... |
0889eee95420a94852c6cf2fdaa53966 | [
{
"content": "Implémente une classe `Stack` et une classe `Queue` avec les méthodes suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et retourne l'élément du sommet de la pile. Si la pile est vide, retourne `None`.\n- `peek()` : Retourne l'élément du sommet de la pile ... | ["\nassert stack.size() == 2\n", "\nassert stack.peek() == \"Plate 2\"\n", "\nassert stack.pop() == \"Plate 2\"\n", "\nassert stack.is_empty() == False\n", "\nassert stack.pop() == \"Plate 1\"\n", "\nassert stack.is_empty() == True\n", "\nassert queue.size() == 2\n", "\nassert queue.front() == \"Person 2\"\n", "\nasser... |
390dba8ec76e8eb01ad72d88ccdf0c2e | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `calculate_statistics` qui calcule la moyenne, la médiane et le mode de la liste. La fonction doit renvoyer un dictionnaire avec les clés `'mean'`, `'median'`, et `'mode'` correspondant à leurs valeurs respectives. Si la list... | ["\nassert calculate_statistics([1, 2, 2, 3, 4]) == {'mean': 2.4, 'median': 2, 'mode': 2}\n", "\nassert calculate_statistics([5, 5, 5, 5, 5]) == {'mean': 5, 'median': 5, 'mode': 5}\n", "\nassert calculate_statistics([1, 1, 2, 3, 4, 5, 5]) == {'mean': 3, 'median': 3, 'mode': 1}\n", "\nassert calculate_statistics([10, 20... |
cc00e542427160d5bdcec904aee90a21 | [
{
"content": "On te donne une chaîne de caractères `text` composée de divers caractères. Ta tâche est de mettre en œuvre une fonction `extract_numbers_from_string(text)` qui identifie et renvoie une liste de tous les nombres autonomes présents dans la chaîne. Un nombre autonome est défini comme une séquence de ... | ["\nassert extract_numbers_from_string(\"I have 2 apples and 34 oranges.\") == [2, 34]\n", "\nassert extract_numbers_from_string(\"No numbers here!\") == []\n", "\nassert extract_numbers_from_string(\"123abc456\") == []\n", "\nassert extract_numbers_from_string(\"abc123def456\") == []\n", "\nassert extract_numbers_from... |
b7182f6f84c112e68d2919f797d75845 | [
{
"content": "On te donne une liste d'entiers et une valeur d'incrémentation. Ta tâche est d'écrire une fonction qui renvoie une nouvelle liste où chaque entier de la liste originale est incrémenté de la valeur donnée.\n\n**Signature de la fonction :** `def increment_list_by_value(int_list, increment):`\n\n**En... | ["\nassert increment_list_by_value([1, 2, 3], 5) == [6, 7, 8]\n", "\nassert increment_list_by_value([0, 0, 0], 1) == [1, 1, 1]\n", "\nassert increment_list_by_value([-1, -2, -3], 3) == [2, 1, 0]\n", "\nassert increment_list_by_value([10, 20, 30], -10) == [0, 10, 20]\n", "\nassert increment_list_by_value([], 5) == []\n"... |
910bd2bf06ffb2282f563bdd67d9df22 | [
{
"content": "On te donne une liste d'entiers `data` et deux entiers positifs `chunk_size` et `max_sum`. Ta tâche est de partitionner la liste en blocs de telle sorte que chaque bloc, sauf éventuellement le dernier, ait une somme inférieure ou égale à `max_sum`. De plus, chaque bloc doit contenir au plus `chunk... | ["\nassert chunk_data([1, 2, 3, 4, 5], 2, 10) == [[1, 2], [3, 4], [5]]\n", "\nassert chunk_data([1, 2, 3, 4, 5], 3, 10) == [[1, 2, 3], [4, 5]]\n", "\nassert chunk_data([1, 2, 3, 4, 5], 2, 3) == [[1, 2], [3], [4], [5]]\n", "\nassert chunk_data([10, 20, 30, 40, 50], 2, 25) == [[10], [20], [30], [40], [50]]\n", "\nassert ... |
8fe1960889a0fcd66cb9f693c1809f7f | [
{
"content": "On te donne un dictionnaire contenant les informations d'une personne. Ta tâche est d'écrire une fonction Python qui formate ces informations en une chaîne de caractères. Le dictionnaire aura les clés suivantes : \"first_name\", \"last_name\", \"age\" et \"address\". La fonction doit renvoyer une ... | ["\nassert format_person_info({\"first_name\": \"John\", \"last_name\": \"Doe\", \"age\": 28, \"address\": \"456 Elm St, Othertown, USA\"}) == \"Full Name: John Doe\\nAge: 28\\nAddress: 456 Elm St, Othertown, USA\"\n", "\nassert format_person_info({\"first_name\": \"Alice\", \"last_name\": \"Smith\", \"age\": 45, \"add... |
b04b229187d1121fb061df5a69716c55 | [
{
"content": "On te demande d'implémenter une fonction `parse_csv` qui traite un fichier CSV et renvoie une liste de dictionnaires. Chaque dictionnaire correspond à une ligne du fichier CSV, avec des clés représentant les en-têtes de colonnes et des valeurs représentant les entrées de chaque ligne. La fonction ... | ["\nassert parse_csv('test.csv', delimiter=',') == [{'name': 'Alice', 'age': '30', 'city': 'New York'}, {'name': 'Bob', 'age': None, 'city': 'Los Angeles'}]\n", "\nassert parse_csv('test.csv', delimiter=';') == [{'name': 'Alice', 'age': '30', 'city': 'New York'}, {'name': 'Bob', 'age': None, 'city': 'Los Angeles'}]\n",... |
2e4a8c59687a2ee275b506374943fda0 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `k`. Ta tâche est de déterminer la somme maximale de tout sous-tableau contigu de longueur `k`. Si la longueur de `nums` est inférieure à `k`, renvoie `0`.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), le nombre d'é... | ["\nassert max_sum_subarray([1, 4, 2, 10, 23, 3, 1, 0, 20], 4) == 39\n", "\nassert max_sum_subarray([2, 3, 5, 2, 8, 1, 5], 3) == 17\n", "\nassert max_sum_subarray([1, 2, 3, 4, 5], 5) == 15\n", "\nassert max_sum_subarray([1, 2, 3, 4, 5], 6) == 0\n", "\nassert max_sum_subarray([], 1) == 0\n", "\nassert max_sum_subarray([... |
6f1cd548dc67fc5ea4ed712b2ae96be2 | [
{
"content": "On te demande d'implémenter une fonction génératrice en Python qui génère la suite de Fibonacci jusqu'à une valeur maximale spécifiée `max_value`. La suite de Fibonacci commence par 0 et 1, et chaque nombre suivant est la somme des deux nombres précédents. Ta fonction génératrice doit être nommée ... | ["\nassert list(fibonacci_sequence(0)) == [0]\n", "\nassert list(fibonacci_sequence(1)) == [0, 1, 1]\n", "\nassert list(fibonacci_sequence(2)) == [0, 1, 1, 2]\n", "\nassert list(fibonacci_sequence(10)) == [0, 1, 1, 2, 3, 5, 8]\n", "\nassert list(fibonacci_sequence(15)) == [0, 1, 1, 2, 3, 5, 8, 13]\n", "\nassert list(fi... |
6c40bdf1fcd1f815c8c8060cb5c2d8d7 | [
{
"content": "On te donne un objet JSON qui peut contenir des structures imbriquées. Ta tâche est d'écrire une fonction Python qui extrait toutes les valeurs associées à une clé spécifiée. La fonction doit gérer à la fois les dictionnaires et les listes imbriqués.\n\n**Entrée :**\n- Un objet JSON (dictionnaire)... | ["\nassert extract_values({\"name\": \"Alice\", \"details\": {\"name\": \"Bob\", \"age\": 30}}, \"name\") == [\"Alice\", \"Bob\"]\n", "\nassert extract_values({\"name\": \"Alice\", \"details\": {\"name\": \"Bob\", \"age\": 30}}, \"age\") == [30]\n", "\nassert extract_values({\"name\": \"Alice\", \"details\": {\"name\":... |
37e261ee49df1922c9a1c483be104e8b | [
{
"content": "On te donne une chaîne binaire `bin_str` de longueur `n`, où `n` est un multiple de 8. Ta tâche est de convertir cette chaîne binaire en sa représentation hexadécimale sans utiliser de fonctions de conversion intégrées. La sortie doit être en majuscules.\n\n**Entrée :**\n- Une seule ligne contenan... | ["\nassert binary_to_hex(\"00000000\") == \"00\"\n", "\nassert binary_to_hex(\"11111111\") == \"FF\"\n", "\nassert binary_to_hex(\"1010101010101010\") == \"AAAA\"\n", "\nassert binary_to_hex(\"0101010101010101\") == \"5555\"\n", "\nassert binary_to_hex(\"1100110011001100\") == \"CCCC\"\n", "\nassert binary_to_hex(\"001... |
4237df10ac3fb1b5c3b54b8fab5d45a5 | [
{
"content": "On te demande d'implémenter une fonction `generate_memory_fill_command(address, value, size)` qui construit une chaîne de commande de remplissage de mémoire formatée. La commande doit inclure l'adresse mémoire, la valeur à remplir, la taille du bloc de mémoire et un checksum. Le checksum est la so... | ["\nassert generate_memory_fill_command(0x1000, 0xFF, 256) == \"fill_memory_command {\\n\taddress: 0x1000,\\n\tvalue: 0xFF,\\n\tsize: 256,\\n\tchecksum: 4095,\\n}\"\n", "\nassert generate_memory_fill_command(0x0, 0x0, 0) == \"fill_memory_command {\\n\taddress: 0x00000000,\\n\tvalue: 0x00,\\n\tsize: 0,\\n\tchecksum: 0,\... |
cfceb59f59016b95168b317c9452de65 | [
{
"content": "On te donne un fichier CSV nommé `data.csv` situé dans le même répertoire que ton script. Le fichier contient des données numériques avec des en-têtes. Ta tâche est d'écrire un script Python qui lit ce fichier CSV et calcule la moyenne des valeurs de chaque colonne. Si une colonne contient des val... | ["\ncreate_csv_file('data.csv', [['A', 'B'], ['1', '2'], ['3', '4']])\nold_stdout = sys.stdout\nnew_stdout = io.StringIO()\nsys.stdout = new_stdout\ncalculate_column_averages('data.csv')\noutput = new_stdout.getvalue().strip()\nsys.stdout = old_stdout\nassert output == \"Average of column 'A': 2.0\\nAverage of column '... |
9a5311b5473a9eb2e00d73a3afdd51f3 | [
{
"content": "On te donne une liste d'octets, `byte_list`, où chaque octet est un entier compris entre 0 et 255 (inclus). Ta tâche est d'écrire une fonction `calculate_little_endian_integer(byte_list)` qui calcule la représentation entière non signée little endian des octets. Dans le format little endian, l'oct... | ["\nassert calculate_little_endian_integer([1, 2]) == 513\n", "\nassert calculate_little_endian_integer([0, 0, 0, 0]) == 0\n", "\nassert calculate_little_endian_integer([255, 255, 255, 255]) == 4294967295\n", "\nassert calculate_little_endian_integer([1]) == 1\n", "\nassert calculate_little_endian_integer([255]) == 255... |
ffd590c9ecb60af61cd80926c2509dac | [
{
"content": "On te donne une liste de chaînes de caractères `words`. Ta tâche est de déterminer le nombre de groupes d'anagrammes distincts dans la liste. Deux chaînes de caractères sont considérées comme des anagrammes si elles sont composées des mêmes caractères dans n'importe quel ordre. Par exemple, \"list... | ["\nassert count_anagrams([\"listen\", \"silent\", \"enlist\"]) == 1\n", "\nassert count_anagrams([\"google\", \"gooegl\"]) == 1\n", "\nassert count_anagrams([\"rat\", \"tar\", \"art\"]) == 1\n", "\nassert count_anagrams([\"abc\", \"def\", \"ghi\"]) == 3\n", "\nassert count_anagrams([\"a\", \"a\", \"a\", \"a\"]) == 1\n... |
7b45cef2024ced706a40ffb57fb88a7d | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères Unicode. Ta tâche est de concevoir une fonction qui calcule un identifiant entier positif unique et déterministe pour cette chaîne. L'identifiant doit être différent pour les chaînes qui diffèrent même d'un seul caractère et doit teni... | ["\nassert generate_identifier(\"hello\") == 2520069434\n", "\nassert generate_identifier(\"world\") == 3259316358\n", "\nassert generate_identifier(\"hello world\") == 2731928795\n", "\nassert generate_identifier(\"\u4f60\u597d\") == 2241406495\n", "\nassert generate_identifier(\"\u4e16\u754c\") == 3818355035\n", "\na... |
f9fe1bf9adda8312a94f163d274eeb61 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `calculate_statistics` qui calcule et renvoie un dictionnaire contenant les mesures statistiques suivantes pour la liste : la moyenne, la médiane, le mode, l'écart type, la valeur minimale et la valeur maximale. S'il n'y a pa... | ["\nassert calculate_statistics([1, 2, 2, 3, 4, 5, 5, 5, 6]) == {\"mean\": 3.7777777777777777, \"median\": 4, \"mode\": 5, \"standard_deviation\": 1.690308509457033, \"minimum\": 1, \"maximum\": 6}\n", "\nassert calculate_statistics([10, 20, 30, 40, 50]) == {\"mean\": 30, \"median\": 30, \"mode\": None, \"standard_devi... |
76be71607b73a06e51e18b2369e41fca | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui renvoie le premier caractère non répétitif dans la chaîne. S'il n'y a pas un tel caractère, renvoie `None`.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10^5), composée de lettres minuscules de l'a... | ["\nassert first_non_repeating_character(\"swiss\") == \"w\"\n", "\nassert first_non_repeating_character(\"aabbcc\") == None\n", "\nassert first_non_repeating_character(\"abcdef\") == \"a\"\n", "\nassert first_non_repeating_character(\"aabbccddee\") == None\n", "\nassert first_non_repeating_character(\"aabbccddeef\") =... |
36d590d1126615807fbff52dfaa96d3c | [
{
"content": "On te donne une liste de fichiers représentée comme une liste de dictionnaires, où chaque dictionnaire contient les clés \"name\" et \"path\" représentant le nom du fichier et son chemin d'accès, respectivement. Ta tâche est d'implémenter une fonction `filter_files` qui filtre les fichiers en fonc... | ["\nassert filter_files([{\"name\": \"document.txt\", \"path\": \"/home/user/documents/\"}], \"*.jpg\") == [{\"name\": \"document.txt\", \"path\": \"/home/user/documents/\"}]\n", "\nassert filter_files([{\"name\": \"image.jpg\", \"path\": \"/home/user/images/\"}], \"*.jpg\") == []\n", "\nassert filter_files([{\"name\":... |
c49674b3d8a6c722225e963f037749da | [
{
"content": "On te donne une réponse HTTP/1.1 bien formée sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction `parse_http_response(response)` qui analyse cette réponse et renvoie un dictionnaire avec les clés suivantes :\n- `status_code` : Un entier représentant le code d'état HTTP.\n- `reas... | ["\nassert parse_http_response(\"HTTP/1.1 200 OK\\r\\nContent-Type: text/html\\r\\n\\r\\n<html><body><h1>Hello, World!</h1></body></html>\") == {'status_code': 200, 'reason_phrase': 'OK', 'headers': {'Content-Type': 'text/html'}, 'body': '<html><body><h1>Hello, World!</h1></body></html>'}\n", "\nassert parse_http_respo... |
6590770719cb5a8edef00c7eb14c43e6 | [
{
"content": "On te donne une liste de noms de fichiers `files_list` et un entier `n_items`. Ta tâche est d'implémenter une fonction `weighted_random_split` qui sélectionne `n_items` noms de fichiers dans `files_list` avec une probabilité proportionnelle à la longueur de chaque nom de fichier. La fonction doit ... | ["\nassert weighted_random_split(['file1', 'file2', 'file3'], 0) == (['file1', 'file2', 'file3'], [])\n", "\nassert weighted_random_split(['file1', 'file2', 'file3'], 3) == ([], ['file1', 'file2', 'file3'])\n", "\nassert len(weighted_random_split(['file1', 'file2', 'file3', 'file4'], 2)[0]) == 2\n", "\nassert len(weigh... |
e37a8f341ba9cf61c21119204eb3c782 | [
{
"content": "On te demande d'implémenter une fonction pour déterminer si une chaîne de caractères donnée est une adresse IPv4 valide. Une adresse IPv4 valide doit respecter les critères suivants :\n1. Elle consiste en exactement quatre nombres décimaux, séparés par des points (\".\").\n2. Chaque nombre décimal... | ["\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.256.256.256\") == False\n", "\nassert is_valid_ipv4(\"192.168.1\") == False\n", "\nassert is_valid_ipv4(\"192.168.1.1.1\") == Fals... |
af59cadcb3284023a2643f50d556551b | [
{
"content": "On te donne une grille 4x4 où chaque cellule peut contenir un chiffre de 1 à 4 ou être vide (représentée par 0). Ta tâche est de remplir la grille de telle sorte que chaque ligne, chaque colonne et chacune des quatre sous-grilles 2x2 contienne exactement une instance de chaque chiffre de 1 à 4. De... | ["\nassert solve_grid([1, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 0, 0]) == [[1, 2, 3, 4], [4, 3, 1, 2], [3, 4, 2, 1], [2, 1, 4, 3]]\n", "\nassert solve_grid([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) == [[1, 2, 3, 4], [4, 3, 1, 2], [3, 4, 2, 1], [2, 1, 4, 3]] or solve_grid([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,... |
d48cf91be1ffaf233b595ed5ca848c24 | [
{
"content": "On te donne une liste de mots. Ta tâche est d'écrire une fonction `count_vowels_in_words(words)` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les mots de la liste, et les valeurs doivent être le nombre de voyelles dans chaque mot. Considère les voyelles majuscules et minuscul... | ["\nassert count_vowels_in_words([\"Hello\", \"world\", \"Python\", \"programming\"]) == {'Hello': 2, 'world': 1, 'Python': 1, 'programming': 3}\n", "\nassert count_vowels_in_words([\"AEIOU\", \"aeiou\"]) == {'AEIOU': 5, 'aeiou': 5}\n", "\nassert count_vowels_in_words([\"bcd\", \"fgh\"]) == {'bcd': 0, 'fgh': 0}\n", "\n... |
aa0f38b2c05a86f7c05f4b9abf2e6c43 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui calcule la somme cumulative de la liste. La somme cumulative à chaque position est la somme de tous les éléments du début de la liste jusqu'à cette position.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(num... | ["\nassert cumulative_sum([1, 2, 3, 4]) == [1, 3, 6, 10]\n", "\nassert cumulative_sum([0, 0, 0, 0]) == [0, 0, 0, 0]\n", "\nassert cumulative_sum([1, -1, 1, -1]) == [1, 0, 1, 0]\n", "\nassert cumulative_sum([5]) == [5]\n", "\nassert cumulative_sum([]) == []\n", "\nassert cumulative_sum([10, 20, 30]) == [10, 30, 60]\n", ... |
d392738723769125d900255d50b569d3 | [
{
"content": "Tu es chargé d'implémenter une fonction `convert_weight` qui accepte deux paramètres : `weight` (un flottant) et `unit` (une chaîne de caractères). La fonction doit convertir le poids donné de \"pounds\", \"ounces\" ou \"grams\" en \"kilograms\". Si le poids est déjà en \"kilograms\", il doit être... | ["\nassert convert_weight(160, \"pounds\") == 72.57\n", "\nassert convert_weight(32, \"ounces\") == 0.90\n", "\nassert convert_weight(1000, \"grams\") == 1.00\n", "\nassert convert_weight(50, \"kilograms\") == 50.00\n", "\nassert convert_weight(0, \"pounds\") == 0.00\n", "\nassert convert_weight(1, \"ounces\") == 0.03\... |
e44846a277ebba512e2ee0c3f757448f | [
{
"content": "On te demande de créer un point de terminaison d'API simple en utilisant Flask qui accepte une charge utile JSON contenant les détails de l'utilisateur et les stocke dans une base de données SQLite. La charge utile JSON comprendra le nom et l'adresse e-mail de l'utilisateur. L'API doit gérer les c... | ["\nassert add_user() == jsonify({\"msg\": \"Missing JSON in request\"}), 400\n", "\nassert add_user(json={'name': 'John Doe'}) == jsonify({\"msg\": \"Missing 'email' parameter\"}), 400\n", "\nassert add_user(json={'email': 'john@example.com'}) == jsonify({\"msg\": \"Missing 'name' parameter\"}), 400\n", "\nassert add_... |
c0c2410db7bdaf641fecd5a5562e37e1 | [
{
"content": "On te donne une liste de dictionnaires, où chaque dictionnaire représente un message électronique. Chaque dictionnaire de message contient une clé `\"messageMetadata\"` qui correspond à un autre dictionnaire. Ce dictionnaire imbriqué contient une clé `\"authorDetails\"` qui correspond elle-même à ... | ["\nassert get_unique_sender_emails([{\"messageMetadata\": {\"authorDetails\": {\"primaryContact\": \"test1@example.com\"}}}]) == [\"test1@example.com\"]\n", "\nassert get_unique_sender_emails([{\"messageMetadata\": {\"authorDetails\": {\"primaryContact\": \"test1@example.com\"}}}, {\"messageMetadata\": {\"authorDetail... |
2bc3219ae3f6c48acee9588cf1e91627 | [
{
"content": "On te demande d'écrire un programme Python pour générer la suite de Fibonacci jusqu'au n-ième nombre. La suite de Fibonacci est une série de nombres où chaque nombre est la somme des deux nombres précédents, commençant généralement par 0 et 1. Ton programme doit gérer l'entrée utilisateur pour la ... | ["\nassert generate_fibonacci(0) == \"Input should be a positive integer.\"\n", "\nassert generate_fibonacci(-5) == \"Input should be a positive integer.\"\n", "\nassert generate_fibonacci(1) == [0]\n", "\nassert generate_fibonacci(2) == [0, 1]\n", "\nassert generate_fibonacci(3) == [0, 1, 1]\n", "\nassert generate_fib... |
6d0ddc148007ecc977772b5c1089bd77 | [
{
"content": "Dans un système de gestion de base de données, tu as pour tâche d'identifier les collections non fragmentées au sein d'une instance de base de données donnée. Implémente une fonction `get_unsharded_collections` qui accepte une `database_instance` en entrée et renvoie une liste des noms de toutes l... | ["\nassert get_unsharded_collections(database_instance) == [\"collection1\", \"collection2\"] if database_instance.retrieveMultipleRecords(\"admin\", \"system.collections\", {\"dropped\": {\"$ne\": True}, \"sharded\": {\"$ne\": True}}, {\"collection_name\": 1, \"creation_date\": -1}) == [{\"collection_name\": \"collect... |
ec1d1b953c959d78dcc74329466b83fb | [
{
"content": "Implémente une classe Python `Car` avec les spécifications suivantes :\n\n- La classe doit avoir un initialiseur (`__init__`) qui accepte quatre paramètres : `make`, `model`, `year` et `color`. Ces paramètres doivent être utilisés pour définir les variables d'instance respectives.\n- Implémente un... | ["\nassert Car.total_cars == 0\n", "\ncar1 = Car(\"Toyota\", \"Corolla\", 2021, \"Blue\")\nassert car1.make == \"Toyota\"\n", "\ncar1 = Car(\"Toyota\", \"Corolla\", 2021, \"Blue\")\nassert car1.model == \"Corolla\"\n", "\ncar1 = Car(\"Toyota\", \"Corolla\", 2021, \"Blue\")\nassert car1.year == 2021\n", "\ncar1 = Car(\"... |
f9d0a7e8bc78c5ff7fad443aca6509a5 | [
{
"content": "On te donne la tâche d'estimer la valeur de Pi en utilisant une simulation de Monte Carlo. Ta simulation doit estimer Pi/2 en utilisant uniquement l'arithmétique entière, à l'exception de l'étape de division finale. Ton programme doit prendre un entier `n` en entrée, représentant le nombre de poin... | ["\nassert estimate_pi(1) == 0.0\n", "\nassert estimate_pi(10) == 0.0\n", "\nassert estimate_pi(100) == 0.0\n", "\nassert estimate_pi(1000) == 0.0\n", "\nassert estimate_pi(10000) == 0.0\n", "\nassert estimate_pi(100000) == 0.0\n", "\nassert estimate_pi(1000000) > 3.0 and estimate_pi(1000000) < 3.5\n", "\nassert estima... |
9428b0ab846d3eb71f9df63e4e081baa | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `count_word_frequency(text)` qui traite le texte et renvoie un dictionnaire avec les mots comme clés et leurs fréquences respectives comme valeurs. La fonction doit être insensible à la casse et doit ignorer l... | ["\nassert count_word_frequency(\"The quick brown fox jumps over the lazy dog.\") == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nassert count_word_frequency(\"Is this the real life? Is this just fantasy? Caught in a landslide, no escape from reality.\") == {'this': 2, 'real': 1... |
44405c25fe4bf9e1c6ccec33961fa5d2 | [
{
"content": "On te donne une liste de `n` nœuds, où chaque nœud est représenté comme un objet avec deux attributs : `x` et `y`. Ces nœuds représentent des points dans un plan 2D. Ta tâche est d'écrire une fonction `closest_pair(nodes)` qui prend une liste de nœuds en entrée et renvoie les indices des deux nœud... | ["\nassert closest_pair([Node(0, 0), Node(1, 1)]) == (0, 1)\n", "\nassert closest_pair([Node(0, 0), Node(1, 1), Node(2, 2)]) == (0, 1)\n", "\nassert closest_pair([Node(0, 0), Node(1, 1), Node(2, 2), Node(3, 3)]) == (0, 1)\n", "\nassert closest_pair([Node(0, 0), Node(1, 1), Node(1, 1)]) == (1, 2)\n", "\nassert closest_p... |
ccf0ca1c128e673b5f8aed38547cc8f2 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente un nombre binaire. Ta tâche est d'écrire une fonction Python qui détermine la valeur décimale du nombre binaire ayant la valeur décimale la plus élevée dans la liste.\n\n**Entrée :**\n- Une liste de chaînes de caractères, ... | ["\nassert max_binary_to_decimal(['1010', '1101', '0111']) == 13\n", "\nassert max_binary_to_decimal(['1111', '1010', '1001']) == 15\n", "\nassert max_binary_to_decimal(['0001', '0010', '0011']) == 3\n", "\nassert max_binary_to_decimal(['10000', '10001', '10010']) == 18\n", "\nassert max_binary_to_decimal(['11111111'])... |
4bbfdd5d526fa12e77e107c0cf7f6620 | [
{
"content": "Tu participes à un concours de programmation où tu dois résoudre un problème lié au calcul des contributions pour un cadeau de groupe. La fonction `gift_contribution` doit calculer le montant que chaque personne d'un groupe doit contribuer pour un cadeau, en tenant compte d'un taux de taxe variabl... | ["\nassert gift_contribution(100.00, [\"Region1\", \"Region2\"], {\"Region1\": 0.07, \"Region2\": 0.05}) == 56.00\n", "\nassert gift_contribution(200.00, [\"Region1\", \"Region1\"], {\"Region1\": 0.07}) == 214.00\n", "\nassert gift_contribution(50.00, [\"Region1\", \"Region2\", \"Region3\"], {\"Region1\": 0.07, \"Regio... |
cb6a21acff52b1ededcc1e8f47964326 | [
{
"content": "On te donne un fichier texte nommé `large_text.txt` contenant plusieurs paragraphes. Ta tâche est d'écrire un programme Python qui lit ce fichier et affiche le nombre de lignes, de mots et de caractères dans le fichier. Suppose que les mots sont séparés par des espaces et que les lignes sont sépar... | ["\nassert count_file_contents('empty.txt') == None # Assuming empty.txt is an empty file\n", "\nassert count_file_contents('single_line.txt') == None # Assuming single_line.txt contains \"Hello World\"\n", "\nassert count_file_contents('multiple_lines.txt') == None # Assuming multiple_lines.txt contains \"Hello\\nW... |
c37b97120ae661b48ab72273bf041daf | [
{
"content": "Tu participes à une compétition de vision par ordinateur où l'on te fournit un modèle de réseau neuronal convolutif (CNN) pré-entraîné capable de classifier des images dans l'une des 1000 catégories distinctes. Ton objectif est d'évaluer les performances du modèle en utilisant la métrique de préci... | ["\nassert compute_topk_accuracy(model, dataloader, [1]) == {1: 0.0}\n", "\nassert compute_topk_accuracy(model, dataloader, [5]) == {5: 0.0}\n", "\nassert compute_topk_accuracy(model, dataloader, [1, 5]) == {1: 0.0, 5: 0.0}\n", "\nassert compute_topk_accuracy(model, dataloader, [3, 5, 10]) == {3: 0.0, 5: 0.0, 10: 0.0}\... |
59a8aadc7aea87790623cfc0c487535d | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'écrire une fonction Python qui filtre et renvoie une nouvelle liste contenant uniquement les chaînes de caractères qui commencent par une voyelle (majuscule ou minuscule).\n\n**Entrée :**\n- Une liste de chaînes de caractères, `words`.... | ["\nassert filter_vowel_strings([\"apple\", \"banana\", \"umbrella\", \"orange\", \"grape\"]) == ['apple', 'umbrella', 'orange']\n", "\nassert filter_vowel_strings([\"elephant\", \"igloo\", \"sky\", \"umbrella\"]) == ['elephant', 'igloo', 'umbrella']\n", "\nassert filter_vowel_strings([\"sky\", \"moon\", \"star\"]) == ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.