id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
9d41af9503adb7111b1e37d52dcd17d4 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `word_count` qui traite cette chaîne et renvoie un dictionnaire. Le dictionnaire doit associer chaque mot unique (sans tenir compte de la casse et de la ponctuation) au nombre de fois où il apparaît dans la chaî... | ["\nassert word_count(\"Hello, world! This is a test. Hello again; hello, universe.\") == {'hello': 3, 'world': 1, 'this': 1, 'is': 1, 'a': 1, 'test': 1, 'again': 1, 'universe': 1}\n", "\nassert word_count(\"Python, Python, Python!\") == {'python': 3}\n", "\nassert word_count(\"A quick brown fox jumps over the lazy dog... |
49f8b825419f0f3d87d91d8e5be19564 | [
{
"content": "On te demande d'implémenter une version modifiée de l'algorithme de tri Shell, nommée \"Tri Shell par Comptage\", en utilisant uniquement des opérations au niveau du bit et sans utiliser aucune opération arithmétique (+, -, *, /, %). Ta fonction doit trier une liste d'entiers par ordre croissant e... | ["\nassert counting_shell_sort([23, 12, 1, 8, 34, 54, 2, 3], [4, 2, 1]) == ([1, 2, 3, 8, 12, 23, 34, 54], 18, 7)\n", "\nassert counting_shell_sort([5, 3, 8, 4, 2], [2, 1]) == ([2, 3, 4, 5, 8], 9, 4)\n", "\nassert counting_shell_sort([1, 2, 3, 4, 5], [1]) == ([1, 2, 3, 4, 5], 4, 0)\n", "\nassert counting_shell_sort([5, ... |
68f25e30a8334cbd18df950f829b47f8 | [
{
"content": "Dans un jeu, tu as un inventaire composé de divers objets. Chaque objet est représenté par une chaîne de caractères. Les objets peuvent être catégorisés en deux types : les objets ordinaires et les objets spéciaux. Les objets spéciaux sont préfixés par \"Special - \". Ta tâche est de trier l'inven... | ["\nassert sort_inventory([\"Special - Sword\", \"Potion\", \"Special - Shield\", \"Apple\"]) == [\"Special - Shield\", \"Special - Sword\", \"Apple\", \"Potion\"]\n", "\nassert sort_inventory([\"Special - Boots\", \"Special - Sword\", \"Apple\", \"Potion\"]) == [\"Special - Boots\", \"Special - Sword\", \"Apple\", \"P... |
8ac0e89ef3ff8a2967c340912e955edb | [
{
"content": "On te donne une liste de langues ainsi que le nombre d'abonnés pour chacune, et une liste de langues prises en charge par notre système de newsletter. Ta tâche est de déterminer la meilleure langue pour la newsletter. La meilleure langue est définie comme la langue prise en charge avec plus de 100... | ["\nassert best_language([('English', 150), ('Spanish', 90), ('French', 120)], ['English', 'French', 'German']) == 'English'\n", "\nassert best_language([('English', 150), ('Spanish', 90), ('French', 120)], ['German']) == 'English'\n", "\nassert best_language([('English', 150), ('Spanish', 90), ('French', 120)], []) ==... |
b975d942503628d8193c287224643842 | [
{
"content": "On te donne un dictionnaire imbriqué `d`. Ta tâche est d'écrire une fonction `flatten_dict(d)` qui transforme ce dictionnaire imbriqué en un dictionnaire aplati. Dans le dictionnaire aplati, chaque clé doit être une concaténation des clés du dictionnaire imbriqué, séparées par un point (`.`). Par ... | ["\nassert flatten_dict({\"a\": {\"b\": 1, \"c\": 2}}) == {\"a.b\": 1, \"a.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({}) == {}\n", "\nassert flatten_dict({\"a\": {\"b\": {\"c\": {... |
af38f7623b2d2a7fc371e46b2e6c8498 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `calculate_statistics(numbers: list) -> dict` qui calcule et renvoie un dictionnaire contenant la moyenne, la médiane et le mode de la liste. Si la liste est vide, la fonction doit renvoyer un dictionnaire vide. Dans les cas ... | ["\nassert calculate_statistics([1, 2, 2, 3, 4]) == {'mean': 2.4, 'median': 2, 'mode': 2}\n", "\nassert calculate_statistics([1, 1, 2, 3, 4, 4]) == {'mean': 2.5, 'median': 2.5, 'mode': None}\n", "\nassert calculate_statistics([7, 8, 9]) == {'mean': 8.0, 'median': 8, 'mode': 7}\n", "\nassert calculate_statistics([5]) ==... |
ba8c4e656c35e15a5a7c677fe1e77d6b | [
{
"content": "Peter, un chef renommé, est spécialisé dans la création d'un éventail diversifié de pizzas. Chaque recette de pizza nécessite un ensemble spécifique d'ingrédients en quantités déterminées. Le garde-manger de Peter est rempli de divers ingrédients, mais il ne sait pas combien de pizzas il peut prép... | ["\nassert max_pizzas({'Margherita': {'dough': 1, 'tomato': 1, 'cheese': 1}}, {'dough': 3, 'tomato': 3, 'cheese': 3}, 1) == 3\n", "\nassert max_pizzas({'Margherita': {'dough': 1, 'tomato': 1, 'cheese': 1}}, {'dough': 3, 'tomato': 3, 'cheese': 3}, 2) == 3\n", "\nassert max_pizzas({'Margherita': {'dough': 1, 'tomato': 1,... |
87da1369c4174823d3f8bc8f40fd618e | [
{
"content": "On te donne une chaîne de caractères représentant une expression infixe composée d'entiers, des opérateurs `+`, `-`, `*`, `/`, et d'espaces. Ta tâche est d'évaluer l'expression et de renvoyer le résultat sous forme de nombre à virgule flottante. Suppose que l'expression d'entrée est toujours valid... | ["\nassert evaluate_infix(\"3 + 5 * 2 - 8 / 4\") == 11.0\n", "\nassert evaluate_infix(\"10 + 2 * 6\") == 22.0\n", "\nassert evaluate_infix(\"100 * 2 + 12\") == 212.0\n", "\nassert evaluate_infix(\"100 * ( 2 + 12 )\") == 1400.0\n", "\nassert evaluate_infix(\"100 * ( 2 + 12 ) / 14\") == 100.0\n", "\nassert evaluate_infix... |
1c93111a74b3518da2e03c98dc060520 | [
{
"content": "On te donne une liste triée de mots, `xs`, et un dictionnaire de mots, `ys`, où chaque clé est une catégorie et chaque valeur est une liste de mots uniques. Ta tâche est de mettre en œuvre une fonction `count_frequencies` qui renvoie une liste imbriquée de fréquences, `counter_list`. Chaque sous-l... | ["\nassert count_frequencies([\"apple\", \"banana\", \"apple\", \"orange\"], {\"fruits\": [\"apple\", \"banana\", \"grape\"]}) == [[2, 1, 0]]\n", "\nassert count_frequencies([\"dog\", \"cat\", \"dog\", \"bird\"], {\"animals\": [\"dog\", \"cat\", \"fish\"]}) == [[2, 1, 0]]\n", "\nassert count_frequencies([\"car\", \"bik... |
576fad668c588c83124e14e659fae56e | [
{
"content": "Tu participes à un concours de programmation où tu dois simuler un jeu de lancer de dés biaisé. Dans ce jeu, un joueur lance un dé à `dX` faces un total de `number` fois. Chaque lancer est influencé par le résultat du lancer précédent, ajustant dynamiquement les probabilités. Plus précisément, la ... | ["\nassert biased_dice_rolls(2, 1) in [1, 2]\n", "\nassert len(biased_dice_rolls(6, 5)) == 5\n", "\nassert all(1 <= roll <= 6 for roll in biased_dice_rolls(6, 10))\n", "\nassert biased_dice_rolls(3, 0) == []\n", "\nassert biased_dice_rolls(4, 1, 0) in [1, 2, 3, 4]\n", "\nassert biased_dice_rolls(5, 100, 1)[0] == biased... |
861548dfe1fd854602b095061ae0d022 | [
{
"content": "On te demande d'implémenter une calculatrice simple qui prend en charge les opérations arithmétiques de base : l'addition, la soustraction, la multiplication et la division. Ton programme doit inviter de manière répétée l'utilisateur à saisir deux nombres et un opérateur (+, -, *, /). En fonction ... | ["\nassert add(2, 3) == 5\n", "\nassert subtract(5, 3) == 2\n", "\nassert multiply(4, 3) == 12\n", "\nassert divide(10, 2) == 5.0\n", "\nassert divide(10, 0) == \"Error! Division by zero.\"\n", "\nassert add(-1, -1) == -2\n", "\nassert subtract(0, 0) == 0\n", "\nassert multiply(0, 5) == 0\n", "\nassert divide(0, 1) == ... |
1438853668bbc3a184b6530ff485de8f | [
{
"content": "On te donne une liste de phrases, où chaque phrase est représentée comme une liste de mots. Ta tâche est d'implémenter une fonction qui renvoie une liste triée de tuples. Chaque tuple contient un mot unique qui apparaît comme le dernier mot dans n'importe quelle phrase et le nombre de fois où il a... | ["\nassert last_word_count([[\"hello\", \"world\"], [\"goodbye\", \"world\"]]) == [(\"world\", 2)]\n", "\nassert last_word_count([[\"hi\", \"there\"], [\"hi\", \"again\"], [\"bye\", \"there\"]]) == [(\"again\", 1), (\"there\", 2)]\n", "\nassert last_word_count([[\"one\"], [\"two\"], [\"three\"]]) == [(\"one\", 1), (\"t... |
8ee9adc9db956420022a7f9e49aa2afc | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tableau NumPy 2D ou un tenseur PyTorch. Ta tâche est de mettre en œuvre une fonction qui génère toutes les boîtes englobantes possibles couvrant l'image en utilisant une approche de fenêtre glissante, sans dépasser un nombre maximal de ... | ["\nassert generate_bounding_boxes(np.array([[1, 2], [3, 4]]), 2, 1) == [(0, 0, 2, 2)]\n", "\nassert generate_bounding_boxes(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), 2, 1) == [(0, 0, 2, 2), (1, 0, 2, 2), (0, 1, 2, 2), (1, 1, 2, 2)]\n", "\nassert generate_bounding_boxes(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), 3... |
06449927f0c543c73ff6d3c5fca49da4 | [
{
"content": "On te demande d'implémenter une fonction `calculate_logistic_growth` qui modélise la croissance logistique. La fonction doit accepter un seul argument `x`, qui peut être soit un entier positif, soit un tenseur PyTorch d'entiers positifs. Le modèle de croissance logistique est défini comme suit :\n... | ["\nassert calculate_logistic_growth(1) == 11.11111111111111\n", "\nassert calculate_logistic_growth(10) == 90.90909090909091\n", "\nassert torch.allclose(calculate_logistic_growth(torch.tensor([1, 10])), torch.tensor([11.11111111111111, 90.90909090909091]))\n", "\nassert calculate_logistic_growth(20) == 99.00664883248... |
f820b2cb640d062e1f8d87a8e42c4def | [
{
"content": "On te donne un graphe non orienté représenté sous forme de dictionnaire où chaque clé est un indice de nœud et la valeur correspondante est une liste des nœuds connectés. Le graphe peut ne pas être entièrement connecté, et certains nœuds peuvent ne pas avoir de connexions. Ta tâche est de mettre e... | ["\nassert add_node_connection({}, 0, 1) == {0: [1], 1: []}\n", "\nassert add_node_connection({0: [1], 1: []}, 1, 2) == {0: [1], 1: [2], 2: []}\n", "\nassert add_node_connection({0: [1], 1: [2], 2: []}, 2, 0) == {0: [1], 1: [2], 2: []}\n", "\nassert add_node_connection({0: [1], 1: [2], 2: []}, 0, 2) == {0: [1, 2], 1: [... |
f497f6bc3105175ef99cceff870988ac | [
{
"content": "Tu développes une fonction pour un système piloté par les événements où les événements peuvent être émis à tout moment. Ta tâche est de créer une fonction `wait_for_event` qui prend un objet système d'événements et un nom d'événement en entrée et renvoie un objet `Future`. Cet objet `Future` doit ... | ["\nassert wait_for_event(EventSystem(), 'my_event').result() == 'Hello, World!' if (event_sys := EventSystem()) and (future := wait_for_event(event_sys, 'my_event')) and event_sys.emit_event('my_event', 'Hello, World!') else False\n", "\nassert wait_for_event(EventSystem(), 'another_event').result() == 42 if (event_sy... |
36264c4c74cde189beb1fa57f59f1408 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'écrire une fonction qui traite cette liste et renvoie une nouvelle liste contenant uniquement les chaînes uniques, en préservant leur ordre d'apparition d'origine.\n\n**Entrée :**\n- Une liste de chaînes de caractères, où chaque chaîne... | ["\nassert remove_duplicates([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"kiwi\"]) == [\"apple\", \"banana\", \"orange\", \"kiwi\"]\n", "\nassert remove_duplicates([\"hello\", \"world\", \"hello\", \"python\"]) == [\"hello\", \"world\", \"python\"]\n", "\nassert remove_duplicates([\"a\", \"b\", \"c\", \... |
b850557cf0fc97484c81e978b1a4caad | [
{
"content": "On te donne une chaîne de caractères `text` contenant une séquence de mots. Ta tâche est de mettre en œuvre une fonction `count_unique_words(text)` qui traite le texte et renvoie un dictionnaire avec le nombre de chaque mot unique, en excluant les mots vides courants de l'anglais. La fonction doit... | ["\nassert count_unique_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_unique_words(\"The quick brown fox jumps over the lazy dog. The dog barked back at the fox.\") == {'quick': 1, 'brown': 1, 'fox': 2, 'jump... |
48abbfd332ef4aecd7d2c28851834ef1 | [
{
"content": "On te donne une liste de livres, chacun représenté comme un dictionnaire avec les clés 'title', 'author' et 'year'. Ta tâche est d'implémenter une fonction `sort_books_by_year` qui trie cette liste de dictionnaires en fonction de l'année de publication par ordre croissant. Si deux livres partagent... | ["\nassert sort_books_by_year([{\"title\": \"A\", \"author\": \"X\", \"year\": 2000}, {\"title\": \"B\", \"author\": \"Y\", \"year\": 1999}]) == [{\"title\": \"B\", \"author\": \"Y\", \"year\": 1999}, {\"title\": \"A\", \"author\": \"X\", \"year\": 2000}]\n", "\nassert sort_books_by_year([{\"title\": \"B\", \"author\":... |
3e5fbda4acc532f1cc5a54385a87a9c3 | [
{
"content": "On te demande d'implémenter un système de gestion de réseau pour une topologie de réseau dynamique impliquant des instances de Routage Virtuel et de Transmission (VRF). Chaque VRF est identifié de manière unique par un ID. Par défaut, la traduction d'adresse réseau source (S-NAT) est activée entre... | ["\nassert VRFManager().get_disabled_snat_rules() == {}\n", "\nassert VRFManager().add_or_update_vrf_pair('VRF1', 'VRF2', False, True, \"S-NAT disabled by orchestrator\") is None\n", "\nassert VRFManager().add_or_update_vrf_pair('VRF1', 'VRF3', True, False, \"S-NAT enabled manually\") is None\n", "\nmanager = VRFManage... |
14b731e855b043b43a9ab5ab18c1a4a8 | [
{
"content": "On te donne un fichier binaire nommé `data.bin` qui contient une séquence d'entiers signés sur 8 bits (octets). Ta tâche est d'écrire une fonction `convert_to_unsigned_bytes(file_path)` qui lit ces octets depuis le fichier et les convertit en leur représentation d'entier non signé sur 8 bits corre... | ["\nassert convert_to_unsigned_bytes(\"test1.bin\") == [255, 254, 3, 4]\n", "\nassert convert_to_unsigned_bytes(\"test2.bin\") == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert convert_to_unsigned_bytes(\"test3.bin\") == [127, 128, 129, 130]\n", "\nassert convert_to_unsigned_bytes(\"test4.bin\") == [255, 0, 128, 127]... |
f71e290b9777e9fbd545f07c2425255c | [
{
"content": "On te donne une liste de dictionnaires `data`, où chaque dictionnaire contient des informations sur une personne avec les clés 'name', 'age' et 'city'. Ta tâche est d'implémenter une fonction `filter_by_city(data, city)` qui renvoie une liste de dictionnaires représentant les individus qui résiden... | ["\nassert filter_by_city([{'name': 'Alice', 'age': 25, 'city': 'New York'}, {'name': 'Bob', 'age': 30, 'city': 'Chicago'}], 'New York') == [{'name': 'Alice', 'age': 25, 'city': 'New York'}]\n", "\nassert filter_by_city([{'name': 'Alice', 'age': 25, 'city': 'New York'}, {'name': 'Bob', 'age': 30, 'city': 'Chicago'}], '... |
4420f9717faac1d5664b31d0e117f683 | [
{
"content": "Tu participes à un concours de programmation où tu dois créer une fonction Python pour interagir avec les journaux AWS CloudWatch Logs. Ta tâche est de récupérer les 10 événements de journal les plus récents d'un groupe de journaux spécifié. Ta fonction doit gérer les erreurs potentielles et les m... | ["\nassert get_recent_log_events(\"non_existent_log_group\", {\"AWS_ACCESS_KEY_ID\": \"fake_key\", \"AWS_SECRET_ACCESS_KEY\": \"fake_secret\", \"AWS_REGION\": \"us-east-1\"}) == {'status': False, 'log_events': [], 'error_message': \"Log group 'non_existent_log_group' does not exist.\"}\n", "\nassert get_recent_log_even... |
e6979d9a4eef11a81b4abcb4587e3117 | [
{
"content": "On te donne un fichier `.dat` nommé `planets.dat` qui contient des informations sur les planètes de notre système solaire. Chaque ligne du fichier représente une planète et inclut son nom, sa masse, son rayon et son nombre de lunes, séparés par des virgules. Les valeurs de masse et de rayon sont f... | ["\nassert read_planet_data('test_planets.dat') == [{'name': 'Earth', 'mass': 5.972e24, 'radius': 6.371e6, 'moons': 1}]\n", "\nassert read_planet_data('test_planets.dat') == [{'name': 'Earth', 'mass': 5.972e24, 'radius': 6.371e6, 'moons': 1}, {'name': 'Mars', 'mass': 6.39e23, 'radius': 3.3895e6, 'moons': 2}]\n", "\nass... |
643cf3ab0f458a58285eef467ac841fe | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est d'implémenter une fonction `find_common_elements(list1, list2)` qui renvoie une liste contenant les éléments communs uniques entre les deux listes. L'ordre des éléments dans la liste renvoyée n'a pas d'importance.\n\n**Entrée :**\... | ["\nassert find_common_elements([1, 2, 3], [2, 3, 4]) == [2, 3]\n", "\nassert find_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_common_elements(['a', 'b', 'c'], ['b', 'c', 'd']) == ['b', 'c']\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], [... |
44231ce8e4c669104f0726bf239ba7f7 | [
{
"content": "On te demande d'optimiser une fonction pour déterminer si un entier donné est un nombre premier. Refactorise la fonction Python fournie pour qu'elle respecte des idiomes et des modèles Python plus courants. Ta fonction doit vérifier efficacement la primalité et gérer correctement les cas limites.\... | ["\nassert is_prime(1) == False\n", "\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(17) == True\n", "\nassert is_prime(18) == False\n", "\nassert is_prime(19) == True\n", "\nassert is_prime(20) == False\n", "\nassert is_prime(97) == True\n", "\na... |
80885ea2de10218bbb68dcaf0c59a366 | [
{
"content": "Dans un jeu de devinettes de mots, tu dois concevoir une fonction qui construit un plateau de jeu. Le plateau de jeu doit représenter un mot ou une phrase donné en remplaçant chaque lettre par un symbole choisi aléatoirement dans l'ensemble { '*', '^', '#' }, et chaque espace par un espace (\" \")... | ["\nassert generate_game_board(\"hello\") in [['*', '^', '#'], ['*', '^', '#'], ['*', '^', '#'], ['*', '^', '#'], ['*', '^', '#']]\n", "\nassert generate_game_board(\"hi there\") in [['*', '^', '#'], ['*', '^', '#'], [' '], ['*', '^', '#'], ['*', '^', '#'], ['*', '^', '#'], ['*', '^', '#'], ['*', '^', '#']]\n", "\nasse... |
7d24c76445fe28d10bee43bddce5699e | [
{
"content": "On te donne un entier décimal `number`. Ta tâche est d'écrire une fonction `convert_to_binary(number)` qui convertit cet entier en sa représentation binaire sous forme de chaîne de caractères. La fonction doit gérer à la fois les entiers positifs et négatifs.\n\n**Entrée :**\n- Un entier `number` ... | ["\nassert convert_to_binary(0) == '0'\n", "\nassert convert_to_binary(1) == '1'\n", "\nassert convert_to_binary(2) == '10'\n", "\nassert convert_to_binary(5) == '101'\n", "\nassert convert_to_binary(10) == '1010'\n", "\nassert convert_to_binary(15) == '1111'\n", "\nassert convert_to_binary(31) == '11111'\n", "\nassert... |
ec9c1bc5447df4c301535ef88a54d4fd | [
{
"content": "On te demande d'implémenter une fonction `color_grade(grade)` pour une application web qui met en évidence les notes en fonction de leur valeur. La fonction doit prendre un seul nombre à virgule flottante `grade` en entrée, qui représente une note comprise entre 0 et 1 (inclus). Avant de détermine... | ["\nassert color_grade(0.5) == 'color: red'\n", "\nassert color_grade(0.6) == 'color: red'\n", "\nassert color_grade(0.61) == 'color: orange'\n", "\nassert color_grade(0.79) == 'color: orange'\n", "\nassert color_grade(0.8) == 'color: orange'\n", "\nassert color_grade(0.81) == 'color: green'\n", "\nassert color_grade(0... |
788d4f88a3647c12729a48a0dcc19fb1 | [
{
"content": "On te demande d'implémenter un serveur web simple en Python qui sert des fichiers statiques à partir d'un répertoire spécifié. Ton serveur doit utiliser le module `http.server` et écouter sur le port 8000. Le répertoire à partir duquel les fichiers seront servis s'appelle `public`. Ton serveur doi... | ["\nassert \"Serving at port 8000\" in str(subprocess.check_output([\"python\", \"server.py\"]))\n", "\nassert requests.get(\"http://localhost:8000/index.html\").status_code == 200\n", "\nassert requests.get(\"http://localhost:8000/nonexistent.html\").status_code == 404\n", "\nassert \"Hello, World!\" in requests.get(\... |
92e34b0d4900fb5f6f03fb1ffd7ba6d4 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui renvoie une nouvelle liste où chaque entier est incrémenté de son index dans la liste originale. Si la liste d'entrée est vide, la fonction doit renvoyer une liste vide.\n\n**Entrée :**\n- Une liste d'entiers, `numbers` (0 ≤ l... | ["\nassert increment_by_index([1, 2, 3, 4]) == [1, 3, 5, 7]\n", "\nassert increment_by_index([0, 0, 0, 0]) == [0, 1, 2, 3]\n", "\nassert increment_by_index([-1, -2, -3, -4]) == [-1, -1, -1, -1]\n", "\nassert increment_by_index([100, 200, 300]) == [100, 201, 302]\n", "\nassert increment_by_index([]) == []\n", "\nassert ... |
bd926df3528d32fc8bb3d42721793e03 | [
{
"content": "On te donne une liste de boîtes englobantes, chacune représentée comme une liste de quatre entiers `[x_min, y_min, x_max, y_max]`. Ta tâche est d'écrire une fonction qui convertit ces boîtes englobantes au format `[x_min, y_min, largeur, hauteur]`. La fonction doit gérer les boîtes englobantes mal... | ["\nassert convert_bounding_boxes([[10, 15, 30, 40]]) == [[10, 15, 20, 25]]\n", "\nassert convert_bounding_boxes([[50, 60, 20, 70]]) == [[20, 60, 30, 10]]\n", "\nassert convert_bounding_boxes([[0, 0, 100, 100]]) == [[0, 0, 100, 100]]\n", "\nassert convert_bounding_boxes([[10, 20, 10, 20]]) == [[10, 20, 0, 0]]\n", "\nas... |
3a06a981d40cfd6b0f8096e93c3c5dca | [
{
"content": "On te donne un bloc de texte. Ta tâche est d'écrire un programme Python qui prétraite le texte en le convertissant en minuscules, en supprimant la ponctuation et en le tokenisant en mots. Après le prétraitement, le programme doit compter les occurrences de chaque mot unique et afficher les résulta... | ["\nassert count_word_occurrences(\"Hello, hello! HELLO.\") == {'hello': 3}\n", "\nassert count_word_occurrences(\"Python, Python, python!\") == {'python': 3}\n", "\nassert count_word_occurrences(\"This is a test. This test is only a test.\") == {'this': 2, 'is': 2, 'a': 2, 'test': 3, 'only': 1}\n", "\nassert count_wor... |
92142df8388eea3a4900b442eb24f65e | [
{
"content": "On te donne une chaîne de caractères `path` représentant un chemin de fichier avec des points en tête potentiels et une casse mixte, y compris des caractères Unicode. Ta tâche est d'écrire une fonction `adjust_path(path)` qui divise le `path` en un nom de répertoire et un nom de base tout en prése... | ["\nassert adjust_path(\"../Exampl\u00eb/Dir/Subdir/f\u00efle.txt\") == ('../Exampl\u00eb/Dir/Subdir', 'f\u00efle.txt')\n", "\nassert adjust_path(\"C:\\\\Users\\\\Example\\\\Documents\\\\file.docx\") == ('C:\\\\Users\\\\Example\\\\Documents', 'file.docx')\n", "\nassert adjust_path(\"/home/user/Music/song.mp3\") == ('/h... |
8cce4756fc0fe609e5a9c1921b0b29fb | [
{
"content": "Tu es chargé d'implémenter une fonction `parse_json_to_dict` qui traite une chaîne contenant des données JSON et la transforme en un dictionnaire Python. Ta fonction doit gérer gracieusement les entrées JSON malformées en renvoyant un dictionnaire vide. De plus, ta solution doit être optimisée pou... | ["\nassert parse_json_to_dict('{\"name\": \"John\", \"age\": 30}') == {\"name\": \"John\", \"age\": 30}\n", "\nassert parse_json_to_dict('{\"key\": \"value\", \"number\": 123, \"array\": [1, 2, 3]}') == {\"key\": \"value\", \"number\": 123, \"array\": [1, 2, 3]}\n", "\nassert parse_json_to_dict('{\"nested\": {\"key\": ... |
e2ac240c700ecae7623ba4e03ba63b47 | [
{
"content": "On te donne une liste imbriquée d'entiers. Ta tâche est d'implémenter une fonction `sum_recursively` qui calcule la somme de tous les entiers dans la liste, quel que soit le niveau d'imbrication. La fonction doit renvoyer 0 pour les listes vides ou les listes contenant uniquement des listes vides ... | ["\nassert sum_recursively([1, [2, [3, 4], 5], 6]) == 21\n", "\nassert sum_recursively([]) == 0\n", "\nassert sum_recursively([[], [[], []], [[[]]]]) == 0\n", "\nassert sum_recursively([1, 2, 3, 4, 5]) == 15\n", "\nassert sum_recursively([1, [2, 3], [4, [5, 6]]]) == 21\n", "\nassert sum_recursively([10, [20, [30, [40, ... |
7a86dba6b7ddbb6ca42ed78faa2ff2ba | [
{
"content": "On te donne une image en niveaux de gris représentée comme une liste 2D `image` de taille `n x m`, où chaque élément est un entier compris entre 0 et 255 inclusivement, représentant l'intensité d'un seul pixel. Ta tâche est d'écrire une fonction `normalize_image(image)` qui normalise les intensité... | ["\nassert normalize_image([[0, 0], [0, 0]]) == [[0.5, 0.5], [0.5, 0.5]]\n", "\nassert normalize_image([[255, 0], [0, 255]]) == [[1.0, 0.0], [0.0, 1.0]]\n", "\nassert normalize_image([[128, 128], [128, 128]]) == [[0.5, 0.5], [0.5, 0.5]]\n", "\nassert normalize_image([[100, 150], [200, 250]]) == [[0.4, 0.6], [0.8, 1.0]]... |
f48c0e917a68ab0f2790b6423000ff05 | [
{
"content": "On te donne un fichier nommé `names.txt` situé dans le même répertoire que ton script. Le fichier contient une liste de noms, chaque nom étant sur une ligne distincte. Ta tâche est d'écrire un programme qui lit ce fichier et affiche le nombre de noms uniques, sans tenir compte de la casse.\n\n**En... | ["\nassert count_unique_names('names.txt') == None\n", "\nassert count_unique_names('nonexistentfile.txt') == None\n", "\nassert count_unique_names('emptyfile.txt') == None\n", "\nassert count_unique_names('single_name.txt') == None\n", "\nassert count_unique_names('duplicate_names.txt') == None\n", "\nassert count_uni... |
3680cb322a5e76a7adb0d36556caaeb3 | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est de déterminer le nombre maximal de paires `(a, b)` telles que `a + b` soit un carré parfait. Chaque élément de `nums` peut être utilisé dans au plus une paire. Par exemple, si `nums = [2, 3, 6, 9]`, le nombre maximal de paires est `1` (associer ... | ["\nassert maxPerfectSquarePairs([2, 3, 6, 9]) == 1\n", "\nassert maxPerfectSquarePairs([1, 3, 5, 7, 9]) == 0\n", "\nassert maxPerfectSquarePairs([4, 5, 11, 14]) == 1\n", "\nassert maxPerfectSquarePairs([1, 2, 3, 4, 5, 6, 7, 8, 9]) == 2\n", "\nassert maxPerfectSquarePairs([1, 1, 1, 1, 1, 1]) == 3\n", "\nassert maxPerfe... |
bb76b77a38f6bfa5c16e1c3e0645076a | [
{
"content": "On te donne deux listes d'entiers ou de nombres à virgule flottante, `selling_prices` et `cost_prices`, chacune de longueur `n`. Ta tâche est de mettre en œuvre une fonction `calculate_profit` qui calcule le profit ou la perte pour chaque article. Le profit d'un article est défini comme la différe... | ["\nassert calculate_profit([100, 200, 150], [80, 220, 120]) == [20, -20, 30]\n", "\nassert calculate_profit([10, 20, 30], [5, 15, 25]) == [5, 5, 5]\n", "\nassert calculate_profit([50, 60, 70], [50, 60, 70]) == [0, 0, 0]\n", "\nassert calculate_profit([100, 100, 100], [90, 110, 100]) == [10, -10, 0]\n", "\nassert calcu... |
205cbd2ae37bb327ff7aa9e2b1908504 | [
{
"content": "On te donne une grille N x N représentant un échiquier, où chaque cellule peut être vide, contenir une tour ou contenir un mur. Une tour peut se déplacer d'un nombre quelconque de cases le long d'une rangée ou d'une colonne jusqu'à ce qu'elle rencontre un mur ou une autre tour. Les murs sont repré... | ["\nassert can_place_rook([[False, False, False], [False, False, False], [False, False, False]], 0, 0) == True\n", "\nassert can_place_rook([[False, True, False], [False, False, False], [False, False, False]], 0, 1) == False\n", "\nassert can_place_rook([[False, False, False], [True, False, False], [False, False, False... |
fd9ca5d487b74b4270264f65faaf2e78 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ton objectif est d'écrire une fonction qui renvoie un dictionnaire où chaque caractère unique de la chaîne est une clé et sa valeur correspondante est son nombre d'occurrences.\n\n**Entrée :**\n- Une seu... | ["\nassert character_count(\"aabbcc\") == {'a': 2, 'b': 1, 'c': 2}\n", "\nassert character_count(\"hello\") == {'h': 1, 'e': 1, 'l': 2, 'o': 1}\n", "\nassert character_count(\"\") == {}\n", "\nassert character_count(\"123321\") == {'1': 2, '2': 2, '3': 2}\n", "\nassert character_count(\"!@#$%^&*()\") == {'!': 1, '@': 1... |
8a3fde05bb1eba86967baf0356d95c21 | [
{
"content": "On te donne un ensemble de données de relevés de température pour une ville à différents moments de la journée. Malheureusement, certains relevés sont manquants, représentés par `None` dans la liste. Ta tâche est d'écrire une fonction qui remplit ces valeurs manquantes en utilisant une interpolati... | ["\nassert interpolate_missing_temperatures([20.0, 22.5, None, None, 25.0, 27.5], [0, 1, 2, 3, 4, 5]) == [20.0, 22.5, 23.75, 25.0, 25.0, 27.5]\n", "\nassert interpolate_missing_temperatures([None, 22.5, 25.0, None, 30.0], [0, 1, 2, 3, 4]) == [22.5, 22.5, 25.0, 27.5, 30.0]\n", "\nassert interpolate_missing_temperatures(... |
53cb81e161b409c2caf65ec01e5d357c | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si la chaîne est un palindrome, en ignorant les espaces, la ponctuation et la casse. Un palindrome est une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :**\n- Une seule chaîne de cara... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Not a palindrome\") == False\n", "\nassert is_palindrome(\"Madam, in Eden, I'm Adam\") == T... |
fcc1eae7972c180fc4a7c022c5278429 | [
{
"content": "Étant donné un tableau d'entiers `nums`, détermine tous les triplets uniques dans le tableau qui s'additionnent à zéro. La fonction doit renvoyer une liste de ces triplets. Note que l'ensemble de solutions ne doit pas contenir de triplets dupliqués.\n\n**Contraintes :**\n- La longueur de `nums` se... | ["\nassert three_sum([-1, 0, 1, 2, -1, -4]) == [[-1, -1, 2], [-1, 0, 1]]\n", "\nassert three_sum([0, 0, 0]) == [[0, 0, 0]]\n", "\nassert three_sum([1, 2, -2, -1]) == []\n", "\nassert three_sum([-2, 0, 1, 1, 2]) == [[-2, 0, 2], [-2, 1, 1]]\n", "\nassert three_sum([3, -1, -7, 2, 9, -4, 6, -3, 2]) == [[-7, 2, 5], [-4, -3,... |
fa798a55ed6fc691761c3c36a2d61a32 | [
{
"content": "On te demande de développer une fonction qui récupère le prix moyen historique d'une cryptomonnaie spécifiée à partir d'une API d'échange de cryptomonnaies moins courante qui nécessite une authentification OAuth2. Ta fonction doit accepter le symbole de la cryptomonnaie et une plage de dates (date... | ["\nassert get_historical_average_price(\"client_id\", \"client_secret\", \"BTC\", \"2022-01-01\", \"2022-01-31\") == 45000.00\n", "\nassert get_historical_average_price(\"client_id\", \"client_secret\", \"ETH\", \"2022-02-01\", \"2022-02-28\") == 3000.00\n", "\nassert get_historical_average_price(\"client_id\", \"clie... |
06968e7cad321b228df13afb9b2e0b30 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si elle est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Hello, World!\") == False\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Madam, in Eden, I'm Adam\") == True... |
6d56381ff3da60d77c94cf02769807d7 | [
{
"content": "On te donne une chaîne de caractères `value`. Ta tâche est de transformer cette chaîne selon les règles suivantes :\n- Parcourir la chaîne caractère par caractère.\n- Si la valeur ASCII d'un caractère est un nombre premier, ignorer ce caractère.\n- Sinon, alterner la casse des caractères, en comme... | ["\nassert convert_alternate_case(\"hello\") == \"HeLlO\"\n", "\nassert convert_alternate_case(\"abcdefg\") == \"AbCdEfG\"\n", "\nassert convert_alternate_case(\"a\") == \"A\"\n", "\nassert convert_alternate_case(\"ab\") == \"Ab\"\n", "\nassert convert_alternate_case(\"abc\") == \"AbC\"\n", "\nassert convert_alternate_... |
68447cb6923e55f65922ea53ca8c0b1d | [
{
"content": "On te donne une liste `lst` et un entier `index`. Ta tâche est de déterminer si l'`index` est un index valide pour la liste `lst`. Un index valide est un index qui est non négatif et inférieur au nombre d'éléments dans la liste. Tu dois implémenter la fonction `is_index_valid` sans utiliser de mét... | ["\nassert is_index_valid([1, 2, 3], 0) == True\n", "\nassert is_index_valid([1, 2, 3], 2) == True\n", "\nassert is_index_valid([1, 2, 3], 3) == False\n", "\nassert is_index_valid([], 0) == False\n", "\nassert is_index_valid([1], 0) == True\n", "\nassert is_index_valid([1], 1) == False\n", "\nassert is_index_valid(['a'... |
cb3873c4dc8f487bf21839d326520655 | [
{
"content": "On te donne une liste d'objets `Product`, où chaque objet `Product` a un attribut `category` et `price`. Ta tâche est de regrouper ces produits en listes en fonction de leurs catégories, en veillant à ce qu'aucun groupe ne dépasse `group_size` produits et que le prix total au sein d'un groupe ne d... | ["\nassert group_products([], 2, 300) == {}\n", "\nassert group_products([Product(\"Electronics\", 100.0)], 2, 300) == {\"Electronics_1\": [Product(\"Electronics\", 100.0)]}\n", "\nassert group_products([Product(\"Electronics\", 100.0), Product(\"Electronics\", 200.0)], 2, 300) == {\"Electronics_1\": [Product(\"Electro... |
4b490f075849239225cb7e7186ff60fc | [
{
"content": "Implémente l'algorithme de tri rapide (QuickSort) en Python. Ta fonction doit prendre une liste d'entiers en entrée et renvoyer une nouvelle liste avec les entiers triés par ordre croissant. La fonction doit utiliser le dernier élément de la liste comme pivot.\n\n**Entrée :**\n- Une liste d'entier... | ["\nassert quicksort([3, 6, 8, 10, 1, 2, 1]) == [1, 1, 2, 3, 6, 8, 10]\n", "\nassert quicksort([10, 7, 8, 9, 1, 5]) == [1, 5, 7, 8, 9, 10]\n", "\nassert quicksort([5, 3, 8, 4, 2, 7, 1, 10]) == [1, 2, 3, 4, 5, 7, 8, 10]\n", "\nassert quicksort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert quicksort([5, 4, 3, 2, 1]) ... |
df4893d7105e524901417bce1a703a99 | [
{
"content": "On te donne deux listes d'entiers, `a` et `b`. Ta tâche est d'écrire une fonction qui renvoie une liste contenant l'intersection de ces deux listes, c'est-à-dire les éléments qui sont communs aux deux listes. L'ordre des éléments dans la liste résultante n'a pas d'importance. Ta solution doit être... | ["\nassert intersect([1, 2, 3], [2, 3, 4]) == [2, 3]\n", "\nassert intersect([1, 5, 9], [2, 6, 5]) == [5]\n", "\nassert intersect([], [1, 2, 3]) == []\n", "\nassert intersect([1, 2, 3], []) == []\n", "\nassert intersect([], []) == []\n", "\nassert intersect(['a', 'b', 'c'], ['b', 'c', 'd']) == ['b', 'c']\n", "\nassert ... |
ea1ec4bd8ce69ad7248e78847a8aad41 | [
{
"content": "On te demande d'implémenter une fonction `merge_table_descriptions` qui traite deux descriptions de tables et les fusionne selon des règles spécifiques. Chaque description de table est représentée comme un dictionnaire où les clés sont les noms de colonnes et les valeurs sont des listes de chaînes... | ["\nassert merge_table_descriptions({\"col1\": [\"desc1\"]}, {\"col1\": [\"desc2\"]}) == {\"col1\": \"desc2\"}\n", "\nassert merge_table_descriptions({\"col1\": [\"desc1\"]}, {}) == {\"col1\": \"desc1\"}\n", "\nassert merge_table_descriptions({}, {\"col1\": [\"desc2\"]}) == {\"col1\": \"desc2\"}\n", "\nassert merge_tab... |
4f0ad0159db6974755ce6afd7177372d | [
{
"content": "On te donne une liste imbriquée `prices_list` où chaque liste interne contient les prix des produits pour un client différent. De plus, on te fournit un dictionnaire imbriqué `discounts_dict` où chaque dictionnaire interne contient les réductions disponibles pour chaque produit pour un client diff... | ["\nassert calculate_total_cost([[100, 200, 300]], {'customer1': {'product1': 0.1, 'product2': 0.2, 'product3': 0.05}}) == [325.0]\n", "\nassert calculate_total_cost([[50, 150, 250]], {'customer1': {'product1': 0.05, 'product2': 0.1, 'product3': 0.15}}) == [322.5]\n", "\nassert calculate_total_cost([[100, 100, 100]], {... |
fcc4562c7f98a8c5fd56d61b3d2cb7b4 | [
{
"content": "On te demande d'implémenter une fonction `left_pad` qui prend trois paramètres : `value`, `length`, et un `pad_char` optionnel qui vaut par défaut '0'. La fonction doit renvoyer une représentation sous forme de chaîne de caractères de `value` complétée à gauche avec `pad_char` pour atteindre la `l... | ["\nassert left_pad(5, 3) == \"005\"\n", "\nassert left_pad(\"abc\", 6, '#') == \"###abc\"\n", "\nassert left_pad(12345, 2) == \"12345\"\n", "\nassert left_pad(\"hello\", 5) == \"hello\"\n", "\nassert left_pad(\"world\", 10, '*') == \"*****world\"\n", "\nassert left_pad(0, 4) == \"0000\"\n", "\nassert left_pad(\"test\"... |
3dd955da152fc8b5a222fa4b1da4190c | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction `find_largest_prime` qui identifie et renvoie le plus grand nombre premier présent dans la liste. Si la liste ne contient aucun nombre premier, la fonction doit renvoyer `None`. Suppose que la liste d'entrée ne ... | ["\nassert find_largest_prime([2, 3, 5, 7, 11]) == 11\n", "\nassert find_largest_prime([4, 6, 8, 9, 10]) == None\n", "\nassert find_largest_prime([13, 17, 19, 23, 29]) == 29\n", "\nassert find_largest_prime([31, 37, 41, 43, 47, 53]) == 53\n", "\nassert find_largest_prime([1, 0, -1, -3, -5]) == None\n", "\nassert find_l... |
fc477b737806f8ebfe3e002d58945f77 | [
{
"content": "On te demande d'implémenter une classe Python `CSVFileReader` qui traite un fichier CSV. La classe doit être initialisée avec un chemin de fichier. Implémente une méthode `read_file` qui lit le fichier CSV et renvoie son contenu sous forme de liste de dictionnaires. Chaque dictionnaire doit représ... | ["\nassert CSVFileReader(\"test1.csv\").read_file() == [{'Column1': 'a', 'Column2': 'b', 'Column3': 'c'}, {'Column1': '1', 'Column2': '2', 'Column3': '3'}]\n", "\nassert CSVFileReader(\"test2.csv\").read_file() == [{'name': 'Alice', 'age': '30', 'city': 'New York'}, {'name': 'Bob', 'age': '25', 'city': 'Los Angeles'}]\... |
8219bb336e7de2566a2ad0476b3cd498 | [
{
"content": "On te charge de gérer un système de réservation de salles de conférence. Les réunions sont programmées à différents moments, et chaque réunion est définie par ses heures de début et de fin. Des réunions peuvent être programmées dans la même salle si elles ne se chevauchent pas dans le temps. Ton o... | ["\nassert min_meeting_rooms([(1, 3), (2, 4), (5, 7), (6, 8)]) == 2\n", "\nassert min_meeting_rooms([(0, 30), (5, 10), (15, 20)]) == 2\n", "\nassert min_meeting_rooms([(2, 7)]) == 1\n", "\nassert min_meeting_rooms([(1, 5), (6, 10), (11, 15)]) == 1\n", "\nassert min_meeting_rooms([(1, 5), (2, 3), (4, 6)]) == 2\n", "\nas... |
3dcfe0dc010f0a8b8f2f493d6abf7203 | [
{
"content": "On te donne un graphe représenté par un dictionnaire `node_hashes`. Chaque clé du dictionnaire correspond à un nœud du graphe, et sa valeur est une liste de chaînes hexadécimales représentant les hachages de ses sous-graphes. Chaque hachage est une représentation hexadécimale d'une chaîne d'octets... | ["\nassert validate_hex_hashes({\"node1\": [\"0000\", \"00ff\"]}, 1) == True\n", "\nassert validate_hex_hashes({\"node1\": [\"0000\", \"00ff\"]}, 2) == False\n", "\nassert validate_hex_hashes({\"node1\": [\"00ff\", \"ff00\"]}, 1) == True\n", "\nassert validate_hex_hashes({\"node1\": [\"00ff\", \"ff00\"]}, 2) == True\n"... |
8de034d774e6c392ea548dffbb00b0ce | [
{
"content": "On te donne une structure de liste imbriquée où chaque élément est soit un entier, soit une autre liste. Ta tâche est d'écrire une fonction `flatten_list` qui prend cette liste imbriquée en entrée et renvoie une nouvelle liste contenant tous les entiers de la liste imbriquée sous une forme aplatie... | ["\nassert flatten_list([1, 2, [3, 4], [5, [6, 7]]]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert flatten_list([1, [2, [3, [4, [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten_list([[[[1], 2], 3], 4]) == [1, 2, 3, 4]\n", "\nassert flatten_list([]) == []\n", "\nassert flatten_list([[], [], []]) == []\n", "\nassert flatten_li... |
0bc39f40c286328c444902ec4b7791a0 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est de convertir chaque chaîne en une liste de ses valeurs ASCII. La sortie doit être une liste de listes, où chaque sous-liste contient les valeurs ASCII des caractères de la chaîne correspondante.\n\n**Entrée :**\n- Une liste de chaînes de... | ["\nassert strings_to_ascii(['hello']) == [[104, 101, 108, 108, 111]]\n", "\nassert strings_to_ascii(['world']) == [[119, 111, 114, 108, 100]]\n", "\nassert strings_to_ascii(['']) == [[]]\n", "\nassert strings_to_ascii(['a', 'b', 'c']) == [[97], [98], [99]]\n", "\nassert strings_to_ascii(['abc', 'def']) == [[97, 98, 99... |
c27ab38aa8351542a41e010dbbecb4cc | [
{
"content": "On te donne une liste de relevés de température quotidiens en Celsius. Certains relevés peuvent être manquants ou invalides (représentés par `None` ou des valeurs non numériques). Implémente une fonction `calculate_average_temperature` qui calcule la moyenne des relevés de température valides. S'i... | ["\nassert calculate_average_temperature([22.5, 19.0, None, 21.2, 'invalid', 23.8]) == 22.125\n", "\nassert calculate_average_temperature([10, 20, 30, 40, 50]) == 30.0\n", "\nassert calculate_average_temperature([None, None, None]) == None\n", "\nassert calculate_average_temperature(['a', 'b', 'c']) == None\n", "\nasse... |
827144bb4bb3cab5bf5202d26c63f706 | [
{
"content": "On te demande d'implémenter une classe `ShoppingCart` pour une boutique en ligne. La classe doit prendre en charge les opérations suivantes :\n\n- `add_item(item, quantity, price)` : Ajoute `quantity` de `item` au prix de `price` au panier. Si l'article existe déjà, met à jour sa quantité.\n- `rem... | ["\nassert ShoppingCart().view_cart() == []\n", "\nassert ShoppingCart().calculate_total() == 0\n", "\ncart = ShoppingCart()\ncart.add_item(\"apple\", 2, 0.5)\nassert cart.view_cart() == [(\"apple\", 2, 0.5)]\n", "\ncart = ShoppingCart()\ncart.add_item(\"banana\", 3, 0.3)\nassert cart.calculate_total() == 0.9\n", "\nca... |
1b7122838b85df02096b5fbd06ac843d | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `sum_of_primes` qui calcule la somme de tous les nombres premiers inférieurs ou égaux à `n`. Un nombre premier est défini comme un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même. Ta solution doit... | ["\nassert sum_of_primes(10) == 17\n", "\nassert sum_of_primes(1) == 0\n", "\nassert sum_of_primes(2) == 2\n", "\nassert sum_of_primes(0) == 0\n", "\nassert sum_of_primes(30) == 129\n", "\nassert sum_of_primes(100) == 1060\n", "\nassert sum_of_primes(5) == 10\n", "\nassert sum_of_primes(19) == 77\n", "\nassert sum_of_p... |
0d5f7ca49be83fd1b68b17d0db94c3fd | [
{
"content": "On te charge de gérer le système d'inventaire d'une entreprise. Étant donné un dictionnaire `inventory` où chaque clé est le nom d'un produit (une chaîne de caractères) et chaque valeur est la quantité de ce produit (un entier), implémente une fonction `reorder_products(inventory)` qui renvoie une... | ["\nassert reorder_products({\"product1\": 15, \"product2\": 8, \"product3\": 3, \"product4\": 20}) == [\"product2\", \"product3\"]\n", "\nassert reorder_products({\"itemA\": 5, \"itemB\": 10, \"itemC\": 2, \"itemD\": 15}) == [\"itemA\", \"itemC\"]\n", "\nassert reorder_products({\"widget\": 9, \"gadget\": 11, \"contra... |
b90222029c2c4b2edbef5e0af86fa113 | [
{
"content": "On te demande d'implémenter une fonction thread-safe `user_info_by_uid` qui récupère les informations d'un utilisateur en fonction de son identifiant utilisateur (UID). La fonction doit renvoyer un dictionnaire contenant le nom d'utilisateur, le répertoire personnel et le shell associé à l'UID. Si... | ["\nassert user_info_by_uid(0) == {'username': 'root', 'home_directory': '/root', 'shell': '/bin/bash'}\n", "\nassert user_info_by_uid(1) == {'username': 'daemon', 'home_directory': '/usr/sbin', 'shell': '/usr/sbin/nologin'}\n", "\nassert user_info_by_uid(99999) == {}\n", "\nassert user_info_by_uid(-1) == {}\n", "\nass... |
5dc84c6f36c5ae8dce3bc104b5b0aebd | [
{
"content": "On te donne une liste de chaînes de caractères représentant des noms de fichiers. Ta tâche est d'écrire une fonction Python qui renvoie une liste de noms de fichiers avec tous les doublons supprimés, en conservant l'ordre d'apparition original. Par exemple, étant donné la liste d'entrée `['report.... | ["\nassert remove_duplicates(['report.txt', 'data.csv', 'report.txt', 'summary.docx', 'data.csv']) == ['report.txt', 'data.csv', 'summary.docx']\n", "\nassert remove_duplicates(['file1.txt', 'file2.txt', 'file3.txt']) == ['file1.txt', 'file2.txt', 'file3.txt']\n", "\nassert remove_duplicates(['duplicate.txt', 'duplicat... |
606c23ab95f62bbd252c3cf31432e234 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules en anglais et éventuellement d'autres caractères. Ta tâche est de mettre en œuvre une fonction `compressString` qui traite la chaîne en supprimant toutes les lettres qui ne sont pas minuscules en anglais, puis en compressant l... | ["\nassert compressString(\"aaabbbccc\") == \"a3b3c3\"\n", "\nassert compressString(\"abcd\") == \"abcd\"\n", "\nassert compressString(\"a1b2c3\") == \"abc\"\n", "\nassert compressString(\"aabbcc123\") == \"a2b2c2\"\n", "\nassert compressString(\"aabbcc!!@@##\") == \"a2b2c2\"\n", "\nassert compressString(\"a\") == \"a1... |
8895b575ab8538b768adf6b1ee63c3ba | [
{
"content": "On te donne une liste triée d'entiers, `numbers`, et un entier cible, `target`. Ta tâche est de déterminer le plus petit entier dans `numbers` qui est à la fois supérieur ou égal à `target` et un nombre premier. Si un tel entier n'existe pas, renvoie `None`.\n\n**Entrée :**\n- La première ligne co... | ["\nassert find_next_largest_prime([2, 3, 5, 7, 11], 5) == 5\n", "\nassert find_next_largest_prime([2, 3, 5, 7, 11], 6) == 7\n", "\nassert find_next_largest_prime([2, 3, 5, 7, 11], 11) == 11\n", "\nassert find_next_largest_prime([2, 3, 5, 7, 11], 12) == None\n", "\nassert find_next_largest_prime([2, 3, 5, 7, 11], 1) ==... |
9b9a167c4ad1deab7fbfccccccb0411a | [
{
"content": "Dans un projet de développement logiciel, tu es chargé de gérer plusieurs versions d'un programme. Chaque version est identifiée de manière unique par un identifiant de version. On te fournit une fonction `get_versions(program_id, client, query_params)` qui renvoie une liste de versions pour un ID... | ["\nassert get_latest_version(\"program1\", client, {}) == \"1.2.3\"\n", "\nassert get_latest_version(\"program2\", client, {}) == \"2.0.0\"\n", "\nassert get_latest_version(\"program3\", client, {}) == \"0.9.9\"\n", "\nassert get_latest_version(\"program4\", client, {}) == \"10.0.0\"\n", "\nassert get_latest_version(\... |
dfdebbc3c74dee2077f8ed94176cc65a | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de trouver la plus longue sous-chaîne palindromique dans `s`. Un palindrome est défini comme une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche. Implémente une fonction pour résoudre ce problème en Python. La fon... | ["\nassert longest_palindromic_substring(\"babad\") == \"bab\" or longest_palindromic_substring(\"babad\") == \"aba\"\n", "\nassert longest_palindromic_substring(\"cbbd\") == \"bb\"\n", "\nassert longest_palindromic_substring(\"a\") == \"a\"\n", "\nassert longest_palindromic_substring(\"ac\") == \"a\" or longest_palind... |
2dfd8691214a1ed5ae5dc3f8904fe484 | [
{
"content": "On te demande d'implémenter une classe `Matrix` qui prend en charge les opérations matricielles de base : l'addition, la soustraction et la multiplication. Les matrices sont représentées sous forme de listes 2D. Assure-toi que les dimensions sont appropriées pour les opérations. Ton implémentation... | ["\nassert str(Matrix([[1, 2], [3, 4]]).add(Matrix([[5, 6], [7, 8]]))) == \"6 8\\n10 12\"\n", "\nassert str(Matrix([[1, 2], [3, 4]]).subtract(Matrix([[1, 1], [1, 1]]))) == \"0 1\\n2 3\"\n", "\nassert str(Matrix([[1, 2], [3, 4]]).multiply(Matrix([[2, 0], [1, 2]]))) == \"4 4\\n10 8\"\n", "\nassert str(Matrix([[1, 2, 3], ... |
a8c88bf89a66cc6030189a64101111ca | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction récursive qui calcule la somme de tous les éléments de la liste. La fonction doit gérer une liste vide en renvoyant 0.\n\n**Exemple d'entrée :**\n```\n[1, 2, 3, 4, 5]\n```\n\n**Exemple de sortie :**\n```\n15\n```\n\nLa foncti... | ["\nassert recursive_sum([1, 2, 3, 4, 5]) == 15\n", "\nassert recursive_sum([10, 20, 30]) == 60\n", "\nassert recursive_sum([]) == 0\n", "\nassert recursive_sum([0, 0, 0, 0]) == 0\n", "\nassert recursive_sum([-1, -2, -3, -4, -5]) == -15\n", "\nassert recursive_sum([100]) == 100\n", "\nassert recursive_sum([1, -1, 1, -1... |
d4a3b45536f423e1b799f6d0fe7ab6ab | [
{
"content": "On te donne un arbre binaire où chaque nœud a une valeur entière. Ta tâche est de déterminer si l'arbre binaire est équilibré. Un arbre binaire est considéré comme équilibré si, pour chaque nœud de l'arbre, la différence de hauteur entre les sous-arbres gauche et droit est au plus égale à 1. Implé... | ["\nassert is_balanced(None) == True\n", "\nassert is_balanced(TreeNode(1)) == True\n", "\nassert is_balanced(TreeNode(1, TreeNode(2))) == True\n", "\nassert is_balanced(TreeNode(1, TreeNode(2), TreeNode(3))) == True\n", "\nassert is_balanced(TreeNode(1, TreeNode(2, TreeNode(4)), TreeNode(3))) == True\n", "\nassert is_... |
7ce419530325ae73cf2897a173f38eaf | [
{
"content": "On te donne une liste d'entiers représentant les forces appliquées à une série d'objets interconnectés. Chaque objet subit une force nette égale à la force qui lui est appliquée moins la force appliquée à l'objet suivant dans la série. Le dernier objet de la série subit une force nette égale à la ... | ["\nassert calculate_net_forces([5, -3, 2, -8, 4]) == [8, -5, 10, 12, 4]\n", "\nassert calculate_net_forces([10, 10, 10, 10]) == [0, 0, 0, 10]\n", "\nassert calculate_net_forces([-1, -2, -3, -4]) == [1, 1, 1, -4]\n", "\nassert calculate_net_forces([0, 0, 0, 0]) == [0, 0, 0, 0]\n", "\nassert calculate_net_forces([1, -1,... |
04b2e6e4b91d9d258560429b24a6e926 | [
{
"content": "On te donne une chaîne de caractères `s` et un caractère `ch`. Ta tâche est d'implémenter une fonction `append_and_reverse` qui ajoute `ch` à la fin de `s`, inverse la chaîne résultante et renvoie la chaîne inversée. Tu ne dois pas utiliser de découpage ou de fonctions d'inversion intégrées pour c... | ["\nassert append_and_reverse(\"hello\", \"!\") == \"!olleh\"\n", "\nassert append_and_reverse(\"world\", \"a\") == \"adlorw\"\n", "\nassert append_and_reverse(\"python\", \"3\") == \"3nohtyp\"\n", "\nassert append_and_reverse(\"\", \"z\") == \"z\"\n", "\nassert append_and_reverse(\"a\", \"b\") == \"ba\"\n", "\nassert ... |
b0b9b0cdd60b6228cb97ad7927c762fc | [
{
"content": "On te donne un fichier nommé `input.txt` contenant une liste de chaînes alphanumériques, une par ligne. Chaque chaîne peut éventuellement commencer par un symbole dièse `#`. Ta tâche est d'écrire une fonction `find_duplicates` qui lit ce fichier et renvoie une liste de chaînes alphanumériques uniq... | ["\nassert find_duplicates('test1.txt') == ['abc']\n", "\nassert find_duplicates('test2.txt') == ['duplicate', 'case']\n", "\nassert find_duplicates('test3.txt') == []\n", "\nassert find_duplicates('test4.txt') == ['123', 'test']\n", "\nassert find_duplicates('test5.txt') == ['hello', 'world']\n", "\nassert find_duplic... |
6ccf7fe7f388b8e081e5805de36d76c3 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules en anglais séparées par des espaces. Ton objectif est d'écrire une fonction qui renvoie une liste de mots de la chaîne, triés par ordre alphabétique.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 1000), où |... | ["\nassert words_in_alphabetical_order(\"the quick brown fox jumps over the lazy dog\") == ['brown', 'dog', 'fox', 'jumps', 'lazy', 'over', 'quick', 'the', 'the']\n", "\nassert words_in_alphabetical_order(\"hello world\") == ['hello', 'world']\n", "\nassert words_in_alphabetical_order(\"a b c d e f g\") == ['a', 'b', '... |
4782a300c27bbdc7f1db7fe7211f10e3 | [
{
"content": "Tu développes une fonction pour une application de traitement d'image qui accepte une liste d'arguments en ligne de commande. L'application prend en charge les options suivantes : `--resize`, `--crop`, `--rotate`, `--flip`, `--grayscale`, `--blur`, `--sharpen`, `--no-save`. Ta tâche est de mettre ... | ["\nassert check_image_processing_options(['--resize', '--crop']) == ['--crop', '--resize']\n", "\nassert check_image_processing_options(['--ROTATE', '--FLIP']) == ['--rotate', '--flip']\n", "\nassert check_image_processing_options(['--grayscale', '--BLUR']) == ['--grayscale', '--blur']\n", "\nassert check_image_proces... |
47b8bd8887357febb57cd863847178c8 | [
{
"content": "On te donne une liste 2D `grid` de taille `n x m` où chaque cellule contient un entier. Ta tâche est de mettre en œuvre une fonction `find_neighbors(row, col, grid)` qui renvoie une liste de toutes les valeurs de cellules voisines valides (haut, bas, gauche, droite) de la cellule à la position `(r... | ["\nassert find_neighbors(0, 0, [[1, 2], [3, 4]]) == [2, 3]\n", "\nassert find_neighbors(1, 1, [[1, 2], [3, 4]]) == [1, 2, 3, 4]\n", "\nassert find_neighbors(0, 1, [[1, 2], [3, 4]]) == [1, 4]\n", "\nassert find_neighbors(1, 0, [[1, 2], [3, 4]]) == [1, 4, 2]\n", "\nassert find_neighbors(2, 2, [[1, 2, 3], [4, 5, 6], [7, ... |
b1e2d773d712c9e529faaf6b79ef9213 | [
{
"content": "On te donne deux listes triées d'entiers. Ta tâche est d'écrire une fonction qui fusionne ces deux listes en une seule liste triée, en veillant à ce que tous les éléments soient uniques.\n\n**Entrée :**\n- Deux listes triées d'entiers, `list1` et `list2`.\n\n**Sortie :**\n- Une nouvelle liste trié... | ["\nassert merge_and_deduplicate([1, 2, 3], [2, 3, 4]) == [1, 2, 3, 4]\n", "\nassert merge_and_deduplicate([], [1, 2, 3]) == [1, 2, 3]\n", "\nassert merge_and_deduplicate([1, 2, 3], []) == [1, 2, 3]\n", "\nassert merge_and_deduplicate([], []) == []\n", "\nassert merge_and_deduplicate([1, 1, 2, 2], [2, 2, 3, 3]) == [1, ... |
daa6df5b25483841a34f513ca4fadad5 | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de déterminer s'il existe un triplet (a, b, c) dans le tableau tel que a + b + c = 0. Si un tel triplet existe, renvoie `True`; sinon, renvoie `False`.\n\n**Exemple d'entrée :**\n```\n[-1, 0, 1, 2, -1, -4]\n```\n\n**Exemple de sortie :**\n```\nTrue\n`... | ["\nassert has_triplet_with_zero_sum([-1, 0, 1, 2, -1, -4]) == True\n", "\nassert has_triplet_with_zero_sum([1, 2, 3, 4, 5]) == False\n", "\nassert has_triplet_with_zero_sum([-2, 0, 1, 1, 2]) == True\n", "\nassert has_triplet_with_zero_sum([0, 0, 0]) == True\n", "\nassert has_triplet_with_zero_sum([1, -1, 2, -2, 3, -3]... |
ae52a4263e4a870917877c567efff87f | [
{
"content": "Tu développes un programme pour un jeu textuel où un agent secret choisit un déguisement parmi une liste de styles de police disponibles. Chaque style de police ne peut être utilisé qu'une seule fois par partie. Le programme doit sélectionner aléatoirement un style de police dans la liste et le re... | ["\nassert DisguiseSelector([\"Arial\", \"Times New Roman\"]).choose_disguise() in [\"Arial\", \"Times New Roman\"]\n", "\nassert DisguiseSelector([]).choose_disguise() == \"No disguises available.\"\n", "\nassert DisguiseSelector([\"Helvetica\"]).choose_disguise() == \"Selected disguise: Helvetica\"\n", "\nassert Disg... |
89dd0c3db4e9b6992cc2360deebc1940 | [
{
"content": "On te donne un dictionnaire représentant une liste de produits avec leurs prix. Ta tâche est de créer une fonction qui renvoie un nouveau dictionnaire contenant uniquement les produits dont les prix, arrondis à l'entier le plus proche, diffèrent de leurs prix d'origine. Les clés du dictionnaire so... | ["\nassert round_prices({\"apple\": 1.49, \"banana\": 0.59, \"orange\": 3.99, \"pear\": 2.34}) == {\"banana\": 1, \"orange\": 4, \"pear\": 2}\n", "\nassert round_prices({\"grape\": 2.5, \"melon\": 5.5, \"kiwi\": 3.0}) == {\"grape\": 2, \"melon\": 6}\n", "\nassert round_prices({\"cherry\": 1.0, \"plum\": 2.0, \"peach\":... |
b395bd52441199e8c9e814b1c41ee222 | [
{
"content": "On te donne une chaîne de caractères `sentence` composée de mots séparés par des espaces. Chaque mot est composé uniquement de lettres anglaises majuscules et minuscules. Ta tâche est de mettre en œuvre une fonction `find_longest_word` qui renvoie le mot le plus long de la chaîne. S'il y a plusieu... | ["\nassert find_longest_word(\"Once upon a time in a land far far away\") == \"Once\"\n", "\nassert find_longest_word(\"The quick brown fox jumps over the lazy dog\") == \"quick\"\n", "\nassert find_longest_word(\"a\") == \"a\"\n", "\nassert find_longest_word(\"equal length words here\") == \"equal\"\n", "\nassert find... |
9c8afa1c1fa40e601a5ac543a1ace0ff | [
{
"content": "On te donne un paragraphe de texte et une liste de mots interdits. Ta tâche est de trouver le mot palindrome le plus long dans le paragraphe qui ne figure pas dans la liste interdite. Le paragraphe peut contenir de la ponctuation et des lettres majuscules, qui doivent être ignorées pendant le trai... | ["\nassert longest_palindrome(\"Madam Arora teaches malayalam, but Adam is not here.\", [\"madam\", \"adam\"]) == \"malayalam\"\n", "\nassert longest_palindrome(\"A Santa at NASA\", []) == \"santa\"\n", "\nassert longest_palindrome(\"No lemon, no melon\", [\"melon\"]) == \"no\"\n", "\nassert longest_palindrome(\"Was it... |
8ffd003bbc2cbfe70d49bd04cadc8b39 | [
{
"content": "Dans la ville mystique de Bracketsville, les habitants rendent hommage à leurs ancêtres en plaçant des pierres d'honneur sur les escaliers. Chaque pierre d'honneur a un poids distinct, et le poids cumulé de ces pierres sur un escalier symbolise le respect montré aux ancêtres. On te fournit une lis... | ["\nassert total_weight_by_staircase([(10, \"stair1\"), (20, \"stair2\"), (30, \"stair1\")]) == {\"stair1\": 40, \"stair2\": 20}\n", "\nassert total_weight_by_staircase([(5, \"main\"), (15, \"main\"), (25, \"side\")]) == {\"main\": 20, \"side\": 25}\n", "\nassert total_weight_by_staircase([(100, \"grand\"), (200, \"gra... |
ad256ec0975dc9b8f09e41c87462389e | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction qui renvoie un dictionnaire où chaque clé est un mot unique (sans tenir compte de la casse) et la valeur est le nombre de fois où le mot apparaît dans toutes les chaînes de la liste. Les mots sont séparés p... | ["\nassert word_count([\"Hello world\", \"hello\"]) == {\"hello\": 2, \"world\": 1}\n", "\nassert word_count([\"Python is great\", \"python is fun\"]) == {\"python\": 2, \"is\": 2, \"great\": 1, \"fun\": 1}\n", "\nassert word_count([\"Repeat repeat repeat\"]) == {\"repeat\": 3}\n", "\nassert word_count([\"Case Insensit... |
0ba0bed4b8b982a544a76dc39b7c0ace | [
{
"content": "On te demande d'implémenter une fonction `flatten_input(x)` qui traite une entrée `x` de n'importe quel type et renvoie une liste aplatie selon les règles suivantes :\n- Si `x` est une chaîne de caractères, convertis-la en majuscules et renvoie-la sous forme de liste à un seul élément.\n- Si `x` e... | ["\nassert flatten_input(\"hello\") == ['HELLO']\n", "\nassert flatten_input(b\"hello\") == [b\"hello\"]\n", "\nassert flatten_input([1, \"world\", [3, \"test\", [5, \"nested\"]]]) == [1, 'WORLD', 3, 'TEST', 5, 'NESTED']\n", "\nassert flatten_input({\"a\": 1, \"b\": [\"c\", 2]}) == [1, 'C', 2]\n", "\nassert flatten_inp... |
9702df6a803551421bf8b746bd582f51 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'une phrase (chaîne de caractères) et de sa fréquence (entier) dans un texte. Ta tâche est de calculer un poids pour chaque tuple. Le poids est déterminé en multipliant le nombre de mots non-stopp dans la phrase par sa fréquence. Les mo... | ["\nassert calculate_weights([(\"hello world\", 1)]) == [(2, 1, 2)]\n", "\nassert calculate_weights([(\"the quick brown fox jumps over the lazy dog\", 1)]) == [(8, 1, 8)]\n", "\nassert calculate_weights([(\"a an the\", 1)]) == [(0, 1, 0)]\n", "\nassert calculate_weights([(\"python programming\", 2)]) == [(2, 2, 4)]\n",... |
db488ef4acc08d161a5a96637d927551 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si elle est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\n", "\nassert is_palindrome(\" \") == True\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(... |
97486157c2381999e08da47e4f778d7e | [
{
"content": "On te donne deux listes triées d'entiers, `la` et `lb`. Implémente une fonction `merge_and_filter(la, lb, key=lambda x: x)` qui fusionne ces deux listes en une seule liste triée, `merged`. Le paramètre `key` est une fonction qui prend un entier et renvoie une valeur qui doit être utilisée pour la ... | ["\nassert merge_and_filter([1, 2, 3], [2, 3, 4]) == [1, 2, 3, 4]\n", "\nassert merge_and_filter([1, 3, 5], [2, 4, 6]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_and_filter([], [1, 2, 3]) == [1, 2, 3]\n", "\nassert merge_and_filter([1, 2, 3], []) == [1, 2, 3]\n", "\nassert merge_and_filter([], []) == []\n", "\nassert me... |
a548a112d265aba530fd8213c2b872bf | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction récursive qui renvoie l'entier maximal de la liste. La fonction doit gérer toute liste non vide d'entiers.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 1000, -1000 ≤ numbers[i] ≤ 1000).\n\n**Sortie :**... | ["\nassert find_max_recursive([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 9\n", "\nassert find_max_recursive([1, 2, 3, 4, 5]) == 5\n", "\nassert find_max_recursive([5, 4, 3, 2, 1]) == 5\n", "\nassert find_max_recursive([10]) == 10\n", "\nassert find_max_recursive([-1, -2, -3, -4, -5]) == -1\n", "\nassert find_max_recursive([... |
9cf96ba928ad9c0a7e7baf37356b0e66 | [
{
"content": "On te demande d'implémenter une fonction `extract_salary(html_content)` qui analyse manuellement une chaîne de contenu HTML donnée pour extraire les informations de salaire d'un tableau. Le contenu HTML contient un tableau avec des offres d'emploi, et chaque offre d'emploi inclut un salaire dans u... | ["\nassert extract_salary('<td class=\"salary\">$50,000</td>') == ['$50,000']\n", "\nassert extract_salary('<td class=\"salary\">$50,000</td><td class=\"salary\">$60,000</td>') == ['$50,000', '$60,000']\n", "\nassert extract_salary('<td class=\"salary\">$50,000</td><td class=\"salary\">$60,000</td><td class=\"salary\">... |
1873aaa3c1f99f015209afc3dab677de | [
{
"content": "On te donne une liste d'entiers. Implémente une fonction `merge_sort` qui trie la liste par ordre croissant en utilisant l'algorithme de tri fusion. La fonction doit renvoyer une nouvelle liste triée sans modifier la liste originale. Ta fonction doit gérer les cas limites tels que les listes vides... | ["\nassert merge_sort([38, 27, 43, 3, 9, 82, 10]) == [3, 9, 10, 27, 38, 43, 82]\n", "\nassert merge_sort([5, 2, 9, 1, 5, 6]) == [1, 2, 5, 5, 6, 9]\n", "\nassert merge_sort([1]) == [1]\n", "\nassert merge_sort([]) == []\n", "\nassert merge_sort([7, 7, 7, 7]) == [7, 7, 7, 7]\n", "\nassert merge_sort([-1, -3, -2, -4]) == ... |
cbdbe65ebbaa34287cbcb81029aa9028 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver les indices des deux éléments distincts dans `nums` qui s'additionnent pour donner `target`. Il est garanti qu'il existe exactement une solution pour chaque cas de test, et tu ne peux pas utiliser le même élémen... | ["\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([10, 20, 30, 40, 50], 90) == [1, 3]\n", "\nassert two_sum([1, 5, 7, -1], 6) == [0, 3]\n", "\nassert two_sum([... |
0a03ab114060a5ed626fa1188c972950 | [
{
"content": "On te donne deux matrices, `matrix_a` et `matrix_b`, représentées comme des listes de listes. Ta tâche est d'implémenter une fonction qui calcule le produit de ces deux matrices. La fonction doit renvoyer la matrice résultante. Si les matrices ne peuvent pas être multipliées en raison de dimension... | ["\nassert matrix_multiply([[1, 2], [3, 4]], [[2, 0], [1, 2]]) == [[4, 4], [10, 8]]\n", "\nassert matrix_multiply([[1, 0, 0], [0, 1, 0], [0, 0, 1]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", "\nassert matrix_multiply([[2, 3], [4, 5]], [[1, 0], [0, 1]]) == [[2, 3], [4, 5]]\n", "\nassert... |
73cff65bbd30c85656efdcb7246cf131 | [
{
"content": "Implémente une fonction génératrice Python nommée `generate_fibonacci` qui génère une séquence infinie de nombres de Fibonacci. La séquence doit commencer par 0 et 1, et chaque nombre suivant doit être la somme des deux nombres précédents. Ta fonction doit être capable de générer des nombres de Fi... | ["\nassert next(generate_fibonacci()) == 0\n", "\ngen = generate_fibonacci()\nnext(gen)\nassert next(gen) == 1\n", "\ngen = generate_fibonacci()\nnext(gen)\nnext(gen)\nassert next(gen) == 1\n", "\ngen = generate_fibonacci()\nnext(gen)\nnext(gen)\nnext(gen)\nassert next(gen) == 2\n", "\ngen = generate_fibonacci()\nnext(... |
6ea0dff10b7e14104f1a484155441988 | [
{
"content": "On te demande d'implémenter une classe `Polynomial` en Python qui prenne en charge les opérations polynomiales de base. La classe doit être capable d'additionner, de soustraire et de multiplier des polynômes, d'évaluer un polynôme en un point donné et d'afficher le polynôme dans un format lisible ... | ["\nassert str(Polynomial([2, -6, 2, -1])) == \"2 - 6*x + 2*x^2 - x^3\"\n", "\nassert str(Polynomial([0, 0, 0])) == \"0\"\n", "\nassert str(Polynomial([1, 0, 0, 0])) == \"1\"\n", "\nassert str(Polynomial([0, 1, 0, 0])) == \"x\"\n", "\nassert str(Polynomial([0, 0, 1, 0])) == \"x^2\"\n", "\nassert Polynomial([2, -6, 2, -... |
527d9c936c974370a55a35d88c7edad5 | [
{
"content": "On te donne un dictionnaire `nodes` représentant une structure arborescente d'une hiérarchie familiale. Chaque clé du dictionnaire est le nom d'une personne, et la valeur correspondante est un autre dictionnaire contenant une liste des noms de ses parents (une personne peut avoir plusieurs parents... | ["\nassert get_generation(nodes, \"Alice\") == 0\n", "\nassert get_generation(nodes, \"Bob\") == 0\n", "\nassert get_generation(nodes, \"Charlie\") == 1\n", "\nassert get_generation(nodes, \"David\") == 1\n", "\nassert get_generation(nodes, \"Eve\") == 1\n", "\nassert get_generation(nodes, \"Frank\") == 2\n", "\nassert... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.