id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
290af19b8e17b771d8d7e9b77932b419 | [
{
"content": "On te donne un fichier CSV nommé `products.csv` contenant une liste de produits avec leurs prix respectifs. Chaque ligne du fichier CSV se compose de trois colonnes : `product_id`, `product_name` et `price`. Ta tâche est de déterminer le produit ayant le prix le plus élevé et d'afficher son nom ai... | ["\nassert find_most_expensive_product('test1.csv') == None # Assuming test1.csv contains: product_id,product_name,price\\n1,Apple,1.20\\n2,Banana,2.50\\n3,Cherry,3.10\n", "\nassert find_most_expensive_product('test2.csv') == None # Assuming test2.csv contains: product_id,product_name,price\\n1,Apple,1.20\\n2,Banana,... |
f10bf938df7601736ff806b9849a4e43 | [
{
"content": "On te donne deux tableaux, `x` et `xx`. Le tableau `x` est un tableau trié de nombres réels distincts, et `xx` est un tableau de nombres réels. Ta tâche est de mettre en œuvre une fonction qui effectue une interpolation linéaire par morceaux sur le tableau `x` et l'évalue aux points du tableau `xx... | ["\nassert piecewise_linear_interpolation([1.0, 2.0, 3.0, 5.0], [0.0]) == [(0.0, None)]\n", "\nassert piecewise_linear_interpolation([1.0, 2.0, 3.0, 5.0], [1.0]) == [(1.0, 1.0)]\n", "\nassert piecewise_linear_interpolation([1.0, 2.0, 3.0, 5.0], [1.5]) == [(1.5, 1.5)]\n", "\nassert piecewise_linear_interpolation([1.0, 2... |
cc102cd682773f554d1e0a80676c4c29 | [
{
"content": "On te donne un dictionnaire `input_dict` où les clés sont des chaînes de caractères et les valeurs peuvent être des chaînes de caractères, `None`, ou des listes. Ta tâche est d'écrire une fonction `remove_empty_entries` qui supprime toutes les entrées avec des valeurs vides du dictionnaire. Une va... | ["\nassert remove_empty_entries({\"name\": \"Alice\", \"age\": \"\", \"city\": \"Wonderland\"}) == {\"name\": \"Alice\", \"city\": \"Wonderland\"}\n", "\nassert remove_empty_entries({\"a\": 1, \"b\": None, \"c\": 2, \"d\": []}) == {\"a\": 1, \"c\": 2}\n", "\nassert remove_empty_entries({\"key1\": \"value1\", \"key2\": ... |
40dea58559e89eae2a3344378f7f7b1f | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation** : Créer un nouveau compte bancaire avec un numéro de compte, le nom du titulaire et un solde facultatif (par défaut 0).\n- **Dépôt** : Ajouter un mont... | ["\nassert account.balance == 1300\n", "\nassert account.account_number == \"123456789\"\n", "\nassert account.owner == \"John Doe\"\n", "\naccount.deposit(0); assert account.balance == 1300\n", "\naccount.deposit(-100); assert account.balance == 1300\n", "\naccount.withdraw(0); assert account.balance == 1300\n", "\nac... |
02c24a569d1a4c731b6e4205727106f8 | [
{
"content": "On te demande d'écrire un programme qui lit un fichier de configuration JSON et met à jour une valeur spécifique dans cette configuration. Ton programme doit demander à l'utilisateur d'entrer le chemin vers le fichier de configuration, la clé à mettre à jour et la nouvelle valeur. Le programme doi... | ["\nconfig_data = {\"name\": \"John\", \"age\": 30}\nfile_path = \"test_config.json\"\nwith open(file_path, 'w') as file:\n json.dump(config_data, file)\nupdate_config(file_path, \"age\", 31)\nwith open(file_path, 'r') as file:\n updated_config = json.load(file)\nassert updated_config[\"age\"] == 31\nos.remove(fi... |
2e9b92fd2b556d324a7e9b070aba59cd | [
{
"content": "On te donne une chaîne de caractères qui représente un objet JSON. Ta tâche est d'écrire une fonction Python qui convertit cette chaîne en un dictionnaire Python. Si la chaîne d'entrée n'est pas un objet JSON valide, ta fonction doit lever une exception `ValueError` avec un message indiquant que l... | ["\nassert json_to_dict('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}') == {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}\n", "\nassert json_to_dict('{\"key\": \"value\"}') == {\"key\": \"value\"}\n", "\nassert json_to_dict('{}') == {}\n", "\nassert json_to_dict('{\"numbers\": [1, 2, 3, 4]}') ==... |
255143558e1aca7e7c8e84ea5a8ce20a | [
{
"content": "On te demande d'implémenter une classe `BinarySearchTree` qui prend en charge les opérations suivantes :\n\n- `insert(value: int)` : Insère une nouvelle valeur dans l'arbre binaire de recherche.\n- `delete(value: int)` : Supprime une valeur de l'arbre binaire de recherche.\n- `search(value: int) -... | ["\nassert BinarySearchTree().inorder_traversal() == []\n", "\nassert BinarySearchTree().search(10) == False\n", "\nbst = BinarySearchTree()\nbst.insert(10)\nassert bst.search(10) == True\n", "\nbst = BinarySearchTree()\nbst.insert(10)\nbst.insert(5)\nbst.insert(15)\nassert bst.inorder_traversal() == [5, 10, 15]\n", "\... |
a917b2d63f167c9a18bd9563d3cf576d | [
{
"content": "On te donne un fichier sérialisé contenant un dictionnaire de livres. Chaque livre est représenté comme un dictionnaire avec les clés suivantes : 'title', 'author', 'pages' et 'language'. La clé 'pages' contient une liste d'entiers représentant les numéros de page utilisés dans le livre. Ta tâche ... | ["\nassert read_book_data('test1.pkl') == {'Book One': {'title': 'Book One', 'author': 'Author One', 'pages': [1, 2, 3], 'language': 'English'}}\n", "\nassert read_book_data('test2.pkl') == {'Book Two': {'title': 'Book Two', 'author': 'Author Two', 'pages': [4, 5, 6], 'language': 'Spanish'}, 'Book Three': {'title': 'Bo... |
7e97dff8cccb048cb7e9e07b639aa816 | [
{
"content": "On te donne une liste de `n` nombres réels non négatifs représentant les probabilités de différents événements. En raison d'une erreur dans le processus de collecte des données, la somme de ces probabilités peut ne pas être égale à 1. Ta tâche est de mettre en œuvre la fonction `probability_deviat... | ["\nassert probability_deviation([0.1, 0.2, 0.3, 0.4]) == 0.0\n", "\nassert probability_deviation([0.1, 0.2, 0.3, 0.5]) == 0.1\n", "\nassert probability_deviation([0.1, 0.1, 0.3, 0.5]) == -1\n", "\nassert probability_deviation([0.25, 0.25, 0.25, 0.25]) == -1\n", "\nassert probability_deviation([0.5, 0.2, 0.15, 0.15]) =... |
e647c82716feb382cf2657304f01ab4b | [
{
"content": "On te donne un fichier CSV contenant des données de capteurs avec différentes colonnes. Ta tâche est de mettre en œuvre une fonction qui lit le fichier CSV, extrait les données d'une colonne spécifiée et applique une fonction de transformation donnée à chaque élément de cette colonne. La fonction ... | ["\nassert transform_column_data('test_data.csv', 'sensor1', lambda x: x + 1) == [2, 3, 4]\n", "\nassert transform_column_data('test_data.csv', 'sensor2', lambda x: x * 2) == [4, 6, 8]\n", "\nassert transform_column_data('test_data.csv', 'sensor3', lambda x: x - 1) == [0, 1, 2]\n", "\nassert transform_column_data('test... |
08b67755894cd6f8c3cd3abec55dc55f | [
{
"content": "On te donne une liste de clauses, où chaque clause est une liste de littéraux. Chaque littéral est représenté comme un objet avec les attributs suivants : `variable_name`, `decision_level` et `assignment`. Ta tâche est de mettre en œuvre une fonction `check_clause_satisfaction(clause, first_uip)` ... | ["\nassert check_clause_satisfaction([{\"variable_name\": \"x\", \"decision_level\": 1, \"assignment\": True}], {\"variable_name\": \"x\", \"decision_level\": 1, \"assignment\": True}) == True\n", "\nassert check_clause_satisfaction([{\"variable_name\": \"x\", \"decision_level\": 1, \"assignment\": True}, {\"variable_n... |
191f14b38381f51c2ca20249ac477c81 | [
{
"content": "On te donne une matrice carrée `M` de taille `N x N`, où chaque élément `M[i][j]` est un entier unique représentant l'identifiant d'une personne. Chaque ligne de la matrice représente un groupe de personnes, et chaque colonne représente une caractéristique unique partagée par les personnes de cett... | ["\nassert transpose_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [[1, 4, 7], [2, 5, 8], [3, 6, 9]]\n", "\nassert transpose_matrix([[10, 20], [30, 40]]) == [[10, 30], [20, 40]]\n", "\nassert transpose_matrix([[1]]) == [[1]]\n", "\nassert transpose_matrix([[1, 2], [3, 4], [5, 6]]) == [[1, 3, 5], [2, 4, 6]]\n", "\nassert... |
f06aa5f2cb669bc2f817e5d412b9cca5 | [
{
"content": "On te demande d'implémenter une structure de données de pile qui prend en charge les opérations suivantes : `push`, `pop`, `peek` et `is_empty`. La pile doit être capable de gérer n'importe quel type de données. Si une opération est effectuée sur une pile vide, ton implémentation doit lever une ex... | ["\nassert Stack().is_empty() == True\n", "\nstack = Stack(); stack.push(1); assert stack.is_empty() == False\n", "\nstack = Stack(); stack.push(1); stack.pop(); assert stack.is_empty() == True\n", "\nstack = Stack(); stack.push(1); stack.push(2); assert stack.peek() == 2\n", "\nstack = Stack(); stack.push(1); stack.pu... |
c5c75368e23a9f281bad7f5dcdd0d7cf | [
{
"content": "On te donne deux dictionnaires, `dict1` et `dict2`, chacun contenant des clés de type chaîne de caractères et des valeurs entières. Ta tâche est de mettre en œuvre une fonction `find_common_keys` qui identifie et renvoie une liste de clés présentes dans les deux dictionnaires. L'ordre des clés dan... | ["\nassert find_common_keys({'a': 1, 'b': 2}, {'b': 3, 'c': 4}) == ['b']\n", "\nassert find_common_keys({'x': 10, 'y': 20}, {'z': 30, 'w': 40}) == []\n", "\nassert find_common_keys({'key1': 1, 'key2': 2}, {'key2': 20, 'key3': 30}) == ['key2']\n", "\nassert find_common_keys({}, {'a': 1, 'b': 2}) == []\n", "\nassert find... |
0184f2ecdf48b257ee94b62800a8939e | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction `find_longest_palindrome` qui identifie et renvoie la plus longue sous-chaîne palindromique de la liste. Si plusieurs sous-chaînes ont la même longueur maximale, renvoie la première rencontrée. Si la liste ... | ["\nassert find_longest_palindrome([\"racecar\", \"banana\", \"level\", \"world\"]) == \"racecar\"\n", "\nassert find_longest_palindrome([\"noon\", \"civic\", \"rotor\", \"deified\"]) == \"noon\"\n", "\nassert find_longest_palindrome([\"abc\", \"def\", \"ghi\"]) == \"\"\n", "\nassert find_longest_palindrome([\"a\", \"b... |
0b19293b1b73c72e9dfc0442bde3baaa | [
{
"content": "On te donne une chaîne de caractères `sentence`. Ta tâche est de mettre en œuvre une fonction `count_unique_words(sentence)` qui renvoie le nombre de mots uniques dans la phrase. Les mots sont définis comme des séquences de caractères alphabétiques, et la comparaison doit être insensible à la cass... | ["\nassert count_unique_words(\"Hello world\") == 2\n", "\nassert count_unique_words(\"Hello hello world\") == 2\n", "\nassert count_unique_words(\"Python, python! Programming and programming.\") == 3\n", "\nassert count_unique_words(\"A quick brown fox jumps over the lazy dog\") == 8\n", "\nassert count_unique_words(\... |
7855a7c4f0e218068ebcce6c33e14edb | [
{
"content": "Implémente l'algorithme de tri par fusion en Python. Ta fonction doit accepter une liste d'entiers en entrée et renvoyer une nouvelle liste contenant les mêmes entiers dans l'ordre trié. La liste d'entrée peut contenir des éléments en double.\n\n**Exemple d'entrée :**\n```\n[38, 27, 43, 3, 9, 82, ... | ["\nassert merge_sort([38, 27, 43, 3, 9, 82, 10]) == [3, 9, 10, 27, 38, 43, 82]\n", "\nassert merge_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([1]) == [1]\n", "\nassert merge_sort([]) == []\n", "\nassert merge_sort([7, 7, 7, 7]) == [7, ... |
0f21dd000a9815ddb9a2601937942f06 | [
{
"content": "On te donne une liste de dictionnaires, où chaque dictionnaire représente un étudiant et ses notes dans différentes matières. Chaque dictionnaire contient une clé 'name' avec le nom de l'étudiant et une clé 'grades' avec une liste de notes numériques. Ta tâche est de mettre en œuvre une fonction `... | ["\nassert calculate_average_grades([{\"name\": \"Alice\", \"grades\": [88, 92, 85]}]) == [{'name': 'Alice', 'average_grade': 88.33333333333333}]\n", "\nassert calculate_average_grades([{\"name\": \"Bob\", \"grades\": [76, 80, 85]}]) == [{'name': 'Bob', 'average_grade': 80.33333333333333}]\n", "\nassert calculate_avera... |
a5276e4cd0647c8d60b7a516e5e71efe | [
{
"content": "On te donne une grille 2D de taille N x N, où chaque cellule est soit de la terre (`1`) soit de l'eau (`0`). Une île est définie comme un groupe de cellules terrestres connectées, qui peuvent être connectées horizontalement ou verticalement. Ta tâche est de déterminer le nombre total d'îles dans l... | ["\nassert num_islands([[1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 0, 0], [1, 0, 1, 0]]) == 3\n", "\nassert num_islands([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) == 1\n", "\nassert num_islands([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) == 0\n", "\nassert num_islands([[1, 0, 0, 0], [0, 1, 0, 0], [... |
9fc157ddd35574231450afa32913fa29 | [
{
"content": "On te demande d'implémenter une fonction `escape_html_identifier(identifier)` qui traite une chaîne de caractères donnée `identifier` pour la rendre appropriée pour une utilisation en tant qu'identifiant HTML. La fonction doit respecter les règles suivantes :\n\n1. L'identifiant doit commencer par... | ["\nassert escape_html_identifier(\"hello-world\") == \"hello-world\"\n", "\nassert escape_html_identifier(\"hello_world\") == \"hello_world\"\n", "\nassert escape_html_identifier(\"hello.world\") == \"hello.world\"\n", "\nassert escape_html_identifier(\"123hello\") == \"_123hello\"\n", "\nassert escape_html_identifier... |
e11a3dcf8b44481f6d851eb34b2fa688 | [
{
"content": "On te demande d'implémenter une simulation simple de distributeur automatique en Python. Le distributeur automatique doit prendre en charge les opérations suivantes :\n\n1. **Ajouter de l'argent** : Les utilisateurs peuvent ajouter de l'argent à leur solde.\n2. **Acheter un article** : Les utilisa... | ["\nassert VendingMachine().balance == 0.0\n", "\nvm = VendingMachine(); vm.add_money(2.00); assert vm.balance == 2.00\n", "\nvm = VendingMachine(); vm.add_money(2.00); vm.purchase_item('Coke'); assert vm.balance == 0.50\n", "\nvm = VendingMachine(); vm.add_money(1.00); vm.purchase_item('Coke'); assert vm.balance == 1.... |
87fba69a6ae37a9fcaa7789b19248557 | [
{
"content": "On te donne un tableau numpy 2D `data` représentant un ensemble de données géographiques, où la première dimension (axis=0) correspond à la latitude et la deuxième dimension (axis=1) correspond à la longitude. Chaque élément du tableau est une mesure prise à une latitude et une longitude spécifiqu... | ["\nassert weighted_average_dask(np.array([[1, 2], [3, 4]]), 0) == 2.5\n", "\nassert weighted_average_dask(np.array([[1, 2], [3, 4]]), 90) == 2.5\n", "\nassert weighted_average_dask(np.array([[1, 1], [1, 1]]), 0) == 1.0\n", "\nassert weighted_average_dask(np.array([[0, 0], [0, 0]]), 0) == 0.0\n", "\nassert weighted_ave... |
e6a7addd067e46de6ae5bbb02333f475 | [
{
"content": "Tu participes à une compétition de science des données où tu dois évaluer les performances de modèles de régression. Ta tâche est d'implémenter une fonction `calculate_mse` qui calcule l'Erreur Quadratique Moyenne (MSE) entre deux listes de nombres à virgule flottante, `actual_values` et `predicte... | ["\nassert calculate_mse([1.0, 2.0, 3.0], [1.0, 2.0, 3.0]) == 0.0\n", "\nassert calculate_mse([1.0, 2.0, 3.0], [2.0, 3.0, 4.0]) == 1.0\n", "\nassert calculate_mse([1.5, 2.5, 3.5], [1.0, 2.0, 3.0]) == 0.5\n", "\nassert calculate_mse([0.0, 0.0, 0.0], [1.0, 1.0, 1.0]) == 1.0\n", "\nassert calculate_mse([1.0, 1.0, 1.0], [0... |
af0a49c0ff5f66153f1f09cc708c5795 | [
{
"content": "On te donne une grille 2D de taille `R x C` où chaque cellule peut être soit vide (indiquée par `0`) soit contenir un obstacle (indiquée par `1`). Un robot est placé à une position de départ `(sx, sy)` sur cette grille. Le robot peut se déplacer dans quatre directions cardinales : haut, bas, gauch... | ["\nassert can_reach_destination([[0, 0, 0], [0, 1, 0], [0, 0, 0]], (0, 0), (2, 2), 2) == True\n", "\nassert can_reach_destination([[0, 0, 0], [0, 1, 0], [0, 0, 0]], (0, 0), (2, 2), 1) == False\n", "\nassert can_reach_destination([[0, 0, 0], [0, 0, 0], [0, 0, 0]], (0, 0), (2, 2), 0) == True\n", "\nassert can_reach_dest... |
0dd5bf77c4553c302c067b3d058c1c50 | [
{
"content": "On te demande d'implémenter une fonction pour convertir les températures entre Celsius et Fahrenheit. Ta fonction doit accepter une valeur de température et une chaîne de caractères indiquant l'unité de température source (`\"C\"` pour Celsius ou `\"F\"` pour Fahrenheit) et renvoyer la température... | ["\nassert convert_temperature(0, \"C\") == 32.0\n", "\nassert convert_temperature(100, \"C\") == 212.0\n", "\nassert convert_temperature(32, \"F\") == 0.0\n", "\nassert convert_temperature(212, \"F\") == 100.0\n", "\nassert convert_temperature(-40, \"C\") == -40.0\n", "\nassert convert_temperature(-40, \"F\") == -40.0... |
bbc2ec3f09ada1a40a0a1dc4297f20d3 | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est de transformer la liste de telle sorte que la somme de ses éléments soit égale à zéro. Tu peux y parvenir en ajoutant et en soustrayant la même valeur entière à différents éléments de la liste. Détermine la plus petite valeur entière possible qu... | ["\nassert balance_list([3, 1, -2, 4, 5]) == 5\n", "\nassert balance_list([1, 2, 3, -6]) == 0\n", "\nassert balance_list([10, -10]) == 0\n", "\nassert balance_list([1, 1, 1, 1, 1, -5]) == 1\n", "\nassert balance_list([-1, -2, -3, 6]) == 0\n", "\nassert balance_list([0, 0, 0, 0]) == 0\n", "\nassert balance_list([1, 2, 3... |
a2a28a964ae93daeb8764f22346e526a | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'écrire une fonction Python qui supprime toutes les chaînes de caractères dupliquées de la liste tout en préservant l'ordre d'apparition original de chaque chaîne. Tu dois implémenter cette fonctionnalité sans utiliser de fonctions ... | ["\nassert remove_duplicates([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"kiwi\"]) == [\"apple\", \"banana\", \"orange\", \"kiwi\"]\n", "\nassert remove_duplicates([\"hello\", \"world\", \"hello\", \"python\", \"world\"]) == [\"hello\", \"world\", \"python\"]\n", "\nassert remove_duplicates([\"a\", \"b\... |
ccf763772f9cd76c2b6224724501b8f8 | [
{
"content": "On te donne un tableau numpy 2D `data` de taille `N x D`, représentant un ensemble de données avec `N` échantillons et `D` caractéristiques. Certaines valeurs de caractéristiques sont manquantes et sont indiquées par `-999`. Ta tâche est de mettre en œuvre une fonction `fill_missing_values(data, f... | ["\nassert np.array_equal(fill_missing_values(np.array([[1, -999, 3], [-999, 5, -999], [7, 8, 9]]), 0), np.array([[1, 0, 3], [0, 5, 0], [7, 8, 9]]))\n", "\nassert np.array_equal(fill_missing_values(np.array([[-999, -999, -999], [-999, -999, -999], [-999, -999, -999]]), 1), np.array([[-999, -999, -999], [-999, -999, -99... |
0a2181cc5e0cac8e0945df5693b18659 | [
{
"content": "On te donne une liste de `n` points dans un plan 2D, où chaque point est représenté comme un tuple de deux entiers `(x, y)`. Ta tâche est d'écrire une fonction `find_min_distance(points)` qui calcule la distance euclidienne minimale entre deux points distincts de la liste. On suppose que `n` est a... | ["\nassert find_min_distance([(0, 0), (1, 1)]) == math.sqrt(2)\n", "\nassert find_min_distance([(1, 2), (4, 6), (7, 8), (2, 1)]) == math.sqrt(2)\n", "\nassert find_min_distance([(0, 0), (3, 4)]) == 5\n", "\nassert find_min_distance([(1, 1), (1, 1)]) == 0\n", "\nassert find_min_distance([(0, 0), (0, 1), (1, 0)]) == 1\n"... |
744747810e8fd0432b2186c5c80b596a | [
{
"content": "On te donne une chaîne d'octets qui a été complétée en utilisant une version modifiée du schéma de remplissage PKCS#7. Dans ce schéma, le remplissage consiste en des blocs de taille `k`, et le dernier bloc est rempli d'une séquence d'octets représentant les valeurs ASCII des caractères de la chaîn... | ["\nassert pkcs7_decrypt(b\"YELLOW SUBMARINEPADDING\") == b\"YELLOW SUBMARINE\"\n", "\nassert pkcs7_decrypt(b\"YELLOW SUBMARINEPADDINGPADDING\") == b\"YELLOW SUBMARINE\"\n", "\nassert pkcs7_decrypt(b\"YELLOW SUBMARINEPADDPADD\") == b\"YELLOW SUBMARINE\"\n", "\nassert pkcs7_decrypt(b\"YELLOW SUBMARINEPADD\") == b\"YELLO... |
694ae9a2133de9749364c3033346f9d8 | [
{
"content": "Tu es chargé de mettre en œuvre une application Python qui gère efficacement le stockage et la récupération de données binaires volumineuses. Ton objectif est de créer deux fonctions : `store_binary_data` et `retrieve_binary_data`. La fonction `store_binary_data` doit accepter un tableau d'octets ... | ["\nassert retrieve_binary_data('test.bin') == b'' if not store_binary_data(b'', 'test.bin') else False\n", "\nassert retrieve_binary_data('test.bin') == b'hello' if not store_binary_data(b'hello', 'test.bin') else False\n", "\nassert retrieve_binary_data('test.bin') == b'\\x00\\x01\\x02\\x03\\x04' if not store_binary_... |
a80ad7dd224be3c89d32d445441711c5 | [
{
"content": "On te donne une chaîne de caractères `text` et une liste de `stop_words`. Ta tâche est de mettre en œuvre une fonction qui traite la chaîne `text` pour extraire les mots et renvoie une liste de mots qui ne sont pas présents dans la liste `stop_words`. Les mots dans la chaîne `text` sont séparés pa... | ["\nassert filter_stop_words(\"This is a test.\", [\"is\", \"a\"]) == [\"this\", \"test\"]\n", "\nassert filter_stop_words(\"Hello world!\", [\"hello\"]) == [\"world\"]\n", "\nassert filter_stop_words(\"Python programming is fun.\", [\"is\", \"fun\"]) == [\"python\", \"programming\"]\n", "\nassert filter_stop_words(\"S... |
5acc859000ce0c6aa77dbc9b6a9ea78e | [
{
"content": "On te donne une liste de tuples `coords`, où chaque tuple représente les coordonnées 2D d'un point. Ta tâche est d'écrire une fonction qui calcule la distance euclidienne entre les deux points les plus proches de la liste. Si la liste contient moins de deux points, la fonction doit renvoyer `None`... | ["\nassert closest_distance([(0, 0), (3, 4)]) == 5.0\n", "\nassert closest_distance([(1, 1), (2, 2)]) == math.sqrt(2)\n", "\nassert closest_distance([(0, 0), (0, 0)]) == 0.0\n", "\nassert closest_distance([(1, 2), (4, 6), (7, 8)]) == math.sqrt(5)\n", "\nassert closest_distance([(10, 10), (10, 10), (10, 10)]) == 0.0\n",... |
edc8e07e40db268ad920ef237c42bc10 | [
{
"content": "On te donne une chaîne de caractères `text` et un booléen `convert_empty_to_zero`. Ta tâche est d'implémenter une fonction `extract_numbers_from_text` qui extrait tous les nombres de la chaîne et les renvoie sous forme de liste de nombres à virgule flottante. Les nombres dans la chaîne peuvent êtr... | ["\nassert extract_numbers_from_text(\"The temperature is -20.5 degrees Celsius.\", False) == [-20.5]\n", "\nassert extract_numbers_from_text(\"The population is 1.2e6.\", False) == [1200000.0]\n", "\nassert extract_numbers_from_text(\"No numbers here!\", True) == [0.0]\n", "\nassert extract_numbers_from_text(\"The val... |
0b7241959278be7850e5a1d1f22b16a5 | [
{
"content": "On te donne un modèle PyTorch pré-entraîné conçu pour prédire la probabilité de précipitations dans une zone géographique spécifiée. Le modèle accepte un tableau numpy 2D représentant une grille de coordonnées de latitude et de longitude et produit deux tableaux numpy : un pour la probabilité préd... | ["\nassert predict_rainfall(model, np.array([[34.05, -118.25], [36.12, -115.17]]))[0].shape == (2,)\n", "\nassert predict_rainfall(model, np.array([[34.05, -118.25], [36.12, -115.17]]))[1].shape == (2,)\n", "\nassert predict_rainfall(model, np.array([[34.05, -118.25], [36.12, -115.17]]), device='cpu')[0].dtype == np.fl... |
1c6f838ba5dc6a9dec675e490608a9e6 | [
{
"content": "Tu es chargé de créer un script Python qui utilise la bibliothèque de graphiques turtle pour générer une fractale. La fractale doit être un flocon de Koch. Ton programme doit demander à l'utilisateur d'entrer la profondeur de récursion, puis afficher la fractale en conséquence. Le flocon de Koch d... | ["\nmock_turtle = MockTurtle()\nkoch_curve(mock_turtle, 100, 0)\nassert mock_turtle.commands == [('forward', 100)]\n", "\nmock_turtle = MockTurtle()\nkoch_curve(mock_turtle, 100, 1)\nassert mock_turtle.commands == [('forward', 33.333333333333336), ('left', 60), ('forward', 33.333333333333336), ('right', 120), ('forward... |
2a67c33b9b194199f8bdbb9659a588df | [
{
"content": "On te donne une chaîne de caractères représentant une liste d'identifiants dans un format non standard. Les identifiants sont encadrés par des accolades `{}` et séparés par des virgules `,`. Chaque identifiant est encadré par des guillemets doubles `\"` et préfixé par une étiquette suivie de deux ... | ["\nassert extract_identifiers('{label1:\"identifier1\", label2:\"identifier2\", label3:\"identifier3\"}') == ['identifier1', 'identifier2', 'identifier3']\n", "\nassert extract_identifiers('{label:\"special@char#123\"}') == ['special@char#123']\n", "\nassert extract_identifiers('{label:\"\"}') == ['']\n", "\nassert ex... |
4e6783a1ec83eddffdbac00e66cf8a2c | [
{
"content": "On te demande d'implémenter une fonction Python qui télécharge une version compressée d'un fichier local vers un bucket AWS S3. La fonction doit prendre trois paramètres : le chemin du fichier local, le nom du bucket S3 et la clé d'objet S3 souhaitée. La fonction doit compresser le fichier en util... | ["\nassert upload_file_gzip_to_s3('/path/to/nonexistentfile.txt', 'my-s3-bucket', 'path/to/s3object.txt.gz') == False\n", "\nassert upload_file_gzip_to_s3('/path/to/localfile.txt', 'nonexistent-bucket', 'path/to/s3object.txt.gz') == False\n", "\nassert upload_file_gzip_to_s3('/path/to/localfile.txt', 'my-s3-bucket', ''... |
0d7dc8397e0939d87fc9487f70eb779b | [
{
"content": "On te demande d'implémenter une fonction `has_required_libraries` qui détermine si un ensemble de bibliothèques sont installées dans l'environnement Python actuel et ont été installées à l'aide d'un gestionnaire de paquets spécifié, tel que `pip`. Ta fonction doit renvoyer `True` si toutes les bib... | ["\nassert has_required_libraries(['numpy']) == True\n", "\nassert has_required_libraries(['numpy', 'pandas']) == True\n", "\nassert has_required_libraries(['numpy', 'nonexistentpackage']) == False\n", "\nassert has_required_libraries(['numpy'], package_manager='conda') == False\n", "\nassert has_required_libraries(['r... |
eefedf72821f6bb885c4dfe109f18767 | [
{
"content": "On te donne une liste de valeurs. Ta tâche est d'implémenter une fonction `detect_data_type` qui catégorise chaque valeur en fonction de son type de données. Si une valeur est une instance d'une sous-classe d'un type de données intégré de Python, elle doit être catégorisée sous sa superclasse. Plu... | ["\nassert detect_data_type([1, 2, 3]) == {'int': 3}\n", "\nassert detect_data_type([1.1, 2.2, 3.3]) == {'float': 3}\n", "\nassert detect_data_type([\"a\", \"b\", \"c\"]) == {'str': 3}\n", "\nassert detect_data_type([[], [1], [1, 2]]) == {'list': 3}\n", "\nassert detect_data_type([(), (1,), (1, 2)]) == {'tuple': 3}\n",... |
d100670fc06cd52e57453da2ff296946 | [
{
"content": "On te donne une liste non triée d'entiers, `numbers`, qui peut contenir des doublons, et un entier cible, `target`. Ta tâche est de trouver l'index de la première occurrence de `target` dans la version triée de `numbers` en utilisant un algorithme de recherche binaire récursif. Si la cible n'est p... | ["\nassert find_first_occurrence([3, 1, 2, 3, 4, 2, 3], 3) == 1\n", "\nassert find_first_occurrence([5, 4, 3, 2, 1], 3) == 2\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5], 6) == -1\n", "\nassert find_first_occurrence([1, 1, 1, 1, 1], 1) == 0\n", "\nassert find_first_occurrence([], 1) == -1\n", "\nassert find_firs... |
7b0d5716504927d0483bbb468d62ce5b | [
{
"content": "On te donne une liste d'événements, chacun représenté comme un objet avec un horodatage et un niveau de priorité. Ta tâche est de construire une chronologie d'événements telle que chaque horodatage soit associé à exactement un événement. Dans les cas où plusieurs événements partagent le même horod... | ["\nassert build_event_timeline([Event(1, 10)]) == [(1, Event(1, 10))]\n", "\nassert build_event_timeline([Event(1, 10), Event(1, 20)]) == [(1, Event(1, 20))]\n", "\nassert build_event_timeline([Event(1, 10), Event(2, 15)]) == [(1, Event(1, 10)), (2, Event(2, 15))]\n", "\nassert build_event_timeline([Event(1, 10), Even... |
e99b06ca8b1f5ac4ff379d9b7a63f166 | [
{
"content": "On te donne un objet datetime et une chaîne de caractères représentant un fuseau horaire. Ta tâche est d'écrire une fonction `convert_to_timestamp` qui convertit l'objet datetime dans le fuseau horaire spécifié, en tenant compte des changements d'heure d'été, et renvoie une chaîne de caractères re... | ["\nassert convert_to_timestamp(datetime(2022, 1, 1, 12, 0), 'America/New_York') == '2022-01-01T17:00:00-05:00'\n", "\nassert convert_to_timestamp(datetime(2022, 7, 1, 12, 0), 'America/New_York') == '2022-07-01T16:00:00-04:00'\n", "\nassert convert_to_timestamp(datetime(2022, 1, 1, 0, 0), 'Europe/London') == '2022-01-0... |
9e266d1f40cd39b74a5f0e85b8b8a4c3 | [
{
"content": "Implémente une fonction `simulate_traffic_light` qui simule le comportement d'un feu de circulation. Le feu de circulation doit passer par les couleurs rouge, jaune et vert, avec des durées de 10 secondes pour le rouge, 5 secondes pour le jaune et 10 secondes pour le vert. La fonction doit continu... | ["\nimport sys\nfrom io import StringIO\n\nold_stdout = sys.stdout\nnew_stdout = StringIO()\nsys.stdout = new_stdout\ntraffic_light()\noutput = new_stdout.getvalue()\nsys.stdout = old_stdout\nassert \"Traffic light is now red.\" in output\n", "\nimport sys\nfrom io import StringIO\n\nold_stdout = sys.stdout\nnew_stdout... |
bb378c88ed2ba5b5cb0868a48b1c38ae | [
{
"content": "On te demande d'implémenter une fonction pour générer la suite de Fibonacci. La suite de Fibonacci est une série de nombres où chaque nombre est la somme des deux nombres précédents, commençant généralement par 0 et 1. Ta fonction doit générer la suite jusqu'à un nombre de termes spécifié et la re... | ["\nassert generate_fibonacci(1) == [0]\n", "\nassert generate_fibonacci(2) == [0, 1]\n", "\nassert generate_fibonacci(5) == [0, 1, 1, 2, 3]\n", "\nassert generate_fibonacci(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert generate_fibonacci(0) == \"Number of terms must be a positive integer\"\n", "\nassert gener... |
d3d26361887e278e5c5060809a33dd5b | [
{
"content": "On te demande d'implémenter une fonction `safe_subtract` qui traite deux entrées : `val` et `otherval`. La fonction doit respecter les règles suivantes :\n\n1. Si `otherval` n'est pas fourni, la fonction doit renvoyer `val`.\n2. Si `otherval` est fourni et peut être converti avec succès en un enti... | ["\nassert safe_subtract(10) == 10\n", "\nassert safe_subtract(10, 3) == 7\n", "\nassert safe_subtract(10, '5') == 5\n", "\nassert safe_subtract(10, 'abc') == 10\n", "\nassert safe_subtract(0, 0) == 0\n", "\nassert safe_subtract(-5, 3) == -8\n", "\nassert safe_subtract(5, -3) == 8\n", "\nassert safe_subtract(100, '100'... |
28053395c12b425afac9cc0b6f71aeb1 | [
{
"content": "Tu es chargé d'implémenter une fonction `clean_text` qui traite une chaîne de caractères donnée `text`. La fonction doit effectuer les transformations suivantes :\n- Remplacer tous les caractères de nouvelle ligne (`\\n`) et de tabulation (`\\t`) par un seul espace.\n- Remplacer toute séquence de ... | ["\nassert clean_text(\"Hello World\\nThis\\tis\\ta\\ttest.\") == \"Hello World This is a test.\"\n", "\nassert clean_text(\"Line1\\nLine2\") == \"Line1 Line2\"\n", "\nassert clean_text(\"Line1\\tLine2\") == \"Line1 Line2\"\n", "\nassert clean_text(\"Line1\\n\\tLine2\") == \"Line1 Line2\"\n", "\nassert clean_text(\"L... |
6f9c5503420b34509cddf3bd73bd3850 | [
{
"content": "On te donne une chaîne de caractères `input_string`. Ton objectif est d'écrire une fonction `escape_special_characters(input_string)` qui traite cette chaîne et renvoie une nouvelle chaîne. Dans la nouvelle chaîne, toutes les occurrences des caractères spéciaux `\\`, `'`, et `\"` doivent être écha... | ["\nassert escape_special_characters(\"a'b\\\"c\\\\d\") == \"a~'b~\\\"c\\\\d\"\n", "\nassert escape_special_characters(\"abc'def\") == \"abc~'def\"\n", "\nassert escape_special_characters(\"abc\\\"def\") == \"abc~\\\"def\"\n", "\nassert escape_special_characters(\"abc\\\\def\") == \"abc\\\\def\"\n", "\nassert escape_sp... |
163ae9e8f1032226f6c6e072c2ddf1b4 | [
{
"content": "Tu es chargé de développer une fonction pour une organisation de recherche météorologique afin de générer des chemins de fichiers pour les données météorologiques. La fonction doit valider les identifiants de station et s'assurer que les dates fournies se situent dans la période d'observation vali... | ["\nassert generate_weather_file_path(\"KCRG\", \"2021-08-30\") == \"data/2021/08/30/KCRG.csv\"\n", "\nassert generate_weather_file_path(\"KCRG\", \"2021-08-30\", \"txt\") == \"data/2021/08/30/KCRG.txt\"\n", "\nassert generate_weather_file_path(\"12345\", \"1900-01-01\") == \"data/1900/01/01/12345.csv\"\n", "\nassert g... |
8a2cdaa691e85de1bbb395bb3672e9bb | [
{
"content": "On te demande d'implémenter une classe `LRUCache` qui respecte le mécanisme de cache \"Least Recently Used\" (LRU). La classe doit prendre en charge les opérations suivantes :\n\n- `get(key)` : Récupérer la valeur associée à la `key` donnée si elle existe dans le cache. Si la `key` n'existe pas, r... | ["\nassert LRUCache(2).get(1) == -1\n", "\nlru = LRUCache(2); lru.put(1, 1); lru.put(2, 2); assert lru.get(1) == 1\n", "\nlru = LRUCache(2); lru.put(1, 1); lru.put(2, 2); lru.put(3, 3); assert lru.get(2) == -1\n", "\nlru = LRUCache(2); lru.put(1, 1); lru.put(2, 2); lru.put(3, 3); lru.put(4, 4); assert lru.get(1) == -1\... |
541097ebd1900bcbbb62a1d389e5e4c8 | [
{
"content": "Tu es chargé d'implémenter un simple jeu de pierre-papier-ciseaux. Le jeu se joue entre un joueur et un ordinateur. L'ordinateur sélectionne aléatoirement l'une des trois actions : \"rock\", \"paper\" ou \"scissors\". L'action du joueur est fournie en entrée. Ton programme doit déterminer le résul... | ["\nassert get_computer_choice() in [\"rock\", \"paper\", \"scissors\"]\n", "\nassert determine_winner(\"rock\", \"rock\") == \"It's a tie!\"\n", "\nassert determine_winner(\"paper\", \"paper\") == \"It's a tie!\"\n", "\nassert determine_winner(\"scissors\", \"scissors\") == \"It's a tie!\"\n", "\nassert determine_winn... |
58f30e100b5913265c43ff34e999f459 | [
{
"content": "On te donne les métadonnées d'une version de logiciel et tu dois générer un identifiant unique selon les règles suivantes :\n\n- Si une version taguée la plus proche existe, l'identifiant doit être au format : `<tag-le-plus-proche>-<distance>-<hash-court>`.\n- Si le répertoire de travail est modif... | ["\nassert generate_version_identifier({'closest-tag': 'v1.0.0', 'distance': 5, 'short': 'abc123', 'dirty': False}) == \"v1.0.0-5-abc123\"\n", "\nassert generate_version_identifier({'closest-tag': 'v2.3.1', 'distance': 0, 'short': 'def456', 'dirty': True}) == \"v2.3.1-0-def456-dirty\"\n", "\nassert generate_version_ide... |
381ede459898c92ca846f4973e547450 | [
{
"content": "On te demande d'implémenter une classe Python nommée `Employee` pour gérer les détails des employés. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Propriétés :**\n - `first_name` : une chaîne de caractères représentant le prénom de l'employé.\n - `last_name` : une chaîn... | ["\nassert Employee(\"John\", \"Doe\", 123).first_name == \"John\"\n", "\nassert Employee(\"John\", \"Doe\", 123).last_name == \"Doe\"\n", "\nassert Employee(\"John\", \"Doe\", 123).employee_id == 123\n", "\nassert Employee(\"John\", \"Doe\", 123).full_name() == \"John Doe\"\n", "\nassert str(Employee(\"John\", \"Doe\"... |
93ca7ed6ffa7db82beb0cdee1af1a2d0 | [
{
"content": "On te donne un dictionnaire `task_results` où chaque clé est un nom d'hôte et chaque valeur est une liste de résultats de tâches. Chaque résultat de tâche est un objet avec les attributs suivants : `name`, `diff`, `changed`, `result`, `failed` et `exception`. Implémente la fonction `process_task_r... | ["\nassert process_task_results({\"host1\": [{\"name\": \"task1\", \"diff\": \"\", \"changed\": False, \"result\": \"success\", \"failed\": False, \"exception\": \"\"}]}) == {\"host1\": [{\"name\": \"task1\", \"result\": \"success\"}]}\n", "\nassert process_task_results({\"host1\": [{\"name\": \"task1\", \"diff\": \"\"... |
96a280bf992b8b3806b12cd74fdcf1bb | [
{
"content": "On te demande d'implémenter une fonction `fizz_buzz_advanced(x)` qui traite un entier `x` selon des règles spécifiques. La fonction doit renvoyer une chaîne de caractères en fonction des critères suivants :\n\n1. Si `x` est un nombre négatif, renvoie \"Invalid Input\".\n2. Si `x` est une puissance... | ["\nassert fizz_buzz_advanced(15) == \"Fizz_Buzz\"\n", "\nassert fizz_buzz_advanced(9) == \"Fizz\"\n", "\nassert fizz_buzz_advanced(25) == \"Buzz\"\n", "\nassert fizz_buzz_advanced(7) == \"7\"\n", "\nassert fizz_buzz_advanced(-1) == \"Invalid Input\"\n", "\nassert fizz_buzz_advanced(1) == \"1\"\n", "\nassert fizz_buzz_... |
a3b3d7cf4bde2d82e86ad7b6a736a293 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire un programme qui identifie le plus grand nombre de la liste et affiche ce nombre ainsi que l'index de sa première occurrence. Si la liste est vide, ton programme doit renvoyer \"List is empty\".\n\n**Exemple d'entrée :**\n```\n[10, 20, 30, 40,... | ["\nassert find_largest_and_position([10, 20, 30, 40, 30, 40, 50, 20, 50]) == (50, 6)\n", "\nassert find_largest_and_position([1, 2, 3, 4, 5]) == (5, 4)\n", "\nassert find_largest_and_position([5, 4, 3, 2, 1]) == (5, 0)\n", "\nassert find_largest_and_position([100, 200, 300, 400, 500]) == (500, 4)\n", "\nassert find_la... |
e0db96226b293b38f64bb4ed06e939f7 | [
{
"content": "On te donne une grille 2D d'entiers, où chaque entier représente un type de terrain unique. Avant de vérifier si la grille est uniforme, tu dois d'abord inverser l'ordre des éléments dans chaque ligne de la grille, puis inverser l'ordre des lignes elles-mêmes. Après ces transformations, détermine ... | ["\nassert is_uniform([[1, 1], [1, 1]]) == True\n", "\nassert is_uniform([[2, 2, 2], [2, 2, 2], [2, 2, 2]]) == True\n", "\nassert is_uniform([[3, 3], [3, 4]]) == False\n", "\nassert is_uniform([[5]]) == True\n", "\nassert is_uniform([[6, 6, 6], [6, 6], [6]]) == False\n", "\nassert is_uniform([[7, 7, 7], [7, 7, 7], [7, ... |
6bcbdb58e50da5a5d6c1d9753819213d | [
{
"content": "On te demande d'implémenter une classe `InventoryManager` en Python pour gérer une collection d'objets. La classe doit prendre en charge les opérations suivantes :\n\n- `add_item(item_name, quantity)` : Ajoute la quantité spécifiée de l'objet à l'inventaire. Si l'objet existe déjà, elle doit augme... | ["\nassert InventoryManager().get_inventory() == {}\n", "\nassert InventoryManager().add_item(\"apple\", 10) is None\n", "\nassert InventoryManager().remove_item(\"apple\", 5) is None\n", "\ninv = InventoryManager(); inv.add_item(\"banana\", 5); assert inv.get_inventory() == {\"banana\": 5}\n", "\ninv = InventoryManage... |
caf77bcb1cb92781c8c2e67a1d255d28 | [
{
"content": "Tu développes un système qui nécessite que les utilisateurs vérifient leurs adresses e-mail. Implémente une fonction `generate_verification_link` qui construit un lien de vérification unique et limité dans le temps. Le lien doit inclure un token basé sur HMAC qui est valide pendant une durée spéci... | ["\nassert generate_verification_link(\"test@example.com\", \"secret\").startswith(\"http://yourdomain.com/verify?email=test%40example.com×tamp=\")\n", "\nassert generate_verification_link(\"user@domain.com\", \"key\", 7200).endswith(\"&token=\")\n", "\nassert generate_verification_link(\"user@domain.com\", \"key\... |
5633e58e8ed4ba50304eff04effd91f7 | [
{
"content": "Tu participes à un défi de prétraitement de données où tu te voit fournir un ensemble de données représenté sous la forme d'un DataFrame pandas `df`. Le DataFrame est constitué de plusieurs caractéristiques (colonnes) et d'échantillons (lignes). Ton objectif est de mettre en œuvre une fonction `fi... | ["\nassert filter_features(pd.DataFrame({'feature1': [1, 2], 'feature2': [3, 4]}), ['feature2']).equals(pd.DataFrame({'feature1': [1, 2]}))\n", "\nassert filter_features(pd.DataFrame({'feature1': [1, 2], 'feature2': [3, 4], 'feature3': [5, 6]}), ['feature1', 'feature3']).equals(pd.DataFrame({'feature2': [3, 4]}))\n", "... |
f70fbb5eea7324dad6b9dee8a8bdf2c4 | [
{
"content": "On te demande d'analyser les performances de plusieurs points de terminaison de service web. Étant donné une liste de tuples, où chaque tuple est constitué d'une URL (chaîne de caractères) et de son temps de réponse correspondant (entier), ton objectif est d'identifier le point de terminaison avec... | ["\nassert find_max_response_time([(\"https://example.com/api/v1/data\", 120), (\"https://example.com/api/v2/data\", 80), (\"https://example.com/api/v3/data\", 150)]) == (\"https://example.com/api/v3/data\", 150)\n", "\nassert find_max_response_time([(\"https://example.com/api/v1/data\", 120), (\"https://example.com/ap... |
425c42ace90dbbbca28cb5289b9c5db4 | [
{
"content": "On te donne un extrait de code Python qui inclut plusieurs fonctions. Ta tâche est de refactoriser le code pour qu'il respecte les directives de style PEP 8. De plus, inclus des docstrings pour chaque fonction afin de décrire son but et ses paramètres.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 10^... | ["\nassert check_prime(2) == 1\n", "\nassert check_prime(1) == 0\n", "\nassert check_prime(0) == 0\n", "\nassert check_prime(-5) == 0\n", "\nassert check_prime(11) == 1\n", "\nassert check_prime(15) == 0\n", "\nassert find_primes(10) == [2, 3, 5, 7]\n", "\nassert find_primes(1) == []\n", "\nassert find_primes(20) == [2... |
88a05a8cf10fde2b9966447c8ef609a9 | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tableau NumPy 2D, où chaque valeur de pixel est un nombre sur 8 bits dans la plage [0, 255]. Ta tâche est d'écrire une fonction `convert_to_custom_binary` qui convertit cette image en niveaux de gris en une image binaire en utilisant un... | ["\nassert np.array_equal(convert_to_custom_binary(np.array([[0, 255]]), 128), np.array([[135, 220]]))\n", "\nassert np.array_equal(convert_to_custom_binary(np.array([[128, 128]]), 128), np.array([[220, 220]]))\n", "\nassert np.array_equal(convert_to_custom_binary(np.array([[64, 192]]), 128), np.array([[135, 220]]))\n"... |
ec2c1ceb11d78035c398ab2f1d3f1368 | [
{
"content": "On te demande d'implémenter une classe `Car` avec les attributs `make`, `model` et `year`. Ton objectif est de définir une méthode `__repr__` pour cette classe qui renvoie une représentation sous forme de chaîne d'un objet `Car`, formatée comme `<Car make='make_value' model='model_value' year=year... | ["\nassert repr(Car('Toyota', 'Corolla', 2020)) == \"<Car make='Toyota' model='Corolla' year=2020>\"\n", "\nassert repr(Car('Honda', 'Civic', 2018)) == \"<Car make='Honda' model='Civic' year=2018>\"\n", "\nassert repr(Car('Ford', 'Mustang', 2022)) == \"<Car make='Ford' model='Mustang' year=2022>\"\n", "\nassert repr(Ca... |
9116c062f79cdf429fa90658046536d8 | [
{
"content": "On te demande d'implémenter une fonction `calculate_total_cost` pour déterminer le coût final de l'achat d'une quantité spécifiée d'un produit, en tenant compte des remises, taxes et suppléments optionnels. La fonction doit respecter les règles suivantes :\n\n- **Paramètres :**\n - `price` (float... | ["\nassert calculate_total_cost(10, 1) == 10.5\n", "\nassert calculate_total_cost(10, 1, 10) == 9.45\n", "\nassert calculate_total_cost(20, 2) == 42.0\n", "\nassert calculate_total_cost(20, 2, 20) == 33.6\n", "\nassert calculate_total_cost(50, 50) == 2625.0\n", "\nassert calculate_total_cost(50, 50, 10) == 2362.5\n", "... |
192350aa106955757a91402b9b0999b4 | [
{
"content": "On te demande d'implémenter une fonction `parse_url` qui traite une chaîne d'URL donnée et en extrait les composants. La fonction doit renvoyer un tuple constitué du protocole, de l'hôte et du chemin. Si le protocole n'est pas spécifié dans l'URL, il doit par défaut être \"http\". De même, si le c... | ["\nassert parse_url(\"https://www.example.com/path/to/resource\") == (\"https\", \"www.example.com\", \"/path/to/resource\")\n", "\nassert parse_url(\"ftp://files.example.com\") == (\"ftp\", \"files.example.com\", \"/\")\n", "\nassert parse_url(\"www.example.com\") == (\"http\", \"www.example.com\", \"/\")\n", "\nasse... |
22b868340206d7a578ec53fe3ece921a | [
{
"content": "Tu développes un système de commande de restaurant simple. Le système doit afficher un menu de plats, chacun identifié par un ID et un nom uniques. Les utilisateurs peuvent sélectionner un plat en entrant son ID de plat. Ta tâche est de mettre en œuvre une fonction qui affiche le menu et invite l'... | ["\nassert display_menu([(1, \"Spaghetti Carbonara\"), (2, \"Caesar Salad\"), (3, \"Tiramisu\")]) == 1\n", "\nassert display_menu([(1, \"Spaghetti Carbonara\"), (2, \"Caesar Salad\"), (3, \"Tiramisu\")]) == 2\n", "\nassert display_menu([(1, \"Spaghetti Carbonara\"), (2, \"Caesar Salad\"), (3, \"Tiramisu\")]) == 3\n", "... |
9d183672a459b1eb723725d88a9dfa49 | [
{
"content": "On te donne une chaîne de caractères `encoded_message` qui représente un message encodé au format JSON. Le message a été encodé en utilisant un schéma d'encodage personnalisé où chaque caractère du message original est remplacé par le caractère correspondant à sa valeur ASCII plus 10. Par exemple,... | ["\nassert decode_message('{\"a\":123}') == {\"a\": 123}\n", "\nassert decode_message('{\"name\":\"John\"}') == {\"name\": \"John\"}\n", "\nassert decode_message('{\"age\":30}') == {\"age\": 30}\n", "\nassert decode_message('{\"is_student\":false}') == {\"is_student\": False}\n", "\nassert decode_message('{\"is_active\... |
5935326ce6f8f08521fbaeca8bcaebee | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si `s` est un palindrome, en ignorant la casse et la ponctuation. Une chaîne est considérée comme un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :**\n- Une seule chaîne de ca... | ["\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(\"Hello, World!\") == False\n", "\nassert i... |
424e077c173e54f502c2e3a143738c99 | [
{
"content": "Tu développes une application web qui interagit avec une API REST pour récupérer des informations sur les utilisateurs. Le point de terminaison de l'API fournit un objet JSON contenant des détails sur un utilisateur, notamment son nom, son adresse e-mail et son âge. Cependant, l'API est peu fiable... | ["\nassert fetch_user_data(1) is not None\n", "\nassert fetch_user_data(1) == fetch_user_data(1) # Check caching\n", "\nassert fetch_user_data(2) is not None\n", "\nassert fetch_user_data(2) == fetch_user_data(2) # Check caching\n", "\nassert fetch_user_data(999999) is None # Non-existent user_id\n", "\nassert fetch... |
d0584a5a45b9829e33eb1e7a25a4059d | [
{
"content": "On te donne trois entiers `n`, `m` et `k`. Ta tâche est de calculer la somme de tous les multiples uniques de `n` et `m` qui sont inférieurs ou égaux à `k`. Utilise des fonctions d'ordre supérieur ou des opérations sur les ensembles pour résoudre ce problème sans utiliser de boucles explicites.\n\... | ["\nassert sum_of_multiples(3, 5, 15) == 60\n", "\nassert sum_of_multiples(2, 4, 10) == 30\n", "\nassert sum_of_multiples(7, 11, 50) == 231\n", "\nassert sum_of_multiples(1, 1, 10) == 55\n", "\nassert sum_of_multiples(5, 10, 50) == 275\n", "\nassert sum_of_multiples(6, 8, 24) == 156\n", "\nassert sum_of_multiples(13, 1... |
b73342a81ccfc541dc6329e0413d20c1 | [
{
"content": "On te demande d'implémenter un système 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.\n2. **Retrait** : Soustraire un montant spécifié du solde du compte, en veillant à ce que le retrait ne ... | ["\nassert BankAccount(\"Alice\").check_balance() == 0.0\n", "\nassert BankAccount(\"Bob\", 100.0).check_balance() == 100.0\n", "\naccount = BankAccount(\"Charlie\", 200.0); account.deposit(50.0); assert account.check_balance() == 250.0\n", "\naccount = BankAccount(\"David\", 150.0); account.withdraw(50.0); assert acco... |
a6f611d06432432c5b7fc528574cd3ef | [
{
"content": "On te donne une chaîne de caractères `text` et un entier `k`. Ta tâche est de mettre en œuvre une fonction `get_top_k_frequent_words(text, k, stop_words)` qui renvoie une liste des `k` mots les plus fréquents dans le texte, en excluant tous les mots figurant dans la liste `stop_words`. La fonction... | ["\nassert get_top_k_frequent_words(\"The quick brown fox jumps over the lazy dog. The dog was not amused.\", 2, [\"the\", \"and\", \"is\", \"in\", \"a\", \"at\", \"to\", \"of\", \"on\", \"with\"]) == [\"the\", \"dog\"]\n", "\nassert get_top_k_frequent_words(\"Hello world! Hello everyone.\", 1, [\"the\", \"and\", \"is\... |
2b6b34e8b47b194630bb5682305b43fa | [
{
"content": "On te donne une structure de liste imbriquée composée d'entiers et d'autres listes imbriquées. Ta tâche est d'écrire une fonction `sum_nested_list(nested_list)` qui calcule la somme de tous les entiers présents dans la liste imbriquée. La liste d'entrée peut être imbriquée de manière arbitraire, m... | ["\nassert sum_nested_list([1, 2, 3, 4, 5]) == 15\n", "\nassert sum_nested_list([1, [2, 3], [4, 5]]) == 15\n", "\nassert sum_nested_list([[1, 2, [3]], 4, [5, 6]]) == 21\n", "\nassert sum_nested_list([1, [2, [3, [4, [5]]]]]) == 15\n", "\nassert sum_nested_list([]) == 0\n", "\nassert sum_nested_list([[[[[]]]]]) == 0\n", ... |
029736a312c9b989e55703a4f9f8c5e4 | [
{
"content": "On te demande d'implémenter une classe `Calculator` en Python qui supporte les opérations arithmétiques de base : addition, soustraction, multiplication et division. La classe doit inclure des méthodes pour chaque opération, chacune prenant deux paramètres `a` et `b`. De plus, implémente une métho... | ["\nassert Calculator().add(2, 3) == 5\n", "\nassert Calculator().subtract(5, 3) == 2\n", "\nassert Calculator().multiply(4, 3) == 12\n", "\nassert Calculator().divide(10, 2) == 5\n", "\nassert Calculator().divide(10, 0) == ValueError(\"Cannot divide by zero\")\n", "\ncalc = Calculator()\ncalc.add(1, 2)\ncalc.subtract(... |
a69687dd5fb4dc1b87007fa467ecc97c | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente un nombre hexadécimal à deux chiffres. Ta tâche est d'écrire une fonction `HexToChar` qui convertit chaque nombre hexadécimal en son caractère ASCII correspondant sans utiliser de fonctions intégrées pour la conversion hex... | ["\nassert HexToChar(['48', '45', '4c', '4c', '4f']) == ['H', 'E', 'L', 'L', 'O']\n", "\nassert HexToChar(['77', '6f', '72', '6c', '64']) == ['w', 'o', 'r', 'l', 'd']\n", "\nassert HexToChar(['20']) == [' ']\n", "\nassert HexToChar(['31', '32', '33']) == ['1', '2', '3']\n", "\nassert HexToChar(['41', '42', '43', '44', ... |
b982d5041b6277ff8a169cf531cc0238 | [
{
"content": "Tu gères un système d'inventaire pour un magasin. L'inventaire est représenté comme un dictionnaire où les clés sont les noms des articles et les valeurs sont les quantités de ces articles. On te donne une liste de transactions de vente, chacune représentée comme un tuple contenant le nom de l'art... | ["\nassert update_inventory({\"apples\": 50, \"bananas\": 30, \"oranges\": 20}, [(\"apples\", 10), (\"bananas\", 5)]) == {\"apples\": 40, \"bananas\": 25, \"oranges\": 20}\n", "\nassert update_inventory({\"apples\": 50, \"bananas\": 30, \"oranges\": 20}, [(\"apples\", 60)]) == {\"apples\": 0, \"bananas\": 30, \"oranges... |
540e8596378c00ac4cb67675b25c9bb2 | [
{
"content": "On te donne une liste d'horodatages au format 'AAAA-MM-JJ HH:MM:SS'. Ta tâche est de trier ces horodatages en fonction des composantes heure, minute et seconde dans l'ordre croissant. Plus précisément, le tri doit privilégier la composante heure, puis la composante minute, et enfin la composante s... | ["\nassert sort_dates_by_time(['2023-01-01 12:30:45', '2023-01-01 11:30:45']) == ['2023-01-01 11:30:45', '2023-01-01 12:30:45']\n", "\nassert sort_dates_by_time(['2023-01-01 12:30:45', '2023-01-01 12:29:45']) == ['2023-01-01 12:29:45', '2023-01-01 12:30:45']\n", "\nassert sort_dates_by_time(['2023-01-01 12:30:45', '202... |
dd46c342930c24c8d6163013f247fd33 | [
{
"content": "On te demande d'implémenter une fonction `sanitize_filename` qui traite une chaîne de nom de fichier donnée pour s'assurer qu'elle est compatible avec la plupart des systèmes de fichiers courants. La fonction doit respecter les règles suivantes :\n\n1. Le nom de fichier assaini ne doit inclure que... | ["\nassert sanitize_filename(\"path/to/my:file.txt\") == \"path/to/my_file.txt\"\n", "\nassert sanitize_filename(\"invalid<>filename!.txt\") == \"invalid_filename_.txt\"\n", "\nassert sanitize_filename(\"another:invalid|filename?.txt\") == \"another_invalid_filename_.txt\"\n", "\nassert sanitize_filename(\"valid-filena... |
34f327fcf2bdf2166fb062d4b643690a | [
{
"content": "On te donne une chaîne de caractères `line` constituée de mots séparés par des espaces. Ton objectif est d'implémenter une fonction `count_unique_letters` qui renvoie le nombre de caractères alphabétiques uniques dans la chaîne, en ignorant la casse et les caractères non alphabétiques. Chaque mot ... | ["\nassert count_unique_letters(\"Hello, world!\") == 7\n", "\nassert count_unique_letters(\"This is a test: 123abc.\") == 8\n", "\nassert count_unique_letters(\"Python programming!\") == 11\n", "\nassert count_unique_letters(\"A quick brown fox jumps over the lazy dog.\") == 15\n", "\nassert count_unique_letters(\"123... |
06d178d0d35a9455e8c6d9652e096dee | [
{
"content": "On te demande d'implémenter un gestionnaire de contexte en Python qui gère efficacement les opérations sur les fichiers. Ton gestionnaire de contexte doit être capable d'ouvrir un fichier dans un mode spécifié et de s'assurer que le fichier est correctement fermé après l'exécution de sa suite, mêm... | ["\nassert open_file('test.txt', 'w').__doc__ == \"Context manager for opening and closing a file automatically.\\n\\nArgs:\\nfile_path (str): Path to the file to be opened.\\nmode (str): Mode to open the file in, e.g., 'r', 'w', 'a'.\\n\\nYields:\\nfile: File object that can be used within a `with` statement.\"\n", "\... |
8c0e87542eb9057d6a50c75840c4716b | [
{
"content": "On te donne un fichier binaire. Ta tâche est d'écrire un programme Python qui lit le fichier et compte le nombre d'occurrences de chaque valeur d'octet. Le programme doit afficher les valeurs d'octet par ordre croissant ainsi que leurs décomptes respectifs. Chaque valeur d'octet doit être représen... | ["\nassert count_byte_occurrences('empty_file.bin') == None\n", "\nassert count_byte_occurrences('single_byte_file.bin') == None\n", "\nassert count_byte_occurrences('multiple_bytes_file.bin') == None\n", "\nassert count_byte_occurrences('non_existent_file.bin') == None\n", "\nassert count_byte_occurrences('file_with_r... |
57245093aae2ced0b5d7d2da90eefed4 | [
{
"content": "On te donne un dictionnaire `config_dict` représentant une configuration système. Ce dictionnaire inclut une clé spéciale connue sous le nom de \"clé discriminateur\" qui détermine le type de configuration. La valeur associée à la clé discriminateur est une chaîne de caractères qui identifie le ty... | ["\nassert transform_config({\"type\": \"A\", \"param1\": 1, \"param2\": 2}, \"type\") == {\"A\": {\"param1\": 1, \"param2\": 2}}\n", "\nassert transform_config({\"kind\": \"B\", \"setting1\": 3, \"setting2\": 4}, \"kind\") == {\"B\": {\"setting1\": 3, \"setting2\": 4}}\n", "\nassert transform_config({\"config\": \"C\"... |
67e35fd671356571d90338337612d91a | [
{
"content": "On te donne une liste d'entiers, qui peut inclure des nombres négatifs, et la liste peut être extrêmement grande. Ta tâche est d'implémenter une fonction `remove_duplicates` qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste d'entrée, en préservant l'ordre de leur... | ["\nassert remove_duplicates([1, 2, 3, 2, 1]) == [1, 2, 3]\n", "\nassert remove_duplicates([-1, -2, -3, -2, -1]) == [-1, -2, -3]\n", "\nassert remove_duplicates([10, 20, 30, 40, 50]) == [10, 20, 30, 40, 50]\n", "\nassert remove_duplicates([-10, -20, -30, -40, -50]) == [-10, -20, -30, -40, -50]\n", "\nassert remove_dupl... |
f9116ca1c49607911f213c87ae5c9b91 | [
{
"content": "On te donne un dictionnaire `person_info` contenant les clés `name`, `age` et `address`. Implémente une fonction `update_person_info(person_info, name=None, age=None, address=None)` qui met à jour le dictionnaire avec les arguments fournis. Si un argument n'est pas fourni, la valeur correspondante... | ["\nassert update_person_info({'name': 'John', 'age': 30, 'address': '123 Main St'}, name='Jane') == {'name': 'Jane', 'age': 30, 'address': '123 Main St'}\n", "\nassert update_person_info({'name': 'John', 'age': 30, 'address': '123 Main St'}, age=31) == {'name': 'John', 'age': 31, 'address': '123 Main St'}\n", "\nasser... |
236f45c32893e371c00cb656d5354676 | [
{
"content": "On te demande d'implémenter une fonction pour filtrer un ensemble de données de produits en fonction de divers critères. L'ensemble de données est représenté sous forme de DataFrame pandas avec les colonnes suivantes : 'product_id', 'product_category', 'product_subcategory', 'product_color', 'prod... | ["\nassert get_product_subset(df, category=\"electronics\").equals(df[df['product_category'] == \"electronics\"])\n", "\nassert get_product_subset(df, subcategory=\"smartphones\").equals(df[df['product_subcategory'] == \"smartphones\"])\n", "\nassert get_product_subset(df, color=\"#FFFFFF\").equals(df[df['product_color... |
2ccd2b84a4c66493a1246411c72ef3fb | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est d'écrire une fonction qui compte le nombre de voyelles dans la chaîne. Une voyelle est définie comme l'un des caractères suivants : 'a', 'e', 'i', 'o', 'u'.\n\n**Entrée :**\n- Une seule chaî... | ["\nassert count_vowels(\"hello world\") == 3\n", "\nassert count_vowels(\"aeiou\") == 5\n", "\nassert count_vowels(\"bcdfg\") == 0\n", "\nassert count_vowels(\"abcdefghijklmnopqrstuvwxyz\") == 5\n", "\nassert count_vowels(\"\") == 0\n", "\nassert count_vowels(\"a\") == 1\n", "\nassert count_vowels(\"ae\") == 2\n", "\n... |
3a85a93edea9f2f50972febd97e5616c | [
{
"content": "On te donne un dictionnaire `input_dict` où les clés sont des chaînes de caractères et les valeurs peuvent être de n'importe quel type de données, y compris des listes et d'autres dictionnaires. Ta tâche est de mettre en œuvre une fonction `format_dict_values(input_dict)` qui traite ce dictionnair... | ["\nassert format_dict_values({\"a\": 1, \"b\": 2}) == \"a: 1\\nb: 2\"\n", "\nassert format_dict_values({\"b\": 2, \"a\": 1}) == \"a: 1\\nb: 2\"\n", "\nassert format_dict_values({\"name\": \"Alice\", \"age\": 30}) == \"age: 30\\nname: Alice\"\n", "\nassert format_dict_values({\"fruits\": [\"banana\", \"apple\", \"cherr... |
b223fbcf016b5b7ee53feb88f0f167a3 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction `filter_strings` qui traite cette liste et renvoie une nouvelle liste contenant uniquement les chaînes de caractères qui ont une longueur supérieure à 3 et incluent au moins une voyelle (a, e, i, o, u). L'ordre... | ["\nassert filter_strings([\"hello\", \"hi\", \"world\", \"sky\", \"python\", \"ae\", \"bcd\"]) == ['hello', 'world', 'python']\n", "\nassert filter_strings([\"a\", \"e\", \"i\", \"o\", \"u\"]) == []\n", "\nassert filter_strings([\"abcd\", \"efgh\", \"ijkl\", \"mnop\"]) == []\n", "\nassert filter_strings([\"abcde\", \"... |
458abc2fc047614ef0320c8a998affdb | [
{
"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- **Initialisation** : Créer un compte bancaire avec un solde initial de 0.\n- **Dépôt** : Ajouter un montant spécifié au ... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount().deposit(100) is None\n", "\nassert BankAccount().withdraw(100) is None\n", "\naccount = BankAccount(); account.deposit(100); assert account.get_balance() == 100\n", "\naccount = BankAccount(); account.deposit(100); account.withdraw(50); assert acco... |
b51dbab2da482e3d715950ad25ece024 | [
{
"content": "On te demande d'implémenter une classe `Car` qui simule les fonctionnalités de base d'une voiture. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `make` : une chaîne de caractères représentant le fabricant de la voiture.\n - `model` : une chaîne de caractères ... | ["\nassert Car(\"Toyota\", \"Corolla\", 2021, \"Blue\").speed == 0\n", "\nassert Car(\"Honda\", \"Civic\", 2020, \"Red\", 5).speed == 5\n", "\ncar = Car(\"Ford\", \"Mustang\", 2019, \"Black\")\ncar.accelerate(20)\nassert car.speed == 20\n", "\ncar = Car(\"Chevrolet\", \"Camaro\", 2022, \"Yellow\", 30)\ncar.brake(10)\na... |
da3abb2321a5b209acbacd84eda3f228 | [
{
"content": "Implémente une classe Python nommée `Animal` avec les exigences suivantes :\n\n- La classe doit avoir une méthode d'initialisation qui accepte deux paramètres : `name` et `species`. Ces paramètres doivent être stockés comme des variables d'instance.\n- Implémente une méthode `speak` qui affiche la... | ["\nassert Animal(\"Dog\", \"Canine\").name == \"Dog\"\n", "\nassert Animal(\"Cat\", \"Feline\").species == \"Feline\"\n", "\nassert Animal(\"Lion\", \"Feline\").info() == \"Name: Lion, Species: Feline\"\n", "\nassert Animal(\"Elephant\", \"Mammal\").info() == \"Name: Elephant, Species: Mammal\"\n", "\nassert Animal(\"... |
cd556e723d9d24dcc95aaeb138485fb2 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui trouve le deuxième plus grand élément de la liste. La fonction ne doit utiliser aucune fonction ou méthode intégrée telle que `max()`, `min()`, `sort()`, etc. Si la liste contient moins de deux éléments distincts, l... | ["\nassert find_second_largest([1, 2]) == 1\n", "\nassert find_second_largest([5, 5, 5, 5]) == None\n", "\nassert find_second_largest([10]) == None\n", "\nassert find_second_largest([1, 2, 3, 4, 5]) == 4\n", "\nassert find_second_largest([5, 4, 3, 2, 1]) == 4\n", "\nassert find_second_largest([10, 10, 5, 5, 3, 3, 1, 1]... |
5a14aa879764ebeefad5e31aada9c2ae | [
{
"content": "On te donne une liste de dimensions d'images, où chaque dimension est représentée comme un tuple (largeur, hauteur). Ta tâche est d'écrire une fonction `scale_images` qui redimensionne chaque image pour qu'elle s'adapte à une taille maximale tout en conservant son rapport hauteur/largeur d'origine... | ["\nassert scale_images([(300, 200), (600, 400), (100, 300)], 500) == [(300, 200), (500, 333), (50, 150)]\n", "\nassert scale_images([(100, 100), (200, 200), (300, 300)], 150) == [(100, 100), (150, 150), (150, 150)]\n", "\nassert scale_images([(500, 500), (500, 500), (500, 500)], 500) == [(500, 500), (500, 500), (500, ... |
dc25db47acaffa23b13a1685f4258db7 | [
{
"content": "On te donne une liste d'entiers `numbers` et une somme cible `target`. Ta tâche est de diviser `numbers` en deux listes non vides, `left` et `right`, de telle sorte que la différence absolue entre la somme des éléments dans `left` et la somme des éléments dans `right` soit minimisée et n'excède pa... | ["\nassert split_list([1, 2, 3, 4], 0) == ([1, 4], [2, 3])\n", "\nassert split_list([1, 2, 3, 4], 1) == ([1, 4], [2, 3])\n", "\nassert split_list([1, 2, 3, 4], 2) == ([1, 4], [2, 3])\n", "\nassert split_list([1, 2, 3, 4], 3) == ([1, 4], [2, 3])\n", "\nassert split_list([1, 2, 3, 4], 4) == ([1, 4], [2, 3])\n", "\nassert... |
86a6a6b860c988bf07bff1861c33d8aa | [
{
"content": "On te donne deux séquences, `seq1` et `seq2`. Ta tâche est d'implémenter une fonction `alternating_cartesian_product(seq1, seq2)` qui renvoie une nouvelle séquence contenant le produit cartésien de `seq1` et `seq2` avec un ordre alterné. Le produit cartésien consiste en toutes les paires possibles... | ["\nassert alternating_cartesian_product((1, 2), (3, 4)) == [(1, 3), (3, 1), (2, 4), (4, 2)]\n", "\nassert alternating_cartesian_product(('a', 'b'), ('x', 'y')) == [('a', 'x'), ('x', 'a'), ('b', 'y'), ('y', 'b')]\n", "\nassert alternating_cartesian_product((1,), (2, 3)) == [(1, 2), (2, 1), (1, 3), (3, 1)]\n", "\nassert... |
99b7ec49e37dd15036c70af62fe7b5b4 | [
{
"content": "On te donne une liste de `n` mots, un ensemble de `m` mots vides et une distance maximale `d`. Construis un graphe pondéré où chaque mot est un nœud. Le poids de l'arête entre deux nœuds diminue exponentiellement avec la distance qui les sépare dans la liste. Plus précisément, le poids est divisé ... | ["\nassert np.array_equal(build_graph([\"hello\", \"world\"], set(), 2, 10.0), np.array([[0.0, 10.0], [10.0, 0.0]]))\n", "\nassert np.array_equal(build_graph([\"hello\", \"world\", \"foo\"], {\"foo\"}, 2, 10.0), np.array([[0.0, 10.0, 0.0], [10.0, 0.0, 0.0], [0.0, 0.0, 0.0]]))\n", "\nassert np.array_equal(build_graph([\... |
d9fd7cd8a02665f2719b55f33c75475f | [
{
"content": "On te donne un tableau d'entiers `A` de taille `N`, où chaque élément du tableau est une permutation des nombres de `1` à `N`. Ta tâche est de trouver le premier élément du tableau qui n'est pas à sa position attendue selon la permutation (c'est-à-dire que le nombre `i` doit se trouver à l'index `... | ["\nassert find_first_misplaced_element([1, 2, 3, 4, 5]) == -1\n", "\nassert find_first_misplaced_element([3, 1, 2, 5, 4]) == 3\n", "\nassert find_first_misplaced_element([2, 3, 1, 5, 4]) == 2\n", "\nassert find_first_misplaced_element([4, 3, 2, 1, 5]) == 4\n", "\nassert find_first_misplaced_element([5, 4, 3, 2, 1]) ==... |
cb7a2e945c3622d2f5bed0621dfc32cb | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'écrire une fonction qui calcule l'intersection de ces deux listes, c'est-à-dire une liste des éléments qui sont présents dans les deux listes d'entrée. La liste résultante doit être triée par ordre croissant. Note que les listes d'entrée peuvent co... | ["\nassert find_intersection([1, 2, 3], [2, 3, 4]) == [2, 3]\n", "\nassert find_intersection([5, 6, 7], [8, 9, 10]) == []\n", "\nassert find_intersection([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_intersection([], [1, 2, 3]) == []\n", "\nassert find_intersection([1, 2, 3], []) == []\n", "\nassert find_inters... |
3ad5f86710d198523a08c1df75aa6f17 | [
{
"content": "On te donne une liste d'entiers, qui peut inclure des nombres négatifs et zéro. Ta tâche est de calculer la racine numérique pour chaque entier de la liste. La racine numérique d'un nombre est le chiffre unique obtenu en additionnant de manière répétée les chiffres du nombre jusqu'à ce qu'il ne re... | ["\nassert digital_root_list([16, -10, 135, 0, 999999999, -28]) == [7, 1, 9, 0, 9, 1]\n", "\nassert digital_root_list([0, 0, 0, 0]) == [0, 0, 0, 0]\n", "\nassert digital_root_list([9, 18, 27, 36]) == [9, 9, 9, 9]\n", "\nassert digital_root_list([-9, -18, -27, -36]) == [9, 9, 9, 9]\n", "\nassert digital_root_list([1, 2,... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.