id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
fcef01ef4855f362e3b67f5b426d410b | [
{
"content": "Implémente une fonction récursive nommée `factorial_recursive` qui calcule la factorielle d'un entier non négatif donné `n`. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. Par définition, la factorielle de 0 est 1. Ta fonction doit... | ["\nassert factorial_recursive(0) == 1\n", "\nassert factorial_recursive(1) == 1\n", "\nassert factorial_recursive(2) == 2\n", "\nassert factorial_recursive(3) == 6\n", "\nassert factorial_recursive(4) == 24\n", "\nassert factorial_recursive(5) == 120\n", "\nassert factorial_recursive(6) == 720\n", "\nassert factorial_... |
1c1a2fed18318c6a3cff8db9bd5d1abf | [
{
"content": "On te donne deux listes triées d'entiers, `list1` et `list2`, chacune contenant jusqu'à 100 000 éléments. De plus, on te fournit une troisième liste, `list3`, qui peut contenir des entiers qui doivent être exclus du résultat final. Ta tâche est de fusionner `list1` et `list2` en une seule liste tr... | ["\nassert merge_and_remove([1, 3, 5], [2, 4, 6], []) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_and_remove([1, 2, 3], [4, 5, 6], [2, 5]) == [1, 3, 4, 6]\n", "\nassert merge_and_remove([], [], []) == []\n", "\nassert merge_and_remove([1, 2, 3], [], []) == [1, 2, 3]\n", "\nassert merge_and_remove([], [1, 2, 3], []) == [1... |
c961487919c7c8d4bf885ab9a27b1212 | [
{
"content": "On te donne un triangle rectangle avec des longueurs de côtés `side1`, `side2` et `side3`. L'un de ces côtés est inconnu et représenté par `None`. Ta tâche est de déterminer l'angle opposé au côté inconnu en utilisant les longueurs de côtés connues. Implémente la fonction `calculate_angle` qui ren... | ["\nassert calculate_angle(3, None, 5) == 36.86989764584402\n", "\nassert calculate_angle(None, 4, 5) == 53.13010235415598\n", "\nassert calculate_angle(5, 12, None) == 22.61986494804043\n", "\nassert calculate_angle(None, 12, 13) == 67.38013505195957\n", "\nassert calculate_angle(8, 15, None) == 28.072486935852994\n",... |
608d99c0add2d414d1cd8e2543cf4fd0 | [
{
"content": "On te donne deux tableaux d'entiers, `list1` et `list2`, de longueur égale `n`. Ta tâche est de construire une nouvelle liste, `output_list`, composée de tuples. Chaque tuple doit contenir les éléments correspondants de `list1` et `list2` uniquement si leur somme est paire. Si la somme est impaire... | ["\nassert create_even_sum_tuples([1, 2, 3], [3, 2, 1]) == [(2, 2)]\n", "\nassert create_even_sum_tuples([4, 4, 4], [4, 4, 4]) == [(4, 4), (4, 4), (4, 4)]\n", "\nassert create_even_sum_tuples([1, 3, 5], [1, 3, 5]) == []\n", "\nassert create_even_sum_tuples([0, 0, 0], [0, 0, 0]) == [(0, 0), (0, 0), (0, 0)]\n", "\nassert... |
6f938cd9fb4f90c8f7aee709cb750f6d | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'une chaîne de caractères et d'une liste d'entiers. Ta tâche est de mettre en œuvre une fonction qui traite cette liste et renvoie une nouvelle liste de tuples. Dans la nouvelle liste, chaque chaîne de caractères doit être inversée, et ... | ["\nassert reverse_and_sort_tuples([(\"hello\", [3, 1, 2])]) == [('olleh', [3, 2, 1])]\n", "\nassert reverse_and_sort_tuples([(\"world\", [5, 4, 6])]) == [('dlrow', [6, 5, 4])]\n", "\nassert reverse_and_sort_tuples([(\"abc\", [9, 7, 8])]) == [('cba', [9, 8, 7])]\n", "\nassert reverse_and_sort_tuples([(\"python\", [10, ... |
c808fcc7d7a71fc467751e9f8079cc1f | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de trouver toutes les paires de nombres pentagonaux `(P_k, P_j)` telles que `P_k - P_j` et `P_k + P_j` soient également des nombres pentagonaux. La fonction doit trouver toutes ces paires en un seul passage dans la liste des nombres pentagonaux jusqu... | ["\nassert find_pentagonal_pairs(10) == []\n", "\nassert find_pentagonal_pairs(20) == [(12, 5)]\n", "\nassert find_pentagonal_pairs(50) == [(12, 5)]\n", "\nassert find_pentagonal_pairs(100) == [(12, 5), (27, 22)]\n", "\nassert find_pentagonal_pairs(1000) == [(12, 5), (27, 22), (70, 17)]\n", "\nassert find_pentagonal_pa... |
1833fcfdde031ed92163f36803afb4b0 | [
{
"content": "On te donne une séquence d'ADN `text` composée des caractères 'A', 'T', 'C' et 'G'. Ta tâche est d'implémenter une fonction `find_unique_substrings(text: str, length: int) -> Set[str]` qui renvoie un ensemble de toutes les sous-chaînes palindromiques uniques de taille `length` dans `text`. Une sou... | ["\nassert find_unique_substrings(\"ATCG\", 2) == set()\n", "\nassert find_unique_substrings(\"ATTA\", 2) == {\"TT\"}\n", "\nassert find_unique_substrings(\"ATTA\", 3) == set()\n", "\nassert find_unique_substrings(\"ATTA\", 4) == {\"ATTA\"}\n", "\nassert find_unique_substrings(\"ATTA\", 0) == set()\n", "\nassert find_u... |
2013975dc18c252ddfa6e59f0834918e | [
{
"content": "On te donne une séquence `seq` qui peut être soit une liste, soit une chaîne de caractères, une longueur cible `target_length`, et un objet `filler`. Ta tâche est de modifier la séquence pour qu'elle corresponde à la `target_length` en la tronquant ou en la complétant avec l'objet `filler`. Si la ... | ["\nassert adjust_sequence([1, 2, 3, 4, 5], 3, [9]) == [1, 2, 3]\n", "\nassert adjust_sequence(\"hello\", 8, \"x\") == \"helloxxx\"\n", "\nassert adjust_sequence(\"world\", 5, \"!\") == \"world\"\n", "\nassert adjust_sequence([10, 20, 30], 5, [0]) == [10, 20, 30, 0, 0]\n", "\nassert adjust_sequence(\"abc\", 2, \"d\") =... |
9c5736d25b95f3b3e96da6d7975e0653 | [
{
"content": "On te demande d'implémenter une classe `Car` pour une simulation. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `make` : une chaîne de caractères représentant la marque de la voiture.\n - `model` : une chaîne de caractères représentant le modèle de la voiture... | ["\nassert Car(\"Toyota\", \"Prius\", 2020).get_info() == \"Car Information:\\nMake: Toyota\\nModel: Prius\\nYear: 2020\\nMileage: 0 miles\\nFuel Level: 0.0 gallons\"\n", "\nassert Car(\"Honda\", \"Civic\", 2018, 15000, 10.0).get_info() == \"Car Information:\\nMake: Honda\\nModel: Civic\\nYear: 2018\\nMileage: 15000 mi... |
93f97c5e06369a70bb2137ffc00a5939 | [
{
"content": "On te demande d'implémenter une fonction `validate_domain` pour un système \"Blockchain DNS\" (BDNS). La fonction doit déterminer si une chaîne de domaine donnée est valide selon les règles suivantes :\n- Chaque sous-domaine doit être composé uniquement de caractères alphanumériques.\n- Aucun sous... | ["\nassert validate_domain(\"blockchain.dns\") == True\n", "\nassert validate_domain(\"block.chain.dns\") == True\n", "\nassert validate_domain(\"block.chain.\") == False\n", "\nassert validate_domain(\"1blockchain.dns\") == False\n", "\nassert validate_domain(\"blockchain-dns\") == False\n", "\nassert validate_domain(... |
b2119772ad67d67c7a9abb80f730d628 | [
{
"content": "On te demande d'implémenter une simulation simple de compte bancaire. Le compte bancaire doit prendre en charge les opérations suivantes :\n- `deposit(amount)` : Ajouter le montant spécifié au solde du compte.\n- `withdraw(amount)` : Soustraire le montant spécifié du solde du compte. Si le solde d... | ["\nassert BankAccount().check_balance() == 0\n", "\naccount = BankAccount(); account.deposit(100); assert account.check_balance() == 100\n", "\naccount = BankAccount(); account.deposit(100); account.withdraw(50); assert account.check_balance() == 50\n", "\naccount = BankAccount(); account.deposit(100); account.withdra... |
d39229191ba1565f582248a7f7aea4c5 | [
{
"content": "On te donne un ensemble de données représenté sous forme de liste de tuples, où chaque tuple est composé d'un identifiant unique et d'une valeur associée. Ta tâche est de mettre en œuvre une fonction `ClientSidePagination` qui effectue une pagination côté client sur cet ensemble de données. La fon... | ["\nassert ClientSidePagination([(1, 'value1'), (3, 'value3'), (2, 'value2')], 2, 1) == [(3, 'value3'), (2, 'value2')]\n", "\nassert ClientSidePagination([(1, 'value1'), (3, 'value3'), (2, 'value2')], 2, 2) == [(1, 'value1')]\n", "\nassert ClientSidePagination([(1, 'value1'), (3, 'value3'), (2, 'value2')], 1, 1) == [(3... |
59db4b4f8e386028358c94d1a64a940b | [
{
"content": "On te donne deux lignes dans un plan 2D, chacune définie par sa pente et son ordonnée à l'origine. Ta tâche est d'écrire une fonction `find_intersection` qui détermine les coordonnées du point d'intersection de ces deux lignes. La fonction doit renvoyer le point d'intersection sous la forme d'un t... | ["\nassert find_intersection((1, 2), (1, 3)) == None\n", "\nassert find_intersection((2, 3), (-0.5, 1)) == (0.4, 2.8)\n", "\nassert find_intersection((0, 5), (0, 10)) == None\n", "\nassert find_intersection((3, -1), (-1/3, 4)) == (1.5, 2.5)\n", "\nassert find_intersection((0.5, 0), (0.5, 0)) == None\n", "\nassert find_... |
c36542fa40e60d2bbd8cc4759d03bfd1 | [
{
"content": "On te donne une matrice 2D `matrix` représentant une image, où chaque cellule contient un entier de 0 à 255 représentant l'intensité de la couleur du pixel. On te donne également une liste `extent` contenant quatre entiers : `xmin`, `xmax`, `ymin` et `ymax`. Ta tâche est d'écrire une fonction `ext... | ["\nassert extract_subimage([[1, 2], [3, 4]], [0, 1, 0, 1]) == [[1, 2], [3, 4]]\n", "\nassert extract_subimage([[1, 2], [3, 4]], [-1, 2, -1, 2]) == [[1, 2], [3, 4]]\n", "\nassert extract_subimage([[1, 2], [3, 4]], [1, 1, 1, 1]) == [[4]]\n", "\nassert extract_subimage([[1, 2], [3, 4]], [2, 3, 2, 3]) == []\n", "\nassert ... |
1dc40511d2270f2cde609a38c5da50cd | [
{
"content": "On te demande d'implémenter une fonction `calculate_discounted_price` qui calcule le prix final d'un article après avoir appliqué une réduction et ajouté la taxe. La fonction accepte trois paramètres : `original_price`, `discount_rate` et `tax_rate`. Les taux de réduction et de taxe sont tous deux... | ["\nassert calculate_discounted_price(100.00, 20, 8) == 86.40\n", "\nassert calculate_discounted_price(200.00, 10, 5) == 189.00\n", "\nassert calculate_discounted_price(50.00, 0, 10) == 55.00\n", "\nassert calculate_discounted_price(150.00, 50, 0) == 75.00\n", "\nassert calculate_discounted_price(0.00, 20, 8) == 0.00\n... |
9938321b7d28990aae7c566a563a47da | [
{
"content": "On te donne une chaîne de caractères `sentence` composée de mots séparés par des espaces et contenant potentiellement des signes de ponctuation. Ta tâche est de mettre en œuvre une fonction `extract_words(sentence)` qui renvoie une liste de mots sans aucun signe de ponctuation. On suppose que les ... | ["\nassert extract_words(\"Hello, world!\") == [\"Hello\", \"world\"]\n", "\nassert extract_words(\"This is a test.\") == [\"This\", \"is\", \"a\", \"test\"]\n", "\nassert extract_words(\"No punctuation\") == [\"No\", \"punctuation\"]\n", "\nassert extract_words(\"Multiple... punctuation!!!\") == [\"Multiple\", \"punct... |
741ead0344618bcb04f0b0fe412b8853 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si les caractères de la chaîne peuvent être réorganisés pour former un palindrome. Un palindrome est une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche. Pour ce problème, considère uniquement les ca... | ["\nassert can_form_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert can_form_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert can_form_palindrome(\"No lemon, no melon\") == True\n", "\nassert can_form_palindrome(\"Hello, World!\") == False\n", "\nassert can_form_palindrome(\"racec... |
c5c95f02635bcaafc6ddf0a456dd4db7 | [
{
"content": "On te donne trois chaînes de caractères : `string_a`, `string_b` et `known_c`. La chaîne `string_a` est composée de 5 chiffres uniques, représentant un nombre à 5 chiffres, tandis que `string_b` est composée de 6 chiffres uniques, représentant un nombre à 6 chiffres. La chaîne `known_c` est un seu... | ["\nassert find_unknown_b(\"12345\", \"678901\", \"0\") == \"1\"\n", "\nassert find_unknown_b(\"12345\", \"678901\", \"1\") == \"2\"\n", "\nassert find_unknown_b(\"12345\", \"678901\", \"2\") == \"3\"\n", "\nassert find_unknown_b(\"12345\", \"678901\", \"3\") == \"4\"\n", "\nassert find_unknown_b(\"12345\", \"678901\",... |
ff367601235000c2a6b929e193e22d5f | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui simule des opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Dépôt** : Ajouter un montant spécifié au solde du compte.\n- **Retrait** : Soustraire un montant spécifié du solde du ... | ["\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount(100).check_balance() == 100\n", "\naccount = BankAccount(100)\naccount.deposit(50)\nassert account.check_balance() == 150\n", "\naccount = BankAccount(100)\naccount.withdraw(50)\nassert account.check_balance() == 50\n", "\naccount = BankAccount(100... |
0b4cb74fa454622e606463876a98d851 | [
{
"content": "On te donne un tableau d'entiers non négatifs distincts représentant les hauteurs de différentes statues dans un musée. Le conservateur du musée souhaite disposer ces statues en ligne de manière à ce que leurs hauteurs forment une séquence consécutive commençant par la statue la plus haute et se t... | ["\nassert min_statues_to_add([3, 7, 5, 9]) == 3\n", "\nassert min_statues_to_add([1, 2, 3, 4, 5]) == 0\n", "\nassert min_statues_to_add([10, 20, 30]) == 18\n", "\nassert min_statues_to_add([5]) == 0\n", "\nassert min_statues_to_add([1, 3, 6, 10]) == 6\n", "\nassert min_statues_to_add([2, 4, 6, 8, 10]) == 4\n", "\nasse... |
e144eb8a4cdde7f22a39195d4e2a0154 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver toutes les paires uniques de nombres dans `nums` qui s'additionnent pour donner `target`. Chaque paire doit être représentée sous forme de tuple, avec le plus petit nombre en premier. Retourne une liste de ces t... | ["\nassert find_pairs([2, 3, 4, 5, 6], 8) == [(2, 6), (3, 5)]\n", "\nassert find_pairs([1, 2, 3, 4, 5], 9) == [(4, 5)]\n", "\nassert find_pairs([1, 2, 3, 4, 5], 10) == []\n", "\nassert find_pairs([0, 0, 0, 0], 0) == [(0, 0)]\n", "\nassert find_pairs([1, 1, 1, 1], 2) == [(1, 1)]\n", "\nassert find_pairs([-1, 0, 1, 2], 1... |
d72aeafb687ea3f7bc62e3bc101287da | [
{
"content": "On te charge d'analyser la productivité des employés sur une période donnée. La productivité de chaque employé est enregistrée quotidiennement et stockée dans un format de dictionnaire. Les clés de ce dictionnaire représentent les dates (formatées en AAAA-MM-JJ), et les valeurs représentent les sc... | ["\nassert calculate_average_productivity({1: {'2023-01-01': 80, '2023-01-02': 90}}) == {1: 85.0}\n", "\nassert calculate_average_productivity({2: {'2023-01-01': 50, '2023-01-02': 50, '2023-01-03': 50}}) == {2: 50.0}\n", "\nassert calculate_average_productivity({3: {'2023-01-01': 100, '2023-01-02': 0}}) == {3: 50.0}\n"... |
590a63b5c6ba9bb1b4f2b223804a56d7 | [
{
"content": "Implémente une classe Python `Car` avec les spécifications suivantes :\n\n- La classe doit avoir un initialiseur `__init__` qui prend cinq paramètres : `make`, `model`, `year`, `color` et `mileage`. Ces paramètres doivent être stockés comme des variables d'instance.\n- Implémente une méthode `pain... | ["\nassert Car('Toyota', 'Corolla', 2020, 'Red', 15000).make == 'Toyota'\n", "\nassert Car('Toyota', 'Corolla', 2020, 'Red', 15000).model == 'Corolla'\n", "\nassert Car('Toyota', 'Corolla', 2020, 'Red', 15000).year == 2020\n", "\nassert Car('Toyota', 'Corolla', 2020, 'Red', 15000).color == 'Red'\n", "\nassert Car('Toyo... |
acdff7fe2db793f0771c1ca49841e378 | [
{
"content": "On te demande de traiter un fichier CSV nommé \"employees.csv\" qui contient les données des employés d'une entreprise. Le fichier CSV a les colonnes suivantes : \"Employee ID\", \"First Name\", \"Last Name\", \"Position\", \"Department\", \"Salary\". Ton objectif est d'écrire une fonction Python ... | ["\nassert get_department_salaries(\"employees.csv\") == {'Engineering': 150000.0, 'HR': 120000.0}\n", "\nassert get_department_salaries(\"employees.csv\") == {'Marketing': 180000.0, 'Sales': 210000.0}\n", "\nassert get_department_salaries(\"employees.csv\") == {}\n", "\nassert get_department_salaries(\"employees.csv\"... |
f523d0c029171f466a5d2ccc6978983a | [
{
"content": "On te donne une liste de transactions de vente. Chaque transaction est représentée comme un dictionnaire avec les clés suivantes : `\"product_name\"`, `\"quantity\"`, `\"price_per_unit\"` et `\"cost_per_unit\"`. Ta tâche est d'implémenter une fonction `calculate_profit` qui calcule le profit total... | ["\nassert calculate_profit([{\"product_name\": \"Widget\", \"quantity\": 10, \"price_per_unit\": 25, \"cost_per_unit\": 15}]) == 100\n", "\nassert calculate_profit([{\"product_name\": \"Gadget\", \"quantity\": 5, \"price_per_unit\": 50, \"cost_per_unit\": 30}]) == 100\n", "\nassert calculate_profit([{\"product_name\":... |
d1b52fcef9cce24a857ece37ec63dae0 | [
{
"content": "Conçois une application web Flask qui inclut un formulaire HTML avec un champ de saisie de texte et un bouton de soumission. Lors de la soumission du formulaire, l'application doit inverser la chaîne de caractères saisie et afficher la chaîne inversée sur une nouvelle page.\n\n**Exemple d'entrée :... | ["\nassert app.route('/').methods == ['GET']\n", "\nassert app.route('/reverse').methods == ['POST']\n", "\nassert 'text_input' in home().data.decode()\n", "\nassert 'Reverse' in home().data.decode()\n", "\nassert 'Reversed String:' in reverse_text().data.decode()\n", "\nassert reverse_text().data.decode().endswith('</... |
cfbaddf9288e602f3e2569e02ea63c98 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction `generate_permutations(lst)` qui génère toutes les permutations possibles de la liste donnée. L'ordre des permutations dans la liste de sortie n'a pas d'importance.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ ... | ["\nassert generate_permutations([1, 2, 3]) == [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]\n", "\nassert generate_permutations([1]) == [(1,)]\n", "\nassert generate_permutations([]) == [()]\n", "\nassert generate_permutations([1, 2]) == [(1, 2), (2, 1)]\n", "\nassert generate_permutations([1, 1, ... |
37057cc372d604df15cf0cb9de281fb6 | [
{
"content": "On te donne une chaîne de caractères `s` contenant des caractères alphanumériques et de la ponctuation. Ta tâche est de mettre en œuvre une fonction `find_largest_palindrome` qui trouve le plus grand palindrome dans la chaîne. Un palindrome est défini comme une séquence de caractères qui se lit de... | ["\nassert find_largest_palindrome(\"A man, a plan, a canal, Panama\") == \"amanaplanacanalpanama\"\n", "\nassert find_largest_palindrome(\"No lemon, no melon\") == \"nolemonnomelon\"\n", "\nassert find_largest_palindrome(\"Was it a car or a cat I saw?\") == \"wasitacaroracatisaw\"\n", "\nassert find_largest_palindrome... |
22115e2e98e47c61278e6a58502ecfc0 | [
{
"content": "Implémente une classe Python `Car` avec les spécifications suivantes :\n\n- La classe doit avoir les attributs suivants :\n - `make` : une chaîne de caractères représentant le fabricant de la voiture.\n - `model` : une chaîne de caractères représentant le modèle de la voiture.\n - `year` : un e... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).make == \"Toyota\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).model == \"Corolla\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).year == 2020\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).mileage == 15000\n", "\ncar = Car(\"Honda\", \... |
e24538f2eff785318540504c1f14e3d9 | [
{
"content": "On te demande d'implémenter une variante de l'algorithme de tri rapide connue sous le nom de \"Tri rapide intelligent\". Dans cette variante, le pivot est choisi comme la médiane d'un sous-ensemble aléatoire de `k` éléments de la liste. Cette approche vise à améliorer les performances du tri rapid... | ["\nassert smart_quick_sort([3, 6, 8, 10, 1, 2, 1], 3) == [1, 1, 2, 3, 6, 8, 10]\n", "\nassert smart_quick_sort([5, 3, 8, 4, 2], 2) == [2, 3, 4, 5, 8]\n", "\nassert smart_quick_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 5) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert smart_quick_sort([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3) ... |
49e33b3c39530b9895827f583c0c5acd | [
{
"content": "On te donne une chaîne d'octets `data` qui a été complétée pour être un multiple de `block_size` en utilisant un schéma de remplissage où le remplissage consiste en une séquence d'octets, chacun égal à la longueur du remplissage. Le remplissage peut inclure des octets de remplissage non nuls. Ta t... | ["\nassert byte_unpad(b'abcde\\x03\\x03\\x03', 4) == b'abcde'\n", "\nassert byte_unpad(b'abcdef\\x02\\x02', 3) == b'abcdef'\n", "\nassert byte_unpad(b'abcdefgh\\x08\\x08\\x08\\x08\\x08\\x08\\x08\\x08', 8) == b'abcdefgh'\n", "\nassert byte_unpad(b'abcdefghi\\x01', 1) == b'abcdefghi'\n", "\nassert byte_unpad(b'\\x04\\x04... |
ea5e3cb9740cd73fc7d83bf6efc18510 | [
{
"content": "On te donne une liste de nombres `vals` et deux entiers `lower` et `upper`. Ta tâche est de remapper chaque nombre dans `vals` à une nouvelle valeur dans la plage `[lower, upper]` tout en préservant les positions relatives des nombres. Si tous les nombres dans `vals` sont identiques, mappe-les tou... | ["\nassert remap_values(10, 20, [1, 2, 3]) == [10.0, 15.0, 20.0]\n", "\nassert remap_values(0, 100, [5, 10, 15]) == [0.0, 50.0, 100.0]\n", "\nassert remap_values(-10, 10, [0, 5, 10]) == [-10.0, 0.0, 10.0]\n", "\nassert remap_values(1, 1, [1, 2, 3]) == [1.0, 1.0, 1.0]\n", "\nassert remap_values(5, 5, [1, 1, 1]) == [5.0,... |
dbb4c8f1aaf832af5ba5835098acdeec | [
{
"content": "Étant donné une chaîne de caractères `s`, trouve la longueur de la plus longue sous-chaîne sans caractères répétés.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` composée de caractères ASCII.\n\n**Sortie :**\n- Un entier représentant la longueur de la plus longue sous-chaîne sans caractère... | ["\nassert length_of_longest_substring(\"abcabcbb\") == 3\n", "\nassert length_of_longest_substring(\"bbbbb\") == 1\n", "\nassert length_of_longest_substring(\"pwwkew\") == 3\n", "\nassert length_of_longest_substring(\"dvdf\") == 3\n", "\nassert length_of_longest_substring(\"anviaj\") == 5\n", "\nassert length_of_longe... |
767590706f54450a4dfe8b67dc8de6e1 | [
{
"content": "On te donne une chaîne de caractères `word` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer le nombre de consonnes distinctes dans la chaîne qui ne correspondent pas à un chiffre lorsque leurs positions dans l'alphabet sont considérées. Par exemple, 'a' est à la po... | ["\nassert count_consonants(\"hello\") == 2\n", "\nassert count_consonants(\"world\") == 3\n", "\nassert count_consonants(\"python\") == 4\n", "\nassert count_consonants(\"algorithm\") == 5\n", "\nassert count_consonants(\"abcdefghijklmnopqrstuvwxyz\") == 19\n", "\nassert count_consonants(\"aeiou\") == 0\n", "\nassert ... |
10797e7b62253cafee5359430c548f81 | [
{
"content": "On te donne un graphe non orienté avec `n` nœuds et `m` arêtes. Détermine si le graphe est bipartite. Un graphe est bipartite si ses sommets peuvent être divisés en deux ensembles disjoints tels qu'aucun deux sommets du graphe au sein du même ensemble ne soient adjacents.\n\n**Entrée :**\n- La pre... | ["\nassert is_bipartite({1: [2], 2: [1]}) == True\n", "\nassert is_bipartite({1: [2, 3], 2: [1, 4], 3: [1, 4], 4: [2, 3]}) == True\n", "\nassert is_bipartite({1: [2, 3], 2: [1, 3], 3: [1, 2]}) == False\n", "\nassert is_bipartite({1: [2], 2: [3], 3: [4], 4: []}) == True\n", "\nassert is_bipartite({1: [2], 2: [3], 3: [1]... |
b47f43a2a8d93d5ddacee8d66c5aa2ea | [
{
"content": "On te donne une liste de chaînes de caractères représentant des formats de date et d'heure. Ton objectif est de créer une fonction qui convertit chaque chaîne en un motif d'expression régulière. Les motifs doivent tenir compte des séparateurs optionnels (`-`, `/`, `.`), de la correspondance insens... | ["\nassert datetime_to_regex([\"2023-10-05 14:30:00\"]) == ['^2023[-/\\\\.]?10[-/\\\\.]?05[ T]?14:30:00$']\n", "\nassert datetime_to_regex([\"2023/10/05 14:30:00\"]) == ['^2023[-/\\\\.]?10[-/\\\\.]?05[ T]?14:30:00$']\n", "\nassert datetime_to_regex([\"2023.10.05 14:30:00\"]) == ['^2023[-/\\\\.]?10[-/\\\\.]?05[ T]?14:30... |
2ede6485d0fa90503c683fa2a8a9fa58 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères ASCII. Ta tâche est d'écrire une fonction `escape_special_characters` qui renvoie une nouvelle chaîne où tous les caractères spéciaux sont échappés en utilisant leurs séquences d'échappement respectives. Les caractères spéciaux inclue... | ["\nassert escape_special_characters(\"Hello World\") == \"Hello World\"\n", "\nassert escape_special_characters(\"Hello \\\"World\\\"\") == \"Hello \\\\\\\"World\\\\\\\"\"\n", "\nassert escape_special_characters(\"Hello\\nWorld\") == \"Hello\\\\nWorld\"\n", "\nassert escape_special_characters(\"Hello\\rWorld\") == \"H... |
e4984a638f0c87d5840201d8f507ad27 | [
{
"content": "On te donne une liste chaînée simple où chaque nœud contient un seul caractère. Ta tâche est de déterminer si la liste chaînée forme un palindrome. Implémente la fonction `is_linked_list_palindrome` qui effectue cette vérification en utilisant une complexité spatiale constante.\n\n**Entrée :**\n- ... | ["\nassert is_linked_list_palindrome(ListNode('a')) == True\n", "\nassert is_linked_list_palindrome(ListNode('a', ListNode('b'))) == False\n", "\nassert is_linked_list_palindrome(ListNode('a', ListNode('b', ListNode('a')))) == True\n", "\nassert is_linked_list_palindrome(ListNode('a', ListNode('b', ListNode('b', ListNo... |
a09b90f1e0fe1b611306ec17923f44ea | [
{
"content": "Étant donné une chaîne de caractères `s`, ta tâche est de trouver la plus longue sous-chaîne palindromique dans `s`. S'il existe plusieurs sous-chaînes de longueur maximale identique, renvoie celle qui apparaît en premier dans la chaîne.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |... | ["\nassert longest_palindromic_substring(\"racecarannakayak\") == \"racecar\"\n", "\nassert longest_palindromic_substring(\"babad\") == \"bab\"\n", "\nassert longest_palindromic_substring(\"cbbd\") == \"bb\"\n", "\nassert longest_palindromic_substring(\"a\") == \"a\"\n", "\nassert longest_palindromic_substring(\"ac\") ... |
1ec60ab21a683f8f2d9defabc6dd1a96 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `sum_of_cubes(n: int) -> int` qui calcule la somme des cubes des `n` premiers nombres naturels. Utilise une expression génératrice dans ta fonction pour accomplir cela.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^5)\n\n**S... | ["\nassert sum_of_cubes(1) == 1\n", "\nassert sum_of_cubes(2) == 9\n", "\nassert sum_of_cubes(3) == 36\n", "\nassert sum_of_cubes(4) == 100\n", "\nassert sum_of_cubes(5) == 225\n", "\nassert sum_of_cubes(0) == 0\n", "\nassert sum_of_cubes(10) == 3025\n", "\nassert sum_of_cubes(15) == 14400\n", "\nassert sum_of_cubes(20... |
cc9aa1e9dcd56392acd273694c3eff0b | [
{
"content": "On te charge d'évaluer la performance d'un test de diagnostic médical. Les résultats des tests sont classés en vrais négatifs (tn), faux négatifs (fn), vrais positifs (tp) et faux positifs (fp). La Valeur Prédictive Négative (VPN) est une mesure essentielle qui indique la proportion de patients ay... | ["\nassert calculate_npv({'tn': 100, 'fn': 50}) == 0.6666666666666666\n", "\nassert calculate_npv({'tn': 0, 'fn': 0}) == -1\n", "\nassert calculate_npv({'tn': 200, 'fn': 0}) == 1.0\n", "\nassert calculate_npv({'tn': 0, 'fn': 300}) == 0.0\n", "\nassert calculate_npv({'tn': 150, 'fn': 150}) == 0.5\n", "\nassert calculate... |
7c24f419aa9d78d870ad7669d2840a03 | [
{
"content": "On te donne deux listes 1D de nombres à virgule flottante, `list1` et `list2`, chacune de longueur `n`. Ta tâche est de mettre en œuvre une fonction `check_similarity(list1, list2, tolerance, v)` qui détermine si les éléments correspondants de `list1` et `list2` sont similaires dans une `tolerance... | ["\nassert check_similarity([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], 0.01, 0.5) == True\n", "\nassert check_similarity([1.0, 2.0, 3.0], [1.1, 2.1, 3.1], 0.15, 0.5) == True\n", "\nassert check_similarity([1.0, 2.0, 3.0], [1.2, 2.2, 3.2], 0.1, 0.5) == False\n", "\nassert check_similarity([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], 0.0, 0... |
8bfabd7467d6a8bea2c36ab4a9bac958 | [
{
"content": "On te donne un bloc de texte. Ta tâche est d'écrire une fonction Python qui extrait toutes les adresses e-mail valides du texte en utilisant des expressions régulières. La fonction doit renvoyer une liste de ces adresses e-mail. Une adresse e-mail valide est constituée d'un ou plusieurs caractères... | ["\nassert extract_emails(\"john.doe@example.com\") == [\"john.doe@example.com\"]\n", "\nassert extract_emails(\"jane_doe123@sub.example.co.uk\") == [\"jane_doe123@sub.example.co.uk\"]\n", "\nassert extract_emails(\"noemails@here\") == [\"noemails@here\"]\n", "\nassert extract_emails(\"multiple@emails.com and another@d... |
cdf6fb9579bd28785bfb5576769a7c2d | [
{
"content": "On te donne un dictionnaire où les clés sont des chaînes de caractères uniques et les valeurs sont des entiers. Ton objectif est d'implémenter une fonction `sort_dict_by_value` qui trie ce dictionnaire par ses valeurs par ordre décroissant et renvoie un nouveau dictionnaire avec les paires clé-val... | ["\nassert sort_dict_by_value({'a': 3, 'b': 1, 'c': 2}) == {'a': 3, 'c': 2, 'b': 1}\n", "\nassert sort_dict_by_value({'x': 10, 'y': 20, 'z': 5}) == {'y': 20, 'x': 10, 'z': 5}\n", "\nassert sort_dict_by_value({'apple': 5, 'banana': 2, 'cherry': 8}) == {'cherry': 8, 'apple': 5, 'banana': 2}\n", "\nassert sort_dict_by_val... |
f2959738dd98c2adc60464a80d6b59f7 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author` et `isbn`. Implémente des méthodes pour définir et obtenir les valeurs de ces attributs. De plus, implémente une méthode `is_valid_isbn` qui vérifie si l'`isbn` est un code ISBN... | ["\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\").is_valid_isbn() == True\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"9780060935467\").is_valid_isbn() == True\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", \"9780743273565\").is_valid_isbn() == True\n", "\nassert Book... |
1a6d8273a13570682a8f91e3cfa2078b | [
{
"content": "On te donne une classe `App` qui contient un objet `Database`. La classe `Database` a une méthode `get_state()` qui renvoie l'état actuel de la base de données. Ta tâche est d'implémenter une fonction `get_database_state(app)` qui récupère l'état de la base de données pour une application donnée d... | ["\nassert get_database_state(App(Database(\"Active\"))) == \"Active\"\n", "\nassert get_database_state(App(Database(\"Inactive\"))) == \"Inactive\"\n", "\nassert get_database_state(App(Database(\"\"))) == \"\"\n", "\nassert get_database_state(App(Database(\"12345\"))) == \"12345\"\n", "\nassert get_database_state(App(... |
51bf8a7fe474079c7b3e7f6a31f2d78f | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver le produit maximal de deux éléments distincts de la liste tel que le produit soit positif. Si une telle paire n'existe pas, retourne -1.\n\n**Entrée :**\n- Une liste d'entiers `nums` (1 ≤ len(nums) ≤ 10^5), où chaque entier `num` satisfait -... | ["\nassert max_positive_product([1, 2, 3, 4]) == 12\n", "\nassert max_positive_product([-1, -2, -3, -4]) == 12\n", "\nassert max_positive_product([-10, -20, 5, 15, 3]) == 225\n", "\nassert max_positive_product([1, -2, 3, -4]) == 8\n", "\nassert max_positive_product([0, 2, 3, 5]) == 15\n", "\nassert max_positive_product... |
c34b470d67d1365ddaa72d7281c2b421 | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots séparés par des espaces et contenant éventuellement de la ponctuation. Ta tâche est de mettre en œuvre une fonction `count_words` qui renvoie un dictionnaire avec chaque mot unique comme clé et le nombre de fois où il apparaît dans le te... | ["\nassert count_words(\"Hello world! Hello everyone.\") == {'hello': 2, 'world': 1, 'everyone': 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': 1, 'over': 1, 'the'... |
0ca01a334da709ca1f4d5ad19ba5ec93 | [
{
"content": "Implémente une classe `SimpleCalculator` en Python qui supporte les opérations arithmétiques de base : addition, soustraction, multiplication et division. La classe doit maintenir une valeur actuelle qui est initialement définie à 0. Implémente des méthodes pour chaque opération arithmétique qui m... | ["\nassert SimpleCalculator().add(5) == 5\n", "\nassert SimpleCalculator().subtract(5) == -5\n", "\nassert SimpleCalculator().multiply(5) == 0\n", "\nassert SimpleCalculator().divide(5) == 0\n", "\ncalc = SimpleCalculator(); calc.add(10); assert calc.subtract(3) == 7\n", "\ncalc = SimpleCalculator(); calc.add(10); calc... |
80fa9349507f160538f717ec9af7bbd5 | [
{
"content": "On te demande d'écrire un programme Python pour analyser la fréquence des mots dans un texte donné. Ton programme doit lire une chaîne de caractères représentant le contenu d'un fichier texte, compter la fréquence de chaque mot et afficher les 10 mots les plus courants ainsi que leurs fréquences. ... | ["\nassert find_most_common_words(\"hello world hello\", 2) == None\n", "\nassert find_most_common_words(\"test test test test\", 1) == None\n", "\nassert find_most_common_words(\"one two three four five six seven eight nine ten eleven\", 10) == None\n", "\nassert find_most_common_words(\"repeat repeat repeat unique\",... |
bf6cf949dea44974185b1c870a483957 | [
{
"content": "On te demande d'implémenter une fonction `convert_temperature` qui convertit une température donnée d'une unité à une autre. La fonction doit gérer les conversions entre Celsius, Fahrenheit et Kelvin. Si une unité non prise en charge est fournie, la fonction doit lever une exception `ValueError`.\... | ["\nassert convert_temperature(0, 'celsius', 'fahrenheit') == 32.0\n", "\nassert convert_temperature(32, 'fahrenheit', 'celsius') == 0.0\n", "\nassert convert_temperature(0, 'celsius', 'kelvin') == 273.15\n", "\nassert convert_temperature(273.15, 'kelvin', 'celsius') == 0.0\n", "\nassert convert_temperature(32, 'fahren... |
7bff20b64af5286575c796ca5534af89 | [
{
"content": "On te donne un ensemble de données représentant les ventes quotidiennes de divers articles dans un magasin sur une période donnée. Les données de vente de chaque article sont fournies sous forme de liste de chaînes de caractères. Ta tâche est de calculer les nouveaux niveaux de stock pour chaque a... | ["\nassert calculate_new_stock([[\"10\", \"20\", \"30\"]]) in range(22, 34)\n", "\nassert calculate_new_stock([[\"5\", \"5\", \"5\", \"5\"]]) in range(6, 7)\n", "\nassert calculate_new_stock([[\"0\", \"0\", \"0\"]]) == [0]\n", "\nassert calculate_new_stock([[\"100\", \"100\", \"100\", \"100\", \"100\"]]) in range(110, ... |
55094229203ab85d7f6354d641aaf14c | [
{
"content": "On te donne une liste d'entiers. Implémente une fonction `shift_and_merge` qui traite la liste selon les règles suivantes :\n1. Déplace tous les entiers non nuls vers la gauche, en remplissant le côté droit avec des zéros.\n2. Fusionne tous les deux entiers adjacents qui sont identiques en un seul... | ["\nassert shift_and_merge([2, 2, 0, 4, 4, 0, 8]) == [4, 8, 8, 0, 0, 0, 0]\n", "\nassert shift_and_merge([0, 0, 0, 0]) == [0, 0, 0, 0]\n", "\nassert shift_and_merge([1, 2, 3, 4]) == [1, 2, 3, 4]\n", "\nassert shift_and_merge([2, 2, 2, 2]) == [4, 4, 0, 0]\n", "\nassert shift_and_merge([0, 1, 0, 1, 0, 1]) == [2, 2, 0, 0,... |
47977ce08d196340228ad6fbba14a951 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `reverse_list_in_place` qui inverse les éléments de la liste sur place. La fonction ne doit utiliser aucune structure de données supplémentaire et ne doit renvoyer aucune valeur. La liste doit être modifiée directement.\n\n**... | ["\nassert reverse_list_in_place([1, 2, 3, 4, 5]) is None and lst == [5, 4, 3, 2, 1]\n", "\nassert reverse_list_in_place(['a', 'b', 'c']) is None and lst == ['c', 'b', 'a']\n", "\nassert reverse_list_in_place([]) is None and lst == []\n", "\nassert reverse_list_in_place([42]) is None and lst == [42]\n", "\nassert rever... |
5d6a053738f08fd2eb9f78b018b5e76d | [
{
"content": "On te donne un tableau NumPy 2D représentant une image en niveaux de gris, où chaque élément est un entier compris entre 0 et 255 inclus. Ta tâche est de mettre en œuvre une fonction `scale_image(image, factor)` qui ajuste l'intensité de chaque pixel de l'image en multipliant par un facteur donné.... | ["\nassert np.array_equal(scale_image(np.array([[100]], dtype=np.uint8), 2), np.array([[200]], dtype=np.uint8))\n", "\nassert np.array_equal(scale_image(np.array([[255]], dtype=np.uint8), 2), np.array([[255]], dtype=np.uint8))\n", "\nassert np.array_equal(scale_image(np.array([[0]], dtype=np.uint8), 0.5), np.array([[0]... |
96ccd797bc03acb9b8d737691efae47e | [
{
"content": "On te donne une fonction quadratique multivariable définie comme suit :\n\nf(x, y) = (x - 3)^2 + (y + 2)^2\n\nTa tâche est de mettre en œuvre l'algorithme de descente de gradient pour trouver la valeur minimale de cette fonction. L'algorithme doit mettre à jour itérativement les valeurs de x et y ... | ["\nassert gradient_descent_multivariable(0, 0, 0.1) < 1e-6\n", "\nassert gradient_descent_multivariable(1, 1, 0.01) < 1e-6\n", "\nassert gradient_descent_multivariable(5, -5, 0.05) < 1e-6\n", "\nassert gradient_descent_multivariable(3, -2, 0.1) < 1e-6\n", "\nassert gradient_descent_multivariable(10, 10, 0.001) < 1e-6\... |
396d531fe6965b0bf7a7abb4ef754a38 | [
{
"content": "On te donne deux matrices carrées `M` et `N` de la même dimension `d` (1 ≤ d ≤ 10), où chaque élément des matrices est un entier non négatif ne dépassant pas 9. Ta tâche est de calculer le « produit en spirale » de ces matrices. Le produit en spirale est défini comme suit :\n\n1. Convertis la matr... | ["\nassert matrix_spiral_product([[1, 2], [3, 4]], [[5, 6], [7, 8]]) == \"512281424\"\n", "\nassert matrix_spiral_product([[1, 0], [0, 1]], [[9, 8], [7, 6]]) == \"9006\"\n", "\nassert matrix_spiral_product([[1, 1], [1, 1]], [[1, 1], [1, 1]]) == \"1111\"\n", "\nassert matrix_spiral_product([[2, 3], [4, 5]], [[6, 7], [8,... |
1d2dbdc7944af0b3d9eef8f6407fde4a | [
{
"content": "On te donne un itérable contenant des entiers. Ta tâche est d'implémenter une fonction `first_even_multiple_of_seven` qui renvoie le premier nombre pair dans l'itérable qui est également un multiple de 7. Si un tel nombre n'existe pas, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Un itérab... | ["\nassert first_even([1, 3, 5, 7, 9]) == None\n", "\nassert first_even([2, 4, 6, 8, 10]) == None\n", "\nassert first_even([14, 21, 28, 35]) == 14\n", "\nassert first_even((7, 14, 21, 28)) == 14\n", "\nassert first_even({2, 4, 6, 8, 10}) == None\n", "\nassert first_even({14, 21, 28, 35}) == 14\n", "\nassert first_even(... |
fd1fd763f2a41805636cc7c5f9568083 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `filter_even_numbers` qui prend cette liste en entrée et renvoie une nouvelle liste contenant uniquement les nombres impairs de la liste originale. La fonction doit être efficace et concise.\n\n**Entrée :**\n- Une liste d'ent... | ["\nassert filter_even_numbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 3, 5, 7, 9]\n", "\nassert filter_even_numbers([2, 4, 6, 8, 10]) == []\n", "\nassert filter_even_numbers([1, 3, 5, 7, 9]) == [1, 3, 5, 7, 9]\n", "\nassert filter_even_numbers([]) == []\n", "\nassert filter_even_numbers([0, 1, 2, 3, 4]) == [1, 3]\n", ... |
87bdc534cae9662077f4d2ed354e9f26 | [
{
"content": "On te donne une chaîne de caractères `phrase` au format camelCase. Ta tâche est d'écrire une fonction `to_snake_case` qui convertit cette chaîne en format snake_case. La fonction doit gérer les chaînes avec plusieurs mots et une capitalisation mixte.\n\n**Entrée :**\n- Une seule chaîne de caractèr... | ["\nassert to_snake_case(\"thisIsACamelCasePhrase\") == \"this_is_a_camel_case_phrase\"\n", "\nassert to_snake_case(\"anotherExample\") == \"another_example\"\n", "\nassert to_snake_case(\"yetAnotherTest\") == \"yet_another_test\"\n", "\nassert to_snake_case(\"singleword\") == \"singleword\"\n", "\nassert to_snake_case... |
071be663504829d281d3f746b81a5444 | [
{
"content": "Tu es chargé d'implémenter une classe `Rectangle` qui peut calculer l'aire et le périmètre d'un rectangle étant donné ses dimensions. La classe doit avoir les attributs suivants : `length` et `width`. Implémente les méthodes `calculate_area()` et `calculate_perimeter()` pour renvoyer l'aire et le ... | ["\nassert Rectangle(5, 3).calculate_area() == 15\n", "\nassert Rectangle(5, 3).calculate_perimeter() == 16\n", "\nassert Rectangle(0, 0).calculate_area() == 0\n", "\nassert Rectangle(0, 0).calculate_perimeter() == 0\n", "\nassert Rectangle(10, 2).calculate_area() == 20\n", "\nassert Rectangle(10, 2).calculate_perimete... |
67a916ab29a628c46a3a8d5e2b5204e1 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction optimisée pour calculer la somme des carrés de ces entiers. La fonction doit être efficace en termes de complexité temporelle et spatiale.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^5), où chaque e... | ["\nassert calculate_sum_of_squares([1, 2, 3, 4]) == 30\n", "\nassert calculate_sum_of_squares([0, 0, 0, 0]) == 0\n", "\nassert calculate_sum_of_squares([-1, -2, -3, -4]) == 30\n", "\nassert calculate_sum_of_squares([10, 20, 30]) == 1400\n", "\nassert calculate_sum_of_squares([1.5, 2.5, 3.5]) == 21.25\n", "\nassert cal... |
0221c996ec6da7d2c20f621da55ec080 | [
{
"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(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Not a palindrome\") == False\n", "\nassert... |
831b90b36000850dbf90653949c9592d | [
{
"content": "Tu es chargé d'optimiser une fonction récursive qui calcule le nième nombre de Fibonacci. Pour améliorer les performances, implémente un mécanisme de mise en cache en utilisant la bibliothèque `functools` pour stocker les résultats des calculs précédents. Ta fonction doit renvoyer le nième nombre ... | ["\nassert fib(0) == 0\n", "\nassert fib(1) == 1\n", "\nassert fib(2) == 1\n", "\nassert fib(3) == 2\n", "\nassert fib(4) == 3\n", "\nassert fib(5) == 5\n", "\nassert fib(10) == 55\n", "\nassert fib(20) == 6765\n", "\nassert fib(30) == 832040\n", "\nassert fib(50) == 12586269025\n"] |
aee5a5c39e4d3477c148572145151e16 | [
{
"content": "On te demande d'implémenter une classe Python nommée `DatabaseConnection` qui gère les opérations de base de données SQLite. La classe doit prendre en charge la connexion à une base de données, l'exécution de requêtes SQL et la fermeture de la connexion. La classe doit gérer les exceptions et four... | ["\nassert isinstance(DatabaseConnection('example.db'), DatabaseConnection)\n", "\nassert DatabaseConnection('example.db').db_path == 'example.db'\n", "\ndb = DatabaseConnection(':memory:')\ndb.connect()\nassert db.connection is not None\n", "\ndb = DatabaseConnection(':memory:')\ndb.connect()\ndb.execute_query('CREATE... |
07209e9a9e7f3aa25b6fde070b4565d7 | [
{
"content": "On te demande d'implémenter une fonction `sanitize_input(input_str)` qui traite une chaîne de caractères donnée selon des règles spécifiques. La fonction doit gérer les parenthèses imbriquées en inversant leur contenu, échapper les parenthèses et encapsuler la chaîne dans un appel de fonction `q()... | ["\nassert sanitize_input(\"hello world\") == 'q(\"hello world\")'\n", "\nassert sanitize_input(\"hello-world\") == \"hello-world\"\n", "\nassert sanitize_input(\"hello(world)\") == 'q(\"\\\\hello\\\\world\\\\)\")'\n", "\nassert sanitize_input(\"hello-(world)\") == 'q(\"\\\\hello-\\\\)dlrow\\\\(\")'\n", "\nassert sanit... |
9f77b617ff20521330f05211e3be4165 | [
{
"content": "Tu es chargé d'implémenter une fonction `calculate_discount` 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`. Les deux paramètres doivent être des nombres non négatifs. Si l'un des param... | ["\nassert calculate_discount(100, 10) == 90.0\n", "\nassert calculate_discount(200, 0) == 200.0\n", "\nassert calculate_discount(0, 20) == 0.0\n", "\nassert calculate_discount(50, 50) == 25.0\n", "\nassert calculate_discount(150, 25) == 112.5\n", "\nassert calculate_discount(1000, 100) == 0.0\n", "\nassert calculate_d... |
7e25d1ff0b635954f97e99a1a4f06d9a | [
{
"content": "On te demande d'implémenter la fonction `get_next_batch` pour une classe de chargeur de données personnalisée, `DataLoader`. La classe `DataLoader` charge des lots d'images et leurs données de vérité terrain (GT) correspondantes, qui peuvent inclure des cartes normales, des cartes de profondeur et... | ["\nassert get_next_batch(DataLoader([(1, 'a'), (2, 'b')])) == ([1], ['a'])\n", "\nassert get_next_batch(DataLoader([(1, 'a'), (2, 'b'), (3, 'c')])) == ([1], ['a'])\n", "\nassert get_next_batch(DataLoader([])) == ([], [])\n", "\nassert get_next_batch(DataLoader([(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')])) == ([1], ['a'])... |
d54fbc36578e4844530ee3727e367191 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui inverse la chaîne sans utiliser de découpage ou de fonctions ou méthodes d'inversion intégrées. Implémente la fonction `reverse_string(s)` et renvoie la chaîne inversée.\n\n**Exemple d'entrée :**\n```\n\"Hello\"\n```\... | ["\nassert reverse_string(\"Hello\") == \"olleH\"\n", "\nassert reverse_string(\"Python\") == \"nohtyP\"\n", "\nassert reverse_string(\"12345\") == \"54321\"\n", "\nassert reverse_string(\"!@#$%\") == \"%$#@!\"\n", "\nassert reverse_string(\"a\") == \"a\"\n", "\nassert reverse_string(\"\") == \"\"\n", "\nassert reverse... |
d72298dd753af9c70985e29ce24aa90e | [
{
"content": "On te donne une chaîne JSON bien formée `json_string` composée de types de données JSON de base : chaînes de caractères, nombres, tableaux et objets. Ta tâche est de mettre en œuvre une fonction `parse_json(json_string)` qui convertit cette chaîne JSON en un dictionnaire Python.\n\n**Entrée :**\n-... | ["\nassert parse_json('{\"name\": \"John\", \"age\": 30}') == {\"name\": \"John\", \"age\": 30}\n", "\nassert parse_json('{\"fruits\": [\"apple\", \"banana\", \"cherry\"]}') == {\"fruits\": [\"apple\", \"banana\", \"cherry\"]}\n", "\nassert parse_json('{\"person\": {\"name\": \"Alice\", \"age\": 25}}') == {\"person\": ... |
c654c5b0aaf6c77cef71a0a2e4e2ceea | [
{
"content": "On te donne une chaîne de caractères `sentence`. Ta tâche est de mettre en œuvre une fonction `convert_to_snake_case` qui transforme la chaîne en format snake_case. En snake_case, tous les espaces et la ponctuation sont supprimés, et tous les mots sont convertis en minuscules, séparés par des tire... | ["\nassert convert_to_snake_case(\"This is an example sentence, with punctuation!\") == \"this_is_an_example_sentence_with_punctuation\"\n", "\nassert convert_to_snake_case(\"Hello World!\") == \"hello_world\"\n", "\nassert convert_to_snake_case(\"Python's syntax is clean.\") == \"pythons_syntax_is_clean\"\n", "\nasser... |
be7c6fdc47e355f6be105275ea0bec62 | [
{
"content": "On te demande d'implémenter une variante de l'algorithme de Kiefer-Gold qui utilise la méthode de recherche de Fibonacci pour trouver la taille de pas optimale dans une direction donnée. La fonction `f` peut renvoyer NaN pour certaines entrées, et ton algorithme doit traiter les évaluations NaN co... | ["\nassert fibonacci_search(lambda x: x[0]**2, np.array([0.0]), np.array([1.0]), 10.0) == 0.0\n", "\nassert fibonacci_search(lambda x: x[0]**2, np.array([1.0]), np.array([-1.0]), 10.0) == 1.0\n", "\nassert fibonacci_search(lambda x: x[0]**2 + x[1]**2, np.array([0.0, 0.0]), np.array([1.0, 1.0]), 10.0) == 0.0\n", "\nasse... |
fb898ef65b5edac36ccb0779691a1453 | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `k`. Ta tâche est d'écrire une fonction `find_substrings_of_length_k(s, k)` qui renvoie une liste de toutes les sous-chaînes uniques de `s` ayant une longueur exactement égale à `k`. Si `k` est supérieur à la longueur de `s` ou inférieur à 1, r... | ["\nassert find_substrings_of_length_k(\"abcabc\", 3) == ['abc', 'bca', 'cab']\n", "\nassert find_substrings_of_length_k(\"aaaa\", 2) == ['aa']\n", "\nassert find_substrings_of_length_k(\"hello\", 1) == ['h', 'e', 'l', 'o']\n", "\nassert find_substrings_of_length_k(\"hello\", 0) == []\n", "\nassert find_substrings_of_l... |
80be5403d2bc06decc51550e8b6476d7 | [
{
"content": "On te donne un fichier CSV contenant des données sur des individus, notamment leur nom, leur âge, leur genre, leur région et leurs revenus. Ta tâche est d'écrire un script Python qui lit ce fichier CSV et calcule le revenu moyen pour chaque région. Le fichier CSV a les colonnes suivantes : 'Name',... | ["\nassert calculate_average_income_by_region('test_data_1.csv') == None\n", "\nassert calculate_average_income_by_region('test_data_2.csv') == None\n", "\nassert calculate_average_income_by_region('empty_data.csv') == None\n", "\nassert calculate_average_income_by_region('single_entry.csv') == None\n", "\nassert calcu... |
8a63b2f2cbe83e01d407724761710ec2 | [
{
"content": "Tu es un généticien qui travaille sur une nouvelle variété de roses. La couleur de chaque rose est déterminée par plusieurs gènes, chacun contribuant indépendamment à la couleur finale. Chaque plante parent a une composition génétique unique décrite par des distributions de probabilité pour chaque... | ["\nassert simulate_rose_colors([rv_discrete(name='gene1_parent1', values=([0, 1, 2, 3], [1, 0, 0, 0]))], [rv_discrete(name='gene1_parent2', values=([0, 1, 2, 3], [1, 0, 0, 0]))], 1) == [0]\n", "\nassert simulate_rose_colors([rv_discrete(name='gene1_parent1', values=([0, 1, 2, 3], [0, 1, 0, 0]))], [rv_discrete(name='ge... |
27b988d7f8949d63bfb10636c87d3c98 | [
{
"content": "On te donne une liste d'entiers et un entier positif `n`. Ta tâche est d'écrire une fonction récursive qui génère toutes les combinaisons possibles de `n` éléments de la liste donnée. L'ordre des combinaisons dans la sortie n'a pas d'importance.\n\n**Entrée :**\n- Une liste d'entiers `lst` et un e... | ["\nassert combinations([1, 2, 3], 2) == [[1, 2], [1, 3], [2, 3]]\n", "\nassert combinations([1, 2, 3, 4], 2) == [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n", "\nassert combinations([1, 2, 3], 3) == [[1, 2, 3]]\n", "\nassert combinations([1, 2, 3], 0) == [[]]\n", "\nassert combinations([], 2) == []\n", "\nassert... |
3d6911ace57d3ae80db866fe0f97f47b | [
{
"content": "Implémente une classe nommée `Car` avec les spécifications suivantes :\n- Attributs : `make` (chaîne de caractères), `model` (chaîne de caractères), `year` (entier) et `mileage` (entier).\n- Méthodes :\n - `get_full_description` : Retourne une chaîne de caractères au format \"{year} {make} {model... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).get_full_description() == \"2020 Toyota Corolla with 15000 miles\"\n", "\nassert Car(\"Honda\", \"Civic\", 2018, 20000).get_full_description() == \"2018 Honda Civic with 20000 miles\"\n", "\nassert Car(\"Ford\", \"Mustang\", 2021, 5000).get_full_description() == \"20... |
7eca0fcdcccc8a3ef7ca45102efe7db2 | [
{
"content": "On te demande d'écrire un programme Python qui effectue une opération spécifique de gestion de fichiers. Étant donné un chemin de répertoire, ton programme doit parcourir récursivement le répertoire et ses sous-répertoires, en identifiant tous les fichiers avec une extension `.tmp`. Pour chaque fi... | ["\ntest_dir = setup_test_directory()\nwith patch('builtins.input', return_value='y'):\n delete_tmp_files(test_dir)\nassert not os.path.exists(os.path.join(test_dir, \"file1.tmp\"))\nassert not os.path.exists(os.path.join(test_dir, \"file2.tmp\"))\nassert not os.path.exists(os.path.join(test_dir, \"subdir\", \"file3... |
b428715d4f2804e08ef9a98e0cbc6a3f | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `get_alternate_elements` qui extrait chaque élément alterné de la liste, en commençant par le premier élément. La fonction doit être optimisée pour gérer efficacement les très grandes listes.\n\n**Entrée :**\n- Une liste d'en... | ["\nassert get_alternate_elements([1, 2, 3, 4, 5]) == [1, 3, 5]\n", "\nassert get_alternate_elements([10, 20, 30, 40, 50, 60]) == [10, 30, 50]\n", "\nassert get_alternate_elements([7, 8, 9]) == [7, 9]\n", "\nassert get_alternate_elements([1]) == [1]\n", "\nassert get_alternate_elements([]) == []\n", "\nassert get_alter... |
e599f25b1363ac6d7fcdc836ee179261 | [
{
"content": "On te demande d'implémenter une classe `Library` pour gérer une collection de livres. Chaque livre est identifié de manière unique par un numéro ISBN et est associé à un titre et à un auteur. Ta classe `Library` doit prendre en charge les opérations suivantes :\n\n- `add_book(isbn, title, author)`... | ["\nassert Library().list_books() == []\n", "\nassert Library().find_book(\"978-3-16-148410-0\") == None\n", "\nlib = Library(); lib.add_book(\"978-3-16-148410-0\", \"Python Programming\", \"John Doe\"); assert lib.find_book(\"978-3-16-148410-0\") == (\"Python Programming\", \"John Doe\")\n", "\nlib = Library(); lib.ad... |
94b85c906d360f896af30a4b9ab8354e | [
{
"content": "On te donne la tâche de concevoir une fonction qui construit un chemin de fichier unique et sécurisé pour les fichiers journaux quotidiens. La fonction doit générer un UUID cryptographiquement sécurisé pour assurer l'unicité de chaque fichier journal. Le chemin du fichier doit inclure un horodatag... | ["\nassert generate_secure_log_path(\"./logs\").startswith(\"./logs/log_\")\n", "\nassert len(generate_secure_log_path(\"./logs\").split(\"_\")[2]) == 36 # UUID length\n", "\nassert generate_secure_log_path(\"./logs\").endswith(\".log\")\n", "\nassert generate_secure_log_path(\"./logs\") != generate_secure_log_path(\"... |
55f8201782c942f348676620036a1853 | [
{
"content": "On te demande d'implémenter une fonction `check_server_status` pour un outil de surveillance réseau. La fonction doit tenter de se connecter à un serveur en utilisant une URL et une valeur de délai d'attente données. Si la connexion échoue, elle doit réessayer jusqu'à un nombre de fois spécifié. L... | ["\nassert check_server_status(\"http://example.com\", 5, 3) == True\n", "\nassert check_server_status(\"http://nonexistentwebsite123456789.com\", 5, 3) == False\n", "\nassert check_server_status(\"http://httpbin.org/status/200\", 5, 1) == True\n", "\nassert check_server_status(\"http://httpbin.org/status/500\", 5, 3) ... |
666dccfeeb5820fc5dc7dda0f4e24fd7 | [
{
"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 'x' in Nixon\") == 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(\"Able was I, I saw Elba\") == True\n... |
e2c2798e47210827e83ea8b68cc9a94d | [
{
"content": "On te demande d'implémenter une fonction `render_template(template_name, context)` pour une application web. Cette fonction doit lire un modèle HTML à partir d'un fichier spécifié par `template_name` et remplacer les espaces réservés dans le modèle par les valeurs du dictionnaire `context`. Les es... | ["\nassert render_template(\"greeting.html\", {\"name\": \"Alice\", \"greeting\": \"Hello\"}) == \"Hello, Alice!\"\n", "\nassert render_template(\"farewell.html\", {\"name\": \"Bob\", \"farewell\": \"Goodbye\"}) == \"Goodbye, Bob!\"\n", "\nassert render_template(\"empty.html\", {}) == \"\"\n", "\nassert render_template... |
176849fd4d03101d13bc6208381a2a7c | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `count_words` qui traite cette chaîne et renvoie une liste de tuples. Chaque tuple doit consister en un mot et sa fréquence dans le texte, triés par fréquence par or... | ["\nassert count_words(\"Hello, world! Hello, universe.\") == [('hello', 2), ('world', 1), ('universe', 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', ... |
b8ed110c6cb06b047bf9ed2e7ab8afb2 | [
{
"content": "On te demande d'écrire un programme efficace pour calculer le nième nombre de Fibonacci. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Pour optimiser ta solution, implémente la mémoïsation afin de stocker les nombres de Fibonacci déjà calc... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(30) == 832040\n", "\nassert fibonacci... |
404c4ab4a45b616a96d8c6abeff7d888 | [
{
"content": "On te donne une chaîne de caractères `s` contenant plusieurs mots séparés par n'importe quel caractère d'espacement (espaces, tabulations, sauts de ligne). Ta tâche est de mettre en œuvre une fonction `word_counter` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les mots unique... | ["\nassert word_counter(\"Hello world\") == {'hello': 1, 'world': 1}\n", "\nassert word_counter(\"Hello hello world\") == {'hello': 2, 'world': 1}\n", "\nassert word_counter(\"Hello, hello world!\") == {'hello,': 1, 'hello': 1, 'world!': 1}\n", "\nassert word_counter(\" Leading and trailing spaces \") == {'leading'... |
f074a6f18911f8006d681a9869133544 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction qui trie cette liste en utilisant l'algorithme Quicksort. La fonction doit renvoyer une nouvelle liste avec les entiers triés par ordre croissant.\n\n**Entrée :**\n- Une liste d'entiers `arr` (1 ≤ len(arr) ≤ 10^3), où chaque ... | ["\nassert quicksort([3, 6, 8, 3, 5, 9, 1]) == [1, 3, 3, 5, 6, 8, 9]\n", "\nassert quicksort([10, 7, 8, 9, 1, 5]) == [1, 5, 7, 8, 9, 10]\n", "\nassert quicksort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert quicksort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert quicksort([]) == []\n", "\nassert quicksort([1]) ... |
9d3cd82e88fb075ea43308314285460a | [
{
"content": "On te demande d'implémenter une fonction `timestamp_to_djd(timestamp)` qui convertit un timestamp Unix en nombre de jours écoulés depuis le 31/12/1899 12:00 UTC, également connu sous le nom de \"jours juliens de Dublin\" (DJD). Un timestamp Unix est défini comme le nombre de secondes écoulées depu... | ["\nassert timestamp_to_djd(0) == 25569.0\n", "\nassert timestamp_to_djd(86400) == 25570.0\n", "\nassert timestamp_to_djd(1609459200) == 44197.0\n", "\nassert timestamp_to_djd(946684800) == 38250.0\n", "\nassert timestamp_to_djd(1577836800) == 43831.0\n", "\nassert timestamp_to_djd(1262304000) == 40172.0\n", "\nassert ... |
b92f1818cc3df59fdc03ce58c07e2457 | [
{
"content": "On te donne la tâche de développer une fonction Python nommée `generate_product_report` qui construit un rapport HTML à partir d'un DataFrame fourni. Le DataFrame inclut des informations sur les produits, telles que leurs noms, leurs descriptions et leurs URL d'images.\n\nLa fonction doit générer ... | ["\nassert \"Product Report\" in generate_product_report(example_df)\n", "\nassert \"<h3>Product A</h3>\" in generate_product_report(example_df)\n", "\nassert \"<h4>Description of Product B</h4>\" in generate_product_report(example_df)\n", "\nassert 'background-color: lightblue;' in generate_product_report(example_df)\... |
20f9ba93ddefecad479ed5c321d21501 | [
{
"content": "On te donne deux chaînes binaires, `binary_string_1` et `binary_string_2`, chacune consistant uniquement de '0' et de '1'. Ta tâche est de calculer le produit scalaire de ces deux chaînes binaires modulo 2. La fonction doit gérer efficacement les longueurs d'entrée jusqu'à \\(10^6\\).\n\n**Entrée ... | ["\nassert dot_product_mod2(\"1101\", \"1011\") == 0\n", "\nassert dot_product_mod2(\"1111\", \"1111\") == 0\n", "\nassert dot_product_mod2(\"0000\", \"1111\") == 0\n", "\nassert dot_product_mod2(\"1010\", \"0101\") == 0\n", "\nassert dot_product_mod2(\"1100\", \"1100\") == 0\n", "\nassert dot_product_mod2(\"1110\", \"... |
960cba322b351ebe530010ea9aeb1126 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction qui trie cette liste par ordre décroissant en utilisant un algorithme de tri autre que les fonctions intégrées `sort()` ou `sorted()` de Python. Ton implémentation doit être efficace et correcte pour les listes contenant ... | ["\nassert bubble_sort_descending([5, 3, 9, 1, 10]) == [10, 9, 5, 3, 1]\n", "\nassert bubble_sort_descending([1, 2, 3, 4, 5]) == [5, 4, 3, 2, 1]\n", "\nassert bubble_sort_descending([10, 9, 8, 7, 6]) == [10, 9, 8, 7, 6]\n", "\nassert bubble_sort_descending([3, 3, 3, 3, 3]) == [3, 3, 3, 3, 3]\n", "\nassert bubble_sort_d... |
8c3909520049b83078fcd5e32fa57f7d | [
{
"content": "On te donne un chemin de fichier sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction `resolve_path(path=\"\")` qui traite ce chemin en développant tous les chemins relatifs et les tildes (`~`) en leurs chemins absolus. La fonction doit également résoudre tous les liens symboliqu... | ["\nassert resolve_path(\"~\") == os.path.expanduser(\"~\")\n", "\nassert resolve_path(\"~/Documents\") == os.path.expanduser(\"~/Documents\")\n", "\nassert resolve_path(\".\") == os.path.abspath(\".\")\n", "\nassert resolve_path(\"./test\") == os.path.abspath(\"./test\")\n", "\nassert resolve_path(\"\") == os.path.abs... |
c94a4f87a9c9dce301e8340b63a660fb | [
{
"content": "Tu dois implémenter une fonction nommée `generate_greeting` qui construit un message de salutation personnalisé en fonction du nom d'utilisateur fourni. La fonction doit gérer les cas où le nom d'utilisateur n'est pas fourni en renvoyant une salutation générique.\n\n**Signature de la fonction :**\... | ["\nassert generate_greeting(None) == {\"message\": \"Welcome to our platform!\"}\n", "\nassert generate_greeting(\"bob\") == {\"message\": \"Welcome to our platform, Bob!\"}\n", "\nassert generate_greeting(\"ALICE\") == {\"message\": \"Welcome to our platform, ALICE!\"}\n", "\nassert generate_greeting(\"charlie\") == ... |
c0aedc46bdcadd1edc27345010a16fab | [
{
"content": "On te donne une liste d'identifiants de produits, où chaque identifiant de produit est une chaîne de quatre caractères. Les trois premiers caractères sont alphanumériques, et le dernier caractère est un seul chiffre. Ta tâche est de catégoriser ces identifiants de produits en groupes en fonction d... | ["\nassert categorize_product_ids(['A1B23', 'C3D45', 'A1B26', 'E5F78', 'C3D49']) == ({'3': {'product_ids': ['A1B23', 'C3D45'], 'prefix_counts': {'A1B': 1, 'C3D': 2}}, '6': {'product_ids': ['A1B26'], 'prefix_counts': {'A1B': 1}}, '5': {'product_ids': ['E5F78', 'C3D49'], 'prefix_counts': {'E5F': 1, 'C3D': 1}}}, ['3', '6'... |
f4cd97d38c4e9c8a78affc045dc00382 | [
{
"content": "Implémente une classe `BasicCalculator` en Python qui prend en charge les opérations arithmétiques de base : l'addition, la soustraction, la multiplication et la division. La calculatrice doit maintenir un résultat courant qui peut être mis à jour à chaque opération. De plus, la classe doit fourni... | ["\nassert BasicCalculator().add(5) == 5\n", "\nassert BasicCalculator().subtract(5) == -5\n", "\nassert BasicCalculator().multiply(5) == 0\n", "\nassert BasicCalculator().divide(5) == 0\n", "\nassert BasicCalculator().add(10).subtract(2).multiply(3).divide(4) == 6.0\n", "\nassert BasicCalculator().add(10).clear() == 0... |
fc964a7fd1dab2e154c598b55e9b3ebe | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `find_largest_number` qui détermine le plus grand entier de la liste sans utiliser de fonctions intégrées telles que `max()` ou `min()`. La fonction doit parcourir la liste et utiliser des structures de contrôle pour trou... | ["\nassert find_largest_number([1, 2, 3, 4, 5]) == 5\n", "\nassert find_largest_number([5, 4, 3, 2, 1]) == 5\n", "\nassert find_largest_number([100]) == 100\n", "\nassert find_largest_number([-1, -2, -3, -4, -5]) == -1\n", "\nassert find_largest_number([0, 0, 0, 0, 0]) == 0\n", "\nassert find_largest_number([10, 10, 10... |
ba44e24d2db842afc24ee6645e078bc6 | [
{
"content": "On te donne un entier `n`. Ta tâche est de déterminer si `n` est une puissance première. Une puissance première est définie comme un nombre qui peut être exprimé sous la forme `p^k`, où `p` est un nombre premier et `k` est un entier positif. Par exemple, 8 est une puissance première car il peut êt... | ["\nassert is_prime_power(8) == True\n", "\nassert is_prime_power(27) == True\n", "\nassert is_prime_power(6) == False\n", "\nassert is_prime_power(2) == True\n", "\nassert is_prime_power(1) == False\n", "\nassert is_prime_power(-8) == False\n", "\nassert is_prime_power(0) == False\n", "\nassert is_prime_power(16.0) ==... |
aa9939195ff8c87371f4716450d3e36f | [
{
"content": "On te donne une liste de séquences d'ADN, chacune représentée comme une liste de caractères. Chaque caractère est soit une nucléotide ('A', 'C', 'G', 'T'), soit un trou ('-'). Toutes les séquences ont la même longueur. Ta tâche est de calculer le nombre total de différences par paires entre toutes... | ["\nassert calculate_pairwise_differences([['A', 'T', 'C', '-'], ['A', '-', 'C', 'G'], ['G', 'T', 'A', 'C'], ['A', 'T', '-', 'C']]) == (6, 1.5)\n", "\nassert calculate_pairwise_differences([['A', 'A', 'A'], ['A', 'A', 'A'], ['A', 'A', 'A']]) == (0, 0.0)\n", "\nassert calculate_pairwise_differences([['A', 'C', 'G', 'T']... |
1554f05f80fc96dc27dfaf2a0860f7e8 | [
{
"content": "On te demande d'implémenter un système de compte bancaire simple en Python. Ton système doit prendre en charge les opérations suivantes :\n\n1. **Dépôt** : Ajouter un montant spécifié au solde du compte. Le montant doit être positif.\n2. **Retrait** : Soustraire un montant spécifié du solde du com... | ["\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount(100).check_balance() == 100\n", "\nassert BankAccount().get_transaction_history() == [\"Checked balance: 0\"]\n", "\nassert BankAccount(100).get_transaction_history() == [\"Checked balance: 100\"]\n", "\naccount = BankAccount(); account.deposit(50)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.