id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
46689467f4261a9ea13a8c112a5700da | [
{
"content": "On te donne deux listes : `numbers` contenant `n` entiers et `words` contenant `n` chaînes de caractères. Ta tâche est de mettre en œuvre une fonction `mix_and_match` qui associe aléatoirement chaque entier de `numbers` à une chaîne de caractères unique de `words`. La fonction doit renvoyer une li... | ["\nassert len(mix_and_match([1, 2, 3], ['I', 'II', 'III'])) == 3\n", "\nassert all(isinstance(pair, tuple) for pair in mix_and_match([1, 2, 3], ['I', 'II', 'III']))\n", "\nassert all(isinstance(num, int) for num, _ in mix_and_match([1, 2, 3], ['I', 'II', 'III']))\n", "\nassert all(isinstance(word, str) for _, word in ... |
0338a14baf12a7eae7de487ff644583c | [
{
"content": "On te donne une date de naissance et une date de référence au format \"AAAA-MM-JJ\", ainsi que les fuseaux horaires du lieu de naissance et du lieu de référence. Ta tâche est d'écrire une fonction `calculateAge` qui calcule l'âge d'une personne née à la date de naissance à la date de référence, en... | ["\nassert calculateAge(\"1990-05-15\", \"2023-01-01\", \"America/New_York\", \"Europe/London\") == 32\n", "\nassert calculateAge(\"2000-02-29\", \"2024-02-29\", \"Europe/London\", \"Europe/London\") == 24\n", "\nassert calculateAge(\"2000-02-29\", \"2024-03-01\", \"Europe/London\", \"Europe/London\") == 24\n", "\nasse... |
c84db61009dbeb71e1c79271d53152ca | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de mettre en œuvre une fonction `twoSumWithIndices` qui renvoie les indices des deux nombres dans `nums` tels qu'ils s'additionnent pour donner `target`. S'il existe plusieurs paires qui satisfont à la condition, renvoie l... | ["\nassert twoSumWithIndices([2, 7, 11, 15], 9) == [0, 1]\n", "\nassert twoSumWithIndices([3, 2, 4], 6) == [1, 2]\n", "\nassert twoSumWithIndices([3, 3], 6) == [0, 1]\n", "\nassert twoSumWithIndices([1, 2, 3, 4, 5], 10) == [3, 4]\n", "\nassert twoSumWithIndices([1, 2, 3, 4, 5], 8) == [2, 4]\n", "\nassert twoSumWithIndi... |
ee5ed0e0f8b1a57f88e7002354565848 | [
{
"content": "On te donne deux points sur une grille 2D, représentés comme des tuples `(x, y)`. Ta tâche est de déterminer la direction dans laquelle une pièce doit se déplacer du point de départ au point d'arrivée en utilisant un chemin en forme de L, similaire au mouvement d'un cavalier aux échecs (c'est-à-di... | ["\nassert knight_move((0, 0), (3, 3)) in [(2, 1), (1, 2)]\n", "\nassert knight_move((0, 0), (2, 2)) is None\n", "\nassert knight_move((0, 0), (4, 5)) in [(2, 1), (1, 2)]\n", "\nassert knight_move((1, 1), (3, 2)) in [(2, 1), (1, 2)]\n", "\nassert knight_move((5, 5), (3, 4)) in [(-2, -1), (-1, -2)]\n", "\nassert knight_... |
df75f5bbe8e3e6d746d8f31c19ad9101 | [
{
"content": "On te demande d'implémenter une fonction `time_breakdown` qui prend un entier `seconds` représentant une durée. La fonction doit renvoyer un dictionnaire décomposant la durée en années, jours, heures, minutes, secondes et microsecondes. La décomposition doit tenir compte des années bissextiles ave... | ["\nassert time_breakdown(0) == {'years': 0, 'days': 0, 'hours': 0, 'minutes': 0, 'seconds': 0, 'microseconds': 0}\n", "\nassert time_breakdown(1) == {'years': 0, 'days': 0, 'hours': 0, 'minutes': 0, 'seconds': 1, 'microseconds': 0}\n", "\nassert time_breakdown(60) == {'years': 0, 'days': 0, 'hours': 0, 'minutes': 1, '... |
2b8d533e8ba506d736073359fcfb63a5 | [
{
"content": "On te demande d'analyser un fichier journal qui contient deux types d'énoncés : réguliers et irréguliers. Chaque énoncé se trouve sur une nouvelle ligne.\n\n**Les énoncés réguliers** suivent ce format :\n- Commencent par une date au format `JJ/MM/AA`.\n- Suivis d'une heure au format `HH:MM AM/PM`.... | ["\nassert parse_log_file(\"12/05/21 03:30 PM - John Doe: This is a statement\") == [[\"12/05/21\", \"03:30\", \"PM\", \"John Doe\", \"This is a statement\", 1]]\n", "\nassert parse_log_file(\"12/05/21 03:30 PM - John Doe: This is a statement\\nIrregular statement\") == [[\"12/05/21\", \"03:30\", \"PM\", \"John Doe\", ... |
6de27309a70c5e59bbd284506c700bf1 | [
{
"content": "On te donne un graphe représenté par un ensemble de nœuds et d'arêtes. Chaque nœud est positionné dans un plan 2D, et chaque arête connecte deux nœuds. Ta tâche est de générer une liste de flèches représentant ces arêtes. Chaque flèche doit partir de la position du premier nœud et se terminer à un... | ["\nassert arrows_from_edges({0: (0, 0), 1: (1, 0)}, {(0, 1): 10}) == [(0, 0, 0.9, 0, 10)]\n", "\nassert arrows_from_edges({0: (0, 0), 1: (0, 1)}, {(0, 1): 10}) == [(0, 0, 0, 0.75, 10)]\n", "\nassert arrows_from_edges({0: (0, 0), 1: (1, 1)}, {(0, 1): 10}) == [(0, 0, 0.8535533905932738, 0.8535533905932738, 10)]\n", "\na... |
1496681350b2e498794264bb91b5213c | [
{
"content": "On te demande d'implémenter une fonction qui traite une chaîne de caractères donnée en supprimant toutes les balises HTML, y compris tout le contenu à l'intérieur de ces balises. La fonction doit gérer les balises HTML imbriquées et préserver tout le contenu qui n'est pas HTML. Ta solution doit êt... | ["\nassert remove_html_tags(\"<p>Hello <b>World</b></p>\") == \"Hello World\"\n", "\nassert remove_html_tags(\"<div><span>Test</span></div>\") == \"Test\"\n", "\nassert remove_html_tags(\"<a href='#'>Link</a>\") == \"Link\"\n", "\nassert remove_html_tags(\"No tags here!\") == \"No tags here!\"\n", "\nassert remove_html... |
cf5accb001384ecb82818dbbfb1c5490 | [
{
"content": "On te donne une chaîne de caractères `url` représentant une URL. Ta tâche est d'implémenter une fonction `parse_url(url)` qui extrait les composants de protocole, de domaine et de chemin de l'URL. La fonction doit renvoyer ces composants sous la forme d'un tuple `(protocole, domaine, chemin)`. Le ... | ["\nassert parse_url(\"https://www.example.com/path/to/resource?query=1\") == ('https', 'www.example.com', '/path/to/resource')\n", "\nassert parse_url(\"http://example.com\") == ('http', 'example.com', '')\n", "\nassert parse_url(\"ftp://files.example.com/downloads/file.zip\") == ('ftp', 'files.example.com', '/downloa... |
510e9f839a9e8aa6686d365bb732ff44 | [
{
"content": "On te donne un objet JSON `data` représentant un arbre généalogique, où chaque clé est le nom d'une personne et chaque valeur est le nom de son parent. Ta tâche est d'écrire une fonction `find_furthest_descendants(data: dict) -> List[str]` qui identifie et renvoie une liste de noms représentant le... | ["\nassert find_furthest_descendants({\"Alice\": \"Bob\", \"Bob\": \"Charlie\", \"Charlie\": \"David\"}) == [\"Alice\", \"David\"]\n", "\nassert find_furthest_descendants({\"Eve\": \"Charlie\", \"Frodo\": \"Eve\", \"Sam\": \"Eve\", \"Pippin\": \"Frodo\", \"Merry\": \"Frodo\"}) == [\"Frodo\", \"Sam\", \"Pippin\", \"Merr... |
dfa1f46ced4062a29b39311ec9652530 | [
{
"content": "On te donne un tableau d'octets qui représente un entier encodé en big-endian. Chaque octet du tableau est chiffré en utilisant un simple chiffrement XOR avec une clé qui est le résultat d'un ET bit à bit de la position de l'octet dans le tableau (indexé à partir de 0) et d'une valeur de clé fixe ... | ["\nassert decode_big_endian(bytearray([0b10101010]), False) == 0\n", "\nassert decode_big_endian(bytearray([0b11111111]), True) == -1\n", "\nassert decode_big_endian(bytearray([0b00000001]), False) == 1\n", "\nassert decode_big_endian(bytearray([0b10000000]), True) == -128\n", "\nassert decode_big_endian(bytearray([0b... |
3038520d29236a08e32349cd39d4a09a | [
{
"content": "On te demande d'implémenter une fonction `extract_identifier` qui traite une chaîne de caractères représentant un identifiant de produit dans un entrepôt. L'identifiant est structuré comme suit : il commence par le préfixe \"ID-\", suivi d'une séquence de chiffres séparés par des tirets, et se ter... | ["\nassert extract_identifier(\"ID-123-456-789-A\") == 123456789\n", "\nassert extract_identifier(\"ID-123-A\") == 123\n", "\nassert extract_identifier(\"ID-A\") == -1\n", "\nassert extract_identifier(\"ID-123-456-A\") == 123456\n", "\nassert extract_identifier(\"ID-1-A\") == 1\n", "\nassert extract_identifier(\"ID--A\... |
5a4109ee1317236e77024a50764593b1 | [
{
"content": "On te donne une liste d'entiers positifs. Ta tâche est de mettre en œuvre une fonction `longest_gap` qui détermine la longueur du plus grand écart entre deux éléments consécutifs de la liste. Un écart est défini comme le nombre de nombres premiers entre deux éléments consécutifs, en incluant les p... | ["\nassert longest_gap([1, 4, 10]) == 3\n", "\nassert longest_gap([2, 3, 5, 7]) == 1\n", "\nassert longest_gap([10, 20]) == 4\n", "\nassert longest_gap([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 1\n", "\nassert longest_gap([14, 22]) == 3\n", "\nassert longest_gap([29, 31]) == 1\n", "\nassert longest_gap([1, 100]) == 25\n", "\... |
83a52d5b710fb054e74b8afee96a4b16 | [
{
"content": "On te demande d'implémenter une fonction `error_handler` qui agit comme un décorateur pour toute fonction donnée `func`. Cette fonction doit enregistrer des informations détaillées sur chaque appel à `func`, notamment l'horodatage, le nom de la fonction, les arguments et le résultat ou toute excep... | ["\nassert error_handler(lambda x: x + 1, [5]) == \"No errors occurred.\"\n", "\nassert error_handler(lambda x: x / 0, [10]) == \"Caught an exception: division by zero\"\n", "\nassert error_handler(lambda x, y: x + y, [3, 4]) == \"No errors occurred.\"\n", "\nassert error_handler(lambda x: x[0], [[1, 2, 3]]) == \"No er... |
43af88657e76ba70e0f2121adc828422 | [
{
"content": "On te donne une liste de mots-clés et un paragraphe de texte. Ta tâche est d'écrire une fonction `find_first_keyword` qui prend ces éléments en entrée et renvoie le premier mot-clé qui apparaît dans le texte. La fonction doit être insensible à la casse et renvoyer le mot-clé tel qu'il apparaît dan... | ["\nassert find_first_keyword([\"apple\", \"Banana\", \"cherry\"], \"In a nearby orchard, there were plenty of Bananas and Apples.\") == \"Banana\"\n", "\nassert find_first_keyword([\"apple\", \"Banana\", \"cherry\"], \"apples are sweet.\") == \"apple\"\n", "\nassert find_first_keyword([\"apple\", \"Banana\", \"cherry\... |
e330109bbbb69be3de665a6d5998a863 | [
{
"content": "On te donne un dictionnaire `gene2transcripts` où chaque clé est un nom de gène et la valeur correspondante est un ensemble de transcrits associés à ce gène. De plus, on te fournit un dictionnaire `gene_mutation_rates` où chaque clé est un nom de gène et la valeur correspondante est le taux de mut... | ["\nassert weighted_subpath_conservation([SubpathData(['gene1'], {'transcript1'})], {'gene1': {'transcript1'}}, {'gene1': 1}) == [1]\n", "\nassert weighted_subpath_conservation([SubpathData(['gene1'], {'transcript2'})], {'gene1': {'transcript1'}}, {'gene1': 1}) == [0]\n", "\nassert weighted_subpath_conservation([Subpat... |
02dd85c592e80237c4da0fd65146343e | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste originale, dans l'ordre de leur première apparition.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 10^5), où chaque entier est dan... | ["\nassert unique_elements([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert unique_elements([1, 1, 1, 1, 1]) == [1]\n", "\nassert unique_elements([5, 4, 3, 2, 1]) == [5, 4, 3, 2, 1]\n", "\nassert unique_elements([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert unique_elements([]) == []\n", "\nassert unique_elem... |
b56c8e55945e10cef85a1bef996d69a4 | [
{
"content": "On te donne une liste triée d'objets `Person`, où chaque `Person` a un attribut `age` unique. Implémente la fonction `find_closest_age(person_list, target_age)` qui renvoie l'index de l'objet `Person` dont l'âge est le plus proche de `target_age`. Si plusieurs objets `Person` ont le même âge le pl... | ["\nassert find_closest_age([Person(10), Person(20), Person(30)], 25) == 1\n", "\nassert find_closest_age([Person(5), Person(15), Person(25), Person(35)], 20) == 2\n", "\nassert find_closest_age([Person(1), Person(3), Person(5), Person(7)], 6) == 2\n", "\nassert find_closest_age([Person(10), Person(20), Person(30), Per... |
819a7e59a281bf27f7ab762361fa3623 | [
{
"content": "On te demande d'implémenter une fonction `calculate_discount` pour une application de shopping. La fonction doit calculer le prix final d'un article après avoir appliqué une remise donnée. La fonction accepte deux paramètres : `original_price`, un nombre à virgule flottante positif représentant le... | ["\nassert calculate_discount(100, 0.2) == 80.0\n", "\nassert calculate_discount(200, 0.5) == 100.0\n", "\nassert calculate_discount(50, 0.0) == 50.0\n", "\nassert calculate_discount(150, 1.0) == 0.0\n", "\nassert calculate_discount(300, 0.75) == 75.0\n", "\nassert calculate_discount(1000, 0.05) == 950.0\n", "\nassert ... |
121fb5f77d0ee89be77ccdf2dc8008a7 | [
{
"content": "On te donne un ensemble de données contenant les enregistrements de ventes d'un magasin de détail sur le dernier trimestre. Chaque enregistrement comprend les champs suivants :\n- `product_id` (chaîne de caractères) : un identifiant unique pour le produit.\n- `quantity_sold` (entier) : le nombre d... | ["\nassert calculate_total_revenue(sales_data) == {'A123': 379.88, 'B456': 182.25, 'C789': 139.93}\n", "\nassert calculate_total_revenue([]) == {}\n", "\nassert calculate_total_revenue([{'product_id': 'X999', 'quantity_sold': 1, 'unit_price': 99.99, 'date_sold': datetime(2023, 10, 1)}]) == {'X999': 99.99}\n", "\nassert... |
e2205d28b02a43c91d541bb51787938f | [
{
"content": "Tu dois implémenter une table de hachage dynamique qui redimensionne automatiquement sa taille lorsque le facteur de charge dépasse 0,75. Le facteur de charge est défini comme le rapport entre le nombre d'entrées et le nombre de buckets. Lors du redimensionnement, le nombre de buckets doit doubler... | ["\nassert hash_table.get('name') == None\n", "\nassert hash_table.get('age') == 30\n", "\nassert hash_table.remove('age') == 30\n", "\nassert hash_table.get('age') == None\n", "\nassert hash_table.insert('city', 'Wonderland') == None\n", "\nassert hash_table.get('city') == 'Wonderland'\n", "\nassert hash_table.insert(... |
6298227f7d2a492573d0623699a1d2da | [
{
"content": "Étant donné une chaîne de caractères `s`, ta tâche est de trouver toutes les sous-chaînes palindromiques uniques dans `s`. Une sous-chaîne est définie comme une séquence contiguë de caractères dans la chaîne, et une chaîne est considérée comme un palindrome si elle se lit de la même manière de gau... | ["\nassert unique_palindromic_substrings(\"ababa\") == ['aba', 'bab', 'ababa', 'a', 'b']\n", "\nassert unique_palindromic_substrings(\"racecar\") == ['cec', 'aceca', 'cec', 'cec', 'racecar', 'ecec', 'cec', 'c', 'e', 'r']\n", "\nassert unique_palindromic_substrings(\"a\") == ['a']\n", "\nassert unique_palindromic_substr... |
2317777c39195abb164fc4454b69ef89 | [
{
"content": "Dans un jeu de rôle, les entités possèdent des attributs, notamment une armure, qui a une valeur actuelle et une valeur maximale. L'armure offre une protection pendant les combats. Tu es chargé d'implémenter une fonction `repairArmor` qui répare l'armure d'une entité vivante.\n\nUne entité vivante... | ["\nassert repairArmor({\"Type\": \"livingEnt\", \"Armor\": 50, \"ArmorMax\": 100, \"UniqueDamageTypes\": [\"fire\", \"ice\"]}, 30) == {\"Type\": \"livingEnt\", \"Armor\": 78, \"ArmorMax\": 100, \"UniqueDamageTypes\": [\"fire\", \"ice\"]}\n", "\nassert repairArmor({\"Type\": \"livingEnt\", \"Armor\": 50, \"ArmorMax\": ... |
f614a2c50f2b30402984f6b172314030 | [
{
"content": "Tu es chargé d'implémenter une classe `Book` qui modélise un livre avec les attributs suivants : titre, auteur, année de publication et genre. La classe doit prendre en charge les opérations suivantes :\n\n1. **Initialisation** : Un constructeur qui initialise les attributs du livre.\n2. **Représe... | ["\nassert str(Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\")) == \"1984 by George Orwell, published in 1949 (Dystopian)\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\").is_classic() == True\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960, \"Fiction\").is_classic() == Fa... |
ad27c0aded065e164b1e6fa4869fb21c | [
{
"content": "On te donne une fonction `mod3plus7` qui accepte trois entiers en entrée. Pour chaque entier, si c'est un nombre premier, retourne l'entier lui-même. Sinon, calcule le reste lorsque l'entier est divisé par 3, ajoute 7 au résultat, et retourne cette valeur. Ta tâche est d'implémenter cette fonction... | ["\nassert mod3plus7(2, 3, 5) == (9, 3, 5)\n", "\nassert mod3plus7(4, 6, 8) == (8, 7, 9)\n", "\nassert mod3plus7(9, 10, 11) == (7, 8, 11)\n", "\nassert mod3plus7(12, 13, 14) == (7, 13, 8)\n", "\nassert mod3plus7(15, 16, 17) == (7, 8, 17)\n", "\nassert mod3plus7(18, 19, 20) == (7, 19, 8)\n", "\nassert mod3plus7(21, 22, ... |
f0b11f5773f637f13fb92385abd2a654 | [
{
"content": "On te donne un message de réseau social, l'ID d'un utilisateur ainsi que ses hashtags favoris. Ta tâche est de déterminer si le message est pertinent pour l'utilisateur en fonction des critères suivants :\n\n1. Le message est un message direct à l'utilisateur.\n2. Le message est publié dans un gro... | ["\nassert is_post_relevant({'type': 'direct_message', 'channel': 'DM', 'text': 'Hello', 'mentions': []}, 'user123', []) == True\n", "\nassert is_post_relevant({'type': 'direct_message', 'channel': 'DM', 'text': 'Hello', 'mentions': []}, 'user456', []) == False\n", "\nassert is_post_relevant({'type': 'public_post', 'ch... |
a42fd26bdac2ce83cefb13afc908e2d7 | [
{
"content": "On te donne une liste de fréquences en Hertz (Hz) et ton objectif est de convertir chaque fréquence à l'échelle de Mel en utilisant la formule : \n\\[ \\text{Mel}(f) = 2595 \\times \\log_{10}(1 + \\frac{f}{700}) \\] \nTa fonction doit gérer efficacement de grands ensembles de données et renvoyer... | ["\nassert np.allclose(freq_to_mel([100]), [2595 * np.log10(1 + 100 / 700)])\n", "\nassert np.allclose(freq_to_mel([500]), [2595 * np.log10(1 + 500 / 700)])\n", "\nassert np.allclose(freq_to_mel([1000]), [2595 * np.log10(1 + 1000 / 700)])\n", "\nassert np.allclose(freq_to_mel([5000]), [2595 * np.log10(1 + 5000 / 700)])... |
737aad8a247ada781c46e51cecba0fcb | [
{
"content": "On te demande d'implémenter un système simple de gestion d'inventaire. Ton programme doit définir une classe `Inventory` avec les méthodes suivantes :\n\n- `add_item(name, quantity)` : Ajoute `quantity` de l'article `name` à l'inventaire. Si l'article existe déjà, sa quantité doit être augmentée d... | ["\nassert Inventory().list_items() == {}\n", "\nassert Inventory().add_item('apples', 10) is None\n", "\nassert Inventory().remove_item('apples', 5) is None\n", "\ninventory = Inventory(); inventory.add_item('apples', 10); assert inventory.list_items() == {'apples': 10}\n", "\ninventory = Inventory(); inventory.add_it... |
f63e23c4ce7683e72f60b6e01cd08110 | [
{
"content": "On te demande d'implémenter une fonction `calculate_discounted_price` qui calcule le prix final d'un article après application d'une réduction. La fonction doit accepter deux paramètres : `original_price` et `discount_percentage`. `original_price` représente le coût initial de l'article, et `disco... | ["\nassert calculate_discounted_price(100, 20) == 80\n", "\nassert calculate_discounted_price(200, 50) == 100\n", "\nassert calculate_discounted_price(0, 10) == 0\n", "\nassert calculate_discounted_price(150, 0) == 150\n", "\nassert calculate_discounted_price(100, 100) == 0\n", "\nassert calculate_discounted_price(-100... |
577c4b053566bbf22759387b952a673a | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction qui détermine le(s) mode(s) de la liste, c'est-à-dire le ou les nombre(s) qui apparaissent le plus fréquemment. Si plusieurs nombres ont la même fréquence la plus élevée, renvoie-les tous dans une liste. Si la liste d'entrée ... | ["\nassert find_mode([4, 1, 2, 2, 3, 4]) == [2, 4]\n", "\nassert find_mode([1, 1, 2, 3, 4]) == 1\n", "\nassert find_mode([]) == None\n", "\nassert find_mode([7, 7, 7, 7]) == 7\n", "\nassert find_mode([1, 2, 3, 4, 5, 5, 6, 6]) == [5, 6]\n", "\nassert find_mode([10, 20, 20, 10, 30, 30]) == [10, 20, 30]\n", "\nassert find... |
c839a3087b4ba498dea408f676f5868e | [
{
"content": "On te donne une liste de chaînes de caractères non vides `words`. Ta tâche est de déterminer le plus long préfixe commun partagé par toutes les chaînes de caractères de la liste. Si aucun préfixe commun n'existe, renvoie une chaîne vide.\n\n**Entrée :**\n- Une liste de chaînes de caractères `words... | ["\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\"]... |
d022b76e017ea3e9d233ad90a053b1dd | [
{
"content": "On te donne une liste d'entiers. Ton objectif est de déterminer si la liste contient des éléments dupliqués. Écris une fonction `contains_duplicates` qui prend une liste d'entiers en entrée et renvoie `True` s'il y a des doublons, sinon `False`.\n\n**Exemple d'entrée :**\n```\n[1, 2, 3, 4, 5, 6, 7... | ["\nassert contains_duplicates([1, 2, 3, 4, 5]) == False\n", "\nassert contains_duplicates([1, 1, 2, 3, 4]) == True\n", "\nassert contains_duplicates([]) == False\n", "\nassert contains_duplicates([10]) == False\n", "\nassert contains_duplicates([1, 2, 2, 3, 4, 4, 5]) == True\n", "\nassert contains_duplicates([1, 2, 3,... |
fbe73d5dc05d4bdaf451e794d71a768c | [
{
"content": "On te donne une structure imbriquée complexe `nested_dict` composée de dictionnaires, de listes et d'ensembles à différents niveaux de profondeur. Ta tâche est de mettre en œuvre une fonction `find_keys` qui prend `nested_dict` et une `target_key` en entrée et renvoie une liste de toutes les valeu... | ["\nassert find_keys({'a': 1, 'b': {'c': 2, 'd': {'a': 3}}}, 'a') == [1, 3]\n", "\nassert find_keys({'a': 1, 'b': {'c': 2, 'd': {'a': 3}}, 'e': {'f': {'a': 4}}}, 'a') == [1, 3, 4]\n", "\nassert find_keys({'a': 1, 'b': {'c': 2, 'd': {'a': 3}}, 'e': {'f': {'a': 4}}, 'g': [{1, 2, 3}, {'a': 5}]}, 'a') == [1, 3, 4, 5]\n", "... |
8e1d37526fe47aeb8895cd3fdf538aac | [
{
"content": "On te donne un fichier CSV avec des en-têtes. Ta tâche est d'écrire une fonction Python qui traite ce fichier et génère un rapport récapitulatif. Le rapport doit inclure :\n- Le nombre total de lignes dans le CSV.\n- La valeur moyenne d'une colonne numérique spécifiée.\n- La valeur maximale de cet... | ["\nassert process_csv('test.csv', 'age') == None\n", "\nassert process_csv('test.csv', 'salary') == None\n", "\nassert process_csv('empty.csv', 'age') == None\n", "\nassert process_csv('single_row.csv', 'age') == None\n", "\nassert process_csv('multiple_rows.csv', 'age') == None\n", "\nassert process_csv('non_numeric_... |
4a49b41e85321f273260d08440572dc6 | [
{
"content": "On te donne une séquence d'ADN composée de nucléotides A, G, C, T, et éventuellement de nucléotides ambigus R, Y, S, W, K, M, B, D, H, V, N. Ta tâche est d'écrire une fonction `calculate_at_content` qui calcule le pourcentage de contenu AT dans la séquence. Les nucléotides ambigus ne contribuent p... | ["\nassert calculate_at_content(\"AGCTAT\") == 50.00\n", "\nassert calculate_at_content(\"AGCT\") == 50.00\n", "\nassert calculate_at_content(\"GGCC\") == 0.00\n", "\nassert calculate_at_content(\"ATATAT\") == 100.00\n", "\nassert calculate_at_content(\"RYSWKMBDHVNN\") == 0.00\n", "\nassert calculate_at_content(\"ATRYS... |
d6485478135ed9069814b40f1cdf8526 | [
{
"content": "On te donne une chaîne de caractères `s` contenant à la fois des caractères anglais et chinois. Ta tâche est d'écrire une fonction `clean_text` qui traite cette chaîne en remplaçant tous les signes de ponctuation qui ne sont pas présents dans la suite de Fibonacci par des tirets bas (\"_\"). La su... | ["\nassert clean_text(\"Hello, \u4e16\u754c\uff01\") == \"Hello_ ______\"\n", "\nassert clean_text(\"a.b,c:d;e'f(g)h\") == \"a_b_c_d_e_f_g_h\"\n", "\nassert clean_text(\"123!@#\") == \"123___\"\n", "\nassert clean_text(\"Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21\") == \"Fibonacci_ 0_ 1_ 1_ 2_ 3_ 5_ 8_ 13_ 21\"\n", "\nasse... |
b5a8c4b09ba9185ba9a7e4767a9921e3 | [
{
"content": "On te demande d'implémenter une structure de données de file d'attente sécurisée pour les threads en Python. Ton implémentation doit inclure une classe `Queue` avec les méthodes suivantes :\n- `enqueue(item)` : Ajoute un élément à la fin de la file d'attente.\n- `dequeue()` : Supprime et renvoie l... | ["\nassert Queue().is_empty() == True\n", "\nassert Queue().dequeue() == None\n", "\nq = Queue(); q.enqueue(5); assert q.dequeue() == 5\n", "\nq = Queue(); q.enqueue(1); q.enqueue(2); assert q.dequeue() == 1\n", "\nq = Queue(); q.enqueue(1); q.enqueue(2); q.dequeue(); assert q.is_empty() == False\n", "\nq = Queue(); q.... |
8fb89d2648b66841a6175fb44d0fd2d6 | [
{
"content": "On te donne un tableau numpy 1D `data` de longueur `2N` qui représente des composantes réelles et imaginaires alternées de `N` nombres complexes stockés selon un motif en zigzag. Chaque paire seconde de composantes réelles et imaginaires est inversée. Ta tâche est d'écrire une fonction `reconstruc... | ["\nassert np.array_equal(reconstruct_complex_numbers(np.array([1, 2, 4, 3, 5, 6])), np.array([1+2j, 3+4j, 5+6j]))\n", "\nassert np.array_equal(reconstruct_complex_numbers(np.array([0, 0, 0, 0, 0, 0])), np.array([0+0j, 0+0j, 0+0j]))\n", "\nassert np.array_equal(reconstruct_complex_numbers(np.array([1, -1, 2, -2, 3, -3]... |
e70bfb643d8c8605e94e9ca77d939b35 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `my_sort` qui trie la liste par ordre croissant en utilisant un algorithme de tri qui n'est pas intégré à Python. La fonction doit renvoyer la liste triée.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ ... | ["\nassert my_sort([3, 1, 2]) == [1, 2, 3]\n", "\nassert my_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert my_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert my_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert my_sort([1]) == [1]\n", "\nassert my_sort([]) == []\n", "... |
8ba79dcac0eafa77112d5d0007372258 | [
{
"content": "On te donne une liste d'entiers `sequence`. Ta tâche est de trouver la plus longue sous-séquence croissante (LSC) dans la séquence. La sous-séquence doit consister en des éléments distincts et doit maintenir l'ordre des éléments tels qu'ils apparaissent dans la séquence d'origine. S'il existe plus... | ["\nassert find_longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 18]\n", "\nassert find_longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert find_longest_increasing_subsequence([7, 7, 7, 7, 7]) == [7]\n", "\nassert find_longest_increasing_subsequence([1, 2, 3, 4, 5])... |
70848ca84c8a5ff008fefee0acc959ba | [
{
"content": "On te donne un objet JSON représentant une liste de dictionnaires. Ta tâche est de mettre en œuvre une fonction `filter_json` qui filtre cette liste en fonction d'une paire clé-valeur spécifiée. La fonction doit renvoyer une nouvelle liste de dictionnaires contenant uniquement les entrées où la cl... | ["\nassert filter_json([{\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Bob\", \"age\": 30}], \"age\", 25) == [{\"name\": \"Alice\", \"age\": 25}]\n", "\nassert filter_json([{\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Bob\", \"age\": 30}], \"age\", 30) == [{\"name\": \"Bob\", \"age\": 30}]\n", "\nassert filter_js... |
3ad237412330aca8fbf911bc20f15c5c | [
{
"content": "On te donne une liste d'entiers. Ton objectif est de créer une fonction qui renvoie une nouvelle liste où chaque élément est le produit de tous les autres éléments de la liste originale, à l'exclusion de l'élément lui-même. La fonction ne doit pas utiliser la division et doit gérer les cas limites... | ["\nassert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]\n", "\nassert product_except_self([0, 1, 2, 3]) == [6, 0, 0, 0]\n", "\nassert product_except_self([1, 0, 3, 4]) == [0, 12, 0, 0]\n", "\nassert product_except_self([1, 2, 0, 4]) == [0, 0, 8, 0]\n", "\nassert product_except_self([1, 2, 3, 0]) == [0, 0, 0, 6]\... |
4b17046b7ae25dcac3ccd2ef942b6a02 | [
{
"content": "On te donne une liste d'outils utilisés dans une recette, où chaque outil est représenté comme un dictionnaire avec une clé \"Tool\". Certains outils sont désignés comme des \"outils de superclasse\" et ne doivent pas être utilisés directement dans une recette. Ta tâche est de mettre en œuvre une ... | ["\nassert validate_no_superclass_tools([{\"Tool\": \"BaseMixer\"}], \"TestRecipe\") == False\n", "\nassert validate_no_superclass_tools([{\"Tool\": \"BaseGrinder\"}], \"TestRecipe\") == False\n", "\nassert validate_no_superclass_tools([{\"Tool\": \"Mixer\", \"uses\": [\"BaseMixer\"]}], \"TestRecipe\") == False\n", "\n... |
fc02755bd01f2e99ae566b279967dff4 | [
{
"content": "On te demande d'implémenter un simple jeu d'aventure textuel en Python. Le jeu consiste en au moins trois pièces, chacune avec un nom et une description uniques. Les joueurs peuvent se déplacer entre les pièces en utilisant des commandes de base ('north', 'south', 'east', 'west') et peuvent intera... | ["\nassert game.current_room.name == \"The Living Room\"\n", "\nassert game.living_room.connected_rooms['south'].name == \"The Kitchen\"\n", "\nassert game.kitchen.connected_rooms['north'].name == \"The Living Room\"\n", "\nassert game.kitchen.connected_rooms['west'].name == \"The Bedroom\"\n", "\nassert game.bedroom.c... |
ae64039bc5518f2632431675ba637f40 | [
{
"content": "On te demande d'implémenter une fonction `get_char_from_ascii_range` qui accepte deux entiers, `start` et `end`, représentant des valeurs ASCII. Ton objectif est de générer une liste de caractères correspondant à toutes les valeurs ASCII de `start` à `end` (inclus). La fonction doit utiliser une s... | ["\nassert get_char_from_ascii_range(65, 90) == ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n", "\nassert get_char_from_ascii_range(97, 122) == ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r'... |
752c433b208f49292f94589f4d727018 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'un nombre et de son poids correspondant. Ta tâche est de calculer la moyenne pondérée de ces nombres. La moyenne pondérée est calculée comme la somme des produits de chaque nombre et de son poids, divisée par la somme totale des poids.... | ["\nassert weighted_average([(3, 2), (5, 1)]) == 3.67\n", "\nassert weighted_average([(1, 1), (2, 2), (3, 3)]) == 2.33\n", "\nassert weighted_average([(10, 0), (20, 0), (30, 0)]) == None\n", "\nassert weighted_average([]) == None\n", "\nassert weighted_average([(100, 1)]) == 100.0\n", "\nassert weighted_average([(0, 1)... |
7023b8ca3c6145b92a9ccd8c5775fb56 | [
{
"content": "Tu développes une fonctionnalité pour une plateforme de commerce en ligne qui inclut une fonctionnalité de \"Liste de souhaits\". Les utilisateurs peuvent ajouter des articles à leur Liste de souhaits avec une quantité spécifiée. Ta tâche est de mettre en œuvre une fonction `add_item_to_wishlist` ... | ["\nassert add_item_to_wishlist(\"laptop\", [(\"laptop\", 2)]) == [(\"laptop\", 4)]\n", "\nassert add_item_to_wishlist(\"mouse\", [\"mouse\"]) == [(\"mouse\", 2)]\n", "\nassert add_item_to_wishlist(\"keyboard\", [(\"laptop\", 2), \"mouse\"]) == [(\"laptop\", 2), (\"mouse\", 1), (\"keyboard\", 1)]\n", "\nassert add_item... |
372db7ae7841ac04fc1b869635ec7107 | [
{
"content": "On te donne un système de fichiers hypothétique où chaque fichier et répertoire est représenté par un dictionnaire avec des identifiants et des types uniques. Certains types ont une définition spéciale, indiquée par une valeur non nulle dans le champ `definition`. Le système de fichiers peut égale... | ["\nassert hasSpecialDefinition({'id': 1, 'type': 'file', 'definition': 'some definition'}, []) == True\n", "\nassert hasSpecialDefinition({'id': 2, 'type': 'dir', 'definition': None}, []) == False\n", "\nassert hasSpecialDefinition({'id': 3, 'link': 1}, [{'id': 1, 'type': 'file', 'definition': 'some definition'}]) == ... |
a7d15d437961361fa67cf797e68b9d6a | [
{
"content": "On te donne une chaîne de caractères `s` qui peut contenir des caractères alphanumériques et des espaces. Ta tâche est de déterminer si la chaîne est un palindrome, en considérant uniquement les caractères alphanumériques et en ignorant la casse. Une chaîne est un palindrome si elle se lit de la m... | ["\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(... |
4c1ecda499e909bb60cf224416f38a1f | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `count_words(text)` qui traite la chaîne et renvoie un dictionnaire. Le dictionnaire doit contenir chaque mot unique de la chaîne comme clé et leur nombre d'occurrences respectif comme valeur. La fonction doit... | ["\nassert count_words(\"Hello, hello! How are you?\") == {\"hello\": 2, \"how\": 1, \"are\": 1, \"you\": 1}\n", "\nassert count_words(\"Python, python, PYTHON!\") == {\"python\": 3}\n", "\nassert count_words(\"A quick brown fox jumps over the lazy dog.\") == {\"a\": 1, \"quick\": 1, \"brown\": 1, \"fox\": 1, \"jumps\"... |
2590efcbb6f544168619be7d835b8da6 | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses IPv4. Une adresse IPv4 est considérée comme valide si elle est composée de quatre octets séparés par des points, chaque octet étant un nombre compris entre 0 et 255 inclus. De plus, aucun octet ne doit avoir de zéros non significat... | ["\nassert validate_ip_address(\"192.168.1.1\") == True\n", "\nassert validate_ip_address(\"255.255.255.255\") == True\n", "\nassert validate_ip_address(\"0.0.0.0\") == True\n", "\nassert validate_ip_address(\"256.256.256.256\") == False\n", "\nassert validate_ip_address(\"192.168.1\") == False\n", "\nassert validate_i... |
40e814c2dc8a5bfd3ab8aa69bf808f8f | [
{
"content": "On te donne un tableau numpy unidimensionnel `data` composé de nombres réels, qui peuvent inclure des valeurs en notation scientifique. Ta tâche est de classer les éléments de `data` par ordre croissant avec une règle spéciale pour gérer les valeurs dupliquées. Si des valeurs sont dupliquées, elle... | ["\nassert np.array_equal(rank_elements_with_adjustment(np.array([0.5, 1.2, 3.4, 1.2, 1.2])), np.array([1, 4, 5, 4, 4]))\n", "\nassert np.array_equal(rank_elements_with_adjustment(np.array([1.0, 2.0, 3.0, 4.0, 5.0])), np.array([1, 2, 3, 4, 5]))\n", "\nassert np.array_equal(rank_elements_with_adjustment(np.array([5.0, 4... |
d3ddf5515022a14e6af478cc9cc7e171 | [
{
"content": "Tu dois implémenter une structure de données `Trie` qui prend en charge les opérations suivantes :\n\n- `insert(word)` : Insère un mot dans le trie.\n- `search(word)` : Renvoie `True` si le mot se trouve dans le trie, et `False` sinon.\n- `startsWith(prefix)` : Renvoie `True` s'il existe un mot da... | ["\nassert Trie().search(\"word\") == False\n", "\nassert Trie().startsWith(\"prefix\") == False\n", "\ntrie = Trie(); trie.insert(\"hello\"); assert trie.search(\"hello\") == True\n", "\ntrie = Trie(); trie.insert(\"hello\"); assert trie.search(\"hell\") == False\n", "\ntrie = Trie(); trie.insert(\"hello\"); assert tr... |
b863209cb3511659b236c2552118252e | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Détermine si les caractères de `s` peuvent être réorganisés pour former un palindrome. Un palindrome se lit de la même manière de gauche à droite et de droite à gauche. Ta tâche est de mettre en œuvre un... | ["\nassert can_form_palindrome(\"aabbc\") == True\n", "\nassert can_form_palindrome(\"racecar\") == True\n", "\nassert can_form_palindrome(\"aabbcc\") == True\n", "\nassert can_form_palindrome(\"abc\") == False\n", "\nassert can_form_palindrome(\"aab\") == True\n", "\nassert can_form_palindrome(\"aabbccdd\") == True\n"... |
89b133b8d831cd6f14476039ddec9d9a | [
{
"content": "On te donne deux vecteurs 3D, `vector1` et `vector2`, représentés comme des listes de trois éléments chacun. Chaque élément peut être un nombre réel ou complexe. Ta tâche est d'écrire une fonction `find_angle_between_vectors(vector1, vector2)` qui calcule et renvoie l'angle entre ces deux vecteurs... | ["\nassert find_angle_between_vectors([1, 0, 0], [0, 1, 0]) == 90.0\n", "\nassert find_angle_between_vectors([1, 0, 0], [1, 0, 0]) == 0.0\n", "\nassert find_angle_between_vectors([1, 0, 0], [-1, 0, 0]) == 180.0\n", "\nassert find_angle_between_vectors([1, 1, 1], [1, 1, 1]) == 0.0\n", "\nassert find_angle_between_vector... |
1ceacfd71dcea581f17c37d67dc5bb55 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'une clé chaîne de caractères et d'une liste d'entiers comme valeurs. Ta tâche est de construire un dictionnaire à partir de cette liste, de sorte que chaque clé corresponde à sa liste de valeurs correspondante, mais d'inclure uniquemen... | ["\nassert convert_to_dict([(\"key\", [1, 2, 3]), (\"oddkey\", [4, 5, 6]), (\"even\", [7, 8, 9])]) == {\"oddkey\": [4, 5, 6]}\n", "\nassert convert_to_dict([(\"a\", [1]), (\"bb\", [2]), (\"ccc\", [3]), (\"dddd\", [4])]) == {\"a\": [1], \"ccc\": [3]}\n", "\nassert convert_to_dict([(\"hello\", [1, 2]), (\"world\", [3, 4]... |
745292531a25ba310427647e32d9bfeb | [
{
"content": "On te demande d'optimiser une fonction pour calculer le nième nombre de Fibonacci efficacement. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Ta solution doit avoir une complexité temporelle meilleure que O(2^n).\n\n**Entrée :**\n- Un enti... | ["\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... |
97cc3b378a3288fa842461c92f391ac6 | [
{
"content": "On te demande d'implémenter une fonction `all_empty` qui accepte un nombre variable d'arguments. Chaque argument peut être de type chaîne de caractères, liste, dictionnaire, ensemble ou un objet personnalisé. La fonction doit déterminer si tous les arguments fournis sont vides, c'est-à-dire s'ils ... | ["\nassert all_empty() == True\n", "\nassert all_empty(\"\", [], {}, set()) == True\n", "\nassert all_empty(\"not empty\") == False\n", "\nassert all_empty([], [1, 2, 3]) == False\n", "\nassert all_empty({}, {\"key\": \"value\"}) == False\n", "\nassert all_empty(set(), {1, 2, 3}) == False\n", "\nassert all_empty([], {}... |
ecf3a771e917836f2b1fc40ed9208562 | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Ta tâche est de déterminer le nombre minimum d'opérations nécessaires pour transformer `str1` en `str2`. Les opérations autorisées sont :\n\n- Insérer un caractère à n'importe quelle position dans la chaîne.\n- Supprimer un caractère de n'i... | ["\nassert min_operations(\"horse\", \"ros\") == 3\n", "\nassert min_operations(\"intention\", \"execution\") == 5\n", "\nassert min_operations(\"abc\", \"abc\") == 0\n", "\nassert min_operations(\"abc\", \"abcd\") == 1\n", "\nassert min_operations(\"abc\", \"def\") == 3\n", "\nassert min_operations(\"\", \"a\") == 1\n... |
1b834ef4b135f9ad1310b5e87f126c7a | [
{
"content": "On te donne un graphe non orienté pondéré `G` et une partition `P` de ses nœuds en communautés. Ta tâche est de calculer la coupe normalisée de la partition `P`. La coupe normalisée est définie comme le rapport du poids total des arêtes entre les communautés au poids total des arêtes à l'intérieur... | ["\nassert normalized_cut_v2({'a': {'b': 1, 'c': 2}, 'b': {'a': 1, 'c': 3}, 'c': {'a': 2, 'b': 3}}, [frozenset(['a', 'b']), frozenset(['c'])]) == 2.0\n", "\nassert normalized_cut_v2({'a': {'b': 1}, 'b': {'a': 1}}, [frozenset(['a']), frozenset(['b'])]) == float('inf')\n", "\nassert normalized_cut_v2({'a': {'b': 1, 'c': ... |
125c020e119dd41a2d87d8678f3d9098 | [
{
"content": "On te donne une chaîne de caractères `sentence`. Ta tâche est d'implémenter une fonction `character_frequency(sentence)` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être des digrammes uniques (paires de caractères alphabétiques consécutifs) trouvés dans la `sentence`, et les vale... | ["\nassert character_frequency(\"Hello, World!\") == {'he': 1, 'el': 1, 'll': 1, 'lo': 1, 'wo': 1, 'or': 1, 'rl': 1, 'ld': 1}\n", "\nassert character_frequency(\"A quick brown fox jumps over the lazy dog.\") == {'aq': 1, 'qu': 1, 'ui': 1, 'ic': 1, 'ck': 1, 'kb': 1, 'br': 1, 'ro': 1, 'ow': 1, 'wn': 1, 'nf': 1, 'fx': 1, ... |
6930804354fa7cbaca5bc3795edc1b35 | [
{
"content": "Dans un jeu numérique, les joueurs collectent des pièces, chacune ayant une valeur distincte. Le score total du joueur est calculé comme la somme des valeurs de toutes les pièces collectées. Implémente une fonction `calculate_score` qui accepte une liste d'entiers représentant les valeurs des pièc... | ["\nassert calculate_score([10, 5, 20, 30, 15]) == (80, 5)\n", "\nassert calculate_score([1, 2, 3, 4, 5]) == (15, 5)\n", "\nassert calculate_score([100, 200, 300]) == (600, 3)\n", "\nassert calculate_score([]) == (0, 0)\n", "\nassert calculate_score([5]) == (5, 1)\n", "\nassert calculate_score([0, 0, 0, 0]) == (0, 4)\n... |
8933310f179f22ac92884f3044f9457d | [
{
"content": "On te donne une matrice `n x n` représentée sous forme de liste 2D. Ta tâche est de faire pivoter la matrice de 90 degrés dans le sens des aiguilles d'une montre sur place, sans utiliser de mémoire supplémentaire pour une autre matrice.\n\n**Entrée :**\n- La première ligne contient un entier `n` (... | ["\nassert rotate_matrix([[1]]) == None\n", "\nmatrix = [[1]]; rotate_matrix(matrix); assert matrix == [[1]]\n", "\nmatrix = [[1, 2], [3, 4]]; rotate_matrix(matrix); assert matrix == [[3, 1], [4, 2]]\n", "\nmatrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; rotate_matrix(matrix); assert matrix == [[7, 4, 1], [8, 5, 2], [9, 6,... |
37f21ee86b05c13ff0321bc0b2ae5c26 | [
{
"content": "Tu développes un jeu de devinettes où le joueur reçoit un mot représenté par des tirets bas, chaque tiret bas correspondant à une lettre du mot. Le joueur doit deviner des lettres pour révéler le mot. Si une lettre devinée est correcte, elle remplace les tirets bas correspondants. Si elle est inco... | ["\nassert setup_word(\"enlist\", [\"enlist\", \"google\", \"inlets\", \"banana\", \"silent\", \"tinsel\", \"listen\"]) == (['_', '_', '_', '_', '_', '_'], ['enlist', 'inlets', 'silent', 'tinsel', 'listen'])\n", "\nassert setup_word(\"google\", [\"enlist\", \"google\", \"inlets\", \"banana\", \"silent\", \"tinsel\", \"... |
49f1c305a0363efc4f222aba630a7a35 | [
{
"content": "On te donne un arbre binaire. Ta tâche est d'effectuer un parcours vertical de l'arbre et de renvoyer le résultat sous forme de liste de listes. Chaque liste interne doit contenir les valeurs des nœuds qui se trouvent au même niveau vertical, en commençant par le niveau vertical le plus à gauche j... | ["\nassert vertical_order(TreeNode(1, TreeNode(2), TreeNode(3))) == [[2], [1], [3]]\n", "\nassert vertical_order(TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7)))) == [[4], [2], [1, 5, 6], [3], [7]]\n", "\nassert vertical_order(TreeNode(3, TreeNode(9), TreeNode(20, TreeNode(15), ... |
d05bbf613739483c18f00d1e924d5e83 | [
{
"content": "On te donne une chaîne JSON représentant les informations d'une personne. Ta tâche est d'écrire une fonction qui convertit cette chaîne JSON en un dictionnaire Python, puis d'extraire la valeur associée à une clé spécifiée. Si la clé n'existe pas ou si la chaîne JSON est invalide, la fonction doit... | ["\nassert extract_key_from_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}', \"name\") == \"John\"\n", "\nassert extract_key_from_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}', \"age\") == 30\n", "\nassert extract_key_from_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\... |
0930d87320443879a92daf514054f8ba | [
{
"content": "Tu es chargé de développer un scraper web pour extraire les titres des 10 premiers articles de la page d'accueil de Hacker News. Ton programme doit utiliser les bibliothèques `requests` et `BeautifulSoup` pour accomplir cette tâche. Ta fonction doit afficher les titres dans la console, chacun préf... | ["\nassert len(scrape_hacker_news_titles()) == 10\n", "\nassert isinstance(scrape_hacker_news_titles(), list)\n", "\nassert all(isinstance(title, str) for title in scrape_hacker_news_titles())\n", "\nassert \"Failed to retrieve the webpage\" not in scrape_hacker_news_titles()\n", "\nassert scrape_hacker_news_titles()[0... |
59ebdd60fd77a276b6886daea5db84d6 | [
{
"content": "Implémente une classe `BankAccount` en Python qui prend en charge les opérations suivantes :\n\n- `deposit(amount)` : ajoute le montant spécifié au solde du compte si le montant est positif.\n- `withdraw(amount)` : soustrait le montant spécifié du solde du compte si le montant est positif et ne dé... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount(50).deposit(50) or BankAccount(50).get_balance() == 100\n", "\nassert BankAccount(100).withdraw(50) or BankAccount(100).get_balance() == 50\n", "\nassert BankAccount(100).withdraw(150) or BankAccoun... |
0c4e592217fa3000165ab75fc118c641 | [
{
"content": "On te donne un tableau d'entiers `arr` de longueur `n`. Un élément de crête est défini comme un élément qui est supérieur à ses éléments adjacents. Pour les premier et dernier éléments, ils n'ont qu'un seul élément adjacent. Ta tâche est de trouver et de renvoyer l'indice de n'importe quel élément... | ["\nassert find_peak_element([1, 2, 3, 1]) == 2\n", "\nassert find_peak_element([1, 3, 20, 4, 1, 0]) == 2\n", "\nassert find_peak_element([10, 20, 15, 2, 23, 90, 67]) == 1 or find_peak_element([10, 20, 15, 2, 23, 90, 67]) == 5\n", "\nassert find_peak_element([1]) == -1\n", "\nassert find_peak_element([]) == -1\n", "\na... |
9f148481cf268b0a27a54f80f1ca69b4 | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction `remove_duplicates` qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste originale, en préservant l'ordre de leur première apparition.\n\n**Entrée :**\n- Une liste d'entiers `numb... | ["\nassert remove_duplicates([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([5, 4, 3, 2, 1]) == [5, 4, 3, 2, 1]\n", "\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([]) == []\n", "\nassert r... |
d0679a4d4e49f10c47fbce8649f71626 | [
{
"content": "Tu es chargé d'implémenter une classe Python nommée `ArithmeticOperations` qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division sur deux nombres. La classe doit gérer la division par zéro avec élégance en renvoyant un message spécifique.\n\n... | ["\nassert ArithmeticOperations(5, 3).add() == 8\n", "\nassert ArithmeticOperations(10, 5).subtract() == 5\n", "\nassert ArithmeticOperations(4, 6).multiply() == 24\n", "\nassert ArithmeticOperations(20, 4).divide() == 5.0\n", "\nassert ArithmeticOperations(7, 0).divide() == \"Division by zero is not allowed.\"\n", "\n... |
66129203c3979cdc0f41e94b34028c3f | [
{
"content": "Implémente une classe Python nommée `Book` avec les spécifications suivantes :\n\n- **Attributs :**\n - `title` : Une chaîne de caractères représentant le titre du livre.\n - `author` : Une chaîne de caractères représentant l'auteur du livre.\n - `year` : Un entier représentant l'année de publi... | ["\nassert Book(\"1984\", \"George Orwell\", 1949, [\"Dystopian\", \"Political Fiction\"]).title == \"1984\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, [\"Dystopian\", \"Political Fiction\"]).author == \"George Orwell\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, [\"Dystopian\", \"Political Fiction... |
c73405bbf71ed8e2aa9e578397afb351 | [
{
"content": "On te demande de traiter un ensemble de données contenant les prix de clôture des actions stockés dans un DataFrame pandas. Chaque colonne correspond à une action différente et chaque ligne représente une date. En raison de problèmes de collecte de données, certaines actions présentent un nombre i... | ["\nassert filter_stock_data(pd.DataFrame({'A': [1, 2, None, 4], 'B': [None, None, None, None], 'C': [1, None, 3, 4]}), limit=2).equals(pd.DataFrame({'A': [1, 2, None, 4], 'C': [1, None, 3, 4]}))\n", "\nassert filter_stock_data(pd.DataFrame({'A': [1, 2, 3, 4], 'B': [None, None, None, None], 'C': [1, 2, 3, 4]}), limit=1... |
0d438a922a07e980b7dba583681f5f69 | [
{
"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(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Hello, World!\") == False\n", "\nassert is_palindrome(\"Madam, in Eden, I'm Adam\") == True... |
5528a72d4e7e21f11a2547b4652e97a4 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction `reverse_string(s: str) -> str` qui renvoie la version inversée de la chaîne `s`. Tu n'es pas autorisé à utiliser le découpage ou toute fonction intégrée qui inverse directement la chaîne. Implémente l'inversion manuellem... | ["\nassert reverse_string(\"hello\") == \"olleh\"\n", "\nassert reverse_string(\"world\") == \"dlrow\"\n", "\nassert reverse_string(\"Python\") == \"nohtyP\"\n", "\nassert reverse_string(\"!@#$%^&*()\") == \")(*&^%$#@!\"\n", "\nassert reverse_string(\"1234567890\") == \"0987654321\"\n", "\nassert reverse_string(\"a\") ... |
8b7983cd642c53e7fd11510d2e060cb7 | [
{
"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 considérant uniquement les caractères alphanumériques et en ignorant la casse. Une chaîne est un palindrome si elle se lit de la même manière à l'endroit et à l'envers.\n\n**Entrée :**\n- Une se... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"hello\") == False\n", "\nassert is_palindrome(\"\") == True\n", "\nassert is_palindrome(\" \") == True\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nasser... |
ab555b073864fbd53767bce3d97feb23 | [
{
"content": "On te demande d'implémenter une fonction pour convertir un entier en sa représentation en chiffres romains. La fonction doit gérer tous les entiers de 1 à 3999 inclus. Ta solution doit être efficace et concise.\n\n**Exemple d'entrée et de sortie :**\n- Entrée : `1`\n - Sortie : `\"I\"`\n- Entrée ... | ["\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(500) ==... |
fbb722ff42ec63c5890e9995144d01a2 | [
{
"content": "On te demande d'écrire une fonction pour valider les adresses e-mail en fonction de critères spécifiques. Une adresse e-mail est considérée comme valide si elle répond aux conditions suivantes :\n- Elle commence par un ou plusieurs caractères alphanumériques.\n- La partie locale (avant le symbole ... | ["\nassert is_valid_email(\"valid.email@example.com\") == True\n", "\nassert is_valid_email(\"valid_email@sub.example.org\") == True\n", "\nassert is_valid_email(\"valid-email@domain.net\") == True\n", "\nassert is_valid_email(\"validemail@domain.edu\") == True\n", "\nassert is_valid_email(\"invalid-email@domain\") == ... |
01796cd70f08916fde396a3559af0aff | [
{
"content": "Tu es chargé de traiter un fichier CSV nommé \"data.csv\" qui contient des informations sur les produits. Chaque ligne du fichier représente un produit distinct, avec des colonnes séparées par des points-virgules (;). La première colonne contient l'ID du produit, la deuxième colonne contient le no... | ["\nassert process_products() == [{'id': '1', 'name': 'Product1', 'price': '10.99'}, {'id': '2', 'name': 'Product2', 'price': '15.99'}] if open(\"data.csv\", \"w\").write(\"id;name;price\\n1;Product1;10.99\\n2;Product2;15.99\") else None\n", "\nassert process_products() == [{'id': '101', 'name': 'Widget', 'price': '23.... |
3cc3395eb0792ffddd59715899a04a1f | [
{
"content": "On te demande d'implémenter une fonction de perte d'entropie croisée binaire polyvalente dans PyTorch qui prenne en charge à la fois la classification mono-étiquette et multi-étiquette. Ta fonction doit gérer les cas où le tenseur `logits` a une forme de `(batch_size, num_classes)` et le tenseur `... | ["\nassert binary_cross_entropy_loss(torch.tensor([[0.5]]), torch.tensor([1]), reduction='none').item() == -torch.log(torch.tensor([0.5])).item()\n", "\nassert binary_cross_entropy_loss(torch.tensor([[0.5]]), torch.tensor([0]), reduction='none').item() == -torch.log(torch.tensor([0.5])).item()\n", "\nassert binary_cros... |
70a41e8c5f4cbb607827d7c220b168b2 | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python. La classe doit avoir un initialisateur qui accepte la largeur et la hauteur du rectangle. Implémente deux méthodes : `area` et `perimeter`. La méthode `area` doit renvoyer l'aire du rectangle, et la méthode `perimeter` doit renvoyer le ... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).perimeter() == 20\n", "\nassert Rectangle(0, 0).area() == 0\n", "\nassert Rectangle(0, 0).perimeter() == 0\n", "\nassert Rectangle(10, 2).area() == 20\n", "\nassert Rectangle(7, 3).perimeter() == 20\n", "\nassert Rectangle(1, 1).area() == 1\n", "\nas... |
900fa32ee5df254a83533d400cf09300 | [
{
"content": "Tu es chargé d'implémenter la fonction `format_duration` qui prend un nombre à virgule flottante `seconds` en entrée et renvoie une chaîne de caractères lisible par un humain représentant la durée donnée. La durée doit être décomposée en heures, minutes et secondes, avec les secondes fractionnaire... | ["\nassert format_duration(0) == \"-\"\n", "\nassert format_duration(3600) == \"1 hour\"\n", "\nassert format_duration(3661) == \"1 hour, 1 minute, 1 second\"\n", "\nassert format_duration(3661.3) == \"1 hour, 1 minute, 1.3 seconds\"\n", "\nassert format_duration(60) == \"1 minute\"\n", "\nassert format_duration(61) ==... |
ea81e38b68d0f189b33d6f4fe151ff81 | [
{
"content": "On te donne une chaîne de caractères `text` contenant diverses entités nommées telles que des noms de personnes, des noms d'organisations et des lieux. Ta tâche est d'écrire une fonction `replace_entities(text)` qui remplace chaque entité nommée par son type d'entité correspondant (par exemple, 'P... | ["\nassert replace_entities(\"Barack Obama was the president of the United States.\") == \"PERSON was the president of the LOC.\"\n", "\nassert replace_entities(\"Apple Inc. is headquartered in Cupertino.\") == \"ORG is headquartered in LOC.\"\n", "\nassert replace_entities(\"Paris is the capital of France.\") == \"LOC... |
8ab99b5f457aff6c1851bae944d661f2 | [
{
"content": "On te donne deux chaînes binaires, `s1` et `s2`, chacune de longueur `n`. La distance de Hamming entre deux chaînes est définie comme le nombre de positions auxquelles les caractères correspondants diffèrent. Ta tâche est de calculer la distance de Hamming entre `s1` et `s2` en utilisant une appro... | ["\nassert hamming_distance_binary_strings(\"1101\", \"1001\") == 1\n", "\nassert hamming_distance_binary_strings(\"1111\", \"0000\") == 4\n", "\nassert hamming_distance_binary_strings(\"0000\", \"0000\") == 0\n", "\nassert hamming_distance_binary_strings(\"101010\", \"010101\") == 6\n", "\nassert hamming_distance_bina... |
3e072e23b19c0a242a17663065e69dc0 | [
{
"content": "On te donne un ensemble de données qui a été normalisé en utilisant la formule : `normalized_value = log((original_value + 1) / (original_value + 1 + e^(-original_value)))`. Ta tâche est d'écrire une fonction qui prend en entrée l'ensemble de données normalisé, la moyenne de l'ensemble de données ... | ["\nassert de_normalize_dataset([[0, 0]], [0, 0], [1, 1]) == [[0.0, 0.0]]\n", "\nassert de_normalize_dataset([[1, -1]], [10, -10], [5, 5]) == [[21.63212055882856, -21.63212055882856]]\n", "\nassert de_normalize_dataset([[0.6931471805599453, -0.6931471805599453]], [0, 0], [1, 1]) == [[1.0, -1.0]]\n", "\nassert de_normal... |
7b043d5d8f0b3a0bddcc17fdbfb31e59 | [
{
"content": "Tu es chargé d'implémenter une fonction `encode_state` qui accepte un tuple d'entiers, chacun allant de 0 à 9, et renvoie une chaîne de caractères. Chaque entier du tuple doit être encodé de manière unique en une séquence de trois caractères. L'encodage doit mapper '0' à '000', '1' à '001', ..., '... | ["\nassert encode_state((1, 2, 3)) == \"001002003\"\n", "\nassert encode_state((0, 9, 8)) == \"000009008\"\n", "\nassert encode_state((5, 5, 5)) == \"005005005\"\n", "\nassert encode_state((4, 3, 2, 1, 0)) == \"004003002001000\"\n", "\nassert encode_state((9, 0, 9, 0)) == \"009000009000\"\n", "\nassert encode_state((6,... |
102a63bbb7079369006acc9fd2098592 | [
{
"content": "On te donne un fichier texte nommé `input.txt` contenant un large corpus de texte en anglais. Le texte est composé uniquement de lettres minuscules et d'espaces, sans caractères spéciaux. Ta tâche est d'écrire un programme Python qui lit ce fichier, calcule la fréquence de chaque mot et écrit les ... | ["\nassert open('output.txt').read() == 'the\\t5\\nand\\t3\\nis\\t2\\nhello\\t1\\nworld\\t1\\n' if open('input.txt').write('the and is the hello world the and the') else False\n", "\nassert open('output.txt').read() == 'a\\t3\\nb\\t2\\nc\\t1\\n' if open('input.txt').write('a b c a b a') else False\n", "\nassert open('o... |
8961b0844212e4f9a031656df6ef323d | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer l'inventaire d'une bibliothèque. La classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation** : Créer un livre avec les attributs `title`, `author`, `publication_year`, `genre`, `isbn` et `available_copies`.\n- **Empru... | ["\nassert Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\", \"1234567890\", 5).title == \"1984\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\", \"1234567890\", 5).author == \"George Orwell\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"Dystopian\", \"1234567890\", 5).publication_y... |
e7573850eda1753bd0529894d0031f5d | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui calcule le produit maximal de deux nombres distincts quelconques dans la liste. La liste contiendra au moins deux entiers.\n\n**Exemple d'entrée :**\n```\n[1, 10, 2, 6, 5, 3]\n[-10, -20, 5, 6]\n```\n\n**Exemple de sortie :**\n... | ["\nassert max_product([1, 10, 2, 6, 5, 3]) == 60\n", "\nassert max_product([-10, -20, 5, 6]) == 200\n", "\nassert max_product([1, 2]) == 2\n", "\nassert max_product([0, 2, 3, 5]) == 15\n", "\nassert max_product([-1, -2, -3, -4]) == -1\n", "\nassert max_product([100, 200, 3, 5]) == 20000\n", "\nassert max_product([-1, ... |
2f589e12bf33c3863f83baed51c0a290 | [
{
"content": "Implémente une classe `LinkedList` qui représente une liste chaînée simple avec les fonctionnalités suivantes :\n\n- `append(data)` : Ajoute un nouveau nœud avec les `data` spécifiées à la fin de la liste.\n- `insert(index, data)` : Insère un nouveau nœud avec les `data` spécifiées à l’`index` spé... | ["\nassert LinkedList().get(0) == None\n", "\nll = LinkedList(); ll.append(1); assert ll.get(0) == 1\n", "\nll = LinkedList(); ll.append(1); ll.append(2); assert ll.get(1) == 2\n", "\nll = LinkedList(); ll.append(1); ll.append(2); ll.insert(1, 3); assert ll.get(1) == 3\n", "\nll = LinkedList(); ll.append(1); ll.append(... |
02cb24454cb8f2d32e1b8127118d734e | [
{
"content": "On te demande de concevoir une fonction `generate_identifier` qui construit un identifiant unique pour un document en fonction de son titre et de son sous-titre. La fonction doit renvoyer une chaîne de caractères appropriée pour être utilisée comme nom de fichier ou de répertoire. La fonction doit... | ["\nassert generate_identifier(\"Government Gazette\", \"Regulation Gazette\", []) == \"government-gazette\"\n", "\nassert generate_identifier(\"government gazette\", \"legal gazette a\", []) == \"government-gazette\"\n", "\nassert generate_identifier(\"Government Gazette\", \"Legal Gazette B\", []) == \"government-gaz... |
6267249c832e98cec630479f4593f851 | [
{
"content": "On te donne un entier `n`. Ta tâche est de déterminer si `n` est un nombre palindrome. Un nombre palindrome est défini comme un nombre qui se lit de la même manière à l'endroit et à l'envers. Par exemple, 121 est un nombre palindrome.\n\n**Entrée :**\n- Un entier `n` (0 ≤ n ≤ 10^9)\n\n**Sortie :**... | ["\nassert is_palindrome_number(121) == True\n", "\nassert is_palindrome_number(-121) == False\n", "\nassert is_palindrome_number(10) == False\n", "\nassert is_palindrome_number(0) == True\n", "\nassert is_palindrome_number(12321) == True\n", "\nassert is_palindrome_number(123456) == False\n", "\nassert is_palindrome_n... |
32480fc42b2bc305cedf269e84f1215a | [
{
"content": "On te donne deux chaînes de caractères `s1` et `s2`. Ta tâche est d'écrire une fonction `interleaveStrings(s1, s2)` qui entrelace les caractères de `s1` et `s2` par blocs de 3 caractères chacun, en commençant par `s1`. Si les chaînes ont des longueurs différentes, ajoute les caractères restants de... | ["\nassert interleaveStrings(\"abc\", \"123\") == \"abc123\"\n", "\nassert interleaveStrings(\"abcdef\", \"123456\") == \"abc123def456\"\n", "\nassert interleaveStrings(\"abcdefgh\", \"123\") == \"abc123def\"\n", "\nassert interleaveStrings(\"abc\", \"123456789\") == \"abc123\"\n", "\nassert interleaveStrings(\"abcdefg... |
abde607751bbdb2142746e903af9b5b0 | [
{
"content": "On te donne une grille 2D représentant un plateau de jeu, où chaque cellule peut contenir soit un entier, soit une chaîne de caractères. La grille est divisée en plusieurs groupes, chaque groupe étant constitué de cellules qui partagent la même valeur entière ou la même chaîne de caractères. Ta tâ... | ["\nassert check_group_validity([[1, 2], [3, 4]], [[[0, 0], [0, 1]], [[1, 0], [1, 1]]]) == True\n", "\nassert check_group_validity([[1, 'a'], [3, 4]], [[[0, 0], [1, 0]], [[0, 1], [1, 1]]]) == False\n", "\nassert check_group_validity([[2, 7, 6], [9, 5, 1], [4, 3, 8]], [[[0, 0], [1, 1], [2, 2]], [[0, 1], [0, 2], [1, 0]],... |
4f4b46c4ebb6bc17c9121201023d4831 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit encapsuler les propriétés d'un livre et fournir des méthodes pour déterminer son âge et s'il est considéré comme un classique. La classe `Book` doit avoir les attributs suivants :\n\n- `title` : une chaîne de caractères représ... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_age() == datetime.now().year - 1949\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).get_age() == datetime.now().year - 1960\n", "\nassert Book(\"Pride and Prejudice\", \"Jane Austen\", 1813).get_age() == datetime.now().year - 1813\n", "\nassert ... |
95e2b9142f961b674bdf848646367912 | [
{
"content": "On te donne une liste de tuples, où chaque tuple consiste en trois éléments : un nombre à virgule flottante `x`, et deux listes d'entiers `A` et `B`. Ta tâche est de calculer une nouvelle liste de nombres. Pour chaque tuple `(x, A, B)`, le nombre correspondant dans la nouvelle liste est calculé co... | ["\nassert process_tuples([(1.0, [10, 20, 30, 40], [15, 25, 35, 45])], 2.5, [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]) == [1.0 + 2.5 * math.log(1 + abs(20 - 25))]\n", "\nassert process_tuples([(2.0, [2, 3, 5, 7], [1, 4, 6, 8])], 2.5, [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]) == [2.0 + 2.5 * math.log(1 + abs(3 - 4))]\n", "\nassert proce... |
e4137e2aa5dbe96d53b82ea0268b7a21 | [
{
"content": "On te demande d'implémenter une fonction `validate_input` qui demande à l'utilisateur une entrée en fonction d'un message donné et d'une liste d'options valides. La fonction doit être robuste face aux variations de l'entrée utilisateur en ignorant la casse et en supprimant les espaces blancs. Ta f... | ["\nassert validate_input(\"Choose an option (apple, banana, cherry): \", [\"Apple\", \"Banana\", \"Cherry\"]) in [\"apple\", \"banana\", \"cherry\"]\n", "\nassert validate_input(\"Choose an option (dog, cat, bird): \", [\"Dog\", \"Cat\", \"Bird\"]) in [\"dog\", \"cat\", \"bird\"]\n", "\nassert validate_input(\"Choose ... |
e1d19b70b6f37bcbabb75408526c4e77 | [
{
"content": "On te donne un objet de type fichier `log_file` avec une méthode `readline` qui lit la ligne suivante du fichier et un attribut `errors` qui est soit `None`, soit un itérable contenant des lignes d'erreur. Implémente une fonction `process_logs` qui lit toutes les lignes de `log_file` et les concat... | ["\nassert process_logs(type('LogFile', (object,), {'readline': lambda self: '', 'errors': None})) == \"\"\n", "\nassert process_logs(type('LogFile', (object,), {'readline': lambda self: 'Log line 1\\n', 'errors': None})) == \"Log line 1\\n\"\n", "\nassert process_logs(type('LogFile', (object,), {'readline': lambda sel... |
5e80afb26115a80de244c5d53d5747ea | [
{
"content": "On te donne une liste de phrases, où chaque phrase est représentée comme une liste de mots. Avant d'extraire des séquences, trie chaque phrase par ordre lexicographique. Ta tâche est d'extraire une séquence contiguë aléatoire de mots de chaque phrase, en veillant à ce que la longueur de la séquenc... | ["\nassert extract_sequences([[\"apple\", \"banana\", \"cherry\"]], 2) == [[\"banana\", \"cherry\"]]\n", "\nassert extract_sequences([[\"dog\", \"cat\", \"bat\"]], 5) == [[\"bat\", \"cat\", \"dog\"]]\n", "\nassert extract_sequences([[\"zebra\", \"yak\", \"antelope\"]], 1) == [[\"antelope\"]]\n", "\nassert extract_seque... |
7dee13e9bfaf3780de901852eb048582 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne consiste en un nom de pièce suivi d'une probabilité d'occupation. Le nom de la pièce et la probabilité sont séparés par un ou plusieurs espaces. Le nom de la pièce peut inclure des nombres et des caractères spéciaux, et la probabilit... | ["\nassert parse_room_probabilities([\"living room 0.75\"]) == {\"living room\": 0.75}\n", "\nassert parse_room_probabilities([\"kitchen 0.2\"]) == {\"kitchen\": 0.2}\n", "\nassert parse_room_probabilities([\"bedroom1 0.95\"]) == {\"bedroom1\": 0.95}\n", "\nassert parse_room_probabilities([\"guest room 1.2e-1\"]) == {\... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.