id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
9afdf884593cdd2f0043ff73b7d27a44 | [
{
"content": "Tu es chargé d'analyser une liste de paramètres de configuration. Chaque paramètre est fourni sous forme de chaîne de caractères au format `paramètre=valeur`. Ton objectif est de construire un dictionnaire à partir de ces paramètres où chaque clé est un paramètre de configuration unique et la vale... | ["\nassert parse_configurations([\"setting1=value1\", \"setting2=value2\"]) == {\"setting1\": \"value1\", \"setting2\": \"value2\"}\n", "\nassert parse_configurations([\"setting1=value1\", \"setting1=value2\"]) == {\"setting1\": \"value2\"}\n", "\nassert parse_configurations([\"setting1=value1\", \"setting2=value2\", \... |
a23621677156a18ad1170ac51ead6a19 | [
{
"content": "Tu développes un système de gestion de documents qui nécessite un mécanisme de filtrage de fichiers sophistiqué. Ta tâche est d'implémenter une fonction `create_file_filter` qui traite une liste de chemins de fichiers et les filtre en fonction de critères d'inclusion et d'exclusion spécifiés. Les ... | ["\nassert create_file_filter([], [], [\"file1.txt\", \"file2.doc\"]) == [\"file1.txt\", \"file2.doc\"]\n", "\nassert create_file_filter([\".txt\"], [], [\"file1.txt\", \"file2.doc\"]) == [\"file1.txt\"]\n", "\nassert create_file_filter([], [\".doc\"], [\"file1.txt\", \"file2.doc\"]) == [\"file1.txt\"]\n", "\nassert cr... |
8dd8677e8fe1cc689c52cebc250fb089 | [
{
"content": "On te donne deux listes : `numbers` contenant `n` entiers et `indices` contenant `m` entiers distincts. Ta tâche est de trouver l'indice du plus petit nombre dans `numbers` qui n'est pas présent dans `indices`. La comparaison pour déterminer le plus petit nombre doit être basée sur la représentati... | ["\nassert find_smallest_index([69, 88, 12, 96, 98, 100, 23, 45], [0, 4, 6]) == 1\n", "\nassert find_smallest_index([69, 88, 12, 96, 98, 100, 23, 45], [1, 2, 3, 5, 7]) == 0\n", "\nassert find_smallest_index([123, 456, 789], [0, 1, 2]) == -1\n", "\nassert find_smallest_index([69, 96, 88, 88], [0]) == 2\n", "\nassert fin... |
378ef5d947ed3300c4908229bad35301 | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction `find_mode` qui renvoie une liste des modes de la liste d'entrée. Le mode est défini comme le ou les nombres qui apparaissent le plus fréquemment. Si plusieurs nombres partagent la fréquence la plus élevée, tous... | ["\nassert find_mode([1, 2, 2, 3, 3, 4]) == [2, 3]\n", "\nassert find_mode([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert find_mode([7, 7, 7, 7, 7]) == [7]\n", "\nassert find_mode([10, 20, 20, 10, 30, 30]) == [10, 20, 30]\n", "\nassert find_mode([1, 1, 2, 3, 3, 4, 4, 5, 5]) == [1, 3, 4, 5]\n", "\nassert find_mode([6... |
a9ab1ff8c79ab6076123aca13d0eb060 | [
{
"content": "On te donne une liste d'entiers `arr`. Ta tâche est de refactoriser la fonction Python fournie pour calculer le produit de chaque paire d'éléments distincts dans la liste. La fonction doit renvoyer une liste de ces produits. Optimise la fonction pour de meilleures performances.\n\n**Exemple d'entr... | ["\nassert efficient_function([1, 2, 3]) == [2, 3, 6, 3, 6, 2]\n", "\nassert efficient_function([0, 1, 2]) == [0, 0, 0, 0, 0, 0]\n", "\nassert efficient_function([1, 1, 1]) == [1, 1, 1, 1, 1, 1]\n", "\nassert efficient_function([2, 4, 6]) == [8, 12, 16, 12, 8, 12]\n", "\nassert efficient_function([-1, 1]) == [-1, 1]\n"... |
89ff4badabf8751e4fbc233b9e2f9ee4 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction Python `find_prime_factors(n)` qui calcule tous les facteurs premiers de `n` et les renvoie dans une liste. La fonction doit gérer les entrées invalides en levant une exception `ValueError` avec un message approprié. L'entrée se... | ["\nassert find_prime_factors(2) == [2]\n", "\nassert find_prime_factors(3) == [3]\n", "\nassert find_prime_factors(4) == [2, 2]\n", "\nassert find_prime_factors(5) == [5]\n", "\nassert find_prime_factors(6) == [2, 3]\n", "\nassert find_prime_factors(28) == [2, 2, 7]\n", "\nassert find_prime_factors(100) == [2, 2, 5, 5... |
6d49275d033421d30d59ab90a760e089 | [
{
"content": "On te demande d'implémenter une fonction `clean_username(username)` qui traite une chaîne de caractères de nom d'utilisateur donnée. La fonction doit effectuer les opérations suivantes :\n1. Convertir l'intégralité du nom d'utilisateur en minuscules.\n2. Supprimer tous les caractères non alphanumé... | ["\nassert clean_username(\"JohnDoe123!\") == \"johndoe\"\n", "\nassert clean_username(\"Jane_Doe\") == \"janedoe\"\n", "\nassert clean_username(\"Alice123\") == None\n", "\nassert clean_username(\"Bobbb\") == None\n", "\nassert clean_username(\"a1b2c3d4e5\") == \"a1b2c3d4e5\"\n", "\nassert clean_username(\"!!!!\") == ... |
01abd25184b34fba64cf8235e3763fa4 | [
{
"content": "On te donne une liste de points dans un plan 2D, où chaque point est représenté comme un tuple `(x, y)`. Ta tâche est d'écrire une fonction Python qui trie ces points en fonction de leur distance euclidienne à l'origine `(0, 0)`. La fonction doit renvoyer la liste triée des points.\n\n**Entrée :**... | ["\nassert sort_points_by_distance_from_origin([(0, 0)]) == [(0, 0)]\n", "\nassert sort_points_by_distance_from_origin([(1, 1), (0, 0)]) == [(0, 0), (1, 1)]\n", "\nassert sort_points_by_distance_from_origin([(3, 4), (1, 2)]) == [(1, 2), (3, 4)]\n", "\nassert sort_points_by_distance_from_origin([(0, 5), (5, 0), (3, 4)])... |
684e944c748aa486bbbc2d11f828e9a3 | [
{
"content": "On te donne deux dictionnaires ordonnés, `dict1` et `dict2`, où chaque dictionnaire contient des clés de type chaîne de caractères et des valeurs entières. Ta tâche est de construire un nouveau dictionnaire ordonné, `dict3`, en fusionnant `dict1` et `dict2`. Pour les clés qui apparaissent dans les... | ["\nassert merge_dictionaries(OrderedDict([('a', 1), ('b', 2)]), OrderedDict([('b', 3), ('c', 4)])) == OrderedDict([('a', 1), ('b', 5), ('c', 4)])\n", "\nassert merge_dictionaries(OrderedDict([('x', 5), ('y', 10)]), OrderedDict([('z', 15)])) == OrderedDict([('x', 5), ('y', 10), ('z', 15)])\n", "\nassert merge_dictionar... |
61ea984923c87974edc2ec576e0ad6f3 | [
{
"content": "On te donne une chaîne de caractères `input_string` au format PascalCase ou camelCase. Ta tâche est d'écrire une fonction Python `convert_to_snake_case` qui convertit cette chaîne en snake_case. En snake_case, toutes les lettres sont en minuscules et les mots sont séparés par des tirets bas. La ch... | ["\nassert convert_to_snake_case(\"ExampleInputString\") == \"example_input_string\"\n", "\nassert convert_to_snake_case(\"PascalCase\") == \"pascal_case\"\n", "\nassert convert_to_snake_case(\"camelCase\") == \"camel_case\"\n", "\nassert convert_to_snake_case(\"Already_snake_case\") == \"already_snake_case\"\n", "\nas... |
f882fc5762c7998c5552fe32bb390c5f | [
{
"content": "On te demande d'implémenter une fonction `create_person` qui construit un dictionnaire imbriqué représentant le profil d'une personne. La fonction accepte trois paramètres : `first_name`, `last_name`, et `**person_info`. `first_name` et `last_name` sont des chaînes de caractères représentant le pr... | ["\nassert create_person('John', 'Doe') == {'first_name': 'John', 'last_name': 'Doe', 'person_info': {}}\n", "\nassert create_person('Alice', 'Smith', age=30, occupation='Engineer') == {'first_name': 'Alice', 'last_name': 'Smith', 'person_info': {'age': 30, 'occupation': 'Engineer'}}\n", "\nassert create_person('Bob', ... |
c8b151a63b409bab6caa4059b9117641 | [
{
"content": "On te donne la tâche d'implémenter une fonction pour déterminer la validité d'un nom d'utilisateur en fonction de critères spécifiques. Un nom d'utilisateur est considéré comme invalide s'il satisfait l'une des conditions suivantes :\n- Il est vide ou ne contient que des caractères d'espacement.\n... | ["\nassert is_valid_username(\"\") == False\n", "\nassert is_valid_username(\" \") == False\n", "\nassert is_valid_username(\"abcd\") == False\n", "\nassert is_valid_username(\"12345\") == False\n", "\nassert is_valid_username(\"!@#$%\") == False\n", "\nassert is_valid_username(\"abcde\") == False\n", "\nassert is_v... |
baa9184505f093eec07e5ae7263871e4 | [
{
"content": "Tu es chargé d'implémenter une fonction `convert_seconds_to_time` qui prend un entier `total_seconds` en entrée et renvoie un dictionnaire représentant la durée équivalente en jours, heures, minutes et secondes. La fonction doit gérer les valeurs positives et négatives de `total_seconds`. Une vale... | ["\nassert convert_seconds_to_time(86401) == {'days': 1, 'hours': 0, 'minutes': 1, 'seconds': 1}\n", "\nassert convert_seconds_to_time(-86401) == {'days': -1, 'hours': 0, 'minutes': -1, 'seconds': -1}\n", "\nassert convert_seconds_to_time(0) == {'days': 0, 'hours': 0, 'minutes': 0, 'seconds': 0}\n", "\nassert convert_s... |
844e46bf3b804b6f3e640167f571e251 | [
{
"content": "On te donne un fichier CSV nommé \"data.csv\" contenant des données numériques. Ta tâche est d'écrire un script Python qui lit ce fichier et calcule la moyenne de chaque colonne, en gérant correctement les valeurs manquantes. Ton programme doit afficher la moyenne de chaque colonne sur la console.... | ["\nassert calculate_column_means(\"non_existent_file.csv\") is None\n", "\nassert calculate_column_means(\"empty_file.csv\") is None\n", "\nassert calculate_column_means(\"corrupted_file.csv\") is None\n", "\nassert calculate_column_means(\"single_value.csv\") is None\n", "\nassert calculate_column_means(\"single_colu... |
a2b29cd9f6c32b17ad81ba7b02b1ea63 | [
{
"content": "On te donne une liste de dictionnaires et une clé spécifique. Ta tâche est de mettre en œuvre une fonction qui filtre les dictionnaires où la valeur associée à la clé donnée est `None`. La fonction doit renvoyer une nouvelle liste de dictionnaires qui répondent aux critères sans modifier la liste ... | ["\nassert filter_dicts_by_key([{'a': 1}, {'b': 2}, {'a': None}], 'a') == [{'a': 1}]\n", "\nassert filter_dicts_by_key([{'x': 10}, {'y': 20}, {'z': 30}], 'x') == [{'x': 10}]\n", "\nassert filter_dicts_by_key([{'name': 'Alice'}, {'name': None}, {'name': 'Bob'}], 'name') == [{'name': 'Alice'}, {'name': 'Bob'}]\n", "\nass... |
33f6265181a9a49aa75663090959eb1f | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_prime_factors(n)` qui renvoie une liste de tous les facteurs premiers de `n`, y compris les doublons. Les facteurs premiers doivent être listés par ordre croissant.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^6)\n\n*... | ["\nassert find_prime_factors(28) == [2, 2, 7]\n", "\nassert find_prime_factors(100) == [2, 2, 5, 5]\n", "\nassert find_prime_factors(1) == []\n", "\nassert find_prime_factors(2) == [2]\n", "\nassert find_prime_factors(3) == [3]\n", "\nassert find_prime_factors(4) == [2, 2]\n", "\nassert find_prime_factors(13195) == [5... |
04e72c2d05b874e86be7e5d2a446dd92 | [
{
"content": "On te demande d'implémenter une fonction `calculate_character_ratio` qui calcule efficacement le rapport entre le nombre de caractères alphanumériques et le nombre total de caractères dans une chaîne de caractères donnée `text`. La chaîne d'entrée peut être très grande, jusqu'à 1 Go, donc ta solut... | ["\nassert calculate_character_ratio(\"abc123\") == 1.0\n", "\nassert calculate_character_ratio(\"abc!@#\") == 0.5\n", "\nassert calculate_character_ratio(\"!@#$%^&*()\") == 0.0\n", "\nassert calculate_character_ratio(\"1234567890\") == 1.0\n", "\nassert calculate_character_ratio(\"\") == 0.0\n", "\nassert calculate_ch... |
9d0550558641b9ac9ed42efbad33fac9 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui supprime les éléments dupliqués consécutifs de la liste. La fonction doit renvoyer la liste optimisée.\n\n**Entrée :**\n- Une liste d'entiers, `lst`, où `0 <= len(lst) <= 10^5` et chaque entier est dans la plage `-10^9 ... | ["\nassert remove_consecutive_duplicates([1, 2, 2, 3, 3, 3, 4]) == [1, 2, 3, 4]\n", "\nassert remove_consecutive_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_consecutive_duplicates([]) == []\n", "\nassert remove_consecutive_duplicates([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_consecutive_dupli... |
54711c0c192a84ff5eb67533f3723982 | [
{
"content": "On te demande d'implémenter une fonction pour analyser un fichier de configuration JSON utilisé par une application web. Le fichier contient des paramètres pour différents environnements : `\"development\"`, `\"testing\"` et `\"production\"`. Chaque environnement a son propre ensemble de paramètre... | ["\nassert get_environment_settings('config.json', 'development') == {\"host\": \"localhost\", \"port\": 5000}\n", "\nassert get_environment_settings('config.json', 'testing') == {\"host\": \"testserver\", \"port\": 5500}\n", "\nassert get_environment_settings('config.json', 'production') == {\"host\": \"prodserver\", ... |
e3c95477ff8b7746705af9795bbaa4f8 | [
{
"content": "On te donne une liste d'événements, chacun représenté comme un dictionnaire avec une clé `date` indiquant la date de l'événement au format AAAA-MM-JJ. Implémente une fonction `filter_by_date` qui filtre les événements se produisant dans une plage de dates spécifiée, inclusivement. La fonction doit... | ["\nassert filter_by_date([{\"name\": \"Event 1\", \"date\": \"2023-01-15\"}], \"2023-01-01\", \"2023-01-31\") == [{\"name\": \"Event 1\", \"date\": \"2023-01-15\"}]\n", "\nassert filter_by_date([{\"name\": \"Event 1\", \"date\": \"2023-01-15\"}], \"2023-01-16\", \"2023-01-31\") == []\n", "\nassert filter_by_date([{\"n... |
797c6988d13cdd0e6bebe593d07d8e3d | [
{
"content": "On te donne un arbre binaire représenté par une classe `Node`, où chaque nœud a un attribut `value` et des attributs `left` et `right` pointant vers les nœuds enfants gauche et droit, respectivement. Ta tâche est de mettre en œuvre une fonction `level_order_traversal` qui prend la racine de l'arbr... | ["\nassert level_order_traversal(None) == []\n", "\nassert level_order_traversal(Node(1)) == [[1]]\n", "\nassert level_order_traversal(Node(1, Node(2), Node(3))) == [[1], [2, 3]]\n", "\nassert level_order_traversal(Node(1, Node(2, Node(4), Node(5)), Node(3, Node(6), Node(7)))) == [[1], [2, 3], [4, 5, 6, 7]]\n", "\nasse... |
9f3566a0d9adb47c197ae812cfd74be8 | [
{
"content": "On te demande d'implémenter une fonction pour censurer une adresse IPv4 donnée. La fonction doit remplacer chaque occurrence d'un caractère spécifié dans l'adresse IP par un caractère de censure donné. La fonction doit construire manuellement la nouvelle chaîne en itérant sur chaque caractère de l... | ["\nassert censor_ip(\"192.168.1.1\", \"[.]\") == \"192[.]168[.]1[.]1\"\n", "\nassert censor_ip(\"10.0.0.1\", \"-\") == \"10-0-0-1\"\n", "\nassert censor_ip(\"172.16.0.0\", \"*\") == \"172*16*0*0\"\n", "\nassert censor_ip(\"127.0.0.1\", \"X\") == \"127X0X0X1\"\n", "\nassert censor_ip(\"0.0.0.0\", \"#\") == \"0#0#0#0\"\... |
50c42f9206e2011a2ad76088da72d0c6 | [
{
"content": "Tu développes un algorithme pour un jeu en ligne qui nécessite de générer des clés aléatoires uniques pour des coffres de butin. Chaque clé doit être une chaîne de 10 caractères composée de lettres minuscules de l'alphabet anglais et de chiffres. Étant donné que le jeu compte 10 000 000 de joueurs... | ["\nassert len(generate_unique_key()) == KEY_LENGTH\n", "\nassert generate_unique_key().isalnum()\n", "\nassert generate_unique_key().islower()\n", "\nassert generate_unique_key() not in existing_keys\n", "\nexisting_keys.add(generate_unique_key()); assert len(existing_keys) == 1\n", "\nexisting_keys.add(generate_uniqu... |
81b5775953631287758b6912d0ce7b7e | [
{
"content": "On te donne une chaîne de caractères `text` et une chaîne de caractères `keyword`. Ta tâche est d'implémenter une fonction `mask_last_keyword(text, keyword)` qui remplace la dernière occurrence de `keyword` dans `text` par des astérisques (`*`), en ignorant la casse et en gérant correctement la po... | ["\nassert mask_last_keyword(\"Hello world! Hello Python, hello everyone.\", \"hello\") == \"Hello world! Hello Python, ***** everyone.\"\n", "\nassert mask_last_keyword(\"This is a test. This is only a test.\", \"test\") == \"This is a test. This is only a ****.\"\n", "\nassert mask_last_keyword(\"Look at the sky, loo... |
16d0228a2604e34a82e25019a394218d | [
{
"content": "On te donne une liste de `n` chaînes de caractères `words` et une chaîne de caractères `prefix`. Ta tâche est de mettre en œuvre une fonction `find_words_with_prefix(words, prefix)` qui renvoie une liste de toutes les chaînes de caractères de `words` qui commencent par le `prefix` donné.\n\n**Entr... | ["\nassert find_words_with_prefix([\"apple\", \"application\", \"apricot\", \"banana\", \"avocado\"], \"ap\") == [\"apple\", \"application\", \"apricot\"]\n", "\nassert find_words_with_prefix([\"dog\", \"cat\", \"camel\", \"caterpillar\"], \"ca\") == [\"camel\", \"caterpillar\"]\n", "\nassert find_words_with_prefix([\"... |
624e75f0abd6d664394678cf978760b8 | [
{
"content": "On te donne un dictionnaire `prices_dict` où chaque clé est le nom d'un produit et chaque valeur est une liste de prix pour ce produit. Ta tâche est d'écrire une fonction `find_min_max_prices` qui calcule le prix minimum et le prix maximum pour chaque produit. La fonction doit renvoyer un nouveau ... | ["\nassert find_min_max_prices({\"product1\": [10.99, 9.99, 11.99]}) == {\"product1\": (9.99, 11.99)}\n", "\nassert find_min_max_prices({\"product1\": [5.00]}) == {\"product1\": (5.00, 5.00)}\n", "\nassert find_min_max_prices({\"product1\": [10.99, 9.99, 11.99], \"product2\": [8.99, 7.99, 9.99]}) == {\"product1\": (9.9... |
af169b6aa61a958af9d891471bcfc05a | [
{
"content": "On te donne une chaîne de caractères représentant un argument de ligne de commande. Cette chaîne peut contenir des espaces, des guillemets et des caractères d'échappement. Ta tâche est d'analyser cette chaîne en une liste de mots, en traitant les sous-chaînes entre guillemets comme un seul mot et ... | ["\nassert parse_command_line('\"hello world\"') == ['hello world']\n", "\nassert parse_command_line(\"'this is a test'\") == ['this is a test']\n", "\nassert parse_command_line('\\\\$HOME') == [os.getenv('HOME', '\\\\$HOME')]\n", "\nassert parse_command_line('hello world') == ['hello', 'world']\n", "\nassert parse_com... |
5a20e64766532673f5ac17a3618f5276 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci en utilisant la récursion. Cependant, ton implémentation doit gérer les cas limites et optimiser les performances. Plus précisément, ta fonction doit lever une exception `ValueError` si l'entrée n'est pas un entier... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(30) == 832040\n", "\nassert fibonacci... |
277fd26c92f2d78cb924ebb2d3f524f7 | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots, de nombres et de caractères spéciaux. Ta tâche est de mettre en œuvre une fonction `extract_words_numbers(text: str) -> Tuple[List[str], List[int]]` qui traite la chaîne et renvoie un tuple de deux listes. La première liste doit conteni... | ["\nassert extract_words_numbers(\"Hello world! 123 abc 456\") == ([\"Hello\", \"world\", \"abc\"], [123, 456])\n", "\nassert extract_words_numbers(\"No numbers here!\") == ([\"No\", \"numbers\", \"here\"], [])\n", "\nassert extract_words_numbers(\"123 456 789\") == ([], [123, 456, 789])\n", "\nassert extract_words_num... |
5f7a6988fcba92e155d2d82e33a364c1 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction qui construit un dictionnaire où chaque clé est un entier unique de la liste, et la valeur correspondante est la fréquence de cet entier dans la liste.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ ... | ["\nassert count_numbers([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) == {1: 1, 2: 2, 3: 3, 4: 4}\n", "\nassert count_numbers([5, 5, 5, 5, 5]) == {5: 5}\n", "\nassert count_numbers([1, 1, 2, 2, 3, 3, 4, 4]) == {1: 2, 2: 2, 3: 2, 4: 2}\n", "\nassert count_numbers([]) == {}\n", "\nassert count_numbers([10, 20, 30, 40, 50]) == {10: 1,... |
29ab3f7aa6615b21e4a46e4b60200e50 | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de déterminer le nombre de paires uniques `(i, j)` dans `nums` telles que `i < j`, `nums[i] > 2 * nums[j]`, et aucun élément de la paire ne fait partie d'une autre paire qualifiée.\n\n**Contraintes :**\n- `1 <= nums.length <= 50000`\n- `-10^9 <... | ["\nassert reverse_pairs([1, 3, 2, 3, 1]) == 2\n", "\nassert reverse_pairs([2, 4, 3, 5, 1]) == 3\n", "\nassert reverse_pairs([5, 4, 3, 2, 1]) == 10\n", "\nassert reverse_pairs([1, 2, 3, 4, 5]) == 0\n", "\nassert reverse_pairs([6, 6, 6, 6]) == 6\n", "\nassert reverse_pairs([1]) == 0\n", "\nassert reverse_pairs([]) == 0\... |
a54c231ba178f8e1d5c8caa71696f800 | [
{
"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 générer toutes les permutations uniques des caractères de la chaîne. Les permutations doivent être renvoyées sous forme de liste de chaînes de caractères. Note que si la chaîne d'entrée c... | ["\nassert generate_permutations(\"abc\") == [\"abc\", \"acb\", \"bac\", \"bca\", \"cab\", \"cba\"]\n", "\nassert generate_permutations(\"a\") == [\"a\"]\n", "\nassert generate_permutations(\"aa\") == [\"aa\"]\n", "\nassert generate_permutations(\"ab\") == [\"ab\", \"ba\"]\n", "\nassert generate_permutations(\"aabb\") ... |
95f25e1a5ff4338d9e174db483be300b | [
{
"content": "On te donne une chaîne binaire qui a été encodée et complétée avec des bits supplémentaires. Le processus d'encodage consiste à effectuer un XOR de chaque octet de la chaîne binaire originale avec l'octet `0xAA`. Après l'encodage, des bits supplémentaires sont ajoutés à la fin de la chaîne, marqué... | ["\nassert clean_binary_string('aaaaaaaa') == '10101010'\n", "\nassert clean_binary_string('aaaaaaaa00000000') == '10101010'\n", "\nassert clean_binary_string('44444444') == '00000000'\n", "\nassert clean_binary_string('4444444400000000') == '00000000'\n", "\nassert clean_binary_string('') == ''\n", "\nassert clean_bin... |
b190ca63407c3787f83b2d0dd5a28ca8 | [
{
"content": "On te donne une liste circulaire de `n` mots, `words`, et deux mots distincts, `w1` et `w2`, dont la présence dans la liste est garantie au moins une fois. Ta tâche est de déterminer le nombre minimum de mots entre `w1` et `w2` (inclus) en tenant compte de la nature circulaire de la liste.\n\n**En... | ["\nassert min_distance_circular(['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'grape'], 'apple', 'grape') == 4\n", "\nassert min_distance_circular(['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'grape'], 'banana', 'cherry') == 2\n", "\nassert min_distance_circular(['apple', 'banana', 'cherry',... |
604dd1fd80ba6173ab862a95d6dad2ab | [
{
"content": "Dans un scénario de test logiciel, tu dois implémenter une fonction `mock_route_change` à des fins de tests unitaires. Cette fonction doit utiliser un objet `mocker` pour patcher la fonction `change_route` du module `navigation.views`. Ce patch doit remplacer la fonction originale par un mock qui ... | ["\nassert mock_route_change(mocker).called == False\n", "\nassert 'navigation.views.change_route' in mocker.patch.object.call_args_list[0][0]\n", "\nassert 'navigation.utils.RouteManager.update_route' in mocker.patch.object.call_args_list[1][0]\n", "\nassert 'navigation.utils.RouteManager.delete_route' in mocker.patch... |
4bfab3e55ec4da51dcb38d80e8926d62 | [
{
"content": "On te donne une chaîne de caractères `text`. Ta tâche est d'écrire une fonction `count_distinct_words` qui renvoie le nombre de mots distincts dans la chaîne. Un mot est défini comme une séquence de caractères alphanumériques, séparés par des espaces ou de la ponctuation. Utilise la bibliothèque `... | ["\nassert count_distinct_words(\"Hello, world! Hello, Python. Python is great.\") == 5\n", "\nassert count_distinct_words(\"This is a test. This test is only a test.\") == 6\n", "\nassert count_distinct_words(\"One fish, two fish, red fish, blue fish.\") == 5\n", "\nassert count_distinct_words(\"To be or not to be, th... |
766e615b14ba1782a6b680459ee25e73 | [
{
"content": "Implémente une fonction génératrice en Python qui génère des nombres de Fibonacci indéfiniment. La fonction doit être conçue pour gérer un nombre d'itérations non spécifié, produisant des nombres de Fibonacci à la demande jusqu'à ce que l'itération soit arrêtée manuellement par l'utilisateur. Ton ... | ["\nassert [next(fibonacci_generator()) for _ in range(1)] == [0]\n", "\nassert [next(fibonacci_generator()) for _ in range(2)] == [0, 1]\n", "\nassert [next(fibonacci_generator()) for _ in range(5)] == [0, 1, 1, 2, 3]\n", "\nassert [next(fibonacci_generator()) for _ in range(10)] == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n... |
89cb9a5a223ddc467df949bdb97bb394 | [
{
"content": "On te donne une liste de `n` intervalles, où chaque intervalle est représenté par une paire d'entiers `[début, fin]`. Ta tâche est de fusionner tous les intervalles qui se chevauchent et de renvoyer les intervalles fusionnés dans l'ordre trié. Les intervalles ne sont pas nécessairement triés initi... | ["\nassert merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]]) == [[1, 6], [8, 10], [15, 18]]\n", "\nassert merge_intervals([[1, 4], [4, 5]]) == [[1, 5]]\n", "\nassert merge_intervals([[1, 2], [3, 4], [5, 6]]) == [[1, 2], [3, 4], [5, 6]]\n", "\nassert merge_intervals([[1, 3], [2, 4], [5, 7], [6, 8]]) == [[1, 4], [5, 8... |
a2984665ad1a6cf18d538c0a6e15ab36 | [
{
"content": "On te donne un faisceau de particules et des paramètres de machine pour calculer le décalage de fréquence moyen. Le décalage de fréquence est une mesure de la déviation de la fréquence d'oscillation du faisceau de particules par rapport à sa valeur idéale, influencée par des facteurs tels que les ... | ["\nassert calculate_average_tune_shift({'Qs': 6.0, 'z_hat': 0.001, 'eta': 0.01, 'radius': 1.0}, 0.01) == 0.0009\n", "\nassert calculate_average_tune_shift({}, 0.01) == 0.0009\n", "\nassert calculate_average_tune_shift({'Qs': None, 'z_hat': None, 'eta': None, 'radius': None}, None) == 0.0009\n", "\nassert calculate_ave... |
0f284e12970b665efca294ec16495f1a | [
{
"content": "Tu es chargé d'analyser une chaîne de caractères `expression` qui représente un ensemble d'ID de transformation. L'`expression` peut inclure des ID individuels, des ID séparés par des virgules, des plages d'ID (inclusives) indiquées par un tiret, et des plages imbriquées entre parenthèses. Ton obj... | ["\nassert parse_expression(\"1-5\") == [1, 2, 4, 5]\n", "\nassert parse_expression(\"3-9\") == [4, 5, 7, 8]\n", "\nassert parse_expression(\"10, 12, 15\") == [10, 12]\n", "\nassert parse_expression(\"(1-3, 5-7)\") == [1, 2, 5, 7]\n", "\nassert parse_expression(\"(3-6, (9-12, 15))\") == [1, 2, 4, 5, 7, 8, 10, 11]\n", "... |
952bd91df9818edb37c28fb449916593 | [
{
"content": "On te donne un tableau NumPy représentant un lot d'images avec les dimensions `[num_images, channels, height, width]`. Ta tâche est d'écrire une fonction `convert_to_cnn_format` qui transforme ce tableau en un format adapté à l'entrée d'un réseau neuronal convolutionnel (CNN). Le format attendu es... | ["\nassert convert_to_cnn_format(np.random.rand(1, 3, 32, 32)).shape == (1, 32, 32, 3)\n", "\nassert convert_to_cnn_format(np.random.rand(5, 1, 28, 28)).shape == (5, 28, 28, 1)\n", "\nassert convert_to_cnn_format(np.random.rand(3, 4, 16, 16)).shape == (3, 16, 16, 4)\n", "\nassert convert_to_cnn_format(np.random.rand(2,... |
e748a0ed89e3797dc96089b2fbcfe8f8 | [
{
"content": "Tu développes une simulation pour un jeu de « roue de la fortune ». La roue est divisée en cinq sections, chacune d'une couleur distincte. Le jeu permet à l'utilisateur de spécifier la probabilité d'atterrir sur chaque section via une liste séparée par des virgules de probabilités. Les probabilité... | ["\nassert simulate_wheel_spin([0.3, 0.2, 0.2, 0.2, 0.1]) in [\"red\", \"blue\", \"green\", \"yellow\", \"orange\"]\n", "\nassert simulate_wheel_spin([0.1, 0.1, 0.1, 0.1, 0.6]) in [\"red\", \"blue\", \"green\", \"yellow\", \"orange\"]\n", "\nassert simulate_wheel_spin([0.5, 0.25, 0.1, 0.1, 0.05]) in [\"red\", \"blue\",... |
c95b5b08f1670ca60f4472773413e3b5 | [
{
"content": "On te donne deux réseaux, un Réseau Informatique (RI) et un Réseau Électrique (RE), représentés comme deux graphes non orientés distincts. Chaque nœud du RI est interdépendant d'au plus un nœud du RE, et vice versa. Les interdépendances entre les nœuds sont fournies sous forme de liste de tuples, ... | ["\nassert create_interdependency_maps([(1, 'A'), (2, 'B')]) == ({1: 'A', 2: 'B'}, {'A': 1, 'B': 2})\n", "\nassert create_interdependency_maps([]) == ({}, {})\n", "\nassert create_interdependency_maps([(10, 'X')]) == ({10: 'X'}, {'X': 10})\n", "\nassert create_interdependency_maps([(1, 'A'), (1, 'B')]) == ({1: 'B'}, {'... |
7eb6f9abfa505280196c52757d709aa2 | [
{
"content": "On te demande d'implémenter une fonction décorateur personnalisée `_custom_decorator` en Python. Ce décorateur doit présenter le comportement suivant :\n\n1. Si aucun argument n'est fourni ou si le premier argument est un objet appelable, le décorateur doit renvoyer la fonction originale inchangée... | ["\nassert _custom_decorator(lambda: \"test\")() == \"test\"\n", "\nassert _custom_decorator()(lambda: \"test\")() == \"test\"\n", "\nassert _custom_decorator(\"test\")() == \"test\"\n", "\nmarker = _custom_decorator.__defaults__[0]\nassert _custom_decorator(marker)() is marker\n", "\nmarker = _custom_decorator.__defau... |
7ce09cf019ac1b3e408ea6acf20a6aaf | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé du nom d'un étudiant et de son score à l'examen correspondant. Ta tâche est de mettre en œuvre une fonction qui trie les étudiants en fonction de leurs scores à l'examen par ordre décroissant, en excluant tout étudiant ayant un score inf... | ["\nassert sort_students_by_score([(\"Alice\", 88), (\"Bob\", 72), (\"Charlie\", 69), (\"David\", 92), (\"Eve\", 72), (\"Frank\", 95)]) == [(\"Frank\", 95), (\"David\", 92), (\"Alice\", 88), (\"Bob\", 72), (\"Eve\", 72)]\n", "\nassert sort_students_by_score([(\"Anna\", 65), (\"Ben\", 70), (\"Chris\", 75)]) == [(\"Chris... |
37cefca98b11defbd6485ba65571d88f | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python qui modélise un rectangle dans un plan 2D. La classe doit être initialisée avec les coordonnées de son coin inférieur gauche `(x1, y1)` et de son coin supérieur droit `(x2, y2)`. Ton implémentation doit inclure les méthodes suivantes :\n... | ["\nassert Rectangle(0, 0, 4, 4).area() == 16\n", "\nassert Rectangle(1, 1, 5, 5).perimeter() == 16\n", "\nassert Rectangle(0, 0, 4, 4).is_square() == True\n", "\nassert Rectangle(0, 0, 4, 5).is_square() == False\n", "\nrect = Rectangle(0, 0, 2, 2)\nrect.translate(1, 1)\nassert rect.x1 == 1 and rect.y1 == 1 and rect.x2... |
7afba577b7b43e5fc654339a9636e40c | [
{
"content": "On te donne un dictionnaire `oligonucs` où les clés sont des identifiants de gènes et les valeurs sont des ensembles d'oligonucléotides. Chaque oligonucléotide est représenté comme une liste d'éléments, où chaque élément peut être soit une chaîne de caractères représentant un nucléotide (A, T, C, ... | ["\nassert get_oligo_seq({'gene1': {['A', 'T', 'G'], ['C', 'A', 'T'], ['C', 'G', 'T']}}, 'gene1') == 'ACG\\tATG\\tCAT'\n", "\nassert get_oligo_seq({'gene2': {['A', 'C'], ['T', 'G', 'A']}}, 'gene2') == 'AC\\tTGA'\n", "\nassert get_oligo_seq({'gene3': {['G', 'C', 'A'], ['T', 'A', 'C'], ['A', 'T', 'G']}}, 'gene3') == 'ACA... |
7c8849ce8173d9c4be8ab63d0a8cd526 | [
{
"content": "Tu es chargé de parser un ensemble de règles de pare-feu représenté sous forme de chaîne de caractères. Chaque règle est séparée par un point-virgule (`;`). Chaque règle est constituée d'un indicateur suivi d'une condition. L'indicateur est un seul mot, et la condition est entre parenthèses et peu... | ["\nassert parse_firewall_rules(\"allow (192.168.1.1)\") == {\"allow\": [\"192.168.1.1\"]}\n", "\nassert parse_firewall_rules(\"deny (255.255.255.255)\") == {\"deny\": [\"255.255.255.255\"]}\n", "\nassert parse_firewall_rules(\"allow (192.168.1.1, 10.0.0.0)\") == {\"allow\": [\"192.168.1.1\", \"10.0.0.0\"]}\n", "\nasse... |
7f21f99e1e67059abac8b687574ff1fe | [
{
"content": "On te donne une liste triée d'entiers, `int_list`, et un entier cible, `target`. Implémente une fonction récursive, `recursive_binary_search(target, low, high, int_list)`, pour trouver l'index de `target` dans `int_list[low..high]`. Si `target` n'est pas trouvé, retourne `None`. Si `int_list` est ... | ["\nassert recursive_binary_search(3, 0, 4, [1, 2, 3, 4, 5]) == 2\n", "\nassert recursive_binary_search(1, 0, 4, [1, 2, 3, 4, 5]) == 0\n", "\nassert recursive_binary_search(5, 0, 4, [1, 2, 3, 4, 5]) == 4\n", "\nassert recursive_binary_search(6, 0, 4, [1, 2, 3, 4, 5]) == None\n", "\nassert recursive_binary_search(0, 0, ... |
9351e090dcb0d316bafdca1ad8adbd7f | [
{
"content": "On te demande d'implémenter une fonction `validate_phone_number` qui détermine si une chaîne de caractères donnée représente un numéro de téléphone américain valide selon des règles spécifiques. Un numéro de téléphone américain valide doit respecter le format suivant :\n\n- Il commence par un sign... | ["\nassert validate_phone_number(\"+1 (123) 234-5678\", [\"123\"]) == True\n", "\nassert validate_phone_number(\"+1 234-5678\", []) == True\n", "\nassert validate_phone_number(\"+1 (123) 234-5678\", [\"456\"]) == False\n", "\nassert validate_phone_number(\"+1 (123) 234-5678\", [\"123\", \"456\"]) == True\n", "\nassert ... |
1a0eedd1ff7cdbc153680f781aff9f4b | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste originale. L'ordre des éléments dans la liste de sortie doit être le même que leur première apparition dans la liste d'entrée. Tu n'es pas au... | ["\nassert get_unique_values([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert get_unique_values([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert get_unique_values([1, 1, 1, 1, 1]) == [1]\n", "\nassert get_unique_values([]) == []\n", "\nassert get_unique_values([7, 8, 9]) == [7, 8, 9]\n", "\nassert get_unique_... |
c6c48c95bc44f6842aad4ee9797a6ca8 | [
{
"content": "On te donne une liste non triée d'entiers. Ta tâche est d'implémenter l'algorithme de tri à bulles pour trier la liste par ordre croissant. Tu dois écrire la fonction `bubble_sort` à partir de zéro sans utiliser de fonctions de tri intégrées. Ta fonction doit prendre une liste d'entiers en entrée ... | ["\nassert bubble_sort([64, 34, 25, 12, 22, 11, 90]) == [11, 12, 22, 25, 34, 64, 90]\n", "\nassert bubble_sort([5, 1, 4, 2, 8]) == [1, 2, 4, 5, 8]\n", "\nassert bubble_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert bubble_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert bub... |
b5309d891cdbcb191f0b2e3554d04779 | [
{
"content": "On te demande d'implémenter une classe `Matrix` en Python qui prenne en charge les opérations matricielles de base. La classe doit gérer les opérations suivantes :\n\n1. **Addition** : Ajouter deux matrices si elles ont les mêmes dimensions.\n2. **Soustraction** : Soustraire une matrice d'une autr... | ["\nassert Matrix([[1, 2], [3, 4]]).dimensions() == (2, 2)\n", "\nassert Matrix([[1, 2, 3], [4, 5, 6]]).add(Matrix([[7, 8, 9], [10, 11, 12]])).data == [[8, 10, 12], [14, 16, 18]]\n", "\nassert Matrix([[1, 2, 3], [4, 5, 6]]).subtract(Matrix([[1, 1, 1], [1, 1, 1]])).data == [[0, 1, 2], [3, 4, 5]]\n", "\nassert Matrix([[1... |
d0a3f00eb1c2e3b92038a83fb40d6080 | [
{
"content": "On te demande d'implémenter une fonction `generate_sequence(length)` qui construit une séquence de nombres de 1 à `length` en suivant des règles spécifiques :\n- Si le nombre est divisible par 3, ajoute \"Fizz\" à la séquence.\n- Si le nombre est divisible par 5, ajoute \"Buzz\" à la séquence.\n- ... | ["\nassert generate_sequence(1) == [1]\n", "\nassert generate_sequence(3) == [1, 2, \"Fizz\"]\n", "\nassert generate_sequence(5) == [1, 2, \"Fizz\", 4, \"Buzz\"]\n", "\nassert generate_sequence(15) == [1, 2, \"Fizz\", 4, \"Buzz\", \"Fizz\", 7, 8, \"Fizz\", \"Buzz\", 11, \"Fizz\", 13, 14, \"FizzBuzz\"]\n", "\nassert gen... |
a16a8b103f2bf1480f2daa81194fa8e7 | [
{
"content": "On te charge de développer une calculatrice financière pour un compte d'épargne bancaire. Le compte a un taux d'intérêt annuel variable qui change au début de chaque trimestre. Étant donné le dépôt initial, une liste des taux d'intérêt annuels pour les quatre prochains trimestres et un montant cib... | ["\nassert months_to_reach_target(1000, [2, 3, 4, 5], 1500) == 36\n", "\nassert months_to_reach_target(1000, [0, 0, 0, 0], 1000) == 0\n", "\nassert months_to_reach_target(1000, [0, 0, 0, 0], 1001) == 12\n", "\nassert months_to_reach_target(1000, [5, 5, 5, 5], 2000) == 24\n", "\nassert months_to_reach_target(1000, [10, ... |
dd53597e3b121538cc9c224e0ebb048b | [
{
"content": "On te donne un document texte sous forme de chaîne de caractères `document`. Implémente une fonction `extract_keywords` qui utilise des techniques de Traitement Automatique du Langage Naturel (TALN) pour identifier et renvoyer une liste des 10 mots-clés les plus fréquents du document. La fonction ... | ["\nassert extract_keywords(\"This is a test. This test is only a test.\") == ['test', 'is', 'a']\n", "\nassert extract_keywords(\"Hello world! Hello everyone.\") == ['hello']\n", "\nassert extract_keywords(\"Python is great. Python is fun. Python is powerful.\") == ['python', 'is']\n", "\nassert extract_keywords(\"NLP... |
f70f4755647da48235aed5510a56700a | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction qui trie la liste par ordre croissant sans utiliser de fonctions de tri intégrées telles que `sort()` ou `sorted()`. Tu dois implémenter ton propre algorithme de tri.\n\n**Entrée :**\n- Une liste d'entiers `arr` (1 ≤ len(arr)... | ["\nassert bubble_sort([34, 7, 23, 32, 5, 62]) == [5, 7, 23, 32, 34, 62]\n", "\nassert bubble_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert bubble_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert bubble_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert bubble_sort([1]... |
5cda464e6928642d3e59e1e36b35287f | [
{
"content": "Dans un système de bibliothèque en ligne hypothétique, tu dois implémenter une fonction qui construit l'URL pour une ressource spécifique. Le système de bibliothèque prend en charge trois types de ressources : des livres, des articles et des vidéos. Chaque ressource est identifiée de manière uniqu... | ["\nassert generate_resource_url(\"book\", \"123\") == \"http://library.com/api/v1/resource/book_123\"\n", "\nassert generate_resource_url(\"article\", \"abc\") == \"http://library.com/api/v1/resource/article_abc\"\n", "\nassert generate_resource_url(\"video\", \"abc123\") == \"http://library.com/api/v1/resource/video_... |
dba5ba483dbfe4485dfcc4109f8b66d9 | [
{
"content": "On te demande d'implémenter une fonction `get_active_policy_document` pour un service IAM-like basé sur le cloud. La fonction doit accepter un ARN de politique et renvoyer le document de politique compressé de la version par défaut de la politique. Le document de politique doit être compressé en u... | ["\nassert get_active_policy_document(\"arn:aws:s3:::example-bucket-policy\") == zlib.compress(json.dumps({\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": \"s3:GetObject\", \"Resource\": \"arn:aws:s3:::examplebucket/*\"}]}).encode('utf-8'))\n", "\nassert get_active_policy_document(\"arn... |
5dbf0645a467781b11b060ee01f13463 | [
{
"content": "On te donne une liste de mots et une longueur minimale. Ta tâche est de mettre en œuvre une fonction `filter_words` qui renvoie une liste de mots de la liste d'entrée qui sont plus longs que la longueur minimale spécifiée. La liste renvoyée ne doit contenir aucun mot en double et doit conserver l'... | ["\nassert filter_words([\"apple\", \"banana\", \"cherry\", \"date\"], 4) == [\"apple\", \"banana\", \"cherry\"]\n", "\nassert filter_words([\"dog\", \"cat\", \"fish\", \"bird\"], 3) == [\"fish\", \"bird\"]\n", "\nassert filter_words([\"hello\", \"world\", \"hello\", \"python\"], 4) == [\"hello\", \"world\", \"python\"... |
606e3d1bdca82f3ec544ea2dbc5b04d8 | [
{
"content": "On te demande d'implémenter une fonction `count_vowels` qui prend une chaîne de caractères en entrée et renvoie un dictionnaire contenant le nombre de chaque voyelle (a, e, i, o, u) présente dans la chaîne. La fonction doit être insensible à la casse, ce qui signifie qu'elle doit compter les voyel... | ["\nassert count_vowels(\"Hello World\") == {'a': 0, 'e': 1, 'i': 0, 'o': 2, 'u': 0}\n", "\nassert count_vowels(\"AEIOU\") == {'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1}\n", "\nassert count_vowels(\"abcdefghijklmnopqrstuvwxyz\") == {'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1}\n", "\nassert count_vowels(\"Python Programming\")... |
f44740cf0e0864324ddb2060b353d55b | [
{
"content": "Dans un problème d'optimisation multi-objectif, on te donne deux conceptions de robots, chacune représentée par un dictionnaire contenant le nombre de nœuds cachés dans un réseau neuronal, une distribution de probabilité représentant la nouveauté de l'architecture, et une valeur de violation de co... | ["\nassert dominates({'hidden_nodes': 5, 'novelty': [0.1, 0.2, 0.7], 'constraint_violation': -1}, {'hidden_nodes': 10, 'novelty': [0.3, 0.4, 0.3], 'constraint_violation': 2}) == True\n", "\nassert dominates({'hidden_nodes': 5, 'novelty': [0.1, 0.2, 0.7], 'constraint_violation': 1}, {'hidden_nodes': 10, 'novelty': [0.3,... |
bcb30a234918e2130ba8d2fecdbe78a7 | [
{
"content": "On te donne deux listes de tuples, `list1` et `list2`. Chaque tuple est composé d'un identifiant chaîne de caractères unique et d'une valeur entière associée. Ta tâche est de construire une nouvelle liste, `merged_list`, qui inclut tous les tuples de `list2` et tous les tuples de `list1` qui n'ont... | ["\nassert merge_and_sort([], []) == []\n", "\nassert merge_and_sort([(\"id1\", 10)], [(\"id2\", 20)]) == [(\"id1\", 10), (\"id2\", 20)]\n", "\nassert merge_and_sort([(\"id1\", 10), (\"id2\", 20)], [(\"id3\", 30)]) == [(\"id1\", 10), (\"id2\", 20), (\"id3\", 30)]\n", "\nassert merge_and_sort([(\"id1\", 10), (\"id2\", 2... |
f6271e9c22e9797281a2048e0d3392f4 | [
{
"content": "Implémente deux types de listes chaînées : une liste chaînée simple et une liste chaînée double. Chaque liste doit prendre en charge les opérations suivantes :\n- `add(data)` : Ajoute un nouveau nœud avec les données spécifiées à la fin de la liste.\n- `remove(data)` : Supprime le premier nœud ave... | ["\nassert SinglyLinkedList().find(1) is None\n", "\nassert SinglyLinkedList().remove(1) is None\n", "\nsll = SinglyLinkedList()\nsll.add(1)\nassert sll.find(1).data == 1\n", "\nsll = SinglyLinkedList()\nsll.add(1)\nsll.add(2)\nassert sll.find(2).data == 2\n", "\nsll = SinglyLinkedList()\nsll.add(1)\nsll.add(2)\nsll.re... |
40b381a0e7ded4c3bfb2539134a6319c | [
{
"content": "On te donne un dictionnaire `d` représentant les statistiques de performance d'un modèle d'apprentissage automatique. Le dictionnaire contient les clés suivantes :\n- `num_pairs` : Le nombre de paires de données utilisées pour entraîner le modèle.\n- `sec_per_pair` : Le temps moyen en secondes néc... | ["\nassert get_total_training_time({'num_pairs': '1000', 'sec_per_pair': '1', 'num_epochs': '1'}) == 1000\n", "\nassert get_total_training_time({'num_pairs': ' 1,234 ', 'sec_per_pair': ' 5.67 ', 'num_epochs': ' 10 '}) == 70035.6\n", "\nassert get_total_training_time({'num_pairs': '500', 'sec_per_pair': '2.5', 'nu... |
9673099076829f4daf43fbd337ff3658 | [
{
"content": "On te donne un dictionnaire représentant une liste d'étudiants et leurs notes correspondantes, mais le dictionnaire est inversé, ce qui signifie que les clés sont les noms des étudiants et les valeurs sont leurs notes respectives. Ta tâche est d'écrire une fonction qui prend ce dictionnaire invers... | ["\nassert invert_and_sort_grades({\"Alice\": \"A\", \"Bob\": \"B\", \"Charlie\": \"A\", \"David\": \"C\", \"Eve\": \"B\", \"Frank\": \"A\"}) == {'A': ['Alice', 'Charlie', 'Frank'], 'B': ['Bob', 'Eve'], 'C': ['David']}\n", "\nassert invert_and_sort_grades({\"Anna\": \"A\", \"Tom\": \"B\", \"Jerry\": \"B\", \"Spike\": \... |
e47817042cd501484a44b717c3f35a23 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé du nom d'un étudiant (une chaîne de caractères) et de son score (un entier). Ta tâche est d'écrire une fonction Python qui renvoie un dictionnaire associant le nom de chaque étudiant à son score, trié par score en ordre décroissant. Si d... | ["\nassert sort_students_by_score([('Alice', 88), ('Bob', 75), ('Charlie', 95), ('David', 82)]) == {'Charlie': 95, 'Alice': 88, 'David': 82, 'Bob': 75}\n", "\nassert sort_students_by_score([('Tom', 90), ('Jerry', 90), ('Spike', 85)]) == {'Tom': 90, 'Jerry': 90, 'Spike': 85}\n", "\nassert sort_students_by_score([('Anna'... |
5fe5eb046454d024e4adf2eb73d67696 | [
{
"content": "On te donne un dictionnaire `original_dict` avec des clés de type chaîne de caractères et des valeurs entières. Ta tâche est de mettre en œuvre une fonction `invert_dict` qui renvoie un nouveau dictionnaire avec les clés et les valeurs échangées. En cas de valeurs dupliquées dans le dictionnaire o... | ["\nassert invert_dict({\"a\": 1, \"b\": 2, \"c\": 3}) == {1: \"a\", 2: \"b\", 3: \"c\"}\n", "\nassert invert_dict({\"a\": 1, \"b\": 1, \"c\": 2}) == {1: \"a\", 2: \"c\"}\n", "\nassert invert_dict({\"z\": 10, \"y\": 10, \"x\": 20}) == {10: \"y\", 20: \"x\"}\n", "\nassert invert_dict({\"apple\": 5, \"banana\": 5, \"cher... |
2be27d69a6722ae2e6a20cf85aca42f7 | [
{
"content": "On te donne une liste de listes, où chaque sous-liste contient exactement quatre entiers positifs. Ta tâche est de déterminer si une permutation quelconque des entiers d'une sous-liste forme un quadruple pythagoricien. Un quadruple pythagoricien est défini comme un ensemble de quatre entiers posit... | ["\nassert find_pythagorean_quadruples([[3, 4, 12, 13]]) == [[3, 4, 12, 13]]\n", "\nassert find_pythagorean_quadruples([[1, 2, 3, 4]]) == []\n", "\nassert find_pythagorean_quadruples([[9, 40, 41, 42]]) == [[9, 40, 41, 42]]\n", "\nassert find_pythagorean_quadruples([[5, 5, 5, 5]]) == []\n", "\nassert find_pythagorean_qu... |
504dd6448825e35f1a27ce1081ce3d95 | [
{
"content": "On te donne deux entiers positifs, `n` et `m`, représentés sous forme de chaînes de caractères. Ces entiers n'ont pas de zéros non significatifs. Ta tâche est d'implémenter une fonction `compare_numbers(n, m)` qui compare ces deux nombres en fonction des règles suivantes :\n\n1. Si les deux nombre... | ["\nassert compare_numbers(\"2\", \"21\") == True\n", "\nassert compare_numbers(\"3\", \"21\") == True\n", "\nassert compare_numbers(\"43\", \"445\") == False\n", "\nassert compare_numbers(\"4500\", \"45\") == True\n", "\nassert compare_numbers(\"123\", \"12300\") == False\n", "\nassert compare_numbers(\"12300\", \"123... |
f1f48120ebd61c6637418d1b2cc32a18 | [
{
"content": "On te donne une liste de nombres, `numbers`, qui peut inclure à la fois des entiers et des nombres à virgule flottante. Ta tâche est de mettre en œuvre une fonction `format_numbers(numbers)` qui traite cette liste et renvoie une nouvelle liste avec les règles suivantes appliquées :\n- Si un nombre... | ["\nassert format_numbers([1.0, 2.5, 3, -4.0, -5.6, 6.0]) == [1, 2.5, 3, -4, -5.6, 6]\n", "\nassert format_numbers([0.0, 1.0, 2.0, 3.0]) == [0, 1, 2, 3]\n", "\nassert format_numbers([1.1, 2.2, 3.3, 4.4]) == [1.1, 2.2, 3.3, 4.4]\n", "\nassert format_numbers([-1.0, -2.5, -3, -4.0, -5.6]) == [-1, -2.5, -3, -4, -5.6]\n", "... |
e45b2bf9e1177c6922d1e8d5e0c2510d | [
{
"content": "Tu participes à un concours de programmation où tu dois développer une fonction Python pour récupérer les données météorologiques d'un lieu spécifié en utilisant l'API OpenWeatherMap. Ta fonction doit accepter une chaîne de caractères représentant le nom du lieu et renvoyer un dictionnaire avec le... | ["\nassert get_weather_data(\"London\") is not None\n", "\nassert get_weather_data(\"New York\") is not None\n", "\nassert get_weather_data(\"Tokyo\") is not None\n", "\nassert get_weather_data(\"InvalidCityName123\") is None\n", "\nassert get_weather_data(\"\") is None\n", "\nassert get_weather_data(\"Paris\")['city_n... |
de0c6e444524ad9c8f60d6fc0eb260fb | [
{
"content": "Tu participes à un défi de prétraitement de données où l'on te fournit un DataFrame pandas `df` représentant un ensemble de données. L'ensemble de données contient diverses caractéristiques (colonnes) qui suivent une convention de nommage spécifique : les caractéristiques numériques sont préfixées... | ["\nassert separate_features(pd.DataFrame({'n_feature1': [1, 2, 3], 'n_123': [4, 5, 6], 'c_feature2': ['A', 'B', 'C'], 'c_456': ['D', 'E', 'F'], 'other_feature': [7, 8, 9]})) == (['n_feature1'], ['c_feature2'])\n", "\nassert separate_features(pd.DataFrame({'n_1': [1, 2, 3], 'n_abc': [4, 5, 6], 'c_1': ['A', 'B', 'C'], '... |
f10cfff5194b478a3e6a65a8b51e027d | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python. La classe doit avoir les fonctionnalités suivantes :\n- Un constructeur qui initialise le rectangle avec une largeur et une hauteur données.\n- Une méthode pour calculer l'aire du rectangle.\n- Une méthode pour calculer le périmètre du ... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).area() == 25\n", "\nassert Rectangle(7, 2).perimeter() == 18\n", "\nassert Rectangle(10, 10).perimeter() == 40\n", "\nassert Rectangle(1, 2).is_square() == False\n", "\nassert Rectangle(8, 8).is_square() == True\n", "\nassert Rectangle(0, 0).area() =... |
e1aa45bc1db4125bbb99acd3abc8a1bd | [
{
"content": "On te demande d'implémenter une fonction génératrice Python nommée `fibonacci` qui génère une séquence infinie de nombres de Fibonacci. La séquence de Fibonacci commence par 0 et 1, et chaque nombre suivant est la somme des deux nombres précédents. Ta fonction doit produire les nombres de Fibonacc... | ["\nassert next(fibonacci()) == 0\n", "\nassert next(fibonacci()) == 0\n", "\ngen = fibonacci()\nnext(gen)\nassert next(gen) == 1\n", "\ngen = fibonacci()\nnext(gen)\nnext(gen)\nassert next(gen) == 1\n", "\ngen = fibonacci()\nnext(gen)\nnext(gen)\nnext(gen)\nassert next(gen) == 2\n", "\ngen = fibonacci()\nnext(gen)\nne... |
e85597b82a3e3a488de90b76983ee7b1 | [
{
"content": "On te demande d'écrire un script Python qui accepte un chemin de répertoire en argument de ligne de commande et liste récursivement tous les fichiers dans ce répertoire et ses sous-répertoires. Ton script doit gérer les exceptions avec élégance, y compris les scénarios où le répertoire n'existe pa... | ["\nassert list_files_in_directory(\"/nonexistent_directory\") == None\n", "\nassert list_files_in_directory(\"/root\") == None # Assuming the test is run by a non-root user\n", "\nassert list_files_in_directory(\"\") == None\n", "\nassert list_files_in_directory(\"/\") == None # This should list all files in the roo... |
6655c433ae9ed2dba7e318e242138066 | [
{
"content": "On te donne une chaîne de caractères `text` qui peut contenir des parenthèses imbriquées `()` et des crochets `[]`. Ta tâche est d'écrire une fonction `clean_text(text)` qui supprime toutes les sous-chaînes contenues dans ces parenthèses et ces crochets, y compris les caractères d'encadrement eux-... | ["\nassert clean_text(\"Hello (world)!\") == \"Hello!\"\n", "\nassert clean_text(\"This is a [test] string.\") == \"This is a string.\"\n", "\nassert clean_text(\"(Remove) this part.\") == \"this part.\"\n", "\nassert clean_text(\"[Keep] this [but remove] this.\") == \"Keep this .\"\n", "\nassert clean_text(\"No (brack... |
8a3c9637e8e9d522ac75ad8e7e89ed6b | [
{
"content": "Tu es chargé d'implémenter une fonction `clean_text` qui traite une chaîne de caractères donnée. La fonction doit renvoyer une nouvelle chaîne contenant uniquement des caractères alphanumériques, des espaces et des caractères de nouvelle ligne. De plus, toute séquence de deux espaces ou plus consé... | ["\nassert clean_text(\"Hello, World!\") == \"Hello World\"\n", "\nassert clean_text(\"This is a test!\") == \"This is a test\"\n", "\nassert clean_text(\"Multiple spaces\") == \"Multiple spaces\"\n", "\nassert clean_text(\"New\\nline\\ncharacters\") == \"New\\nline\\ncharacters\"\n", "\nassert clean_text(\" Leadin... |
709e02693232de14424210b21132ed69 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais et d'espaces. Ta tâche est de convertir cette chaîne en PascalCase. PascalCase est défini comme une chaîne où la première lettre de chaque mot est mise en majuscule et tous les mots sont concaténés sans e... | ["\nassert convert_to_pascal_case(\"hello world\") == \"HelloWorld\"\n", "\nassert convert_to_pascal_case(\"convert to pascal case\") == \"ConvertToPascalCase\"\n", "\nassert convert_to_pascal_case(\"python programming\") == \"PythonProgramming\"\n", "\nassert convert_to_pascal_case(\"openai gpt-4\") == \"OpenaiGpt4\"\... |
b32ef92e3c514d13bb4c30847a522a95 | [
{
"content": "On te donne un tableau `arr` de `n` entiers. Ta tâche est de trouver la plus longue sous-séquence croissante dans le tableau. Une sous-séquence croissante est définie comme une séquence où chaque élément est strictement supérieur au précédent. S'il existe plusieurs sous-séquences de longueur maxim... | ["\nassert find_longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) in ([2, 3, 7, 101], [2, 3, 7, 18])\n", "\nassert find_longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) in ([0, 1, 2, 3], [0, 1, 3, 3])\n", "\nassert find_longest_increasing_subsequence([7, 7, 7, 7, 7]) == [7]\n", "\nassert find_longest_incre... |
fef2a3770ea68dee4c461a8ab678e475 | [
{
"content": "On te donne une liste d'entiers positifs `numbers`. Ta tâche est de déterminer le plus petit entier positif `result` tel que `result` soit divisible par tous les entiers de la liste `numbers`. Tu n'es pas autorisé à utiliser des fonctions ou des bibliothèques intégrées qui calculent directement le... | ["\nassert smallest_divisible_number([1, 2, 3, 4, 5]) == 60\n", "\nassert smallest_divisible_number([7, 5, 3]) == 105\n", "\nassert smallest_divisible_number([2, 4, 6, 8]) == 24\n", "\nassert smallest_divisible_number([11, 22, 33]) == 66\n", "\nassert smallest_divisible_number([13, 17]) == 221\n", "\nassert smallest_di... |
78da65afec31cd2d0ff7b97fccf1cb80 | [
{
"content": "On te donne une liste d'entiers, qui peut inclure des nombres positifs et négatifs. Ta tâche est d'écrire une fonction qui calcule la différence maximale entre deux nombres quelconques dans la liste. Si la liste est vide, la fonction doit renvoyer 0.\n\n**Entrée :**\n- Une liste d'entiers, `number... | ["\nassert max_difference([3, 10, 6, 1, 8]) == 9\n", "\nassert max_difference([-10, -3, -5, -2, -8]) == 7\n", "\nassert max_difference([1, 1, 1, 1, 1]) == 0\n", "\nassert max_difference([100]) == 0\n", "\nassert max_difference([]) == 0\n", "\nassert max_difference([0, 0, 0, 0, 0]) == 0\n", "\nassert max_difference([5, ... |
cd159a807a152805646feca2e7fb607c | [
{
"content": "On te donne le contenu d'un fichier CSV sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction Python qui analyse ce contenu CSV et le convertit en un dictionnaire de listes. Chaque clé du dictionnaire doit être un en-tête de colonne du CSV, et la valeur correspondante doit être un... | ["\nassert csv_to_dict_of_lists(\"name,age\\nAlice,30\\nBob,25\") == {'name': ['Alice', 'Bob'], 'age': ['30', '25']}\n", "\nassert csv_to_dict_of_lists(\"header1,header2,header3\\nvalue1,value2,value3\") == {'header1': ['value1'], 'header2': ['value2'], 'header3': ['value3']}\n", "\nassert csv_to_dict_of_lists(\"a,b,c\... |
09702a9d00e878230daeac49164bd8ce | [
{
"content": "On te donne une liste d'entiers positifs `nums` et un entier `k`. Détermine s'il est possible de partitionner `nums` en `k` sous-ensembles non vides tels que la somme des éléments dans chaque sous-ensemble soit égale. Chaque entier dans `nums` doit appartenir à exactement un sous-ensemble.\n\n**En... | ["\nassert partition_k_subsets([4, 3, 2, 3, 5, 2, 1], 4, 5) == True\n", "\nassert partition_k_subsets([1, 2, 3, 4], 2, 5) == True\n", "\nassert partition_k_subsets([1, 2, 3, 4], 3, 3) == False\n", "\nassert partition_k_subsets([10, 10, 10, 10, 10, 10], 3, 20) == True\n", "\nassert partition_k_subsets([1, 1, 1, 1, 1, 1]... |
b79ffc772a03fd5a03ebc5388a16ee7c | [
{
"content": "On te demande d'implémenter une fonction qui analyse une URL donnée et en extrait les composants : schéma, netloc, chemin, paramètres, requête et fragment. Ta fonction doit gérer les URL valides et invalides avec élégance. Si l'URL est invalide, la fonction doit renvoyer `None`.\n\n**Entrée :**\n-... | ["\nassert parse_url(\"https://www.example.com/path/to/resource?key=value#section\") == {'scheme': 'https', 'netloc': 'www.example.com', 'path': '/path/to/resource', 'params': '', 'query': 'key=value', 'fragment': 'section'}\n", "\nassert parse_url(\"http://example.com\") == {'scheme': 'http', 'netloc': 'example.com', ... |
e7957f02b1db159a9fec83f089ee181a | [
{
"content": "On te donne un entier non négatif `n`, une base `base`, et un nombre de chiffres `numDigits`. Ta tâche est de convertir l'entier `n` en une représentation sous forme de chaîne dans la base spécifiée, en t'assurant que la chaîne de sortie a exactement `numDigits` caractères en ajoutant des zéros en... | ["\nassert decimalToCustomBase(0, 2, 1) == '-----'\n", "\nassert decimalToCustomBase(1, 2, 1) == '.----'\n", "\nassert decimalToCustomBase(2, 2, 2) == '-----..---'\n", "\nassert decimalToCustomBase(10, 2, 4) == '----.---'\n", "\nassert decimalToCustomBase(15, 16, 2) == '..-....-'\n", "\nassert decimalToCustomBase(255, ... |
a04e4d3952c84239d82b32cd75638d7a | [
{
"content": "On te donne une chaîne de caractères ne contenant que des lettres alphabétiques et des espaces. Ta tâche est d'écrire une fonction Python qui trie les mots de la chaîne par ordre alphabétique tout en préservant leur casse d'origine. La fonction doit renvoyer la chaîne modifiée.\n\n**Entrée :**\n- ... | ["\nassert sort_words_alphabetically(\"the quick brown fox jumps over the lazy dog\") == \"brown dog fox jumps lazy over quick the the\"\n", "\nassert sort_words_alphabetically(\"hello world\") == \"hello world\"\n", "\nassert sort_words_alphabetically(\"zebra apple banana\") == \"apple banana zebra\"\n", "\nassert sor... |
60b205fe410447ecf92b537d7f89b09a | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `find_duplicates(listinput)` qui identifie tous les entiers qui apparaissent plus d'une fois dans la liste. La fonction doit renvoyer une nouvelle liste contenant ces entiers sans doublons, en conservant leur ordre d'apparition in... | ["\nassert find_duplicates([1, 2, 3, 2, 4, 3, 5, 6, 5, 5]) == [2, 3, 5]\n", "\nassert find_duplicates([1, 1, 2, 2, 3, 3]) == [1, 2, 3]\n", "\nassert find_duplicates([1, 2, 3, 4, 5]) == []\n", "\nassert find_duplicates([5, 4, 3, 2, 1, 1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert find_duplicates([10, 20, 20, 10, 30, ... |
eb767ee404bd24f84e913051cb077d37 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de déterminer la plus petite base `b` supérieure à 2 telle que la représentation de `n` en base `b` soit un palindrome. Un palindrome est une séquence qui se lit de la même manière de gauche à droite et de droite à gauche.\n\nLa représentation de `n`... | ["\nassert smallest_palindrome_base(9) == 8\n", "\nassert smallest_palindrome_base(10) == 3\n", "\nassert smallest_palindrome_base(15) == 4\n", "\nassert smallest_palindrome_base(21) == 5\n", "\nassert smallest_palindrome_base(25) == 4\n", "\nassert smallest_palindrome_base(100) == 3\n", "\nassert smallest_palindrome_b... |
1d26c29e1b1e411c40461469a59c8770 | [
{
"content": "On te donne une liste de mots. Ton objectif est d'écrire une fonction Python qui renvoie une nouvelle liste avec tous les mots dupliqués supprimés, tout en conservant l'ordre d'origine des mots.\n\n**Entrée :**\n- Une liste de chaînes de caractères `words` (1 ≤ len(words) ≤ 10^5), où chaque chaîne... | ["\nassert remove_duplicates([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"grape\"]) == [\"apple\", \"banana\", \"orange\", \"grape\"]\n", "\nassert remove_duplicates([\"hello\", \"world\", \"hello\", \"python\", \"world\"]) == [\"hello\", \"world\", \"python\"]\n", "\nassert remove_duplicates([\"one\", ... |
09c532ec178b68ebc96dcb94bfeb635a | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente la vitesse d'un véhicule à un moment précis. Chaque tuple est formaté comme (vitesse, temps), la vitesse étant un nombre à virgule flottante et le temps un entier. Ta tâche est d'écrire une fonction qui interpole entre ces points de vites... | ["\nassert interpolate_speeds([(10.0, 5), (15.0, 10), (25.0, 15)]) == [(10, 5.0), (11, 5.2), (12, 5.4), (13, 5.6), (14, 5.8), (15, 10.0), (16, 10.4), (17, 10.8), (18, 11.2), (19, 11.6), (20, 12.0), (21, 12.4), (22, 12.8), (23, 13.2), (24, 13.6), (25, 15.0)]\n", "\nassert interpolate_speeds([(5.0, 1), (10.0, 2)]) == [(5... |
db8344562552f6eeb2423d1c8b8142d3 | [
{
"content": "On te donne une chaîne HTML contenant un seul tableau. Ta tâche est d'écrire une fonction Python `parse_html_table` qui extrait les données de ce tableau dans une liste 2D. Le tableau peut contenir plusieurs lignes et colonnes, y compris une ligne d'en-tête. La fonction doit renvoyer les données s... | ["\nassert parse_html_table(\"<table><tr><th>Header1</th><th>Header2</th></tr><tr><td>Data1</td><td>Data2</td></tr></table>\") == [['Header1', 'Header2'], ['Data1', 'Data2']]\n", "\nassert parse_html_table(\"<table><tr><td>SingleRow</td></tr></table>\") == [['SingleRow']]\n", "\nassert parse_html_table(\"<table><tr><th... |
f59fddf3ffddf083a776a8c4a5566b3b | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de trouver tous les triplets uniques dans le tableau qui s'additionnent à zéro. La solution ne doit pas inclure de triplets dupliqués.\n\n**Entrée :**\n- Une liste d'entiers `nums` où `1 <= len(nums) <= 3000` et `-10^5 <= nums[i] <= 10^5`.\n\n**Sortie... | ["\nassert three_sum([-1, 0, 1, 2, -1, -4]) == [[-1, -1, 2], [-1, 0, 1]]\n", "\nassert three_sum([0, 0, 0]) == [[0, 0, 0]]\n", "\nassert three_sum([1, 2, -2, -1]) == []\n", "\nassert three_sum([-2, 0, 1, 1, 2]) == [[-2, 0, 2], [-2, 1, 1]]\n", "\nassert three_sum([3, -2, 1, 0, -1, -2, 1]) == [[-2, -1, 3], [-2, 0, 2], [-... |
fdfd07586c0965259deebfe5987303dd | [
{
"content": "On te donne une liste de dictionnaires, chacun représentant un produit dans un magasin en ligne. Chaque dictionnaire contient les clés suivantes : 'name', 'price', 'category' et 'stock'. Ta tâche est de mettre en œuvre une fonction `filter_products` qui renvoie une nouvelle liste de produits qui s... | ["\nassert filter_products(products, 100) == [{'name': 'Headphones', 'price': 150, 'category': 'Electronics', 'stock': 5}, {'name': 'T-shirt', 'price': 20, 'category': 'Clothing', 'stock': 20}, {'name': 'Jeans', 'price': 50, 'category': 'Clothing', 'stock': 15}]\n", "\nassert filter_products(products, 150) == [{'name':... |
39f5b471e0f0004e3ef5a6df1dca9a85 | [
{
"content": "On te donne un fichier CSV nommé `books.csv` qui contient des informations sur des livres. Chaque ligne du fichier CSV représente un livre et possède les champs suivants : `title`, `author` et `publication_year`. Ta tâche est d'écrire un programme qui lit ce fichier CSV et renvoie une liste de dic... | ["\nassert load_books_from_csv('test_books.csv') == [{'title': 'Book One', 'author': 'Author A', 'publication_year': 2001}, {'title': 'Book Two', 'author': 'Author B', 'publication_year': 1998}]\n", "\nassert filter_books_by_year([{'title': 'Book One', 'author': 'Author A', 'publication_year': 2001}, {'title': 'Book Tw... |
4db315cab880e2233171c7f22f16d023 | [
{
"content": "On te demande d'implémenter une fonction `count_words_in_file(file_name)` qui lit un fichier texte et renvoie un dictionnaire contenant la fréquence de chaque mot unique. Un mot est défini comme une séquence de caractères alphabétiques consécutifs (sans tenir compte de la casse). Tu ne dois utilis... | ["\nassert count_words_in_file(\"test1.txt\") == {\"hello\": 1, \"world\": 1}\n", "\nassert count_words_in_file(\"test2.txt\") == {\"this\": 1, \"is\": 1, \"a\": 1, \"test\": 1, \"file\": 1}\n", "\nassert count_words_in_file(\"test3.txt\") == {\"repeated\": 2, \"word\": 1}\n", "\nassert count_words_in_file(\"test4.txt\... |
145546b4b1cd461f0fd34b9b3e038bc3 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui supporte les opérations basiques suivantes : dépôt, retrait et vérification du solde. Le solde ne doit jamais être autorisé à devenir négatif. Ton implémentation doit gérer les opérations invalides en levant une exception `ValueErr... | ["\nassert BankAccount(100).check_balance() == 100\n", "\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount(50).deposit(50).check_balance() == 100\n", "\nassert BankAccount(100).withdraw(50).check_balance() == 50\n", "\nassert BankAccount(100).deposit(100).withdraw(50).check_balance() == 150\n", "\nas... |
4b66d9f0121aa10c1cd49ee4cdba493a | [
{
"content": "On te donne deux listes, `actual_values` et `predicted_values`, contenant chacune des valeurs booléennes (True ou False). Ces listes représentent les résultats réels et prédits d'un problème de classification binaire, respectivement. Ta tâche est d'écrire une fonction `evaluate_classifier(actual_v... | ["\nassert evaluate_classifier([True, False, True, True], [True, False, False, True]) == (0.75, 0.6666666666666666, 1.0)\n", "\nassert evaluate_classifier([True, True, True], [False, False, False]) == None\n", "\nassert evaluate_classifier([False, False, False], [False, False, False]) == (1.0, None, None)\n", "\nassert... |
bf6ad4a7b4f75e37a420d87dc77da5a7 | [
{
"content": "On te donne la tâche de créer une fonction `generate_config_table` qui formate les paramètres de configuration en un tableau avec trois colonnes : 'Name' (Nom), 'Description' (Description) et 'Default value' (Valeur par défaut). La fonction doit accepter deux paramètres : un dictionnaire ou un Cha... | ["\nassert generate_config_table({'host': 'localhost'}, {'host': 'The server host'}) == \"| Name | Description | Default value |\\n|---------------|-------------------------|---------------|\\n| host | The server host | 'localhost' |\"\n", "\nassert generate_config_table({'port': 8... |
082c285536e210d0783a485fd1f0df2a | [
{
"content": "On te donne une liste d'entiers. Implémente la fonction `merge_sort` pour trier la liste par ordre croissant en utilisant l'algorithme de tri fusion. Ta fonction doit renvoyer une nouvelle liste triée. La liste d'entrée peut contenir des éléments dupliqués.\n\n**Entrée :**\n- Une liste d'entiers `... | ["\nassert merge_sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]\n", "\nassert merge_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert merge_sort([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert merge_sort([5, 5, 5, 5, 5,... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.