id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
af12f174240ab95b3ed029ab0ec6a46d | [
{
"content": "On te donne une liste imbriquée contenant des entiers et d'autres listes imbriquées. Ta tâche est d'écrire une fonction `flatten_list` qui prend cette liste imbriquée en entrée et renvoie une nouvelle liste avec tous les entiers triés par ordre croissant. La fonction doit gérer les listes imbriqué... | ["\nassert flatten_list([3, [1, 2, [4, 5]], [6, 7]]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert flatten_list([1, [2, [3, [4, [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten_list([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "\nassert flatten_list([1, [2, [3, 4], 5], 6, [7, 8]]) == [1, 2, 3, 4, 5, ... |
404b0b38b5ef2c5e95b02dc0c9a073a1 | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de trouver le produit maximal de tout sous-tableau contigu dans `nums`. La solution doit être efficace et s'exécuter en temps linéaire. Considère les cas limites tels que lorsque la liste d'entrée est vide ou ne contient qu'un seul élément.\n\n... | ["\nassert maxProduct([2, 3, -2, 4]) == 6\n", "\nassert maxProduct([-2, 0, -1]) == 0\n", "\nassert maxProduct([0, 2]) == 2\n", "\nassert maxProduct([-2, 3, -4]) == 24\n", "\nassert maxProduct([2, -5, -2, -4, 3]) == 24\n", "\nassert maxProduct([1]) == 1\n", "\nassert maxProduct([-1]) == -1\n", "\nassert maxProduct([]) =... |
4f0da1061c5f75a52efd4e1e1a276492 | [
{
"content": "On te donne une chaîne de caractères `sentence` composée de mots séparés par des espaces, qui peuvent inclure de la ponctuation. Ta tâche est de mettre en œuvre une fonction `count_words(sentence)` qui renvoie un dictionnaire avec chaque mot unique comme clé et sa fréquence comme valeur. Les mots ... | ["\nassert count_words(\"Hello, world! Hello, universe.\") == {'hello': 2, 'world': 1, 'universe': 1}\n", "\nassert count_words(\"Python is great. Python is fun!\") == {'python': 2, 'is': 2, 'great': 1, 'fun': 1}\n", "\nassert count_words(\"A quick brown fox jumps over the lazy dog.\") == {'a': 1, 'quick': 1, 'brown': ... |
267141e1b634b94fa6efee2f4876ed8b | [
{
"content": "On te donne une chaîne JSON valide `data`. Ta tâche est d'implémenter une fonction `decode_json(data)` qui analyse la chaîne JSON et renvoie l'objet Python correspondant. La chaîne JSON peut contenir des types de données de base tels que des chaînes de caractères, des nombres, des tableaux et des ... | ["\nassert decode_json('\"hello\"') == \"hello\"\n", "\nassert decode_json('123') == 123\n", "\nassert decode_json('123.456') == 123.456\n", "\nassert decode_json('true') == True\n", "\nassert decode_json('false') == False\n", "\nassert decode_json('null') == None\n", "\nassert decode_json('[\"apple\", \"banana\", \"ch... |
c1ee14024fa71f7ee87bd474ffba7252 | [
{
"content": "On te demande d'implémenter une fonction `intercept_output` qui agit comme un middleware dans une application WSGI. Cette fonction doit intercepter la sortie d'une application WSGI donnée, capturant le statut HTTP, les en-têtes, le corps et les cookies sans envoyer le corps au client. La fonction ... | ["\nassert intercept_output({}, lambda status, headers: None, lambda environ, start_response: [b\"Hello, World!\"]) == ('200 OK', [], b'Hello, World!', [])\n", "\nassert intercept_output({}, lambda status, headers: None, lambda environ, start_response: [b\"Hello\", b\", \", b\"World\", b\"!\"]) == ('200 OK', [], b'Hell... |
eeab1da8a4a9022566ca6484996fa2c9 | [
{
"content": "On te demande d'implémenter une fonction `calculate_total_cost` qui calcule le coût total d'un produit en fonction de son coût de base, du taux de taxe, des frais de port et des frais supplémentaires. La fonction doit prendre quatre paramètres :\n- `base_cost` : un flottant représentant le coût in... | ["\nassert calculate_total_cost(100, 0.08, 10) == 118.0\n", "\nassert calculate_total_cost(200, 0.10, 0) == 220.0\n", "\nassert calculate_total_cost(50, 0, 5) == 55.0\n", "\nassert calculate_total_cost(0, 0.05, 10) == 10.0\n", "\nassert calculate_total_cost(150, 0.07, 20, [('handling_fee', 5)]) == 180.5\n", "\nassert c... |
15f36fe36fa316ead2a732430ba1e659 | [
{
"content": "On te donne une liste de dataframes, où chaque dataframe représente une séquence d'événements. Chaque événement est représenté comme une ligne dans le dataframe, et les colonnes représentent différents attributs de l'événement. La longueur de chaque séquence (c'est-à-dire le nombre de lignes dans ... | ["\nassert len(split_and_filter_dataframes([pd.DataFrame({'timestamp': ['2023-01-01 00:00:00', '2023-01-01 00:01:00', '2023-01-01 00:02:00', '2023-01-01 00:03:00', '2023-01-01 00:04:00']})], 5, 300)) == 1\n", "\nassert len(split_and_filter_dataframes([pd.DataFrame({'timestamp': ['2023-01-01 00:00:00', '2023-01-01 00:01... |
fdbba06024b2ffe45bfa62b33dcca5a6 | [
{
"content": "On te donne une chaîne binaire qui contient un nombre en base 36 à 5 chiffres, où chaque chiffre est représenté par un nombre binaire à 6 bits. La chaîne binaire est entrelacée avec d'autres données, et le nombre en base 36 est marqué par des marqueurs de séquence spécifiques. La séquence \"100000... | ["\nassert binary_to_base36_decimal(\"000000100000101001010010100101001010111111\") == 2649365\n", "\nassert binary_to_base36_decimal(\"000000000000000000000000000000000000111111\") == 0\n", "\nassert binary_to_base36_decimal(\"000000111111111111111111111111111111111111\") == 60466175\n", "\nassert binary_to_base36_dec... |
44df2b4f48bc42cff24510ffa8602525 | [
{
"content": "On te donne une liste d'entiers représentant un flux de nombres. Ta tâche est de mettre en œuvre une fonction qui identifie les deux plus grands nombres uniques de la liste et renvoie leur somme. S'il y a moins de deux nombres uniques, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste... | ["\nassert sum_of_two_largest_unique_numbers([10, 20, 30, 40, 40, 50]) == 80\n", "\nassert sum_of_two_largest_unique_numbers([1, 2, 3, 4, 5]) == 9\n", "\nassert sum_of_two_largest_unique_numbers([5, 5, 5, 5, 5]) == None\n", "\nassert sum_of_two_largest_unique_numbers([100]) == None\n", "\nassert sum_of_two_largest_uniq... |
b5608c7e2176e6404cce86f5005bc667 | [
{
"content": "On te donne une chaîne JSON représentant une configuration. Ta tâche est d'écrire une fonction Python `parse_config(config: str) -> Dict[str, Union[str, int, float, bool]]` qui analyse la chaîne JSON et renvoie un dictionnaire avec les valeurs analysées. Si la chaîne JSON est invalide, ta fonction... | ["\nassert parse_config('{\"name\": \"Server\", \"port\": 8080, \"enabled\": true, \"version\": 1.0}') == {\"name\": \"Server\", \"port\": 8080, \"enabled\": True, \"version\": 1.0}\n", "\nassert parse_config('{\"key\": \"value\"}') == {\"key\": \"value\"}\n", "\nassert parse_config('{\"number\": 42}') == {\"number\": ... |
c577d251fc5bc3a7ddcb24f36b4f8ada | [
{
"content": "Tu es chargé d'implémenter une fonction pour simuler une machine à sous simple. La machine à sous se compose de trois rouleaux, chacun contenant les symboles : 'cherry', 'lemon', 'orange' et 'apple'. Ta fonction doit sélectionner aléatoirement un symbole de chaque rouleau et renvoyer le résultat s... | ["\nassert isinstance(simulate_slot_machine(), tuple)\n", "\nassert len(simulate_slot_machine()) == 3\n", "\nassert all(symbol in ['cherry', 'lemon', 'orange', 'apple'] for symbol in simulate_slot_machine())\n", "\nassert simulate_slot_machine() != simulate_slot_machine() # Due to randomness, this might fail sometimes... |
8d3d0205108152d8002e436e5c864dff | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots séparés par des espaces. Ta tâche est d'écrire une fonction `word_frequency` qui renvoie un dictionnaire avec chaque mot unique comme clé et sa fréquence comme valeur. La fonction doit être insensible à la casse et doit ignorer la ponctu... | ["\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, 'jumps': 1, 'over... |
e44c1ab4bb5724532b1aa313bf509c71 | [
{
"content": "On te donne un fichier CSV nommé `employees.csv` contenant des données sur les employés. Ta tâche est d'écrire un programme qui lit ce fichier et affiche le nom et le département de chaque employé dont le salaire dépasse 50 000 $. Le fichier CSV a les colonnes suivantes : `name`, `position`, `sala... | ["\nassert read_and_filter_employees() is None # Assuming the function prints and does not return anything\n", "\nassert read_and_filter_employees() is None # Test with no employees earning more than 50,000\n", "\nassert read_and_filter_employees() is None # Test with all employees earning more than 50,000\n", "\nas... |
e4b7cb6a55059cf3268252207c76716a | [
{
"content": "On te donne une liste d'éléments. Ta tâche est d'implémenter une fonction `calculate_average` qui calcule la moyenne de toutes les valeurs numériques dans la liste. La fonction doit renvoyer `0.0` si la liste est vide ou s'il n'y a pas de valeurs numériques dans la liste. Les valeurs numériques so... | ["\nassert calculate_average([10, 20, 30, 40]) == 25.0\n", "\nassert calculate_average([]) == 0.0\n", "\nassert calculate_average(['a', 'b', 'c']) == 0.0\n", "\nassert calculate_average([1, 'a', 2, 'b', 3]) == 2.0\n", "\nassert calculate_average([5.5, 6.5, 7.5]) == 6.5\n", "\nassert calculate_average([100, 200, 300, 40... |
7bdc9978b4f4985727a9fe3b4326a4c7 | [
{
"content": "On te donne une température en Fahrenheit. Ta tâche est d'écrire une fonction qui convertit cette température en Celsius et renvoie le résultat arrondi à deux décimales.\n\n**Entrée :**\n- Un seul nombre à virgule flottante représentant la température en Fahrenheit.\n\n**Sortie :**\n- Un seul nomb... | ["\nassert fahrenheit_to_celsius(32) == 0.0\n", "\nassert fahrenheit_to_celsius(212) == 100.0\n", "\nassert fahrenheit_to_celsius(98.6) == 37.0\n", "\nassert fahrenheit_to_celsius(-40) == -40.0\n", "\nassert fahrenheit_to_celsius(0) == -17.78\n", "\nassert fahrenheit_to_celsius(100) == 37.78\n", "\nassert fahrenheit_to... |
745260f7c9a5d1f13bbd1a68b2ec82d9 | [
{
"content": "On te donne un arbre binaire où chaque nœud a une valeur et des pointeurs vers ses enfants gauche et droit. Ta tâche est de convertir cet arbre binaire en une liste doublement chaînée sur place. Les pointeurs gauche et droit des nœuds de l'arbre doivent être utilisés comme les pointeurs précédent ... | ["\nassert tree_to_doubly_linked_list(None) is None\n", "\nhead = tree_to_doubly_linked_list(TreeNode(1))\nassert head.value == 1 and head.left is None and head.right is None\n", "\nroot = TreeNode(2, TreeNode(1), TreeNode(3))\nhead = tree_to_doubly_linked_list(root)\nassert head.value == 1 and head.right.value == 2 an... |
296e05fb77d1a0163a389268243c2b4b | [
{
"content": "On te demande d'écrire une fonction `get_book_info(count: bool, randomize: bool) -> str` pour un système de gestion de bibliothèque. Le système dispose d'une table de base de données nommée `books` avec les colonnes suivantes : `id_book`, `title`, `author`, `publication_year` et `publisher`. Ta fo... | ["\nassert get_book_info(True, False) == \"SELECT COUNT(*) FROM books;\"\n", "\nassert get_book_info(False, True) == \"SELECT id_book FROM books ORDER BY RANDOM() LIMIT 10;\"\n", "\nassert get_book_info(False, False) == \"SELECT id_book FROM books;\"\n", "\nassert get_book_info(True, True) == \"SELECT COUNT(*) FROM boo... |
76ce1d31b15a924d361b4c1255fb737b | [
{
"content": "On te donne une chaîne de caractères `s`. Implémente une fonction `is_palindrome(s)` qui détermine si la chaîne est un palindrome. Une chaîne est un palindrome si elle se lit de la même manière à l'endroit et à l'envers, en ignorant la casse et les caractères non alphanumériques. Ta fonction doit ... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\n", "\nassert is_palindrome(\" \") == True\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(... |
accb35a996caa403dd98f680c2576037 | [
{
"content": "On te demande d'implémenter une version récursive de l'algorithme de tri fusion en Python. Ta fonction doit accepter une liste d'entiers et renvoyer une nouvelle liste triée par ordre croissant. La fonction doit correctement gérer les cas limites tels que les listes vides et les listes contenant u... | ["\nassert merge_sort([3, 1, 2]) == [1, 2, 3]\n", "\nassert merge_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([]) == []\n", "\nassert merge_sort([1]) == [1]\n", "\nassert merge_sort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0]) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "\nassert merge_sort([10, 9, 8, 7, 6, 5, 4, 3,... |
0a879c986667c302e9fc6e1aef97c894 | [
{
"content": "On te donne une liste de chaînes de caractères non vides. Ta tâche est de déterminer le plus long préfixe commun à toutes les chaînes de caractères de la liste. S'il n'y a pas de préfixe commun, renvoie une chaîne vide.\n\n**Entrée :**\n- Une liste de chaînes de caractères `strs` (1 ≤ len(strs) ≤ ... | ["\nassert longest_common_prefix([\"flower\", \"flow\", \"flight\"]) == \"fl\"\n", "\nassert longest_common_prefix([\"dog\", \"racecar\", \"car\"]) == \"\"\n", "\nassert longest_common_prefix([\"interspecies\", \"interstellar\", \"interstate\"]) == \"inters\"\n", "\nassert longest_common_prefix([\"throne\", \"throne\"]... |
f97e1e0f928006523520bcf0af436ce9 | [
{
"content": "On te donne un entier `num` qui représente un nombre en base-7. Ta tâche est de convertir chaque chiffre de `num` de la base-7 à la base-10, de cuber les valeurs résultantes et de renvoyer la somme de ces cubes.\n\n**Entrée :**\n- Un entier `num` (0 ≤ num ≤ 10^9) représentant un nombre en base-7.\... | ["\nassert sum_of_cubes(0) == 0\n", "\nassert sum_of_cubes(1) == 1\n", "\nassert sum_of_cubes(6) == 216\n", "\nassert sum_of_cubes(12) == 1 + 8 # 1^3 + 2^3 in base-7\n", "\nassert sum_of_cubes(16) == 1 + 216 # 1^3 + 6^3 in base-7\n", "\nassert sum_of_cubes(20) == 8 # 2^3 in base-7\n", "\nassert sum_of_cubes(33) == 2... |
d2bb865ae1c45999b7960f467ebaae02 | [
{
"content": "On te donne une chaîne de caractères `log` représentant le contenu d'un fichier journal. Ta tâche est de mettre en œuvre une fonction `detect_log_issues` qui détermine si le fichier journal contient des problèmes. Le fichier journal est considéré comme ayant des problèmes s'il contient l'un des mo... | ["\nassert detect_log_issues(\"--- Debugging Mode ---\\nCritical Failure\") == False\n", "\nassert detect_log_issues(\"Critical Failure\") == True\n", "\nassert detect_log_issues(\"System Fault\") == True\n", "\nassert detect_log_issues(\"Runtime Exception\") == True\n", "\nassert detect_log_issues(\"inaccessible\") ==... |
270649fd66644321a0b2490839fa367e | [
{
"content": "On te demande d'implémenter une fonction pour un jeu basé sur une grille. L'environnement du jeu est représenté par une grille 2D où chaque cellule est soit passable (0) soit un obstacle (1). Étant donné une position de départ et un nombre maximal de mouvements, détermine toutes les positions atte... | ["\nassert find_reachable_positions([[0, 0, 0], [0, 1, 0], [0, 0, 0]], (0, 0), 1) == {(0, 0), (0, 1), (1, 0)}\n", "\nassert find_reachable_positions([[0, 0, 0], [0, 1, 0], [0, 0, 0]], (0, 0), 2) == {(0, 0), (0, 1), (1, 0), (0, 2), (2, 0)}\n", "\nassert find_reachable_positions([[0, 0, 0], [0, 1, 0], [0, 0, 0]], (1, 1),... |
35f053167f9678e46daa67eae267690b | [
{
"content": "On te donne deux listes d'entiers, `values` et `weights`, toutes deux de la même longueur. Ta tâche est de calculer la moyenne pondérée des valeurs absolues des entiers dans `values`, où chaque entier est pondéré par sa valeur correspondante dans `weights`. La moyenne pondérée est définie comme la... | ["\nassert weighted_average([10, -10, 12, 12], [1, 2, 3, 4]) == 10.5\n", "\nassert weighted_average([1, 2, 3, 4], [1, 1, 1, 1]) == 2.5\n", "\nassert weighted_average([0, 0, 0, 0], [1, 1, 1, 1]) == 0\n", "\nassert weighted_average([1, -1, 1, -1], [1, 1, 1, 1]) == 1\n", "\nassert weighted_average([100, 200, 300], [1, 2, ... |
ae3f2a337bee96c0401df494e4a7f5f9 | [
{
"content": "On te donne une liste d'entiers `my_list`, une fonction de condition `condition(x)`, et un entier `replace`. Ta tâche est d'implémenter une fonction `filter_and_replace` qui construit et renvoie une nouvelle liste où chaque élément qui satisfait la condition spécifiée par `condition(x)` est rempla... | ["\nassert filter_and_replace([1, 2, 3, 4, 5], lambda x: x % 2 == 0, 0) == [1, 0, 3, 0, 5]\n", "\nassert filter_and_replace([10, 20, 30, 40, 50], lambda x: x > 25, 99) == [10, 20, 99, 99, 99]\n", "\nassert filter_and_replace([7, 8, 9, 10, 11], lambda x: x < 8, 1) == [1, 8, 9, 10, 11]\n", "\nassert filter_and_replace([5... |
fc2f8728a6ecbbdd897258b3b2053053 | [
{
"content": "On te donne une grille 3x3 où chaque cellule est identifiée par ses coordonnées (x, y). La grille est un tore avec une règle d'enroulement asymétrique. Si la coordonnée x dépasse 2, soustrais 2 et ajoute 1 à la coordonnée y. Si la coordonnée x est inférieure à 0, ajoute 2 et soustrais 1 à la coord... | ["\nassert wrap_coordinates([3, 0]) == [1, 1]\n", "\nassert wrap_coordinates([-1, -1]) == [1, 1]\n", "\nassert wrap_coordinates([0, 3]) == [1, 0]\n", "\nassert wrap_coordinates([2, -1]) == [1, 2]\n", "\nassert wrap_coordinates([0, 0]) == [0, 0]\n", "\nassert wrap_coordinates([1, 1]) == [1, 1]\n", "\nassert wrap_coordin... |
5458f50e7434c4a7ef723739cbeb4482 | [
{
"content": "On te donne deux listes d'entiers, `country1` et `country2`, représentant les années des œuvres d'art de deux pays différents. Implémente la fonction `compare_artwork_countries(country1, country2)` qui renvoie `True` si la somme des chiffres des années des œuvres d'art de `country1` qui sont divis... | ["\nassert compare_artwork_countries([1991, 1998, 2005], [2010, 2017, 2024]) == True\n", "\nassert compare_artwork_countries([1991, 1998, 2005], [1998, 2005, 2012]) == False\n", "\nassert compare_artwork_countries([2005, 2012, 2019], [2026, 2033, 2040]) == True\n", "\nassert compare_artwork_countries([2005, 2012, 2019]... |
f1500dcd0cd7c2c37d915589f2b0fa58 | [
{
"content": "On te donne deux listes triées d'entiers, `xs` et `ys`. Ta tâche est de fusionner ces deux listes en une seule liste triée. Tu n'es autorisé à utiliser qu'une seule liste supplémentaire, `result`, pour stocker les éléments fusionnés. Pour rendre le problème plus difficile, tu ne peux pas utiliser ... | ["\nassert merge_sorted_lists([1, 3, 5], [2, 4, 6]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_sorted_lists([], [1, 2, 3]) == [1, 2, 3]\n", "\nassert merge_sorted_lists([1, 2, 3], []) == [1, 2, 3]\n", "\nassert merge_sorted_lists([], []) == []\n", "\nassert merge_sorted_lists([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]) == [1, 2,... |
2364c1044dd0c255b57f202a3497865f | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tableau NumPy 2D `image` de dimensions `rows x cols`, où chaque élément est un entier compris entre 0 et 255 inclusivement. Ta tâche est d'appliquer une fenêtre de Hamming 2D à cette image, puis d'ajuster les valeurs de sorte que la som... | ["\nassert np.array_equal(apply_normalized_hamming_window(np.zeros((5, 5), dtype=np.uint8)), np.zeros((5, 5), dtype=np.uint8))\n", "\nassert np.array_equal(apply_normalized_hamming_window(np.ones((5, 5), dtype=np.uint8)), np.hamming(5)[:, np.newaxis] * np.hamming(5)[np.newaxis, :] * (25 / np.sum(np.hamming(5)[:, np.new... |
80299eff52d7915332d2fd480c18af47 | [
{
"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 `target`. S'il y a plusieurs entiers avec la même distance minimale à `target`, renv... | ["\nassert find_closest_number([1, 2, 3, 4, 5], 3) == 3\n", "\nassert find_closest_number([10, 22, 28, 29, 30, 40], 27) in [28, 29]\n", "\nassert find_closest_number([5, 10, 15, 20, 25], 12) == 10\n", "\nassert find_closest_number([5, 10, 15, 20, 25], 18) == 20\n", "\nassert find_closest_number([], 10) == None\n", "\na... |
82cefc02597a79e8c88d80dd57601649 | [
{
"content": "Implémente une classe Python `Student` avec les spécifications suivantes :\n\n- **Attributs :**\n - `name` : une chaîne de caractères représentant le nom de l'étudiant.\n - `student_id` : une chaîne de caractères représentant l'identifiant de l'étudiant.\n - `major` : une chaîne de caractères r... | ["\nassert Student(\"Alice\", \"S12345\", \"Computer Science\", 3.5).gpa == 3.5\n", "\nassert Student(\"Bob\", \"S67890\", \"Mathematics\", 4.0).gpa == 4.0\n", "\nassert Student(\"Charlie\", \"S11223\", \"Physics\", 0.0).gpa == 0.0\n", "\nassert Student(\"David\", \"S44556\", \"Chemistry\", 2.75).gpa == 2.75\n", "\ntry... |
acd2609fa585eff87be9663a83bb7d71 | [
{
"content": "On te demande de traiter un grand fichier CSV nommé \"employees.csv\" contenant des données sur les employés d'une entreprise. Le fichier CSV comprend les colonnes suivantes : \"ID\", \"First Name\", \"Last Name\", \"Position\", \"Department\" et \"Salary\". Ton objectif est de calculer le salaire... | ["\nassert get_department_salary_sum(\"employees.csv\") == {'HR': 150000, 'Engineering': 300000, 'Marketing': 200000}\n", "\nassert get_department_salary_sum(\"employees.csv\") == {'Finance': 120000, 'IT': 250000}\n", "\nassert get_department_salary_sum(\"employees.csv\") == {'Sales': 180000, 'Support': 90000}\n", "\na... |
de42668bcd2adc8b3f835eac02275662 | [
{
"content": "Tu participes à une compétition de science des données où tu dois prétraiter un ensemble de données. L'une des tâches consiste à convertir une liste d'étiquettes catégorielles en étiquettes entières. Étant donné une liste `y` d'étiquettes catégorielles (chaînes de caractères), écris une fonction `... | ["\nassert convert_labels_to_integers([\"cat\", \"dog\", \"cat\"]) == [0, 1, 0]\n", "\nassert convert_labels_to_integers([\"apple\", \"banana\", \"cherry\", \"apple\"]) == [0, 1, 2, 0]\n", "\nassert convert_labels_to_integers([\"a\", \"b\", \"c\", \"d\", \"e\"]) == [0, 1, 2, 3, 4]\n", "\nassert convert_labels_to_intege... |
f524938191bfcebacfeed16ae903b657 | [
{
"content": "On te donne pour tâche d'implémenter une fonction `calculate_seconds_from_hours` qui calcule le nombre total de secondes dans un nombre d'heures spécifié. La fonction ne doit renvoyer un résultat valide que si le nombre d'heures est compris entre 1 heure et 10 années juliennes (incluses). L'année ... | ["\nassert calculate_seconds_from_hours(1) == 3600\n", "\nassert calculate_seconds_from_hours(24) == 86400\n", "\nassert calculate_seconds_from_hours(87660) == 315570000\n", "\nassert calculate_seconds_from_hours(87659) == 315534000\n", "\nassert calculate_seconds_from_hours(0) == \"Invalid input: Hours must be between... |
23e2b3596549575f4ee6e1e2dc887225 | [
{
"content": "On te donne une chaîne de caractères `s` représentant une expression logique composée de variables d'un seul caractère (`a` à `z`) et des opérateurs `IMPLIES`, `NAND`, `NOR`, `EQUIVALENT` et `XOR`. L'expression est bien formée, entre parenthèses, et chaque variable ou sous-expression est séparée p... | ["\nassert parse_expression(\"((a IMPLIES b) NAND (c))\") == ('NAND', ('IMPLIES', 'a', 'b'), 'c')\n", "\nassert parse_expression(\"((d EQUIVALENT e) XOR (f))\") == ('XOR', ('EQUIVALENT', 'd', 'e'), 'f')\n", "\nassert parse_expression(\"((a NAND b) NOR (c XOR d))\") == ('NOR', ('NAND', 'a', 'b'), ('XOR', 'c', 'd'))\n", ... |
c31051f1d5d3cdaadb75a9cf20a5c9b6 | [
{
"content": "On te donne deux matrices `A` et `B` représentées comme des listes 2D. Ta tâche est de calculer le produit de ces matrices et de retourner la somme de tous les éléments de la matrice résultante. Chaque élément de la matrice résultante doit être arrondi à l'entier le plus proche avant d'être additi... | ["\nassert matrix_product_sum([[1, 2], [3, 4]], [[2, 0], [1, 2]]) == 16\n", "\nassert matrix_product_sum([[1, 2, 3]], [[4], [5], [6]]) == 32\n", "\nassert matrix_product_sum([[1]], [[2]]) == 2\n", "\nassert matrix_product_sum([], [[1, 2], [3, 4]]) == 0\n", "\nassert matrix_product_sum([[1, 2], [3, 4]], []) == 0\n", "\n... |
a77047c5acc0d424cf2d77c3060fbf70 | [
{
"content": "On te donne une liste de tuples représentant des produits dans un magasin, où chaque tuple est composé d'un nom de produit (une chaîne de caractères) et de son prix (un nombre à virgule flottante). Ton objectif est d'écrire une fonction qui renvoie un dictionnaire avec les noms des produits comme ... | ["\nassert sort_products_by_price([(\"apple\", 0.5), (\"banana\", 0.3), (\"cherry\", 0.7)]) == {\"banana\": 0.3, \"apple\": 0.5, \"cherry\": 0.7}\n", "\nassert sort_products_by_price([(\"orange\", 1.2), (\"grape\", 1.0), (\"pear\", 1.5)]) == {\"grape\": 1.0, \"orange\": 1.2, \"pear\": 1.5}\n", "\nassert sort_products_b... |
d11d878d4c7c58017e5bbf0cb63332cd | [
{
"content": "On te donne un ensemble de données de nuage de points 3D composé de points prédits et réels. Chaque point est représenté par ses coordonnées (x, y, z). De plus, tu as une liste d'arêtes, où chaque arête est définie par une paire d'indices de points, indiquant que ces deux points sont connectés.\n\... | ["\nassert calculate_mae(torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0]]), torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0]]), torch.tensor([[0, 1], [1, 2], [2, 0]])) == 0\n", "\nassert calculate_mae(torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0]]), torch.tensor([[0, 0, 0], [1, 1, 0], [0, 1, 0]]), torch.tensor([[0, 1], [1, ... |
53e3c68cac1195c1a120d8c045a2a3ac | [
{
"content": "On te donne une chaîne de caractères `input_str` et un délimiteur `delim`. Ta tâche est d'implémenter une fonction `process_string` qui remplace toutes les occurrences de `delim` dans `input_str` par un espace, mais seulement si `delim` n'est pas entouré de caractères alphanumériques. Les caractèr... | ["\nassert process_string(\"Hello$World$!$How$are$you$?\", \"$\") == \"Hello World! How are you?\"\n", "\nassert process_string(\"Hello$World$!$How$are$you$?\", \"o\") == \"Hell o World! How are you?\"\n", "\nassert process_string(\"Hello-World-!-How-are-you-?\", \"-\") == \"Hello World! How are you?\"\n", "\nassert pr... |
8788e01363351c64bb138f752cfb06ff | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui supprime toutes les voyelles de la chaîne et renvoie la chaîne modifiée. La fonction doit être insensible à la casse, ce qui signifie qu'elle doit supprimer les voyelles majuscules et minuscules.\n\n**Entrée :**\n- Un... | ["\nassert remove_vowels(\"Hello, World!\") == \"Hll, Wrld!\"\n", "\nassert remove_vowels(\"Python Programming\") == \"Pythn Prgrmmng\"\n", "\nassert remove_vowels(\"AEIOUaeiou\") == \"\"\n", "\nassert remove_vowels(\"abcdefghijklmnopqrstuvwxyz\") == \"bcdfghjklmnpqrstvwxyz\"\n", "\nassert remove_vowels(\"BCDFGHJKLMNPQ... |
5cd475e53af516074a4d3b33ff6e6ad1 | [
{
"content": "On te donne une liste de dictionnaires, où chaque dictionnaire contient les clés suivantes : `name`, `age`, `grades` et `activities`. Chaque dictionnaire représente les informations d'un étudiant. Ta tâche est de mettre en œuvre une fonction `convert_to_student_objects` qui prend cette liste en en... | ["\nassert convert_to_student_objects([{'name': 'Alice', 'age': 20, 'grades': [88, 92, 85], 'activities': ['Basketball', 'Debate Club']}])[0].name == 'Alice'\n", "\nassert convert_to_student_objects([{'name': 'Bob', 'age': 22, 'grades': [75, 80, 78], 'activities': ['Football', 'Chess Club']}])[0].age == 22\n", "\nasser... |
84931bde3788c1da34490243a6b683c1 | [
{
"content": "On te donne un tableau d'entiers. Implémente une fonction `sort_array` qui trie le tableau par ordre croissant et renvoie le nombre d'éléments dans le tableau trié. Ta fonction doit modifier le tableau sur place.\n\n**Entrée :**\n- Un tableau d'entiers `arr` (1 ≤ len(arr) ≤ 10^5)\n- Chaque élément... | ["\nassert sort_array([3, 1, 2]) == 3\n", "\nassert sort_array([5, 4, 3, 2, 1]) == 5\n", "\nassert sort_array([1, 2, 3, 4, 5]) == 5\n", "\nassert sort_array([]) == 0\n", "\nassert sort_array([10]) == 1\n", "\nassert sort_array([7, 7, 7, 7]) == 4\n", "\nassert sort_array([-1, -2, -3, -4]) == 4\n", "\nassert sort_array([... |
31805688b5a1c26be38ae4e96a0891ea | [
{
"content": "On te donne une liste de notes de musique représentées sous forme de chaînes de caractères. Chaque chaîne de caractères est composée d'un nom de note suivi de sa durée. Les noms de notes sont représentés par les sept premières lettres de l'alphabet (A, B, C, D, E, F, G), et la durée est représenté... | ["\nassert consolidate_notes(['A1', 'A2', 'B3', 'B4', 'A5', 'A6']) == ['A3', 'B7', 'A9', 'A2']\n", "\nassert consolidate_notes(['A1', 'A9', 'A5']) == ['A9', 'A5']\n", "\nassert consolidate_notes(['A9', 'A9', 'A9']) == ['A9', 'A9', 'A9']\n", "\nassert consolidate_notes(['A1', 'B2', 'C3', 'D4', 'E5']) == ['A1', 'B2', 'C3... |
57d5746d3caeb2ba78a3d4fa7ab901be | [
{
"content": "On te donne une séquence d'entiers `seq` contenant jusqu'à 1 000 000 d'éléments. Ta tâche est de calculer séparément la somme des éléments situés aux indices pairs et la somme des éléments situés aux indices impairs. Renvoie ces deux sommes sous forme de tuple.\n\n**Entrée :**\n- Une liste d'entie... | ["\nassert alternate_sum([1, 2, 3, 4, 5]) == (9, 6)\n", "\nassert alternate_sum([10, 20, 30, 40, 50, 60]) == (90, 120)\n", "\nassert alternate_sum([0, 0, 0, 0, 0, 0]) == (0, 0)\n", "\nassert alternate_sum([1]) == (1, 0)\n", "\nassert alternate_sum([]) == (0, 0)\n", "\nassert alternate_sum([-1, -2, -3, -4, -5]) == (-9, ... |
2582203bfa0f02de89f86295886f35e7 | [
{
"content": "On te donne une chaîne de caractères `resource_name` représentant une ressource dans un système informatique distribué. La convention de nommage pour `resource_name` est `<group>_<label><version>_<number>`, où `<group>` et `<label>` sont des chaînes de caractères alphanumériques, `<version>` est u... | ["\nassert extract_identifier(\"group1\", \"label1\", \"group1_label1_123\") == 123\n", "\nassert extract_identifier(\"group1\", \"label1\", \"group1_label1v1_123\") == 123\n", "\nassert extract_identifier(\"group1\", \"label1\", \"group1_label1v1a_123\") == 0\n", "\nassert extract_identifier(\"group1\", \"label1\", \"... |
60f636202c0b83d270c6b95cc1bee387 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `filter_odd_numbers` qui traite cette liste et renvoie une nouvelle liste contenant uniquement les nombres impairs uniques de la liste originale. L'ordre des éléments dans la liste résultante n'a pas d'importance.\n\n**Entrée... | ["\nassert filter_odd_numbers([1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9, 10, 11]) == [1, 3, 5, 7, 9, 11]\n", "\nassert filter_odd_numbers([2, 4, 6, 8, 10]) == []\n", "\nassert filter_odd_numbers([1, 3, 5, 7, 9]) == [1, 3, 5, 7, 9]\n", "\nassert filter_odd_numbers([11, 11, 11, 11, 11]) == [11]\n", "\nassert filter_odd_numbers([]... |
2cc9b1813753cfc6b98a8647bbb0d00a | [
{
"content": "On te demande d'implémenter une fonction `log_error_location` qui aide au débogage en enregistrant l'emplacement des erreurs dans un programme. La fonction doit accepter trois paramètres : `file_name` (une chaîne de caractères représentant le nom du fichier), `line_number` (un entier représentant ... | ["\nassert log_error_location(\"example.py\", 42, True) == \"Error occurred in example.py at line 42: An unexpected error has been encountered.\"\n", "\nassert log_error_location(\"example.py\", 42, False) == \"Error in example.py:42.\"\n", "\nassert log_error_location(\"main.py\", 1, True) == \"Error occurred in main.... |
b8cc5499b8817198f0120a130721e86d | [
{
"content": "On te donne un fichier binaire contenant une séquence d'octets. Ta tâche est d'écrire une fonction Python qui lit ce fichier et calcule la fréquence de chaque valeur d'octet de 0 à 255. La fonction doit afficher la fréquence de chaque octet par ordre croissant de la valeur de l'octet.\n\n**Entrée ... | ["\nassert calculate_byte_frequencies('empty_file.bin') == None\n", "\nassert calculate_byte_frequencies('single_byte_file.bin') == None\n", "\nassert calculate_byte_frequencies('all_zeros.bin') == None\n", "\nassert calculate_byte_frequencies('all_ones.bin') == None\n", "\nassert calculate_byte_frequencies('sequential... |
1889464b81082a938213ff7c1af15857 | [
{
"content": "On te donne une liste d'articles de blog, où chaque article de blog est représenté comme un dictionnaire avec les clés suivantes : 'title', 'content' et 'tags'. La clé 'tags' contient une liste de chaînes de caractères, chaque chaîne étant un tag associé à l'article de blog. Ta tâche est d'écrire ... | ["\nassert get_unique_tags([{'title': 'Post1', 'content': 'Content1', 'tags': ['tag1', 'tag2']}]) == 'tag1 tag2'\n", "\nassert get_unique_tags([{'title': 'Post1', 'content': 'Content1', 'tags': ['tag1', 'tag1']}]) == 'tag1'\n", "\nassert get_unique_tags([{'title': 'Post1', 'content': 'Content1', 'tags': ['tag1', '']}])... |
b5807433da36fc670e0b8c7ff772560c | [
{
"content": "On te donne un hypergraphe `H` représenté comme un dictionnaire où chaque clé est un identifiant de nœud et chaque valeur est un autre dictionnaire contenant les attributs du nœud. Chaque nœud peut avoir plusieurs attributs tels que `color`, `name`, `age`, etc. Ta tâche est d'implémenter une fonct... | ["\nassert get_node_attributes({}, [1, 2, 3], 'color', 'Unknown') == ({1: 'Unknown', 2: 'Unknown', 3: 'Unknown'}, [1, 2, 3])\n", "\nassert get_node_attributes({1: {'color': 'red'}, 2: {'color': 'blue'}}, [1, 2], 'color') == ({1: 'red', 2: 'blue'}, [])\n", "\nassert get_node_attributes({1: {'color': 'red'}, 2: {'color':... |
87c90e67ded19c7c9c06da9281075fa7 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `calculate_statistics(numbers)` qui calcule et renvoie un dictionnaire contenant la moyenne, la médiane, le mode et l'écart type de la liste. Si la liste est vide, renvoie `None` pour chaque statistique. Si tous les nombres d... | ["\nassert calculate_statistics([1, 2, 2, 3, 4]) == {'mean': 2.4, 'median': 2, 'mode': 2, 'std_dev': 1.0954451150103321}\n", "\nassert calculate_statistics([5, 5, 5, 5]) == {'mean': 5, 'median': 5, 'mode': 5, 'std_dev': 0}\n", "\nassert calculate_statistics([10]) == {'mean': 10, 'median': 10, 'mode': 10, 'std_dev': 0}\... |
9782799a909460a9554cd3d415431b4c | [
{
"content": "Dans le domaine de la cryptographie, les corps de Galois (GF) sont essentiels pour la détection et la correction d'erreurs. Une de ces opérations est la multiplication dans GF(2^8). Ta tâche est de mettre en œuvre une fonction qui effectue cette opération.\n\n**Énoncé du problème :**\nÉcris une fo... | ["\nassert gf_mult(0x02, 0x03) == 0x06\n", "\nassert gf_mult(0x03, 0x03) == 0x05\n", "\nassert gf_mult(0x05, 0x09) == 0x28\n", "\nassert gf_mult(0x0F, 0x0F) == 0xF1\n", "\nassert gf_mult(0x1B, 0x1B) == 0x0E\n", "\nassert gf_mult(0x00, 0xFF) == 0x00\n", "\nassert gf_mult(0xFF, 0xFF) == 0xE3\n", "\nassert gf_mult(0x01, 0... |
abf195fe493e68f3b96cbc0553dc9991 | [
{
"content": "On te donne une liste de blocs d'octets. Ta tâche est d'implémenter une fonction `checksum_generator` qui calcule la somme de contrôle CRC32 cumulative de ces blocs d'octets de manière parallèle ou concurrente, en utilisant plusieurs cœurs de CPU pour maximiser les performances. La fonction doit r... | ["\nassert checksum_generator([b'']) == 0\n", "\nassert checksum_generator([b'hello']) == zlib.crc32(b'hello')\n", "\nassert checksum_generator([b'hello', b'world']) == zlib.crc32(b'world', zlib.crc32(b'hello'))\n", "\nassert checksum_generator([b'a', b'b', b'c']) == zlib.crc32(b'c', zlib.crc32(b'b', zlib.crc32(b'a')))... |
8bbcd11447d815454c19dbb9809184ef | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente un chemin de fichier. Ta tâche est d'implémenter une fonction qui vérifie l'existence de chaque fichier aux chemins spécifiés. La fonction doit renvoyer une liste de valeurs booléennes, où chaque booléen indique si le fich... | ["\nassert check_file_existence([\"./data/file1.csv\"]) == [False]\n", "\nassert check_file_existence([\"./data/file1.csv\", \"./data/file2.txt\"]) == [False, False]\n", "\nassert check_file_existence([]) == []\n", "\nassert check_file_existence([\"nonexistentfile.txt\"]) == [False]\n", "\nassert check_file_existence([... |
4e79d1c76e607876d417fc989fd2863f | [
{
"content": "On te donne un dictionnaire avec des clés de type chaîne de caractères et des valeurs booléennes, qui peut inclure des dictionnaires imbriqués. Ta tâche est d'implémenter une fonction `find_true_keys(dictionary)` qui renvoie une liste de toutes les clés dont la valeur correspondante est `True`. Po... | ["\nassert find_true_keys({'a': True, 'b': False}) == ['a']\n", "\nassert find_true_keys({'x': {'y': True, 'z': False}}) == ['x.y']\n", "\nassert find_true_keys({'m': {'n': {'o': True}}}) == ['m.n.o']\n", "\nassert find_true_keys({'p': False, 'q': {'r': False, 's': {'t': True}}}) == ['q.s.t']\n", "\nassert find_true_ke... |
2982321b567e4ff55ce38adfad39d43c | [
{
"content": "On te demande d'implémenter un système de caisse simple en Python. Le système doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un article** : Ajouter un article au panier avec son prix. Si l'article existe déjà, mettre à jour son prix.\n2. **Supprimer un article** : Supprimer un a... | ["\nassert CashierSystem().checkout() == 0\n", "\nassert CashierSystem().add_item(\"Apple\", 1.00) is None\n", "\nassert CashierSystem().remove_item(\"Banana\") is None\n", "\nassert CashierSystem().list_cart_items() is None\n", "\ncashier = CashierSystem(); cashier.add_item(\"Laptop\", 1200); assert cashier.checkout()... |
f598889455fa312f8877d6cbaac18ef0 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si la chaîne est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :*... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\n", "\nassert is_palindrome(\" \") == True\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(... |
0d401fecb3618168a2c32b6504be3b8e | [
{
"content": "On te donne une chaîne de requête encodée par URL. Ta tâche est de mettre en œuvre une fonction `parse_query_string` qui décode la chaîne de requête et renvoie un dictionnaire de paires clé-valeur. Chaque clé du dictionnaire doit correspondre à une seule valeur (la première valeur s'il y en a plus... | ["\nassert parse_query_string(\"name=John%20Doe&age=25&city=New%20York\") == {'name': 'John Doe', 'age': '25', 'city': 'New York'}\n", "\nassert parse_query_string(\"key1=value1&key2=value2\") == {'key1': 'value1', 'key2': 'value2'}\n", "\nassert parse_query_string(\"singlekey=singlevalue\") == {'singlekey': 'singleval... |
9add2cd0fe6f5524fb8974005f91f04b | [
{
"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 fonction doit renvoyer une liste de ces triplets. Si aucun triplet de ce type n'existe, renvoie une liste vide. Assure-toi que la sortie ne contient pas de triplets dup... | ["\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]) == [[-2, -1, 3], [-2, 0,... |
14d8004c442ff70b6c6e7492029e5c4c | [
{
"content": "Dans une ROM de cartouche de jeu représentée comme un fichier binaire, l'octet 5 (indexé à partir de 0) indique le nombre de banques PRG. Ta tâche est de mettre en œuvre une fonction `get_prg_banks_count` qui lit cet octet et renvoie sa valeur décimale. La fonction doit gérer les erreurs d'ouvertu... | ["\nassert get_prg_banks_count(\"test_rom.bin\") == 0 if not open(\"test_rom.bin\", 'wb').write(b'\\x00\\x01\\x02\\x03\\x04') else 4\n", "\nassert get_prg_banks_count(\"test_rom.bin\") == 0 if not open(\"test_rom.bin\", 'wb').write(b'\\x00\\x01\\x02\\x03') else 3\n", "\nassert get_prg_banks_count(\"test_rom.bin\") == 2... |
199c44c4184984eb1ae44a0a39d69f3f | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `rotate_string(s, n)` qui fait pivoter la chaîne `s` vers la gauche de `n` positions. Si `n` dépasse la longueur de la chaîne, elle doit revenir au début. La fonction doit gérer efficacement les... | ["\nassert rotate_string(\"abcde\", 2) == \"cdeab\"\n", "\nassert rotate_string(\"abcde\", 6) == \"cdeab\"\n", "\nassert rotate_string(\"abcdef\", 3) == \"defabc\"\n", "\nassert rotate_string(\"abcdef\", 0) == \"abcdef\"\n", "\nassert rotate_string(\"abcdef\", 6) == \"abcdef\"\n", "\nassert rotate_string(\"\", 3) == \"... |
c39b91746a7452c1530f58c28ed4e89c | [
{
"content": "On te demande d'implémenter une fonction `validate_credit_card_number` qui détermine la validité d'un numéro de carte de crédit donné. La fonction doit accepter des entiers et des chaînes de caractères en entrée. Les zéros en tête ne sont pas autorisés, sauf si le nombre est exactement zéro. Le nu... | ["\nassert validate_credit_card_number(4539148803436467) == True\n", "\nassert validate_credit_card_number(\"4539148803436467\") == True\n", "\nassert validate_credit_card_number(1234567812345670) == False\n", "\nassert validate_credit_card_number(\"1234567812345670\") == False\n", "\nassert validate_credit_card_number... |
28675c1f41f401ce6bda7994c1e2c6c3 | [
{
"content": "On te demande d'écrire un programme Python pour calculer la factorielle d'un entier non négatif donné en utilisant la récursion. Ton programme doit définir une fonction nommée `factorial` qui accepte un entier comme paramètre et renvoie la factorielle de cet entier.\n\n**Entrée :**\n- Un seul enti... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(2) == 2\n", "\nassert factorial(3) == 6\n", "\nassert factorial(4) == 24\n", "\nassert factorial(5) == 120\n", "\nassert factorial(6) == 720\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factor... |
3040e8faa25944a5d78d4e9712ed8206 | [
{
"content": "On te donne un tableau non trié d'entiers `arr` et un entier `k`. Ta tâche est d'écrire une fonction qui renvoie le k-ième plus petit élément du tableau sans modifier le tableau original. Le tableau peut contenir des éléments dupliqués. Suppose que `1 ≤ k ≤ len(arr)`.\n\n**Exemple d'entrée :**\n``... | ["\nassert find_kth_smallest_element([7, 10, 4, 3, 20, 15], 3) == 7\n", "\nassert find_kth_smallest_element([1, 2, 3, 4, 5, 6], 1) == 1\n", "\nassert find_kth_smallest_element([10, 9, 8, 7, 6, 5], 6) == 5\n", "\nassert find_kth_smallest_element([5, 5, 5, 5, 5, 5], 3) == 5\n", "\nassert find_kth_smallest_element([100, 2... |
d965a61828b5ebafbfd1551ce4fc28cd | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `count_vowels(s)` qui renvoie le nombre de voyelles présentes dans la chaîne. Les voyelles sont définies comme 'a', 'e', 'i', 'o', 'u' (en majuscules et en minuscules). La fonction doit être insensible à la cass... | ["\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... |
77d37faf55c7a62a07d9b38d9f1a36d0 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne est une phrase contenant plusieurs mots. Ta tâche est d'écrire une fonction qui extrait tous les mots uniques de ces phrases. Un mot est défini comme une séquence de caractères alphanumériques. La comparaison doit être insensible à l... | ["\nassert unique_words([\"Hello world!\", \"This is hello to the WORLD of Python.\", \"Python is great.\"]) == ['hello', 'world', 'this', 'to', 'the', 'of', 'python', 'is', 'great']\n", "\nassert unique_words([\"Python\", \"python\", \"PYTHON\"]) == ['python']\n", "\nassert unique_words([\"\"]) == []\n", "\nassert uni... |
cf27f0d9ab2993774a32f3fa52e39098 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_duplicates` qui identifie et renvoie une liste de tous les entiers qui apparaissent plus d'une fois dans la liste d'entrée. La liste renvoyée ne doit contenir aucun entier en double. L'ordre des éléments dans la liste r... | ["\nassert find_duplicates([1, 2, 3, 2, 4, 5, 5, 6]) == [2, 5]\n", "\nassert find_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert find_duplicates([1, 2, 3, 4, 5]) == []\n", "\nassert find_duplicates([]) == []\n", "\nassert find_duplicates([10, 20, 30, 40, 50, 10, 20, 30]) == [10, 20, 30]\n", "\nassert find_duplicates(... |
43bbb936839c87e161ed9aa37bfda572 | [
{
"content": "On te donne une chaîne de caractères `message` qui contient une commande suivie d'un espace et de texte supplémentaire. Ta tâche est d'implémenter la fonction `extract_command(message)` qui extrait la commande du `message`. La commande est définie comme la sous-chaîne avant le premier caractère es... | ["\nassert extract_command(\"start game\") == \"start\"\n", "\nassert extract_command(\"stop\") == \"stop\"\n", "\nassert extract_command(\"jump high\") == \"jump\"\n", "\nassert extract_command(\"run fast\") == \"run\"\n", "\nassert extract_command(\"walk\") == \"walk\"\n", "\nassert extract_command(\"attack the targe... |
4fc88f71f377c56f0d6dcc2776fb2f93 | [
{
"content": "On te donne deux ensembles d'entiers, `set1` et `set2`. Ta tâche est d'écrire une fonction qui calcule la différence symétrique de ces deux ensembles. La différence symétrique de deux ensembles est un ensemble contenant les éléments qui sont dans l'un ou l'autre des ensembles, mais pas dans leur i... | ["\nassert symmetric_difference({1, 2, 3}, {2, 3, 4}) == {1, 4}\n", "\nassert symmetric_difference({1, 2, 3}, {4, 5, 6}) == {1, 2, 3, 4, 5, 6}\n", "\nassert symmetric_difference({1, 2, 3}, {1, 2, 3}) == set()\n", "\nassert symmetric_difference(set(), {1, 2, 3}) == {1, 2, 3}\n", "\nassert symmetric_difference({1, 2, 3},... |
e12da5a5de24d9ea05840667d713e4aa | [
{
"content": "Tu participes à un concours de programmation graphique où l'on te donne une liste triée de tuples. Chaque tuple est composé d'une valeur flottante comprise entre 0 et 1 et d'une couleur représentée sous forme de chaîne hexadécimale (par exemple, \"#FF0000\" pour le rouge). La liste est triée par o... | ["\nassert extract_colors([(0.1, \"#FF0000\"), (0.3, \"#00FF00\"), (0.5, \"#0000FF\")]) == [\"#FF0000\", \"#00FF00\", \"#0000FF\"]\n", "\nassert extract_colors([(0.2, \"#FFFFFF\"), (0.8, \"#000000\")]) == [\"#FFFFFF\", \"#000000\"]\n", "\nassert extract_colors([(0.0, \"#123456\"), (0.5, \"#654321\"), (1.0, \"#ABCDEF\")... |
5cb6d129b8b64cb349485672f23a42a4 | [
{
"content": "On te donne un entier `N`. Ta tâche est de déterminer si `N` peut être exprimé comme une puissance à la fois de 3 et de 4 simultanément. En d'autres termes, trouve s'il existe des entiers non négatifs `x` et `y` tels que `N = 3^x = 4^y`. Implémente la fonction `is_power_of_three_and_four(N)` qui r... | ["\nassert is_power_of_three_and_four(1) == True\n", "\nassert is_power_of_three_and_four(3) == False\n", "\nassert is_power_of_three_and_four(4) == False\n", "\nassert is_power_of_three_and_four(12) == True\n", "\nassert is_power_of_three_and_four(144) == True\n", "\nassert is_power_of_three_and_four(256) == False\n",... |
de805fed42ef71525d4a6fc4e45bab37 | [
{
"content": "On te demande d'implémenter une fonction nommée `get_valid_input` qui prend une chaîne de caractères `message` en entrée. La fonction doit inviter l'utilisateur à entrer une valeur de manière répétée jusqu'à ce qu'un entier premier valide soit saisi. Si l'utilisateur entre une valeur non entière, ... | ["\nassert get_valid_input(\"Enter a prime number: \") == 2\n", "\nassert get_valid_input(\"Enter a prime number: \") == 3\n", "\nassert get_valid_input(\"Enter a prime number: \") == 5\n", "\nassert get_valid_input(\"Enter a prime number: \") == 7\n", "\nassert get_valid_input(\"Enter a prime number: \") == 11\n", "\n... |
c13668b2af005fe1304192d7c49e18b8 | [
{
"content": "Tu participes à une compétition de traitement du langage naturel où tu dois évaluer un étiqueteur morphosyntaxique (POS) simple. L'étiqueteur prédit l'étiquette la plus fréquente pour chaque mot dans une phrase donnée. Ta tâche est d'implémenter une fonction `evaluate_most_frequent_tagger` qui cal... | ["\nassert evaluate_most_frequent_tagger([[(\"the\", \"DT\"), (\"cat\", \"NN\")]], {\"the\": \"DT\", \"cat\": \"NN\"}) == 1.0\n", "\nassert evaluate_most_frequent_tagger([[(\"the\", \"DT\"), (\"cat\", \"VB\")]], {\"the\": \"DT\", \"cat\": \"NN\"}) == 0.5\n", "\nassert evaluate_most_frequent_tagger([[(\"dog\", \"NN\"), ... |
32d06c51b204f6d2b534d8bdc0a8db26 | [
{
"content": "On te donne une chaîne de caractères `text` et une chaîne de caractères `word`. Ton objectif est d'implémenter une fonction `find_all_occurrences(text, word)` qui renvoie une liste de tous les indices de début où `word` apparaît dans `text`. Les indices doivent être dans l'ordre croissant. La fonc... | ["\nassert find_all_occurrences(\"hello world hello\", \"hello\") == [0, 11]\n", "\nassert find_all_occurrences(\"hello world hello\", \"hello\") == [0, 12]\n", "\nassert find_all_occurrences(\"abc abc abc\", \"abc\") == [0, 4, 8]\n", "\nassert find_all_occurrences(\"abc abc abc\", \"abcd\") == []\n", "\nassert find_... |
ff4624a5366d7e19422d6e49299ea9ca | [
{
"content": "On te donne un fichier CSV nommé `books.csv` contenant des informations sur des livres. Chaque ligne du fichier CSV représente un livre et possède les colonnes suivantes : 'Title', 'Author', 'Genre', 'Year' et 'Price'. Ta tâche est de mettre en œuvre une fonction `sort_books_by_price` qui lit ce f... | ["\nassert sort_books_by_price(\"test_books.csv\") == [{'Title': 'Book A', 'Author': 'Author X', 'Genre': 'Fiction', 'Year': '2001', 'Price': 10.99}, {'Title': 'Book B', 'Author': 'Author Y', 'Genre': 'Non-Fiction', 'Year': '2005', 'Price': 15.99}, {'Title': 'Book C', 'Author': 'Author Z', 'Genre': 'Science', 'Year': '... |
947a42aacd8e322e2b8acecb87020147 | [
{
"content": "On te donne une liste de tuples, où chaque tuple consiste en le nom d'un étudiant (une chaîne de caractères), une matière (une chaîne de caractères) et une note (un entier). Ta tâche est de concevoir une classe `StudentGrades` qui traite cette liste pour créer un dictionnaire imbriqué mappant chaq... | ["\nassert grades_manager.get_grades() == {'Alice': {'Math': 90, 'Science': 88}}\n", "\nassert grades_manager.get_student_grades('Alice') == {'Math': 90, 'Science': 88}\n", "\nassert grades_manager.get_student_grades('Bob') == {}\n", "\nassert grades_manager.get_grades() == {'Alice': {'Math': 90}}\n", "\nassert grades_... |
2c18d8b677d8ed5cc1996bbafeb95a83 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui simule les opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Créer un compte bancaire avec le nom du titulaire et un solde initial facultatif (par défaut, 0).\n... | ["\nassert BankAccount(\"Alice\").get_balance() == 0\n", "\nassert BankAccount(\"Bob\", 100).get_balance() == 100\n", "\nassert BankAccount(\"Charlie\").deposit(50) == True\n", "\nassert BankAccount(\"David\", 200).deposit(-100) == False\n", "\nassert BankAccount(\"Eve\", 150).withdraw(50) == True\n", "\nassert BankAcc... |
6724db1248a13998209899f4ed81e939 | [
{
"content": "On te donne une liste de numéros de téléphone, `phone_numbers`, où chaque numéro de téléphone est une chaîne de caractères formatée comme `'(XXX) YYY-ZZZZ'`. Ici, `XXX` représente l'indicatif régional, `YYY` est le code du central téléphonique et `ZZZZ` est le code de poste. Ta tâche est de mettre... | ["\nassert count_local_calls(['(080) 123-4567', '(022) 987-6543', '(080) 456-7890']) == 1\n", "\nassert count_local_calls(['(121) 123-4567', '(232) 987-6543', '(343) 456-7890']) == 3\n", "\nassert count_local_calls(['(123) 123-4567', '(456) 987-6543', '(789) 456-7890']) == 0\n", "\nassert count_local_calls(['(000) 123-... |
45c4c01c6e2dd6f3616ada12dcdbac3a | [
{
"content": "On te donne un ensemble de données contenant des avis clients pour un produit. Chaque avis est représenté comme un dictionnaire avec deux clés : \"text\" (une chaîne de caractères contenant le texte de l'avis) et \"rating\" (un entier représentant la note numérique attribuée par le client). Ta tâc... | ["\nassert filter_and_sort_reviews([{\"text\": \"Great product!\", \"rating\": 5}, {\"text\": \"Not bad\", \"rating\": 3}], 3) == [{\"text\": \"Great product!\", \"rating\": 5}]\n", "\nassert filter_and_sort_reviews([{\"text\": \"Terrible\", \"rating\": 1}, {\"text\": \"Awful\", \"rating\": 2}], 2) == []\n", "\nassert ... |
bd2b4836610a13a745d959eecfadbafc | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_second_largest` qui identifie le deuxième plus grand entier distinct de la liste. Si la liste contient moins de deux entiers distincts, la fonction doit renvoyer `None`.\n\n**Signature de la fonction :**\n```python\ndef... | ["\nassert find_second_largest([1, 2, 3, 4, 5]) == 4\n", "\nassert find_second_largest([5, 5, 5, 5]) == None\n", "\nassert find_second_largest([10]) == None\n", "\nassert find_second_largest([1, 1, 2, 2, 3, 3]) == 2\n", "\nassert find_second_largest([100, 90]) == 90\n", "\nassert find_second_largest([-1, -2, -3, -4]) =... |
aeeb8753375d47ffba04874e8adf72db | [
{
"content": "On te donne un graphe orienté avec `V` sommets et `E` arêtes, représenté sous forme d'une liste d'adjacence sous la forme d'un dictionnaire. Chaque clé du dictionnaire est un nœud, et la valeur correspondante est une liste des nœuds qui peuvent être atteints directement à partir du nœud clé. Ta tâ... | ["\nassert has_isolated_cycles({}) == False\n", "\nassert has_isolated_cycles({'a': ['b'], 'b': ['a']}) == True\n", "\nassert has_isolated_cycles({'a': ['b'], 'b': ['c'], 'c': ['a']}) == True\n", "\nassert has_isolated_cycles({'a': ['b'], 'b': ['c'], 'c': ['d']}) == False\n", "\nassert has_isolated_cycles({'a': ['b'], ... |
4b0cff6a76e6f93cdcb21111b2daaa92 | [
{
"content": "Implémente une classe Python nommée `Stack` qui simule une structure de données de pile simple avec les méthodes suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élément du sommet de la pile. Lève une exception `IndexError` avec le message \"... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().push(1) is None\n", "\nassert Stack().push(2) is None\n", "\ns = Stack(); s.push(3); assert s.peek() == 3\n", "\ns = Stack(); s.push(4); s.push(5); assert s.pop() == 5\n", "\ns = Stack(); s.push(6); s.push(7); s.pop(); assert s.peek() == 6\n", "\ns = Stack(); ... |
dc773dce91c0764c730f404fd68aaa1b | [
{
"content": "On te donne une liste de paiements `pmt_list` où chaque élément représente le paiement effectué à la fin de chaque période. Ta tâche est de calculer la valeur future d'une rente viagère avec ces paiements variables. La rente est composée `n` fois par an à un taux d'intérêt annuel `r` sur une pério... | ["\nassert future_value_of_varying_annuity([100, 200, 300], 0.05, 4, 2) == 1071.2815625000002\n", "\nassert future_value_of_varying_annuity([100, 100, 100], 0.05, 2, 1) == 202.5\n", "\nassert future_value_of_varying_annuity([500, 500, 500, 500], 0.07, 1, 4) == 2148.5499999999995\n", "\nassert future_value_of_varying_an... |
5f9319493992cd75a1c6344a10aefd83 | [
{
"content": "On te donne une chaîne de caractères `S` composée de lettres (majuscules et minuscules), de chiffres et de caractères spéciaux. Ta tâche est d'écrire une fonction qui supprime toutes les voyelles (a, e, i, o, u) de la chaîne, quelle que soit leur casse, et qui renvoie la chaîne résultante.\n\n**En... | ["\nassert remove_vowels(\"Hello, World! 123\") == \"Hll, Wrld! 123\"\n", "\nassert remove_vowels(\"AEIOUaeiou\") == \"\"\n", "\nassert remove_vowels(\"Python Programming\") == \"Pythn Prgrmmng\"\n", "\nassert remove_vowels(\"abcdefghijklmnopqrstuvwxyz\") == \"bcdfghjklmnpqrstvwxyz\"\n", "\nassert remove_vowels(\"ABCDE... |
9aef482a6ed067ed15ef33dca3fbfb7c | [
{
"content": "On te donne une pile de crêpes représentée par une liste d'entiers, où chaque entier représente la hauteur d'une crêpe. Ta tâche est de trier la pile de crêpes par ordre décroissant en utilisant le nombre minimum d'opérations de retournement. Une opération de retournement consiste à choisir un ind... | ["\nassert sort_pancakes([3, 2, 1, 4]) == 2\n", "\nassert sort_pancakes([1, 2, 3, 4]) == 3\n", "\nassert sort_pancakes([4, 3, 2, 1]) == 0\n", "\nassert sort_pancakes([1, 3, 2, 4]) == 3\n", "\nassert sort_pancakes([1, 1, 1, 1]) == 0\n", "\nassert sort_pancakes([1, 2, 2, 3, 3, 4, 4]) == 5\n", "\nassert sort_pancakes([4, ... |
b4b14f4808a8bb43b80f448c44461a13 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `count_vowels` qui renvoie le nombre de voyelles dans la chaîne. La fonction doit être insensible à la casse et considérer 'a', 'e', 'i', 'o', 'u' comme des voyelles.\n\n**Entrée :**\n- Une seule chaîne de carac... | ["\nassert count_vowels(\"Hello, World!\") == 3\n", "\nassert count_vowels(\"Python Programming\") == 4\n", "\nassert count_vowels(\"AEIOU\") == 5\n", "\nassert count_vowels(\"abcdefghijklmnopqrstuvwxyz\") == 5\n", "\nassert count_vowels(\"BCDFG\") == 0\n", "\nassert count_vowels(\"\") == 0\n", "\nassert count_vowels(\... |
b6d54105edfa4e2043c09c49ec65224e | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit encapsuler les propriétés d'un livre, notamment son `title`, son `author` et son `year_published`. Le constructeur de la classe doit accepter trois paramètres correspondant à ces propriétés et initialiser l'objet en conséquenc... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_info() == \"Title: 1984, Author: George Orwell, Year: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).get_info() == \"Title: To Kill a Mockingbird, Author: Harper Lee, Year: 1960\"\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzg... |
97a4e07342ca32b2902a31a27ad9c4da | [
{
"content": "On te demande d'implémenter une classe nommée `DataFrameProcessor` qui gérera des tâches de manipulation de données de base sur un fichier CSV. Ta classe doit être capable de charger des données, de filtrer les lignes en fonction d'une condition spécifique et de calculer la moyenne d'une colonne. ... | ["\nassert DataFrameProcessor(\"test_data.csv\").data.shape == (5, 3)\n", "\nassert DataFrameProcessor(\"test_data.csv\").filter_rows(\"Name\", \"Alice\").shape == (1, 3)\n", "\nassert DataFrameProcessor(\"test_data.csv\").filter_rows(\"Age\", 30).shape == (2, 3)\n", "\nassert DataFrameProcessor(\"test_data.csv\").calc... |
e6b286b4e72644d7f5d2957d9ce816c4 | [
{
"content": "On te donne une liste de phrases, où chaque phrase est représentée comme une liste de mots. Ta tâche est de créer une fonction qui génère une représentation \"éparse\" de ces phrases. Une représentation \"éparse\" est une liste d'entiers, où chaque entier correspond à la valeur de hachage d'un mot... | ["\nassert generate_sparse_representation([[\"hello\", \"world\"]], {}, True) == [[custom_hash(\"hello\"), custom_hash(\"world\")]]\n", "\nassert generate_sparse_representation([[\"hello\", \"hello\"]], {\"hello\": 10}, False) == [[10, 10]]\n", "\nassert generate_sparse_representation([[\"hi\", \"there\"], [\"hi\", \"e... |
b952a78c0cd1052b296909d4ad52fbc3 | [
{
"content": "Tu développes une simulation pour une épicerie magique où les articles sont classés en types magiques et non magiques. En raison des propriétés magiques de certains articles, un panier ne peut contenir que des articles du même type. Ta tâche est de mettre en œuvre une fonction `check_basket_validi... | ["\nassert check_basket_validity([('Biscuits', 1), ('Flying Pig', 1)], {'Flying Pig', 'Unicorn'}) == False\n", "\nassert check_basket_validity([('Flying Pig', 1), ('Unicorn', 1)], {'Flying Pig', 'Unicorn'}) == True\n", "\nassert check_basket_validity([('Biscuits', 1), ('Apple', 2)], {'Flying Pig', 'Unicorn'}) == True\n... |
114038332d81366b0c9788b21ef7a0fa | [
{
"content": "On te demande d'implémenter deux fonctions pour calculer la somme des `n` premiers nombres naturels. Une fonction doit utiliser la récursion, et l'autre doit utiliser l'itération. Tes fonctions doivent gérer les cas où `n` est zéro ou négatif en renvoyant 0.\n\n**Entrée :**\n- Un entier `n` (0 ≤ n... | ["\nassert sum_recursive(0) == 0\n", "\nassert sum_recursive(1) == 1\n", "\nassert sum_recursive(5) == 15\n", "\nassert sum_recursive(10) == 55\n", "\nassert sum_recursive(100) == 5050\n", "\nassert sum_iterative(0) == 0\n", "\nassert sum_iterative(1) == 1\n", "\nassert sum_iterative(5) == 15\n", "\nassert sum_iterativ... |
4c7c358fbbbbb138564b9c76b442e673 | [
{
"content": "On te donne une chaîne de caractères représentant la description d'un cours universitaire. La chaîne contient trois parties : le code du cours, le nom du cours et le domaine, séparées par des virgules. Le nom du cours et le domaine peuvent contenir des caractères non alphanumériques, à l'exception... | ["\nassert parse_course_info(\"CS101, Intro to Programming, Computer Science\") == (\"CS101\", \"Intro to Programming\", \"Computer Science\")\n", "\nassert parse_course_info(\"MATH202, Calculus & Analytic Geometry, Mathematics\") == (\"MATH202\", \"Calculus Analytic Geometry\", \"Mathematics\")\n", "\nassert parse_co... |
3ff4fe41385b12f31465f49183eab897 | [
{
"content": "On te donne deux chaînes de caractères `s1` et `s2`. Ta tâche est de mettre en œuvre une fonction `find_common_words` qui renvoie un ensemble de mots communs aux deux chaînes. La fonction doit ignorer la ponctuation et ne pas tenir compte de la casse.\n\n**Entrée :**\n- Deux chaînes de caractères ... | ["\nassert find_common_words(\"Hello, world!\", \"world\") == {'world'}\n", "\nassert find_common_words(\"Python is great.\", \"Great Python!\") == {'python', 'great'}\n", "\nassert find_common_words(\"No common words here.\", \"Completely different.\") == set()\n", "\nassert find_common_words(\"Case Insensitivity.\", ... |
4bf669ed36a4e87da863f2d9fe4904f0 | [
{
"content": "On te demande d'implémenter une fonction `download_and_store_image` en Python. La fonction doit accepter trois paramètres : `id` (un entier), `text` (une chaîne de caractères) et `link` (une chaîne de caractères). Le paramètre `link` est une URL vers un fichier image.\n\nTa fonction doit utiliser ... | ["\nassert os.path.exists(\"1_test.jpg\") == False # Ensure the file does not exist before the test\ndownload_and_store_image(1, \"test\", \"https://via.placeholder.com/150\")\nassert os.path.exists(\"1_test.jpg\") == True # Ensure the file exists after the test\n", "\nassert os.path.exists(\"2_test.jpg\") == False ... |
25f6c6ab4984289d4183178008a1ccc0 | [
{
"content": "On te donne une chaîne de caractères représentant un chemin de fichier. Ta tâche est de mettre en œuvre une fonction `extract_root_name` qui extrait le nom de base du fichier à partir du chemin. Le nom de base est défini comme le nom du fichier sans aucun suffixe numérique suivant le dernier point... | ["\nassert extract_root_name(\"example.001.txt\") == \"example\"\n", "\nassert extract_root_name(\"document.txt\") == \"document\"\n", "\nassert extract_root_name(\"image.1234\") == \"image\"\n", "\nassert extract_root_name(\"archive.tar.gz\") == \"archive.tar.gz\"\n", "\nassert extract_root_name(\"file.999\") == \"fil... |
5fab29636aa9e166c77fcff3e98f21c0 | [
{
"content": "On te donne une phrase sous forme de chaîne de caractères `sentence`. Ta tâche est de mettre en œuvre une fonction `word_frequency(sentence)` qui traite la phrase et renvoie une liste de tuples. Chaque tuple doit contenir un mot unique et sa fréquence dans la phrase. La liste doit être triée princ... | ["\nassert word_frequency(\"Hello, hello! How are you? I hope you're doing well, well.\") == [('hello', 2), ('well', 2), ('are', 1), ('doing', 1), ('hope', 1), ('how', 1), ('i', 1), ('you', 1), ('youre', 1)]\n", "\nassert word_frequency(\"A quick brown fox jumps over the lazy dog.\") == [('a', 1), ('brown', 1), ('dog',... |
03d4e993ed6994a4d4b3e13ab2df6c97 | [
{
"content": "On te demande d'écrire une fonction `parse_log_file` qui traite un fichier journal nommé `server.log` pour extraire toutes les adresses IPv4 uniques. Chaque ligne du fichier journal peut contenir plusieurs adresses IP au format `XXX.XXX.XXX.XXX`, où `XXX` est un entier compris entre 0 et 255. Ta f... | ["\nassert parse_log_file('test_log_1.log') == ['192.168.1.1']\n", "\nassert parse_log_file('test_log_2.log') == ['10.0.0.1', '192.168.1.1']\n", "\nassert parse_log_file('test_log_3.log') == []\n", "\nassert parse_log_file('test_log_4.log') == ['255.255.255.255']\n", "\nassert parse_log_file('test_log_5.log') == ['0.0.... |
a98619f2494047c73d9c6edcf3c28486 | [
{
"content": "On te donne un tableau d'entiers distincts `arr` et un entier `threshold`. Ta tâche est de générer toutes les permutations du tableau telles que la différence absolue entre deux éléments adjacents dans la permutation est inférieure ou égale au `threshold`. Implémente une fonction génératrice qui p... | ["\nassert list(valid_permutations([1, 2, 3], 1)) == [[1, 2], [2, 1], [2, 3], [3, 2]]\n", "\nassert list(valid_permutations([1, 2, 3], 2)) == [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]\n", "\nassert list(valid_permutations([1, 2, 3], 0)) == [[1], [2], [3]]\n", "\nassert list(valid_permutations([1, 5, 9], 4)) == [... |
3f3fe3380d25c8d6ae898d68ae80c1e3 | [
{
"content": "On te donne les cotes en faveur de la survenue d'un événement sous la forme d'un tuple de deux entiers. Le premier entier représente le nombre d'issues favorables, et le second entier représente le nombre d'issues défavorables. Ta tâche est d'écrire une fonction Python qui calcule et renvoie la pr... | ["\nassert probability_from_odds((3, 2)) == 0.6\n", "\nassert probability_from_odds((1, 1)) == 0.5\n", "\nassert probability_from_odds((0, 5)) == 0.0\n", "\nassert probability_from_odds((5, 0)) == 1.0\n", "\nassert probability_from_odds((2, 3)) == 0.4\n", "\nassert probability_from_odds((10, 10)) == 0.5\n", "\nassert p... |
f220787254c40077ada4267d5f25e374 | [
{
"content": "On te donne un dictionnaire `algorithm_times` où chaque clé est une chaîne de caractères représentant le nom d'un algorithme, et chaque valeur est une liste d'entiers représentant les temps d'exécution de cet algorithme sur plusieurs tests. Ta tâche est de mettre en œuvre une fonction `fastest_alg... | ["\nassert fastest_algorithm({'AlgorithmA': [10, 12, 11], 'AlgorithmB': [9, 11, 10], 'AlgorithmC': [13, 12, 14]}) == 'AlgorithmB'\n", "\nassert fastest_algorithm({'AlgorithmX': [5, 5, 5], 'AlgorithmY': [6, 6, 6], 'AlgorithmZ': [7, 7, 7]}) == 'AlgorithmX'\n", "\nassert fastest_algorithm({'QuickSort': [0.1, 0.2, 0.3], 'M... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.