id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
f22fb5aedca338005752f56f821ff0c4 | [
{
"content": "Tu es chargé de mettre en œuvre une fonction qui convertit un entier en sa représentation en chiffres romains. La fonction doit gérer les entiers dans la plage de 1 à 3999 inclus. Ta solution doit être efficace et concise.\n\n**Exemple d'entrée :**\n```\n1987\n```\n\n**Exemple de sortie :**\n```\n... | ["\nassert int_to_roman(1) == \"I\"\n", "\nassert int_to_roman(4) == \"IV\"\n", "\nassert int_to_roman(9) == \"IX\"\n", "\nassert int_to_roman(58) == \"LVIII\"\n", "\nassert int_to_roman(1994) == \"MCMXCIV\"\n", "\nassert int_to_roman(3999) == \"MMMCMXCIX\"\n", "\nassert int_to_roman(44) == \"XLIV\"\n", "\nassert int_t... |
5724174a5e75f87c3ea7e9a186773798 | [
{
"content": "On te donne une chaîne de caractères `s` qui peut contenir des parenthèses imbriquées. Ta tâche est d'implémenter la fonction `clean_string(s)` qui traite la chaîne selon les règles suivantes :\n\n1. Supprime tous les caractères qui apparaissent à un quelconque niveau de parenthèses imbriquées.\n2... | ["\nassert clean_string(\"hello (world)\") == \"hello\"\n", "\nassert clean_string(\"(hello) world\") == \"world\"\n", "\nassert clean_string(\"he(llo) world\") == \"helloworld\"\n", "\nassert clean_string(\"he(llo(wor)ld)\") == \"helloorld\"\n", "\nassert clean_string(\"he(llo(wor)ld)!\") == \"helloorld!\"\n", "\nasse... |
63edd874c9e7d514ec198dd6fe65e029 | [
{
"content": "On te donne une liste d'adresses e-mail. Ta tâche est d'implémenter une fonction `filter_invalid_emails` qui renvoie une liste contenant uniquement les adresses e-mail valides. Une adresse e-mail est considérée comme valide si elle correspond au modèle d'expression régulière `[a-zA-Z0-9_.+-]+@[a-z... | ["\nassert filter_invalid_emails([\"test.email+alex@leetcode.com\"]) == [\"test.email+alex@leetcode.com\"]\n", "\nassert filter_invalid_emails([\"invalid-email@.com\"]) == []\n", "\nassert filter_invalid_emails([\"another.invalid@com\"]) == []\n", "\nassert filter_invalid_emails([\"valid.email@domain.com\"]) == [\"vali... |
89699418a0dc9a3be40b550f872957cb | [
{
"content": "On te donne une liste de chaînes HTML, chacune représentant une ligne de tableau avec plusieurs cellules. Ta tâche est d'écrire une fonction qui extrait le contenu textuel de chaque cellule, supprime les puces (•), et renvoie une liste de chaînes nettoyées. Tu ne dois pas utiliser de bibliothèques... | ["\nassert extract_and_clean_table_row_data([\"<tr><td>\u2022 Item 1</td><td>\u2022 Item 2</td></tr>\"]) == [\" Item 1\", \" Item 2\"]\n", "\nassert extract_and_clean_table_row_data([\"<tr><td>\u2062\u2022\u2062 Red</td><td>\u2022 Blue</td><td>Green</td></tr>\"]) == [\"\u2062 Red\", \" Blue\", \"Green\"]\n", "\nassert ... |
31716760fd1afe9da6d3c2716a3494c3 | [
{
"content": "On te donne un fichier texte nommé `urls.txt` qui contient une liste d'URL, une par ligne. Ta tâche est d'écrire une fonction Python `filter_urls` qui lit ce fichier, filtre toutes les URL qui ne commencent pas par `http://` ou `https://`, et écrit les URL restantes dans un nouveau fichier nommé `... | ["\nassert open('filtered_urls.txt').read() == '' if not open('urls.txt').read() else True\n", "\nassert open('filtered_urls.txt').read() == 'http://example.com\\n' if open('urls.txt').read() == 'http://example.com\\n' else True\n", "\nassert open('filtered_urls.txt').read() == 'https://example.com\\n' if open('urls.tx... |
cde3611d882353648ab8de40cc3a70fe | [
{
"content": "On te donne une chaîne de caractères `s` et une liste de chaînes de caractères `lst_strings`. Ta tâche est de déterminer si `s` se termine par l'une des sous-chaînes de `lst_strings`, en ignorant les caractères non alphanumériques en fin de chaîne `s`. Retourne `True` si cette condition est rempli... | ["\nassert ends_with_any_substring(\"hello!\", [\"lo\", \"world\"]) == True\n", "\nassert ends_with_any_substring(\"hello world!!!\", [\"world\", \"hello\"]) == True\n", "\nassert ends_with_any_substring(\"hello world!!!\", [\"planet\", \"galaxy\"]) == False\n", "\nassert ends_with_any_substring(\"test123\", [\"123\", ... |
2a4bbb776ba56c5ea7384c0a43bcacf6 | [
{
"content": "On te demande d'implémenter une fonction `dec_to_base_n(num, base)` qui convertit un entier décimal donné `num` en sa représentation sous forme de chaîne dans une base spécifiée `base`. La chaîne résultante doit être complétée avec des zéros en tête pour garantir qu'elle ait une longueur minimale ... | ["\nassert dec_to_base_n(0, 2) == \"00000000\"\n", "\nassert dec_to_base_n(255, 16) == \"000000FF\"\n", "\nassert dec_to_base_n(10, 2) == \"00001010\"\n", "\nassert dec_to_base_n(123456, 10) == \"01234560\"\n", "\nassert dec_to_base_n(1, 36) == \"00000001\"\n", "\nassert dec_to_base_n(35, 36) == \"0000000Z\"\n", "\nass... |
351e61eccacd7b2b01b7ae71f9a431d3 | [
{
"content": "Tu développes un système de pagination pour une application web. Implémente une fonction `generate_pagination(total, current)` qui renvoie deux listes : une pour les numéros de page à afficher et une autre pour les numéros de page masqués. La fonction doit prendre deux paramètres :\n- `total` : un... | ["\nassert generate_pagination(10, 5) == ([3, 4, 5, 6, 7], [1, 2, 8, 9, 10])\n", "\nassert generate_pagination(10, 1) == ([1, 2, 3, 4, 5], [6, 7, 8, 9, 10])\n", "\nassert generate_pagination(10, 10) == ([6, 7, 8, 9, 10], [1, 2, 3, 4, 5])\n", "\nassert generate_pagination(5, 3) == ([1, 2, 3, 4, 5], [])\n", "\nassert gen... |
eff672f16da039b46cedd1d05b2f4001 | [
{
"content": "On te donne une liste d'entiers `i_ls`, une valeur minimale `i_min`, une valeur maximale `i_max`, et un booléen `i_reverse`. Ta tâche est d'implémenter la fonction `sort_and_filter_list(i_ls, i_min, i_max, i_reverse)` en une seule ligne de code en utilisant une fonction lambda et les fonctions int... | ["\nassert sort_and_filter_list([1, 2, 3, 4, 5], 2, 4, False) == [2, 3, 4]\n", "\nassert sort_and_filter_list([10, 20, 30, 40, 50], 15, 45, True) == [40, 30, 20]\n", "\nassert sort_and_filter_list([5, 15, 25, 35, 45], 0, 100, False) == [5, 15, 25, 35, 45]\n", "\nassert sort_and_filter_list([5, 15, 25, 35, 45], 20, 30, ... |
94256cf2451e8a1887815bba70cacc05 | [
{
"content": "On te donne une liste non vide de chaînes de caractères, où chaque chaîne est composée de lettres minuscules de l'alphabet anglais. La longueur de la liste est garantie d'être comprise entre 1 et 100, inclusivement, et la longueur de chaque chaîne est garantie d'être comprise entre 1 et 100, inclu... | ["\nassert find_max_length_strings([\"code\", \"programming\", \"puzzles\", \"quiz\"]) == [\"programming\", \"puzzles\"]\n", "\nassert find_max_length_strings([\"a\", \"bb\", \"ccc\", \"dddd\"]) == [\"dddd\"]\n", "\nassert find_max_length_strings([\"equal\", \"equal\", \"equal\"]) == [\"equal\", \"equal\", \"equal\"]\n... |
9178df14e60eaaacc7c4127030b823c4 | [
{
"content": "On te donne un fichier texte. Ta tâche est d'implémenter une fonction `count_words_in_file(file_path)` qui lit le fichier et renvoie un dictionnaire. Les clés du dictionnaire doivent être des trigrammes uniques (séquences de trois mots consécutifs) trouvés dans le fichier, et les valeurs doivent ê... | ["\nassert count_words_in_file(\"test1.txt\") == {'the quick brown': 1}\n", "\nassert count_words_in_file(\"test2.txt\") == {'hello world this': 1, 'world this is': 1}\n", "\nassert count_words_in_file(\"test3.txt\") == {'a b c': 2, 'b c d': 2}\n", "\nassert count_words_in_file(\"test4.txt\") == {}\n", "\nassert count_... |
a389d1a9aacf3276758f605f08d2388c | [
{
"content": "Étant donné un entier positif `n`, calcule sa racine numérique en utilisant la méthode du reste modulo 9. Implémente ceci sans utiliser d'opérateurs arithmétiques ni de fonctions intégrées pour les opérations de division ou de modulo.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^9)\n\n**Sorti... | ["\nassert digital_root_without_mod_or_div(942) == 6\n", "\nassert digital_root_without_mod_or_div(138) == 3\n", "\nassert digital_root_without_mod_or_div(16) == 7\n", "\nassert digital_root_without_mod_or_div(123456789) == 9\n", "\nassert digital_root_without_mod_or_div(0) == 0\n", "\nassert digital_root_without_mod_o... |
eb3551deb7a21da41690f14f9f1ca784 | [
{
"content": "On te donne une matrice à valeurs complexes `A` de taille `n x m` représentant un état quantique dans un espace de Hilbert. Ta tâche est d'écrire une fonction `normalize_quantum_state(A)` qui normalise cette matrice. Le processus de normalisation consiste à diviser chaque élément de la matrice par... | ["\nassert normalize_quantum_state([[1 + 0j]]) == [[1 + 0j]]\n", "\nassert normalize_quantum_state([[1 + 0j, 0 + 0j], [0 + 0j, 1 + 0j]]) == [[0.7071067811865476 + 0j, 0 + 0j], [0 + 0j, 0.7071067811865476 + 0j]]\n", "\nassert normalize_quantum_state([[1 + 1j, 0 + 0j], [0 + 0j, 1 + 1j]]) == [[0.5 + 0.5j, 0 + 0j], [0 + 0j... |
11b621c92bae0a755c041571bc7bcd70 | [
{
"content": "On te donne une durée dans le temps en secondes, qui peut inclure des secondes fractionnaires jusqu'à six décimales. Ta tâche est d'écrire une fonction `time_converter` qui convertit cette durée en une chaîne formatée comme `HH:MM:SS.ss`, où `HH` représente les heures, `MM` représente les minutes,... | ["\nassert time_converter(10239) == \"02:50:39.00\"\n", "\nassert time_converter(86400) == \"24:00:00.00\"\n", "\nassert time_converter(3661.5) == \"01:01:01.50\"\n", "\nassert time_converter(0) == \"00:00:00.00\"\n", "\nassert time_converter(3600) == \"01:00:00.00\"\n", "\nassert time_converter(60) == \"00:01:00.00\"\... |
6a953a9c2f401bff925ede8aaf05a9ef | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `calculate_alphabet_score` qui calcule un score selon les critères suivants :\n\n- Ajoute 10 points au score si la chaîne contient au moins un caractère alphabétique minuscule.\n- Ajoute 10 points au score si la chaî... | ["\nassert calculate_alphabet_score(\"abc\") == 10\n", "\nassert calculate_alphabet_score(\"ABC\") == 10\n", "\nassert calculate_alphabet_score(\"Abc\") == 25\n", "\nassert calculate_alphabet_score(\"aBc1\") == 20\n", "\nassert calculate_alphabet_score(\"123\") == -5\n", "\nassert calculate_alphabet_score(\"!@#\") == 0... |
e95d6772cb6b45c9fcc4cb82418e40e1 | [
{
"content": "On te donne une chaîne hexadécimale et un alphabet personnalisé base64. Ta tâche est d'écrire une fonction `hex_to_base64` qui convertit la chaîne hexadécimale en sa chaîne encodée en base64 équivalente en utilisant l'alphabet base64 personnalisé fourni.\n\n**Entrée :**\n- Une chaîne hexadécimale ... | ["\nassert hex_to_base64('49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f736974697665206861636b6572', \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\") == \"SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9zaXRpdmUgaGFja2Vy\"\n", "\nassert hex_to_base64('00', \"ABCDEFGHIJKLMNOPQRSTUVWXYZa... |
aa85572be140ce21fbd2db9e39bb4ef1 | [
{
"content": "On te donne un espace vertical de hauteur `total_space`. Tu dois déterminer le nombre maximal de boîtes qui peuvent tenir dans cet espace. Chaque boîte a une hauteur fixe de `box_height`. De plus, il y a un en-tête et un pied de page, chacun occupant respectivement `header_height` et `footer_heigh... | ["\nassert max_boxes(100, 10, [5, 5, 5], 1, 1) == 3\n", "\nassert max_boxes(50, 10, [5, 5, 5], 1, 1) == 2\n", "\nassert max_boxes(30, 10, [5, 5, 5], 1, 1) == 1\n", "\nassert max_boxes(20, 10, [5, 5, 5], 1, 1) == 0\n", "\nassert max_boxes(100, 10, [], 1, 1) == 9\n", "\nassert max_boxes(100, 10, [1, 2, 3, 4, 5], 1, 1) ==... |
a06a92eb33d15e746002bb4ddc173d86 | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses e-mail. Ta fonction doit renvoyer `True` si la chaîne d'entrée est une adresse e-mail valide, et `False` sinon. Une adresse e-mail est considérée comme valide si elle correspond au schéma suivant : un ou plusieurs caractères alphan... | ["\nassert is_valid_email(\"example@test.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]\") == F... |
b43f85fad2cfe344fe86bd57a78610e0 | [
{
"content": "On te donne un dictionnaire `data_blocks` où les clés sont des entiers de 0 à 15, et les valeurs sont des chaînes d'octets. La longueur de chaque chaîne d'octets peut ne pas être exactement de 256 octets. Ta tâche est de mettre en œuvre une fonction `assemble_data` qui construit une seule chaîne d... | ["\nassert assemble_data({0: b'a' * 256, 1: b'b' * 256}) == b'a' * 256 + b'b' * 256 + b'\\x00' * 256 * 14\n", "\nassert assemble_data({15: b'z' * 256}) == b'\\x00' * 256 * 15 + b'z' * 256\n", "\nassert assemble_data({7: b'm' * 128}) == b'\\x00' * 256 * 7 + b'm' * 128 + b'\\x00' * 128 + b'\\x00' * 256 * 8\n", "\nassert ... |
c1bd87bc236bc943a600735a72a01450 | [
{
"content": "On te donne un fichier binaire contenant une séquence d'entiers non signés de 8 octets. Ta tâche est d'écrire une fonction qui lit ce fichier binaire en ordre inverse, calcule la somme de tous les entiers non signés et renvoie la somme. La fonction doit prendre le chemin du fichier comme argument ... | ["\nassert sum_unsigned_long_integers_from_file(\"test1.bin\") == 0\n", "\nassert sum_unsigned_long_integers_from_file(\"test2.bin\") == 18446744073709551615\n", "\nassert sum_unsigned_long_integers_from_file(\"test3.bin\") == 281474976710656\n", "\nassert sum_unsigned_long_integers_from_file(\"test4.bin\") == 42949672... |
f414061e20e1f3f3b7ef077c0499bf26 | [
{
"content": "On te donne une chaîne de caractères `text` qui peut contenir des signes de ponctuation, des nombres et des mots en casse mixte. Ta tâche est de mettre en œuvre une fonction `get_word_frequency(text)` qui traite cette chaîne et renvoie un dictionnaire. Le dictionnaire doit associer chaque mot uniq... | ["\nassert get_word_frequency(\"Hello, world! Hello world... 123\") == {'hello': 2, 'world': 2}\n", "\nassert get_word_frequency(\"Python, python, PYTHON!\") == {'python': 3}\n", "\nassert get_word_frequency(\"A quick brown fox jumps over the lazy dog.\") == {'a': 1, 'brown': 1, 'dog': 1, 'fox': 1, 'jumps': 1, 'lazy': ... |
53ea9ef78deeb43685b7d5808a24c10f | [
{
"content": "On te donne un tableau `prices` de longueur `n`, où `prices[i]` est le prix d'une action donnée au `i-ème` jour. Tu veux maximiser ton profit en choisissant un seul jour pour acheter une action et en choisissant un jour différent dans le futur pour vendre cette action. Retourne le profit maximum q... | ["\nassert max_profit([7, 1, 5, 3, 6, 4]) == 5\n", "\nassert max_profit([7, 6, 4, 3, 1]) == 0\n", "\nassert max_profit([1, 2, 3, 4, 5]) == 4\n", "\nassert max_profit([3, 3, 5, 0, 0, 3, 1, 4]) == 4\n", "\nassert max_profit([1, 2]) == 1\n", "\nassert max_profit([1]) == 0\n", "\nassert max_profit([]) == 0\n", "\nassert ma... |
458218ecf2350ddc743b882fcb14f456 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui identifie et renvoie le plus grand nombre premier de la liste. Si la liste ne contient aucun nombre premier, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers, `lst`, où `1 <= len(lst) <= 100`... | ["\nassert largest_prime([29, 15, 20, 31, 8, 11]) == 31\n", "\nassert largest_prime([4, 6, 8, 10]) == None\n", "\nassert largest_prime([2, 3, 5, 7, 11, 13]) == 13\n", "\nassert largest_prime([17, 19, 23, 29, 31]) == 31\n", "\nassert largest_prime([1, 4, 6, 8, 10, 12]) == None\n", "\nassert largest_prime([37, 41, 43, 47... |
bb915a6e5a6c8b3dd59514629db1cd9e | [
{
"content": "Tu es chargé d'implémenter une fonction `classify_text` qui catégorise un texte donné dans l'une des catégories prédéfinies : \"news\", \"sports\", \"entertainment\" ou \"opinion\". Utilise un modèle de classification de texte pré-entraîné accessible via la fonction `predict_category(text)`, qui a... | ["\nassert classify_text(\"The latest news from around the world\") == \"news\"\n", "\nassert classify_text(\"The final score was 3-1 in favor of the home team\") == \"sports\"\n", "\nassert classify_text(\"The singer performed an amazing concert last night\") == \"entertainment\"\n", "\nassert classify_text(\"The edit... |
eac18a845de6f8ae4cb23b06b827b550 | [
{
"content": "On te donne un ensemble de données et un ensemble de quantiles. Ta tâche est de calculer les index ajustés pour ces quantiles en fonction d'une distribution d'échantillonnage personnalisée définie par une fonction polynomiale quadratique par morceaux. La fonction `compute_adjusted_indexes` doit pr... | ["\nassert compute_adjusted_indexes([1, 2, 3, 4, 5], [0.5], (0.1, 0.1), [(1, 0, 0)]) == [1.9]\n", "\nassert compute_adjusted_indexes([10, 20, 30, 40, 50], [0.25, 0.75], (0.2, 0.2), [(1, 0, 0)]) == [0.45, 3.55]\n", "\nassert compute_adjusted_indexes([], [0.5], (0.1, 0.1), [(1, 0, 0)]) == []\n", "\nassert compute_adjuste... |
14cdac71652d053d3a4c81fa0cd4c574 | [
{
"content": "On te demande d'implémenter une simulation de boutique en ligne simple en Python. Ton programme doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un produit** : Ajouter un nouveau produit à la boutique. Chaque produit est identifié par un ID unique, possède un nom et un prix. Si un... | ["\nassert OnlineStore().add_product(Product(\"001\", \"Laptop\", 999.99)) is None\n", "\nassert OnlineStore().add_product(Product(\"002\", \"Mouse\", 25.50)) is None\n", "\nassert OnlineStore().add_product(Product(\"003\", \"Keyboard\", 45.00)) is None\n", "\nassert OnlineStore().add_product(Product(\"004\", \"Monitor... |
80941bd22f26ffc8686028670ed6cfc1 | [
{
"content": "On te donne une chaîne de caractères `text` représentant un document avec plusieurs paragraphes séparés par des doubles sauts de ligne (`\\n\\n`). De plus, on te fournit une liste de `excluded_words`. Ta tâche est d'implémenter une fonction `count_paragraphs` qui renvoie le nombre de paragraphes d... | ["\nassert count_paragraphs(\"This is a sample paragraph.\\n\\nThis one has excluded word test.\\n\\nAnd this does not.\", [\"test\"]) == 2\n", "\nassert count_paragraphs(\"Hello world.\\n\\nFoo bar.\", [\"foo\"]) == 1\n", "\nassert count_paragraphs(\"Hello world.\\n\\nFoo bar.\", [\"hello\", \"world\"]) == 0\n", "\nas... |
16d5f8b487107eb26bffde323509f8cb | [
{
"content": "On te donne une chaîne de caractères `dna` représentant une séquence de nucléotides d'ADN. Ta tâche est de mettre en œuvre une fonction `dnaToCodonList(dna)` qui traite cette chaîne et renvoie une liste de codons valides. Un codon est une séquence de exactement trois nucléotides standard d'ADN ('A... | ["\nassert dnaToCodonList(\"ACGT\") == [\"ACG\"]\n", "\nassert dnaToCodonList(\"ACGTTGCA\") == [\"ACG\", \"TTG\", \"CA\"]\n", "\nassert dnaToCodonList(\"ACGTXGCA\") == [\"ACG\", \"XGC\", \"A\"]\n", "\nassert dnaToCodonList(\"ACGTXGCA\") == [\"ACG\", \"GCA\"]\n", "\nassert dnaToCodonList(\"ACGTXGCAZ\") == [\"ACG\", \"GC... |
20a7c5afb31ed53f6a484e602dc720c8 | [
{
"content": "On te demande de développer une fonction `generate_unique_serial_number(old_serial_number, existing_serial_numbers)` qui génère un numéro de série unique à partir d'un `old_serial_number` donné. Le nouveau numéro de série ne doit pas entrer en collision avec les numéros de série présents dans l'en... | ["\nassert generate_unique_serial_number(\"SN123\", set()) == \"SN123\"\n", "\nassert generate_unique_serial_number(\"SN123\", {\"SN123\"}) == \"SN123-1\"\n", "\nassert generate_unique_serial_number(\"SN123\", {\"SN123\", \"SN123-1\"}) == \"SN123-2\"\n", "\nassert generate_unique_serial_number(\"SN123\", {\"SN123\", \"... |
6fd6af7a8d01909d787b7a4f8e772638 | [
{
"content": "On te donne deux instances d'un système de base de données : un Maître et un Esclave. L'instance Maître a un fichier journal binaire avec un nom spécifique et une position de journal. De même, l'instance Esclave a un fichier journal de relais avec un nom spécifique et une position de journal. De p... | ["\nassert are_logs_aligned(master, slave) == False if master.version != slave.version else True\n", "\nassert are_logs_aligned(master, slave) == False if master.file != slave.relay_mst_log else True\n", "\nassert are_logs_aligned(master, slave) == False if master.pos != slave.exec_mst_pos else True\n", "\nassert are_l... |
d35885df607b0d47cefd2eeb7b56c7bf | [
{
"content": "On te donne une liste imbriquée d'entiers. Ton objectif est d'écrire une fonction qui aplatit récursivement cette liste imbriquée en une seule liste d'entiers. La fonction doit gérer des niveaux de nidification arbitraires.\n\n**Entrée :**\n- Une liste imbriquée d'entiers. La liste peut contenir d... | ["\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([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert flatten([]) == []\n", "\nassert flatten([[], [], []]) == []\n", "\nassert flatten([[[[[]]]]]) == []\n", "\nas... |
e1bacf87204498ddf7a9baf91b4c4ad7 | [
{
"content": "On te demande de développer une fonction pour identifier tous les ensembles de planètes qui sont alignées dans une fenêtre de 5 degrés dans leurs orbites. La fonction recevra une liste de tuples, où chaque tuple consiste en le nom d'une planète et sa position dans son orbite, représentée par un en... | ["\nassert find_aligned_planets([('Mercury', 10), ('Venus', 12), ('Earth', 15), ('Mars', 200)]) == [['Mercury', 'Venus', 'Earth'], ['Mercury', 'Venus'], ['Venus', 'Earth'], ['Mercury'], ['Venus'], ['Earth'], ['Mars']]\n", "\nassert find_aligned_planets([('Mercury', 0), ('Venus', 359), ('Earth', 1), ('Mars', 360)]) == [... |
89afa07d0f84f9b5210f798de2301193 | [
{
"content": "On te donne une phrase sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction Python qui calcule la fréquence de chaque mot dans la phrase, en ignorant la casse et la ponctuation. La fonction doit renvoyer un dictionnaire où les clés sont les mots et les valeurs sont leurs fréquenc... | ["\nassert word_frequency(\"Hello world! Hello everyone.\") == {\"hello\": 2, \"world\": 1, \"everyone\": 1}\n", "\nassert word_frequency(\"Python, python, PYTHON!\") == {\"python\": 3}\n", "\nassert word_frequency(\"A quick brown fox jumps over the lazy dog.\") == {\"a\": 1, \"quick\": 1, \"brown\": 1, \"fox\": 1, \"j... |
7e21d3d1a2f3809302a1fea6fd90e523 | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses IPv4. Une adresse IPv4 valide est constituée de quatre octets, chacun allant de 0 à 255, séparés par des points. Chaque octet ne doit pas avoir de zéros non significatifs, sauf s'il est exactement \"0\". Ta fonction doit renvoyer `... | ["\nassert validate_ip_address(\"192.168.1.1\") == True\n", "\nassert validate_ip_address(\"255.255.255.255\") == True\n", "\nassert validate_ip_address(\"0.0.0.0\") == True\n", "\nassert validate_ip_address(\"256.256.256.256\") == False\n", "\nassert validate_ip_address(\"192.168.1\") == False\n", "\nassert validate_i... |
bae61766eb6c1e752f5091f0d3a7af23 | [
{
"content": "Dans le domaine de l'informatique quantique, les portes de Pauli (I, X, Y, Z) sont des opérations essentielles sur un seul qubit. On considère que deux portes de Pauli sont diagonales dans une base produit tensoriel si elles commutent, ce qui signifie que l'ordre de leur application n'influence pa... | ["\nassert are_pauli_gates_diagonal('I', 'I', 'X') == True\n", "\nassert are_pauli_gates_diagonal('X', 'X', 'Y') == True\n", "\nassert are_pauli_gates_diagonal('Y', 'Y', 'Z') == True\n", "\nassert are_pauli_gates_diagonal('Z', 'Z', 'I') == True\n", "\nassert are_pauli_gates_diagonal('X', 'Z', 'Y') == False\n", "\nasser... |
8e02d037f8a1da4e8ef702152f07d38d | [
{
"content": "On te donne un fichier texte. Ta tâche est d'écrire une fonction Python qui lit le fichier et renvoie un dictionnaire avec la fréquence de chaque mot, en excluant les mots vides anglais courants. La fonction doit gérer la ponctuation et être insensible à la casse.\n\n**Entrée :**\n- Une chaîne de ... | ["\nassert word_frequency('empty.txt') == {}\n", "\nassert word_frequency('single_word.txt') == {'hello': 1}\n", "\nassert word_frequency('stop_words_only.txt') == {}\n", "\nassert word_frequency('punctuation.txt') == {'hello': 1, 'world': 1}\n", "\nassert word_frequency('case_insensitive.txt') == {'hello': 2}\n", "\na... |
cc13a9a5c733f057eb183faede655235 | [
{
"content": "On te donne un répertoire contenant plusieurs fichiers texte. Ta tâche est d'écrire un script Python qui lit tous les fichiers texte du répertoire, compte la fréquence de chaque mot et écrit les fréquences des mots dans un nouveau fichier nommé `word_frequencies.txt`. Les mots sont considérés sans... | ["\nassert os.path.exists('word_frequencies.txt') == False\nmain('test_dir')\nassert os.path.exists('word_frequencies.txt') == True\n", "\nmain('test_dir')\nwith open('word_frequencies.txt', 'r', encoding='utf-8') as file:\n content = file.read()\nassert 'hello: 2' in content\n", "\nmain('test_dir')\nwith open('word... |
4602e5c1c2128912dad96099fd5eb116 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour générer tous les nombres premiers jusqu'à un entier donné `n`. Ta solution doit utiliser la méthode du crible d'Ératosthène pour améliorer les performances par rapport aux tests de primalité naïfs. Écris une fonction `generate_primes(n)` qui ... | ["\nassert generate_primes(10) == [2, 3, 5, 7]\n", "\nassert generate_primes(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_primes(1) == []\n", "\nassert generate_primes(2) == [2]\n", "\nassert generate_primes(0) == []\n", "\nassert generate_primes(30) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n", "\nassert g... |
bcbfca901e5bf3091517c31ef8ef62e7 | [
{
"content": "Tu participes à une compétition de machine learning où tu dois implémenter une fonction de perte personnalisée pour un réseau neuronal en utilisant PyTorch. La tâche consiste à prédire la valeur d'une variable continue, et la fonction de perte doit pénaliser les prédictions en fonction de la diffé... | ["\nassert mae_loss(torch.tensor([1.0, 2.0, 3.0]), torch.tensor([1.0, 2.0, 3.0])) == 0.0\n", "\nassert mae_loss(torch.tensor([1.0, 2.0, 3.0]), torch.tensor([0.0, 0.0, 0.0])) == 2.0\n", "\nassert mae_loss(torch.tensor([[1.0, 2.0], [3.0, 4.0]]), torch.tensor([[1.0, 2.0], [3.0, 4.0]])) == 0.0\n", "\nassert mae_loss(torch.... |
e96bb2f9cbc2a2acf3be8446bee15a3e | [
{
"content": "On te donne un tableau d'entiers. Implémente une fonction `split_array` qui partitionne le tableau en deux moitiés autour d'un élément pivot. L'élément pivot doit être le premier élément du tableau. La fonction doit renvoyer deux tableaux : l'un contenant les éléments strictement inférieurs au piv... | ["\nassert split_array([5, 3, 8, 6, 2, 7, 4, 1]) == ([3, 2, 4, 1], [5, 8, 6, 7])\n", "\nassert split_array([1, 2, 3, 4, 5]) == ([], [1, 2, 3, 4, 5])\n", "\nassert split_array([5, 4, 3, 2, 1]) == ([4, 3, 2, 1], [5])\n", "\nassert split_array([3, 3, 3, 3, 3]) == ([], [3, 3, 3, 3, 3])\n", "\nassert split_array([10]) == ([... |
751c1ade46440996a067356746257c88 | [
{
"content": "Tu dois implémenter une classe Python qui simule un serveur web basique capable de gérer les requêtes GET vers le chemin racine (\"/\"). Lorsqu'il reçoit une requête GET vers le chemin racine, le serveur doit répondre avec un document HTML contenant un titre avec le texte \"Hello, World !\" et un ... | ["\nassert run() is None\n", "\nassert SimpleHTTPRequestHandler.do_GET(None) is None\n", "\nassert SimpleHTTPRequestHandler.path == '/'\n", "\nassert SimpleHTTPRequestHandler.send_response(200) is None\n", "\nassert SimpleHTTPRequestHandler.send_header('Content-type', 'text/html') is None\n", "\nassert SimpleHTTPReques... |
c572d46c74875836b5fc41bb80fcfc76 | [
{
"content": "On te donne une chaîne de caractères `value`. Ta tâche est d'écrire une fonction `convert_value(value: str) -> Union[int, float, str]` qui tente de convertir la chaîne en un entier ou un flottant. La fonction doit gérer correctement la notation scientifique et les nombres négatifs. Si la conversio... | ["\nassert convert_value(\"123\") == 123\n", "\nassert convert_value(\"-123\") == -123\n", "\nassert convert_value(\"123.45\") == 123.45\n", "\nassert convert_value(\"-123.45\") == -123.45\n", "\nassert convert_value(\"1.23e4\") == 12300.0\n", "\nassert convert_value(\"-1.23e4\") == -12300.0\n", "\nassert convert_value... |
f8c7760860eb987736865562c7d21708 | [
{
"content": "On te donne une liste de réactions chimiques, où chaque réaction est représentée comme une liste de chaînes de caractères. Les sept premiers éléments de chaque liste de réaction représentent les réactifs et les produits. Les 11ème et 12ème éléments représentent la plage de température pour la réac... | ["\nassert is_valid_reaction([\"HO2\", \"O2\", \"H2O\", \"CO2\", \"CO\", \"H2\", \"O2\", \"combust\", \"\", \"200\", \"500\"], [\"H2\", \"O2\", \"H2O\", \"CO2\", \"CO\"], {\"HO2\": \"H2O\"}) == True\n", "\nassert is_valid_reaction([\"H2O\", \"CO2\", \"CO\", \"H2\", \"O2\", \"N2\", \"O2\", \"combust\", \"\", \"\", \"\"]... |
bc69bc61d430d2d61991a83625aaa29f | [
{
"content": "On te demande de développer un système de classification de texte qui catégorise le texte d'entrée dans l'une des trois catégories suivantes : « spam », « ham » ou « neutral ». Implémente une fonction `classify_text` qui prend une chaîne de caractères en entrée et renvoie la catégorie prédite. Ta ... | ["\nassert classify_text(\"Congratulations, you've won a $1000 Walmart gift card! Click here to claim.\") == \"spam\"\n", "\nassert classify_text(\"Earn big with this investment opportunity. Don't miss out!\") == \"spam\"\n", "\nassert classify_text(\"Hey, are we still going for lunch tomorrow?\") == \"ham\"\n", "\nass... |
9848a97c1088e6b5f159aa72d8781176 | [
{
"content": "On te demande d'implémenter une classe `DataValidator` en Python qui peut valider différents types de données d'entrée. La classe doit inclure les méthodes suivantes :\n\n- `__init__(self, data)` : Initialise la classe avec les données à valider.\n- `is_valid_email(self)` : Renvoie `True` si les d... | ["\nassert DataValidator(\"test@example.com\").is_valid_email() == True\n", "\nassert DataValidator(\"invalid-email\").is_valid_email() == False\n", "\nassert DataValidator(\"+1234567890\").is_valid_phone_number() == True\n", "\nassert DataValidator(\"1234567890\").is_valid_phone_number() == True\n", "\nassert DataVali... |
90e399bb4dfe34f9ef0b5323dc7d24d7 | [
{
"content": "On te donne une chaîne de caractères contenant divers textes et adresses e-mail. Ta tâche est d'écrire un programme Python qui extrait toutes les adresses e-mail uniques de la chaîne en utilisant des expressions régulières. Le programme doit afficher une liste d'adresses e-mail uniques dans l'ordr... | ["\nassert extract_unique_emails(\"test@example.com test@example.com\") == [\"test@example.com\"]\n", "\nassert extract_unique_emails(\"user.name+tag+sorting@example.com\") == [\"user.name+tag+sorting@example.com\"]\n", "\nassert extract_unique_emails(\"user@sub.example.com\") == [\"user@sub.example.com\"]\n", "\nasser... |
dc77e5a55b3ccc9fb680e5bbbd633603 | [
{
"content": "On te donne un répertoire contenant plusieurs fichiers CSV. Ta tâche est d'écrire un script Python qui lit chaque fichier CSV, les fusionne en un seul DataFrame, et écrit le DataFrame fusionné dans un nouveau fichier CSV. Le script doit gérer les problèmes potentiels liés aux noms de colonnes ou a... | ["\nassert os.path.exists('path/to/output/merged_data.csv') == False\nmerge_csv_files_in_directory('path/to/csv/files', 'path/to/output/merged_data.csv')\nassert os.path.exists('path/to/output/merged_data.csv') == True\n", "\nmerge_csv_files_in_directory('path/to/csv/files', 'path/to/output/merged_data.csv')\ndf = pd.r... |
4b8814f04c1c589ae42733fe59879074 | [
{
"content": "On te donne un tableau d'entiers et un nombre de positions. Ta tâche est d'effectuer une rotation vers la gauche du tableau du nombre de positions spécifié, en place. Le tableau doit être modifié directement sans utiliser de tableaux supplémentaires.\n\n**Entrée :**\n- Un tableau d'entiers `arr` e... | ["\nassert left_rotate([1, 2, 3, 4, 5], 2) is None\n", "\nassert left_rotate([1, 2, 3, 4, 5], 2) or [3, 4, 5, 1, 2] == [3, 4, 5, 1, 2]\n", "\nassert left_rotate([1, 2, 3, 4, 5], 5) or [1, 2, 3, 4, 5] == [1, 2, 3, 4, 5]\n", "\nassert left_rotate([1, 2, 3, 4, 5], 0) or [1, 2, 3, 4, 5] == [1, 2, 3, 4, 5]\n", "\nassert lef... |
89b5664f0c511ed1b2dc702bfe34cf5b | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de déterminer la longueur du plus long sous-tableau contigu où la différence absolue entre deux éléments quelconques est au plus égale à 1. Tu n'es pas autorisé à utiliser des fonctions de tri ou de sous-tableau intégrées.\n\n**Entrée :**\n- La premiè... | ["\nassert longest_sublist([1, 2, 2, 3, 1, 2]) == 5\n", "\nassert longest_sublist([1, 3, 2, 2, 3, 1]) == 3\n", "\nassert longest_sublist([1, 1, 1, 1, 1]) == 5\n", "\nassert longest_sublist([1, 2, 3, 4, 5]) == 2\n", "\nassert longest_sublist([5, 5, 5, 5, 5, 5]) == 6\n", "\nassert longest_sublist([1, 2, 1, 2, 1, 2]) == 6... |
39575a12b6090a50ee96c25b18cc341d | [
{
"content": "On te demande d'implémenter une fonction `reverse_fibonacci` qui génère la suite de Fibonacci en utilisant la récursion. La fonction doit renvoyer les `n` premiers nombres de la suite de Fibonacci dans l'ordre inverse. La suite de Fibonacci commence par 0 et 1, et chaque nombre suivant est la somm... | ["\nassert reverse_fibonacci(1) == [0]\n", "\nassert reverse_fibonacci(2) == [1, 0]\n", "\nassert reverse_fibonacci(3) == [1, 1, 0]\n", "\nassert reverse_fibonacci(4) == [2, 1, 1, 0]\n", "\nassert reverse_fibonacci(5) == [3, 2, 1, 1, 0]\n", "\nassert reverse_fibonacci(6) == [5, 3, 2, 1, 1, 0]\n", "\nassert reverse_fibo... |
cba4096878874173d5d1f4442f067b4b | [
{
"content": "On te donne un modèle défini par une classe personnalisée `Model` avec des attributs `n_u` et un vecteur de biais `pa_bias`. L'attribut `n_u` est une liste d'entiers positifs, et `pa_bias` est un tableau NumPy 1D. Ta tâche est de calculer le logarithme de la fonction de partition `log_za` pour le ... | ["\nassert log_partition_function(Model([1], np.array([0.0]))) == 0.0\n", "\nassert log_partition_function(Model([1], np.array([1.0]))) == 1.0\n", "\nassert log_partition_function(Model([2], np.array([0.0, 0.0]))) == 0.0\n", "\nassert log_partition_function(Model([2], np.array([1.0, 2.0]))) == np.logaddexp(1.0, 2.0) * ... |
fee36b3e2bc380f5dbce4c1a9eadf247 | [
{
"content": "On te donne une chaîne de caractères `name_list` contenant une liste de noms séparés par des virgules. Ta tâche est de mettre en œuvre une fonction `count_names` qui renvoie un dictionnaire où les clés sont les noms (en minuscules) et les valeurs sont le nombre de fois que chaque nom apparaît dans... | ["\nassert count_names(\"Alice, bob, alice, Bob, Charlie, charlie, CHARLIE\") == {'alice': 3, 'bob': 2, 'charlie': 3}\n", "\nassert count_names(\"John, john, JOHN, john\") == {'john': 4}\n", "\nassert count_names(\"Anna, Anna, Anna, Anna\") == {'anna': 4}\n", "\nassert count_names(\"Tom, Jerry, Tom, Jerry, Tom\") == {'... |
a3e79433ea6666f6254567d091ed2f87 | [
{
"content": "On te donne un tableau `L` de `n` entiers. Ta tâche est de construire un tableau `R` tel que `R[i]` soit le produit de tous les éléments de `L` sauf `L[i]`. La fonction doit gérer les cas où `L` contient des éléments nuls. La solution doit s'exécuter en temps O(n) et ne doit pas utiliser la divisi... | ["\nassert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]\n", "\nassert product_except_self([0, 1, 2]) == [2, 0, 0]\n", "\nassert product_except_self([0, 0, 1]) == [0, 0, 0]\n", "\nassert product_except_self([1, 0, 3, 4]) == [0, 12, 0, 0]\n", "\nassert product_except_self([1, 2, 0, 4]) == [0, 0, 8, 0]\n", "\nasser... |
ec38cfdc0f61b203e198a1df49f8658f | [
{
"content": "On te demande d'implémenter une classe `Polynomial` en Python qui supporte les opérations arithmétiques de base : l'addition, la soustraction et la multiplication. Le polynôme est représenté par une liste de coefficients, où le i-ème élément de la liste correspond au coefficient du terme x^i. Impl... | ["\nassert str(Polynomial([1, 2, 3]) + Polynomial([4, 5, 6])) == \"5x^2 + 7x + 5\"\n", "\nassert str(Polynomial([1, 2, 3]) - Polynomial([4, 5, 6])) == \"-3x^2 - 3x - 3\"\n", "\nassert str(Polynomial([1, 2]) * Polynomial([3, 4])) == \"3x^2 + 10x + 8\"\n", "\nassert str(Polynomial([0, 0, 0]) + Polynomial([0, 0, 0])) == \... |
ded49b03c9ec708ad8a03d9212bf8e77 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est de déterminer s'il est possible de partitionner la liste en deux sous-ensembles tels que la somme des éléments dans les deux sous-ensembles soit égale. Écris une fonction `can_partition(nums)` qui prend une liste d'entiers en entrée et renvoie `Tru... | ["\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... |
40bc30f42108b2c0ab11d4147c2c5cdd | [
{
"content": "On te donne un dictionnaire `input_dict` où chaque clé est une chaîne de caractères et chaque valeur est un entier. Ta tâche est de créer une fonction `square_values` qui renvoie un nouveau dictionnaire avec les mêmes clés mais avec chaque valeur au carré.\n\n**Entrée :**\n- Un dictionnaire `input... | ["\nassert square_values({\"a\": 2, \"b\": 3}) == {\"a\": 4, \"b\": 9}\n", "\nassert square_values({\"x\": 0, \"y\": -1}) == {\"x\": 0, \"y\": 1}\n", "\nassert square_values({\"one\": 1, \"two\": 2, \"three\": 3}) == {\"one\": 1, \"two\": 4, \"three\": 9}\n", "\nassert square_values({\"\": 10}) == {\"\": 100}\n", "\nas... |
e90d6147808eed9fa79b5b644381e1d7 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction génératrice Python `prime_factors(n)` qui renvoie les facteurs premiers distincts de `n` dans l'ordre croissant. Chaque facteur premier doit être renvoyé une seule fois, quelle que soit sa multiplicité dans la factorisation de `... | ["\nassert list(prime_factors(2)) == [2]\n", "\nassert list(prime_factors(3)) == [3]\n", "\nassert list(prime_factors(4)) == [2]\n", "\nassert list(prime_factors(6)) == [2, 3]\n", "\nassert list(prime_factors(15)) == [3, 5]\n", "\nassert list(prime_factors(28)) == [2, 7]\n", "\nassert list(prime_factors(100)) == [2, 5]... |
7650cd0bf65e69303ab043a404e6e357 | [
{
"content": "On te donne un dictionnaire `student_grades` où chaque paire clé-valeur représente le nom d'un étudiant et sa note correspondante. Ta tâche est de mettre en œuvre une fonction `get_average_grade()` qui calcule et renvoie la note moyenne de tous les étudiants. La fonction doit gérer les cas où le d... | ["\nassert get_average_grade({'Alice': 85, 'Bob': 92, 'Charlie': 78}) == 85.0\n", "\nassert get_average_grade({'Alice': 100, 'Bob': 100, 'Charlie': 100}) == 100.0\n", "\nassert get_average_grade({'Alice': 50, 'Bob': 50, 'Charlie': 50}) == 50.0\n", "\nassert get_average_grade({'Alice': 85}) == 85.0\n", "\nassert get_ave... |
f8cb41d8e1d1bcf5c8efd48c35eda8bf | [
{
"content": "On te demande de traiter une liste d'enregistrements d'employés à partir d'un fichier CSV nommé \"employee_records.csv\". Chaque enregistrement est formaté comme suit :\n\n`employee_id,first_name,last_name,department,position,hire_date`\n\nTon objectif est de filtrer les employés embauchés après l... | ["\nassert get_existing_employees(open(\"test_employee_records.csv\", \"r\")) == [101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 105.5]\n", "\nassert get_existing_employees(open(\"test_employee_records.csv\", \"r\")) == [101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 105]\n", "\nassert get_existing_employees(open... |
13fe42bb84dd4e33802edbbaa0e76675 | [
{
"content": "On te donne une liste d'entiers représentant les codes d'évaluation de la qualité (QA) pour un ensemble d'images satellite. Chaque code QA est un entier non signé sur 16 bits, où chaque bit représente une condition ou un indicateur spécifique. Ta tâche est de mettre en œuvre une fonction qui évalu... | ["\nassert check_qa_code(0b00001010) == True\n", "\nassert check_qa_code(0b00001000) == False\n", "\nassert check_qa_code(0b00011010) == False\n", "\nassert check_qa_code(0b00101010) == False\n", "\nassert check_qa_code(0b00000010) == False\n", "\nassert check_qa_code(0b00001110) == False\n", "\nassert check_qa_code(0b... |
c973a6fbf8e2295262b57b36351a084a | [
{
"content": "On te donne une chaîne de caractères `text` et une liste de mots `words_to_count`. Ta tâche est d'implémenter une fonction `count_words` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les mots de `words_to_count`, et les valeurs doivent être le nombre de fois que chaque mot app... | ["\nassert count_words(\"Hello world!\", [\"hello\", \"world\"]) == {\"hello\": 1, \"world\": 1}\n", "\nassert count_words(\"Python, python, PYTHON!\", [\"python\"]) == {\"python\": 3}\n", "\nassert count_words(\"This is a test. This test is only a test.\", [\"this\", \"is\", \"a\", \"test\"]) == {\"this\": 2, \"is\": ... |
8a6f920096c8d381d7e03bf4f6090c09 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères alphabétiques et de ponctuation. Ta tâche est d'écrire une fonction qui renvoie le nombre de mots uniques dans la chaîne. Les mots sont définis comme des séquences de caractères alphabétiques, et la fonction doit ignorer la ponctuatio... | ["\nassert count_unique_words(\"Hello, world!\") == 2\n", "\nassert count_unique_words(\"Python, Python, Python!\") == 1\n", "\nassert count_unique_words(\"A quick brown fox jumps over the lazy dog.\") == 8\n", "\nassert count_unique_words(\"To be or not to be, that is the question.\") == 10\n", "\nassert count_unique_... |
aac81cb08aa917c0c1a91f0c060244a7 | [
{
"content": "On te donne un système qui gère plusieurs processus, et tu dois traiter les entrées de journal de ce système. Chaque entrée de journal est une chaîne de caractères contenant des valeurs séparées par des virgules. La première valeur est une étiquette de type d'événement, et les valeurs suivantes so... | ["\nassert process_log_entry(\"A,592,1,100,50\") == {'event': 'A', 'time': '592', 'pid': '1', 'mem_required': '100', 'burst_time': '50'}\n", "\nassert process_log_entry(\"I,100,20\") == {'event': 'I', 'time': '100', 'ioBurstTime': '20'}\n", "\nassert process_log_entry(\"W,150,sem1\") == {'event': 'W', 'time': '150', 's... |
41ab81f06cc8ec63966682ed1dcf0ed4 | [
{
"content": "On te donne deux chaînes de caractères `a` et `b` représentant des entiers non négatifs. Ta tâche est d'écrire une fonction `add_large_numbers(a, b)` qui renvoie une chaîne de caractères représentant la somme de ces deux entiers. Les entiers en entrée peuvent être très grands, dépassant la capacit... | ["\nassert add_large_numbers(\"123\", \"456\") == \"579\"\n", "\nassert add_large_numbers(\"999\", \"1\") == \"1000\"\n", "\nassert add_large_numbers(\"0\", \"0\") == \"0\"\n", "\nassert add_large_numbers(\"1000\", \"2000\") == \"3000\"\n", "\nassert add_large_numbers(\"99999999999999999999\", \"1\") == \"1000000000000... |
c6e6a8c94ff9a4cbbfc5bd97e16a46c7 | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'écrire une fonction Python qui renvoie une liste contenant les éléments uniques présents dans les deux listes d'entrée. L'ordre des éléments dans la liste résultante n'a pas d'importance.\n\n**Entrée :**\n- Deux listes d'entiers, `list1` et `list2`... | ["\nassert find_intersection([1, 2, 3], [2, 3, 4]) == [2, 3]\n", "\nassert find_intersection([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_intersection([5, 6, 7], [8, 9, 10]) == []\n", "\nassert find_intersection([], [1, 2, 3]) == []\n", "\nassert find_intersection([1, 2, 3], []) == []\n", "\nassert find_inters... |
f74006f6afb674a9f19f805e7d0d9b60 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier cible `target`. Ta tâche est de mettre en œuvre une fonction `find_closest_number(numbers, target)` qui renvoie l'entier de la liste qui est le plus proche de la cible. Si deux entiers sont également proches de la cible, renvoie le plus petit.... | ["\nassert find_closest_number([1, 2, 3, 5, 6], 4) == 3\n", "\nassert find_closest_number([10, 22, 28, 29, 30, 40], 27) == 28\n", "\nassert find_closest_number([1, 3, 5, 7, 9], 8) == 7\n", "\nassert find_closest_number([1, 3, 5, 7, 9], 6) == 5\n", "\nassert find_closest_number([1, 3, 5, 7, 9], 10) == 9\n", "\nassert fi... |
957acd1ed72f939260b6b67f66fa4f99 | [
{
"content": "On te donne une liste de segments et de décalages, chacun représenté comme une chaîne binaire de 4 bits. Ta tâche est de calculer les adresses effectives pour chaque paire segment et décalage. L'adresse effective est déterminée en décalant le segment de 4 bits vers la gauche, puis en ajoutant le d... | ["\nassert calculate_effective_addresses([\"0000\"], [\"0000\"]) == [0]\n", "\nassert calculate_effective_addresses([\"1111\"], [\"1111\"]) == [255]\n", "\nassert calculate_effective_addresses([\"1010\"], [\"0011\"]) == [163]\n", "\nassert calculate_effective_addresses([\"1100\"], [\"1010\"]) == [1962]\n", "\nassert ca... |
e1542c684b94c4646b7c5f5e2a6d71f5 | [
{
"content": "On te donne une liste triée d'entiers qui peut contenir des éléments dupliqués. Implémente une fonction `optimize_binary_search` qui effectue une recherche binaire pour trouver l'indice de la première occurrence d'une valeur cible dans la liste. Si la valeur cible n'est pas présente, la fonction d... | ["\nassert optimize_binary_search([1, 2, 2, 2, 3, 4, 5], 2) == 1\n", "\nassert optimize_binary_search([1, 2, 2, 2, 3, 4, 5], 3) == 4\n", "\nassert optimize_binary_search([1, 2, 2, 2, 3, 4, 5], 5) == 6\n", "\nassert optimize_binary_search([1, 2, 2, 2, 3, 4, 5], 1) == 0\n", "\nassert optimize_binary_search([1, 2, 2, 2, 3... |
3a5b92a1cda96d234fb2efe0e804c631 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer la longueur de la plus longue sous-séquence strictement croissante qui peut être formée en réarrangeant les caractères de la chaîne. Une sous-séquence est une séquence dérivée ... | ["\nassert longest_increasing_subsequence(\"aabced\") == 5\n", "\nassert longest_increasing_subsequence(\"abc\") == 3\n", "\nassert longest_increasing_subsequence(\"a\") == 1\n", "\nassert longest_increasing_subsequence(\"zzzz\") == 1\n", "\nassert longest_increasing_subsequence(\"abcdefg\") == 7\n", "\nassert longest_... |
cd942e5dcc86ed77f57be11905760e13 | [
{
"content": "On te demande d'implémenter la fonction `get_memory_address` qui traite une liste de nombres hexadécimaux de longueur arbitraire. Ton objectif est de concaténer ces nombres en une seule chaîne binaire, de supprimer les deux premiers bits de cette chaîne binaire, puis de reconvertir la chaîne binai... | ["\nassert get_memory_address(['1a', '2b']) == '0x2b'\n", "\nassert get_memory_address(['ff', 'ff']) == '0x3ff'\n", "\nassert get_memory_address(['00', '00']) == '0x0'\n", "\nassert get_memory_address(['01', '02']) == '0x2'\n", "\nassert get_memory_address(['ab', 'cd']) == '0x2bcd'\n", "\nassert get_memory_address(['12... |
3168ae5101f36cb3a03a7167a2e8bc53 | [
{
"content": "On te demande d'implémenter une simulation simple d'un jeu de dés. Dans ce jeu, un joueur lance deux dés à six faces. Ton programme doit afficher le résultat de chaque dé et le score total.\n\n**Entrée :**\nAucune entrée n'est fournie à la fonction.\n\n**Sortie :**\n- Affiche le résultat du premie... | ["\nassert roll_dice() == None # The function should not return anything\n", "\nassert random.randint(1, 6) in range(1, 7) # Ensure random.randint returns a value between 1 and 6\n", "\nassert random.randint(1, 6) in range(1, 7) # Ensure random.randint returns a value between 1 and 6\n", "\nassert random.randint(1, ... |
bd94d95ae5215864ec0de9ab54326402 | [
{
"content": "On te donne un graphe représenté par un ensemble de sommets et une matrice d'adjacence. Ta tâche est de convertir cette représentation de graphe en une liste d'arêtes triée. La liste d'arêtes doit être triée par le poids des arêtes par ordre croissant. Le graphe peut être orienté ou non orienté. S... | ["\nassert convert_to_edge_list((['A', 'B', 'C'], [[0, 1, 0], [1, 0, 2], [0, 2, 0]], False)) == (['A', 'B', 'C'], [('A', 'B'), ('B', 'C')])\n", "\nassert convert_to_edge_list((['A', 'B', 'C'], [[0, 1, 0], [1, 0, 2], [0, 2, 0]], True)) == (['A', 'B', 'C'], [('A', 'B'), ('B', 'A'), ('B', 'C'), ('C', 'B')])\n", "\nassert ... |
428f86090a8cb34e570fbc61feec4289 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui trouve le plus grand entier de la liste qui est divisible par 5. Si un tel entier n'existe pas, la fonction doit renvoyer -1.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 1000), où chaque entier `nu... | ["\nassert largest_divisible_by_five([12, 35, 10, 46, 78, 95, 23]) == 95\n", "\nassert largest_divisible_by_five([5, 10, 15, 20, 25]) == 25\n", "\nassert largest_divisible_by_five([1, 2, 3, 4, 6]) == -1\n", "\nassert largest_divisible_by_five([0, 5, 10, 15, 20]) == 20\n", "\nassert largest_divisible_by_five([-5, -10, -... |
c4e0877672fb9ab47721812e3771fd9e | [
{
"content": "On te donne un fichier JSON contenant une liste d'enregistrements d'étudiants. Chaque enregistrement d'étudiant est un dictionnaire avec les clés \"name\", \"age\" et \"grades\". La clé \"grades\" correspond à une liste d'entiers représentant les notes de l'étudiant. Ta tâche est de calculer la mo... | ["\nassert calculate_harmonic_mean_grades(\"students1.json\") == {\"Alice\": 2.0, \"Bob\": 3.0}\n", "\nassert calculate_harmonic_mean_grades(\"students2.json\") == {\"Charlie\": 0.0, \"David\": 4.0}\n", "\nassert calculate_harmonic_mean_grades(\"students3.json\") == {\"Eve\": 2.4, \"Frank\": 0.0}\n", "\nassert calculat... |
50f569c87495df0263aebcff7ff0790b | [
{
"content": "On te donne la tâche de concevoir une fonction qui construit un chemin de fichier unique pour stocker des images en fonction d'un répertoire de base donné, d'un identifiant et d'une extension de fichier facultative. Le chemin de fichier doit être unique pour chaque combinaison de date et d'identif... | ["\nassert generate_unique_image_path(\"/images\", \"user_123\") == \"/images/20231005_3b18e51277d488fe93102466253872b1b7594e4d6d297482c864782f44e5a01a.png\"\n", "\nassert generate_unique_image_path(\"/images\", \"user_123\", \"jpg\") == \"/images/20231005_3b18e51277d488fe93102466253872b1b7594e4d6d297482c864782f44e5a01... |
d2472bea26935611000eba8a58dfd576 | [
{
"content": "On te donne une liste d'intervalles de temps, chacun représenté comme un tuple `(début, fin)`, où `début` et `fin` désignent respectivement les heures de début et de fin de l'intervalle. La liste n'est pas forcément triée. Ta tâche est de mettre en œuvre une fonction qui traite ces intervalles sel... | ["\nassert merge_intervals([(1, 3), (2, 6), (8, 10), (15, 18), (5, 7), (11, 13), (0, 2)], 1, 0) == [(0, 7), (8, 10), (11, 13), (15, 18)]\n", "\nassert merge_intervals([(1, 2), (3, 4), (5, 6)], 1, 1) == [(1, 6)]\n", "\nassert merge_intervals([(1, 2), (3, 4), (5, 6)], 1, 0) == [(1, 2), (3, 4), (5, 6)]\n", "\nassert merge... |
1972e43427806625a1db0ea0e4cc1374 | [
{
"content": "On te demande d'implémenter une fonction `find_super_divisible_numbers` qui identifie les nombres divisibles par tous les entiers d'une plage spécifiée. Plus précisément, écris une fonction `find_super_divisible_numbers(n, mn=1, mx=20)` qui renvoie une liste des `n` premiers nombres qui sont divis... | ["\nassert find_super_divisible_numbers(1) == [232792560]\n", "\nassert find_super_divisible_numbers(2) == [232792560, 465585120]\n", "\nassert find_super_divisible_numbers(3) == [232792560, 465585120, 698377680]\n", "\nassert find_super_divisible_numbers(1, 1, 5) == [60]\n", "\nassert find_super_divisible_numbers(2, 1... |
4f8214bf22466ffead8b95bc9ee0d603 | [
{
"content": "Tu es chargé d'implémenter une fonction `analyze_text` qui traite une chaîne de caractères donnée `text` et renvoie un dictionnaire avec la fréquence de chaque mot. La fonction doit traiter les mots de manière insensible à la casse et ignorer la ponctuation, en ne considérant que les caractères al... | ["\nassert analyze_text(\"Hello world! Hello, Universe.\") == {'hello': 2, 'world': 1, 'universe': 1}\n", "\nassert analyze_text(\"Python, Python, Python!\") == {'python': 3}\n", "\nassert analyze_text(\"A quick brown fox jumps over the lazy dog.\") == {'a': 1, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, '... |
42090708184c47bfcf750cfa9bfe51ac | [
{
"content": "On te donne une chaîne de caractères `s` composée de `n` caractères. Ta tâche est de mettre en œuvre une fonction `count_vowels` qui renvoie le nombre total de voyelles présentes dans la chaîne. Les voyelles sont définies comme les caractères `'a'`, `'e'`, `'i'`, `'o'`, `'u'` et leurs versions maj... | ["\nassert count_vowels(\"hello\") == 2\n", "\nassert count_vowels(\"HELLO\") == 2\n", "\nassert count_vowels(\"Python Programming\") == 4\n", "\nassert count_vowels(\"AEIOUaeiou\") == 10\n", "\nassert count_vowels(\"\") == 0\n", "\nassert count_vowels(\"bcdfg\") == 0\n", "\nassert count_vowels(\"abcdefghijklmnopqrstuv... |
aa47abec60413df7e08b9f725ceafe0e | [
{
"content": "Étant donné une chaîne de caractères `s` et un entier `k`, détermine la longueur de la plus longue sous-chaîne qui contient au plus `k` caractères distincts.\n\n**Entrée :**\n- Une chaîne de caractères `s` (1 ≤ |s| ≤ 10^5) composée de lettres minuscules de l'alphabet anglais.\n- Un entier `k` (0 ≤... | ["\nassert length_of_longest_substring_k_distinct(\"eceba\", 2) == 3\n", "\nassert length_of_longest_substring_k_distinct(\"aa\", 1) == 2\n", "\nassert length_of_longest_substring_k_distinct(\"aabbcc\", 1) == 2\n", "\nassert length_of_longest_substring_k_distinct(\"aabbcc\", 2) == 4\n", "\nassert length_of_longest_subs... |
ac7f013527a3bef215b7b0208e2a1922 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence croissante dans la liste. Une sous-séquence croissante est définie comme une séquence de nombres où chaque nombre est supérieur au précédent. Par exemple, dans la liste [3, 6, 2, 7], la plus longue sous-séquence ... | ["\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 18]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7]) == [7]\n", "\nassert longest_increasing_subsequence([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\... |
4440feb3f82595b4c3889638e2181609 | [
{
"content": "On te demande d'implémenter une fonction `generate_csv` qui accepte une liste de dictionnaires et l'écrit dans un fichier CSV. Chaque dictionnaire de la liste correspond à une ligne du fichier CSV, les clés du dictionnaire servant d'en-têtes de colonne. Ta fonction doit gérer les erreurs potentiel... | ["\nassert generate_csv([{'name': 'Alice', 'age': 30, 'city': 'New York'}, {'name': 'Bob', 'age': 25, 'city': 'Los Angeles'}], 'test1.csv') is None\n", "\nassert generate_csv([{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}], 'test2.csv') is None\n", "\nassert generate_csv([{'name': 'Alice', 'age': 30, 'city':... |
c6dfbd08570f1b59369aa0f2284d175e | [
{
"content": "Tu développes un système pour gérer le menu d'un restaurant stocké dans un fichier JSON. Chaque plat du menu est représenté comme un dictionnaire avec les clés \"name\", \"price\" et \"category\". La \"category\" peut être \"appetizer\", \"main course\" ou \"dessert\". Ta tâche est d'implémenter l... | ["\nassert loadMenu('menu1.json') == {'appetizer': [{'name': 'Spring Rolls', 'price': 5, 'category': 'appetizer'}], 'main course': [{'name': 'Spaghetti', 'price': 12, 'category': 'main course'}]}\n", "\nassert loadMenu('menu2.json') == {'dessert': [{'name': 'Ice Cream', 'price': 6, 'category': 'dessert'}, {'name': 'Cak... |
96dbb1d65179e907cb98d5ac3c06c054 | [
{
"content": "On te demande d'implémenter un simple jeu de devinettes de nombres en mode texte. Le jeu consiste à deviner un entier généré aléatoirement entre 1 et 100. Le joueur dispose d'un maximum de 10 tentatives par manche. Après chaque proposition, le jeu doit fournir un retour d'information indiquant si ... | ["\nassert isinstance(NumberGuessingGame().target_number, int)\n", "\nassert 1 <= NumberGuessingGame().target_number <= 100\n", "\nassert NumberGuessingGame().attempts == 0\n", "\nassert NumberGuessingGame().max_attempts == 10\n", "\nassert NumberGuessingGame().best_score is None\n", "\ngame = NumberGuessingGame(); gam... |
8d127b272cbd075893e8f90951914f09 | [
{
"content": "On te demande de traiter un fichier CSV volumineux qui contient des informations sur des produits. Chaque ligne du fichier représente un produit et comprend les champs suivants séparés par des virgules : l'ID du produit, le nom du produit, la catégorie du produit et le prix du produit. En raison d... | ["\nassert list(product_generator(\"test.csv\")) == [('1', 'Product1', 'Category1', '10.99'), ('2', 'Product2', 'Category2', '15.99')]\n", "\nassert list(product_generator(\"empty.csv\")) == []\n", "\nassert list(product_generator(\"malformed.csv\")) == [('1', 'Product1', 'Category1', '10.99')]\n", "\nassert list(produ... |
7a69fcf401618824185ec1e4eb97f895 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`, chacune contenant des éléments uniques. Ta tâche est de déterminer l'intersection de ces deux listes. Pour chaque élément commun, compte ses occurrences dans les deux listes combinées, en excluant les nombres premiers du compte. Retourne le ré... | ["\nassert intersection_count([2, 3, 4, 5], [3, 4, 5, 6]) == [(4, 2), (6, 1)]\n", "\nassert intersection_count([11, 13, 17], [11, 13, 17]) == []\n", "\nassert intersection_count([4, 6, 8, 9], [4, 6, 8, 9]) == [(4, 2), (6, 2), (8, 2), (9, 2)]\n", "\nassert intersection_count([2, 3, 5], [2, 3, 5]) == []\n", "\nassert int... |
b0e9c85b6e2cd0d18bfce192df8f6bd7 | [
{
"content": "On te donne une liste de titres de livres. Ta tâche est d'écrire une fonction Python qui détermine la première lettre la plus courante parmi ces titres, sans tenir compte de la casse. Si plusieurs lettres ont la même fréquence la plus élevée, renvoie-les toutes dans un dictionnaire avec leurs déno... | ["\nassert most_common_first_letter([\"The Great Gatsby\", \"To Kill a Mockingbird\", \"The Catcher in the Rye\", \"1984\", \"The Hobbit\"]) == {\"t\": 3}\n", "\nassert most_common_first_letter([\"Moby Dick\", \"Madame Bovary\", \"Macbeth\", \"Moby Dick\", \"Macbeth\"]) == {\"m\": 3}\n", "\nassert most_common_first_let... |
03a44b1786fcc606a5a75ae851563526 | [
{
"content": "On te donne deux dictionnaires, `dict1` et `dict2`. Ta tâche est d'écrire une fonction Python `merge_dictionaries(dict1, dict2)` qui fusionne ces deux dictionnaires dans un nouveau dictionnaire. En cas de conflit de clé, la valeur de `dict2` doit écraser la valeur de `dict1`.\n\n**Entrée :**\n- De... | ["\nassert merge_dictionaries({}, {}) == {}\n", "\nassert merge_dictionaries({'a': 1}, {'b': 2}) == {'a': 1, 'b': 2}\n", "\nassert merge_dictionaries({'a': 1, 'b': 2}, {'b': 3, 'c': 4}) == {'a': 1, 'b': 3, 'c': 4}\n", "\nassert merge_dictionaries({'x': 10, 'y': 20}, {'z': 30}) == {'x': 10, 'y': 20, 'z': 30}\n", "\nasse... |
1118e469be68468412a01ab5d6bf1413 | [
{
"content": "On te donne une liste d'entiers `numbers` et une fonction `operation`. La fonction `operation` prend un seul entier en entrée et renvoie un entier. Ta tâche est de mettre en œuvre une fonction `apply_operation` qui applique la fonction `operation` à chaque élément de la liste `numbers` et renvoie ... | ["\nassert apply_operation([1, 2, 3], lambda x: x + 5) == [6, 7, 8]\n", "\nassert apply_operation([10, 20, 30], lambda x: x * 2) == [20, 40, 60]\n", "\nassert apply_operation([5, 15, 25], lambda x: x - 10) == [-5, 5, 15]\n", "\nassert apply_operation([1, 2, 3], lambda x: 1 / x) == [1.0, 0.5, 0.3333333333333333]\n", "\n... |
bec35e1c8744f109a3ac298f97c30900 | [
{
"content": "On te donne une liste de `N` boîtes englobantes au format `[x, y, largeur, hauteur, rotation]`, où `(x, y)` représente le centre de la boîte, `largeur` et `hauteur` sont les dimensions de la boîte, et `rotation` est l'angle de rotation de la boîte en degrés. Ta tâche est de convertir ces boîtes en... | ["\nassert convert_bounding_boxes([[0, 0, 2, 2, 0]]) == [[(-1.0, -1.0), (1.0, -1.0), (1.0, 1.0), (-1.0, 1.0), 0]]\n", "\nassert convert_bounding_boxes([[1, 1, 2, 2, 90]]) == [[(0.0, 0.0), (0.0, 2.0), (2.0, 2.0), (2.0, 0.0), 90]]\n", "\nassert convert_bounding_boxes([[0, 0, 4, 2, 45]]) == [[(-1.414213562373095, -1.41421... |
127402ec210bb6211437d2b9b35124b5 | [
{
"content": "On te donne une chaîne de caractères `path` représentant un chemin de fichier. Ta tâche est d'écrire une fonction `normalize_path(path)` qui renvoie une version normalisée du chemin d'entrée. Le processus de normalisation implique les étapes suivantes :\n1. Remplace tous les séparateurs de réperto... | ["\nassert normalize_path(\"C:\\\\Users\\\\Example\\\\Documents\\\\\") == \"c:/users/example/documents\"\n", "\nassert normalize_path(\"/path//to///file/\") == \"path/to/file\"\n", "\nassert normalize_path(\"\\\\another\\\\path\\\\\") == \"another/path\"\n", "\nassert normalize_path(\"///\") == \"\"\n", "\nassert norma... |
97a27af18500fb7488ab5a11388a41c2 | [
{
"content": "Tu es chargé d'implémenter une classe `Rectangle` en Python qui modélise un rectangle dans un plan 2D. Le rectangle est défini par sa largeur et sa hauteur. Ta classe doit inclure des méthodes pour calculer l'aire et le périmètre du rectangle. La classe doit respecter les spécifications suivantes ... | ["\nassert Rectangle(3.0, 4.0).area() == 12.0\n", "\nassert Rectangle(5.5, 2.0).perimeter() == 15.0\n", "\nassert Rectangle(0.0, 0.0).area() == 0.0\n", "\nassert Rectangle(7.2, 3.8).perimeter() == 22.0\n", "\nassert Rectangle(1.0, 1.0).area() == 1.0\n", "\nassert Rectangle(10.0, 5.0).perimeter() == 30.0\n", "\nassert R... |
cd71633925480a8b835409e0f0150155 | [
{
"content": "On te donne une liste de tuples. Ton objectif est d'écrire une fonction Python qui trie cette liste en fonction du deuxième élément de chaque tuple, par ordre croissant.\n\n**Entrée :**\n- Une liste de tuples, où chaque tuple contient deux entiers.\n\n**Sortie :**\n- Une liste de tuples triée en f... | ["\nassert sort_tuples_by_second_item([(2, 3), (1, 2), (4, 1), (3, 4)]) == [(4, 1), (1, 2), (2, 3), (3, 4)]\n", "\nassert sort_tuples_by_second_item([(5, 5), (4, 4), (3, 3), (2, 2)]) == [(2, 2), (3, 3), (4, 4), (5, 5)]\n", "\nassert sort_tuples_by_second_item([(1, 10), (2, 9), (3, 8), (4, 7)]) == [(4, 7), (3, 8), (2, 9... |
fc88ee251b0e9ef8beff107530ce8344 | [
{
"content": "On te donne une chaîne de caractères qui représente un objet JSON. Ta tâche est d'écrire une fonction Python `parse_json` qui convertit cette chaîne en un dictionnaire Python. Si la chaîne n'est pas un objet JSON valide, ta fonction doit renvoyer un dictionnaire vide. Ta fonction doit gérer tous l... | ["\nassert parse_json('{\"name\": \"John\", \"age\": 30}') == {\"name\": \"John\", \"age\": 30}\n", "\nassert parse_json('{\"key\": \"value\", \"number\": 123}') == {\"key\": \"value\", \"number\": 123}\n", "\nassert parse_json('{\"nested\": {\"key\": \"value\"}}') == {\"nested\": {\"key\": \"value\"}}\n", "\nassert pa... |
afccd6a0399dd3c9d8b97152349e1cf3 | [
{
"content": "On te demande d'implémenter une fonction `sumFiboEvenLessThanN(n)` qui calcule la somme de tous les nombres de Fibonacci pairs inférieurs à un entier donné `n`. Utilise les propriétés suivantes pour optimiser ta solution :\n\n- Les nombres de Fibonacci pairs apparaissent aux indices qui sont des m... | ["\nassert sumFiboEvenLessThanN(10) == 10\n", "\nassert sumFiboEvenLessThanN(34) == 44\n", "\nassert sumFiboEvenLessThanN(1) == 0\n", "\nassert sumFiboEvenLessThanN(2) == 0\n", "\nassert sumFiboEvenLessThanN(4000000) == 4613732\n", "\nassert sumFiboEvenLessThanN(100) == 44\n", "\nassert sumFiboEvenLessThanN(4000001) ==... |
48a930e7f30648c2836a315851da741e | [
{
"content": "On te donne un grand fichier texte. Ta tâche est d'écrire une fonction Python qui lit le fichier ligne par ligne et compte la fréquence de chaque mot. Les mots sont définis comme des séquences de caractères alphanumériques et ne distinguent pas la casse. La ponctuation doit être ignorée. La foncti... | ["\nassert count_word_frequencies('test_file_1.txt') == Counter({'the': 2, 'quick': 2, 'brown': 2, 'fox': 2, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1})\n", "\nassert count_word_frequencies('test_file_2.txt') == Counter({'hello': 3, 'world': 2, 'this': 1, 'is': 1, 'a': 1, 'test': 1})\n", "\nassert count_word_frequenci... |
7e17b1f008f37ef9366819bd0440e431 | [
{
"content": "On te donne deux listes : `ranks` et `suites`. Ta tâche est de construire un jeu de cartes où chaque carte est une combinaison d'un rang et d'une couleur. Une carte est valide si la somme des valeurs ASCII de son rang et de sa couleur est paire, et qu'aucune couleur n'apparaît plus de trois fois d... | ["\nassert generate_deck(['2'], ['H']) == ['2H']\n", "\nassert generate_deck(['2', '3'], ['H', 'D']) == ['2H', '3D']\n", "\nassert generate_deck(['A'], ['S']) == ['AS']\n", "\nassert generate_deck(['10'], ['C']) == []\n", "\nassert generate_deck(['2', '4', '6', '8', '10'], ['H', 'D', 'C', 'S']) == ['2H', '4D', '6C', '8... |
841008f1540fc31800bc88fd0c933a77 | [
{
"content": "On te donne une grille 3D de dimensions `N x M x O` remplie d'entiers. Chaque cellule de la grille est identifiée par ses coordonnées 3D `(i, j, k)` où `0 <= i < N`, `0 <= j < M`, et `0 <= k < O`. La grille est stockée en ordre de parcours par lignes. Implémente une fonction `find_cell_index(coor,... | ["\nassert find_cell_index((0, 0, 0), (2, 3, 4)) == 0\n", "\nassert find_cell_index((1, 2, 3), (5, 4, 3)) == 21\n", "\nassert find_cell_index((1, 1, 1), (2, 2, 2)) == 7\n", "\nassert find_cell_index((-1, -1, -1), (3, 3, 3)) == 26\n", "\nassert find_cell_index((2, 2, 2), (3, 3, 3)) == 26\n", "\nassert find_cell_index((0... |
67e1ccd3c9f0a16658d3ed65636562d9 | [
{
"content": "On te donne une liste d'entiers `word_lengths` et un entier `initial_window_size`. Chaque entier dans `word_lengths` représente la longueur d'un mot modifié dans un document texte. Le `initial_window_size` est le nombre de caractères dans le document texte original qui correspondent aux trois prem... | ["\nassert generate_pointers([5, 3, 7], 10) == [(0, 4), (5, 7), (8, 14)]\n", "\nassert generate_pointers([2, 2, 2, 2, 2, 2], 3) == [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, 11)]\n", "\nassert generate_pointers([1, 1, 1, 1, 1, 1, 1, 1, 1], 1) == [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8)... |
84aa6e0b2816457795af9bb1e7dab550 | [
{
"content": "On te donne une série de dictionnaires. Ta tâche est de fusionner ces dictionnaires en un seul dictionnaire. En cas de collisions de clés, la valeur du dictionnaire qui apparaît le plus tard dans la liste d'arguments doit prévaloir. Si les valeurs associées à une clé sont des listes, concatène-les... | ["\nassert merge_dicts_with_priority({'a': 1}, {'b': 2}) == {'a': 1, 'b': 2}\n", "\nassert merge_dicts_with_priority({'a': [1, 2]}, {'a': [3, 4]}) == {'a': [1, 2, 3, 4]}\n", "\nassert merge_dicts_with_priority({'a': {1, 2}}, {'a': {3, 4}}) == {'a': {1, 2, 3, 4}}\n", "\nassert merge_dicts_with_priority({'a': 'hello'}, {... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.