id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
e336dc067498dda27e91c183b2052ae5 | [
{
"content": "On te demande d'implémenter une fonction pour interroger une table de base de données nommée `Items`. La table se compose des colonnes suivantes : `ItemId`, `Name`, `Category`, `Status` et `Timestamp`. La colonne `Status` indique la disponibilité d'un article, `0` désignant \"disponible\" et `1` d... | ["\nassert get_items(c) == c.execute(\"SELECT ItemId, Name, Category, Status, Timestamp FROM Items\").fetchall()\n", "\nassert get_items(c, status=0) == c.execute(\"SELECT ItemId, Name, Category, Status, Timestamp FROM Items WHERE Status = 0\").fetchall()\n", "\nassert get_items(c, status=1) == c.execute(\"SELECT ItemI... |
bac9ed958cb147992f6785ad0a343473 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer si tous les caractères de la chaîne sont uniques. Implémente une fonction `unique_chars(s)` qui renvoie `True` si tous les caractères de la chaîne sont uniques, et `False` sino... | ["\nassert unique_chars(\"abcdef\") == True\n", "\nassert unique_chars(\"aabbcc\") == False\n", "\nassert unique_chars(\"abcabc\") == False\n", "\nassert unique_chars(\"xyz\") == True\n", "\nassert unique_chars(\"xyzz\") == False\n", "\nassert unique_chars(\"\") == True\n", "\nassert unique_chars(\"a\") == True\n", "\n... |
945043529ce5d7d72cbdd465248499f4 | [
{
"content": "Implémente l'algorithme de tri \"Min-Max\" pour trier une liste d'entiers donnée. L'algorithme fonctionne en trouvant itérativement les éléments minimum et maximum de la portion non triée de la liste et en les plaçant respectivement au début et à la fin de cette portion. Ce processus est répété ju... | ["\nassert min_max_sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]\n", "\nassert min_max_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert min_max_sort([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert min_max_sort([5, 3, ... |
3f45d38b888ef3ff0aef45ca72635178 | [
{
"content": "Tu es chargé d'implémenter un simple algorithme de chiffrement XOR. Ta fonction doit prendre deux paramètres : une chaîne de caractères `text` et une chaîne de caractères `key`. La fonction doit renvoyer la chaîne chiffrée sous forme de chaîne hexadécimale. Le processus de chiffrement XOR consiste... | ["\nassert xor_encrypt(\"Hello, World!\", \"key\") == \"1c151b0b1e1b000e0b1e1b00\"\n", "\nassert xor_encrypt(\"abc\", \"a\") == \"000102\"\n", "\nassert xor_encrypt(\"abc\", \"abc\") == \"000000\"\n", "\nassert xor_encrypt(\"secret\", \"key\") == \"1c151b0b1e1b\"\n", "\nassert xor_encrypt(\"Python\", \"123\") == \"1f1c... |
b2183e2c532dcd44f461ebdc3c07e53a | [
{
"content": "Tu es chargé d'implémenter une fonction `convert_to_roman(num)` qui convertit un entier donné en sa représentation en chiffres romains. La fonction doit gérer les entiers compris entre 1 et 3999 inclus. Si l'entrée est en dehors de cette plage ou n'est pas un entier, la fonction doit renvoyer la c... | ["\nassert convert_to_roman(1) == \"I\"\n", "\nassert convert_to_roman(4) == \"IV\"\n", "\nassert convert_to_roman(9) == \"IX\"\n", "\nassert convert_to_roman(58) == \"LVIII\"\n", "\nassert convert_to_roman(1994) == \"MCMXCIV\"\n", "\nassert convert_to_roman(3999) == \"MMMCMXCIX\"\n", "\nassert convert_to_roman(0) == \... |
fad1780303497b1bebc91406e6bd5a63 | [
{
"content": "On te donne un tableau d'entiers `arr` et un entier `threshold`. Ta tâche est de trouver la somme maximale de n'importe quel sous-tableau non vide de `arr` telle que la somme soit strictement inférieure à `threshold`. Si un tel sous-tableau n'existe pas, retourne `None`.\n\n**Entrée :**\n- La prem... | ["\nassert max_sum_subarray_less_than_threshold([1, 2, 3], 6) == 5\n", "\nassert max_sum_subarray_less_than_threshold([1, 2, 3], 1) == None\n", "\nassert max_sum_subarray_less_than_threshold([5, 5, 5, 5], 15) == 10\n", "\nassert max_sum_subarray_less_than_threshold([-1, -2, -3, -4], -5) == -6\n", "\nassert max_sum_suba... |
2289db854b2f37d58f9ccbee7966594d | [
{
"content": "On te demande d'implémenter une fonction `validate_date(date_str)` qui vérifie la validité d'une chaîne de caractères représentant une date. La chaîne de caractères de la date est formatée comme `AAAA-MM-JJ`. Ta fonction doit renvoyer `True` si la date est valide, en tenant compte des années bisse... | ["\nassert validate_date(\"2023-02-29\") == False\n", "\nassert validate_date(\"2024-02-29\") == True\n", "\nassert validate_date(\"2023-04-31\") == False\n", "\nassert validate_date(\"2023-06-30\") == True\n", "\nassert validate_date(\"2023-12-31\") == True\n", "\nassert validate_date(\"2023-01-00\") == False\n", "\na... |
1783b8eaa0bf277b5fb107b1586bde3c | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver les indices des deux nombres dans `nums` qui s'additionnent pour donner `target`. Si aucune paire de ce type n'existe, renvoie une liste vide. S'il existe plusieurs paires valides, renvoie les indices de la prem... | ["\nassert two_sum([2, 7, 11, 15], 9) == [0, 1]\n", "\nassert two_sum([3, 2, 4], 6) == [1, 2]\n", "\nassert two_sum([3, 3], 6) == [0, 1]\n", "\nassert two_sum([1, 2, 3, 4, 5], 9) == [3, 4]\n", "\nassert two_sum([1, 2, 3, 4, 5], 10) == [3, 4]\n", "\nassert two_sum([1, 2, 3, 4, 5], 8) == [2, 4]\n", "\nassert two_sum([1, ... |
a80611ec48c23731c800d6e5821f9fe0 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de déterminer la longueur de la plus longue sous-séquence croissante (LIS) dans la liste. Une sous-séquence croissante est définie comme une séquence où chaque élément est supérieur au précédent. La sous-séquence n'a pas besoin d'être contiguë.\n\n**En... | ["\nassert length_of_lis([10, 9, 2, 5, 3, 7, 101, 18]) == 4\n", "\nassert length_of_lis([0, 1, 0, 3, 2, 3]) == 4\n", "\nassert length_of_lis([7, 7, 7, 7, 7, 7, 7]) == 1\n", "\nassert length_of_lis([1, 2, 3, 4, 5]) == 5\n", "\nassert length_of_lis([5, 4, 3, 2, 1]) == 1\n", "\nassert length_of_lis([1]) == 1\n", "\nassert... |
240cb6b74883896c40976cf62c6285ac | [
{
"content": "On te demande d'implémenter une fonction `_stub_return_zero_if_even` qui traite un nombre variable d'arguments. La fonction doit calculer la somme de tous les arguments entiers, en ignorant les arguments qui ne sont pas des entiers. Si la somme calculée est paire, la fonction doit renvoyer 0 ; sin... | ["\nassert _stub_return_zero_if_even(1, 2, 3) == 6\n", "\nassert _stub_return_zero_if_even(2, 4, 6) == 0\n", "\nassert _stub_return_zero_if_even(1, 3, 5, 7) == 16\n", "\nassert _stub_return_zero_if_even(0, 0, 0) == 0\n", "\nassert _stub_return_zero_if_even(1, 'a', 3.5, 5) == 6\n", "\nassert _stub_return_zero_if_even('h... |
d5743e71d791dc7e963c3967b499035c | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'inverser la chaîne sans utiliser de découpage. Implémente plusieurs méthodes pour accomplir cette tâche. Chaque méthode doit être implémentée dans une fonction séparée.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 1000).\... | ["\nassert reverse_string_method_1(\"hello\") == \"olleh\"\n", "\nassert reverse_string_method_2(\"world\") == \"dlrow\"\n", "\nassert reverse_string_method_3(\"python\") == \"nohtyp\"\n", "\nassert reverse_string_method_4(\"!@#$%^&*()\") == \")(*&^%$#@!\"\n", "\nassert reverse_string_method_5(\"12345\") == \"54321\"\n... |
9d06c30c749a411c5a0588909434b5c0 | [
{
"content": "On te donne un dictionnaire où les clés sont les noms de pays et les valeurs sont des dictionnaires représentant le PIB par habitant de ce pays pour les trois dernières années. Ta tâche est d'écrire une fonction nommée `calculate_average_gdp_per_capita` qui calcule le PIB par habitant moyen sur le... | ["\nassert calculate_average_gdp_per_capita({\"USA\": {\"2020\": 62745, \"2021\": 64682, \"2022\": 66789}}) == {\"USA\": 64738.666666666664}\n", "\nassert calculate_average_gdp_per_capita({\"Canada\": {\"2020\": 45990, \"2021\": 47818, \"2022\": 49656}}) == {\"Canada\": 47821.333333333336}\n", "\nassert calculate_avera... |
2da5738066137bb7699abda8f1209d82 | [
{
"content": "On te charge de gérer une base de données de jeux multijoueurs en ligne. Chaque jeu peut avoir plusieurs instances en cours d'exécution simultanément, et chaque instance possède un identifiant unique ainsi qu'une liste des joueurs qui y ont participé. Ton objectif est d'implémenter une fonction `g... | ["\nassert get_game_instances('Dota 2', 'player1@example.com', {'Dota 2': {'instance_1': ['player1@example.com'], 'instance_2': ['player1@example.com']}}) == ['instance_1', 'instance_2']\n", "\nassert get_game_instances('Hearthstone', 'player2@example.com', {'Hearthstone': {'instance_7': ['player2@example.com']}}) == [... |
01666ac710977ffa9b1e4ab0beb1bc7e | [
{
"content": "On te donne une liste d'entiers `numbers`. Ta tâche est d'implémenter une fonction `remove_duplicates` qui supprime tous les éléments dupliqués de la liste tout en conservant l'ordre d'origine des éléments. La fonction doit renvoyer la liste résultante.\n\n**Entrée :**\n- Une liste d'entiers `numb... | ["\nassert remove_duplicates([1, 2, 3, 2, 1, 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([7, 8, 9]) == [7, 8, 9]\n", "\nassert remove_dupl... |
9b648116906376acd95c3e475ba629d0 | [
{
"content": "On te donne la tâche d'optimiser une fonction pour calculer la factorielle d'un entier non négatif `n`. L'implémentation récursive actuelle est inefficace et peut entraîner un dépassement de pile pour les grandes valeurs de `n`. Ton objectif est d'implémenter une version itérative de la fonction f... | ["\nassert factorial_iterative(0) == 1\n", "\nassert factorial_iterative(1) == 1\n", "\nassert factorial_iterative(5) == 120\n", "\nassert factorial_iterative(10) == 3628800\n", "\nassert factorial_iterative(12) == 479001600\n", "\nassert factorial_iterative(15) == 1307674368000\n", "\nassert factorial_iterative(20) ==... |
a1f5ebe0c5c2e2b71d6653766d698880 | [
{
"content": "On te donne un tableau `daily_sales` de `n` entiers, où chaque entier représente les ventes d'un magasin un jour donné. Ta tâche est de calculer le total cumulé des ventes jusqu'à chaque jour, en tenant compte d'une promotion spéciale tous les 3 jours. Lors de ces journées de promotion, les ventes... | ["\nassert running_totals_with_promotion([100, 200, 150]) == [100, 300, 600]\n", "\nassert running_totals_with_promotion([10, 20, 30, 40, 50, 60]) == [10, 30, 90, 130, 180, 330]\n", "\nassert running_totals_with_promotion([50, 50, 50, 50, 50, 50, 50]) == [50, 100, 200, 250, 300, 550, 600]\n", "\nassert running_totals_w... |
4be1828d950aff5ed386c2f120a68d1c | [
{
"content": "On te demande d'implémenter un jeu de Bataille Navale simple en mode texte. Le jeu se déroule sur une grille de 5x5. Un seul navire est placé aléatoirement sur la grille. Le joueur a jusqu'à 4 tentatives pour deviner la position du navire. Après chaque tentative, le joueur est informé si sa suppos... | ["\nassert create_grid(5) == [['O', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', 'O', 'O']]\n", "\nassert create_grid(3) == [['O', 'O', 'O'], ['O', 'O', 'O'], ['O', 'O', 'O']]\n", "\nassert check_guess((2, 2), (2, 2)) == True\n", "\nassert check_g... |
10bf5648cb828d1ab5a2d050b0e652c4 | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'écrire une fonction Python `find_common_elements` qui renvoie une liste d'entiers qui sont présents dans les deux listes d'entrée. La fonction doit être optimisée pour la performance et ne doit pas effectuer d'opérations inutiles. L'ordre des éléme... | ["\nassert find_common_elements([1, 2, 3], [3, 4, 5]) == [3]\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\nassert find_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert ... |
f84b0647a7479f75af7bfaf7c7dba8b3 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres majuscules et minuscules, d'espaces et de ponctuation. Ta tâche est de déterminer si la chaîne est un palindrome, en ignorant les espaces, la ponctuation et la casse. Un palindrome est une chaîne qui se lit de la même manière de gauche à... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\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", "\nas... |
b34084e895c70422807e74e005e042d9 | [
{
"content": "On te demande de développer une fonction `estimate_house_price` qui calcule le prix estimé d'une maison en fonction de ses caractéristiques. La fonction doit accepter quatre paramètres : le nombre de chambres, le nombre de salles de bain, la ville où se trouve la maison et la superficie de la mais... | ["\nassert estimate_house_price(1, 1, \"New York\", 1000) == {\"estimated_price\": 250000.0}\n", "\nassert estimate_house_price(2, 2, \"Los Angeles\", 1500) == {\"estimated_price\": 790000.0}\n", "\nassert estimate_house_price(3, 3, \"Chicago\", 2000) == {\"estimated_price\": 1100000}\n", "\nassert estimate_house_price... |
039a313b9761c14c1ffd105a234033a4 | [
{
"content": "Tu implémentes un système de cache basé sur le temps qui prend en charge les opérations suivantes :\n- `put(key, value)` : Insère une paire clé-valeur dans le cache. Si la clé existe déjà, met à jour la valeur et l'horodatage. Si le cache est plein, évince la paire clé-valeur la moins récemment ut... | ["\nassert TimeBasedCache(3).get(1) == -1\n", "\ncache = TimeBasedCache(3); cache.put(1, 100); assert cache.get(1) == 100\n", "\ncache = TimeBasedCache(3); cache.put(1, 100); cache.put(2, 200); cache.put(3, 300); assert cache.get_range(1, 3) == [(1, 100), (2, 200), (3, 300)]\n", "\ncache = TimeBasedCache(3); cache.put(... |
588f35f76c5a0266054590d74a14852e | [
{
"content": "On te demande d'implémenter une fonction `greet` qui accepte trois paramètres : `some_number` (un entier), `mood` (une chaîne de caractères) et `verbose` (un booléen). La fonction doit afficher un message d'accueil basé sur l'humeur et le niveau de verbosité fournis. La fonction doit respecter les... | ["\nassert greet(42, \"happy\", True) == 42\n", "\nassert greet(0, \"sad\", False) == 0\n", "\nassert greet(-10, \"angry\", True) == -10\n", "\nassert greet(1000000, \"excited\", False) == 1000000\n", "\nassert greet(5, \"\", True) == 5\n", "\nassert greet(7, \"confused\", False) == 7\n", "\nassert greet(1, \"very happ... |
37c1819a8dd1ec2763344b291c5d2f53 | [
{
"content": "On te demande d'implémenter une classe `LRUCache` qui simule le mécanisme de cache du type \"Least Recently Used\" (le moins récemment utilisé). La classe doit prendre en charge les opérations suivantes :\n- `get(key)` : Récupérer la valeur de la clé si elle existe dans le cache, sinon retourner -... | ["\nassert LRUCache(2).get(1) == -1\n", "\ncache = LRUCache(2)\ncache.put(1, 1)\ncache.put(2, 2)\nassert cache.get(1) == 1\n", "\ncache = LRUCache(2)\ncache.put(1, 1)\ncache.put(2, 2)\ncache.put(3, 3)\nassert cache.get(2) == -1\n", "\ncache = LRUCache(2)\ncache.put(1, 1)\ncache.put(2, 2)\ncache.put(3, 3)\ncache.put(4, ... |
1049b0594faa6583820291930bcaa191 | [
{
"content": "On te demande d'implémenter une fonction `calculate_display_length` qui calcule la longueur d'une variable donnée `val` lorsqu'elle est affichée sous forme de chaîne de caractères. La fonction doit gérer les types de données suivants :\n\n- **Chaîne de caractères (`str`)** : Retourne la longueur d... | ["\nassert calculate_display_length(\"hello\") == 5\n", "\nassert calculate_display_length(12345678) == 8\n", "\nassert calculate_display_length(12321) == 9\n", "\nassert calculate_display_length(123.456789) == 14\n", "\nassert calculate_display_length(123.0) == 12\n", "\nassert calculate_display_length(True) == 4\n", ... |
50d911a78e63018770f9a6de2c778358 | [
{
"content": "Étant donné deux chaînes de caractères `str1` et `str2` composées de lettres minuscules en anglais et de chiffres, détermine la plus longue sous-chaîne commune entre elles. Traite les chiffres comme des caractères distincts. Ta fonction doit renvoyer un tuple contenant les indices de début et de f... | ["\nassert longest_common_substring(\"abc123def\", \"xyz123def456\") == (2, 8, 3, 9)\n", "\nassert longest_common_substring(\"abc\", \"def\") == None\n", "\nassert longest_common_substring(\"abcabc\", \"abc\") == (0, 2, 0, 2)\n", "\nassert longest_common_substring(\"12345\", \"54321\") == (4, 4, 0, 0)\n", "\nassert lon... |
18c93e1ade3c736f114a324c638452dc | [
{
"content": "On te donne une liste de `n` chaînes de caractères, chacune composée de lettres minuscules de l'alphabet anglais. Ta tâche est de regrouper les chaînes qui sont des anagrammes les unes des autres. Deux chaînes sont des anagrammes si elles contiennent les mêmes caractères dans n'importe quel ordre.... | ["\nassert group_anagrams([\"cat\", \"dog\", \"tac\", \"god\", \"act\"]) == [[\"cat\", \"tac\", \"act\"], [\"dog\", \"god\"]]\n", "\nassert group_anagrams([\"listen\", \"silent\", \"enlist\"]) == [[\"listen\", \"silent\", \"enlist\"]]\n", "\nassert group_anagrams([\"a\", \"b\", \"c\", \"d\"]) == [[\"a\"], [\"b\"], [\"c... |
d4d80d1fab6a638c1f57eb386754a26d | [
{
"content": "On te donne une grille 2D représentant une carte où chaque cellule est soit vide (indiquée par `0`), soit contient un obstacle (indiquée par `1`). On te fournit également une position de départ `(x, y)` dans la grille. Ta tâche est de déterminer les coordonnées de toutes les cellules voisines qui ... | ["\nassert find_empty_neighbors([[0, 0, 0], [0, 1, 0], [0, 0, 0]], (1, 1)) == [(0, 1), (1, 0), (1, 2), (2, 1)]\n", "\nassert find_empty_neighbors([[1, 1, 1], [1, 1, 1], [1, 1, 1]], (1, 1)) == []\n", "\nassert find_empty_neighbors([[0, 0], [0, 0]], (0, 0)) == [(0, 1), (1, 0)]\n", "\nassert find_empty_neighbors([[0, 0], ... |
ee5014188b6e7443b59a3ce960679596 | [
{
"content": "On te demande d'implémenter un générateur de numéros de loterie simple. Ton programme doit afficher un ensemble de 6 entiers aléatoires uniques, chacun compris entre 1 et 49 inclusivement. La sortie doit représenter les numéros gagnants de la loterie pour un tirage.\n\n**Entrée :**\nAucune entrée ... | ["\nassert len(generate_lottery_numbers()) == 6\n", "\nassert all(1 <= num <= 49 for num in generate_lottery_numbers())\n", "\nassert len(set(generate_lottery_numbers())) == 6\n", "\nassert isinstance(generate_lottery_numbers(), list)\n", "\nassert all(isinstance(num, int) for num in generate_lottery_numbers())\n", "\n... |
200421f8fd56f1284d4bdf865dba6017 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de calculer le produit de ces entiers avec une particularité : le signe de chaque entier dans le produit est déterminé par la primalité de son indice. Plus précisément, si l'indice est un nombre premier, le signe de l'entier correspondant est négatif ;... | ["\nassert multiply_alternate([-5, 10, -15, 21, 22]) == -78750\n", "\nassert multiply_alternate([1, 2, 3, 4, 5, 6]) == -720\n", "\nassert multiply_alternate([2, 3, 5, 7, 11, 13]) == -30030\n", "\nassert multiply_alternate([0, 1, 2, 3, 4, 5]) == 0\n", "\nassert multiply_alternate([1]) == 1\n", "\nassert multiply_alterna... |
252f36689cbad1fe9a631ec3bdb2a6b9 | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est de déterminer si la liste est alternée. Une liste est considérée comme alternée si la différence absolue entre chaque paire d'éléments consécutifs est la même. Formellement, pour tout `i` de `1` à `n-1` (où `n` est la longueur de la liste), `|nu... | ["\nassert is_alternating([1, 3, 5, 7]) == True\n", "\nassert is_alternating([7, 5, 3, 1]) == True\n", "\nassert is_alternating([1, 2, 3, 4]) == False\n", "\nassert is_alternating([10, 5, 0, -5]) == True\n", "\nassert is_alternating([2, 2, 2, 2]) == True\n", "\nassert is_alternating([1, 4, 7, 10, 13]) == True\n", "\nas... |
965d21c99b3ae9bf543af5e53f495460 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui calcule et renvoie la somme de tous les nombres pairs de la liste. La fonction doit être efficace et concise.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^5), où chaque entier `num` satisfait ... | ["\nassert sum_of_even_numbers([2, 5, 8, 13, 20, 23]) == 30\n", "\nassert sum_of_even_numbers([1, 3, 5, 7, 9]) == 0\n", "\nassert sum_of_even_numbers([0, 2, 4, 6, 8]) == 20\n", "\nassert sum_of_even_numbers([-2, -4, -6, -8]) == -20\n", "\nassert sum_of_even_numbers([]) == 0\n", "\nassert sum_of_even_numbers([10, 15, 20... |
72619bebdcd7c7f2a3db8d037ccf35b5 | [
{
"content": "On te demande d'optimiser une fonction récursive pour calculer le nième nombre de Fibonacci. La fonction doit gérer efficacement les grandes valeurs de n en évitant les calculs redondants. Implémente une technique de mémorisation pour y parvenir.\n\n**Entrée :**\n- Un 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(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(25... |
4ef6f1064d63c1cff239b2f2dcb01c17 | [
{
"content": "On te demande d'implémenter une fonction `memory_difference` qui calcule la différence d'utilisation de la mémoire entre deux instantanés de l'état mémoire d'un programme. Chaque instantané est représenté comme un dictionnaire où les clés sont les identifiants des objets et les valeurs sont leur u... | ["\nassert memory_difference({\"1\": 100, \"2\": 200}, {\"1\": 150, \"2\": 250}) == {\"1\": 50, \"2\": 50}\n", "\nassert memory_difference({\"1\": 100, \"2\": 200}, {\"1\": 50, \"2\": 150}) == {\"1\": -50, \"2\": -50}\n", "\nassert memory_difference({\"1\": 100}, {\"1\": 100}) == {\"1\": 0}\n", "\nassert memory_differe... |
aab72ecb398739b56c04b7c9c32069d6 | [
{
"content": "On te donne un fichier texte nommé `input.txt` contenant une seule ligne de texte. Ta tâche est de lire le fichier, d'extraire tous les mots, de les trier par ordre lexicographique et d'afficher la liste triée des mots. Les mots sont séparés par des espaces et peuvent contenir uniquement des carac... | ["\nassert main() == None\n", "\nassert main() == ['a', 'b', 'c']\n", "\nassert main() == ['apple', 'banana', 'cherry']\n", "\nassert main() == ['1', '2', '3']\n", "\nassert main() == ['!@#', '$%^', '&*(']\n", "\nassert main() == ['hello', 'world']\n", "\nassert main() == ['a', 'A', 'b', 'B']\n", "\nassert main() == ['... |
4cd1d53b86341a0969210db2b066bce4 | [
{
"content": "On te donne une liste de termes de filtre et une liste de noms de colonnes. Chaque terme de filtre est une chaîne de caractères qui représente une condition pour filtrer les données en fonction des noms de colonnes en utilisant des opérateurs de comparaison (`<`, `<=`, `>`, `>=`, `==`, `!=`) et de... | ["\nassert parse_filter_terms(['Age > 30'], ['Age']) == ['Age > 30']\n", "\nassert parse_filter_terms(['Salary <= 50000 AND Age >= 25'], ['Age', 'Salary']) == ['Salary <= 50000 AND Age >= 25']\n", "\nassert parse_filter_terms(['Address == \"New York\"'], ['Age', 'Name', 'Salary']) == None\n", "\nassert parse_filter_ter... |
b7aea96538d2bd1e8034d01fc0137b52 | [
{
"content": "On te demande de refactoriser un script Python qui effectue une analyse statistique de base sur une liste d'entiers. Le script comprend des fonctions pour calculer la moyenne, la médiane et le mode de la liste. Ton objectif est d'améliorer le script en termes de lisibilité et de performance. S'il ... | ["\nassert calculate_mean([1, 2, 3, 4, 5]) == 3\n", "\nassert calculate_mean([10, 20, 30]) == 20\n", "\nassert calculate_median([1, 2, 3, 4, 5]) == 3\n", "\nassert calculate_median([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 5\n", "\nassert calculate_mode([1, 2, 2, 3, 4]) == 2\n", "\nassert calculate_mode([1, 1, 2, 2, 3, 3])... |
6a036597e4c36480362dfc9eac150cc8 | [
{
"content": "On te donne deux sous-réseaux, chacun représenté par un tuple de deux entiers : l'adresse IP et le masque de sous-réseau. Ta tâche est de déterminer si ces deux sous-réseaux se chevauchent. Le chevauchement est défini comme ayant au moins une adresse IP commune dans la plage de chaque sous-réseau,... | ["\nassert subnet_overlap((3232235776, 4294967040), (3232236032, 4294967168)) == False\n", "\nassert subnet_overlap((3232235777, 4294967040), (3232235776, 4294967040)) == True\n", "\nassert subnet_overlap((3232235776, 4294967040), (3232235780, 4294967040)) == True\n", "\nassert subnet_overlap((3232235776, 4294967040), ... |
1e5dd079636a708940163bd78c111294 | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `digit_frequency(n)` qui renvoie un dictionnaire où les clés sont les chiffres présents dans `n` et les valeurs sont le nombre de fois que chaque chiffre apparaît dans `n`, mais seulement lorsqu'il n'est pas immédiatement précédé par le... | ["\nassert digit_frequency(122333) == {1: 1, 2: 1, 3: 1}\n", "\nassert digit_frequency(-112233) == {1: 1, 2: 1, 3: 1}\n", "\nassert digit_frequency(0) == {0: 1}\n", "\nassert digit_frequency(111111) == {1: 1}\n", "\nassert digit_frequency(1234567890) == {1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1, 0: 1}\n", "... |
c8cfee6051ce5dc08d36deec6bc80b8f | [
{
"content": "On te donne un arbre binaire. Implémente une fonction pour effectuer un parcours en profondeur d'abord (in-order) de l'arbre et renvoyer les valeurs des nœuds dans l'ordre où ils ont été visités. Définis une classe `TreeNode` pour représenter chaque nœud de l'arbre.\n\n**Entrée :**\n- La racine de... | ["\nassert inorder_traversal(None) == []\n", "\nassert inorder_traversal(TreeNode(1)) == [1]\n", "\nassert inorder_traversal(TreeNode(2, TreeNode(1), TreeNode(3))) == [1, 2, 3]\n", "\nassert inorder_traversal(TreeNode(4, TreeNode(2, TreeNode(1), TreeNode(3)), TreeNode(6, TreeNode(5), TreeNode(7)))) == [1, 2, 3, 4, 5, 6... |
8fe219b79eeb746d78496d83fc064864 | [
{
"content": "On te donne une liste de chaînes de caractères `strs`. Ta tâche est d'écrire une fonction Python qui trouve la plus longue chaîne de caractères commune à toutes les chaînes données. S'il n'y a pas de préfixe commun, renvoie une chaîne vide `\"\"`.\n\n**Entrée :**\n- Une liste de chaînes de caractè... | ["\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\"]... |
c12089f70f9c55c5f45387d7c538d352 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `sum_of_even_indices` qui calcule la somme des nombres premiers situés aux indices pairs de la liste. Les indices sont basés sur 0, ce qui signifie que les éléments aux indices pairs sont le premier, le troisième, le cinquièm... | ["\nassert sum_of_even_indices([2, 3, 5, 7, 11, 13, 17]) == 24\n", "\nassert sum_of_even_indices([4, 6, 8, 10, 12, 14]) == 0\n", "\nassert sum_of_even_indices([]) == 0\n", "\nassert sum_of_even_indices([3, 1, 7, 5, 11, 9, 13]) == 24\n", "\nassert sum_of_even_indices([17, 23, 19, 29, 2, 31, 37]) == 75\n", "\nassert sum_... |
31293d3917bfe63b9b6ac4bc930cb243 | [
{
"content": "On te donne un ensemble de données d'images catégorisées en différentes classes. Chaque image est représentée par un tuple contenant son chemin d'accès et sa résolution. Ta tâche est de mettre en œuvre une fonction `generate_triplet` qui, étant donné cet ensemble de données, sélectionne un triplet... | ["\nassert generate_triplet({'dogs': [('path/to/dog1.jpg', 720), ('path/to/dog2.jpg', 1080)], 'cats': [('path/to/cat1.jpg', 480), ('path/to/cat2.jpg', 240)]})[1].endswith('.jpg')\n", "\nassert generate_triplet({'dogs': [('path/to/dog1.jpg', 720), ('path/to/dog2.jpg', 1080)], 'cats': [('path/to/cat1.jpg', 480), ('path/t... |
b999fdbb816b00e2b8d3428815cdcc06 | [
{
"content": "On te demande d'implémenter une fonction récursive en Python pour calculer la factorielle d'un entier non négatif donné `n`. Pour optimiser la fonction, utilise la mémoïsation afin d'éviter les calculs redondants. Ta fonction doit gérer efficacement plusieurs cas de test.\n\n**Entrée :**\n- La pre... | ["\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(10) == 3628800\n", "\nassert factorial(12) == 479001600\n", "\nassert ... |
50c4d12c1d4c6bdff4dc90e234edab50 | [
{
"content": "On te demande d'implémenter une fonction pour gérer les serveurs de relais DHCP pour une interface Ethernet virtuelle (VE) donnée. La fonction doit gérer efficacement jusqu'à 500 serveurs DHCP et vérifier le format des adresses IP à l'aide d'une expression régulière.\n\n**Signature de la fonction ... | ["\nassert manage_dhcp_relay((0,), [(\"192.168.1.1\", \"vrf1\")])[0] in [True, False]\n", "\nassert manage_dhcp_relay((4294967295,), [(\"10.0.0.1\", \"vrf2\")])[0] in [True, False]\n", "\nassert manage_dhcp_relay((1234,), [(\"192.168.1.1\", \"vrf1\"), (\"10.0.0.1\", \"vrf2\")])[1][0][\"ip\"] == \"192.168.1.1\"\n", "\na... |
f86ea1314c8919deb5a3a9a81a907cbc | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `sort_odd_even_numbers` qui traite cette liste de sorte que tous les nombres impairs soient triés par ordre croissant et que tous les nombres pairs soient triés par ordre décroissant. L'ordre relatif des nombres impairs et pairs d... | ["\nassert sort_odd_even_numbers([4, 1, 3, 2, 8, 5, 7]) == [8, 1, 3, 2, 4, 5, 7]\n", "\nassert sort_odd_even_numbers([10, 15, 3, 7, 8, 12, 5]) == [12, 3, 5, 7, 10, 15, 8]\n", "\nassert sort_odd_even_numbers([1, 3, 5, 7, 9]) == [1, 3, 5, 7, 9]\n", "\nassert sort_odd_even_numbers([2, 4, 6, 8, 10]) == [10, 8, 6, 4, 2]\n",... |
2f33036ad9325957fdb6be639c9fca8d | [
{
"content": "On te donne une phrase constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction Python qui identifie et renvoie le mot le plus long de la phrase. S'il y a plusieurs mots de longueur maximale identique, renvoie le premier rencontré.\n\n**Entrée :**\n- Une seule chaîne de carac... | ["\nassert find_longest_word(\"The quick brown fox\") == \"quick\"\n", "\nassert find_longest_word(\"Jumped over the lazy dog\") == \"Jumped\"\n", "\nassert find_longest_word(\"a\") == \"a\"\n", "\nassert find_longest_word(\"equal length words\") == \"equal\"\n", "\nassert find_longest_word(\"one two three four five\")... |
ef982a4052ad245108836f1cdddd3214 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `word_frequency` qui traite cette chaîne et renvoie un dictionnaire où chaque clé est un mot unique (sans tenir compte de la casse et sans ponctuation) et la valeur correspondante est la fréquence de ce mot da... | ["\nassert word_frequency(\"Hello, world!\") == {\"hello\": 1, \"world\": 1}\n", "\nassert word_frequency(\"Python, python, PYTHON!\") == {\"python\": 3}\n", "\nassert word_frequency(\"A quick brown fox jumps over the lazy dog.\") == {\"a\": 1, \"quick\": 1, \"brown\": 1, \"fox\": 1, \"jumps\": 1, \"over\": 1, \"the\":... |
fa90a969bd9f4088bb8c9234220518da | [
{
"content": "On te donne une liste d'entiers positifs `numbers`. Implémente une fonction `average_ratio(numbers)` qui calcule la moyenne des ratios de chaque paire de nombres consécutifs dans la liste, en ne considérant que les paires où le premier nombre est premier. Si aucune paire de ce type n'existe, retou... | ["\nassert average_ratio([2, 4, 6, 7, 8, 11, 12]) == 3.0476190476190474\n", "\nassert average_ratio([3, 6, 9, 12]) == 2.0\n", "\nassert average_ratio([5, 10, 15, 20]) == 2.0\n", "\nassert average_ratio([7, 14, 21, 28]) == 2.0\n", "\nassert average_ratio([11, 22, 33, 44]) == 2.0\n", "\nassert average_ratio([2, 3, 5, 7, ... |
d8fa6155d9c438c5efa04d69e2e89b4d | [
{
"content": "On te donne un réseau de nœuds représenté sous forme de dictionnaire où les clés sont les identifiants des nœuds et les valeurs sont leurs statuts, soit \"I\" pour infecté ou \"S\" pour susceptible. De plus, tu as une liste d'hyperarêtes, où chaque hyperarête est un ensemble de nœuds qui sont conn... | ["\nassert contagion_spread(1, {1: 'S', 2: 'S', 3: 'I'}, [{1, 2, 3}]) == {1: 'I', 2: 'I', 3: 'I'}\n", "\nassert contagion_spread(1, {1: 'S', 2: 'S', 3: 'S'}, [{1, 2}, {2, 3}]) == {1: 'S', 2: 'S', 3: 'S'}\n", "\nassert contagion_spread(1, {1: 'I', 2: 'S', 3: 'S'}, [{1, 2}, {2, 3}]) == {1: 'I', 2: 'I', 3: 'S'}\n", "\nass... |
ee5a264742ed5c4380236ccac233251f | [
{
"content": "On te donne un dictionnaire `data` et optionnellement une liste de clés `keys_to_remove`. Ta tâche est d'implémenter une fonction `filter_dict` qui renvoie un nouveau dictionnaire excluant les paires clé-valeur où la clé est présente dans `keys_to_remove`. Si `keys_to_remove` n'est pas fourni, la ... | ["\nassert filter_dict({'a': 'hi', 'b': 'world', 'c': 'yes'}) == {'b': 'world'}\n", "\nassert filter_dict({'x': 'abc', 'y': 'defgh', 'z': 'ijklmno'}) == {'y': 'defgh', 'z': 'ijklmno'}\n", "\nassert filter_dict({'key1': 'short', 'key2': 'longerstring', 'key3': 'tiny'}) == {'key2': 'longerstring'}\n", "\nassert filter_di... |
700adfc0a24e5e16b67dd17bc86a6f20 | [
{
"content": "Tu dois implémenter une liste chaînée simple en Python. Ton implémentation doit inclure les fonctionnalités suivantes :\n\n- **Initialisation** : Créer une liste chaînée vide.\n- **Append** : Ajouter un élément à la fin de la liste chaînée.\n- **Remove** : Supprimer la première occurrence d'un élé... | ["\nassert LinkedList().display() is None\n", "\nll = LinkedList(); ll.append(1); assert ll.display() is None\n", "\nll = LinkedList(); ll.append(1); ll.append(2); assert ll.display() is None\n", "\nll = LinkedList(); ll.append(1); ll.append(2); ll.remove(1); assert ll.display() is None\n", "\nll = LinkedList(); ll.app... |
fd7a94c0052efe836876775aeb8f413b | [
{
"content": "On te donne une liste de mots et un dictionnaire qui associe chaque mot à sa fréquence correspondante dans un vaste corpus de texte. Ta tâche est de transformer la liste de mots en une liste de leurs fréquences respectives, en excluant les mots qui apparaissent moins de 5 fois dans le dictionnaire... | ["\nassert get_frequencies([\"apple\", \"banana\", \"cherry\"], {\"apple\": 10, \"banana\": 3, \"cherry\": 7}) == [10, 5.0, 7]\n", "\nassert get_frequencies([\"dog\", \"cat\", \"mouse\"], {\"dog\": 2, \"cat\": 8, \"mouse\": 1}) == [5.0, 8, 5.0]\n", "\nassert get_frequencies([\"hello\", \"world\"], {\"hello\": 5, \"worl... |
fa857a6ea40343ea01a87b50aa617c46 | [
{
"content": "Tu développes un système de surveillance pour un serveur. Implémente une fonction `calculate_system_stats` qui prend un objet `System` en entrée et renvoie une chaîne formatée représentant les statistiques du système. L'objet `System` contient les attributs suivants :\n- `nProcesses` : Un entier r... | ["\nassert calculate_system_stats(System(5, 10, [10, 20, 30], [5, 15, 25], 45.5, 12345)) == \"nProcesses=5 nThreads=10 cpuMax=30 cpuMean=20 memMean=15 diskUsage=45.5 uptime=12345\"\n", "\nassert calculate_system_stats(System(0, 0, [], [], 0.0, 0)) == \"nProcesses=0 nThreads=0 cpuMax=0 cpuMean=0 memMean=0 diskUsage=0.0 ... |
0268afcb1b61ad249c313b722012b80d | [
{
"content": "On te donne un fichier CSV nommé `data.csv` contenant une liste d'URL et leurs catégories correspondantes. Chaque ligne du fichier consiste en une URL et sa catégorie, séparées par une virgule. Les catégories sont représentées par '0' ou '1'. Ta tâche est d'implémenter une fonction `read_urls_and_... | ["\nassert read_urls_and_categories('test1.csv') == {'http://example.com': ['0'], 'http://example.org': ['1']}\n", "\nassert read_urls_and_categories('test2.csv') == {'http://example.com': ['0', '1'], 'http://example.org': ['1', '0']}\n", "\nassert read_urls_and_categories('test3.csv') == {'http://example.net': ['1'], ... |
520d9c84dce9769e163ca4801af5fd3f | [
{
"content": "Étant donné une chaîne de caractères `s` constituée d'une séquence de mots séparés par des espaces simples, écris une fonction `reverse_words` qui inverse l'ordre des mots dans la chaîne et renvoie la chaîne résultante.\n\n**Contraintes :**\n- La chaîne d'entrée `s` contiendra au moins un mot.\n- ... | ["\nassert reverse_words(\"the quick brown fox jumps over the lazy dog\") == \"dog lazy the over jumps fox brown quick the\"\n", "\nassert reverse_words(\"hello world\") == \"world hello\"\n", "\nassert reverse_words(\"a\") == \"a\"\n", "\nassert reverse_words(\"\") == \"\"\n", "\nassert reverse_words(\" hello world... |
8403d2be9cb0f79c709cdcb737326dc4 | [
{
"content": "On te donne un ensemble de données représentant des mesures d'intensité lumineuse à différentes longueurs d'onde et le temps d'acquisition total. L'ensemble de données est structuré comme un dictionnaire avec deux clés : \"spectrum\" et \"acquisition_time\". La clé \"spectrum\" contient une liste ... | ["\nassert normalize_spectrum({'spectrum': [100, 1000, 10000, 100000], 'acquisition_time': 10}) == {'spectrum': [-499.99999999999994, -499.99999999999994, -499.99999999999994, -499.99999999999994], 'acquisition_time': 10}\n", "\nassert normalize_spectrum({'spectrum': [1, 10, 100, 1000], 'acquisition_time': 5}) == {'spe... |
086ba3f3f4845322ab18c45210b58297 | [
{
"content": "On te donne un dictionnaire imbriqué. Ta tâche est d'écrire une fonction `flatten_dict` qui transforme ce dictionnaire en un dictionnaire aplati. Les clés dans le dictionnaire aplati doivent être une représentation sous forme de chaîne séparée par des points des clés imbriquées d'origine. Ignore t... | ["\nassert flatten_dict({'a': 1, 'b': {'c': 2}}) == {'a': 1, 'b.c': 2}\n", "\nassert flatten_dict({'x': {'y': {'z': 3}}}) == {'x.y.z': 3}\n", "\nassert flatten_dict({'key': 'value'}) == {'key': 'value'}\n", "\nassert flatten_dict({'a': 1, 'b': {'c': 2, 'd': {'e': 3, 'f': [4, 5]}}}) == {'a': 1, 'b.c': 2, 'b.d.e': 3}\n",... |
19a5c9474d52e81e528d754cebac0b17 | [
{
"content": "On te donne deux entiers, `D` et `p` (où `p` est une probabilité représentée par un flottant entre 0 et 1). Ta tâche est de générer un vecteur binaire de taille `D` tel que chaque élément ait indépendamment une probabilité `p` d'être un 1, avec la contrainte qu'aucun deux éléments consécutifs dans... | ["\nassert generate_random_binary_vector(0, 0.5) == []\n", "\nassert generate_random_binary_vector(1, 0) == [0]\n", "\nassert generate_random_binary_vector(1, 1) == [1]\n", "\nassert generate_random_binary_vector(5, 0) == [0, 0, 0, 0, 0]\n", "\nassert generate_random_binary_vector(5, 1) == [1, 0, 1, 0, 1] or generate_r... |
7447c39f73757b9ee4b3c0ca5fa5e54d | [
{
"content": "On te donne un fichier CSV nommé `sales_data.csv` contenant des données de ventes dans le format suivant : `Product,Category,Sales`. Ta tâche est d'écrire un programme Python qui lit ce fichier et calcule le total des ventes pour chaque catégorie de produits. Le programme doit afficher le total de... | ["\nassert calculate_total_sales_per_category('test_sales_data_1.csv') == {'Electronics': 1500.0, 'Clothing': 1200.0}\n", "\nassert calculate_total_sales_per_category('test_sales_data_2.csv') == {'Books': 500.0, 'Toys': 300.0}\n", "\nassert calculate_total_sales_per_category('test_sales_data_3.csv') == {'Furniture': 20... |
d1c49fb6ca27dffb44cd63c3a887d5c6 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de déterminer s'il existe trois nombres distincts dans la liste qui s'additionnent à zéro et dont les indices forment une progression arithmétique. La fonction doit être efficace, avec une complexité temporelle inférieure à O(n^3).\n\n**Entrée :**\n- U... | ["\nassert has_zero_sum_arithmetic_triplet([-1, 2, 1, -4, 3, 0]) == True\n", "\nassert has_zero_sum_arithmetic_triplet([1, 2, 3, 4, 5]) == False\n", "\nassert has_zero_sum_arithmetic_triplet([-1, 0, 1, 2, -1, -4]) == True\n", "\nassert has_zero_sum_arithmetic_triplet([0, 0, 0]) == True\n", "\nassert has_zero_sum_arithm... |
fbf33e4d54b2ae30fb26462be7673932 | [
{
"content": "On te donne deux listes : `values` et `weights`. Ta tâche est de calculer la moyenne arithmétique pondérée de la liste `values`, où chaque valeur est multipliée par son poids correspondant dans la liste `weights`. Assure-toi que tous les poids sont des entiers positifs et que toutes les valeurs so... | ["\nassert calc_weighted_am([1, 2, 3], [1, 1, 1]) == 2.0\n", "\nassert calc_weighted_am([10, 20, 30], [1, 2, 3]) == 23.333333333333332\n", "\nassert calc_weighted_am([-1000, 1000], [1, 1]) == 0.0\n", "\nassert calc_weighted_am([0, 0, 0], [1, 2, 3]) == 0.0\n", "\nassert calc_weighted_am([100, 200, 300], [3, 2, 1]) == 16... |
5b7a2cefb7b739c055b9fc6c198a7b0e | [
{
"content": "Tu participes à une compétition d'apprentissage automatique où tu dois implémenter une fonction `optimize_model` qui effectue une optimisation par descente de gradient sur une fonction objectif donnée. La fonction objectif est une fonction qui prend un vecteur de paramètres `w` en entrée et renvoi... | ["\nassert optimize_model(lambda w: (w[0]**2, 2*w), np.array([1.0]), 10, 0.1) == (np.array([0.]), [1.0, 0.64, 0.4096, 0.262144, 0.16777216, 0.1073741824, 0.068719476736, 0.04404922610816, 0.028190411029696, 0.01771561281868544], [2.0, 1.28, 0.8192, 0.5153960784313725, 0.33554432, 0.2147483648, 0.136048896, 0.0858993459... |
68e41d5160e46a105fa71b5f508af6b0 | [
{
"content": "On te donne un dictionnaire imbriqué où les valeurs peuvent être des entiers, des listes ou d'autres dictionnaires. Ta tâche est d'écrire une fonction `flatten_dict(d)` qui transforme ce dictionnaire en une liste de paires clé-valeur. Chaque clé dans la liste résultante doit être une chaîne de car... | ["\nassert flatten_dict({\"a\": 1, \"b\": {\"c\": 2, \"d\": [3, 4]}}) == [(\"a\", 1), (\"b.c\", 2), (\"b.d.0\", 3), (\"b.d.1\", 4)]\n", "\nassert flatten_dict({\"x\": {\"y\": {\"z\": 5}}}) == [(\"x.y.z\", 5)]\n", "\nassert flatten_dict({\"key\": \"value\"}) == [(\"key\", \"value\")]\n", "\nassert flatten_dict({\"list\"... |
53bc37be4b7c665d37cec4c2f9939dcd | [
{
"content": "On te donne un fichier CSV avec une ligne d'en-tête. Ta tâche est d'écrire une fonction Python qui lit ce fichier et calcule la somme des valeurs dans la colonne nommée \"Amount\". Suppose que toutes les valeurs dans la colonne \"Amount\" sont numériques, à l'exception d'éventuelles erreurs, qui d... | ["\nassert sum_column_in_csv('test1.csv', 'Amount') == 150.0\n", "\nassert sum_column_in_csv('test2.csv', 'Amount') == 0.0\n", "\nassert sum_column_in_csv('test3.csv', 'Amount') == 100.5\n", "\nassert sum_column_in_csv('test4.csv', 'Amount') == 200.0\n", "\nassert sum_column_in_csv('test5.csv', 'Amount') == 300.75\n", ... |
134b5df1057a1fa1280997a1bfa34ee5 | [
{
"content": "On te donne un graphe acyclique orienté (DAG) avec `N` sommets étiquetés de `0` à `N-1`. Le graphe est représenté sous forme de liste d'adjacence. Ta tâche est d'effectuer un tri topologique des sommets et de renvoyer les sommets triés sous forme de tableau.\n\n**Entrée :**\n- Un entier `N` représ... | ["\nassert topological_sort_dfs({\"A\": [\"B\", \"C\"], \"B\": [\"D\"], \"C\": [\"D\"], \"D\": []}) == [\"A\", \"B\", \"C\", \"D\"]\n", "\nassert topological_sort_dfs({\"A\": [\"B\"], \"B\": [\"C\"], \"C\": []}) == [\"A\", \"B\", \"C\"]\n", "\nassert topological_sort_dfs({\"A\": [], \"B\": [], \"C\": []}) == [\"A\", \"... |
5dcbc1db1fae7eb9e44679537058dd31 | [
{
"content": "On te donne une liste d'entiers représentant les prix quotidiens des actions. Ta tâche est d'écrire une fonction `smax_diff` qui calcule la différence maximale entre deux éléments quelconques de la liste, de telle sorte que l'élément le plus grand vienne après l'élément le plus petit. Si la liste ... | ["\nassert smax_diff([1, 5, 2, 9, 3]) == 8\n", "\nassert smax_diff([7, 1, 5, 3, 6, 4]) == 5\n", "\nassert smax_diff([7, 6, 4, 3, 1]) == 0\n", "\nassert smax_diff([1, 2, 3, 4, 5]) == 4\n", "\nassert smax_diff([]) == 0\n", "\nassert smax_diff([5]) == 0\n", "\nassert smax_diff([-1, -2, -3, -4, -5]) == 0\n", "\nassert smax... |
c4c401382f76d27851b552c2e8318b3c | [
{
"content": "Tu es chargé d'implémenter une fonction `base32_encode` qui prend une chaîne de caractères en entrée et renvoie sa représentation encodée en base32. La chaîne d'entrée peut contenir des caractères Unicode, qui doivent être convertis en leur représentation octet UTF-8 avant l'encodage. Ta fonction ... | ["\nassert base32_encode(\"Hello, World!\") == \"JBSWY3DPFQQHO33SNRSCC===\" \n", "\nassert base32_encode(\"abc\") == \"ME======\"\n", "\nassert base32_encode(\"123\") == \"GE======\"\n", "\nassert base32_encode(\"!@#\") == \"UEQGBA==\"\n", "\nassert base32_encode(\"\ud83d\ude0a\") == \"8J+Yhg==\"\n", "\nassert base32_e... |
7044a8fea0b9d770865fe963d3a04e90 | [
{
"content": "On te demande d'implémenter une fonction `create_blog_post_slug` qui génère un slug convivial pour les URL à partir d'un titre d'article de blog donné. Le slug doit respecter les règles suivantes :\n- Convertir l'intégralité du titre en minuscules.\n- Supprimer tous les caractères sauf les lettres... | ["\nassert create_blog_post_slug(\"Hello World!\") == \"hello-world\"\n", "\nassert create_blog_post_slug(\"This is a Test.\") == \"this-is-a-test\"\n", "\nassert create_blog_post_slug(\"Python 3.8\") == \"python-38\"\n", "\nassert create_blog_post_slug(\" Leading and Trailing Spaces \") == \"leading-and-trailing-spa... |
645d59ae891b33785af679fddc5dda7f | [
{
"content": "On te donne une grille 2D dynamique de taille `N x M` où chaque cellule peut être soit de la terre (`1`) soit de l'eau (`0`). La grille représente une île, où les cellules de terre sont connectées horizontalement ou verticalement. Tu recevras une série d'opérations qui modifient l'état d'une cellu... | ["\nassert calculate_perimeter([[0, 0, 0], [0, 0, 0], [0, 0, 0]], [(0, 0)]) == [4]\n", "\nassert calculate_perimeter([[1, 1], [1, 1]], [(0, 0)]) == [6]\n", "\nassert calculate_perimeter([[1, 0], [0, 1]], [(0, 1)]) == [6]\n", "\nassert calculate_perimeter([[1, 1, 1], [1, 0, 1], [1, 1, 1]], [(1, 1)]) == [16]\n", "\nasser... |
d0a1c5757588a6e256d65bd5eb9b180b | [
{
"content": "Conçois un système de compte bancaire simple en Python qui prenne en charge les fonctionnalités suivantes. Implémente des classes pour `Account`, `CheckingAccount` et `SavingsAccount`. Chaque type de compte doit avoir des méthodes pour déposer, retirer et vérifier le solde. Le `CheckingAccount` do... | ["\nassert Account(\"Alice\", 100).check_balance() == None\n", "\nassert Account(\"Bob\", 100).deposit(50) == None\n", "\nassert Account(\"Charlie\", 100).withdraw(30) == None\n", "\nassert CheckingAccount(\"David\", 100, 50).withdraw(160) == None\n", "\nassert CheckingAccount(\"Eve\", 100, 50).withdraw(150) == None\n"... |
139303fba710ee12cabcdc415314c467 | [
{
"content": "On te demande d'implémenter une fonction `WeightedSum` qui traite des données géographiques stockées dans un GeoDataFrame. La fonction doit calculer une somme pondérée de champs spécifiés en fonction des poids fournis, même si certains champs sont manquants dans les données d'entrée. La fonction d... | ["\nassert WeightedSum(GeoDataFrame({'A': [1, 2], 'B': [3, 4]}), ['A', 'B'], pd.DataFrame({'weight': [0.5, 0.5]}, index=['A', 'B']), 'new_field', False).equals(GeoDataFrame({'A': [1, 2], 'B': [3, 4], 'new_field': [2.0, 3.0]}))\n", "\nassert WeightedSum(GeoDataFrame({'A': [1, 2], 'B': [3, 4]}), ['A', 'B'], pd.DataFrame(... |
e8e2f375982a0e86c1c997f4c4727195 | [
{
"content": "On te donne une liste `pattern` d'entiers. Ta tâche est de construire une deque où chaque élément de la liste `pattern` est répété un certain nombre de fois. Le nombre de répétitions pour un élément à l'index `i` est `i` si l'élément n'est pas un nombre premier, et `i + 2` si l'élément est un nomb... | ["\nassert create_deque_with_pattern([2, 3, 4, 5]) == deque([2, 3, 3, 4, 4, 4, 5, 5, 5, 5])\n", "\nassert create_deque_with_pattern([1, 2, 3, 4, 5, 6]) == deque([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6])\n", "\nassert create_deque_with_pattern([7, 11, 13]) == deque([7, 7, 7, 7, 11, 11, 11, 11, 11,... |
7d2c6857bed4126758edad4715b4441a | [
{
"content": "On te donne deux ensembles d'entiers, A et B, chacun contenant jusqu'à 1000 éléments. Ta tâche est d'écrire une fonction qui calcule l'union de ces deux ensembles et renvoie le résultat sous forme de liste triée par ordre croissant.\n\n**Entrée :**\n- Deux ensembles d'entiers, A et B.\n\n**Sortie ... | ["\nassert sorted_union({1, 3, 5, 7, 9}, {2, 4, 6, 8, 10}) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert sorted_union({1, 2, 3}, {3, 4, 5}) == [1, 2, 3, 4, 5]\n", "\nassert sorted_union({10, 20, 30}, {5, 15, 25}) == [5, 10, 15, 20, 25, 30]\n", "\nassert sorted_union(set(), {1, 2, 3}) == [1, 2, 3]\n", "\nassert sorte... |
528f94cc9acef753fa692150b8d5f70c | [
{
"content": "On te donne une liste d'entiers `nums` et un entier `target`. Ta tâche est de modifier la liste `nums` en changeant la valeur d'au plus un élément de telle sorte que la somme de toute sous-tableau de longueur `3` ne soit pas égale à `target`. Si ce n'est pas possible en modifiant seulement un élém... | ["\nassert modify_subarray([1, 2, 3], 6) == (2, 0)\n", "\nassert modify_subarray([1, 2, 3, 4, 5], 9) == (2, 0)\n", "\nassert modify_subarray([5, 5, 5, 5], 15) == (0, 0)\n", "\nassert modify_subarray([1, 1, 1, 1, 1, 1], 3) == (2, 0)\n", "\nassert modify_subarray([10, 20, 30, 40, 50], 60) == (0, 0)\n", "\nassert modify_s... |
bf57bd8b034069697001a79baf2701da | [
{
"content": "On te donne deux fonctions `func1` et `func2`. Ta tâche est d'implémenter une fonction `time_comparison` qui mesure le temps d'exécution de chaque fonction et affiche le nom de la fonction qui s'exécute le plus rapidement. Si une exception se produit pendant l'exécution d'une fonction, affiche le ... | ["\nassert time_comparison(lambda: None, lambda: None) is None\n", "\nassert time_comparison(lambda: time.sleep(0.1), lambda: time.sleep(0.2)) is None\n", "\nassert time_comparison(lambda: time.sleep(0.2), lambda: time.sleep(0.1)) is None\n", "\nassert time_comparison(lambda: time.sleep(0.1), lambda: time.sleep(0.1)) i... |
90350f95a188e8f7a48ee3436461c832 | [
{
"content": "On te donne un ensemble de données de transactions financières stockées dans un fichier CSV nommé `transactions.csv`. Chaque enregistrement de transaction est composé de quatre champs : `transaction_id`, `transaction_date`, `amount` et `category`. Ta tâche est de mettre en œuvre une fonction `filt... | ["\nassert filter_transactions('empty.csv', 'output.csv') is None\n", "\nassert filter_transactions('invalid_amounts.csv', 'output.csv') is None\n", "\nassert filter_transactions('nonexistentfile.csv', 'output.csv') is None\n", "\nassert filter_transactions('valid_transactions.csv', 'output.csv') is None\n", "\nassert ... |
07a41f1e9d6507eaf5218287f76d0830 | [
{
"content": "Tu participes à un concours de programmation où l'on te donne un itérateur de tableaux numpy, `arrs`, et une fonction binaire, `ufunc`, qui prend deux tableaux numpy et renvoie un nouveau tableau numpy. Ta tâche est de mettre en œuvre une fonction, `reduce_arrays`, qui applique `ufunc` cumulativem... | ["\nassert np.array_equal(reduce_arrays([np.array([1, 2, 3]), np.array([4, 5, 6])], np.add), np.array([5, 7, 9]))\n", "\nassert reduce_arrays([np.array([1, 2, 3]), np.array([4, 5])], np.add) is None\n", "\nassert np.array_equal(reduce_arrays([np.array([1, 2]), np.array([3, 4]), np.array([5, 6])], np.multiply), np.array... |
025b05fc30223031ed0a228c9487bffd | [
{
"content": "On te donne un triangle avec trois angles, dont l'un est manquant et représenté par `None`. Écris une fonction `calculate_missing_angle` qui prend trois paramètres : `angle1`, `angle2` et `angle3`. Ta fonction doit déterminer et renvoyer la mesure de l'angle manquant. Les angles peuvent être fourn... | ["\nassert calculate_missing_angle(None, 60, 60) == 60\n", "\nassert calculate_missing_angle(90, None, 45) == 45\n", "\nassert calculate_missing_angle(30, 60, None) == 90\n", "\nassert calculate_missing_angle(None, None, 90) == 90\n", "\nassert calculate_missing_angle(0, 0, None) == 180\n", "\nassert calculate_missing_... |
31bf88190b4ac5bcdf223c0f37483b2d | [
{
"content": "On te donne deux dictionnaires, `dict1` et `dict2`, où chaque dictionnaire contient des éléments comme clés et leurs quantités correspondantes comme valeurs. Ta tâche est de créer un nouveau dictionnaire qui représente l'union de ces deux ensembles, en respectant les règles suivantes :\n\n- Si un ... | ["\nassert merge_dictionaries({}, {}) == {}\n", "\nassert merge_dictionaries({'apple': 3}, {}) == {'apple': 3}\n", "\nassert merge_dictionaries({}, {'banana': 2}) == {'banana': 2}\n", "\nassert merge_dictionaries({'apple': 3}, {'banana': 2}) == {'apple': 3, 'banana': 2}\n", "\nassert merge_dictionaries({'apple': 3, 'ba... |
11ef82dba515303128030e5aed83c059 | [
{
"content": "On te donne un fichier CSV avec des en-têtes. Ta tâche est d'implémenter une fonction `read_csv_to_dict` qui lit le fichier CSV et renvoie un dictionnaire. Les clés du dictionnaire doivent être les valeurs d'une colonne spécifiée, et les valeurs doivent être des listes de dictionnaires, chacun rep... | ["\nassert read_csv_to_dict('data.csv', 'id') == {'1': [{'id': '1', 'name': 'Alice', 'age': '30'}], '2': [{'id': '2', 'name': 'Bob', 'age': '22'}]}\n", "\nassert read_csv_to_dict('data.csv', 'name') == {'Alice': [{'id': '1', 'name': 'Alice', 'age': '30'}], 'Bob': [{'id': '2', 'name': 'Bob', 'age': '22'}]}\n", "\nassert... |
ef0fe44d744df51cdc0433a63824594a | [
{
"content": "On te donne un entier positif `n` supérieur à 2. Ton objectif est d'écrire une fonction `find_largest_prime_below(n)` qui renvoie le plus grand nombre premier inférieur à `n`.\n\n**Entrée :**\n- Un seul entier `n` (3 ≤ n ≤ 10^6)\n\n**Sortie :**\n- Un seul entier représentant le plus grand nombre p... | ["\nassert find_largest_prime_below(10) == 7\n", "\nassert find_largest_prime_below(20) == 19\n", "\nassert find_largest_prime_below(30) == 29\n", "\nassert find_largest_prime_below(50) == 47\n", "\nassert find_largest_prime_below(100) == 97\n", "\nassert find_largest_prime_below(101) == 101\n", "\nassert find_largest_... |
74994d02f6cc7e008b9db9f02e4a776c | [
{
"content": "On te demande d'implémenter une classe Python `Employee` pour gérer les détails et les opérations 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 - `position` : une chaî... | ["\nassert Employee(\"John Doe\", \"Developer\", 50000).name == \"John Doe\"\n", "\nassert Employee(\"Jane Smith\", \"Manager\", 75000).position == \"Manager\"\n", "\nassert Employee(\"Alice Johnson\", \"Analyst\", 60000).salary == 60000\n", "\nemp = Employee(\"Bob Brown\", \"Intern\", 30000)\nemp.promote(\"Junior Deve... |
e793a0557722a2c92c07534fb1aba36c | [
{
"content": "On te donne une chaîne de caractères `ip_string` composée exactement de 12 chiffres. Ta tâche est de générer toutes les adresses IP valides possibles en insérant exactement trois points dans la chaîne. Une adresse IP valide doit satisfaire les conditions suivantes :\n- Chaque segment (octet) doit ... | ["\nassert generate_ip_addresses(\"192168000000\") == ['192.168.0.0', '192.168.0.00', '192.168.00.0', '192.168.00.00', '192.16.8.0.0', '192.16.80.0.0', '192.168.0.0', '192.168.0.00', '192.168.00.0', '192.168.00.00', '192.1.68.0.0', '192.1.680.0.0', '192.168.0.0', '192.168.0.00', '192.168.00.0', '192.168.00.00', '19.216... |
590e5b8fa5d2a803df6a4be39778bc79 | [
{
"content": "On te donne un système avec plusieurs états, chacun ayant des probabilités de transition vers d'autres états. Il existe un état spécial N avec des propriétés uniques. L'efficacité du système est déterminée par le temps passé dans chaque état, le temps passé dans l'état N, les temps de migration en... | ["\nassert system_efficiency_constraint(0.75, np.array([10, 20, 30]), [example_L], np.array([0.2, 0.3, 0.5]), np.array([[0.1, 0.2, 0.7], [0.3, 0.4, 0.3], [0.6, 0.3, 0.1]]), 120, 50, 50) == False\n", "\nassert system_efficiency_constraint(0.75, np.array([10, 20, 30]), [example_L], np.array([0.2, 0.3, 0.5]), np.array([[0... |
f311f9fe6264ca8ae232af04edfc964a | [
{
"content": "Tu es chargé d'implémenter une fonction `parse_json` qui analyse manuellement une chaîne JSON en un dictionnaire Python. La chaîne JSON peut contenir des objets et des tableaux imbriqués. Ton implémentation ne doit utiliser aucune bibliothèque d'analyse JSON intégrée. La fonction doit gérer toutes... | ["\nassert parse_json('{\"name\": \"John\"}') == {\"name\": \"John\"}\n", "\nassert parse_json('{\"age\": 30}') == {\"age\": 30}\n", "\nassert parse_json('{\"is_student\": false}') == {\"is_student\": False}\n", "\nassert parse_json('{\"skills\": [\"Python\", \"C++\"]}') == {\"skills\": [\"Python\", \"C++\"]}\n", "\nas... |
185c485b10ae2aef76d92ef692ed4d7d | [
{
"content": "On te demande d'implémenter une fonction `int_to_bytestring_le(value, length)` qui convertit un entier donné `value` en une chaîne d'octets en little-endian d'une longueur spécifiée `length`. La fonction doit renvoyer un objet bytes contenant la représentation little-endian de l'entier d'entrée, c... | ["\nassert int_to_bytestring_le(0x12345678, 4) == b'xV4\\x12'\n", "\nassert int_to_bytestring_le(0x1234, 4) == b'\\x34\\x12\\x00\\x00'\n", "\nassert int_to_bytestring_le(0x0, 4) == b'\\x00\\x00\\x00\\x00'\n", "\nassert int_to_bytestring_le(0xFF, 2) == b'\\xff\\x00'\n", "\nassert int_to_bytestring_le(0x1, 1) == b'\\x01'... |
04c384c8129b8ca4e2501bed26812318 | [
{
"content": "Implémente une fonction récursive nommée `factorial` qui calcule la factorielle d'un entier non négatif `n`. La fonction doit lever une exception `ValueError` si `n` est négatif. Ta solution doit gérer le cas de base où `n` est 0, en renvoyant 1, et le cas récursif pour les entiers positifs.\n\n**... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(3) == 6\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(15) == 1307674368000\n", "\nassert factorial(1) == 1\n", "\ntry: factorial(-1); assert False ex... |
a40f8de91257dfd7d7dfeb75ee9c2c73 | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces, pouvant contenir des signes de ponctuation et une capitalisation variable. Ta tâche est de déterminer si la phrase est un palindrome, ce qui signifie que la séquence des mots se lit de la même manière de gauche à ... | ["\nassert isMirroredSentence(\"A man a plan a canal Panama\") == True\n", "\nassert isMirroredSentence(\"Hello World\") == False\n", "\nassert isMirroredSentence(\"Was it a car or a cat I saw\") == True\n", "\nassert isMirroredSentence(\"No lemon no melon\") == True\n", "\nassert isMirroredSentence(\"Madam In Eden Im ... |
60e703d65b929f870b08431f3703436a | [
{
"content": "On te donne une valeur de température et son unité ('C' pour Celsius ou 'F' pour Fahrenheit). Implémente une fonction qui effectue une série de conversions basées sur les règles suivantes :\n\n- Si la température est en Celsius et inférieure à 0, convertis-la en Fahrenheit et ajoute 10. Si elle es... | ["\nassert convert_temperature(-10, 'C', 1) == 58.0\n", "\nassert convert_temperature(0, 'C', 1) == 20.0\n", "\nassert convert_temperature(10, 'C', 1) == 10.0\n", "\nassert convert_temperature(32, 'F', 1) == 27.0\n", "\nassert convert_temperature(50, 'F', 1) == 10.0\n", "\nassert convert_temperature(-10, 'C', 2) == 16.... |
f9e56de113fca3d8b4e1c3f422e4fd2d | [
{
"content": "On te donne une liste non triée d'entiers. Ta tâche est d'implémenter l'algorithme de tri fusion pour trier la liste par ordre croissant. La fonction doit renvoyer une nouvelle liste triée.\n\n**Entrée :**\n- Une liste d'entiers `arr` (1 ≤ len(arr) ≤ 10^4), où chaque entier est dans la plage [-10^... | ["\nassert merge_sort([3, 1, 2]) == [1, 2, 3]\n", "\nassert merge_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([]) == []\n", "\nassert merge_sort([1]) == [1]\n", "\nassert merge_sort([9, 7, 5, 11, 12, 2, 14, 3, 10, 6]) == [2, 3, 5, 6, 7, ... |
ee80499351f4de0d17c950d090c1b577 | [
{
"content": "On te donne une URL pointant vers un document texte brut. Ta tâche est d'écrire une fonction Python nommée `fetch_and_count_words` qui traite le contenu du document en supprimant les mots vides courants de la langue anglaise et en comptant les occurrences de chaque mot restant. La fonction doit re... | ["\nassert fetch_and_count_words(\"http://example.com\") == {'example': 1, 'com': 1}\n", "\nassert fetch_and_count_words(\"http://example.com\") != {'the': 1, 'is': 1}\n", "\nassert fetch_and_count_words(\"http://example.com\") == {}\n", "\nassert fetch_and_count_words(\"http://example.com\") == {'hello': 1, 'world': 1... |
dbad474ca16a0a0ba84dbedd4a0333ae | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `tokenize_string(s)` qui renvoie une liste de tokens. Un token est défini comme une séquence contiguë de caractères alphanumériques ou un seul caractère non alphanumérique. De plus, toute séquence de quatre caractère... | ["\nassert tokenize_string(\"Hello, World!\") == ['Hello', ',', ' ', 'World', '!']\n", "\nassert tokenize_string(\"Hello, World!\") == ['Hello', ',', ' ', 'World', '!']\n", "\nassert tokenize_string(\"This is a test.\") == ['This', ' ', 'is', ' ', 'a', ' ', 'test', '.']\n", "\nassert tokenize_string(\"Multiple s... |
125a26e4d5e9fdb0462f3b52e7af22ff | [
{
"content": "On te donne deux chaînes de caractères `s1` et `s2`. Ta tâche est d'écrire une fonction qui trouve la plus longue sous-chaîne commune entre ces deux chaînes. S'il existe plusieurs sous-chaînes de longueur maximale identique, retourne l'une d'entre elles. Si aucune sous-chaîne commune n'existe, ret... | ["\nassert longest_common_substring(\"abcdef\", \"zabcf\") == \"abc\"\n", "\nassert longest_common_substring(\"abc\", \"def\") == \"\"\n", "\nassert longest_common_substring(\"banana\", \"anana\") == \"anana\"\n", "\nassert longest_common_substring(\"\", \"a\") == \"\"\n", "\nassert longest_common_substring(\"abc\", \"... |
2c33edf4ad4110b29d5be93486a0c1f0 | [
{
"content": "On te donne une liste d'éléments qui peuvent inclure des nombres et des valeurs non numériques. Ta tâche est d'implémenter une fonction `median_list(items)` qui calcule la médiane des valeurs numériques dans la liste. La médiane est définie comme la valeur du milieu dans une liste triée de nombres... | ["\nassert median_list([3, 1, 4, 1, 5, 9, 'a', None, float('nan')]) == 3\n", "\nassert median_list([1, 2, 3, 4, 5]) == 3\n", "\nassert median_list([1, 2, 3, 4]) == 2.5\n", "\nassert median_list([10, 20, 30, 40, 50, 60]) == 35.0\n", "\nassert median_list([1.5, 2.5, 3.5, 4.5, 5.5]) == 3.5\n", "\nassert median_list([1.5, ... |
7b86a4ff8a8438aa7d8f7da886ec4b47 | [
{
"content": "On te donne une liste de chaînes de caractères, chacune représentant une adresse e-mail. Ta tâche est d'écrire une fonction Python qui filtre les adresses e-mail valides en fonction des règles simplifiées suivantes :\n- L'adresse e-mail doit commencer par une lettre ou un chiffre.\n- Elle peut con... | ["\nassert validate_emails([\"test.email@example.com\"]) == [(\"test.email@example.com\",)]\n", "\nassert validate_emails([\"invalid-email@.com\"]) == []\n", "\nassert validate_emails([\"another.test@domain.co.uk\"]) == [(\"another.test@domain.co.uk\",)]\n", "\nassert validate_emails([\"wrong@domain,com\"]) == []\n", "... |
586d1a88c317fec57ffda0be27e6efb7 | [
{
"content": "On te donne les statistiques de performance d'un joueur de football et un ensemble de valeurs de points pour chaque statistique. Ta tâche est de mettre en œuvre une fonction qui calcule le score de performance global du joueur. Les statistiques du joueur et leurs valeurs de points correspondantes ... | ["\nassert calculate_performance_score(Player(goals=10, assists=5, saves=3, shots_on_target=8), {'goals': 3, 'assists': 2, 'saves': 1.5, 'shots_on_target': 1}) == 52.5\n", "\nassert calculate_performance_score(Player(goals=0, assists=0, saves=0, shots_on_target=0), {'goals': 3, 'assists': 2, 'saves': 1.5, 'shots_on_tar... |
7341f22fcfeb7688406402fef7a9a681 | [
{
"content": "On te demande de simuler le lancer de deux dés à six faces. Écris une fonction Python `roll_dice()` qui génère deux entiers aléatoires entre 1 et 6 inclus, représentant les résultats des lancers de dés. La fonction doit afficher les résultats au format \"Dé 1 : X\" et \"Dé 2 : Y\", où X et Y sont ... | ["\nassert 1 <= roll_dice()[0] <= 6\n", "\nassert 1 <= roll_dice()[1] <= 6\n", "\nassert isinstance(roll_dice()[0], int)\n", "\nassert isinstance(roll_dice()[1], int)\n", "\nassert roll_dice() != (0, 0)\n", "\nassert roll_dice() != (7, 7)\n", "\nassert roll_dice() != (1, 7)\n", "\nassert roll_dice() != (7, 1)\n", "\nas... |
b7036650358ce97830022e92c1d66ae4 | [
{
"content": "On te demande d'implémenter une fonction efficace pour générer la suite de Fibonacci. Ta fonction, `fibonacci(n)`, doit renvoyer une liste contenant les `n` premiers nombres 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 >= ... | ["\nassert fibonacci(0) == []\n", "\nassert fibonacci(1) == [0]\n", "\nassert fibonacci(2) == [0, 1]\n", "\nassert fibonacci(3) == [0, 1, 1]\n", "\nassert fibonacci(4) == [0, 1, 1, 2]\n", "\nassert fibonacci(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci(6) == [0, 1, 1, 2, 3, 5]\n", "\nassert fibonacci(10) == [0, 1, 1, ... |
0514b977724249a8bb79a8b8117fc2b8 | [
{
"content": "On te demande d'implémenter une classe `Product` qui modélise un produit avec les attributs `name`, `price` et `category`. La classe doit inclure une méthode `get_discount_price` qui calcule le prix du produit après avoir appliqué un pourcentage de réduction donné. La méthode doit lever une except... | ["\nassert Product(\"Laptop\", 1000, \"Electronics\").get_discount_price(20) == 800.0\n", "\nassert Product(\"Smartphone\", 500, \"Electronics\").get_discount_price(10) == 450.0\n", "\nassert Product(\"Book\", 20, \"Literature\").get_discount_price(50) == 10.0\n", "\nassert Product(\"Coffee Maker\", 150, \"Home Applian... |
7395d7514b6c7b6c06b28cf3729d81bd | [
{
"content": "Implémente une structure de données de file d'attente en Python en utilisant une classe. Ta classe doit supporter les opérations suivantes :\n- `enqueue(item)` : Ajouter un élément à la fin de la file d'attente.\n- `dequeue()` : Supprimer et retourner l'élément du début de la file d'attente. Si la... | ["\nassert Queue().is_empty() == True\n", "\nassert Queue().size() == 0\n", "\nqueue = Queue()\nqueue.enqueue(1)\nassert queue.size() == 1\n", "\nqueue = Queue()\nqueue.enqueue(1)\nqueue.enqueue(2)\nassert queue.peek() == 1\n", "\nqueue = Queue()\nqueue.enqueue(1)\nqueue.enqueue(2)\nqueue.enqueue(3)\nassert queue.deque... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.