id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
8c6fd86cfb4072aa90c10515e49afb14 | [
{
"content": "On te donne deux entiers `start` et `end`. Ta tâche est d'écrire une fonction `find_primes_in_range` qui renvoie une liste de tous les nombres premiers compris entre `start` et `end` (inclus). Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et l... | ["\nassert find_primes_in_range(10, 30) == [11, 13, 17, 19, 23, 29]\n", "\nassert find_primes_in_range(1, 10) == [2, 3, 5, 7]\n", "\nassert find_primes_in_range(20, 22) == []\n", "\nassert find_primes_in_range(0, 1) == []\n", "\nassert find_primes_in_range(2, 2) == [2]\n", "\nassert find_primes_in_range(14, 16) == []\n... |
cebf754d488be061b16f2247f87d6247 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `classify_numbers` qui catégorise ces entiers en nombres pairs et impairs. La fonction doit renvoyer un dictionnaire avec deux clés : `\"even\"` et `\"odd\"`, représentant les nombres de nombres pairs et impairs, respectivement.\n... | ["\nassert classify_numbers([1, 2, 3, 4, 5]) == {\"even\": 2, \"odd\": 3}\n", "\nassert classify_numbers([2, 4, 6, 8, 10]) == {\"even\": 5, \"odd\": 0}\n", "\nassert classify_numbers([1, 3, 5, 7, 9]) == {\"even\": 0, \"odd\": 5}\n", "\nassert classify_numbers([]) == {\"even\": 0, \"odd\": 0}\n", "\nassert classify_numb... |
b46cf16f7ca466ec58c32bd66437a0a4 | [
{
"content": "On te donne une chaîne de caractères `input_string` et un caractère optionnel `allowed_special_char`. Ta tâche est de mettre en œuvre une fonction `clean_string` qui traite la chaîne selon les règles suivantes :\n\n1. Remplace tous les caractères non alphanumériques dans `input_string` par un tire... | ["\nassert clean_string(\"Hello, World!\") == \"Hello_World\"\n", "\nassert clean_string(\"Hello, World!\", \"!\") == \"Hello_World!\"\n", "\nassert clean_string(\"Hello__World\", \"!\") == \"Hello_World\"\n", "\nassert clean_string(\"Hello___World\", \"!\") == \"Hello_World\"\n", "\nassert clean_string(\"Hello, World!... |
8fea82022f679ea2d2c15620ff194959 | [
{
"content": "On te demande d'implémenter une fonction `calculate_core_allocation` qui distribue de manière optimale la charge de travail entre deux cœurs, le cœur A et le cœur B, en fonction de la taille de l'entrée. Le cœur A traite les lignes à 80 % de la vitesse du cœur B. La fonction doit renvoyer un tuple... | ["\nassert calculate_core_allocation(1) == (\"Core A only\", 1, 0)\n", "\nassert calculate_core_allocation(32) == (\"Core A only\", 32, 0)\n", "\nassert calculate_core_allocation(33) == (\"Both cores\", 15, 18)\n", "\nassert calculate_core_allocation(64) == (\"Both cores\", 32, 32)\n", "\nassert calculate_core_allocati... |
d60fba8ec21da8ba9192670ec5c059be | [
{
"content": "On te donne une liste de tuples, où chaque tuple est constitué d'une valeur numérique et de son poids correspondant. Ta tâche est de calculer l'écart type pondéré de ces valeurs. L'écart type pondéré est défini comme suit :\n\n1. Calcule la moyenne pondérée en additionnant le produit de chaque val... | ["\nassert calculate_weighted_stddev([(1, 1), (2, 1), (3, 1)]) == 0.816496580927726\n", "\nassert calculate_weighted_stddev([(1, 2), (2, 3), (3, 5)]) == 0.7453559924999299\n", "\nassert calculate_weighted_stddev([(10, 1), (20, 1), (30, 1)]) == 8.16496580927726\n", "\nassert calculate_weighted_stddev([(5, 1), (5, 1), (5... |
b4a09d8b41c145f8a7bf3f89362aa7c6 | [
{
"content": "On te donne un document XML simple sous forme de chaîne de caractères et une nouvelle description. Ta tâche est de mettre en œuvre une fonction `add_description_to_xml` qui ajoute la nouvelle description en tant qu'élément enfant de l'élément racine dans le document XML. Le nouvel élément de descr... | ["\nassert add_description_to_xml('<root></root>', 'Test description') == '<root><desc_0bb1d358d7e867ed24d535efc7a08996>Test description</desc_0bb1d358d7e867ed24d535efc7a08996></root>'\n", "\nassert add_description_to_xml('<root><child>Existing</child></root>', 'Another description') == '<root><child>Existing</child><d... |
ebc96cc701d47d26e417ba983c9b7616 | [
{
"content": "On te donne un tableau d'entiers `numbers`. Ta tâche est de trouver le plus long sous-tableau contigu dans `numbers` qui est un palindrome. Un sous-tableau est considéré comme un palindrome s'il se lit de la même manière de gauche à droite et de droite à gauche. Retourne un tuple contenant l'indic... | ["\nassert find_longest_palindrome_subarray([1, 2, 3, 2, 1]) == (0, 5)\n", "\nassert find_longest_palindrome_subarray([1, 2, 3, 4, 5]) == (0, 1)\n", "\nassert find_longest_palindrome_subarray([1, 2, 2, 1, 3, 2, 2, 3]) == (1, 4)\n", "\nassert find_longest_palindrome_subarray([1, 2, 3, 2, 1, 4, 5, 4]) == (0, 5)\n", "\nas... |
867237a572b5c97594fe47a91c8b25bd | [
{
"content": "On te donne un tableau numpy 2D `data` représentant des mesures météorologiques sur plusieurs jours. Chaque ligne correspond à un jour, et chaque colonne représente un type de mesure différent. Ta tâche est de mettre en œuvre une fonction `filter_weather_data` qui extrait uniquement les colonnes p... | ["\nassert np.array_equal(filter_weather_data(np.array([[25, 15, 100, 50, 30, 500, 20, 10, 30], [26, 16, 110, 55, 35, 510, 25, 15, 35]])), np.array([[25, 15, 500, 30], [26, 16, 510, 35]]))\n", "\nassert np.array_equal(filter_weather_data(np.array([[25, 15, 100, 50, 30, np.nan, 20, 10, 30], [26, 16, 110, 55, 35, 510, 25... |
85146a4bab23a1b99651ccb3d57d0376 | [
{
"content": "On te donne la tâche de calculer le coût total d'une addition au restaurant, en incluant un pourcentage de pourboire variable et un pourcentage de taxes. Implémente une fonction `calculate_total_cost` qui prend trois paramètres : `bill`, `tip_percentage` et `tax_percentage`. Le paramètre `bill` es... | ["\nassert calculate_total_cost(100, 15, 10) == 126.5\n", "\nassert calculate_total_cost(50, 20, 5) == 63.0\n", "\nassert calculate_total_cost(200, 0, 0) == 200.0\n", "\nassert calculate_total_cost(0, 10, 10) == 0.0\n", "\nassert calculate_total_cost(123.45, 18, 8) == 148.5318\n", "\nassert calculate_total_cost(99.99, ... |
75286ada9b97f252f860464843a8de5c | [
{
"content": "On te demande d'implémenter une fonction pour diviser un ensemble de données en ensembles d'entraînement, de validation et de test pour un modèle d'apprentissage automatique. L'ensemble de données est fourni sous forme de liste de points de données. Ta fonction doit diviser l'ensemble de données e... | ["\nassert split_dataset([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == ([1, 2, 3, 4, 5, 6, 7, 8], [9], [10])\n", "\nassert split_dataset([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) == ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [13, 14], [15])\n", "\nassert split_dataset([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,... |
3b9953b9486ad147692578b25c3db030 | [
{
"content": "On te donne une chaîne de caractères `s` qui représente un objet JSON. Ta tâche est d'écrire une fonction `validate_json` qui détermine si l'objet JSON est valide. La fonction doit renvoyer `True` si l'objet JSON est valide, et `False` sinon. Tu dois implémenter la logique d'analyse toi-même et tu... | ["\nassert validate_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}') == True\n", "\nassert validate_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\",}') == False\n", "\nassert validate_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"') == False\n", "\nassert validate_json('{... |
e0ac53e9be613ba40d0e5f150ed34dff | [
{
"content": "Implémente une classe `Calculator` en Python qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. Ta classe doit inclure les méthodes suivantes :\n\n- `add(a, b)` : Retourne la somme de `a` et `b`.\n- `subtract(a, b)` : Retourne le résultat... | ["\nassert Calculator().add(2, 3) == 5\n", "\nassert Calculator().subtract(5, 3) == 2\n", "\nassert Calculator().multiply(4, 3) == 12\n", "\nassert Calculator().divide(10, 2) == 5\n", "\nassert Calculator().add(-1, 1) == 0\n", "\nassert Calculator().subtract(0, 0) == 0\n", "\nassert Calculator().multiply(-2, 3) == -6\n... |
f2d23436e725b9a4a19c2780fc149f03 | [
{
"content": "On te demande d'implémenter une fonction `validate_input` pour un système de validation de données. La fonction doit accepter trois paramètres : `value`, `field_name` et `min_length`. La fonction doit vérifier que `value` est une chaîne de caractères non vide, qu'elle a une longueur d'au moins `mi... | ["\nassert validate_input(\"John\", \"name\", 4) == \"John\"\n", "\nassert validate_input(\"Alice\", \"username\", 5) == \"Alice\"\n", "\nassert validate_input(\"Bob\", \"nickname\", 3) == \"Bob\"\n", "\nassert validate_input(\"A\", \"initial\", 1) == \"A\"\n", "\nassert validate_input(\"Z\", \"letter\", 1) == \"Z\"\n"... |
4e9f177ba5417e8fde2bc4b94adae592 | [
{
"content": "On te donne un entier `num`. Ta tâche est de déterminer si `num` est un palindrome. Un nombre est considéré comme un palindrome s'il se lit de la même manière à l'endroit qu'à l'envers. Par exemple, `121` est un palindrome, tandis que `123` ne l'est pas.\n\n**Entrée :**\n- Un entier `num` tel que ... | ["\nassert is_palindrome_number(121) == True\n", "\nassert is_palindrome_number(-121) == False\n", "\nassert is_palindrome_number(10) == False\n", "\nassert is_palindrome_number(0) == True\n", "\nassert is_palindrome_number(12321) == True\n", "\nassert is_palindrome_number(123456) == False\n", "\nassert is_palindrome_n... |
c3710a09c524c0cfbee4304ef059c31c | [
{
"content": "On te demande d'implémenter une calculatrice simple en Python. La calculatrice doit effectuer des opérations arithmétiques de base : addition, soustraction, multiplication et division. Ton programme doit demander à l'utilisateur d'entrer deux nombres et un opérateur. Il doit ensuite afficher le ré... | ["\nassert simple_calc() == None # Test with valid addition\n", "\nassert simple_calc() == None # Test with valid subtraction\n", "\nassert simple_calc() == None # Test with valid multiplication\n", "\nassert simple_calc() == None # Test with valid division\n", "\nassert simple_calc() == None # Test with division ... |
3efe0f5c5da950ada59b819f1c0f633f | [
{
"content": "On te demande d'implémenter une classe Python `Employee` pour gérer les détails des employés. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Propriétés** :\n - `name` : une chaîne de caractères représentant le nom de l'employé.\n - `employee_id` : une chaîne de caractère... | ["\nassert hasattr(Employee, '__init__')\n", "\nassert hasattr(Employee, 'display_info')\n", "\nassert hasattr(Employee, 'update_salary')\n", "\nemp = Employee(\"John Doe\", \"E123\", 50000.00); assert emp.name == \"John Doe\"\n", "\nemp = Employee(\"John Doe\", \"E123\", 50000.00); assert emp.employee_id == \"E123\"\n... |
f245966a35826ac26ba91994ad41d1ad | [
{
"content": "On te donne deux listes de longueur égale, `current_prices` et `predicted_changes`. La liste `current_prices` contient les prix actuels d'une action à différents intervalles de temps, et la liste `predicted_changes` contient les variations de prix de l'action prédites pour ces mêmes intervalles de... | ["\nassert stock_trading_strategy([10, 11, 12, 11, 13], [1, -1, 2, -2, 1]) == (0, [0, 0, 0, 0, 0])\n", "\nassert stock_trading_strategy([10, 15, 20], [1, 1, 1]) == (-30, [-10, -25, -40])\n", "\nassert stock_trading_strategy([10, 15, 20], [-1, -1, -1]) == (30, [10, 25, 40])\n", "\nassert stock_trading_strategy([10, 10, ... |
1172d6a88a8d4d4fb5f9094c8102186c | [
{
"content": "On te donne une liste de statuts et tu dois générer une liste de couleurs correspondante en te basant sur le mappage suivant : 'active' -> 'green', 'inactive' -> 'red', 'pending' -> 'yellow'. Implémente une fonction `get_colors` qui effectue cette tâche sans utiliser de boucles ni de méthodes inté... | ["\nassert get_colors(['active']) == ['green']\n", "\nassert get_colors(['inactive']) == ['red']\n", "\nassert get_colors(['pending']) == ['yellow']\n", "\nassert get_colors(['unknown']) == [None]\n", "\nassert get_colors(['active', 'inactive', 'pending']) == ['green', 'red', 'yellow']\n", "\nassert get_colors(['pendin... |
d395f24891dff34b31b0d91439df561b | [
{
"content": "On te donne un fichier CSV contenant des données avec plusieurs colonnes. Ta tâche est d'écrire une fonction Python qui lit ce fichier CSV, regroupe les données par une colonne spécifiée et calcule la moyenne d'une autre colonne spécifiée. Utilise la bibliothèque `pandas` pour accomplir cette tâch... | ["\nassert calculate_grouped_means('data.csv', 'Category', 'Value').equals(pd.Series({'A': 10.0, 'B': 20.0}))\n", "\nassert calculate_grouped_means('data.csv', 'Type', 'Amount').equals(pd.Series({'X': 15.0, 'Y': 25.0}))\n", "\nassert calculate_grouped_means('data.csv', 'Group', 'Score').equals(pd.Series({'G1': 5.0, 'G2... |
b79de450b25b1ca66f63b3834eed1ac0 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer la longueur de la plus longue sous-chaîne qui ne contient aucun caractère répété.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10^5), composée de caractères ASCII.\n\n**Sortie :**\n- Un entier représentant la ... | ["\nassert find_longest_substring_without_repeating_characters(\"abcabcbb\") == 3\n", "\nassert find_longest_substring_without_repeating_characters(\"bbbbb\") == 1\n", "\nassert find_longest_substring_without_repeating_characters(\"pwwkew\") == 3\n", "\nassert find_longest_substring_without_repeating_characters(\"dvdf\... |
50cf3996f0e4b68bef6d4bae666769cd | [
{
"content": "Tu es chargé 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 un solde initial facultatif. Si aucun solde initial n'est fourni, le c... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount(50).deposit(50) is None and BankAccount(50).get_balance() == 100\n", "\nassert BankAccount(100).withdraw(50) is None and BankAccount(100).get_balance() == 50\n", "\nassert BankAccount(100).deposit(0... |
82ef53c34476725f6673c02b13e4d22a | [
{
"content": "Tu es un voleur qui planifie de voler des objets de valeur dans un musée. Le musée dispose d'un système de sécurité qui ne peut être contourné que pendant une durée limitée, tu dois donc maximiser la valeur totale des objets que tu peux voler dans ce délai. Chaque objet a un poids et une valeur, e... | ["\nassert maximize_loot([Item(10, 60), Item(20, 100), Item(30, 120)], 50) == (180.0, [10, 20, 20])\n", "\nassert maximize_loot([Item(10, 60), Item(20, 100)], 10) == (60.0, [10])\n", "\nassert maximize_loot([Item(10, 60), Item(20, 100)], 30) == (160.0, [10, 20])\n", "\nassert maximize_loot([Item(10, 60), Item(20, 100),... |
25054ca7c3b87b8c9e3eabd8a699d27b | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères ASCII et Unicode. Ta tâche est de mettre en œuvre une fonction `count_whitespace` qui renvoie le nombre de séquences d'espaces blancs dans la chaîne, en excluant les espaces blancs en début et en fin de chaîne. Une séquence d'espaces ... | ["\nassert count_whitespace(\" hello world \") == 1\n", "\nassert count_whitespace(\"hello world\") == 1\n", "\nassert count_whitespace(\"hello world\") == 1\n", "\nassert count_whitespace(\"hello world\") == 1\n", "\nassert count_whitespace(\"hello world\") == 0\n", "\nassert count_whitespace(\" hello wo... |
499c134f8c7382f9886b844f4e863a98 | [
{
"content": "On te donne une liste de chaînes de caractères, chacune représentant un chemin de fichier. Ta tâche est de filtrer cette liste pour n'inclure que les chemins qui pointent vers des fichiers avec les extensions `.txt` ou `.log`. Implémente une fonction `filter_file_paths` qui accepte une liste de ch... | ["\nassert filter_file_paths([\"file1.txt\", \"file2.log\", \"file3.pdf\"]) == [\"file1.txt\", \"file2.log\"]\n", "\nassert filter_file_paths([\"report.log\", \"image.png\", \"notes.txt\"]) == [\"report.log\", \"notes.txt\"]\n", "\nassert filter_file_paths([\"data.csv\", \"log.log\", \"summary.txt\"]) == [\"log.log\", ... |
55cfc7c07d58bb494880687d1ee5840f | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `count_words` qui traite cette chaîne et renvoie un dictionnaire. Le dictionnaire doit associer chaque mot unique (sans tenir compte de la casse ni de la ponctuation... | ["\nassert count_words(\"The quick brown fox jumps over the lazy dog.\") == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nassert count_words(\"The quick brown fox jumps over the lazy dog. The dog was not amused. The fox is quick.\") == {'quick': 2, 'fox': 2, 'the': 3, 'dog': 2, '... |
28399fce513d5ad2c2a4c1fe4de2a7ae | [
{
"content": "On te donne un ensemble de fragments d'ADN, chacun représenté comme une chaîne de caractères, qui sont des parties d'une séquence d'ADN plus large. Les fragments sont fournis dans un dictionnaire où les clés sont les positions de départ des fragments dans la séquence complète, et les valeurs sont ... | ["\nassert assemble_dna_fragments({0: \"ACGT\", 3: \"ATCGT\", 5: \"CGTAC\"}) == \"ACGTACGTAC\"\n", "\nassert assemble_dna_fragments({0: \"ATCG\", 4: \"CGTA\", 8: \"TAGC\"}) == \"ATCGCGTAGC\"\n", "\nassert assemble_dna_fragments({1: \"CGTA\", 0: \"ATCG\"}) == \"ATCGTA\"\n", "\nassert assemble_dna_fragments({5: \"GCTA\",... |
0a341ac2f033e33ffffe6b3ebecd1254 | [
{
"content": "On te donne un ensemble de données représentant plusieurs chansons, où chaque chanson est décrite comme une liste d'événements. Chaque événement est un tuple constitué d'un horodatage (en secondes) et d'un type d'événement (par exemple, \"drum\", \"guitar\", \"vocal\"). Ta tâche est d'écrire une f... | ["\nassert get_unique_timestamps([[(10, \"drum\"), (20, \"guitar\"), (30, \"vocal\")]]) == [10, 20, 30]\n", "\nassert get_unique_timestamps([[(10, \"drum\"), (10, \"guitar\")], [(10, \"vocal\")]]) == [10, 10, 10]\n", "\nassert get_unique_timestamps([[(5, \"drum\")], [(15, \"guitar\")], [(25, \"vocal\")]]) == [5, 15, 25... |
373dcba96d7fe377218e9680da9498ae | [
{
"content": "Dans un circuit parallèle, la résistance totale \\( R_{total} \\) peut être calculée en utilisant la formule suivante :\n\n\\[\n\\frac{1}{R_{total}} = \\frac{1}{R_1} + \\frac{1}{R_2} + \\ldots + \\frac{1}{R_n}\n\\]\n\noù \\( R_1, R_2, \\ldots, R_n \\) sont les résistances individuelles. Implémente... | ["\nassert total_parallel_resistance([100, 200, None, 0, 300]) == 60.0\n", "\nassert total_parallel_resistance([10, 20, 30]) == 5.454545454545454\n", "\nassert total_parallel_resistance([0, 0, 0]) == None\n", "\nassert total_parallel_resistance([None, None, None]) == None\n", "\nassert total_parallel_resistance([100, 0... |
8e9cbbb04232683f4bc7717159461517 | [
{
"content": "On te donne un tableau d'entiers distincts, `arr`, et un entier positif `k`. Ta tâche est de déterminer l'indice du `k`-ième plus petit élément du tableau. Si `k` dépasse la longueur du tableau, renvoie `-1`. Tu n'es pas autorisé à utiliser des fonctions ou méthodes de tri intégrées.\n\n**Entrée :... | ["\nassert find_kth_smallest_index([7, 10, 4, 3, 20, 15], 3) == 2\n", "\nassert find_kth_smallest_index([1, 2, 3, 4, 5], 1) == 0\n", "\nassert find_kth_smallest_index([5, 4, 3, 2, 1], 5) == 0\n", "\nassert find_kth_smallest_index([10, 20, 30, 40, 50], 3) == 2\n", "\nassert find_kth_smallest_index([100, 200, 300, 400, 5... |
63fef96477c3815fbc31c0b71e3dc11e | [
{
"content": "On te donne un graphe non orienté `G` représenté sous forme de matrice d'adjacence, où `G[i][j]` indique la présence d'une arête entre les nœuds `i` et `j` (1 s'il y a une arête, 0 sinon). Le graphe est garanti comme étant connexe et ne contient pas de boucles ou d'arêtes multiples entre la même p... | ["\nassert find_path_between_cities([[0, 1, 0, 0], [1, 0, 1, 1], [0, 1, 0, 1], [0, 1, 1, 0]], 0, 3) in [[0, 1, 3], [0, 1, 2, 3]]\n", "\nassert find_path_between_cities([[0, 1], [1, 0]], 0, 1) == [0, 1]\n", "\nassert find_path_between_cities([[0, 0, 1], [0, 0, 1], [1, 1, 0]], 0, 2) == [0, 2]\n", "\nassert find_path_betw... |
c989ad3cd7d5eb49ea027fd7a18f8408 | [
{
"content": "On te donne un fichier nommé \"numbers.txt\" qui contient une liste d'entiers, un entier par ligne. Ta tâche est de calculer le produit de tous les nombres pairs uniques trouvés dans le fichier. S'il n'y a pas de nombres pairs, la fonction doit renvoyer 0.\n\n**Entrée :**\n- Le fichier \"numbers.t... | ["\nassert product_of_unique_evens(\"test1.txt\") == 0 # File with no even numbers\n", "\nassert product_of_unique_evens(\"test2.txt\") == 8 # File with one even number 2\n", "\nassert product_of_unique_evens(\"test3.txt\") == 48 # File with even numbers 2, 3, 4, 4 (duplicates)\n", "\nassert product_of_unique_evens(... |
318cb79d4f9540834fb411ec30b3914c | [
{
"content": "Tu développes une interface en ligne de commande (CLI) pour un système de gestion de données. La CLI doit gérer deux types d'entrées : un identifiant unique pour un ensemble de données (appelé \"ID d'ensemble de données\") et un chemin d'accès au répertoire racine de l'ensemble de données. La CLI ... | ["\nassert main() == None # This is a placeholder to check if the function runs without errors. Actual assertions will check the output.\n", "\nassert main(['dataset1']) == {'dataset1': os.getcwd()}\n", "\nassert main(['dataset1', 'dataset2']) == {'dataset1': os.getcwd(), 'dataset2': os.getcwd()}\n", "\nassert main(['... |
4dc6a21b63d051b04cd4ca10939606d1 | [
{
"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 positif.\n- `withdraw(amount)` : soustrait le montant spécifié du solde du compte si le... | ["\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount(100).check_balance() == 100\n", "\nassert BankAccount(500).deposit(500) or BankAccount(500).check_balance() == 1000\n", "\nassert BankAccount(1000).withdraw(200) or BankAccount(1000).check_balance() == 800\n", "\nassert BankAccount(1000).withdraw(1... |
53a46581ff3af4d3b7092280f28903a5 | [
{
"content": "Tu es chargé d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author` et `year`. Implémente des méthodes pour récupérer et mettre à jour chaque attribut. De plus, implémente une méthode `get_full_reference()` qui renvoie une chaîne formatée sous la... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_full_reference() == \"George Orwell, 1949: 1984\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).get_full_reference() == \"Harper Lee, 1960: To Kill a Mockingbird\"\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925).get_ful... |
145e61f0790b7acebc6a56d2fefafae0 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python pour simuler des opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur doit accepter un solde initial. Si le solde initial est négatif, le constructeur ... | ["\nassert BankAccount(100).check_balance() == 100\n", "\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount(50).deposit(50).check_balance() == 100\n", "\nassert BankAccount(100).withdraw(50).check_balance() == 50\n", "\nassert BankAccount(100).deposit(50).withdraw(25).check_balance() == 125\n", "\nass... |
8bbed4c8efba5fe7828ec2f8abe6e989 | [
{
"content": "On te charge de développer un système pour gérer les notes des élèves d'un lycée. Le système doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un Élève** : Ajouter un nouvel élève au système. Si l'élève existe déjà, ne l'ajoute pas à nouveau.\n2. **Ajouter une Note** : Ajouter une ... | ["\nassert 'Alice' in grades_system.students_grades\n", "\nassert 'Bob' in grades_system.students_grades\n", "\nassert grades_system.students_grades['Alice'] == [90.0, 85.0]\n", "\nassert grades_system.students_grades['Bob'] == [78.0, 82.0]\n", "\nassert grades_system.average_grade('Alice') is None # This will print t... |
d3f6432c34b4919163f12284b0a04a93 | [
{
"content": "On te donne un DataFrame pandas `gene_expression_data` de taille `m x n` représentant les niveaux d'expression des gènes pour `m` gènes sur `n` lignées cellulaires différentes. De plus, on te fournit une Série pandas `drug_response_data` de taille `n` représentant la réponse de chaque lignée cellu... | ["\nassert filter_nonresponsive_cell_lines(pd.DataFrame({'GeneA': [1, 2, 3], 'GeneB': [4, 5, 6]}), pd.Series([0, 1, 1]), ['GeneA']) == (pd.DataFrame({'GeneA': [2, 3]}), pd.Series([1, 1], index=[1, 2]))\n", "\nassert filter_nonresponsive_cell_lines(pd.DataFrame({'GeneA': [1, 2, 3], 'GeneB': [4, 5, 6]}), pd.Series([1, 0,... |
5b2a87995bed2c55f4645e181d043cbb | [
{
"content": "On te demande d'implémenter une classe `Matrix` en Python qui supporte les opérations matricielles de base : addition, soustraction et multiplication. La classe doit également fournir une méthode pour afficher la matrice de manière formatée. Ton implémentation doit gérer les cas où les dimensions ... | ["\nassert Matrix([[1, 2], [3, 4]]) + Matrix([[2, 0], [1, 2]]) == Matrix([[3, 2], [4, 6]])\n", "\nassert Matrix([[1, 2], [3, 4]]) - Matrix([[2, 0], [1, 2]]) == Matrix([[-1, 2], [2, 2]])\n", "\nassert Matrix([[1, 2], [3, 4]]) * Matrix([[2, 0], [1, 2]]) == Matrix([[4, 4], [10, 8]])\n", "\nassert Matrix([[1, 2, 3], [4, 5,... |
2b793a2241cb6c7cba560d759b6e8db2 | [
{
"content": "On te donne une structure imbriquée composée d'entiers, de listes et d'ensembles. Ta tâche est d'écrire une fonction qui renvoie une liste de tuples, où chaque tuple contient un entier unique de l'entrée et sa fréquence correspondante. Les tuples doivent être triés d'abord par fréquence par ordre ... | ["\nassert element_frequencies([1, 2, 3, 4, 5]) == [(1, 1), (2, 1), (3, 1), (4, 1), (5, 1)]\n", "\nassert element_frequencies([1, [2, 2, 3], set([3, 4, 4]), 5, [1, set([2, 3]), [4, [5]]]]) == [(2, 3), (3, 3), (4, 3), (1, 2), (5, 2)]\n", "\nassert element_frequencies([1, 1, 1, 2, 2, 3]) == [(1, 3), (2, 2), (3, 1)]\n", "... |
83c81fe19c2d32b3aee8686c7590cf11 | [
{
"content": "On te donne une liste d'entiers `nums` et un entier `target`. Ta tâche est de trouver toutes les combinaisons uniques d'éléments dans `nums` qui totalisent `target`. Chaque combinaison doit être triée par ordre non décroissant, et les combinaisons elles-mêmes doivent être triées lexicographiquemen... | ["\nassert combination_sum([2, 3, 6, 7], 7) == [[2, 2, 3], [7]]\n", "\nassert combination_sum([2, 3, 5], 8) == [[2, 2, 2, 2], [2, 3, 3], [3, 5]]\n", "\nassert combination_sum([1], 1) == [[1]]\n", "\nassert combination_sum([1], 2) == [[1, 1]]\n", "\nassert combination_sum([1, 2], 4) == [[1, 1, 1, 1], [1, 1, 2], [2, 2]]\... |
fd3892abbe9ef3ed0f938d7e71e2b318 | [
{
"content": "On te donne la tâche de simuler la décroissance d'une substance radioactive au fil du temps. La substance se décompose en deux phases : une décroissance initiale rapide et une décroissance subséquente plus lente. La décroissance rapide est modélisée par la fonction `0.0036 * exp(-x / 0.25)` et la ... | ["\nassert isinstance(remaining_substance(0), float)\n", "\nassert remaining_substance(0) > 0.00432 and remaining_substance(0) < 0.004752\n", "\nassert remaining_substance(1) > 0.0039 and remaining_substance(1) < 0.00432\n", "\nassert remaining_substance(5) > 0.0028 and remaining_substance(5) < 0.0032\n", "\nassert rem... |
c2cac1b6d6e9e33b4154288e87aa9971 | [
{
"content": "On te demande d'implémenter une fonction `get_property(obj, prop_name)` qui navigue à travers une structure d'objets profondément imbriquée, qui peut inclure des dictionnaires, des listes, des tuples et des objets personnalisés. Ta fonction doit rechercher récursivement la première occurrence d'un... | ["\nassert get_property({\"a\": 1, \"b\": {\"c\": 2}}, \"c\") == 2\n", "\nassert get_property([{\"a\": 1}, {\"b\": 2}, {\"c\": 3}], \"b\") == 2\n", "\nassert get_property(({\"a\": 1}, {\"b\": 2}, {\"c\": 3}), \"c\") == 3\n", "\nassert get_property({\"a\": [1, 2, {\"b\": 3}]}, \"b\") == 3\n", "\nassert get_property({\"a... |
b680646dd9d710950c8572047235e19d | [
{
"content": "On te donne une séquence d'ADN sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction `get_reverse_complement` qui traite cette séquence en supprimant les espaces et les caractères invalides (seuls 'A', 'C', 'G', 'T' sont valides), convertit les caractères restants en majuscules, p... | ["\nassert get_reverse_complement(\"A GCT TAC G\") == \"CGATACGCT\"\n", "\nassert get_reverse_complement(\"acgt\") == \"ACGT\"\n", "\nassert get_reverse_complement(\"GCTA\") == \"TAGC\"\n", "\nassert get_reverse_complement(\"a c g t\") == \"ACGT\"\n", "\nassert get_reverse_complement(\"invalid sequence 123\") == \"\"\... |
f343b4fa6fc2269f2fb9709bcef44a07 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Implémente la fonction `compress_string` qui compresse la chaîne en utilisant une version modifiée de l'algorithme de compression LZ78 avec un dictionnaire qui redimensionne dynamiquement sa capacité max... | ["\nassert compress_string(\"abcabcabc\") == [(0, 'a'), (1, 'b'), (2, 'c'), (0, 'a'), (1, 'b'), (2, 'c'), (0, 'a'), (1, 'b'), (2, 'c')]\n", "\nassert compress_string(\"aaaa\") == [(0, 'a'), (1, 'a'), (2, 'a'), (3, 'a')]\n", "\nassert compress_string(\"ababab\") == [(0, 'a'), (1, 'b'), (0, 'a'), (1, 'b'), (0, 'a'), (1, ... |
142c7dd43227230d4ad18cecf3e1eacd | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction `find_intersection` qui renvoie une liste contenant l'intersection des deux listes, y compris les éléments en double. L'intersection doit être constituée des éléments qui apparaissent dans les deux ... | ["\nassert find_intersection([1, 2, 2, 3, 4], [2, 3, 5]) == [2, 2, 3]\n", "\nassert find_intersection([1, 1, 1, 1], [1, 1, 1]) == [1, 1, 1]\n", "\nassert find_intersection([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_intersection([], [1, 2, 3]) == []\n", "\nassert find_intersection([1, 2, 3], []) == []\n", "\nassert ... |
a0efa9dab9a16a556a7ce0cdb0a87c39 | [
{
"content": "On te donne une chaîne de motifs composée d'alphabets, de chiffres et de motifs imbriqués. Un motif imbriqué est défini comme une sous-chaîne entre parenthèses suivie d'un chiffre indiquant le nombre de répétitions. Ta tâche est de mettre en œuvre une fonction `create_pattern_list(n: int, pattern:... | ["\nassert create_pattern_list(5, \"abc123\") == [\"abc123\", \"3abc12\", \"23abc1\", \"123abc\", \"c123ab\"]\n", "\nassert create_pattern_list(3, \"(ab)3\") == [\"ababab\", \"bababa\", \"ababab\"]\n", "\nassert create_pattern_list(4, \"abc(de)2\") == [\"abc dede\", \"cab dede\", \"bc dedeca\", \"b dedecab\"]\n", "\nas... |
0675f27da380c3317873b074cf7665ba | [
{
"content": "On te donne une liste de données d'étudiants, où chaque étudiant est représenté par un tuple contenant son nom, son pays, son âge et son score. Ta tâche est de calculer le score moyen pondéré pour chaque pays, en ignorant les scores inférieurs à 70, en utilisant l'âge comme poids (les étudiants pl... | ["\nassert weighted_average_by_country([(\"Alice\", \"USA\", 20, 80), (\"Bob\", \"Canada\", 19, 90)]) == [90.0, 80.0]\n", "\nassert weighted_average_by_country([(\"Alice\", \"USA\", 20, 80), (\"Bob\", \"USA\", 19, 90)]) == [84.73684210526315]\n", "\nassert weighted_average_by_country([(\"Alice\", \"USA\", 20, 80), (\"B... |
9bc81ef126f40fb0b29cc4092f23c138 | [
{
"content": "On te demande d'implémenter une fonction `convert_to_html` qui traite une chaîne de caractères formatée en Markdown et la convertit en HTML. Ta fonction doit utiliser la bibliothèque `markdown` disponible en Python. La fonction doit renvoyer la chaîne HTML résultante.\n\n**Entrée :**\n- Une seule ... | ["\nassert convert_to_html(\"# Header\") == \"<h1>Header</h1>\"\n", "\nassert convert_to_html(\"## Subheader\") == \"<h2>Subheader</h2>\"\n", "\nassert convert_to_html(\"This is a **bold** text.\") == \"<p>This is a <strong>bold</strong> text.</p>\"\n", "\nassert convert_to_html(\"This is an *italic* text.\") == \"<p>T... |
4b07f2201633bfd1f386f024c5b7f8ce | [
{
"content": "On te donne un objet JSON représentant une structure imbriquée de dictionnaires. Ta tâche est d'écrire une fonction Python qui aplatit cet objet JSON en un dictionnaire à un seul niveau avec des clés concaténées. Les clés dans le dictionnaire aplati doivent être formées en concaténant les clés par... | ["\nassert flatten_json({\"a\": {\"b\": 1, \"c\": 2}}) == {\"a_b\": 1, \"a_c\": 2}\n", "\nassert flatten_json({\"x\": {\"y\": {\"z\": 3}}}) == {\"x_y_z\": 3}\n", "\nassert flatten_json({\"key\": \"value\"}) == {\"key\": \"value\"}\n", "\nassert flatten_json({\"list\": [1, 2, {\"nested\": \"value\"}]}) == {\"list0\": 1,... |
a0c040c986de8c30f8cab8c6b266d903 | [
{
"content": "On te donne une liste 2D `transactions` représentant un ensemble de transactions financières pour une entreprise. Chaque ligne de la liste correspond à une seule transaction, et chaque colonne représente un type de devise différent. Les valeurs de la liste indiquent le montant de chaque devise imp... | ["\nassert balance_transactions([[100, 200, -300]]) == [[-33.333333333333336, 66.66666666666667, -33.333333333333336]]\n", "\nassert balance_transactions([[50, -150, 100]]) == [[-33.333333333333336, -166.66666666666666, 66.66666666666667]]\n", "\nassert balance_transactions([[200, 300, -500]]) == [[-33.333333333333336,... |
1a6188ab78f718d44a6335de0d66e470 | [
{
"content": "On te donne un tableau NumPy à 5 dimensions `arr` de forme `(a, b, c, d, e)` où chaque élément est un nombre complexe. Implémente une fonction `slice_array(arr, dim, start, end)` qui découpe le tableau le long d'une dimension spécifiée `dim` de l'index `start` à `end` (exclus). La fonction doit re... | ["\nassert np.array_equal(slice_array(np.zeros((2, 2, 2, 2, 2), dtype=complex), 0, 0, 2), np.zeros((2, 2, 2, 2, 2), dtype=complex))\n", "\nassert np.array_equal(slice_array(np.zeros((2, 2, 2, 2, 2), dtype=complex), 1, 1, 1), np.zeros((2, 2, 2, 2, 2), dtype=complex))\n", "\nassert np.array_equal(slice_array(np.zeros((2,... |
de1f6cbef144c0700c784157354885d2 | [
{
"content": "On te donne une chaîne de caractères `sentence` qui peut contenir de la ponctuation et des lettres en majuscules et minuscules. Ta tâche est de mettre en œuvre une fonction `group_words_by_length` qui traite cette chaîne et renvoie un dictionnaire. Les clés du dictionnaire doivent être les longueu... | ["\nassert group_words_by_length(\"The quick brown fox jumps over the lazy dog.\") == {3: ['the', 'fox', 'the', 'dog'], 4: ['over', 'lazy'], 5: ['quick', 'brown', 'jumps']}\n", "\nassert group_words_by_length(\"Hello, world!\") == {5: ['hello', 'world']}\n", "\nassert group_words_by_length(\"A\") == {1: ['a']}\n", "\na... |
6a859fcb8bdbd3c6f4515302cb6cebfc | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de mettre en œuvre une fonction `find_indices` qui renvoie une liste de tous les indices dans `nums` où l'élément est égal à `target`. Si `target` n'est pas présent dans le tableau, la fonction doit renvoyer une liste vide... | ["\nassert find_indices([1, 2, 3, 4, 2, 5, 2], 2) == [1, 4, 6]\n", "\nassert find_indices([1, 2, 3, 4, 5], 6) == []\n", "\nassert find_indices([], 1) == []\n", "\nassert find_indices([1, 1, 1, 1, 1], 1) == [0, 1, 2, 3, 4]\n", "\nassert find_indices([10, 20, 30, 40, 50], 30) == [2]\n", "\nassert find_indices([5, 4, 3, 2... |
4f5c6140304c6aa216e8190f58d23702 | [
{
"content": "On te donne une liste d'images, chacune représentée comme un objet avec des attributs `width` et `height`. Ta tâche est de trier ces images en fonction de leurs ratios d'aspect, arrondis à l'entier le plus proche, en utilisant une implémentation personnalisée de l'algorithme de tri rapide (quickso... | ["\nassert [fuzzy_aspect_ratio(img) for img in fuzzy_sort_images([Image(800, 600), Image(1024, 768)])] == [1, 1]\n", "\nassert [fuzzy_aspect_ratio(img) for img in fuzzy_sort_images([Image(1920, 1080), Image(3840, 2160)])] == [2, 2]\n", "\nassert [fuzzy_aspect_ratio(img) for img in fuzzy_sort_images([Image(100, 200), Im... |
8efebceae8ba7ec68f220b7d645af428 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères distincts. Ta tâche est d'écrire une fonction `generate_permutations` qui génère toutes les permutations possibles de la chaîne `s` sans utiliser de fonctions de permutation intégrées. La fonction doit renvoyer une liste de chaînes de... | ["\nassert generate_permutations(\"a\") == [\"a\"]\n", "\nassert generate_permutations(\"ab\") == [\"ab\", \"ba\"]\n", "\nassert generate_permutations(\"abc\") == [\"abc\", \"acb\", \"bac\", \"bca\", \"cab\", \"cba\"]\n", "\nassert generate_permutations(\"abcd\") == [\"abcd\", \"abdc\", \"acbd\", \"acdb\", \"adbc\", \"... |
2cb05a5b66c722a470f371881a04b8f7 | [
{
"content": "On te donne deux distributions gaussiennes définies par leurs moyennes et leurs écarts types. Ta tâche est de calculer la divergence de Kullback-Leibler (KLD) entre ces deux distributions. Si l'écart type d'une des distributions est non positif, renvoie `None`. Si la deuxième distribution n'est pa... | ["\nassert calculate_kld(0, 1, 0, 1) == 0\n", "\nassert calculate_kld(0, 1, 1, 1) == 0.5 * (2 * math.log(1) - 2 * math.log(1) + (1**2 + (0 - 1)**2) / 1**2 - 1)\n", "\nassert calculate_kld(0, 1) == 0.5 * (2 * math.log(1) - 2 * math.log(1) + (1**2 + (0 - 0)**2) / 1**2 - 1)\n", "\nassert calculate_kld(0, 1, 1, -1) == None... |
2907d9da4e5905f89c5b7fed32176156 | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots séparés par des espaces et incluant potentiellement de la ponctuation et des accents. Ta tâche est d'écrire une fonction `count_unique_words` qui renvoie le nombre de mots uniques dans le texte, en ignorant la ponctuation et les accent... | ["\nassert count_unique_words(\"L'acc\u00e8s \u00e0 l'information est un droit fondamental.\") == 7\n", "\nassert count_unique_words(\"C'est un beau temps, n'est-ce pas?\") == 7\n", "\nassert count_unique_words(\"Hello, HELLO, hello!\") == 1\n", "\nassert count_unique_words(\"Cr\u00e8me br\u00fbl\u00e9e est d\u00e9lici... |
318e5a9f71fd59a0264d80145a9f6bc0 | [
{
"content": "Tu développes un module logiciel pour gérer un système de stockage hiérarchique. Chaque contrôleur de stockage peut avoir zéro ou plusieurs contrôleurs enfants. Ta tâche est d'implémenter une fonction `storage_system_reset` qui réinitialise un contrôleur spécifié et tous ses descendants dans la hi... | ["\nassert storage_system_reset(storage_system, \"root\", 1) == True\n", "\nassert storage_system_reset(storage_system, \"child1\", 11) == True\n", "\nassert storage_system_reset(storage_system, \"child1\", 12) == True\n", "\nassert storage_system_reset(storage_system, \"child2\", 21) == True\n", "\nassert storage_syst... |
9eca649bb40fa84762944ab75b089ce0 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Ton implémentation doit être efficace et facile à comprendre.\n\n**Entrée :**\n- Un entier `n` (0 ≤ n ≤ 50),... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(25... |
0c03d2404ee95e363bf689112f81a269 | [
{
"content": "Dans un système informatique hypothétique, les adresses mémoire sont représentées comme des entiers sur 32 bits. En raison de limitations matérielles, seul un sous-ensemble des bits d'adresse est utilisé pour l'accès à la mémoire, déterminé par un masque sur 32 bits donné. Le masque spécifie quels... | ["\nassert get_memory_region(0b10011010110100111010110111101111, 0b00000000000000000000001111111111) == 0b110111101111\n", "\nassert get_memory_region(0b11111111111111111111111111111111, 0b00000000000000000000001111111111) == 0b111111111111\n", "\nassert get_memory_region(0b00000000000000000000000000000000, 0b000000000... |
a3e3642d7de1fe599c5827bb3010a76a | [
{
"content": "On te donne un fichier texte. Ta tâche est d'écrire une fonction Python qui lit le fichier, compte la fréquence de chaque mot, et renvoie les 10 mots les plus fréquemment rencontrés ainsi que leurs fréquences. Les mots doivent être considérés sans tenir compte de la casse et la ponctuation doit êt... | ["\nassert count_word_frequencies('test1.txt') == [('the', 4), ('and', 3), ('of', 2), ('to', 2), ('a', 2), ('in', 2), ('that', 1), ('it', 1), ('was', 1), ('with', 1)]\n", "\nassert count_word_frequencies('test2.txt') == [('hello', 5), ('world', 3), ('this', 2), ('is', 2), ('a', 2), ('test', 1), ('file', 1), ('for', 1),... |
d789a908c6e95ce5148178277aa7fe4d | [
{
"content": "On te donne un fichier CSV avec une ligne d'en-tête. Ta tâche est d'écrire un programme Python qui lit ce fichier et calcule la moyenne d'une colonne spécifiée. Le nom de la colonne sera fourni en entrée. Suppose que le fichier CSV est bien formé et que la colonne spécifiée contient des données nu... | ["\nassert calculate_column_average('test.csv', 'age') == 30.0\n", "\nassert calculate_column_average('test.csv', 'salary') == 50000.0\n", "\nassert calculate_column_average('test.csv', 'height') == 175.0\n", "\nassert calculate_column_average('test.csv', 'weight') == 70.0\n", "\nassert calculate_column_average('test.c... |
666a3983a7cb12af40a038068eb98a46 | [
{
"content": "Tu es chargé de créer un script Python qui configure un serveur web simple. Le serveur doit servir une page HTML statique qui inclut un bouton. Lorsque le bouton est cliqué, une requête AJAX doit être faite au serveur pour récupérer une réponse JSON contenant une liste de 10 noms d'utilisateur alé... | ["\nassert isinstance(get_random_users(), list)\n", "\nassert len(get_random_users()) == 10\n", "\nassert all(name in user_names for name in get_random_users())\n", "\nassert isinstance(MyHttpRequestHandler, http.server.BaseHTTPRequestHandler)\n", "\nassert MyHttpRequestHandler().do_GET() is None\n", "\nassert MyHttpRe... |
a1840439eca355e619a5ebc3a657ba9a | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_largest_prime_factor` qui renvoie le plus grand facteur premier de `n`. La fonction doit être suffisamment efficace pour gérer des nombres très grands.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 10^18)\n\n**Sortie :**\n- Un... | ["\nassert find_largest_prime_factor(2) == 2\n", "\nassert find_largest_prime_factor(3) == 3\n", "\nassert find_largest_prime_factor(4) == 2\n", "\nassert find_largest_prime_factor(5) == 5\n", "\nassert find_largest_prime_factor(6) == 3\n", "\nassert find_largest_prime_factor(13195) == 29\n", "\nassert find_largest_pri... |
b0f9701dfa0f4f2ebaa8cc72d65e1feb | [
{
"content": "On te demande d'implémenter une fonction nommée `generate_fibonacci_sequence` qui génère une liste contenant les `n` premiers termes de la suite de Fibonacci. La suite de Fibonacci est définie comme suit : le premier terme est 0, le deuxième terme est 1, et chaque terme suivant est la somme des de... | ["\nassert generate_fibonacci_sequence(0) == []\n", "\nassert generate_fibonacci_sequence(-5) == []\n", "\nassert generate_fibonacci_sequence(1) == [0]\n", "\nassert generate_fibonacci_sequence(2) == [0, 1]\n", "\nassert generate_fibonacci_sequence(3) == [0, 1, 1]\n", "\nassert generate_fibonacci_sequence(5) == [0, 1, ... |
5cff55c8c7c029ac62319d39f2403586 | [
{
"content": "On te donne un dictionnaire imbriqué `data` où chaque clé correspond soit à un tableau numpy 1D d'entiers, soit à un autre dictionnaire. Ta tâche est de mettre en œuvre la fonction `extract_sub_arrays(data, indices)` qui prend en entrée le dictionnaire `data` et un dictionnaire `indices` contenant... | ["\nassert np.array_equal(extract_sub_arrays({'a': np.array([1, 2, 3, 4])}, {'a': np.array([0, 2])})['a'], np.array([1, 3]))\n", "\nassert np.array_equal(extract_sub_arrays({'b': {'c': np.array([5, 6, 7, 8])}}, {'b': {'c': np.array([1, 3])}})['b']['c'], np.array([6, 8]))\n", "\nassert np.array_equal(extract_sub_arrays(... |
1ce42a9ecc1410f8b9edffefc4f3fb12 | [
{
"content": "On te demande d'implémenter une fonction `read_nwords(filename, nwords)` qui lit un fichier texte et en extrait jusqu'à `nwords` mots. Les mots sont définis comme des séquences de caractères alphanumériques et sont séparés par tout caractère non alphanumérique, y compris la ponctuation et les saut... | ["\nassert read_nwords(\"test.txt\", 0) == []\n", "\nassert read_nwords(\"test.txt\", -1) == ['hello', 'world', 'this', 'is', 'a', 'test', 'file', 'with', 'multiple', 'lines', 'and', 'punctuation', 'marks', 'such', 'as', 'commas', 'periods', 'and', 'exclamation', 'marks']\n", "\nassert read_nwords(\"test.txt\", 5) == [... |
71861448c70206e100a7893f17bf2a4a | [
{
"content": "Étant donné un tableau d'entiers `arr` et un entier cible `target`, trouve le sous-tableau contigu le plus long dont la somme est supérieure ou égale à `target`. S'il existe plusieurs sous-tableaux de même longueur, renvoie celui qui a la somme la plus élevée. Si aucun sous-tableau de ce type n'ex... | ["\nassert longest_subarray_with_sum_at_least_target([1, 2, 3, 4, 5], 9) == [2, 3, 4]\n", "\nassert longest_subarray_with_sum_at_least_target([5, 1, 3, 5, 2, 4, 1, 2, 5], 15) == [5, 2, 4, 1, 2, 5]\n", "\nassert longest_subarray_with_sum_at_least_target([1, 2, 3, 4, 5], 15) == [1, 2, 3, 4, 5]\n", "\nassert longest_subar... |
dfb1be188638e1095ced06eaac70c593 | [
{
"content": "On te donne une liste de cours de bourse et une taille de fenêtre `k`. Ta tâche est de mettre en œuvre une fonction `calculate_moving_average` qui calcule les moyennes mobiles pour chaque fenêtre de `k` cours consécutifs. La moyenne mobile d'une fenêtre est la moyenne arithmétique des cours dans c... | ["\nassert calculate_moving_average([10, 20, 30, 40, 50], 2) == [15.0, 25.0, 35.0, 45.0]\n", "\nassert calculate_moving_average([1, 2, 3, 4, 5, 6], 3) == [2.0, 3.0, 4.0, 5.0]\n", "\nassert calculate_moving_average([5, 5, 5, 5, 5], 5) == [5.0]\n", "\nassert calculate_moving_average([100, 200, 300], 4) == []\n", "\nasser... |
3230ee567919500877c92deafe680fd6 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour calculer le nième nombre de Fibonacci. Pour ce faire, tu dois utiliser la mémoïsation pour optimiser l'approche récursive. Ta fonction doit renvoyer le nième nombre de Fibonacci.\n\n**Entrée :**\n- Un entier `n` (0 ≤ n ≤ 50), représentant la ... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(30) == 832040\n", "\nassert fibonacci... |
77b6a3ada78d9b80acd1adce9a890193 | [
{
"content": "On te donne une liste triée d'entiers `nums` et un entier `target`. Ta tâche est de trouver deux indices distincts `i` et `j` tels que `nums[i] + nums[j] == target`. Utilise la technique des deux pointeurs pour résoudre ce problème efficacement. Si aucune paire de ce type n'existe, retourne `None`... | ["\nassert two_sum_sorted_list([1, 2, 3, 4, 6], 8) == (1, 3)\n", "\nassert two_sum_sorted_list([1, 2, 3, 4, 6], 10) == (2, 4)\n", "\nassert two_sum_sorted_list([1, 2, 3, 4, 6], 5) == (0, 3)\n", "\nassert two_sum_sorted_list([1, 2, 3, 4, 6], 7) == (1, 2)\n", "\nassert two_sum_sorted_list([1, 2, 3, 4, 6], 12) == None\n",... |
0e946c0ed8dc5ffa8d29b33808872004 | [
{
"content": "On te donne une liste d'entiers `nums` qui peut contenir des doublons. Ta tâche est d'écrire une fonction `find_kth_smallest` qui renvoie le k-ième plus petit élément de la liste. La fonction doit gérer l'indexation à base 1 pour `k`.\n\n**Entrée :**\n- Une liste d'entiers `nums` (1 ≤ len(nums) ≤ ... | ["\nassert find_kth_smallest([3, 2, 1, 5, 4], 3) == 3\n", "\nassert find_kth_smallest([7, 10, 4, 3, 20, 15], 4) == 7\n", "\nassert find_kth_smallest([1, 2, 3, 4, 5, 6], 1) == 1\n", "\nassert find_kth_smallest([10, 20, 30, 40, 50], 5) == 50\n", "\nassert find_kth_smallest([5, 5, 5, 5, 5], 3) == 5\n", "\nassert find_kth_... |
ce179aa022fd0ce18d04f8ac4c6eba48 | [
{
"content": "On te donne un tableau d'entiers. Implémente une version optimisée de l'algorithme de tri à bulles qui arrête le processus de tri si aucun échange n'est effectué lors d'un passage dans le tableau. Ta fonction doit renvoyer le tableau trié.\n\n**Entrée :**\n- Une liste d'entiers `arr` (1 ≤ len(arr)... | ["\nassert optimize_bubble_sort([64, 34, 25, 12, 22, 11, 90]) == [11, 12, 22, 25, 34, 64, 90]\n", "\nassert optimize_bubble_sort([5, 1, 4, 2, 8]) == [1, 2, 4, 5, 8]\n", "\nassert optimize_bubble_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert optimize_bubble_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert... |
829cc9b340fa2975a22813e99b2cba74 | [
{
"content": "On te donne un ensemble de données composé de plusieurs échantillons, où chaque échantillon est une liste de fichiers représentés sous forme de dictionnaires. Chaque dictionnaire contient des métadonnées sur un fichier, notamment une clé `config` qui contient des informations sur l'algorithme de t... | ["\nassert delayed_file_merge([[], []], run_parallel) == [[], []]\n", "\nassert delayed_file_merge([[{\"config\": {\"algorithm\": {\"merge_bamprep\": False}}, \"name\": \"file1.bam\"}]], run_parallel) == [[{\"config\": {\"algorithm\": {\"merge_bamprep\": False}}, \"name\": \"file1.bam\"}]]\n", "\nassert delayed_file_me... |
3038d41690726241aa1ffb7c031ab6c0 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'optimiser une fonction pour trouver le deuxième plus petit entier de la liste. La fonction doit avoir une complexité temporelle inférieure à O(n^2). Implémente la fonction optimisée et fournis les versions originale et optimisée à titre de comparaiso... | ["\nassert second_smallest([2, 1, 3, 4, 5]) == 2\n", "\nassert second_smallest([5, 4, 3, 2, 1]) == 2\n", "\nassert second_smallest([10, 20, 30, 40, 50]) == 20\n", "\nassert second_smallest([1, 1, 2, 2, 3, 3]) == 2\n", "\nassert second_smallest([100, 200]) == 200\n", "\nassert second_smallest([7, 7, 7, 7, 8]) == 8\n", "... |
8fb83697a5eb26c5bb6951f90d14ee22 | [
{
"content": "On te donne une grille de type treillis de taille `n x n`. Tu commences au coin supérieur gauche de la grille (0,0) et ton objectif est d'atteindre le coin inférieur droit (n-1, n-1). À chaque étape, tu ne peux te déplacer que vers le bas ou vers la droite. Chaque cellule de la grille peut conteni... | ["\nassert find_path(1, [[0]]) == [(0, 0)]\n", "\nassert find_path(2, [[0, 0], [0, 0]]) == [(0, 0), (0, 1), (1, 1)]\n", "\nassert find_path(3, [[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]\n", "\nassert find_path(3, [[0, 1, 0], [0, 0, 0], [0, 0, 0]]) == [(0, 0), (1, 0), (1, 1), (1, 2), ... |
3c9ac88056e5995b33f905e38101e870 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction qui calcule la moyenne et l'écart type de la liste. Si la liste est vide, la fonction doit renvoyer `None` pour la moyenne et l'écart type.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (0 ≤ len(numbers) ≤ 1000).\n\n**Sort... | ["\nassert calculate_mean_std([1, 2, 3, 4, 5]) == (3.0, math.sqrt(2.0))\n", "\nassert calculate_mean_std([10, 10, 10, 10]) == (10.0, 0.0)\n", "\nassert calculate_mean_std([1]) == (1.0, 0.0)\n", "\nassert calculate_mean_std([]) == (None, None)\n", "\nassert calculate_mean_std([5, 15, 25, 35, 45]) == (25.0, math.sqrt(200... |
c2f8c1c08ab40eecc3ea02a801ab2766 | [
{
"content": "On te donne la tâche de concevoir une fonction qui génère un chemin de répertoire temporaire unique à des fins de test. Ce répertoire sera utilisé pour stocker les résultats d'un processus de conversion de fichiers, plus précisément pour convertir des fichiers BCL au format FASTQ. Ta fonction doit... | ["\nassert create_unique_temp_dir(\"/path/to/bcl/files\", \"/path/to/temp/directories\").startswith(\"/path/to/temp/directories/bcl_to_fastq_temp_\")\n", "\nassert create_unique_temp_dir(\"/another/path/to/bcl\", \"/another/temp/path\").startswith(\"/another/temp/path/bcl_to_fastq_temp_\")\n", "\nassert create_unique_t... |
ff1a59f0fd7609477e222f1f4902abd0 | [
{
"content": "Étant donné une liste de chaînes de caractères non vides `words`, détermine la longueur de la chaîne de préfixe commun la plus longue parmi elles. Si aucun préfixe commun n'existe, retourne une chaîne vide `\"\"`.\n\n**Entrée :**\n- Une liste de chaînes de caractères `words` (1 ≤ len(words) ≤ 200)... | ["\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\"]... |
e81353549b13a2ac9f342b7304765992 | [
{
"content": "On te donne une bibliothèque d'une hauteur fixe `H`. Chaque étagère de la bibliothèque a une hauteur fixe `S`, et il y a un espace fixe `G` entre chaque étagère pour faciliter l'accès aux livres. De plus, il y a une garde minimale `C` entre le bas de la bibliothèque et le bas de l'étagère inférieu... | ["\nassert max_shelves(200, 20, 10, 5) == 8\n", "\nassert max_shelves(150, 30, 5, 10) == 4\n", "\nassert max_shelves(100, 25, 5, 5) == 3\n", "\nassert max_shelves(300, 50, 10, 20) == 5\n", "\nassert max_shelves(100, 50, 10, 60) == 0\n", "\nassert max_shelves(200, 20, 0, 0) == 10\n", "\nassert max_shelves(100, 100, 10, ... |
d14249110696a4a29d4f5492f52a5c7c | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres majuscules et minuscules et de chiffres. Ta tâche est d'écrire une fonction qui supprime tous les chiffres de la chaîne et renvoie la chaîne résultante. La fonction doit être efficace et gérer les chaînes de différentes longueurs, y comp... | ["\nassert remove_digits(\"abc123def456\") == \"abcdef\"\n", "\nassert remove_digits(\"noDigitsHere\") == \"noDigitsHere\"\n", "\nassert remove_digits(\"1234567890\") == \"\"\n", "\nassert remove_digits(\"\") == \"\"\n", "\nassert remove_digits(\"a1b2c3d4e5f6g7h8i9j0\") == \"abcdefghij\"\n", "\nassert remove_digits(\"1... |
fb83206007cef69e082e5f9d1a5f70dc | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation** : Créer un compte bancaire avec un solde initial de 0.\n- **Dépôt** : Ajouter un montant spécifié au solde du compte si le montant est positif.\n- **R... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount().deposit(100) is None\n", "\nassert BankAccount().withdraw(100) == False\n", "\naccount = BankAccount(); account.deposit(100); assert account.get_balance() == 100\n", "\naccount = BankAccount(); account.deposit(100); account.withdraw(50); assert acc... |
6f9b6251c6a6c5883c276d7b9dc9d84b | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est de créer une fonction qui renvoie un dictionnaire associant chaque chaîne de caractères à sa longueur. Implémente cette fonctionnalité en une seule ligne de code en utilisant une compréhension de dictionnaire.\n\n**Exemple d'entrée :... | ["\nassert strings_to_length_dict([\"apple\", \"banana\", \"cherry\"]) == {\"apple\": 5, \"banana\": 6, \"cherry\": 6}\n", "\nassert strings_to_length_dict([]) == {}\n", "\nassert strings_to_length_dict([\"\"]) == {\"\" : 0}\n", "\nassert strings_to_length_dict([\"a\", \"ab\", \"abc\"]) == {\"a\": 1, \"ab\": 2, \"abc\"... |
d0bff2e2f059bc3651558aa41d3883e4 | [
{
"content": "Tu participes à une compétition d'algorithmes génétiques où l'objectif est de maximiser la fonction \\( f(x) = x^3 - 3x^2 + 2x \\) pour \\( x \\) dans l'intervalle \\([-10, 10]\\). Ta tâche est d'implémenter une méthode de sélection par tournoi avec une taille de tournoi de 3. Cette méthode doit s... | ["\nassert len(tournament_selection([random.uniform(-10, 10) for _ in range(10)], 10)) == 2\n", "\nassert all(isinstance(i, int) for i in tournament_selection([random.uniform(-10, 10) for _ in range(10)], 10))\n", "\nassert all(0 <= i < 10 for i in tournament_selection([random.uniform(-10, 10) for _ in range(10)], 10))... |
328779f424a9a6086ac3cdc81668ba12 | [
{
"content": "On te donne deux entiers, `n` et `limit`. Ta tâche est d'écrire une fonction `find_multiples(n, limit)` qui renvoie une chaîne de multiples de `n` jusqu'à `limit`, séparés par un seul espace. Les multiples doivent être en ordre croissant, en commençant par le plus petit multiple de `n` supérieur o... | ["\nassert find_multiples(7, 50) == \"7 14 21 28 35 42 49\"\n", "\nassert find_multiples(-7, -50) == \"0 -7 -14 -21 -28 -35 -42 -49\"\n", "\nassert find_multiples(-7, 50) == \"0 -7 -14 -21 -28 -35 -42 -49\"\n", "\nassert find_multiples(1, 10) == \"1 2 3 4 5 6 7 8 9 10\"\n", "\nassert find_multiples(10, 1) == \"\"\n", "... |
09423033dc22c93a54709ef277be9d96 | [
{
"content": "On te demande d'implémenter une fonction qui sérialise un dictionnaire Python contenant diverses données numériques, y compris des objets non sérialisables, et de l'enregistrer sous forme de fichier .mat. Le dictionnaire peut contenir des objets tels que des listes, des tuples ou d'autres structur... | ["\nassert serialize_dict_to_mat({'key1': np.array([1, 2, 3])}, 'test1.mat') == 'test1.mat'\n", "\nassert serialize_dict_to_mat({'key1': [1, 2, 3], 'key2': [4, 5, 6]}, 'test2.mat') == 'test2.mat'\n", "\nassert serialize_dict_to_mat({'key1': np.array([[1, 2], [3, 4]])}, 'test3.mat') == 'test3.mat'\n", "\nassert serializ... |
50fcd4bc8f6763917319ba78979895c4 | [
{
"content": "On te donne un jeu appelé « Balle Chanceuse » où il y a 5 balles à motifs uniques dans un chapeau : Rouge à Rayures, Bleu à Pois, Vert Tacheté, Jaune Marbré et Violet Tourbillonnant. Chaque balle a une valeur de point spécifique : Rouge à Rayures (5 points), Bleu à Pois (3 points), Vert Tacheté (1... | ["\nassert simulate_lucky_ball() >= 0 and simulate_lucky_ball() <= 19\n", "\nassert simulate_lucky_ball() != 20 # Since the maximum possible score is 19\n", "\nassert simulate_lucky_ball() != -1 # Since the minimum possible score is 0\n", "\nassert simulate_lucky_ball() == 15 if simulate_lucky_ball() == 15 else True ... |
a73191a67c7dcbfa6c7e695ee47de721 | [
{
"content": "On te donne une chaîne de caractères `text` contenant un mélange de mots et de phrases. Ta tâche est de mettre en œuvre une fonction `extract_names` qui identifie et extrait tous les noms de la chaîne. Un nom est défini comme une séquence de deux mots commençant par une majuscule, séparés par un s... | ["\nassert extract_names(\"John Doe and Jane Smith are attending.\") == [\"John Doe\", \"Jane Smith\"]\n", "\nassert extract_names(\"Alice Johnson is here with Bob Brown.\") == [\"Alice Johnson\", \"Bob Brown\"]\n", "\nassert extract_names(\"No names here.\") == []\n", "\nassert extract_names(\"SingleNameOnly\") == []\... |
05b30de70722c21268b982eb99e3e14a | [
{
"content": "On te donne un fichier texte qui contient des données sur les interactions entre des entités, chacune identifiée par une chaîne de caractères unique (par exemple, \"A1\", \"B2\"). Chaque interaction est décrite par une ligne dans le fichier, qui inclut les identifiants des deux entités interagissa... | ["\nassert read_interactions(\"test1.txt\") == ({'A1': {'B2': 3.5}, 'B2': {'A1': 3.5}}, {'A1': {'B2': 4.7}, 'B2': {'A1': 4.7}})\n", "\nassert read_interactions(\"test2.txt\") == ({'X1': {'Y2': 2.5, 'Z3': 3.6}, 'Y2': {'X1': 2.5}, 'Z3': {'X1': 3.6}}, {'X1': {'Y2': 4.0, 'Z3': 5.0}, 'Y2': {'X1': 4.0}, 'Z3': {'X1': 5.0}})\n... |
1a30be663581f2b8e52042b081d09477 | [
{
"content": "On te donne trois entiers : `num1`, `num2` et `num3`. Ta tâche est de mettre en œuvre une fonction `add_and_compare` qui calcule la somme de `num1` et `num2`. Si cette somme est supérieure à `num3`, la fonction doit renvoyer la somme ; sinon, elle doit renvoyer `num3`. La fonction doit s'assurer q... | ["\nassert add_and_compare(1, 2, 3) == 3\n", "\nassert add_and_compare(5, 5, 8) == 10\n", "\nassert add_and_compare(-1, -2, -3) == -1\n", "\nassert add_and_compare(-5, 5, 0) == 0\n", "\nassert add_and_compare(100, 200, 150) == 300\n", "\nassert add_and_compare(0, 0, 0) == 0\n", "\nassert add_and_compare(10, -10, 5) == ... |
7ba37ce10628f8bd1ca6b87ad0627ae6 | [
{
"content": "On te demande d'implémenter une fonction `color_text` qui traite une chaîne de caractères contenant des requêtes de couleur imbriquées. Chaque requête de couleur est dénotée par des crochets au format `[color:text]`, où `color` peut être l'une des valeurs suivantes : 'red', 'yellow', 'green', 'gre... | ["\nassert color_text(\"This is [red:important [yellow:urgent]] text.\") == \"\\033[31mThis is \\033[33murgent\\033[0m\\033[0m text.\"\n", "\nassert color_text(\"This is [green:ok] text.\") == \"\\033[32mThis is ok\\033[0m text.\"\n", "\nassert color_text(\"[blue:unsupported] This should not be blue.\") == \"[blue:unsu... |
566aa4d33e4c87deb253b7a31b94ff27 | [
{
"content": "Tu développes une fonctionnalité pour une plateforme de réseaux sociaux qui nécessite d'organiser les messages par utilisateur. Chaque message est représenté comme un dictionnaire avec les clés `user_id`, `message_text` et `timestamp`. Ta tâche est d'implémenter une fonction `group_messages_by_use... | ["\nassert group_messages_by_user([]) == {}\n", "\nassert group_messages_by_user([{\"user_id\": 1, \"message_text\": \"Hello!\", \"timestamp\": 1633072800}]) == {1: [{\"user_id\": 1, \"message_text\": \"Hello!\", \"timestamp\": 1633072800}]}\n", "\nassert group_messages_by_user([{\"user_id\": 1, \"message_text\": \"Hel... |
4caeeda0bcd2e16c45eb284344b857e6 | [
{
"content": "Dans le domaine de l'apprentissage automatique, la précision et le rappel sont des mesures essentielles pour évaluer les performances des modèles de classification binaire. Le rappel est défini comme le rapport entre les prédictions de vrais positifs et le nombre total d'instances positives réelle... | ["\nassert calculate_recall(100, 20, 30, 50) == 100 / 130\n", "\nassert calculate_recall(0, 0, 0, 100) == 0.0\n", "\nassert calculate_recall(1000000000000000000, 0, 0, 0) == 1.0\n", "\nassert calculate_recall(1, 1, 1, 1) == 0.5\n", "\nassert calculate_recall(999999999999999999, 1, 1, 1) == 999999999999999999 / 10000000... |
f57a62bb4df8ee6473c230b47e7e151b | [
{
"content": "On te demande de traiter une liste d'enregistrements d'employés. Chaque enregistrement est représenté comme un dictionnaire avec les clés \"name\", \"department\" et \"salary\". Ton objectif est d'implémenter une fonction `group_by_department(employee_records)` qui organise ces enregistrements dan... | ["\nassert group_by_department([{\"name\": \"Alice\", \"department\": \"Engineering\", \"salary\": 90000}]) == {\"Engineering\": [\"Alice\"]}\n", "\nassert group_by_department([{\"name\": \"Bob\", \"department\": \"Marketing\", \"salary\": 85000}, {\"name\": \"Charlie\", \"department\": \"Engineering\", \"salary\": 880... |
60c8fbea901ed3bec52a5b60e8256f39 | [
{
"content": "On te donne une liste de `n` mots. Ta tâche est de déterminer le nombre minimum d'échanges adjacents nécessaires pour trier la liste par ordre lexicographique.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 1000), le nombre de mots.\n- Les `n` lignes suivantes contiennent les... | ["\nassert min_adjacent_swaps_to_sort([\"apple\", \"banana\", \"orange\"]) == 2\n", "\nassert min_adjacent_swaps_to_sort([\"banana\", \"apple\", \"orange\"]) == 2\n", "\nassert min_adjacent_swaps_to_sort([\"apple\", \"orange\", \"banana\"]) == 2\n", "\nassert min_adjacent_swaps_to_sort([\"apple\", \"apple\", \"banana\"... |
7ccf8644a0fb20da96f7fb0f161887b2 | [
{
"content": "On te donne un entier positif représentant une durée en secondes. Ta tâche est d'écrire une fonction Python qui convertit cette durée en nombre équivalent de jours, d'heures, de minutes et de secondes. La fonction doit renvoyer ces valeurs sous la forme d'un tuple dans l'ordre (jours, heures, minu... | ["\nassert convert_seconds(0) == (0, 0, 0, 0)\n", "\nassert convert_seconds(60) == (0, 0, 1, 0)\n", "\nassert convert_seconds(3600) == (0, 1, 0, 0)\n", "\nassert convert_seconds(86400) == (1, 0, 0, 0)\n", "\nassert convert_seconds(90061) == (1, 1, 1, 1)\n", "\nassert convert_seconds(31536000) == (365, 0, 0, 0)\n", "\na... |
cc1455ffd6c181c95055694f1797145d | [
{
"content": "On te donne une liste de phrases. Ta tâche est d'identifier les `n` séquences de trois mots consécutifs (trigrammes) les plus fréquentes dans la liste, en veillant à ce qu'aucun trigramme ne contienne de mots vides. Les mots vides sont des mots courants qui sont souvent supprimés des données textu... | ["\nassert top_n_trigrams([\"hello world this is a test\", \"this is a test of the system\"], 2) == [(('this', 'is', 'a'), 2), (('a', 'test', 'of'), 1)]\n", "\nassert top_n_trigrams([\"one two three\", \"four five six\", \"one two three\"], 1) == [(('one', 'two', 'three'), 2)]\n", "\nassert top_n_trigrams([\"the quick ... |
eebf9b2b8736322b4d7a8eb5971851e9 | [
{
"content": "On te demande d'implémenter une fonction nommée `is_valid_file` qui évalue si un chemin de fichier donné est valide en fonction d'un ensemble d'extensions de fichier autorisées. La fonction doit respecter les critères suivants :\n\n1. Le chemin de fichier doit être débarrassé de tout espace blanc ... | ["\nassert is_valid_file(\"test.txt\", {\"txt\"}) == True\n", "\nassert is_valid_file(\" test.txt \", {\"txt\"}) == True\n", "\nassert is_valid_file(\"test..txt\", {\"txt\"}) == False\n", "\nassert is_valid_file(\"tes.txt\", {\"txt\"}) == False\n", "\nassert is_valid_file(\"test.doc\", {\"txt\"}) == False\n", "\nas... |
cd531e691ffae04337c33dbe2a950eec | [
{
"content": "On te demande d'écrire une fonction `count_leap_years(start_year, end_year)` qui calcule le nombre total d'années bissextiles entre deux années données, `start_year` et `end_year` (incluses). Une année bissextile est définie comme une année divisible par 4, à l'exception des années de fin de siècl... | ["\nassert count_leap_years(1600, 1600) == 1\n", "\nassert count_leap_years(1700, 1700) == 0\n", "\nassert count_leap_years(1752, 1752) == 1\n", "\nassert count_leap_years(1600, 1700) == 88\n", "\nassert count_leap_years(1752, 1800) == 12\n", "\nassert count_leap_years(1800, 1900) == 24\n", "\nassert count_leap_years(1... |
dc0ed73e7c7ecaf4d0c3c3944fa434a8 | [
{
"content": "Implémente une classe Python nommée `Car` pour modéliser une voiture avec les spécifications suivantes :\n- Attributs : `make`, `model`, `year`, et `is_running` (initialement défini sur `False`).\n- Méthodes :\n - `start()` : Change l'état de `is_running` à `True` si la voiture n'est pas déjà en ... | ["\nassert Car(\"Toyota\", \"Corolla\", 2021).make == \"Toyota\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2021).model == \"Corolla\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2021).year == 2021\n", "\nassert Car(\"Toyota\", \"Corolla\", 2021).is_running == False\n", "\ncar = Car(\"Honda\", \"Civic\", 2020); car.star... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.