id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
06d08f4d1a87d37d276d34583bfcd122 | [
{
"content": "On te donne une liste ou un tableau NumPy de rendements quotidiens d'un portefeuille et le taux de rendement annuel sans risque. Ta tâche est de mettre en œuvre une fonction `calculate_sharpe_ratio(portfolio_returns, risk_free_rate)` qui calcule le ratio de Sharpe du portefeuille. Le ratio de Shar... | ["\nassert calculate_sharpe_ratio([0.01, 0.02, 0.03], 0.05) == (np.mean([0.01, 0.02, 0.03]) - 0.05 / 252) / np.std([0.01, 0.02, 0.03])\n", "\nassert calculate_sharpe_ratio([0.001, 0.002, 0.003], 0.03) == (np.mean([0.001, 0.002, 0.003]) - 0.03 / 252) / np.std([0.001, 0.002, 0.003])\n", "\nassert calculate_sharpe_ratio([... |
96809b4bb6c9b2234e8a05198964c444 | [
{
"content": "On te donne une liste d'entiers qui sont censés former une séquence de nombres consécutifs, mais qui peuvent contenir des lacunes. Ta tâche est d'écrire une fonction `find_missing_elements` qui identifie et renvoie une liste de tous les entiers manquants dans la séquence. La liste d'entrée est gar... | ["\nassert find_missing_elements([1, 2, 4, 6, 7, 9, 10]) == [3, 5, 8]\n", "\nassert find_missing_elements([5, 7, 10]) == [6, 8, 9]\n", "\nassert find_missing_elements([1, 3, 5, 7]) == [2, 4, 6]\n", "\nassert find_missing_elements([10, 11, 12, 13]) == []\n", "\nassert find_missing_elements([1, 2, 3, 4, 5]) == []\n", "\n... |
ed31cd981a815b21a71f880101ee2536 | [
{
"content": "On te demande d'implémenter une fonction Python pour calculer la factorielle d'un entier donné en utilisant la récursion. La fonction doit gérer les cas limites où l'entrée est un nombre négatif ou zéro en renvoyant un message spécifique. Ton programme doit être efficace et respecter les contraint... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(3) == 6\n", "\nassert factorial(-1) == \"Factorial is not defined for negative numbers.\"\n", "\nassert factorial(-5) == \"Factorial is not defined for negative numbers.\"\n", "\nassert factorial(10) =... |
493f4bde8dffb20b8b4e8fac3c8243fa | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction `find_fibonacci_sequence(numbers)` qui trouve la sous-séquence contiguë la plus longue dans `numbers` qui forme une séquence de Fibonacci. Une séquence de Fibonacci est définie comme une séquence où chaque nombr... | ["\nassert find_fibonacci_sequence([1, 1, 2, 3, 5, 8, 13]) == [1, 1, 2, 3, 5, 8, 13]\n", "\nassert find_fibonacci_sequence([5, 8, 13, 21, 34, 55]) == [5, 8, 13, 21, 34, 55]\n", "\nassert find_fibonacci_sequence([1, 4, 5, 6, 7, 8]) == []\n", "\nassert find_fibonacci_sequence([1, 1, 2, 4, 8, 16]) == [1, 1, 2]\n", "\nasse... |
da7b52f20219d8f0d7008afbf2f730f3 | [
{
"content": "On te demande d'implémenter une fonction `parse_query_params` qui traite les paramètres de requête d'une URL. La fonction doit accepter soit un dictionnaire, soit une liste de tuples en entrée et renvoyer un dictionnaire. L'entrée représente les paramètres de requête où les clés sont les noms des ... | ["\nassert parse_query_params({\"param[0]\": \"value1\", \"param[1]\": \"value2\"}) == {\"param\": [\"value1\", \"value2\"]}\n", "\nassert parse_query_params([(\"param[]\", \"value1\"), (\"param[]\", \"value2\")]) == {\"param\": [\"value1\", \"value2\"]}\n", "\nassert parse_query_params({\"param\": \"value\"}) == {\"pa... |
faf4d02c719f7062d3ba2e23bfbbcb0a | [
{
"content": "On te donne une liste de projets, chacun identifié par un ID entier unique. Chaque projet a une liste de périodes opérationnelles, où chaque période est définie par une année de début, une année de fin et la capacité construite pendant cette période. Ta tâche est d'écrire une fonction qui calcule ... | ["\nassert calculate_total_capacity(projects, 1, 2027) == 3000\n", "\nassert calculate_total_capacity(projects, 1, 2024) == 0\n", "\nassert calculate_total_capacity(projects, 2, 2027) == 1500\n", "\nassert calculate_total_capacity(projects, 2, 2029) == 0\n", "\nassert calculate_total_capacity(projects, 1, 2030) == 3000... |
1bdeaca321f67f8d13c8746ee6c62239 | [
{
"content": "On te demande de développer une fonction `generate_milestones` qui calcule une liste de points d'étape espacés uniformément en fonction d'un nombre total de points spécifié. La granularité des étapes augmente avec le nombre total de points. La fonction doit prendre en charge à la fois des règles d... | ["\nassert generate_milestones(3) == [0, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3]\n", "\nassert generate_milestones(7) == [0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7]\n", "\nassert generate_milestones(12) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n", "\nassert generate_milestones(1... |
643bc0bf3b00811cade9fd22dcc775e8 | [
{
"content": "On te donne une liste de nombres qui peut inclure à la fois des entiers positifs et négatifs ainsi que des nombres à virgule flottante. Ta tâche est d'écrire une fonction qui renvoie la valeur maximale dans la liste. Si la liste est vide, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une li... | ["\nassert find_maximum([3.5, -2, 7, 0, 1.2]) == 7\n", "\nassert find_maximum([-10, -20, -30, -5]) == -5\n", "\nassert find_maximum([0.1, 0.2, 0.3, 0.4]) == 0.4\n", "\nassert find_maximum([100]) == 100\n", "\nassert find_maximum([]) == None\n", "\nassert find_maximum([5, 5, 5, 5]) == 5\n", "\nassert find_maximum([-1, 0... |
7cdae8676516086ecf1eeb8b58f0594d | [
{
"content": "On te demande d'implémenter une fonction `generate_html_table` qui construit un tableau HTML à partir d'une liste de listes donnée. Chaque liste interne correspond à une ligne du tableau, la première liste interne représentant la ligne d'en-tête et les listes internes suivantes représentant les li... | ["\nassert generate_html_table([[\"Name\", \"Age\", \"City\"], [\"Alice\", \"24\", \"New York\"], [\"Bob\", \"30\", \"Chicago\"]]) == \"<table>\\n <tr>\\n\t<th>Name</th>\\n\t<th>Age</th>\\n\t<th>City</th>\\n </tr>\\n <tr>\\n\t<td>Alice</td>\\n\t<td>24</td>\\n\t<td>New York</td>\\n </tr>\\n <tr>\\n\t<td>Bob</td>\\n... |
4fb9f353204c0d427b534124d0a728c1 | [
{
"content": "On te donne deux listes, `predictions` et `labels`, représentant les étiquettes prédites et réelles pour un ensemble d'échantillons, respectivement. Ta tâche est de mettre en œuvre une fonction `binary_classification_accuracy` qui calcule la précision des prédictions pour uniquement les échantillo... | ["\nassert binary_classification_accuracy([1, 0, 1, 1], [1, 0, 1, 1]) == 1.0\n", "\nassert binary_classification_accuracy([1, 0, 1, 1], [0, 0, 0, 0]) == 0.0\n", "\nassert binary_classification_accuracy([1, 0, 1, 1], [1, 2, 1, 3]) == 0.6666666666666666\n", "\nassert binary_classification_accuracy([0, 0, 0, 0], [0, 0, 0,... |
fc5920031427d7890e42e848808b8869 | [
{
"content": "On te donne une liste de mots uniques (tokens) et une phrase. Ta tâche est de mettre en œuvre une fonction `token_anagram_presence` qui renvoie une liste de valeurs binaires indiquant la présence ou l'absence de chaque token dans la phrase. Les tokens qui sont des anagrammes les uns des autres son... | ["\nassert token_anagram_presence([\"apple\", \"banana\", \"cherry\"], \"I like bananas and cherries\") == [0, 1, 1]\n", "\nassert token_anagram_presence([\"apple\", \"banana\", \"cherry\", \"enana\"], \"I like bananas and cherries\") == [0, 1, 1]\n", "\nassert token_anagram_presence([\"apple\", \"banana\", \"cherry\"]... |
98a97adbc790c8f081af97c12a2e6d19 | [
{
"content": "Dans une entreprise de fabrication de meubles, chaque meuble est identifié de manière unique par une clé générée à partir de son type et de son matériau. Le type et le matériau sont tous deux représentés sous forme de chaînes de caractères et doivent être alphanumériques. Ta tâche est de mettre en... | ["\nassert generate_furniture_key(\"Chair\", \"Wood\") == \"CHAIR_WOOD\"\n", "\nassert generate_furniture_key(\"Table\", \"Glass\") == \"TABLE_GLASS\"\n", "\nassert generate_furniture_key(\"Bed\", \"Metal\") == \"BED_METAL\"\n", "\nassert generate_furniture_key(\"Desk\", \"Plastic\") == \"DESK_PLASTIC\"\n", "\nassert g... |
7b8efed2b4b060b9232b48f66697faf1 | [
{
"content": "On te demande d'implémenter un système de gestion de bibliothèque en utilisant une classe Python. Le système doit prendre en charge les opérations suivantes :\n- Ajouter un livre à la bibliothèque.\n- Supprimer un livre de la bibliothèque s'il existe.\n- Afficher la liste de tous les livres dispon... | ["\nassert Library().display_books() == None\n", "\nassert Library().add_book(\"1984\") == None\n", "\nassert Library().remove_book(\"1984\") == None\n", "\nlib = Library(); lib.add_book(\"1984\"); assert lib.display_books() == None\n", "\nlib = Library(); lib.add_book(\"1984\"); lib.add_book(\"To Kill a Mockingbird\")... |
289f08973c038eaf9318a3798c358f93 | [
{
"content": "On te demande d'implémenter une fonction `encode_data` qui traite les données d'entrée et les convertit en octets en utilisant un schéma d'encodage spécifié. La fonction doit gérer trois types d'entrées : les chaînes de caractères, les octets et les listes contenant uniquement des chaînes de carac... | ["\nassert encode_data(\"hello\") == b'hello'\n", "\nassert encode_data(\"world\", \"ascii\") == b'world'\n", "\nassert encode_data(b\"hello\") == b\"hello\"\n", "\nassert encode_data([\"hello\", \"world\"]) == [b'hello', b'world']\n", "\nassert encode_data([b\"hello\", \"world\"]) == [b\"hello\", b'world']\n", "\nasse... |
314d91664044c1fd11b4d335731af24e | [
{
"content": "Dans un projet logiciel, les fichiers sont organisés dans une structure de répertoires hiérarchique composée de paquets et de sous-paquets. Chaque paquet est un répertoire qui peut contenir des modules Python et d'autres paquets. Les chemins de fichiers sont représentés sous forme de chaînes de ca... | ["\nassert same_top_level_package(\"package1.module\", \"package1.another_module\") == True\n", "\nassert same_top_level_package(\"package1.module\", \"package2.module\") == False\n", "\nassert same_top_level_package(\"package1.subpackage.module\", \"package1.subpackage.another_module\") == True\n", "\nassert same_top_... |
2ba3add570ee27b5aba2aa8e66791583 | [
{
"content": "On te donne une liste de dictionnaires, où chaque dictionnaire contient le titre d'un film et sa note correspondante. Ta tâche est de mettre en œuvre une fonction `top_rated_movies` qui renvoie une liste des 10 films les mieux notés. S'il y a moins de 10 films dans la liste d'entrée, renvoie-les t... | ["\nassert top_rated_movies([{\"title\": \"A\", \"rating\": 10}, {\"title\": \"B\", \"rating\": 9}, {\"title\": \"C\", \"rating\": 8}]) == [{\"title\": \"A\", \"rating\": 10}, {\"title\": \"B\", \"rating\": 9}, {\"title\": \"C\", \"rating\": 8}]\n", "\nassert top_rated_movies([{\"title\": \"X\", \"rating\": 5}, {\"titl... |
79dd6e855035b57989605d9cb078fb41 | [
{
"content": "On te demande d'implémenter une fonction `format_frequency` qui formate une valeur de fréquence donnée en une chaîne de caractères lisible par l'homme avec les unités SI appropriées. La fonction doit gérer les fréquences allant de Hz à GHz et formater la sortie selon les règles suivantes :\n\n- Le... | ["\nassert format_frequency(500) == \"500Hz\"\n", "\nassert format_frequency(1234) == \"1.234kHz\"\n", "\nassert format_frequency(9999) == \"9.999kHz\"\n", "\nassert format_frequency(10000) == \"10.00kHz\"\n", "\nassert format_frequency(99999) == \"99.99kHz\"\n", "\nassert format_frequency(100000) == \"100.0kHz\"\n", "... |
ea6d8475fa0d8af25683ed004ab4e5a3 | [
{
"content": "On te donne un tableau d'entiers. Implémente une version modifiée de l'algorithme de tri à bulles pour trier le tableau. La modification exige qu'un échange entre deux éléments adjacents ne se produise que si la somme des deux éléments est paire. Ta tâche est de renvoyer le tableau trié.\n\n**Entr... | ["\nassert modified_bubble_sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == [1, 1, 3, 3, 5, 5, 5, 4, 6, 9, 2]\n", "\nassert modified_bubble_sort([2, 4, 6, 8, 10]) == [2, 4, 6, 8, 10]\n", "\nassert modified_bubble_sort([1, 3, 5, 7, 9]) == [1, 3, 5, 7, 9]\n", "\nassert modified_bubble_sort([10, 20, 30, 40, 50]) == [10, 20, 30,... |
f8127a3be3f905c51b01eb3f2cae6a01 | [
{
"content": "On te demande d'écrire un programme Python qui identifie tous les nombres premiers dans une plage spécifiée. Ton programme doit accepter deux entiers, `a` et `b`, en entrée et afficher tous les nombres premiers entre `a` et `b` (inclus). Le programme doit gérer les entrées invalides avec élégance ... | ["\nassert get_primes_between(10, 20) == [11, 13, 17, 19]\n", "\nassert get_primes_between(1, 10) == [2, 3, 5, 7]\n", "\nassert get_primes_between(20, 30) == [23, 29]\n", "\nassert get_primes_between(0, 1) == []\n", "\nassert get_primes_between(2, 2) == [2]\n", "\nassert get_primes_between(14, 16) == []\n", "\nassert g... |
1753f3752504dd62e81ae8d322e865d8 | [
{
"content": "Tu es chargé de générer un motif fractal en utilisant l'ensemble de Mandelbrot. Ton programme doit produire un tableau 2D représentant le fractal et l'afficher en utilisant la bibliothèque `matplotlib`. Le fractal doit être affiché avec une résolution d'au moins 800x800 pixels. Utilise les paramèt... | ["\nassert mandelbrot_set(-2.0, 1.0, -1.5, 1.5, 800, 800, 100).shape == (800, 800)\n", "\nassert np.all(mandelbrot_set(-2.0, 1.0, -1.5, 1.5, 800, 800, 100) >= 0)\n", "\nassert np.all(mandelbrot_set(-2.0, 1.0, -1.5, 1.5, 800, 800, 100) <= 100)\n", "\nassert mandelbrot_set(-2.0, 1.0, -1.5, 1.5, 400, 400, 100).shape == (4... |
317377db2b8b32311c75b8f58f93130e | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche consiste à créer une fonction qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les caractères uniques de la chaîne, et les valeurs doivent être des listes contenant les indices auxquels chaque caractère apparaît dans la chaîne. L... | ["\nassert char_index_map(\"hello world\") == {'h': [0], 'e': [1], 'l': [2, 3, 9], 'o': [4, 7], ' ': [5], 'w': [6], 'r': [8], 'd': [10]}\n", "\nassert char_index_map(\"aabbcc\") == {'a': [0, 1], 'b': [2, 3], 'c': [4, 5]}\n", "\nassert char_index_map(\"abcABC\") == {'a': [0], 'b': [1], 'c': [2], 'A': [3], 'B': [4], 'C':... |
cc62c41cfa822807a9165ac74526d91c | [
{
"content": "On te donne une structure de liste imbriquée composée d'entiers et d'autres listes. Ta tâche est d'écrire une fonction qui aplatit cette liste imbriquée en une seule liste contenant tous les entiers dans l'ordre où ils apparaissent.\n\n**Entrée :**\n- Une liste `lst` qui peut contenir des entiers ... | ["\nassert flatten([1, 2, [3, 4], [5, [6, 7]]]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert flatten([1, [2, [3, [4, [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten([]) == []\n", "\nassert flatten([[], [], []]) == []\n", "\nassert flatten([1, 2, 3]) == [1, 2, 3]\n", "\nassert flatten([[[[1]]]]) == [1]\n", "\nassert flatten... |
ef79401516171f462d5fe7d12997a147 | [
{
"content": "On te donne une chaîne de caractères `time_range` qui contient plusieurs plages horaires séparées par des virgules. Chaque plage horaire est au format `HH:MM:SS`. Ta tâche est d'écrire une fonction `time_range_to_list(time_range)` qui analyse cette chaîne et renvoie une liste de tuples, où chaque ... | ["\nassert time_range_to_list(\"12:30:45\") == [(12, 30, 45)]\n", "\nassert time_range_to_list(\"09:00:00, 23:59:59\") == [(9, 0, 0), (23, 59, 59)]\n", "\nassert time_range_to_list(\"00:00:00, 11:11:11, 22:22:22\") == [(0, 0, 0), (11, 11, 11), (22, 22, 22)]\n", "\nassert time_range_to_list(\"25:00:00\") == []\n", "\nas... |
4a9808b89503d31be0d9a5cebe75c99a | [
{
"content": "On te donne un dictionnaire imbriqué où les clés peuvent correspondre à d'autres dictionnaires ou à des valeurs. Ta tâche est d'écrire une fonction Python qui aplatit ce dictionnaire. Les clés du dictionnaire résultant doivent être des chaînes de caractères représentant la hiérarchie des clés imbr... | ["\nassert flatten_dict({\"a\": {\"b\": 1}}) == {\"a.b\": 1}\n", "\nassert flatten_dict({\"x\": 1, \"y\": {\"z\": 2}}) == {\"x\": 1, \"y.z\": 2}\n", "\nassert flatten_dict({\"level1\": {\"level2\": {\"level3\": {\"level4\": 5}}}}) == {\"level1.level2.level3.level4\": 5}\n", "\nassert flatten_dict({\"a\": 1, \"b\": 2, \... |
08b74183cc2a28bffe25e94b441b3ea7 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `is_special_character` qui traite cette chaîne et renvoie une liste de booléens. Chaque booléen de la liste doit indiquer si le caractère correspondant dans la chaîne est un caractère spécial, à l'exclusion de t... | ["\nassert is_special_character(\"Hello World! @#\") == [False, False, False, False, False, True, True, True]\n", "\nassert is_special_character(\"1234567890\") == [False, False, False, False, False, False, False, False, False, False]\n", "\nassert is_special_character(\"!@#$%^&*()\") == [True, True, True, True, True, ... |
5dae901c44ed19616fdbdcde3a720e0c | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est de mettre en œuvre une fonction `find_longest_palindrome_substring(s)` qui renvoie la plus longue sous-chaîne palindromique dans `s`. S'il existe plusieurs sous-chaînes de longueur maximale identique, renvoie celle qui apparaît en premier ... | ["\nassert find_longest_palindrome_substring(\"babad\") == \"bab\" or find_longest_palindrome_substring(\"babad\") == \"aba\"\n", "\nassert find_longest_palindrome_substring(\"cbbd\") == \"bb\"\n", "\nassert find_longest_palindrome_substring(\"a\") == \"a\"\n", "\nassert find_longest_palindrome_substring(\"ac\") == \"a... |
6a90d74d210c06a8461e74bf316d1b7d | [
{
"content": "On te demande d'écrire une fonction Python qui automatise le renommage des fichiers dans un répertoire spécifié. Chaque fichier doit être renommé en ajoutant le préfixe \"backup_\" à son nom d'origine. Par exemple, un fichier nommé \"report.docx\" doit être renommé en \"backup_report.docx\". Ta fo... | ["\nassert rename_files_with_prefix(\"non_existent_directory\") == None\n", "\nassert rename_files_with_prefix(\"\") == None\n", "\nassert rename_files_with_prefix(\"/tmp\") == None\n", "\nassert rename_files_with_prefix(\"/tmp\", \"backup_\") == None\n", "\nassert rename_files_with_prefix(\"/tmp\", \"test_\") == None\... |
6002ebdecc07caa39382689e88dca8f6 | [
{
"content": "Tu es chargé d'implémenter une fonction `recursive_fibonacci_sum` qui calcule la somme des `n` premiers nombres de Fibonacci en utilisant la récursion. La suite de Fibonacci commence par 1 et 1, et chaque nombre suivant est la somme des deux nombres précédents. De plus, ta fonction doit suivre et ... | ["\nassert recursive_fibonacci_sum(1) == (1, 1)\n", "\nassert recursive_fibonacci_sum(2) == (2, 2)\n", "\nassert recursive_fibonacci_sum(3) == (4, 4)\n", "\nassert recursive_fibonacci_sum(4) == (7, 7)\n", "\nassert recursive_fibonacci_sum(5) == (12, 12)\n", "\nassert recursive_fibonacci_sum(6) == (20, 20)\n", "\nassert... |
d963ecffb6df48d8129734f6323fb779 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie une nouvelle liste où chaque élément est la somme de tous les éléments de la liste d'entrée, à l'exception de l'élément courant. Tu dois implémenter cette fonction sans utiliser la fonction intégrée `sum()` ni les ... | ["\nassert sum_except_self([1, 2, 3, 4]) == [9, 8, 7, 6]\n", "\nassert sum_except_self([10, 20, 30, 40]) == [90, 80, 70, 60]\n", "\nassert sum_except_self([5, 5, 5, 5]) == [15, 15, 15, 15]\n", "\nassert sum_except_self([0, 0, 0, 0]) == [0, 0, 0, 0]\n", "\nassert sum_except_self([1]) == [0]\n", "\nassert sum_except_self... |
ad78d62eb0506de1d2cee5727220826f | [
{
"content": "Dans un environnement de calcul scientifique, tu dois concevoir une fonction pour générer des noms de répertoires uniques pour les tâches de simulation. Chaque nom de répertoire doit suivre ce format :\n\n- Préfixe : \"simulation-\"\n- Identifiant unique : job_id\n- Suffixe : \"-output\"\n\nLa fon... | ["\nassert generate_unique_directory_name(\"001\", []) == \"simulation-001-output\"\n", "\nassert generate_unique_directory_name(\"002\", [\"simulation-002-output\"]) == \"simulation-002-output-1\"\n", "\nassert generate_unique_directory_name(\"003\", [\"simulation-003-output\", \"simulation-003-output-1\"]) == \"simul... |
b3b0200927ce61385f80a8fed8522cc0 | [
{
"content": "On te demande d'implémenter une fonction `generate_shuffled_sequence(limit)` qui génère une liste d'entiers de 0 à `limit - 1` dans un ordre aléatoire. La fonction ne doit utiliser aucune fonction intégrée de Python pour mélanger, trier ou générer des nombres aléatoires. Au lieu de cela, tu dois i... | ["\nassert len(generate_shuffled_sequence(0)) == 0\n", "\nassert len(generate_shuffled_sequence(1)) == 1\n", "\nassert generate_shuffled_sequence(1) == [0]\n", "\nassert set(generate_shuffled_sequence(5)) == {0, 1, 2, 3, 4}\n", "\nassert set(generate_shuffled_sequence(10)) == {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\n", "\nasser... |
5679c0fc5ae6bf0a13c9e33e4e21d991 | [
{
"content": "Implémente une structure de données pile en Python. Ta pile doit prendre en charge les opérations suivantes :\n- `is_empty()` : Renvoie `True` si la pile est vide, sinon `False`.\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élément du sommet de la pi... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().size() == 0\n", "\ns = Stack(); s.push(1); assert s.peek() == 1\n", "\ns = Stack(); s.push(1); s.push(2); assert s.pop() == 2\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.size() == 1\n", "\ns = Stack(); s.push(1); s.push(2); s.push(3); assert st... |
77ccf475bc4612b3ee746c63db22fa66 | [
{
"content": "On te demande d'implémenter une fonction `file_counter` qui traite un fichier texte et renvoie un tuple contenant le nombre de lignes, de mots et de caractères dans le fichier. La fonction doit compter avec précision les lignes, les mots et les caractères, y compris les caractères d'espacement. Ta... | ["\nassert file_counter('empty.txt') == (0, 0, 0)\n", "\nassert file_counter('single_line_no_space.txt') == (1, 1, 5)\n", "\nassert file_counter('single_line_with_spaces.txt') == (1, 3, 11)\n", "\nassert file_counter('multiple_lines_no_space.txt') == (3, 3, 9)\n", "\nassert file_counter('multiple_lines_with_spaces.txt'... |
62fc63481a5f2617a808c7179a299575 | [
{
"content": "On te demande de développer une fonction pour extraire l'adresse IP et l'interface associées à une adresse MAC donnée depuis un dispositif réseau. La fonction doit gérer les adresses MAC dans les formats `XX:XX:XX:XX:XX:XX` et `XX-XX-XX-XX-XX-XX`. Le dispositif réseau fournit une méthode `execute`... | ["\nassert get_ip_and_interface(dev, \"00:50:abcd:de17\") == {'ip': '10.9.2.171', 'interface': 'Vlan18'}\n", "\nassert get_ip_and_interface(dev, \"00-50-abcd-de17\") == {'ip': '10.9.2.171', 'interface': 'Vlan18'}\n", "\nassert get_ip_and_interface(dev, \"00:50:AB:CD:DE:17\") == {'ip': '10.9.2.171', 'interface': 'Vlan18... |
ede7a667c93454ac2fe9b9e507a5a187 | [
{
"content": "Implémente une table de hachage simple avec des opérations basiques : insertion, récupération et suppression. La table de hachage doit gérer les collisions en utilisant le chaînage. La fonction de hachage doit utiliser la fonction intégrée `hash()` de Python modulo la taille de la table.\n\n**Entr... | ["\nassert ht.get('apple') == None\n", "\nassert ht.get('banana') == 5\n", "\nassert ht.get('cherry') == None\n", "\nassert ht.get('date') == None\n", "\nassert ht.get('elderberry') == None\n", "\nht.insert('fig', 7)\nassert ht.get('fig') == 7\n", "\nht.insert('grape', 9)\nht.delete('grape')\nassert ht.get('grape') == ... |
fa27472dcac491e7c686152e5d8ad178 | [
{
"content": "On te demande d'implémenter une fonction `convert_to_roman(num)` qui convertit un entier donné `num` (où 1 ≤ num ≤ 3999) en sa représentation en chiffres romains. Ta fonction doit renvoyer le chiffre romain sous forme de chaîne de caractères.\n\n**Exemple d'entrée :**\n```\n1994\n```\n\n**Exemple ... | ["\nassert convert_to_roman(1) == \"I\"\n", "\nassert convert_to_roman(4) == \"IV\"\n", "\nassert convert_to_roman(9) == \"IX\"\n", "\nassert convert_to_roman(58) == \"LVIII\"\n", "\nassert convert_to_roman(1994) == \"MCMXCIV\"\n", "\nassert convert_to_roman(3999) == \"MMMCMXCIX\"\n", "\nassert convert_to_roman(500) ==... |
e3edbacfec3709ff731bb7edd0d36054 | [
{
"content": "On te demande d'implémenter une fonction pour rechercher un livre dans un catalogue de bibliothèque. Le catalogue est représenté comme une liste de listes, où chaque sous-liste contient trois éléments : l'identifiant unique du livre (une chaîne de caractères), le titre du livre (une chaîne de cara... | ["\nassert find_book_title([[\"1\", \"Book One\", \"Author A\"], [\"2\", \"Book Two\", \"Author B\"]], \"1\") == \"Book One\"\n", "\nassert find_book_title([[\"1\", \"Book One\", \"Author A\"], [\"2\", \"Book Two\", \"Author B\"]], \"2\") == \"Book Two\"\n", "\nassert find_book_title([[\"1\", \"Book One\", \"Author A\"... |
c4316de35b491cb8d23b6cd5ce15ee42 | [
{
"content": "On te demande d'implémenter un système de boutique en ligne simple. Le système doit prendre en charge les opérations suivantes :\n- Ajouter un produit avec un nom, un prix et une quantité donnés.\n- Supprimer un produit par son nom.\n- Lister tous les produits actuellement dans la boutique.\n\nCha... | ["\nassert isinstance(store, OnlineStore)\n", "\nassert len(store.products) == 0\n", "\nstore.add_product(Product(\"Laptop\", 1200.50, 10)); assert len(store.products) == 1\n", "\nstore.add_product(Product(\"Smartphone\", 700.25, 5)); assert len(store.products) == 2\n", "\nstore.remove_product(\"Laptop\"); assert len(s... |
c6c90143c659cddc6d7d4f4b7bdf5d5a | [
{
"content": "On te donne une chaîne de caractères `S` et un caractère `C`. Ta tâche est d'écrire une fonction qui supprime toutes les occurrences de `C` dans `S`, sans tenir compte de la casse. La fonction doit renvoyer la chaîne modifiée tout en préservant la casse originale des caractères restants.\n\n**Entr... | ["\nassert remove_character(\"Hello World\", \"o\") == \"Hell Wrld\"\n", "\nassert remove_character(\"Python Programming\", \"m\") == \"Python Prograing\"\n", "\nassert remove_character(\"Case Insensitive\", \"i\") == \"Cae nsensetve\"\n", "\nassert remove_character(\"Mississippi\", \"s\") == \"Miiippi\"\n", "\nassert ... |
3f7f489c5dc9463cb43d3df0ffd95f0f | [
{
"content": "Tu développes une simulation pour un jeu impliquant un dé biaisé. Le dé a `s` faces, chacune avec une probabilité initiale spécifiée dans la liste `initial_probabilities`. Après chaque `rolls_per_change` lancers, les probabilités d'atterrir sur chaque face sont mises à jour en faisant pivoter la l... | ["\nassert biased_dice_simulation(2, [0.5, 0.5], 1, 2) == {1: 1, 2: 1}\n", "\nassert biased_dice_simulation(3, [0.33, 0.33, 0.34], 3, 3) == {1: 1, 2: 1, 3: 1}\n", "\nassert biased_dice_simulation(4, [0.25, 0.25, 0.25, 0.25], 4, 4) == {1: 1, 2: 1, 3: 1, 4: 1}\n", "\nassert biased_dice_simulation(6, [0.1, 0.1, 0.2, 0.25,... |
b9868e26f3f56684537865b3b71bcd7d | [
{
"content": "Dans un jeu de cartes simulé, tu dois implémenter une fonction `play_card` qui facilite l'action d'un joueur consistant à jouer une carte de sa main. Le jeu est hébergé sur un serveur, et chaque joueur possède un identifiant unique et participe à un jeu spécifique identifié par un identifiant de j... | ["\nassert play_card(\"localhost\", 1, 101, 0) == \"Expected server response\"\n", "\nassert play_card(\"example.com\", 2, 202, 1) == \"Expected server response\"\n", "\nassert play_card(\"game-server.net\", 3, 303, 2) == \"Expected server response\"\n", "\nassert play_card(\"localhost\", 1, 101, 3) == \"Expected serve... |
0899356e54ad038bfea94ef7d61838a6 | [
{
"content": "On te donne un graphe orienté représenté sous forme de liste d'adjacence. Ta tâche est d'implémenter une fonction `find_paths(graph, start, end)` qui renvoie tous les chemins possibles du nœud `start` au nœud `end`. Le graphe est représenté sous forme de dictionnaire où les clés sont les noms des ... | ["\nassert find_paths({'A': ['B', 'C'], 'B': ['C', 'D'], 'C': ['D'], 'D': ['C']}, 'A', 'D') == [['A', 'B', 'C', 'D'], ['A', 'C', 'D']]\n", "\nassert find_paths({'A': ['B', 'C'], 'B': ['C', 'D'], 'C': ['D'], 'D': ['C']}, 'A', 'A') == [['A']]\n", "\nassert find_paths({'A': ['B', 'C'], 'B': ['C', 'D'], 'C': ['D'], 'D': ['... |
780c05522a1db2ffeeb015f188ebfd3a | [
{
"content": "On te donne une liste d'entiers. Ton objectif est de déterminer s'il y a des éléments dupliqués dans la liste. Implémente une fonction `has_repeats(lst)` qui vérifie les doublons en parcourant la liste en ordre inverse. La fonction doit avoir une complexité temporelle de O(n log n), où n est la lo... | ["\nassert has_repeats([1, 2, 3, 4, 5]) == False\n", "\nassert has_repeats([5, 4, 3, 2, 1, 1]) == True\n", "\nassert has_repeats([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 100]) == True\n", "\nassert has_repeats([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) == True\n", "\nassert has_repeats([]) == False\n", "\nassert has_repeats([42]... |
d222af6476c4fd6a450fea4281822d76 | [
{
"content": "On te donne une liste de tuples, où chaque tuple consiste en deux entiers : la capacitance d'un condensateur existant (C1) et la capacitance totale souhaitée (C). Ta tâche est de déterminer la capacitance du condensateur qui doit être placé en parallèle avec le condensateur existant pour atteindre... | ["\nassert calculate_parallel_capacitor([(10, 15)]) == [5]\n", "\nassert calculate_parallel_capacitor([(20, 20)]) == [None]\n", "\nassert calculate_parallel_capacitor([(5, 10)]) == [5]\n", "\nassert calculate_parallel_capacitor([(10, 5)]) == [None]\n", "\nassert calculate_parallel_capacitor([(0, 10)]) == [10]\n", "\nas... |
e1583fe703655f3ddd29ba46d9248cfd | [
{
"content": "On te donne pour tâche d'implémenter une fonction `format_stock_identifier` qui traite une chaîne d'identification d'action. La chaîne est un identifiant alphanumérique unique de 6 caractères où le premier caractère indique la bourse. Si le premier caractère est une lettre minuscule, l'action est ... | ["\nassert format_stock_identifier(\"a12345\") == \"a12345.SZ\"\n", "\nassert format_stock_identifier(\"A12345\") == \"A12345.SH\"\n", "\nassert format_stock_identifier(\"b98765\") == \"b98765.SZ\"\n", "\nassert format_stock_identifier(\"B98765\") == \"B98765.SH\"\n", "\nassert format_stock_identifier(\"c43210\") == \"... |
c4ac597b8adcfd873de4d4be03dedbc6 | [
{
"content": "On te demande d'implémenter une fonction `convert_temperature` qui effectue des conversions de température entre Celsius et Fahrenheit. La fonction doit accepter une valeur de température et un indicateur d'unité ('C' pour Celsius ou 'F' pour Fahrenheit) comme paramètres d'entrée. Elle doit renvoy... | ["\nassert convert_temperature(100, 'C') == 212.0\n", "\nassert convert_temperature(32, 'F') == 0.0\n", "\nassert convert_temperature(0, 'C') == 32.0\n", "\nassert convert_temperature(212, 'F') == 100.0\n", "\nassert convert_temperature(-40, 'C') == -40.0\n", "\nassert convert_temperature(-40, 'F') == -40.0\n", "\nasse... |
affbffaa15f074bcc14a450bec2ec165 | [
{
"content": "On te donne une liste de chaînes de caractères représentant des chemins de fichiers. Ta tâche est de mettre en œuvre une fonction `filter_hidden_files` qui traite cette liste et renvoie une nouvelle liste contenant uniquement les fichiers non cachés. Dans les systèmes d'exploitation de type Unix, ... | ["\nassert filter_hidden_files(['.gitignore', 'README.md', 'src/main.c', '.DS_Store', 'LICENSE', 'docs/index.html']) == ['README.md', 'src/main.c', 'LICENSE', 'docs/index.html']\n", "\nassert filter_hidden_files(['.hidden', 'visible', '.another_hidden', 'also_visible']) == ['visible', 'also_visible']\n", "\nassert filt... |
2c3a2147b843ba1c35cb040d71426a56 | [
{
"content": "On te donne deux dictionnaires. Ta tâche est d'implémenter une fonction `compare_dictionaries` qui détermine si les deux dictionnaires sont équivalents. Deux dictionnaires sont considérés comme équivalents s'ils contiennent les mêmes clés (à l'exclusion des clés qui commencent par un tiret bas) et... | ["\nassert compare_dictionaries({}, {}) == True\n", "\nassert compare_dictionaries({'a': 1}, {'a': 1}) == True\n", "\nassert compare_dictionaries({'a': 1}, {'a': 2}) == False\n", "\nassert compare_dictionaries({'a': 1, 'b': 2}, {'b': 2, 'a': 1}) == True\n", "\nassert compare_dictionaries({'a': 1, '_b': 2}, {'a': 1, '_c... |
dc340f17b05a8e165c7ebc21440e50c6 | [
{
"content": "Tu développes un système de recommandation de livres qui interagit avec une base de données SQLite. La base de données contient des tables pour les livres, les genres, les sous-genres et leurs relations. Ta tâche est d'implémenter une fonction `recommend_books(genre)` qui renvoie une liste de livr... | ["\nassert recommend_books(\"Science Fiction\") == \"Dune by Frank Herbert (1965)\\nNeuromancer by William Gibson (1984)\"\n", "\nassert recommend_books(\"Fantasy\") == \"The Hobbit by J.R.R. Tolkien (1937)\\nHarry Potter and the Sorcerer's Stone by J.K. Rowling (1997)\"\n", "\nassert recommend_books(\"Mystery\") == \"... |
ec2956ec311d191e53110b83ee1bd0fc | [
{
"content": "On te donne un fichier CSV où la première colonne contient des identifiants uniques. Ta tâche est d'écrire une fonction Python nommée `read_csv_to_dict` qui lit ce fichier et renvoie un dictionnaire. Les clés du dictionnaire doivent être les valeurs de la première colonne, et les valeurs doivent ê... | ["\nassert read_csv_to_dict(\"test1.csv\") == {'key1': ['value1', 'value2'], 'key2': ['value3', 'value4']}\n", "\nassert read_csv_to_dict(\"test2.csv\") == {'1': ['2', '3'], '4': ['5', '6'], '7': ['8', '9']}\n", "\nassert read_csv_to_dict(\"test3.csv\") == {'a': ['b', 'c', 'd'], 'e': ['f', 'g', 'h']}\n", "\nassert read... |
083d7fad67e14ab5d1686d33f0a6ff2a | [
{
"content": "On te demande d'implémenter une classe Python nommée `FileProcessor` pour gérer les opérations de base sur les fichiers. La classe doit prendre en charge la lecture, l'écriture et l'ajout de contenu à un fichier. La classe doit être initialisée avec un chemin de fichier, et elle doit supposer que ... | ["\nassert FileProcessor(\"test.txt\").read_file() == \"\"\n", "\nprocessor = FileProcessor(\"test.txt\"); processor.write_file(\"Hello\"); assert processor.read_file() == \"Hello\"\n", "\nprocessor = FileProcessor(\"test.txt\"); processor.write_file(\"Hello\"); processor.append_to_file(\" World\"); assert processor.re... |
d6a16aa4748400e6ccaee617c59a9697 | [
{
"content": "On te donne une superficie forestière et tu dois calculer le Taux d'Utilisation de l'Espace (TUE) en fonction du Rapport de Couronne (RC) des arbres. Le TUE est calculé à l'aide de la formule suivante :\n\n\\[ \\text{TUE} = \\left(\\text{RC} \\times \\frac{\\pi}{12}\\right) \\]\n\nCette formule su... | ["\nassert calculate_space_utilization_ratio(0.5) == (0.5 * math.pi) / 12\n", "\nassert calculate_space_utilization_ratio(1.0) == (1.0 * math.pi) / 12\n", "\nassert calculate_space_utilization_ratio(0.75, 10) == (0.75 * 1.05 * math.pi) / 12\n", "\nassert calculate_space_utilization_ratio(0.8, -5) == (0.8 * 0.975 * math... |
21454e9783194697f7df385ea4833f1a | [
{
"content": "On te demande d'implémenter un arbre de recherche binaire (ARB) en Python. Ton ARB doit prendre en charge l'insertion de nouvelles valeurs et le parcours en ordre pour récupérer les valeurs dans l'ordre trié. Implémente une classe `TreeNode` avec les spécifications suivantes :\n\n- **Attributs :**... | ["\nassert TreeNode(5).inorder_traversal() == [5]\n", "\nassert TreeNode(5).insert(3) is None\n", "\nassert TreeNode(5).insert(7) is None\n", "\nroot = TreeNode(5)\nroot.insert(3)\nroot.insert(7)\nassert root.inorder_traversal() == [3, 5, 7]\n", "\nroot = TreeNode(5)\nroot.insert(3)\nroot.insert(2)\nroot.insert(4)\nroo... |
9c4d7ccfbf865fe38872b3f6b95c34f8 | [
{
"content": "On te demande d'implémenter une fonction pour une classe `Restaurant` qui traite les spécialités du jour. La classe `Restaurant` possède les attributs suivants : `name`, `menu` et, optionnellement, `daily_specials`. L'attribut `daily_specials` est un dictionnaire où les clés sont les noms des plat... | ["\nassert get_daily_specials(Restaurant(\"Bistro\", {}, {})) == None\n", "\nassert get_daily_specials(Restaurant(\"Bistro\", {}, {\"Pasta\": 12.99})) == {\"Pasta\": 11.69}\n", "\nassert get_daily_specials(Restaurant(\"Bistro\", {}, {\"Salad\": 8.50, \"Soup\": 5.75})) == {\"Salad\": 7.65, \"Soup\": 5.18}\n", "\nassert ... |
a4aee27566e6acf8ed9ae0c1dad00858 | [
{
"content": "On te donne une liste d'applications actives, où chaque application est représentée comme un tuple constitué de son nom et d'une liste d'URL auxquelles elle est enregistrée. Ta tâche est d'écrire une fonction `format_applications` qui prend cette liste en entrée et renvoie une chaîne formatée. La ... | ["\nassert format_applications([(\"App1\", [\"http://example.com/app1\", \"http://example.org/app1\"])]) == \"Active applications\\nApplication 'App1' registered as '<a href='http://example.com/app1?source=App1'>http://example.com/app1</a>, <a href='http://example.org/app1?source=App1'>http://example.org/app1</a>'\"\n"... |
e548378761f8116bac043b2d85051477 | [
{
"content": "On te donne une liste de chemins de fichiers, où chaque chemin de fichier est une chaîne de caractères représentant la structure de répertoires d'un fichier. Chaque chemin de fichier est constitué de noms de répertoires séparés par une barre oblique (\"/\"). Par exemple, un chemin de fichier pourr... | ["\nassert group_and_sort_paths([\"home/user/documents/file1.txt\", \"home/user/pictures/photo1.jpg\"], 2) == [\"home/user/documents/file1.txt\", \"home/user/pictures/photo1.jpg\"]\n", "\nassert group_and_sort_paths([\"home/user/documents/file1.txt\", \"home/user/documents/file2.txt\"], 2) == [\"home/user/documents/fil... |
2b621a3e3ef8a7ab3662fcf4e4ab8da2 | [
{
"content": "On te donne deux listes de chaînes de caractères, `list1` et `list2`. Ta tâche est d'écrire une fonction `generate_combinations(list1, list2)` qui renvoie une liste de toutes les combinaisons uniques triées lexicographiquement formées en concaténant chaque chaîne de caractères de `list1` avec chaq... | ["\nassert generate_combinations([\"apple\", \"banana\"], [\"pie\", \"smoothie\"]) == ['applepie', 'applesmoothie', 'bananapie', 'bananasmoothie']\n", "\nassert generate_combinations([\"a\", \"b\"], [\"c\", \"d\"]) == ['ac', 'ad', 'bc', 'bd']\n", "\nassert generate_combinations([\"x\"], [\"y\"]) == ['xy']\n", "\nassert... |
7b33ef6beddf84357f5fb983836ead13 | [
{
"content": "On te donne un objet JavaScript représentant un livre avec les propriétés suivantes : `title`, `author`, `publicationYear` et `ISBN`. Ta tâche est d'implémenter une fonction `formatBookInfo` qui accepte cet objet et renvoie une chaîne formatée. Le format de la chaîne de sortie doit être le suivant... | ["\nassert formatBookInfo({\"title\": \"1984\", \"author\": \"George Orwell\", \"publicationYear\": 1949, \"ISBN\": \"978-0-451-52493-5\"}) == \"Title: 1984, Author: George Orwell, Publication Year: 1949, ISBN: 978-0-451-52493-5\"\n", "\nassert formatBookInfo({\"title\": \"The Great Gatsby\", \"author\": \"F. Scott Fit... |
3869dbb433e24f00e45b8b7992571978 | [
{
"content": "On te donne une liste d'URL. Ta tâche est d'écrire une fonction Python qui renvoie un dictionnaire où chaque URL est une clé et son code d'état HTTP correspondant est la valeur. Si une URL est inaccessible ou qu'une erreur se produit, la valeur doit être une chaîne indiquant l'erreur.\n\n**Entrée ... | ["\nassert get_status_codes([\"http://example.com\"])[\"http://example.com\"] == 200\n", "\nassert isinstance(get_status_codes([\"http://nonexistentwebsite123.com\"])[\"http://nonexistentwebsite123.com\"], str)\n", "\nassert \"Error\" in get_status_codes([\"http://nonexistentwebsite123.com\"])[\"http://nonexistentwebsi... |
96514349d7b66a1f40f4188cd68b2d03 | [
{
"content": "On te donne deux tableaux d'entiers triés, `list_a` et `list_b`, où `list_a` a suffisamment d'espace à la fin pour accueillir tous les éléments de `list_b`. Ta tâche est de fusionner `list_b` dans `list_a` de manière à ce que `list_a` reste trié. Le processus de fusion doit commencer par la fin de... | ["\nassert merge_from_end([1, 3, 5, 0, 0, 0], [2, 4, 6]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_from_end([1, 2, 3, 0, 0, 0], [4, 5, 6]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_from_end([0, 0, 0], [1, 2, 3]) == [1, 2, 3]\n", "\nassert merge_from_end([1, 2, 3], []) == [1, 2, 3]\n", "\nassert merge_from_end([], [1, 2... |
499cc2f1d9bbb8a0e5362cd7c9ab6fd6 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python qui modélise une voiture avec des attributs tels que la marque, le modèle, l'année et le nombre de miles parcourus. La classe doit inclure des méthodes pour mettre à jour le nombre de miles parcourus, afficher les informations de la voiture et... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020).display_info() == \"Car(make=Toyota, model=Corolla, year=2020, miles_driven=0)\"\n", "\nassert Car(\"Honda\", \"Civic\", 2019, 10000).display_info() == \"Car(make=Honda, model=Civic, year=2019, miles_driven=10000)\"\n", "\nassert Car(\"Ford\", \"Mustang\", 1965).display_inf... |
34552cd182e074c12d567b4867c3ef8c | [
{
"content": "On te donne un fichier CSV et un nom de colonne en entrée. Ta tâche est d'écrire un script Python qui lit le fichier CSV et calcule la moyenne et l'écart type de la colonne spécifiée. Le script doit gérer les erreurs telles que les fichiers manquants, les colonnes inexistantes et les données non n... | ["\nassert calculate_statistics(\"test.csv\", \"age\") == None # Assuming test.csv has a column 'age' with numeric data\n", "\nassert calculate_statistics(\"nonexistent.csv\", \"age\") == None # File does not exist\n", "\nassert calculate_statistics(\"test.csv\", \"nonexistent_column\") == None # Column does not exi... |
073697f9b1afdb20aa20c421474e8d4c | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères alphanumériques et de symboles spéciaux. Ta tâche est de mettre en œuvre une fonction `pair_count` qui renvoie le nombre de paires de caractères alphabétiques consécutifs répétés dans la chaîne. Une paire est définie comme deux caract... | ["\nassert pair_count(\"a#abb&c\") == 2\n", "\nassert pair_count(\"aabbcc\") == 0\n", "\nassert pair_count(\"a#b#c#d#e\") == 0\n", "\nassert pair_count(\"aa#bb##cc\") == 3\n", "\nassert pair_count(\"a##a##a\") == 2\n", "\nassert pair_count(\"a#b#b#c#c\") == 2\n", "\nassert pair_count(\"a#b#c#d#e#f#f\") == 1\n", "\nasse... |
e60c71542d33bef23c6c5ca8f7f19428 | [
{
"content": "On te donne une fonction `float2bin(x)` qui convertit un nombre à virgule flottante `x` en sa représentation binaire sous forme de chaîne de 32 bits. Ta tâche est d'implémenter une fonction `bin2float(s)` qui effectue l'opération inverse. Plus précisément, `bin2float(s)` doit prendre une chaîne bi... | ["\nassert bin2float('01000000101000000000000000000000') == 5.0\n", "\nassert bin2float('11000000101000000000000000000000') == -5.0\n", "\nassert bin2float('00111111100000000000000000000000') == 1.0\n", "\nassert bin2float('10111111100000000000000000000000') == -1.0\n", "\nassert bin2float('1000000011111111111111111111... |
bf1747cd4496efde86cca5f6a2b52fc8 | [
{
"content": "On te donne trois listes : `names`, `midterm_scores` et `final_scores`. Chaque liste contient `n` éléments, et les éléments à la même index dans chaque liste correspondent au même étudiant. La liste `names` contient les noms des étudiants, tandis que les listes `midterm_scores` et `final_scores` c... | ["\nassert calculate_total_scores([\"Alice\", \"Bob\", \"Charlie\"], [70, 90, 40], [80, 45, 60]) == {'Alice': 150, 'Bob': 90, 'Charlie': 60}\n", "\nassert calculate_total_scores([\"Alice\", \"Bob\", \"Charlie\"], [40, 45, 40], [60, 55, 50]) == {'Alice': 60, 'Bob': 55, 'Charlie': 50}\n", "\nassert calculate_total_scores... |
98e6aef952bc5ce499deec6f713ed8d4 | [
{
"content": "On te donne une chaîne de caractères `equation` représentant une expression mathématique en notation infixe. L'expression est composée d'entiers non négatifs et des opérateurs `+`, `-`, `*` et `/`. Ta tâche est d'écrire une fonction `simplify_equation(equation)` qui simplifie l'expression à sa for... | ["\nassert simplify_equation(\"2 + 3\") == \"5\"\n", "\nassert simplify_equation(\"10 - 5\") == \"5\"\n", "\nassert simplify_equation(\"4 * 3\") == \"12\"\n", "\nassert simplify_equation(\"8 / 2\") == \"4\"\n", "\nassert simplify_equation(\"(2 + 3) * 4\") == \"20\"\n", "\nassert simplify_equation(\"10 / (2 + 3)\") == \... |
db1e6b7b7e0e91d27e14c53e038fb444 | [
{
"content": "On te donne un fichier CSV nommé `grades.csv` contenant des données sur les notes des élèves. Chaque ligne du fichier représente un élève et ses notes dans différentes matières. La première colonne contient le nom de l'élève, et les colonnes suivantes contiennent ses notes sous forme de nombres à ... | ["\nassert calculate_average_grades('test_input_1.csv', 'test_output_1.csv') is None\n", "\nassert calculate_average_grades('test_input_2.csv', 'test_output_2.csv') is None\n", "\nassert calculate_average_grades('test_input_3.csv', 'test_output_3.csv') is None\n", "\nassert calculate_average_grades('test_input_4.csv', ... |
efeaf1fe5517cb88b2d74eb9c4480aad | [
{
"content": "On te donne pour tâche d'implémenter une fonction `apply_transformation` qui applique une transformation mathématique spécifiée à une valeur d'entrée. Les fonctions de transformation doivent être implémentées en utilisant la récursion, sans utiliser de boucles ni de fonctions Python intégrées comm... | ["\nassert apply_transformation(2, 'square') == 4\n", "\nassert apply_transformation(3, 'cube') == 27\n", "\nassert apply_transformation(4, 'inverse') == 0.25\n", "\nassert apply_transformation(5, 'square', {'square': lambda x: x * x}) == 25\n", "\nassert apply_transformation(2, 'custom', {'custom': lambda x: x + 1}) =... |
55ef966a1c466207add7c41c33cb3715 | [
{
"content": "On te donne une chaîne hexadécimale `hex_string` et un entier `n` (la valeur par défaut est 2). Ta tâche est de convertir la chaîne hexadécimale en sa représentation décimale, mais de ne considérer que les `n` chiffres non nuls les moins significatifs. Si `n` est 0, considère tous les chiffres non... | ["\nassert hex_to_decimal_digits(\"1a3f\", 2) == 63\n", "\nassert hex_to_decimal_digits(\"1a3f\", 0) == 6719\n", "\nassert hex_to_decimal_digits(\"0000\", 2) == 0\n", "\nassert hex_to_decimal_digits(\"abc\", 1) == 12\n", "\nassert hex_to_decimal_digits(\"abc\", 3) == 2748\n", "\nassert hex_to_decimal_digits(\"123456789... |
c62e6ff8ac25def67033a71f7559a298 | [
{
"content": "Tu participes à une compétition de classification d'images où les images sont catégorisées dans l'une de 10 classes distinctes. Chaque image est représentée comme un tenseur de forme (batch_size, 3, 28, 28), avec 3 canaux de couleur et une résolution de 28x28 pixels. Les étiquettes de ces images s... | ["\nassert torch.equal(one_hot_encode(torch.tensor([0]), 10), torch.tensor([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]))\n", "\nassert torch.equal(one_hot_encode(torch.tensor([9]), 10), torch.tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]))\n", "\nassert torch.equal(one_hot_encode(torch.tensor([1, 2]), 10), torch.tensor([[0, 1, 0, 0, 0,... |
cc9015c87b5ec9970ba3484d6fce7c5b | [
{
"content": "Tu es chargé d'implémenter une classe `Book` pour gérer les informations des livres. La classe doit stocker les attributs suivants : `title`, `author` et `published_year`. Implémente une méthode `info()` qui renvoie une chaîne formatée contenant les détails du livre sous la forme : \"Title: {title... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).info() == \"Title: 1984, Author: George Orwell, Published Year: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).info() == \"Title: To Kill a Mockingbird, Author: Harper Lee, Published Year: 1960\"\n", "\nassert Book(\"The Great Gatsby\", \"F.... |
421084bb1452ea8296c275369c053352 | [
{
"content": "On te donne une liste de dictionnaires. Ta tâche est d'implémenter une fonction `group_dicts_by_key(dicts, key)` qui regroupe ces dictionnaires en fonction de la valeur associée à une clé spécifiée. La fonction doit renvoyer un dictionnaire où chaque clé est une valeur unique de la clé spécifiée d... | ["\nassert group_dicts_by_key([{'a': 1}, {'a': 2}, {'a': 1}], 'a') == {1: [{'a': 1}, {'a': 1}], 2: [{'a': 2}]}\n", "\nassert group_dicts_by_key([{'b': 'x'}, {'b': 'y'}, {'b': 'x'}], 'b') == {'x': [{'b': 'x'}, {'b': 'x'}], 'y': [{'b': 'y'}]}\n", "\nassert group_dicts_by_key([{'c': 3}, {'d': 4}, {'c': 3}], 'c') == {3: [{... |
1ae5588c6bf73620617dce526a6c728d | [
{
"content": "On te donne un répertoire téléphonique représenté sous forme de dictionnaire où chaque clé est un nom complet au format \"Prénom Nom\" et chaque valeur est le numéro de téléphone correspondant. Ta tâche est d'écrire une fonction qui prend ce dictionnaire en entrée et renvoie une liste de noms trié... | ["\nassert sort_phone_book_by_last_name({\"John Doe\": \"123-456-7890\", \"Jane Smith\": \"987-654-3210\"}) == [\"Jane Smith\", \"John Doe\"]\n", "\nassert sort_phone_book_by_last_name({\"Alice Johnson\": \"555-123-4567\", \"Bob Johnson\": \"555-987-6543\", \"Charlie Brown\": \"555-555-5555\"}) == [\"Charlie Brown\", \... |
5662d958890704578f61361ad99536b9 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author` et `ISBN`. Pour chaque attribut, tu dois fournir des méthodes getter et setter. De plus, la classe doit inclure une méthode `info()` qui renvoie une chaîne formatée comme `Title... | ["\nassert Book(\"1984\", \"George Orwell\", \"0451524934980\").get_title() == \"1984\"\n", "\nassert Book(\"1984\", \"George Orwell\", \"0451524934980\").get_author() == \"George Orwell\"\n", "\nassert Book(\"1984\", \"George Orwell\", \"0451524934980\").get_isbn() == \"0451524934980\"\n", "\nassert Book(\"1984\", \"G... |
cd20cde8fed34f2a48e53fe1dcc2f4ac | [
{
"content": "On te donne deux entiers, `start` et `end`. Ta tâche est d'écrire une fonction `countSetBitsInRange(start, end)` qui calcule le nombre total de bits à 1 dans la représentation binaire de tous les entiers de `start` à `end` (inclus). Tu dois calculer manuellement les bits à 1 pour chaque nombre dan... | ["\nassert countSetBitsInRange(0, 0) == 0\n", "\nassert countSetBitsInRange(1, 1) == 1\n", "\nassert countSetBitsInRange(2, 2) == 1\n", "\nassert countSetBitsInRange(3, 3) == 2\n", "\nassert countSetBitsInRange(0, 3) == 4\n", "\nassert countSetBitsInRange(4, 7) == 8\n", "\nassert countSetBitsInRange(8, 15) == 16\n", "\... |
eb290e8434b79b9ce4f3f0a05bfdca68 | [
{
"content": "On te donne un nombre à virgule flottante représentant une durée en secondes avec une précision au millième de seconde. Ta tâche est de convertir cette durée en une chaîne formatée. Le format doit être \"HH:MM:SS,MS\" pour les durées inférieures à 24 heures, et \"JJ HH:MM:SS,MS\" pour les durées d... | ["\nassert format_duration(0) == \"00:00:00,00\"\n", "\nassert format_duration(59.999) == \"00:00:59,99\"\n", "\nassert format_duration(60) == \"00:01:00,00\"\n", "\nassert format_duration(3600) == \"01:00:00,00\"\n", "\nassert format_duration(86400) == \"1 00:00:00,00\"\n", "\nassert format_duration(86400.123) == \"1 ... |
e1df3bb17050560f9bf3eab24ee04d69 | [
{
"content": "On te demande de créer un programme qui génère une grille de Sudoku 5x5 valide et solvable. La grille doit être affichée sur la console avec certains chiffres supprimés pour former l'énigme. Le programme doit s'assurer que la grille générée a une solution unique.\n\n**Entrée :**\nAucune entrée n'e... | ["\nassert generate_sudoku() is not None\n", "\nassert all(len(row) == 5 for row in generate_sudoku())\n", "\nassert all(isinstance(num, int) and 0 <= num <= 5 for row in generate_sudoku() for num in row)\n", "\nassert sum(row.count(0) for row in generate_sudoku()) >= 12\n", "\nassert sum(row.count(0) for row in genera... |
0625b535462a19263b05f8cfe6c38fbe | [
{
"content": "On te donne une chaîne de caractères contenant des nombres séparés par des espaces ou des virgules. Ta tâche est d'écrire une fonction `sum_from_string(input_string)` qui calcule la somme de tous les nombres consécutifs uniques dans la chaîne. Les nombres peuvent être positifs, négatifs ou décimau... | ["\nassert sum_from_string(\"1 2 3\") == 6\n", "\nassert sum_from_string(\"1,2,3\") == 6\n", "\nassert sum_from_string(\"1 2 2 3\") == 6\n", "\nassert sum_from_string(\"1,2,2,3\") == 6\n", "\nassert sum_from_string(\"1.5 2.5 3.5\") == 7.5\n", "\nassert sum_from_string(\"1.5,2.5,3.5\") == 7.5\n", "\nassert sum_from_stri... |
d1fcbd089533563f22be55d759044784 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de créer une nouvelle liste où les éléments aux indices impairs sont inversés, tandis que les éléments aux indices pairs restent à leurs positions d'origine. Écris une fonction `reverse_odd_indexed_elements` qui prend une liste d'entiers en entrée et r... | ["\nassert reverse_odd_indexed_elements([1, 2, 3, 4, 5, 6, 7, 8]) == [1, 8, 3, 6, 5, 4, 7, 2]\n", "\nassert reverse_odd_indexed_elements([10, 11, 12, 13, 14, 15]) == [10, 15, 12, 13, 14, 11]\n", "\nassert reverse_odd_indexed_elements([1, 3, 5, 7, 9]) == [1, 7, 5, 3, 9]\n", "\nassert reverse_odd_indexed_elements([2, 4, ... |
125a9ee8122ad5abde2c83e36d00a868 | [
{
"content": "On te donne un ensemble `set5`. Ta tâche est d'écrire une fonction `find_divisible_numbers(set5)` qui met à jour cet ensemble en ajoutant tous les nombres impairs entre 0 et 30 (inclus) qui sont divisibles par 5. La fonction doit ensuite renvoyer l'ensemble mis à jour.\n\n**Exemple d'entrée :**\n`... | ["\nassert find_divisible_numbers(set()) == {5, 15, 25}\n", "\nassert find_divisible_numbers({1, 2, 3}) == {1, 2, 3, 5, 15, 25}\n", "\nassert find_divisible_numbers({5, 15, 25}) == {5, 15, 25}\n", "\nassert find_divisible_numbers({0, 2, 4, 6, 8}) == {0, 2, 4, 6, 8, 5, 15, 25}\n", "\nassert find_divisible_numbers({10, 2... |
e89ec44a946f77c16d524c33a63f55ac | [
{
"content": "On te donne une chaîne de caractères `S` et une sous-chaîne `T`. Ta tâche est de mettre en œuvre une fonction qui supprime toutes les occurrences de `T` de `S` de manière insensible à la casse et renvoie la chaîne résultante.\n\n**Entrée :**\n- La première ligne contient la chaîne `S` (1 ≤ |S| ≤ 1... | ["\nassert remove_substring_case_insensitive(\"Hello World\", \"world\") == \"Hello \"\n", "\nassert remove_substring_case_insensitive(\"Python is fun\", \"PYTHON\") == \" is fun\"\n", "\nassert remove_substring_case_insensitive(\"Case Insensitive\", \"insensitive\") == \"Case \"\n", "\nassert remove_substring_case_ins... |
b50d33627f6a1a04f474fa1908d88892 | [
{
"content": "On te donne une chaîne de caractères `s` composée à la fois de caractères alphabétiques et non alphabétiques. Implémente une fonction `filter_repeats` qui traite la chaîne selon les règles suivantes :\n- Aucun caractère ne doit apparaître plus de deux fois consécutivement. Pour les caractères non ... | ["\nassert filter_repeats(\"aaabbbccc11122334455\") == \"97ab99c12345\"\n", "\nassert filter_repeats(\"aabbcc\") == \"97ab99c\"\n", "\nassert filter_repeats(\"abc\") == \"97bc\"\n", "\nassert filter_repeats(\"aaa\") == \"97a\"\n", "\nassert filter_repeats(\"111222333\") == \"4912233\"\n", "\nassert filter_repeats(\"!@#... |
ec57559e5c58b690662baae1a70c7fb8 | [
{
"content": "On te donne un tableau multidimensionnel (tenseur) représenté sous forme de listes imbriquées et un entier `k` représentant le nombre de dimensions non principales dans le tenseur. Ta tâche est d'écrire une fonction qui infère le nombre de dimensions principales, la taille des première et deuxième... | ["\nassert infer_tensor_shape([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], 2) == (2, 2, 2, [])\n", "\nassert infer_tensor_shape([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], 1) == (2, 2, 2, [2, 2])\n", "\nassert infer_tensor_shape([[1, 2, 3], [4, 5, 6]], 1) == (1, 2, 1, [3])\n", "\nassert infer_tensor_shape([[1, 2, 3], [4, 5, 6]], 0)... |
3d168d8642282415c2b6bc49f3848499 | [
{
"content": "On te donne la tâche de calculer l'\"intensité de couleur\" d'un pixel dans une image. L'intensité de couleur est une mesure de la luminosité du pixel, dérivée de ses valeurs rouge, verte et bleue (RVB). Chaque valeur RVB est un entier dans la plage [0, 255]. L'intensité de couleur est calculée co... | ["\nassert calculate_color_intensity(128, 128, 128) == 21845\n", "\nassert calculate_color_intensity(255, 0, 0) == 43690\n", "\nassert calculate_color_intensity(0, 255, 0) == 43690\n", "\nassert calculate_color_intensity(0, 0, 255) == 43690\n", "\nassert calculate_color_intensity(255, 255, 255) == 65535\n", "\nassert c... |
26c63c5ba1664f590673a87fcaf01e68 | [
{
"content": "On te demande d'implémenter un algorithme de tri connu sous le nom de \"Tri Cocktail Shaker\" pour trier une liste donnée d'entiers par ordre croissant. Contrairement au tri à bulles traditionnel, le tri Cocktail Shaker trie dans les deux sens, en alternant entre des passes de gauche à droite et d... | ["\nassert cocktail_shaker_sort([3, 1, 5, 4, 2]) == [1, 2, 3, 4, 5]\n", "\nassert cocktail_shaker_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert cocktail_shaker_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert cocktail_shaker_sort([10, -1, 2, 5, 0, 6, 4, -5]) == [-5, -1, 0, 2, 4, 5, 6, 10]\n", "\nassert c... |
c4950f4f6beadfe4e5f5344d8453c2be | [
{
"content": "Tu es un agriculteur qui sélectionne une espèce unique de lapins. Chaque paire de lapins adultes donne naissance à `k` nouvelles paires chaque mois, mais les lapins nouveau-nés mettent un mois à arriver à maturité. De plus, les lapines alternent leur capacité de reproduction tous les deux mois. Pl... | ["\nassert rabbit_breeding(0, 2) == 1\n", "\nassert rabbit_breeding(1, 2) == 1\n", "\nassert rabbit_breeding(2, 2) == 2\n", "\nassert rabbit_breeding(3, 2) == 3\n", "\nassert rabbit_breeding(4, 2) == 5\n", "\nassert rabbit_breeding(5, 2) == 8\n", "\nassert rabbit_breeding(6, 2) == 13\n", "\nassert rabbit_breeding(5, 3)... |
df88d845340efc7c9aab21734ea972c0 | [
{
"content": "On te donne une liste de `n` points distincts dans un plan 2D, où chaque point est représenté comme un tuple `(x, y)`. Ta tâche est d'écrire une fonction qui trie ces points dans le sens inverse des aiguilles d'une montre autour de leur centroïde. Tu ne dois pas utiliser de fonctions de tri intégr... | ["\nassert sort_points_around_centroid([(1, 1), (3, 1), (2, 3), (1, 3)]) == [(2, 3), (1, 3), (1, 1), (3, 1)]\n", "\nassert sort_points_around_centroid([(0, 0), (1, 0), (0, 1)]) == [(0, 1), (1, 0), (0, 0)]\n", "\nassert sort_points_around_centroid([(1, 1), (1, 2), (2, 1), (2, 2)]) == [(1, 2), (2, 2), (2, 1), (1, 1)]\n",... |
f51737a0c7e5abc9ad84280b7f77d7c4 | [
{
"content": "On te donne deux nombres à virgule flottante `a` et `b`, ainsi qu’un petit nombre positif `epsilon`. Ta tâche est de mettre en œuvre une fonction `is_close_enough(a, b, epsilon)` qui renvoie `True` si la différence relative entre `a` et `b` est inférieure ou égale à `epsilon`. La différence relati... | ["\nassert is_close_enough(1.0, 1.0, 0.01) == True\n", "\nassert is_close_enough(1.0, 1.01, 0.01) == True\n", "\nassert is_close_enough(1.0, 1.02, 0.01) == False\n", "\nassert is_close_enough(0.0, 0.0, 0.01) == True\n", "\nassert is_close_enough(0.0, 0.01, 0.01) == True\n", "\nassert is_close_enough(0.0, 0.02, 0.01) ==... |
7c664e34aedd894d7581126dcd1e2130 | [
{
"content": "On te donne la tâche de concevoir un générateur de fonction qui produit une fonction signal en échelon. Un signal en échelon change de valeur à des moments spécifiques et reste constant par la suite. Ton travail consiste à implémenter la fonction `step_signal_generator` qui accepte une liste de tu... | ["\nassert step_signal_generator([(1, 2), (3, 5), (5, 3)])(0) == 0\n", "\nassert step_signal_generator([(1, 2), (3, 5), (5, 3)])(2) == 2\n", "\nassert step_signal_generator([(1, 2), (3, 5), (5, 3)])(4) == 5\n", "\nassert step_signal_generator([(1, 2), (3, 5), (5, 3)])(6) == 3\n", "\nassert step_signal_generator([(0, 10... |
c3a1d00e0eedc104e87976a4e8136f36 | [
{
"content": "On te demande d'implémenter une fonction pour déterminer si une chaîne de caractères donnée est une adresse e-mail valide. La fonction doit utiliser des expressions régulières pour effectuer la validation. Ta fonction doit renvoyer `True` si la chaîne est une adresse e-mail valide, et `False` sino... | ["\nassert is_valid_email(\"example@example.com\") == True\n", "\nassert is_valid_email(\"user.name+tag+sorting@example.com\") == True\n", "\nassert is_valid_email(\"user@sub.example.com\") == True\n", "\nassert is_valid_email(\"user@123.123.123.123\") == True\n", "\nassert is_valid_email(\"user@[IPv6:2001:db8::1]\") =... |
e058432148f60a346d221488a295c646 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si `s` est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**E... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Hello, World!\") == False\n", "\nassert is... |
5bb950968c3e0dadc887621e71babb1e | [
{
"content": "On te donne un tableau de base de données `orders` avec le schéma suivant : `id` (entier), `customer_id` (entier), `product_id` (entier), `quantity` (entier), `price` (flottant). Ta tâche est d'écrire une fonction Python qui génère une requête SQL paramétrée pour calculer le revenu total (quantity... | ["\nassert generate_sql_query([1, 2, 3]) == (\"SELECT customer_id, SUM(quantity * price) AS total_revenue\\nFROM orders\\nWHERE customer_id IN (%s, %s, %s)\\nGROUP BY customer_id;\", [1, 2, 3])\n", "\nassert generate_sql_query([10]) == (\"SELECT customer_id, SUM(quantity * price) AS total_revenue\\nFROM orders\\nWHERE ... |
5d9066180f7800e8e616341a92a05297 | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces. Chaque mot peut contenir des signes de ponctuation. Ton objectif est d'écrire une fonction qui inverse chaque mot de la chaîne tout en conservant l'ordre original des mots. La fonction doit gérer correctement la p... | ["\nassert reverse_words_in_sentence(\"Hello world\") == \"olleH dlrow\"\n", "\nassert reverse_words_in_sentence(\"Python is fun!\") == \"nohtyP si !nuf\"\n", "\nassert reverse_words_in_sentence(\"Keep it simple.\") == \"peeK ti .elpmis\"\n", "\nassert reverse_words_in_sentence(\"A quick brown fox.\") == \"A kciuq nwor... |
501f514d0ccb76b623ef3fdc89bf3fdb | [
{
"content": "On te donne un fichier CSV nommé `memory.csv` contenant une liste d'emplacements mémoire et leurs valeurs entières correspondantes. Chaque ligne du fichier CSV se compose de deux valeurs séparées par une virgule : l'emplacement mémoire (un index entier commençant à 0) et la valeur stockée à cet em... | ["\nassert read_memory_locations(\"test1.csv\") == {0: 10, 1: 20, 2: 30}\n", "\nassert read_memory_locations(\"test2.csv\") == {100: 1000, 200: 2000, 300: 3000}\n", "\nassert read_memory_locations(\"test3.csv\") == {0: 1, 2: 3, 4: 5}\n", "\nassert read_memory_locations(\"test4.csv\") == {}\n", "\nassert read_memory_loc... |
968ac17e16e2347341b725cba4ebbe61 | [
{
"content": "Tu es chargé d'implémenter une fonction pour valider les numéros de carte de crédit en utilisant l'algorithme de Luhn. Ta fonction doit prendre un numéro de carte de crédit en entrée et renvoyer `True` si le numéro est valide, et `False` sinon. Le numéro de carte de crédit peut être fourni sous fo... | ["\nassert validate_credit_card_number(\"4539 1488 0343 6467\") == True\n", "\nassert validate_credit_card_number(\"6771 7992 5274 2936\") == False\n", "\nassert validate_credit_card_number(\"1234 5678 1234 5670\") == True\n", "\nassert validate_credit_card_number(\"4992 7398 716\") == True\n", "\nassert validate_credi... |
4e2465abe09fb263701e9989cdf8a1cb | [
{
"content": "On te donne une liste triée d'entiers `nums` et un entier cible `target`. Ta tâche est de trouver l'indice de la première occurrence de `target` dans `nums` en utilisant un algorithme de recherche binaire. Si `target` n'est pas présent dans `nums`, renvoie -1. Note que `nums` peut contenir des élé... | ["\nassert find_first_occurrence([1, 2, 3, 3, 3, 4, 5], 3) == 2\n", "\nassert find_first_occurrence([1, 1, 1, 1, 1, 1, 1], 1) == 0\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5, 6, 7], 7) == 6\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5, 6, 7], 1) == 0\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5, 6, ... |
dbd6e98c59c6accb60be6cef4249229c | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est de déterminer s'il est possible de partitionner la liste en deux sous-ensembles tels que la somme des éléments de chaque sous-ensemble soit égale. C'est ce qu'on appelle le problème de partition. Écris une fonction `can_partition(nums)` qui renv... | ["\nassert can_partition([1, 5, 11, 5]) == True\n", "\nassert can_partition([1, 2, 3, 5]) == False\n", "\nassert can_partition([1, 2, 3, 4, 5, 6, 7]) == True\n", "\nassert can_partition([1, 2, 3, 4, 5, 6, 14]) == False\n", "\nassert can_partition([1, 1, 1, 1, 1, 1, 1, 1]) == True\n", "\nassert can_partition([100]) == F... |
1de3e6e2f76f6181c947580cec36b4b6 | [
{
"content": "On te donne un tableau `nums` de `n` entiers. Ta tâche est de trouver le plus petit entier positif qui n'apparaît pas dans le tableau. Si le tableau est vide ou ne contient pas d'entiers positifs, retourne 1. Ta solution doit s'exécuter en temps O(n) et ne doit utiliser aucune structure de données... | ["\nassert find_smallest_positive([3, 4, -1, 1]) == 2\n", "\nassert find_smallest_positive([1, 2, 0]) == 3\n", "\nassert find_smallest_positive([7, 8, 9, 11, 12]) == 1\n", "\nassert find_smallest_positive([1, 2, 3]) == 4\n", "\nassert find_smallest_positive([]) == 1\n", "\nassert find_smallest_positive([-1, -2, -3]) ==... |
ac0693931d587c86d831be425c74b4a6 | [
{
"content": "On te donne un chemin de fichier et une liste de motifs glob personnalisés. Ta tâche est de déterminer si le chemin de fichier correspond à l'un des motifs. Les motifs glob personnalisés utilisent `#` pour correspondre à n'importe quelle séquence de caractères et `@` pour correspondre à n'importe ... | ["\nassert custom_glob_match(\"fileA.txt\", [\"file@.txt\", \"file#.txt\"]) == True\n", "\nassert custom_glob_match(\"file123.txt\", [\"file#.txt\"]) == True\n", "\nassert custom_glob_match(\"file.txt\", [\"file@.txt\"]) == True\n", "\nassert custom_glob_match(\"fileA.txt\", [\"fileB.txt\"]) == False\n", "\nassert cust... |
68b93605ab803cc0801bcc2e9bac531b | [
{
"content": "On te donne une grille 3D de données représentée comme un tenseur 5D de forme `(batch_size, channels, H, W, D)`. Chaque élément de ce tenseur représente une valeur de caractéristique à un emplacement spécifique dans l'espace 3D. De plus, on te fournit un ensemble de coordonnées 3D, représentées co... | ["\nassert bilinear_interpolate_3d(torch.randn(1, 1, 2, 2, 2), torch.tensor([[[0.5, 0.5, 0.5]]])).shape == torch.Size([1, 1, 1])\n", "\nassert torch.allclose(bilinear_interpolate_3d(torch.tensor([[[[[1.]]]]]), torch.tensor([[[0., 0., 0.]]])), torch.tensor([[[1.]]]))\n", "\nassert torch.allclose(bilinear_interpolate_3d(... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.