id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
87547e4c99bd35950643d0390c00689c | [
{
"content": "On te donne une liste de produits, chacun représenté comme un tuple contenant le nom du produit et son prix. Ta tâche est de mettre en œuvre une fonction qui calcule le pourcentage de réduction pour chaque produit en fonction de son prix. Les règles de réduction sont les suivantes :\n- Aucune rédu... | ["\nassert calculate_discount((\"Book\", 500)) == (\"Book\", 0)\n", "\nassert calculate_discount((\"Tablet\", 750)) == (\"Tablet\", 0)\n", "\nassert calculate_discount((\"Smartphone\", 800)) == (\"Smartphone\", math.log2(50) / 7.5)\n", "\nassert calculate_discount((\"Laptop\", 1500)) == (\"Laptop\", math.log2(750) / 7.... |
ad68b0fd2fe357049c2fc8bdac5f4b89 | [
{
"content": "Tu es un chimiste chargé d'analyser la composition élémentaire d'un maximum de 100 matériaux différents. Pour chaque matériau, on te fournit les masses atomiques et les fractions massiques de deux éléments. Ton objectif est de calculer le rapport molaire de ces deux éléments pour chaque matériau. ... | ["\nassert calculate_molar_ratio(12.011, 15.999, 0.4, 0.6) == 0.4993600683013609\n", "\nassert calculate_molar_ratio(28.0855, 32.065, 0.3, 0.7) == 0.30034632034632034\n", "\nassert calculate_molar_ratio(1.008, 16.00, 0.5, 0.5) == 0.063\n", "\nassert calculate_molar_ratio(14.007, 12.011, 0.2, 0.8) == 0.2833333333333333\... |
8ccf1024e92f4f3a238e47b39a1bee41 | [
{
"content": "On te donne un chemin d'accès complet à un fichier ou un dossier, qui peut inclure des liens symboliques. Ta tâche est d'écrire une fonction `get_grandparent_folder_name(path)` qui renvoie le nom du dossier grand-parent. Si le chemin n'a pas de dossier grand-parent, renvoie `None`.\n\n**Entrée :**... | ["\nassert get_grandparent_folder_name(\"/home/user/documents/file.txt\") == \"user\"\n", "\nassert get_grandparent_folder_name(\"/home/user/documents/\") == \"user\"\n", "\nassert get_grandparent_folder_name(\"/home/user/\") == None\n", "\nassert get_grandparent_folder_name(\"/home/\") == None\n", "\nassert get_grandp... |
146601520acaab2a20ebdff4061aaff3 | [
{
"content": "On te donne une liste d'identifiants d'éléments uniques. Ta tâche est d'implémenter la fonction `find_matching_pairs(items)` qui génère toutes les paires possibles et uniques d'éléments de la liste. Cependant, la fonction doit éviter de générer des paires qui ont déjà été associées. Les paires pré... | ["\nassert find_matching_pairs(['item1', 'item2', 'item3']) == [{frozenset({'item1', 'item2'}), frozenset({'item1', 'item3'}), frozenset({'item2', 'item3'})}]\n", "\nassert find_matching_pairs(['item1', 'item2']) == [{frozenset({'item1', 'item2'})}]\n", "\nassert find_matching_pairs(['item1']) == []\n", "\nassert find_... |
e109eb64f040c72838df89228c2a6599 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé de deux entiers. Ta tâche est d'écrire une fonction Python qui trie cette liste de tuples principalement par le deuxième élément de chaque tuple. En cas d'égalité (c'est-à-dire que deux tuples ont le même deuxième élément), les tuples do... | ["\nassert sort_tuples([(1, 3), (4, 1), (5, 0), (2, 3)]) == [(5, 0), (4, 1), (1, 3), (2, 3)]\n", "\nassert sort_tuples([(2, 2), (1, 2), (3, 1)]) == [(3, 1), (1, 2), (2, 2)]\n", "\nassert sort_tuples([(7, 5), (3, 2), (5, 2)]) == [(3, 2), (5, 2), (7, 5)]\n", "\nassert sort_tuples([(10, 10), (9, 9), (8, 8)]) == [(8, 8), (... |
35c0e6988fb6e21bd165a7f33acaeb7f | [
{
"content": "On te donne un masque de sous-réseau IPv4 en notation décimale pointée (par exemple, \"255.255.255.0\") ou en notation CIDR (par exemple, \"24\"). Ta tâche est d'écrire une fonction `count_set_bits_in_ip_mask` qui renvoie le nombre total de bits à 1 (1) dans la représentation binaire du masque de ... | ["\nassert count_set_bits_in_ip_mask(\"255.255.255.0\") == 24\n", "\nassert count_set_bits_in_ip_mask(\"24\") == 24\n", "\nassert count_set_bits_in_ip_mask(\"255.255.255.128\") == 25\n", "\nassert count_set_bits_in_ip_mask(\"32\") == 32\n", "\nassert count_set_bits_in_ip_mask(\"255.255.255.255\") == 32\n", "\nassert co... |
2b707378a28e27f4524666f73f8f323d | [
{
"content": "Dans une liste paginée, chaque page peut contenir un nombre différent d'éléments. Le nombre d'éléments sur chaque page est spécifié dans la liste `page_sizes`, où `page_sizes[i]` représente le nombre d'éléments sur la page `i+1`. Étant donné le `page_number`, détermine l'indice de début (base 0) d... | ["\nassert calculate_starting_index([10, 20, 30], 1) == 0\n", "\nassert calculate_starting_index([10, 20, 30], 2) == 10\n", "\nassert calculate_starting_index([10, 20, 30], 3) == 30\n", "\nassert calculate_starting_index([5, 5, 5, 5], 4) == 15\n", "\nassert calculate_starting_index([1, 2, 3, 4, 5], 5) == 10\n", "\nasse... |
03f2268626eae5f8cc0cf7c463d25cc5 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de partitionner la liste en sous-listes aussi courtes que possible, de telle sorte que chaque sous-liste contienne des entiers de la même parité (tous pairs ou tous impairs). Chaque sous-liste doit contenir au moins deux entiers. Si il n'est pas possib... | ["\nassert group_integers([1, 3, 5, 2, 4, 6, 7]) == [[1, 3, 5], [2, 4, 6]]\n", "\nassert group_integers([2, 4, 6, 8, 10]) == [[2, 4, 6, 8, 10]]\n", "\nassert group_integers([1, 1, 1, 1, 1]) == [[1, 1, 1, 1, 1]]\n", "\nassert group_integers([1, 2, 3, 4, 5, 6]) == [[1], [2, 4, 6]]\n", "\nassert group_integers([1]) == []\... |
e1808a9d9e6fb984c65c76aad067d7e6 | [
{
"content": "On te demande de simuler le lancer d'un dé à six faces équitable. Implémente une fonction `roll_die(num_rolls)` qui simule le lancer du dé `num_rolls` fois et renvoie un tuple contenant une liste des résultats et un dictionnaire avec les résultats comme clés et leurs probabilités respectives comme... | ["\nassert roll_die(0) == ([], {1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0, 6: 0.0})\n", "\nassert roll_die(1)[0][0] in [1, 2, 3, 4, 5, 6]\n", "\nassert all(0 <= prob <= 1 for prob in roll_die(100)[1].values())\n", "\nassert len(roll_die(10)[0]) == 10\n", "\nassert len(roll_die(100)[1]) == 6\n", "\nassert sum(roll_die(1000... |
bd7c8324e15b86f3429ef576a8630463 | [
{
"content": "On te demande d'implémenter une fonction `generate_file_path` qui construit un chemin de fichier en fonction du nom d'utilisateur, de la catégorie et du nom de fichier fournis. Le chemin de fichier doit suivre le format `users/{username}/{category}/{filename}`. La fonction doit gérer les caractère... | ["\nassert generate_file_path('john_doe', 'documents', 'my file.txt!@#') == 'users/john_doe/documents/my%20file.txt%21%40%23'\n", "\nassert generate_file_path('jane_smith', 'images', 'photo.jpg') == 'users/jane_smith/images/photo.jpg'\n", "\nassert generate_file_path('alice', 'videos', 'movie.mp4') == 'users/alice/vide... |
382665056aa23414ccc514d0f0a77cf7 | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction `find_largest_prime` qui identifie et renvoie le plus grand nombre premier présent dans la liste. Si la liste ne contient aucun nombre premier, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'en... | ["\nassert find_largest_prime([3, 5, 8, 13, 20]) == 13\n", "\nassert find_largest_prime([4, 6, 8, 10]) == None\n", "\nassert find_largest_prime([2, 3, 5, 7, 11, 13, 17, 19]) == 19\n", "\nassert find_largest_prime([29, 15, 21, 33, 37]) == 37\n", "\nassert find_largest_prime([1, 4, 6, 8, 10, 12]) == None\n", "\nassert fi... |
d65ae7accf9d8ea23404baa6732e8bff | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `count_set_bits(n)` qui renvoie le nombre de bits à 1 (bits avec la valeur 1) dans la représentation binaire de `n` qui sont suivis d'un bit avec la valeur 0 et qui sont situés aux indices pairs en comptant à partir du bit le moins sign... | ["\nassert count_set_bits(13) == 2\n", "\nassert count_set_bits(5) == 1\n", "\nassert count_set_bits(10) == 1\n", "\nassert count_set_bits(0) == 0\n", "\nassert count_set_bits(1) == 0\n", "\nassert count_set_bits(2) == 0\n", "\nassert count_set_bits(8) == 0\n", "\nassert count_set_bits(18) == 1\n", "\nassert count_set_... |
9e5a3c4e0572c10959066176738845c1 | [
{
"content": "On te donne un fichier JSON nommé `data.json` situé dans le même répertoire que ton programme. Le fichier JSON contient des dictionnaires et des listes imbriqués. Ta tâche est d'écrire un programme Python qui lit ce fichier JSON et extrait toutes les valeurs associées à une clé fournie par l'utili... | ["\nassert list(find_values({\"a\": 1, \"b\": 2}, \"a\")) == [1]\n", "\nassert list(find_values({\"a\": 1, \"b\": {\"a\": 2}}, \"a\")) == [1, 2]\n", "\nassert list(find_values({\"a\": [1, 2, {\"a\": 3}]}, \"a\")) == [1, 3]\n", "\nassert list(find_values([{\"a\": 1}, {\"b\": 2}, {\"a\": 3}], \"a\")) == [1, 3]\n", "\nass... |
b73125bf70ebb796ea329dd27ffdd3f9 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `remove_duplicates` qui modifie la liste sur place pour supprimer tous les entiers en double, en préservant l'ordre de leur première apparition. La fonction ne doit utiliser aucune structure de données supplémentaire autre qu... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 4, 5, 6, 6, 7]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([10, 20, 30, 40, 50]) == [10, 20, 30, 40, 50]\n", "\nassert remove_duplicates([5, 5, 5, 5, 5, 5, 5, 5... |
d69064e6333fe1e2e3cd4c6c6b092765 | [
{
"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 présentes dans la chaîne. Les voyelles sont définies comme les caractères `a`, `e`, `i`, `o` et `u`, et peuvent apparaître en minuscules ou en majuscules.\n\n**En... | ["\nassert count_vowels(\"Hello World\") == 3\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(\"abcdefghijklmnopqrstuvwxyz\") == 5\n", "\nassert count_vowe... |
d62a508d4da5a05bff5ec10b84aa77fa | [
{
"content": "On te donne une tâche de programmation consistant à implémenter une fonction nommée `generate_error_message` qui construit un message d'erreur personnalisé en fonction du nom de l'objet fourni et éventuellement de son type. La fonction doit respecter les règles suivantes :\n\n- Si `obj_name` est u... | ["\nassert generate_error_message(\"\") == \"Cannot proceed with an empty object name.\"\n", "\nassert generate_error_message(\"file\") == \"The object 'file' was not found.\"\n", "\nassert generate_error_message(\"document\", \"file\") == \"The file 'document' was not found.\"\n", "\nassert generate_error_message(\"us... |
12c255f77f964b6c402f27339d59c445 | [
{
"content": "On te donne une liste de tâches, où chaque tâche est une chaîne de caractères qui inclut un niveau de priorité indiqué par \"P1\", \"P2\" ou \"P3\" à la fin. Implémente une fonction `filter_tasks_by_priority(tasks, priority)` qui renvoie une liste de tâches correspondant à la priorité spécifiée.\n... | ["\nassert filter_tasks_by_priority([\"Write report P1\", \"Schedule meeting P2\", \"Update website P3\", \"Send email P1\", \"Prepare presentation P2\"], \"P1\") == [\"Write report P1\", \"Send email P1\"]\n", "\nassert filter_tasks_by_priority([\"Write report P1\", \"Schedule meeting P2\", \"Update website P3\", \"Se... |
779c318a02a8598f68f6c3ec455ae19b | [
{
"content": "On te donne une chaîne de caractères `s` composée d'une série de mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `reverse_words(s)` qui inverse l'ordre des mots dans la chaîne. La fonction doit renvoyer la chaîne résultante avec les mots dans l'ordre inverse, en veillant... | ["\nassert reverse_words(\"hello world\") == \"world hello\"\n", "\nassert reverse_words(\" hello world \") == \"world hello\"\n", "\nassert reverse_words(\"a b c d e\") == \"e d c b a\"\n", "\nassert reverse_words(\" multiple spaces here \") == \"here spaces multiple\"\n", "\nassert reverse_words(\"single\"... |
677070c69615236a7be8f3b53eda49e3 | [
{
"content": "On te donne une liste de phrases. Ta tâche est d'écrire une fonction Python qui renvoie un dictionnaire où chaque clé est un mot et sa valeur est le nombre de phrases qui contiennent le mot. Suppose que les mots sont séparés par des espaces et que la ponctuation est ignorée.\n\n**Entrée :**\n- Une... | ["\nassert count_words_in_sentences(['The cat sat on the mat']) == {'the': 1, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1}\n", "\nassert count_words_in_sentences(['The dog chased the cat', 'The cat sat on the mat']) == {'the': 2, 'dog': 1, 'chased': 1, 'cat': 2, 'sat': 1, 'on': 1, 'mat': 1}\n", "\nassert count_words_in_sente... |
b8b62e3c9e146c54e0fff38764ebd251 | [
{
"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 ignorant la casse, les espaces, la ponctuation et les caractères spéciaux. Un palindrome est une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :**\n-... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama!\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Not a palindrome\") == False\n", "\nasser... |
42184f8105f99a434f359748c32cd2b5 | [
{
"content": "On te charge d'implémenter une fonction pour déterminer la validité d'une adresse e-mail en fonction d'un modèle standard. Ta fonction doit renvoyer `True` si l'adresse e-mail est valide et `False` sinon. L'adresse e-mail est considérée comme valide si elle correspond au modèle suivant : elle comm... | ["\nassert is_valid_email(\"example@test.com\") == True\n", "\nassert is_valid_email(\"user.name+tag+sorting@example.com\") == True\n", "\nassert is_valid_email(\"user@sub.example.com\") == True\n", "\nassert is_valid_email(\"user@123.123.123.123\") == True\n", "\nassert is_valid_email(\"user@[IPv6:2001:db8::1]\") == F... |
bc77e2bc3040f61269f39db374810753 | [
{
"content": "Étant donnés deux entiers positifs `x` et `y`, détermine s'ils sont premiers entre eux. Deux nombres sont considérés comme premiers entre eux si leur plus grand commun diviseur est 1. Implémente la fonction `is_relatively_prime(x, y)` qui renvoie `True` si `x` et `y` sont premiers entre eux, et `F... | ["\nassert is_relatively_prime(15, 28) == True\n", "\nassert is_relatively_prime(12, 18) == False\n", "\nassert is_relatively_prime(7, 13) == True\n", "\nassert is_relatively_prime(1, 1) == True\n", "\nassert is_relatively_prime(100, 25) == False\n", "\nassert is_relatively_prime(81, 16) == True\n", "\nassert is_relati... |
acc010e67d4f433f4b577a2ba54487cd | [
{
"content": "On te donne une liste de `n` points dans un plan 2D, chacun représenté par une paire de coordonnées `(x, y)`. Ta tâche est de trouver le chemin le plus court possible qui visite chaque point exactement une fois et revient au point de départ. Implémente une fonction `optimize_path` qui utilise l'al... | ["\nassert optimize_path([(0, 0), (1, 1)]) == [(0, 0), (1, 1), (0, 0)]\n", "\nassert optimize_path([(0, 0), (1, 0), (0, 1)]) == [(0, 0), (1, 0), (0, 1), (0, 0)]\n", "\nassert optimize_path([(0, 0), (1, 1), (2, 2), (3, 3)]) == [(0, 0), (1, 1), (2, 2), (3, 3), (0, 0)]\n", "\nassert optimize_path([(0, 0), (1, 0), (1, 1), ... |
a99011e737b1e5c52ba23c8dcbcd724a | [
{
"content": "On te demande d'implémenter une hiérarchie de classes pour gérer les employés et leurs départements au sein d'une entreprise. Ta tâche est de créer une classe de base `Employee` avec les attributs et méthodes suivants :\n\n- **Attributs :**\n - `name` : une chaîne de caractères représentant le no... | ["\nassert Employee(\"John Doe\", \"Developer\", 50000).name == \"John Doe\"\n", "\nassert Employee(\"Jane Smith\", \"Designer\", 60000).position == \"Designer\"\n", "\nassert Employee(\"Alice Johnson\", \"Analyst\", 55000).salary == 55000\n", "\nemp = Employee(\"Bob Brown\", \"Tester\", 45000)\nemp.raise_salary(5000)\... |
2fed832616111367c160817508b865ba | [
{
"content": "On te demande d'implémenter une classe `Book` qui étend une classe existante `Item`. La classe `Book` doit inclure les attributs suivants :\n- `title` : une chaîne de caractères représentant le titre du livre.\n- `author` : une chaîne de caractères représentant l'auteur du livre.\n- `publication_y... | ["\nassert Book(1, \"Aisle 1\", \"1984\", \"George Orwell\", 1949).title == \"1984\"\n", "\nassert Book(2, \"Aisle 2\", \"To Kill a Mockingbird\", \"Harper Lee\", 1960).author == \"Harper Lee\"\n", "\nassert Book(3, \"Aisle 3\", \"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925).publication_year == 1925\n", "\nassert... |
6a823bf8da8f84113eed9042e60872a5 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver tous les quadruplets uniques dans `nums` dont la somme est égale à `target`. Les quadruplets doivent être dans un ordre non décroissant, et aucun quadruplet dupliqué ne doit être inclus dans le résultat.\n\n**En... | ["\nassert four_sum([1, 0, -1, 0, -2, 2], 0) == [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]\n", "\nassert four_sum([1, 2, 3, 4, 5], 10) == [[1, 2, 3, 4]]\n", "\nassert four_sum([0, 0, 0, 0], 0) == [[0, 0, 0, 0]]\n", "\nassert four_sum([1, 2, 3, 4, 5, 6, 7, 8], 16) == [[1, 2, 5, 8], [1, 2, 6, 7], [1, 3, 4, 8], [1, 3,... |
76d5fb4d378386f79546c07ad0aa852a | [
{
"content": "On te donne un arbre binaire et ta tâche est de déterminer s'il est équilibré. Un arbre binaire est considéré comme équilibré si, pour chaque nœud, la différence de hauteur entre ses sous-arbres gauche et droit est au plus égale à 1. Implémente une fonction `is_balanced_binary_tree` qui prend la r... | ["\nassert is_balanced_binary_tree(None) == True\n", "\nassert is_balanced_binary_tree(TreeNode(1)) == True\n", "\nassert is_balanced_binary_tree(TreeNode(1, TreeNode(2))) == True\n", "\nassert is_balanced_binary_tree(TreeNode(1, TreeNode(2), TreeNode(3))) == True\n", "\nassert is_balanced_binary_tree(TreeNode(1, TreeN... |
772385bf82fe4d749a3550df2004af0a | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la paire d'entiers dans la liste qui a la plus petite différence absolue entre eux. Si la liste contient moins de deux entiers, retourne `None`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^3), où chaque entier est... | ["\nassert find_closest_pair([1, 2, 3, 4, 5]) == (1, 2)\n", "\nassert find_closest_pair([10, 22, 28, 29, 30, 40]) == (28, 29)\n", "\nassert find_closest_pair([5, 8, 12, 15, 16]) == (15, 16)\n", "\nassert find_closest_pair([100, 101, 102, 103]) == (100, 101)\n", "\nassert find_closest_pair([1, 1, 1, 1]) == (1, 1)\n", "\... |
caabd90927be7bfebf19e3a0d00c01f9 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente une ligne de texte. Chaque ligne contient trois entiers séparés par des espaces. Ta tâche est d'écrire une fonction qui traite cette liste et renvoie une nouvelle liste contenant uniquement les lignes où le deuxième entier... | ["\nassert filter_lines([\"1 5 3\", \"4 6 2\", \"7 8 10\", \"9 13 4\"]) == ['1 5 3', '4 6 2']\n", "\nassert filter_lines([\"10 15 12\", \"20 25 22\", \"30 35 32\"]) == ['10 15 12', '20 25 22', '30 35 32']\n", "\nassert filter_lines([\"1 2 3\", \"4 5 6\", \"7 8 9\"]) == []\n", "\nassert filter_lines([\"10 11 10\", \"20 ... |
6609f66f89bc95376711d3227403fa4a | [
{
"content": "On te donne un dictionnaire `word_count` où chaque clé est un mot et chaque valeur est le nombre d'occurrences de ce mot. Implémente une fonction `most_frequent_word(word_count)` qui renvoie le mot ayant la fréquence la plus élevée. S'il y a plusieurs mots ayant la même fréquence la plus élevée, r... | ["\nassert most_frequent_word({\"apple\": 4, \"banana\": 2, \"cherry\": 5, \"date\": 3}) == \"cherry\"\n", "\nassert most_frequent_word({\"apple\": 4, \"banana\": 4, \"cherry\": 4, \"date\": 4}) == \"apple\"\n", "\nassert most_frequent_word({\"apple\": 1, \"banana\": 2, \"cherry\": 3, \"date\": 3}) == \"banana\"\n", "\... |
cbe753ea7dce28a8c750f190dc1d1bad | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui trouve la valeur maximale dans la liste en utilisant la récursion. La fonction doit être nommée `find_max`.\n\n**Entrée :**\n- Une liste d'entiers `lst` où `1 <= len(lst) <= 1000` et `-1000 <= lst[i] <= 1000`.\n\n**Sort... | ["\nassert find_max([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 9\n", "\nassert find_max([10, 20, 30, 40, 50]) == 50\n", "\nassert find_max([50, 40, 30, 20, 10]) == 50\n", "\nassert find_max([1]) == 1\n", "\nassert find_max([-1, -2, -3, -4, -5]) == -1\n", "\nassert find_max([0, 0, 0, 0, 0]) == 0\n", "\nassert find_max([100])... |
290227488b7d6ef8c3f4f8e1ede589d8 | [
{
"content": "Dans l'industrie brassicole, la gravité spécifique d'un liquide est une mesure de sa densité par rapport à l'eau, souvent utilisée pour évaluer la teneur en alcool de la bière. Les degrés Plato sont une autre mesure, représentant la concentration de solides dissous dans un liquide. Tu es chargé d'... | ["\nassert plato_to_gravity(0) == 1.0000\n", "\nassert plato_to_gravity(12) == 1.0479\n", "\nassert plato_to_gravity(20) == 1.0842\n", "\nassert plato_to_gravity(30) == 1.1205\n", "\nassert plato_to_gravity(40) == 1.1567\n", "\nassert plato_to_gravity(50) == 1.1928\n", "\nassert plato_to_gravity(-5) == None\n", "\nasse... |
23cdec0f4e4b913f732e413a7741d7f6 | [
{
"content": "On te donne une liste d'entiers `lst` où chaque élément représente un chiffre d'un nombre. Le premier élément de la liste est le chiffre le plus significatif. Si le premier élément est `-1`, cela indique que le nombre est négatif. Ta tâche est d'implémenter une fonction `list_to_num(lst)` qui conv... | ["\nassert list_to_num([1, 2, 3]) == 123\n", "\nassert list_to_num([-1, 1, 2, 3]) == -123\n", "\nassert list_to_num([0]) == 0\n", "\nassert list_to_num([-1, 0]) == 0\n", "\nassert list_to_num([9, 8, 7, 6, 5]) == 98765\n", "\nassert list_to_num([-1, 9, 8, 7, 6, 5]) == -98765\n", "\nassert list_to_num([5]) == 5\n", "\nas... |
27d23dc61c15ad0c16ea9cb7ea8fc55f | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'écrire une fonction Python `find_common_elements` qui identifie et renvoie une liste triée d'entiers uniques qui sont présents dans les deux listes d'entrée. La fonction doit gérer les listes de différentes longueurs et s'assurer que la liste de so... | ["\nassert find_common_elements([1, 2, 3, 4, 5], [3, 4, 5, 6, 7]) == [3, 4, 5]\n", "\nassert find_common_elements([10, 20, 30], [30, 40, 50]) == [30]\n", "\nassert find_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3]... |
b9d7c36b2490d2e84589a1ad4e4c7a75 | [
{
"content": "On te donne un entier positif `num`. Ta tâche est de déterminer si `num` est un nombre premier. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même. Écris une fonction `is_prime(num)` qui renvoie `True` si `num` est un nombre premier, et... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(9) == False\n", "\nassert is_prime(11) == True\n", "\nassert is_prime(15) == False\n", "\nassert is_prime(17) == True\n", "\nassert is_prime(1) == False\n", "\nass... |
66453c89a0b3f7dd2ac7d8566b5719cc | [
{
"content": "Tu es chargé d'implémenter une fonction pour simuler un lancer de dé. Ta fonction doit générer un entier aléatoire entre 1 et 6, inclusivement. Si une valeur de départ est fournie en argument, la fonction doit utiliser cette valeur pour initialiser le générateur de nombres aléatoires, assurant ain... | ["\nassert roll_dice() in range(1, 7)\n", "\nassert roll_dice(1) == 2\n", "\nassert roll_dice(2) == 8 % 7 + 1\n", "\nassert roll_dice(3) == 4\n", "\nassert roll_dice(4) == 5\n", "\nassert roll_dice(5) == 6\n", "\nassert roll_dice(6) == 1\n", "\nassert roll_dice(7) == 2\n", "\nassert roll_dice(10) == 5\n", "\nassert rol... |
20011c99a93f21fb1b78fa43dd0b7d4f | [
{
"content": "On te donne un graphe orienté avec des arêtes pondérées. Le graphe est représenté comme un dictionnaire où chaque clé est un nœud et la valeur correspondante est une liste de tuples. Chaque tuple contient un nœud qui peut être directement atteint à partir du nœud clé et le coût pour atteindre ce n... | ["\nassert find_all_paths({'A': [('B', 1), ('C', 2)], 'B': [('C', 2)], 'C': []}, 'A', 'C') == [(['A', 'B', 'C'], 3), (['A', 'C'], 2)]\n", "\nassert find_all_paths({'A': [('B', 1)], 'B': [('C', 2)], 'C': [('D', 3)], 'D': []}, 'A', 'D') == [(['A', 'B', 'C', 'D'], 6)]\n", "\nassert find_all_paths({'A': [('B', 1), ('C', 2)... |
bf036ed9bb0abe24cb8b8dd913665fd2 | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est de générer toutes les permutations possibles de cette chaîne en utilisant une approche récursive. Implémente une fonction `generate_permutations` qui prend une chaîne `s` en entrée et renvoie une liste de toutes les permutations. La foncti... | ["\nassert generate_permutations(\"abc\") == ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']\n", "\nassert generate_permutations(\"a\") == ['a']\n", "\nassert generate_permutations(\"\") == ['']\n", "\nassert generate_permutations(\"ab\") == ['ab', 'ba']\n", "\nassert generate_permutations(\"123\") == ['123', '132', '213', ... |
7ec31dfc7d140ef997c895faabfef87d | [
{
"content": "On te donne une chaîne de caractères `s` composée des caractères '(', ')', '[', ']', '{', et '}'. Ta tâche est de déterminer si la chaîne est équilibrée. Une chaîne est considérée comme équilibrée si chaque parenthèse ouvrante a une parenthèse fermante correspondante et qu'elles sont correctement ... | ["\nassert is_balanced(\"{[()]}\") == True\n", "\nassert is_balanced(\"{[(])}\") == False\n", "\nassert is_balanced(\"{{[[(())]]}}\") == True\n", "\nassert is_balanced(\"()[]{}\") == True\n", "\nassert is_balanced(\"([)]\") == False\n", "\nassert is_balanced(\"{[}\") == False\n", "\nassert is_balanced(\"\") == True\n",... |
83bca0b5ec599567dbc53edcf43fcc3e | [
{
"content": "On te donne une structure de répertoires avec plusieurs sous-répertoires. Chaque sous-répertoire peut contenir un ou plusieurs fichiers avec l'extension `.txt`. Ta tâche est de mettre en œuvre une fonction qui identifie tous les sous-répertoires contenant au moins un fichier `.txt` non vide qui a ... | ["\nassert get_recently_modified_txt_subdirs(\"/path/to/empty/directory\") == []\n", "\nassert get_recently_modified_txt_subdirs(\"/path/to/directory/with/empty/txt\") == []\n", "\nassert get_recently_modified_txt_subdirs(\"/path/to/directory/with/recent/txt\") == [\"/path/to/directory/with/recent\"]\n", "\nassert get_... |
c49019254be51fa84df63dfc39889183 | [
{
"content": "On te donne une liste de noms de fichiers, chacun contenant un identifiant à 6 chiffres qui représente un numéro d'orbite de satellite. Ta tâche est d'écrire une fonction `organize_filenames_by_orbit` qui prend cette liste de noms de fichiers en entrée et renvoie un dictionnaire. Le dictionnaire d... | ["\nassert organize_filenames_by_orbit([\"satellite_data_001234.txt\"]) == {\"001234\": [\"satellite_data_001234.txt\"]}\n", "\nassert organize_filenames_by_orbit([\"satellite_orbit_567890_report.csv\"]) == {\"567890\": [\"satellite_orbit_567890_report.csv\"]}\n", "\nassert organize_filenames_by_orbit([\"098765_satelli... |
381d95a6869434a21f25dbca4b18fbbd | [
{
"content": "On te donne deux ensembles de points dans un espace de dimension D, représentés sous forme de deux tenseurs `pts1` et `pts2`. Le tenseur `pts1` a la forme `[M x D]`, où `M` est le nombre de points dans le premier ensemble et `D` est la dimensionnalité de l'espace. De même, `pts2` a la forme `[N x ... | ["\nassert torch.equal(chebyshev_distance_matrix(torch.tensor([[1, 2]]), torch.tensor([[3, 4]])), torch.tensor([[2]]))\n", "\nassert torch.equal(chebyshev_distance_matrix(torch.tensor([[0, 0], [1, 1]]), torch.tensor([[1, 1], [0, 0]])), torch.tensor([[1, 1], [1, 1]]))\n", "\nassert torch.equal(chebyshev_distance_matrix(... |
afe36f5d04daaab7e7dd714ce0c6a49c | [
{
"content": "Implémente une structure de données pile en Python. Ta pile doit prendre en charge les opérations suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élément au sommet de la pile. Si la pile est vide, lève une exception `IndexError`.\n- `peek()`... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().size() == 0\n", "\ns = Stack(); s.push(1); assert s.peek() == 1\n", "\ns = Stack(); s.push(1); s.push(2); assert s.pop() == 2\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.size() == 1\n", "\ns = Stack(); s.push(1); s.push(2); s.push(3); assert s.... |
1905d474763ca0d75a51a8e9e69da53e | [
{
"content": "On te donne un fichier contenant une liste de livres, où chaque ligne est formatée comme `<titre du livre> [ISBN: <numéro>] : <auteur>`. Ta tâche est d'écrire une fonction qui lit ce fichier et construit un dictionnaire. Les clés du dictionnaire doivent être les numéros ISBN, et les valeurs doiven... | ["\nassert parse_books_file('test1.txt') == {'1234567890': 'Author A'}\n", "\nassert parse_books_file('test2.txt') == {'0987654321': 'Author B', '1111111111': 'Author C'}\n", "\nassert parse_books_file('test3.txt') == {'2222222222': 'Author D', '3333333333': 'Author E', '4444444444': 'Author F'}\n", "\nassert parse_boo... |
a0f520c8520bb01a1cafda2f6f9afcd8 | [
{
"content": "On te donne une chaîne de caractères `S` et deux sous-chaînes `A` et `B`. Ta tâche est d'écrire une fonction qui remplace toutes les occurrences de `A` dans `S` par `B`. La fonction doit gérer les cas limites tels que les chaînes ou sous-chaînes vides.\n\n**Entrée :**\n- La première ligne contient... | ["\nassert replace_substring(\"hello world\", \"world\", \"planet\") == \"hello planet\"\n", "\nassert replace_substring(\"hello world\", \"hello\", \"hi\") == \"hi world\"\n", "\nassert replace_substring(\"hello world\", \"o\", \"a\") == \"hella warld\"\n", "\nassert replace_substring(\"hello world\", \"l\", \"x\") ==... |
7663f0027b30a0816b27d7ea5b3475bd | [
{
"content": "On te donne la tâche d'écrire un programme qui lit un fichier CSV nommé `students.csv` et calcule la moyenne des notes de tous les étudiants. Le fichier CSV contient trois colonnes : `student_id`, `name` et `grade`. Ton programme doit afficher la moyenne des notes formatée à deux décimales. Si le ... | ["\nassert calculate_average_grade('non_existent_file.csv') == None # This will print an error message, but we're checking for no return value\n", "\nassert calculate_average_grade('empty_file.csv') == None # Assuming empty_file.csv is an empty file, should print \"No valid grades found in the CSV file.\"\n", "\nasse... |
88b2dc49eea41bcc58e28d298419389d | [
{
"content": "On te demande d'implémenter une fonction efficace `get_items` pour traiter un grand ensemble de données d'éléments. Chaque élément est représenté comme un dictionnaire avec les clés `'name'` et `'type'`. Ta fonction doit accepter trois paramètres : une liste de tous les éléments, une chaîne de car... | ["\nassert get_items([{'name': 'apple', 'type': 'fruit'}, {'name': 'banana', 'type': 'fruit'}], 'fruit') == [{'name': 'apple', 'type': 'fruit'}, {'name': 'banana', 'type': 'fruit'}]\n", "\nassert get_items([{'name': 'apple', 'type': 'fruit'}, {'name': 'banana', 'type': 'fruit'}], 'fruit', ['apple']) == [{'name': 'apple... |
81d905ba59d135b314f7dbd7f86569bf | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif. La factorielle d'un entier non négatif \\( n \\) est le produit de tous les entiers positifs inférieurs ou égaux à \\( n \\). La factorielle de 0 est définie comme étant 1.\n\n**Entrée :**\n- U... | ["\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... |
520d2d83d5c00f410f264150073fd521 | [
{
"content": "On te donne un arbre binaire représenté sous forme de liste imbriquée de la forme `[racine, [sous_arbre_gauche], [sous_arbre_droit]]`, où chaque sous-arbre est également représenté de la même manière. Ta tâche est de mettre en œuvre une fonction qui effectue un parcours en largeur de l'arbre et re... | ["\nassert level_order_traversal([1, [2, [4], [5]], [3, [6], [7]]]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert level_order_traversal([1, [2, None, None], [3, None, None]]) == [1, 2, 3]\n", "\nassert level_order_traversal([1, None, [3, None, [7]]]) == [1, 3, 7]\n", "\nassert level_order_traversal([1, [2, [4, [8], None], [5]... |
2aaa86138da501da9c22917d15986144 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction Python qui génère toutes les permutations uniques de la chaîne `s`. La fonction doit renvoyer une liste de ces permutations. Note que l'ordre des permutations dans la liste de sortie n'a pas d'importance.\n\n**Exemple d'e... | ["\nassert find_unique_permutations(\"abc\") == ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']\n", "\nassert find_unique_permutations(\"a\") == ['a']\n", "\nassert find_unique_permutations(\"ab\") == ['ab', 'ba']\n", "\nassert find_unique_permutations(\"aabb\") == ['aabb', 'abab', 'abba', 'baab', 'baba', 'bbaa']\n", "\nass... |
28e6ef5654dfcf9609af2d6cbac96548 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de calculer l'inverse modulaire multiplicatif pour chaque paire d'entiers `(e, phi)` où `1 <= e, phi <= n`. L'inverse modulaire multiplicatif de `e` par rapport à `phi` est un entier `d` tel que `(e * d) % phi == 1`. Si l'inverse n'existe pas, renvoi... | ["\nassert find_modular_inverse(3, 11) == 4\n", "\nassert find_modular_inverse(10, 17) == 12\n", "\nassert find_modular_inverse(7, 26) == 15\n", "\nassert find_modular_inverse(10, 20) == None\n", "\nassert find_modular_inverse(1, 1) == 1\n", "\nassert find_modular_inverse(5, 8) == 5\n", "\nassert find_modular_inverse(1... |
4d01d2551941396fc1d49390e4ad5d66 | [
{
"content": "On te donne une version tournée d'une liste triée de chaînes de caractères `words` et une chaîne cible `target`. Ta tâche est de mettre en œuvre une fonction `find_target_in_rotated_list` qui renvoie l'index de la chaîne `target` dans la liste `words` si elle existe, sinon renvoie `-1`. La fonctio... | ["\nassert find_target_in_rotated_list([\"d\", \"e\", \"f\", \"a\", \"b\", \"c\"], \"b\") == 4\n", "\nassert find_target_in_rotated_list([\"d\", \"e\", \"f\", \"a\", \"b\", \"c\"], \"d\") == 0\n", "\nassert find_target_in_rotated_list([\"d\", \"e\", \"f\", \"a\", \"b\", \"c\"], \"c\") == 5\n", "\nassert find_target_in_... |
a3812a6f03d700dd77c3de1aa4be422a | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'un langage de programmation et de son numéro de version. La liste est triée par ordre décroissant des numéros de version pour chaque langage. Ta tâche est d'écrire une fonction qui renvoie un dictionnaire avec les langages de programma... | ["\nassert get_latest_versions([(\"Python\", \"3.8.5\"), (\"Python\", \"3.7.6\")]) == {\"Python\": \"3.8.5\"}\n", "\nassert get_latest_versions([(\"Java\", \"11.0.9\"), (\"Java\", \"1.8.0_261\")]) == {\"Java\": \"11.0.9\"}\n", "\nassert get_latest_versions([(\"C++\", \"10.2.0\"), (\"C++\", \"9.3.0\")]) == {\"C++\": \"1... |
b37cff6bb39b3f514a405667e10573e4 | [
{
"content": "On te demande d'implémenter une fonction `apply_if_valid` qui traite une valeur donnée en fonction d'une vérification de validation. La fonction doit appliquer une transformation si la valeur passe la validation ; sinon, elle doit renvoyer la valeur inchangée. Ton implémentation doit également s'a... | ["\nassert apply_if_valid(lambda x: x + 1, 5, lambda x: x > 0) == 6\n", "\nassert apply_if_valid(lambda x: x * 2, 10, lambda x: x % 2 == 0) == 20\n", "\nassert apply_if_valid(lambda x: x - 3, 7, lambda x: x < 10) == 4\n", "\nassert apply_if_valid(lambda x: x.upper(), \"hello\", lambda x: isinstance(x, str)) == \"HELLO\... |
052f27f8459cf7b04cb4f5f0d07d79be | [
{
"content": "On te donne un modèle simplifié d'un réseau de communication composé de `N` nœuds et d'une matrice de probabilité `P` de taille `N x N`. Chaque élément `P[i][j]` représente la probabilité qu'un lien existe entre les nœuds `i` et `j`. Ta tâche est de simuler le réseau et de déterminer quels liens e... | ["\nassert generate_network([1, 2], [[0.0, 0.0], [0.0, 0.0]]) == ([], 0.0)\n", "\nassert generate_network([1, 2], [[0.0, 1.0], [1.0, 0.0]])[1] >= 1.0 and generate_network([1, 2], [[0.0, 1.0], [1.0, 0.0]])[1] <= 3.0\n", "\nassert generate_network([1, 2, 3], [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]) == ([], 0.... |
866510aa2333654b13081e73c028e1f2 | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction qui renvoie le deuxième plus grand nombre unique de la liste. Si la liste contient moins de deux nombres uniques, la fonction doit renvoyer `None`. La solution doit être efficace, avec une complexité temporelle ... | ["\nassert second_largest([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 6\n", "\nassert second_largest([1, 1, 1, 1]) == None\n", "\nassert second_largest([10]) == None\n", "\nassert second_largest([5, 5, 5, 5, 5, 5, 5, 5, 5, 5]) == None\n", "\nassert second_largest([1, 2]) == 1\n", "\nassert second_largest([10, 20]) == 10\n", ... |
2b3a90077f5bc13ee6d80281ae8b3265 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n- `deposit(amount)` : ajoute le montant spécifié au solde du compte. Le montant doit être positif.\n- `withdraw(amount)` : soustrait le montant spécifié du solde du compte s... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount().__str__() == \"Current balance: 0\"\n", "\naccount = BankAccount(); account.deposit(100); assert account.get_balance() == 100\n", "\naccount = BankAccount(); account.deposit(100); account.deposit(50); assert account.get_balance() == 150\n", "\nacco... |
4d5a9e0418a558540d6643b85dab67e3 | [
{
"content": "On te donne un fichier texte nommé `songs.txt` qui contient une liste de noms de chansons, un par ligne. Chaque nom de chanson est représenté par un code unique de deux caractères. Ta tâche est de créer une fonction qui génère une liste de chemins de fichiers pour les données de chaque chanson, qu... | ["\nassert generate_track_paths('songs.txt', 'tracks') == ['tracks/trackAB.txt', 'tracks/trackCD.txt']\n", "\nassert generate_track_paths('songs.txt', 'tracks') == []\n", "\nassert generate_track_paths('songs.txt', 'tracks') == ['tracks/trackEF.txt']\n", "\nassert generate_track_paths('songs.txt', 'tracks') == ['tracks... |
d210bc40ee9c8f339c0ab07620b59813 | [
{
"content": "On te demande d'implémenter une fonction pour aplatir un objet de configuration JSON imbriqué en un dictionnaire à un seul niveau. Les clés dans le dictionnaire résultant doivent être les chemins concaténés des clés d'origine, séparés par des points. Par exemple, étant donné l'entrée `{\"model\": ... | ["\nassert flatten_json({\"model\": {\"type\": \"logistic_regression\", \"params\": {\"C\": 1.0}}}) == {\"model.type\": \"logistic_regression\", \"model.params.C\": 1.0}\n", "\nassert flatten_json({\"a\": 1, \"b\": {\"c\": 2, \"d\": {\"e\": 3}}}) == {\"a\": 1, \"b.c\": 2, \"b.d.e\": 3}\n", "\nassert flatten_json({\"x\"... |
727abdd8679307042157acc32eb4eb80 | [
{
"content": "On te donne deux listes : `strings` contenant `n` chaînes de caractères et `indices` contenant `n` entiers. Ta tâche est de mettre en œuvre une fonction `select_substrings(strings, indices)` qui renvoie une liste de sous-chaînes. Chaque sous-chaîne est dérivée de la chaîne de caractères correspond... | ["\nassert select_substrings([\"hello\", \"world\", \"test\"], [1, 3, 0]) == [\"ello\", \"rld\", \"test\"]\n", "\nassert select_substrings([\"abc\", \"def\", \"ghi\"], [0, 1, 2]) == [\"abc\", \"ef\", \"i\"]\n", "\nassert select_substrings([\"abc\", \"def\", \"ghi\"], [3, 3, 3]) == [\"\", \"\", \"\"]\n", "\nassert selec... |
7db26324d982ec89cac65b99b9d34948 | [
{
"content": "Écris un programme Python pour générer et afficher tous les nombres premiers dans la plage de 1 à 100 inclus. Ton programme doit afficher la liste des nombres premiers par ordre croissant.\n\n**Exemple de sortie :**\n```\n[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,... | ["\nassert generate_primes_up_to_100() == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n", "\nassert 2 in generate_primes_up_to_100()\n", "\nassert 100 not in generate_primes_up_to_100()\n", "\nassert 1 not in generate_primes_up_to_100()\n", "\nassert 97 in generate_p... |
489750661ebaa10046c680f3a194deb9 | [
{
"content": "On te donne une matrice binaire 2D `matrix` de taille `n x m`, où chaque ligne représente un élément et chaque colonne représente une caractéristique. Un '1' dans la matrice indique que l'élément possède la caractéristique correspondante, tandis qu'un '0' indique qu'il ne la possède pas. Ta tâche ... | ["\nassert find_unique_features([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == [0, 1, 2]\n", "\nassert find_unique_features([[1, 1, 0], [1, 0, 1], [0, 1, 1]]) == [0, 1, 2]\n", "\nassert find_unique_features([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) == [0, 0, 0]\n", "\nassert find_unique_features([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == [... |
5af5566db8d58bba7cc3b17f8f8909fc | [
{
"content": "On te donne une liste d'entiers représentant les températures quotidiennes d'une ville sur une période donnée. Ta tâche est d'écrire une fonction qui calcule la différence absolue entre les températures de chaque paire de jours consécutifs. La fonction doit gérer les listes de différentes longueur... | ["\nassert daily_temp_diff([15, 20, 25, 30, 28, 22, 18]) == [5, 5, 5, 2, 6, 4]\n", "\nassert daily_temp_diff([30, 25, 20, 15, 10, 5, 0]) == [5, 5, 5, 5, 5, 5]\n", "\nassert daily_temp_diff([-10, -20, -30, -25, -15, -5, 0]) == [10, 10, 5, 10, 10, 5]\n", "\nassert daily_temp_diff([0, 0, 0, 0, 0, 0, 0]) == [0, 0, 0, 0, 0,... |
ef8d72600b54a1c4d6f8356371843552 | [
{
"content": "Étant donné une chaîne de caractères `s`, écris une fonction `count_unique_characters` qui renvoie une liste de tuples. Chaque tuple contient un caractère alphabétique unique de la chaîne (sans tenir compte de la casse) et son nombre d'occurrences. La liste doit être triée par ordre alphabétique d... | ["\nassert count_unique_characters(\"Hello World!\") == [('d', 1), ('e', 1), ('h', 1), ('l', 3), ('o', 2), ('r', 1), ('w', 1)]\n", "\nassert count_unique_characters(\"AaBbCc\") == [('a', 2), ('b', 2), ('c', 2)]\n", "\nassert count_unique_characters(\"Python Programming!\") == [('a', 1), ('g', 2), ('h', 1), ('i', 1), ('... |
fd8412e573eb54964a3ac94ed4a5855e | [
{
"content": "On te donne un fichier CSV nommé `data.csv` situé dans le même répertoire que ton programme. Ta tâche est d'écrire un programme qui lit ce fichier et affiche le nombre total de lignes (sans inclure l'en-tête) et le nombre total de colonnes. La première ligne du fichier CSV est l'en-tête et ne doit... | ["\nassert count_rows_and_columns('data.csv') == None\n", "\nassert count_rows_and_columns('empty.csv') == None\n", "\nassert count_rows_and_columns('single_row.csv') == None\n", "\nassert count_rows_and_columns('single_column.csv') == None\n", "\nassert count_rows_and_columns('multiple_rows_columns.csv') == None\n", "... |
a2b66cae2ab67392170c75239afcef13 | [
{
"content": "On te demande d'écrire un programme qui génère un ensemble d'entiers aléatoires uniques dans une plage donnée. Ton programme doit accepter trois paramètres : le début et la fin de la plage, et le nombre d'entiers uniques à générer. Assure-toi que les entiers générés sont dans la plage spécifiée et... | ["\nassert len(generate_unique_random_numbers(1, 10, 5)) == 5\n", "\nassert all(isinstance(num, int) for num in generate_unique_random_numbers(1, 10, 5))\n", "\nassert len(set(generate_unique_random_numbers(1, 10, 5))) == 5\n", "\nassert all(1 <= num <= 10 for num in generate_unique_random_numbers(1, 10, 5))\n", "\nass... |
866f126be30ed750f8118149e8d70592 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci efficacement. Pour ce faire, ta fonction doit utiliser la mémoïsation pour éviter les calculs redondants. Ta solution ne doit pas dépendre d'aucune bibliothèque ou module externe.\n\n**Entrée :**\n- Un entier `n` (... | ["\nassert calculate_fibonacci_sequence(0) == 0\n", "\nassert calculate_fibonacci_sequence(1) == 1\n", "\nassert calculate_fibonacci_sequence(2) == 1\n", "\nassert calculate_fibonacci_sequence(3) == 2\n", "\nassert calculate_fibonacci_sequence(4) == 3\n", "\nassert calculate_fibonacci_sequence(5) == 5\n", "\nassert cal... |
9ca22654d43b27f21354532919d88988 | [
{
"content": "On te donne un objet JSON sous forme de chaîne de caractères où toutes les valeurs sont uniques. Ta tâche est d'écrire une fonction Python qui renvoie un nouvel objet JSON sous forme de chaîne de caractères où chaque paire clé-valeur est inversée, c'est-à-dire que les clés deviennent des valeurs e... | ["\nassert reverse_json('{\"a\": \"1\", \"b\": \"2\"}') == '{\"1\": \"a\", \"2\": \"b\"}'\n", "\nassert reverse_json('{\"name\": \"John\", \"age\": \"30\"}') == '{\"John\": \"name\", \"30\": \"age\"}'\n", "\nassert reverse_json('{\"key1\": \"value1\", \"key2\": \"value2\", \"key3\": \"value3\"}') == '{\"value1\": \"key... |
6c14a21db21d12b8e2835ddf1bf37e9a | [
{
"content": "On te donne une date au format du calendrier grégorien, composée d'une année, d'un mois et d'un jour. Ta tâche est d'écrire une fonction `gregorian_to_modified_julian_day` qui convertit cette date en Jour Julien Modifié (MJD). Suppose que l'heure est minuit (00:00:00) et ignore les secondes interc... | ["\nassert gregorian_to_modified_julian_day(2000, 1, 1) == 51544.0\n", "\nassert gregorian_to_modified_julian_day(1970, 1, 1) == 40587.0\n", "\nassert gregorian_to_modified_julian_day(2023, 10, 5) == 59859.0\n", "\nassert gregorian_to_modified_julian_day(2020, 2, 29) == 58849.0\n", "\nassert gregorian_to_modified_julia... |
b0b7cbb0a42787515c11755e441e9158 | [
{
"content": "On te donne une chaîne de caractères `s` composée de plusieurs phrases. Chaque phrase se termine par un point (.), un point d'exclamation (!) ou un point d'interrogation (?). Les phrases peuvent être séparées par un ou plusieurs espaces. Ta tâche est de mettre en œuvre une fonction `split_sentence... | ["\nassert split_sentences(\"Hello world! This is a test. How are you today?\") == [\"Hello world!\", \"This is a test.\", \"How are you today?\"]\n", "\nassert split_sentences(\"This is a sentence. And another one!\") == [\"This is a sentence.\", \"And another one!\"]\n", "\nassert split_sentences(\"No punctuation her... |
d1bd5d44bc502b0bc7105b9ef8bade1d | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `count_even_digits(n)` qui renvoie le nombre de chiffres pairs dans `n`. Tu n'es pas autorisé à convertir `n` en chaîne de caractères ou à utiliser des fonctions intégrées qui extraient directement les chiffres.\n\n**Contraintes :**\n- ... | ["\nassert count_digits(123456) == 3\n", "\nassert count_digits(-2468) == 4\n", "\nassert count_digits(13579) == 0\n", "\nassert count_digits(0) == 1\n", "\nassert count_digits(222222) == 6\n", "\nassert count_digits(111111) == 0\n", "\nassert count_digits(1020304050) == 5\n", "\nassert count_digits(-111222333) == 3\n"... |
782ae1893390198417ce514286b54b1d | [
{
"content": "On te donne une chaîne de caractères `hex_string` composée de chiffres hexadécimaux (0-9, a-f, A-F). Ta tâche est de convertir cette chaîne en une représentation ASCII. Chaque paire de chiffres hexadécimaux doit être convertie en son caractère ASCII correspondant. Si la longueur de `hex_string` es... | ["\nassert hex_to_ascii_art('48656c6c6f') == 'H|e|l|l|o'\n", "\nassert hex_to_ascii_art('48656c6c6f77') == 'H|e|l|l|o|w'\n", "\nassert hex_to_ascii_art('48656c6c6f7') == 'H|e|l|l|o|w'\n", "\nassert hex_to_ascii_art('') == ''\n", "\nassert hex_to_ascii_art('41') == 'A'\n", "\nassert hex_to_ascii_art('414243') == 'A|B|C'... |
bbd522cc41e8d5a7f603ca3efc90a486 | [
{
"content": "On te donne un arbre binaire représenté comme une liste de tuples, où chaque tuple `(valeur, enfant_gauche, enfant_droit)` décrit un nœud dans l'arbre. Les indices des nœuds sont basés sur 0, et `-1` indique l'absence d'un enfant (c'est-à-dire un nœud feuille). Ta tâche est de mettre en œuvre une ... | ["\nassert replace_leaf_value([(1, -1, -1)], 1, 2) is None and tree == [(2, -1, -1)]\n", "\nassert replace_leaf_value([(1, 1, -1), (2, -1, -1)], 2, 3) is None and tree == [(1, 1, -1), (3, -1, -1)]\n", "\nassert replace_leaf_value([(1, 1, 2), (2, -1, -1), (3, -1, -1)], 2, 4) is None and tree == [(1, 1, 2), (4, -1, -1), ... |
1b456ca07e7f6d493464b5bc3e1586e5 | [
{
"content": "On te demande de refactoriser une fonction Python donnée pour améliorer sa lisibilité et sa maintenabilité. La fonction calcule la somme des carrés des `n` premiers nombres naturels. Ton objectif est de réécrire la fonction avec des conventions de nommage appropriées, une indentation et un espacem... | ["\nassert sum_of_squares(1) == 1\n", "\nassert sum_of_squares(2) == 5\n", "\nassert sum_of_squares(3) == 14\n", "\nassert sum_of_squares(4) == 30\n", "\nassert sum_of_squares(5) == 55\n", "\nassert sum_of_squares(10) == 385\n", "\nassert sum_of_squares(0) == 0\n", "\nassert sum_of_squares(100) == 338350\n", "\nassert ... |
dcde94b6f3bdff75f07ba2685486beeb | [
{
"content": "On te donne une liste de nombres. Ton objectif est d'écrire une fonction Python qui calcule et renvoie la moyenne, la médiane et le mode de la liste. La fonction doit gérer la validation des entrées pour s'assurer que l'entrée est une liste de nombres. Si l'entrée est invalide, la fonction doit le... | ["\nassert calculate_statistics([1, 2, 2, 3, 4, 5, 5, 5, 6]) == None\n", "\nassert calculate_statistics([1, 1, 1, 1, 1]) == None\n", "\nassert calculate_statistics([1, 2, 3, 4, 5]) == None\n", "\nassert calculate_statistics([5]) == None\n", "\nassert calculate_statistics([1, 2, 2, 3, 4, 4]) == None\n", "\nassert calcul... |
44e851a4fb4f41fe63e47c4ecc36d1e5 | [
{
"content": "On te demande d'implémenter une classe `Circle` en Python. La classe doit avoir les fonctionnalités suivantes :\n- Un constructeur qui initialise le cercle avec un rayon donné.\n- Une méthode pour calculer et renvoyer l'aire du cercle.\n- Une méthode pour afficher les détails du cercle, y compris ... | ["\nassert Circle(1).calculate_area() == math.pi\n", "\nassert Circle(0.5).calculate_area() == math.pi * 0.25\n", "\nassert Circle(10).calculate_area() == math.pi * 100\n", "\nassert Circle(2.5).calculate_area() == math.pi * 6.25\n", "\ntry:\n Circle(-1)\nexcept ValueError as e:\n assert str(e) == \"Radius must b... |
f40d7d102378eefded432ddffcba20e6 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui supprime tous les éléments dupliqués de la liste et renvoie une nouvelle liste contenant uniquement les éléments uniques dans leur ordre d'apparition initial.\n\n**Entrée :**\n- Une liste d'entiers, `input_list`.\n\... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([5, 4, 3, 2, 1]) == [5, 4, 3, 2, 1]\n", "\nass... |
1191e09faa899f77dc5642bae7b40262 | [
{
"content": "On te donne un fichier texte nommé `names.txt` contenant une liste de noms, un par ligne. Ta tâche est d'écrire un script Python qui lit ce fichier, compte le nombre de noms commençant par chaque lettre (sans tenir compte de la casse), et affiche les résultats par ordre alphabétique des lettres. S... | ["\nassert count_names_by_starting_letter('names1.txt') == None\n", "\nassert count_names_by_starting_letter('names2.txt') == None\n", "\nassert count_names_by_starting_letter('empty.txt') == None\n", "\nassert count_names_by_starting_letter('single_name.txt') == None\n", "\nassert count_names_by_starting_letter('multi... |
75925c01a0ae229b48c8abcbfa420eb3 | [
{
"content": "On te donne trois entiers positifs : `a`, `n` et `m`. Ta tâche est de calculer `a` élevé à la puissance `n`, modulo `m`, en utilisant la méthode de l'exponentiation binaire. La méthode de l'exponentiation binaire consiste à exprimer l'exposant sous forme binaire et à mettre au carré et à multiplie... | ["\nassert binary_exponentiation(2, 10, 1000) == 24\n", "\nassert binary_exponentiation(3, 13, 50) == 27\n", "\nassert binary_exponentiation(5, 0, 7) == 1\n", "\nassert binary_exponentiation(7, 3, 11) == 2\n", "\nassert binary_exponentiation(10, 5, 13) == 10\n", "\nassert binary_exponentiation(123456789, 2, 1000000007)... |
bb4bd207603142f51bc1556ad3bc8ff2 | [
{
"content": "On te donne une fonction `f` et une liste imbriquée `collection`. Ta tâche est d'implémenter la fonction `reduce_r` qui applique récursivement la fonction `f` à tous les éléments de la `collection`, quel que soit leur niveau d'imbrication. La fonction `f` prend deux arguments et renvoie une seule ... | ["\nassert reduce_r(lambda x, y: x + y, [1, [2, 3], [4, [5, 6]]]) == 21\n", "\nassert reduce_r(lambda x, y: x * y, [1, [2, 3], [4, [5, 6]]]) == 720\n", "\nassert reduce_r(lambda x, y: x - y, [10, [5, 3], [2, [1]]]) == 0\n", "\nassert reduce_r(lambda x, y: x + y, [1]) == 1\n", "\nassert reduce_r(lambda x, y: x + y, [[1,... |
2c8e4b015cf285a89f580de38d30acf2 | [
{
"content": "On te donne un tableau d'entiers `nums` de longueur `n`. Ta tâche est de trouver un élément qui apparaît plus de `n/3` fois dans le tableau. Si aucun élément de ce type n'existe, retourne `-1`. Tu dois résoudre ce problème en temps O(n) et en espace O(1) sans modifier le tableau d'entrée ni utilis... | ["\nassert find_majority_element([3, 3, 4, 2, 3, 3, 3, 4, 4, 4, 4]) == 4\n", "\nassert find_majority_element([1, 2, 3, 1, 1]) == 1\n", "\nassert find_majority_element([1, 2, 3, 4, 5]) == -1\n", "\nassert find_majority_element([1, 1, 1, 2, 2, 2, 2]) == 2\n", "\nassert find_majority_element([10, 10, 10, 10, 10, 5, 5, 5, ... |
f920f934da72acceb95c8d7be6af90b8 | [
{
"content": "On te demande d'implémenter une fonction nommée `is_documentation_file` qui détermine si un nom de fichier donné est un fichier de documentation en fonction de son extension. La fonction doit d'abord vérifier si le nom de fichier contient des caractères numériques. Si c'est le cas, la fonction doi... | ["\nassert is_documentation_file(\"README.md\") == True\n", "\nassert is_documentation_file(\"documentation.RST\") == True\n", "\nassert is_documentation_file(\"file1.md\") == False\n", "\nassert is_documentation_file(\"file_2.rst\") == False\n", "\nassert is_documentation_file(\"notes.md\") == True\n", "\nassert is_do... |
b6ef1c71a95d414430fbc2a99910acd0 | [
{
"content": "On te demande de développer une fonction `count_words` pour un outil d'analyse de texte. Étant donné un chemin de fichier vers un fichier texte brut, ta fonction doit renvoyer un dictionnaire avec la fréquence de chaque mot, en excluant les mots vides courants et en traitant tous les mots en minus... | ["\nassert count_words(\"test1.txt\") == {\"hello\": 1, \"world\": 1}\n", "\nassert count_words(\"test2.txt\") == {\"python\": 2, \"programming\": 1}\n", "\nassert count_words(\"test3.txt\") == {\"code\": 3, \"example\": 1}\n", "\nassert count_words(\"test4.txt\") == {\"test\": 4, \"file\": 1}\n", "\nassert count_words... |
a2bf2a997b08b65be2f3ba307a001da6 | [
{
"content": "On te demande d'implémenter une fonction pour trouver le n-ième nombre premier. La fonction doit déterminer efficacement le nombre premier à la position spécifiée dans la séquence des nombres premiers. Par exemple, le 1er nombre premier est 2, le 2ème est 3, le 3ème est 5, et ainsi de suite.\n\n**... | ["\nassert get_nth_prime(1) == 2\n", "\nassert get_nth_prime(2) == 3\n", "\nassert get_nth_prime(3) == 5\n", "\nassert get_nth_prime(4) == 7\n", "\nassert get_nth_prime(5) == 11\n", "\nassert get_nth_prime(6) == 13\n", "\nassert get_nth_prime(10) == 29\n", "\nassert get_nth_prime(20) == 71\n", "\nassert get_nth_prime(5... |
487e68280c3ecc458470df153a44fe57 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci dans une séquence définie comme suit :\n- Le premier nombre de Fibonacci (F1) est 1.\n- Le deuxième nombre de Fibonacci (F2) est 1.\n- Pour n > 2, le nième nombre de Fibonacci (Fn) est la somme des deux nombres pré... | ["\nassert calculate_fibonacci_sequence(1) == 1\n", "\nassert calculate_fibonacci_sequence(2) == 1\n", "\nassert calculate_fibonacci_sequence(3) == 2\n", "\nassert calculate_fibonacci_sequence(4) == 3\n", "\nassert calculate_fibonacci_sequence(5) == 5\n", "\nassert calculate_fibonacci_sequence(6) == 8\n", "\nassert cal... |
f1a8402266b9114a12272abc9fd8ff9f | [
{
"content": "On te charge d'implémenter un système pour calculer les scores z des ventes quotidiennes d'un produit dans un magasin. Le système doit être capable de gérer des données en flux continu, en mettant à jour les scores z de manière incrémentale à l'arrivée de nouvelles données de ventes. Le score z po... | ["\nassert online_calculator.get_z_scores() == [0.0, 0.7071067811865475, -0.7071067811865475, 1.224744871391589, 0.0]\n", "\nonline_calculator.add_sale(15)\nassert online_calculator.get_z_scores() == [0.0, 1.0, -1.0, 1.5, 0.0, -0.5]\n", "\nonline_calculator = ZScoreCalculator()\nonline_calculator.add_sale(5)\nassert on... |
e67bb85cc27617301fc3b17e890508f2 | [
{
"content": "On te donne deux séquences d'ADN, `seq1` et `seq2`, chacune de longueur `N`, qui peuvent contenir des lacunes représentées par les caractères \".\" ou \"-\". Ta tâche est d'écrire une fonction `calculate_sequence_similarity(seq1, seq2)` qui calcule le pourcentage de caractères non-lacunaires qui s... | ["\nassert calculate_sequence_similarity(\"ATG-C\", \"ATGCC\") == 66.66666666666666\n", "\nassert calculate_sequence_similarity(\"ATG-C\", \"ATG-C\") == 100.0\n", "\nassert calculate_sequence_similarity(\"ATG-C\", \"-----\") == 0.0\n", "\nassert calculate_sequence_similarity(\"ATG-C\", \"ATGCA\") == 80.0\n", "\nassert ... |
9256c1a819f9566e011cb727d76a7bb2 | [
{
"content": "On te donne un nombre réel `x`. Ton objectif est d'implémenter une fonction qui calcule la tangente hyperbolique (tanh) de `x` sans utiliser de fonctions mathématiques intégrées pour les calculs exponentiels ou trigonométriques/hyperboliques. La tangente hyperbolique est définie comme suit :\n\n\\... | ["\nassert tanh(0) == 0.0\n", "\nassert tanh(1) == sinh_approx(1) / cosh_approx(1)\n", "\nassert tanh(-1) == -tanh(1)\n", "\nassert tanh(10) == 1.0 # tanh(x) approaches 1 as x approaches infinity\n", "\nassert tanh(-10) == -1.0 # tanh(x) approaches -1 as x approaches negative infinity\n", "\nassert tanh(0.5) == sinh_... |
ea5ee2ed20ac47f70c2cf076aac929bc | [
{
"content": "On te donne un fichier texte nommé `input.txt` contenant une liste de phrases, chacune sur une nouvelle ligne. Ta tâche est d'implémenter une fonction `read_and_process_sentences` qui lit les données d'entrée de ce fichier et renvoie une liste de phrases, où chaque phrase est représentée comme une... | ["\nassert read_and_process_sentences('test1.txt') == [['hello', 'world']]\n", "\nassert read_and_process_sentences('test2.txt') == [['this', 'is', 'a', 'test'], ['another', 'line', 'here']]\n", "\nassert read_and_process_sentences('test3.txt') == [['it', 'is', \"it's\", \"can't\", \"you're\", \"they'll\"]]\n", "\nasse... |
350a4333c1e610ced4d32e754baa3288 | [
{
"content": "Implémente une classe Python nommée `SimpleCalculator` qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. Chaque opération doit être implémentée comme une méthode qui prend deux arguments numériques et renvoie le résultat. La méthode de d... | ["\nassert SimpleCalculator().add(10, 5) == 15\n", "\nassert SimpleCalculator().subtract(10, 5) == 5\n", "\nassert SimpleCalculator().multiply(10, 5) == 50\n", "\nassert SimpleCalculator().divide(10, 5) == 2.0\n", "\nassert SimpleCalculator().divide(10, 0) == \"Error: Division by zero is not allowed.\"\n", "\nassert Si... |
6b6e4425f1a34d965851e4bb6ded42b9 | [
{
"content": "On te donne la tâche de concevoir une fonction `generate_formatted_string` qui construit une chaîne formatée représentant un tuple avec un nombre spécifié de paramètres et une profondeur d'imbrication donnée. Chaque paramètre du tuple doit être représenté par un espace réservé `%s`. Si le nombre d... | ["\nassert generate_formatted_string(1) == \"( %s )\"\n", "\nassert generate_formatted_string(2) == \"( %s, %s )\"\n", "\nassert generate_formatted_string(3) == \"( %s, %s, %s )\"\n", "\nassert generate_formatted_string(0) == \"( )\"\n", "\nassert generate_formatted_string(1, 1) == \"( ( %s ) )\"\n", "\nassert generat... |
571391c17baf7b32fedb96d10809f08d | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n- `deposit(amount)` : Ajoute le montant spécifié au solde du compte. Si le montant est négatif, lève une exception `ValueError` avec le message \"Deposit amount cannot be ne... | ["\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount().deposit(100) or BankAccount().check_balance() == 100\n", "\naccount = BankAccount(); account.deposit(100); account.withdraw(50); assert account.check_balance() == 50\n", "\naccount = BankAccount(); account.deposit(100); account.withdraw(100); ass... |
344588fc1cbdd1cf54d1f0da2cf7e9e1 | [
{
"content": "On te donne deux tableaux d'entiers 2D, `matrix_a` et `matrix_b`, représentant respectivement les matrices A et B. La matrice A a des dimensions `m x n`, et la matrice B a des dimensions `n x p`. Ta tâche est de calculer la somme de tous les éléments de la matrice résultante C, qui est le produit ... | ["\nassert matrix_product_sum([[1, 2], [3, 4]], [[5, 6], [7, 8]]) == 70\n", "\nassert matrix_product_sum([[1, 0], [0, 1]], [[1, 2], [3, 4]]) == 10\n", "\nassert matrix_product_sum([[2, 3], [4, 5]], [[1, 0], [0, 1]]) == 23\n", "\nassert matrix_product_sum([[1]], [[1]]) == 1\n", "\nassert matrix_product_sum([[0, 0], [0, ... |
f9a484b8525b60381d92f29a16f6010a | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python qui reflète la fonctionnalité d'une classe Java fournie. La classe `Rectangle` doit avoir deux attributs privés, `length` et `width`, et une méthode pour calculer l'aire du rectangle. Ton implémentation doit inclure un initialisateur pou... | ["\nassert Rectangle(5, 10).calculate_area() == 50\n", "\nassert Rectangle(0, 10).calculate_area() == 0\n", "\nassert Rectangle(7, 3).calculate_area() == 21\n", "\nassert Rectangle(1.5, 2.5).calculate_area() == 3.75\n", "\nassert Rectangle(10, 10).calculate_area() == 100\n", "\nassert Rectangle(100, 0.5).calculate_area... |
1e4a942bc4bb86c6f181398e6a65d415 | [
{
"content": "On te donne une liste de tuples `coordinates`, où chaque tuple représente les coordonnées (x, y) d'un point dans un plan 2D. Ta tâche est de mettre en œuvre une fonction `sort_by_distance` qui trie ces points en fonction de leur distance euclidienne par rapport à l'origine (0, 0). La fonction doit... | ["\nassert sort_by_distance([(1, 2), (3, 4), (0, 0), (2, 2)]) == [(0, 0), (1, 2), (2, 2), (3, 4)]\n", "\nassert sort_by_distance([(0, 0), (0, 0), (0, 0)]) == [(0, 0), (0, 0), (0, 0)]\n", "\nassert sort_by_distance([(5, 12), (3, 4), (8, 15)]) == [(3, 4), (5, 12), (8, 15)]\n", "\nassert sort_by_distance([(1, 1), (-1, -1)... |
de8fcb71a8028e9e02847f2fe4d877d4 | [
{
"content": "On te donne une chaîne de caractères `expression` représentant une expression arithmétique simple composée d'entiers non négatifs et des opérateurs `+`, `-`, `*`, et `/`. L'expression peut également contenir des parenthèses `(` et `)`. Ta tâche est d'évaluer l'expression et de renvoyer le résultat... | ["\nassert evaluate_expression(\"3 + 5 * (2 - 8)\") == -17\n", "\nassert evaluate_expression(\"10 + 2 * 6\") == 22\n", "\nassert evaluate_expression(\"100 * 2 + 12\") == 212\n", "\nassert evaluate_expression(\"100 * ( 2 + 12 )\") == 1400\n", "\nassert evaluate_expression(\"100 * ( 2 + 12 ) / 14\") == 100\n", "\nassert ... |
ff733ea510afca51954bb4ff718b082e | [
{
"content": "On te donne un chemin de fichier qui contient un certificat au format texte brut. Ta tâche est d'écrire une fonction nommée `validate_certificate` qui lit le contenu du fichier et détermine s'il s'agit d'un certificat valide. Un certificat valide se compose exactement de six caractères alphanuméri... | ["\nassert validate_certificate(\"valid_cert_1.txt\") == True\n", "\nassert validate_certificate(\"valid_cert_2.txt\") == True\n", "\nassert validate_certificate(\"invalid_cert_1.txt\") == False\n", "\nassert validate_certificate(\"invalid_cert_2.txt\") == False\n", "\nassert validate_certificate(\"nonexistent_file.txt... |
d4451c4786477b9ac742f38505459477 | [
{
"content": "On te donne une chaîne de caractères `S` et une sous-chaîne `T`. Ta tâche est de mettre en œuvre une fonction qui supprime toutes les occurrences de `T` de `S` et renvoie la chaîne résultante ainsi que le nombre de fois où `T` a été supprimé. La fonction doit renvoyer un tuple où le premier élémen... | ["\nassert remove_substring_and_count(\"hello world, hello universe\", \"hello \") == (\"world, universe\", 2)\n", "\nassert remove_substring_and_count(\"banana\", \"na\") == (\"ba\", 2)\n", "\nassert remove_substring_and_count(\"aaaa\", \"aa\") == (\"\", 2)\n", "\nassert remove_substring_and_count(\"abcabcabc\", \"abc... |
014761d22996bdcb1cc8bb6c9b5f9b11 | [
{
"content": "On te donne un entier non négatif `n`. Ta tâche est de calculer le nième nombre de Fibonacci en utilisant la programmation dynamique. La séquence de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n ≥ 2.\n\n**Entrée :**\n- Un seul entier `n` (0 ≤ n ≤ 50).\n\n*... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(6) == 8\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) ==... |
7842c59a6ed2823e0e74c7539ba5481b | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `find_second_largest(numbers)` qui renvoie le deuxième entier distinct le plus grand de la liste. Si la liste contient moins de deux entiers distincts, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'enti... | ["\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([7, 7, 7, 8, 8, 9, ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.