id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
34ed78829b6db0673a797cea673b1dbf | [
{
"content": "On te demande d'implémenter une fonction `extract_db_connection_string(json_file)` pour un projet d'application web. La fonction doit lire un fichier de configuration JSON et extraire la chaîne de connexion à la base de données. Si le fichier JSON n'existe pas, n'est pas un JSON valide, ou ne cont... | ["\nassert extract_db_connection_string(\"valid_config.json\") == \"Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;\"\n", "\nassert extract_db_connection_string(\"missing_database_key.json\") == None\n", "\nassert extract_db_connection_string(\"missing_connection_string_key.json\") ==... |
68bab8ff1e8cfe471df0490ed3f213a8 | [
{
"content": "Tu gères l'inventaire d'un magasin, qui est une liste triée d'identifiants de produits uniques. Le magasin fonctionne selon la contrainte qu'il ne peut vendre qu'une seule unité d'un produit à la fois et doit maintenir la liste d'inventaire triée. Implémente la fonction `sell_product(inventory, pr... | ["\nassert sell_product([1, 2, 3, 4, 5], 3) == True\n", "\nassert sell_product([1, 2, 3, 4, 5], 6) == False\n", "\nassert sell_product([10, 20, 30, 40, 50], 10) == True\n", "\nassert sell_product([10, 20, 30, 40, 50], 50) == True\n", "\nassert sell_product([10, 20, 30, 40, 50], 25) == False\n", "\nassert sell_product([... |
79fc37ada072381558a6153d37b7654e | [
{
"content": "Tu es chargé d'implémenter une fonction `serialize_object` qui convertit un objet donné en un dictionnaire compatible JSON. La fonction doit exclure tous les attributs commençant par un tiret bas (\"_\"). Elle doit gérer les objets imbriqués de profondeur arbitraire et les types personnalisés. Ta ... | ["\nassert serialize_object({\"key\": \"value\", \"_private\": \"should_not_be_here\"}) == {\"key\": \"value\"}\n", "\nassert serialize_object({\"nested\": {\"key\": \"value\", \"_private\": \"should_not_be_here\"}}) == {\"nested\": {\"key\": \"value\"}}\n", "\nassert serialize_object([{\"key\": \"value\"}, {\"_private... |
e5766259226f2a21bd816966ceca2ddb | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer l'inventaire d'une bibliothèque. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Créer un objet `Book` avec les propriétés `title`, `author`, `genre` et `available_copies`. Le nombre de `available_c... | ["\nassert Book(\"1984\", \"George Orwell\", \"Dystopian\", 3).available_copies == 3\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"Fiction\", 0).is_available() == False\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", \"Novel\", 2).borrow_book() == True\n", "\nassert Book(\"The Great ... |
1ffdc116323bddc4982bc891675a3670 | [
{
"content": "On te donne une liste de chaînes de caractères `tweets` représentant des tweets provenant d'une plateforme de réseaux sociaux. Ta tâche est de mettre en œuvre une fonction `filter_tweets_by_language(tweets, language)` qui filtre et renvoie une liste de tweets écrits dans la langue spécifiée. Utili... | ["\nassert filter_tweets_by_language([\"Bonjour, comment \u00e7a va?\", \"Hello, how are you?\", \"Hola, \u00bfc\u00f3mo est\u00e1s?\"], \"en\") == [\"Hello, how are you?\"]\n", "\nassert filter_tweets_by_language([\"Bonjour, comment \u00e7a va?\", \"Hello, how are you?\", \"Hola, \u00bfc\u00f3mo est\u00e1s?\"], \"fr\"... |
e85332b606cfedf31d398b3ce830ec41 | [
{
"content": "On te donne un dictionnaire `input_dict` où chaque clé est un identifiant de chaîne unique et chaque valeur est une liste de tuples. Chaque tuple est composé d'une chaîne `category` et d'un flottant `score`. Ta tâche est de mettre en œuvre une fonction `sort_dict_by_score` qui trie les tuples dans... | ["\nassert sort_dict_by_score({\"item1\": [(\"cat1\", 1.5), (\"cat2\", 2.5), (\"cat3\", 2.5)]}) == {\"item1\": [(\"cat2\", 2.5), (\"cat3\", 2.5), (\"cat1\", 1.5)]}\n", "\nassert sort_dict_by_score({\"item2\": [(\"catA\", 3.0), (\"catB\", 2.0), (\"catC\", 1.0)]}) == {\"item2\": [(\"catA\", 3.0), (\"catB\", 2.0), (\"catC... |
edba65149cb24329cc9f0dcc5563e026 | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses IPv4. Étant donné une chaîne de caractères `ip`, ta fonction doit déterminer si elle représente une adresse IPv4 valide. Une adresse IPv4 est valide si elle répond aux critères suivants :\n- Elle est composée de quatre nombres déci... | ["\nassert validate_ip_address(\"192.168.1.1\") == True\n", "\nassert validate_ip_address(\"255.255.255.255\") == True\n", "\nassert validate_ip_address(\"0.0.0.0\") == True\n", "\nassert validate_ip_address(\"192.168.1.256\") == False\n", "\nassert validate_ip_address(\"192.168.1\") == False\n", "\nassert validate_ip_... |
34389e4457e90e4e008e6e01ae1c5e5c | [
{
"content": "On te donne une matrice constituée d'entiers. Ta tâche est d'écrire une fonction Python qui calcule la valeur maximale dans chaque ligne de la matrice et renvoie ces valeurs dans une liste. On suppose que la matrice n'est pas vide et que chaque ligne contient le même nombre de colonnes.\n\n**Entré... | ["\nassert max_values_in_rows([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [3, 6, 9]\n", "\nassert max_values_in_rows([[10, 20, 30], [25, 5, 15], [50, 40, 60]]) == [30, 25, 60]\n", "\nassert max_values_in_rows([[100], [200], [300]]) == [100, 200, 300]\n", "\nassert max_values_in_rows([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]... |
e5bc97c4e77816ed68bad83fe922aabb | [
{
"content": "On te donne une liste qui peut contenir des entiers ou des sous-listes d'entiers. Ta tâche est d'écrire une fonction `product_of_even_indices` qui calcule le produit des éléments aux indices pairs pour chaque sous-liste, puis renvoie le produit de ces résultats. Si la liste d'entrée est vide ou co... | ["\nassert product_of_even_indices([1, 2, 3, 4]) == 3\n", "\nassert product_of_even_indices([4, 2, 5, 9, 10]) == 40\n", "\nassert product_of_even_indices([]) == 1\n", "\nassert product_of_even_indices([[1, 2, 3], [4, 5, 6]]) == 4\n", "\nassert product_of_even_indices([[1, 2], [], [3, 4, 5]]) == 3\n", "\nassert product_... |
b02c0d7f0671138bfa3e34ee887a7cbf | [
{
"content": "On te donne un fichier CSV nommé `sales_data.csv` contenant des données de ventes pour divers produits. Chaque ligne du fichier CSV représente un produit et inclut les colonnes suivantes : `ProductID`, `ProductName`, `Category`, `Price` et `Quantity`. Ta tâche est d'écrire un programme Python qui ... | ["\nassert calculate_total_sales_per_category('empty.csv') == None\n", "\nassert calculate_total_sales_per_category('single_entry.csv') == None\n", "\nassert calculate_total_sales_per_category('multiple_entries_same_category.csv') == None\n", "\nassert calculate_total_sales_per_category('multiple_categories.csv') == No... |
49788ce740d3b468a28595a874a94d29 | [
{
"content": "On te charge de développer un programme pour une boutique en ligne afin de calculer le coût total des articles dans un panier, taxes comprises. La boutique propose trois catégories d'articles : livres, électronique et vêtements, chacune ayant des taux de taxe distincts de 5 %, 12 % et 10 % respect... | ["\nassert calculate_total([{\"item_type\": \"book\", \"price\": 10.00, \"quantity\": 1}]) == 10.50\n", "\nassert calculate_total([{\"item_type\": \"electronics\", \"price\": 100.00, \"quantity\": 1}]) == 112.00\n", "\nassert calculate_total([{\"item_type\": \"clothing\", \"price\": 50.00, \"quantity\": 1}]) == 55.00\n... |
2639493958a3c1b1c64f4c4431db8306 | [
{
"content": "On te donne une base de données de bibliothèque avec une table nommée `books` qui contient les colonnes `book_title`, `author` et `publication_year`. Ta tâche est de mettre en œuvre une fonction `add_book` qui ajoute un nouveau livre à cette base de données. La fonction doit prendre quatre paramèt... | ["\nassert add_book(db_connection, \"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925) > 0\n", "\nassert add_book(db_connection, \"1984\", \"George Orwell\", 1949) > 0\n", "\nassert add_book(db_connection, \"To Kill a Mockingbird\", \"Harper Lee\", 1960) > 0\n", "\nassert add_book(db_connection, \"The Catcher in the R... |
26ce5caea869f712431833202393bdb7 | [
{
"content": "On te donne une liste de tuples, `frequency_list`, où chaque tuple est composé d'une valeur de fréquence et d'une étiquette correspondante. La liste est triée par ordre décroissant en fonction des valeurs de fréquence. Ta tâche est de mettre en œuvre une fonction `dominance_ratio(frequency_list)` ... | ["\nassert dominance_ratio([(10, 'apple'), (5, 'banana'), (5, 'apple'), (3, 'cherry')]) == 3.0\n", "\nassert dominance_ratio([(20, 'dog'), (15, 'cat'), (10, 'dog'), (5, 'bird')]) == 2.67\n", "\nassert dominance_ratio([(100, 'red'), (50, 'blue'), (50, 'red'), (25, 'green')]) == 4.0\n", "\nassert dominance_ratio([(8, 'ca... |
99b1b8add59e8971effb451f35844c62 | [
{
"content": "On te demande de concevoir un point de terminaison d'API RESTful utilisant Flask qui accepte une charge utile JSON contenant des informations sur l'utilisateur (nom, email, âge) et les stocke dans une base de données SQLite. L'API doit valider les données d'entrée selon les règles suivantes :\n- L... | ["\nassert add_user() == jsonify({\"error\": \"Invalid request payload\"}), 400\n", "\nassert add_user({\"name\": \"John Doe\", \"email\": \"johndoe@example.com\", \"age\": 30}) == jsonify({\"message\": \"User added successfully\"}), 201\n", "\nassert add_user({\"name\": \"Jane\", \"email\": \"jane\", \"age\": 25}) == ... |
efb3a209fa84896beafd5f9bcbfd0d0a | [
{
"content": "On te donne une chaîne de caractères `sentence` représentant une seule phrase. Ta tâche est de déterminer si la phrase est grammaticalement correcte. Une phrase est considérée comme grammaticalement correcte si elle commence par une majuscule et se termine par un point ('.'). La phrase d'entrée ne... | ["\nassert is_grammatically_correct(\"This is a correct sentence.\") == True\n", "\nassert is_grammatically_correct(\"this is an incorrect sentence\") == False\n", "\nassert is_grammatically_correct(\"Another correct sentence.\") == True\n", "\nassert is_grammatically_correct(\"incorrect sentence.\") == False\n", "\nas... |
bf886aae2072e91d6e9d56afa20f89d4 | [
{
"content": "On te demande d'implémenter une fonction pour vérifier la validité d'un numéro ISBN-13. Un ISBN-13 est considéré comme valide si la somme de ses chiffres, chaque chiffre alterné à partir de la gauche étant multiplié par 1 et le suivant par 3, est divisible par 10. Ta fonction doit renvoyer `True` ... | ["\nassert is_valid_isbn13(\"9780306406157\") == True\n", "\nassert is_valid_isbn13(\"9780306406158\") == False\n", "\nassert is_valid_isbn13(\"0306406152\") == False\n", "\nassert is_valid_isbn13(\"978030640615\") == False\n", "\nassert is_valid_isbn13(\"97803064061577\") == False\n", "\nassert is_valid_isbn13(\"97803... |
b4946323f0c30ea0a0ade6c429e9d705 | [
{
"content": "On te demande d'implémenter une fonction `read_matrix_from_file` qui lit une matrice à partir d'un fichier texte et renvoie la matrice ainsi qu'un booléen indiquant le succès de l'opération. La fonction doit gérer les erreurs de permission de fichier, ignorer les lignes commençant par `#` (insensi... | ["\nassert read_matrix_from_file(\"test_matrix_1.txt\") == ([[1, 2, 3], [4, 5, 6]], True)\n", "\nassert read_matrix_from_file(\"test_matrix_2.txt\") == ([[1000, -1000], [0, 500]], True)\n", "\nassert read_matrix_from_file(\"test_matrix_3.txt\") == (None, False) # Invalid number\n", "\nassert read_matrix_from_file(\"te... |
df484b93cdb5e63f79ea6288532f5981 | [
{
"content": "On te donne un entier `n` et un entier `k`. Implémente la fonction `is_probable_prime(n, k)` qui détermine si `n` est un nombre premier probable en utilisant le test de primalité de Miller-Rabin avec `k` itérations. Pour chaque itération, utilise un non-résidu quadratique modulo `n` comme base. Un... | ["\nassert is_probable_prime(2, 5) == True\n", "\nassert is_probable_prime(3, 5) == True\n", "\nassert is_probable_prime(4, 5) == False\n", "\nassert is_probable_prime(5, 5) == True\n", "\nassert is_probable_prime(10, 5) == False\n", "\nassert is_probable_prime(17, 5) == True\n", "\nassert is_probable_prime(18, 5) == F... |
addae5ad7d68a96fba3c70792aa44d7e | [
{
"content": "On te donne une chaîne de caractères au format `snake_case`. Ta tâche est d'écrire une fonction `snakeCaseToCamel` qui convertit cette chaîne au format `CamelCase`. Tu **n'es pas** autorisé à utiliser la fonction `split`.\n\n**Entrée :**\n- Une seule chaîne de caractères `snake_str` (1 ≤ len(snake... | ["\nassert snakeCaseToCamel(\"this_is_a_test_string\") == \"ThisIsATestString\"\n", "\nassert snakeCaseToCamel(\"hello_world\") == \"HelloWorld\"\n", "\nassert snakeCaseToCamel(\"snake_case_to_camel\") == \"SnakeCaseToCamel\"\n", "\nassert snakeCaseToCamel(\"singleword\") == \"Singleword\"\n", "\nassert snakeCaseToCame... |
1c772f6e87f888196bc7c370c7816dec | [
{
"content": "On te donne une chaîne de caractères `text` et un entier `max_length`. Ta tâche est de mettre en œuvre une fonction `word_wrap` qui divise le `text` en lignes de sorte qu'aucune ligne ne dépasse `max_length` caractères et qu'aucune ligne ne contienne plus de 10 mots. Les mots doivent être divisés ... | ["\nassert word_wrap(\"This is a simple test\", 10) == [\"This is a\", \"simple test\"]\n", "\nassert word_wrap(\"OneWordThatIsTooLongToFit\", 10) == [\"OneWordThatIsTooLongToFit\"]\n", "\nassert word_wrap(\"Short words only\", 5) == [\"Short\", \"words\", \"only\"]\n", "\nassert word_wrap(\"Many many many many many ma... |
5701f875650679731711473f2ea7f22d | [
{
"content": "On te donne une classe `MyClass` avec plusieurs attributs statiques. Ta tâche est d'implémenter une fonction `get_attribute_names(cls)` qui renvoie une liste des noms de tous les attributs statiques de la classe donnée, en excluant tous les attributs dont les noms commencent par un tiret bas.\n\n*... | ["\nassert get_attribute_names(MyClass) == ['public_attr']\n", "\nassert get_attribute_names(MyClass) == ['public_attr1', 'public_attr2']\n", "\nassert get_attribute_names(MyClass) == []\n", "\nassert get_attribute_names(MyClass) == ['attr1', 'attr2', 'attr3']\n", "\nassert get_attribute_names(MyClass) == ['public']\n"... |
a80f23489e7d4859d1c4042c7276bfb4 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif. Si l'entrée est négative, la fonction doit renvoyer `None`. Ta fonction doit être robuste et gérer correctement les cas limites.\n\n**Entrée :**\n- Un seul entier `n` tel que `-10 <= n <= 10`.\... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(-1) == None\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(3) == 6\n", "\nassert factorial(-5) == None\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(20) == 2432902008176640... |
76a5a64aad97aefbc5934ff7dfde4045 | [
{
"content": "Tu participes à une compétition de science des données où tu dois implémenter une fonction de scoring personnalisée. Ta tâche est d'écrire une fonction nommée `modified_brier_score_loss` qui calcule une version modifiée du score de Brier. Le score de Brier est une métrique utilisée pour évaluer la... | ["\nassert modified_brier_score_loss([0, 1], [0.1, 0.9]) == 0.02\n", "\nassert modified_brier_score_loss([1, 0], [0.9, 0.1]) == 0.02\n", "\nassert modified_brier_score_loss([1, 1], [0.8, 0.8]) == 0.04\n", "\nassert modified_brier_score_loss([0, 0], [0.2, 0.2]) == 0.04\n", "\nassert modified_brier_score_loss([1, 0, 1], ... |
7e5b9c8d4dab5918fdd8dd63a84a82db | [
{
"content": "On te donne les nœuds racines de deux arbres binaires. Ta tâche est de déterminer si les deux arbres sont identiques. Deux arbres binaires sont considérés comme identiques s'ils ont la même structure et que leurs nœuds correspondants ont les mêmes valeurs.\n\n**Entrée :**\n- L'entrée consiste en d... | ["\nassert are_identical_trees(TreeNode(1), TreeNode(1)) == True\n", "\nassert are_identical_trees(TreeNode(1, TreeNode(2)), TreeNode(1, TreeNode(2))) == True\n", "\nassert are_identical_trees(TreeNode(1, TreeNode(2)), TreeNode(1, TreeNode(3))) == False\n", "\nassert are_identical_trees(TreeNode(1, TreeNode(2), TreeNod... |
7d168df39ec193a8ae3d72f09196bdd4 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'inverser la chaîne sur place avec une complexité spatiale supplémentaire de O(1). Implémente la fonction `reverse_string` pour y parvenir.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10^5), composée de lettres minuscules... | ["\nassert reverse_string(\"hello\") == \"olleh\"\n", "\nassert reverse_string(\"world\") == \"dlrow\"\n", "\nassert reverse_string(\"a\") == \"a\"\n", "\nassert reverse_string(\"\") == \"\"\n", "\nassert reverse_string(\"racecar\") == \"racecar\"\n", "\nassert reverse_string(\"Python\") == \"nohtyP\"\n", "\nassert rev... |
47fee7c09c5c332887214957bf39d03e | [
{
"content": "On te donne une liste de chemins de fichiers `file_paths`. Ta tâche est d'implémenter une fonction `get_file_info(file_paths)` qui renvoie un dictionnaire. Chaque clé du dictionnaire doit être une extension de fichier, et la valeur correspondante doit être une liste de noms de fichiers qui ont cet... | ["\nassert get_file_info(['file1.txt', 'file2.docx', 'image1.jpg', 'notes.txt']) == {'txt': ['file1.txt', 'notes.txt'], 'docx': ['file2.docx'], 'jpg': ['image1.jpg']}\n", "\nassert get_file_info(['report.pdf', 'summary.pdf', 'presentation.pptx']) == {'pdf': ['report.pdf', 'summary.pdf'], 'pptx': ['presentation.pptx']}\... |
7ae7c20c0f2e3890e2c7f2818bedffec | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction qui affiche tous les nombres premiers inférieurs à `n`. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même.\n\n**Entrée :**\n- Un entier `n` (2 ≤ n ≤ 10^6)\n\n**Sorti... | ["\nassert printPrimes(10) == None # This function prints primes, does not return them\n", "\nassert printPrimes(1) == None # No primes less than 2\n", "\nassert printPrimes(2) == None # 2 is the only prime less than 3\n", "\nassert printPrimes(3) == None # 2 is the only prime less than 3\n", "\nassert printPrimes(... |
6f9995157a15042ed6697475ab733980 | [
{
"content": "On te donne une chaîne de caractères `expression`, une chaîne de caractères `pattern`, et une chaîne de caractères `replacement`. Ta tâche est d'implémenter une fonction `find_and_replace_pattern` qui remplace toutes les occurrences de `pattern` dans `expression` par `replacement`. La fonction doi... | ["\nassert find_and_replace_pattern(\"hello world\", \"world\", \"there\") == \"hello there\"\n", "\nassert find_and_replace_pattern(\"abcabcabc\", \"abc\", \"xyz\") == \"xyzxyzxyz\"\n", "\nassert find_and_replace_pattern(\"mississippi\", \"issi\", \"xxxx\") == \"mxxxxppi\"\n", "\nassert find_and_replace_pattern(\"case... |
06f5153a565faca909cd8e34d68c3015 | [
{
"content": "On te donne un tableau d'entiers. Implémente l'algorithme QuickSort pour trier le tableau par ordre croissant. Ton implémentation ne doit pas utiliser de fonctions de tri intégrées. La première ligne de l'entrée contient un entier `n`, le nombre d'éléments dans le tableau. La deuxième ligne contie... | ["\nassert quicksort([3, 6, 8, 10, 1, 2, 1]) == [1, 1, 2, 3, 6, 8, 10]\n", "\nassert quicksort([10, 7, 8, 9, 1, 5]) == [1, 5, 7, 8, 9, 10]\n", "\nassert quicksort([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]... |
833e2c84eac769c17b9ec545009c04c5 | [
{
"content": "On te demande de créer une fonction `sanitize_identifier` qui traite une chaîne de caractères donnée pour s'assurer qu'elle respecte les règles d'identification de Python. Un identifiant Python valide doit commencer par une lettre ou un tiret bas, suivi d'un nombre quelconque de lettres, de chiffr... | ["\nassert sanitize_identifier(\"class\") == \"class_bi\"\n", "\nassert sanitize_identifier(\"1variable\") == \"_1variable\"\n", "\nassert sanitize_identifier(\"validIdentifierNameThatIsWayTooLong\") == \"validIdentifi\"\n", "\nassert sanitize_identifier(\"for\") == \"for_bi\"\n", "\nassert sanitize_identifier(\"print\... |
756e08fb248c77315a02bc3fba2afd03 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente une phrase. Ta tâche est d'écrire une fonction qui traite ces phrases en supprimant la ponctuation, en convertissant tous les caractères en minuscules, puis en divisant chaque phrase en une liste de mots. La fonction doit ... | ["\nassert process_sentences([\"Hello, world!\"]) == [[\"hello\", \"world\"]]\n", "\nassert process_sentences([\"Python is great, isn't it?\"]) == [[\"python\", \"is\", \"great\", \"isnt\", \"it\"]]\n", "\nassert process_sentences([\"This is a test.\"]) == [[\"this\", \"is\", \"a\", \"test\"]]\n", "\nassert process_sen... |
bb38fdfb948119327ce09dc03cb2f656 | [
{
"content": "On te donne trois entiers, `x`, `y` et `z`. Ta tâche est de calculer la valeur de `d` en utilisant les expressions suivantes :\n- `a = x * (y + z)`\n- `b = (x + y) * z`\n- `c = (x + y) * (y + z)`\n- `d = a + b + c`\n\nRefactorise l'extrait de code fourni pour améliorer sa lisibilité et sa maintena... | ["\nassert calculate_expression() == None\n", "\nimport io\nimport sys\ncaptured_output = io.StringIO()\nsys.stdout = captured_output\ncalculate_expression()\nsys.stdout = sys.__stdout__\nassert captured_output.getvalue().strip() == \"The value of d is: 25\"\n", "\nimport io\nimport sys\ncaptured_output = io.StringIO()... |
a901e04925bfa15769dd752c2bd686fd | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif donné. La factorielle d'un entier non négatif \\( n \\) est le produit de tous les entiers positifs inférieurs ou égaux à \\( n \\). La factorielle de 0 est définie comme 1. Ta fonction doit gér... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(2) == 2\n", "\nassert factorial(3) == 6\n", "\nassert factorial(4) == 24\n", "\nassert factorial(5) == 120\n", "\nassert factorial(6) == 720\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factor... |
418360bd85b4500b40df01b41547420e | [
{
"content": "On te donne un tableau 2D `coordinates` où chaque ligne représente un rectangle défini par ses coordonnées de centre `(center_x, center_y)`, sa `width` et sa `height`. Ta tâche est de convertir ces coordonnées dans le format `(x1, y1, x2, y2)`, où `(x1, y1)` est le coin supérieur gauche et `(x2, y... | ["\nassert convert_coordinates([[1, 1, 2, 2]]) == [(0.0, 0.0, 2.0, 2.0)]\n", "\nassert convert_coordinates([[0, 0, 4, 4], [2, 2, 2, 2]]) == [(-2.0, -2.0, 2.0, 2.0), (1.0, 1.0, 3.0, 3.0)]\n", "\nassert convert_coordinates([[5, 5, 10, 5], [3, 3, 6, 6]]) == [(0.0, 2.5, 10.0, 7.5), (-1.5, -1.5, 7.5, 7.5)]\n", "\nassert con... |
aa6252792ecc361a5a0a4ce4ae484aa1 | [
{
"content": "On te donne pour tâche d'implémenter une fonction `get_customer_group` qui catégorise les clients en fonction de leur nombre total d'achats. La fonction doit renvoyer une chaîne de caractères représentant le groupe de clients selon les règles suivantes :\n\n- \"new_customers\" si le nombre total d... | ["\nassert get_customer_group(-1) == \"Invalid purchase count\"\n", "\nassert get_customer_group(0) == \"new_customers\"\n", "\nassert get_customer_group(4) == \"new_customers\"\n", "\nassert get_customer_group(5) == \"regular_customers\"\n", "\nassert get_customer_group(10) == \"regular_customers\"\n", "\nassert get_c... |
3f13f02859b4b71a46d11712c9c02357 | [
{
"content": "On te donne une matrice carrée d'entiers. Ta tâche est d'écrire une fonction `calculate_determinant` qui calcule le déterminant de la matrice en utilisant la méthode du développement de Laplace. Pour optimiser la fonction, utilise la mémoïsation pour stocker les déterminants déjà calculés des sous... | ["\nassert calculate_determinant([[1]]) == 1\n", "\nassert calculate_determinant([[4, 7], [2, 6]]) == 10\n", "\nassert calculate_determinant([[1, 2, 3], [0, 4, 5], [1, 0, 6]]) == 41\n", "\nassert calculate_determinant([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == 1\n", "\nassert calculate_determinant([[1, 2], [3, 4]]) == -2\n"... |
241153bfc179114951f10cba09b9a264 | [
{
"content": "Tu développes une interface en ligne de commande (CLI) pour un logiciel nommé \"StarTracker\" utilisé dans le traitement des données astronomiques. La CLI doit accepter des paramètres spécifiques pour effectuer des opérations sur les données célestes. Les paramètres sont les suivants :\n- `observa... | ["\nassert generate_command(\"obs1\", \"cal2\", \"2023-09-22T08:00:00Z\", \"2023-09-22T16:00:00Z\") == \"StarTracker --observation_id=obs1 --calibration_id=cal2 --start_time='2023-09-22T08:00:00Z' --end_time='2023-09-22T16:00:00Z'\"\n", "\nassert generate_command(\"obs123456789\", \"cal123456789\", \"2023-01-01T00:00:0... |
43b68cc4cae9e37f29331b88e426d1c0 | [
{
"content": "On te donne une chaîne de caractères représentant un nombre fractionnaire dans un format unique. La chaîne commence par le caractère 'x', suivi soit d'une seule fraction, soit d'un nombre mixte. Une fraction simple est représentée par un numérateur et un dénominateur séparés par une barre oblique ... | ["\nassert convert_fractional_string_to_decimal(\"x3/4\") == 0.75\n", "\nassert convert_fractional_string_to_decimal(\"x-1 3/4\") == -1.75\n", "\nassert convert_fractional_string_to_decimal(\"x5/2\") == 2.5\n", "\nassert convert_fractional_string_to_decimal(\"x-7/3\") == -2.3333333333333335\n", "\nassert convert_fracti... |
528f45e396d964becc687a733fb139d5 | [
{
"content": "On te demande d'implémenter une classe `BookManager` en Python pour gérer une collection de livres. Chaque livre a les attributs suivants : titre, auteur et année de publication. Ta classe doit prendre en charge les opérations suivantes :\n\n1. `add_book(title, author, year_of_publication)` : Ajou... | ["\nassert BookManager().add_book(\"1984\", \"George Orwell\", 1949) is None\n", "\nassert BookManager().remove_book(\"1984\") is None\n", "\nassert BookManager().find_book_by_title(\"1984\") is None\n", "\nassert BookManager().list_all_books() == []\n", "\nmanager = BookManager(); manager.add_book(\"1984\", \"George O... |
5b60df88992e32e5817e66412db86c05 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence croissante (PSC) dans la liste. La PSC est définie comme la plus longue sous-séquence où chaque élément est supérieur au précédent. S'il existe plusieurs PSC de même longueur, renvoie l'une d'entre elles.\n\n**En... | ["\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 18]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7, 7, 7]) == [7]\n", "\nassert longest_increasing_subsequence([1, 2, 3, 4, 5]) == [1, 2, 3, ... |
783230921f3bc55af66fb17461d8fa34 | [
{
"content": "On te donne deux séquences d'ADN `dna1` et `dna2` composées des caractères 'A', 'T', 'C' et 'G'. Ta tâche est d'écrire une fonction `dna_hamming_distance(dna1, dna2)` qui calcule la distance de Hamming entre ces deux séquences. La distance de Hamming est définie comme le nombre de positions auxque... | ["\nassert dna_hamming_distance(\"GATTACA\", \"GACTATA\") == 3\n", "\nassert dna_hamming_distance(\"AAAA\", \"AAAA\") == 0\n", "\nassert dna_hamming_distance(\"ATCG\", \"CGAT\") == 4\n", "\nassert dna_hamming_distance(\"GCTAGCTA\", \"GCTAGCTA\") == 0\n", "\nassert dna_hamming_distance(\"GCTAGCTA\", \"GCTAGCTG\") == 1\n... |
a298e2261f7bf2dfbadcb729e24896de | [
{
"content": "On te donne une fonction qui effectue une soustraction sur des nombres réels. Ta tâche est de modifier cette fonction pour gérer également les nombres complexes. La fonction doit prendre deux nombres complexes en entrée et renvoyer leur différence.\n\n**Entrée :**\n- Deux nombres complexes `a` et ... | ["\nassert subtract_numbers(3+4j, 1+2j) == 2+2j\n", "\nassert subtract_numbers(5-3j, 2+1j) == 3-4j\n", "\nassert subtract_numbers(-1+2j, -3-4j) == 2+6j\n", "\nassert subtract_numbers(0+0j, 0+0j) == 0+0j\n", "\nassert subtract_numbers(10+0j, 5+0j) == 5+0j\n", "\nassert subtract_numbers(0+10j, 0+5j) == 0+5j\n", "\nassert... |
723c1d854b91428ee396046d88f1d3c6 | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente les coordonnées d'un point dans un plan 2D. Ta tâche est d'écrire une fonction `sort_points_by_distance(points)` qui trie ces points en fonction de leur distance euclidienne à l'origine (0, 0) par ordre croissant. La fonction doit renvoye... | ["\nassert sort_points_by_distance([(0, 0)]) == [(0, 0)]\n", "\nassert sort_points_by_distance([(1, 0), (0, 1), (-1, 0), (0, -1)]) == [(0, 1), (1, 0), (0, -1), (-1, 0)]\n", "\nassert sort_points_by_distance([(3, 4), (4, 3), (0, 5), (5, 0)]) == [(3, 4), (4, 3), (0, 5), (5, 0)]\n", "\nassert sort_points_by_distance([(0, ... |
643dc244ceb4b95e026fa252d250a896 | [
{
"content": "On te donne une chaîne de caractères `text` contenant un mélange de mots et d'adresses e-mail. Ta tâche est d'écrire une fonction Python qui extrait toutes les adresses e-mail uniques de la chaîne en utilisant des expressions régulières. La fonction doit renvoyer une liste de ces adresses e-mail u... | ["\nassert find_unique_emails(\"Please contact us at support@example.com or sales@example.com for more information.\") == ['support@example.com', 'sales@example.com']\n", "\nassert find_unique_emails(\"No emails here!\") == []\n", "\nassert find_unique_emails(\"Multiple emails: test1@test.com, test2@test.com, test1@tes... |
d5c829722cd0e9baac4a4e620e9e1377 | [
{
"content": "On te donne une liste de mots uniques extraits d'un livre. Ta tâche est de mettre en œuvre une fonction qui prend cette liste en entrée et renvoie un dictionnaire. Chaque clé du dictionnaire doit être un mot de la liste, et sa valeur correspondante doit être un entier aléatoire compris entre 1 et ... | ["\nassert isinstance(word_frequency([\"hello\", \"world\"]), dict)\n", "\nassert all(isinstance(count, int) for count in word_frequency([\"hello\", \"world\"]).values())\n", "\nassert all(1 <= count <= 10 for count in word_frequency([\"hello\", \"world\"]).values())\n", "\nassert len(word_frequency([\"hello\", \"world... |
1eb89663f5ba5a2de674e1a14e524cd0 | [
{
"content": "On te demande d'écrire un script Python pour traiter un fichier CSV contenant des données clients. Le fichier CSV comprend les colonnes suivantes : `customer_id`, `first_name`, `last_name`, `email` et `phone_number`. Ton script doit valider le champ `phone_number` selon le format `(xxx) xxx-xxxx`,... | ["\nassert validate_phone_number(\"(123) 456-7890\") == True\n", "\nassert validate_phone_number(\"123-456-7890\") == False\n", "\nassert validate_phone_number(\"(123)456-7890\") == False\n", "\nassert validate_phone_number(\"(123) 4567-890\") == False\n", "\nassert validate_phone_number(\"(123) 456-789\") == False\n",... |
a1cad0629f3611b9f98133dca2e21e33 | [
{
"content": "On te donne la tâche de concevoir une fonction pour calculer la longueur totale de fil nécessaire à la construction d'une spirale circulaire. La spirale est constituée de `N` cercles concentriques, chaque cercle suivant ayant un rayon supérieur de `d` unités au précédent. De plus, le fil utilisé a... | ["\nassert spiral_wire_length(1, 1) == 2 * math.pi * 1 + 0.1\n", "\nassert spiral_wire_length(2, 1) == 2 * math.pi * 1 + 2 * math.pi * 2 + 0.2\n", "\nassert spiral_wire_length(3, 2) == 2 * math.pi * 2 + 2 * math.pi * 4 + 2 * math.pi * 6 + 0.3\n", "\nassert spiral_wire_length(0, 5) == 0\n", "\nassert spiral_wire_length(... |
2ac3cc5ece92f762db29475224620e44 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui traite cette chaîne et renvoie une nouvelle chaîne où tous les caractères consécutifs en double sont supprimés. La fonction doit être sensible à la casse, ce qui signifie que les lettres majuscules et minuscules doive... | ["\nassert remove_consecutive_duplicates(\"aabbcc\") == \"abc\"\n", "\nassert remove_consecutive_duplicates(\"abc\") == \"abc\"\n", "\nassert remove_consecutive_duplicates(\"aaabbbccc\") == \"abc\"\n", "\nassert remove_consecutive_duplicates(\"a\") == \"a\"\n", "\nassert remove_consecutive_duplicates(\"\") == \"\"\n", ... |
07f179f0929b888eadb46c882e42065f | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `sort_and_deduplicate` qui traite cette liste et renvoie une nouvelle liste contenant les éléments uniques de la liste originale, triés par ordre croissant.\n\n**Entrée :**\n- Une liste d'entiers, `numbers`, où `0 <= len(numbers) ... | ["\nassert sort_and_deduplicate([5, 3, 9, 3, 2, 7, 9, 1]) == [1, 2, 3, 5, 7, 9]\n", "\nassert sort_and_deduplicate([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert sort_and_deduplicate([1, 1, 1, 1, 1]) == [1]\n", "\nassert sort_and_deduplicate([]) == []\n", "\nassert sort_and_deduplicate([5, 4, 3, 2, 1]) == [1, 2, 3... |
ad935d81128df15c1b97c1870d26ce19 | [
{
"content": "Écris une fonction récursive en Python pour calculer le nième nombre de Fibonacci. La séquence de Fibonacci est définie comme suit : F(1) = 0, F(2) = 1, et F(n) = F(n-1) + F(n-2) pour n > 2. Ta fonction doit gérer les entrées invalides avec élégance en renvoyant un message approprié.\n\n**Exemple ... | ["\nassert fibonacci(1) == 0\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 1\n", "\nassert fibonacci(4) == 2\n", "\nassert fibonacci(5) == 3\n", "\nassert fibonacci(6) == 5\n", "\nassert fibonacci(7) == 8\n", "\nassert fibonacci(8) == 13\n", "\nassert fibonacci(9) == 21\n", "\nassert fibonacci(10) == 34... |
182fb2b00b5c90ef584ead1ad084050a | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `count_unique_words(s)` qui renvoie le nombre de mots uniques dans la chaîne, sans tenir compte de la casse et en excluant les mots vides anglais courants : \"a\", \"an\", \"the\", \"and\", \"but\", \"or\", \"if... | ["\nassert count_unique_words(\"The quick brown fox jumps over the lazy dog\") == 8\n", "\nassert count_unique_words(\"a an the and but or if in of for to with\") == 0\n", "\nassert count_unique_words(\"Hello world hello\") == 2\n", "\nassert count_unique_words(\"Python, Java, and C++ are programming languages.\") == 6... |
f922a03a6d0c3bcf82c9d16cf6666d45 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres anglaises majuscules et minuscules et d'espaces. Ta tâche est de convertir cette chaîne en `snake_case`. En `snake_case`, toutes les lettres sont en minuscules et les mots sont séparés par des tirets bas. S'il y a plusieurs lettres majus... | ["\nassert convert_to_snake_case(\"ConvertToSnakeCase\") == \"convert_to_snake_case\"\n", "\nassert convert_to_snake_case(\"ThisIsATest\") == \"this_is_a_test\"\n", "\nassert convert_to_snake_case(\"multipleSpaces here\") == \"multiple_spaces___here\"\n", "\nassert convert_to_snake_case(\"Already_snake_case\") == \"a... |
533c35759be0f9c347361497c0d2d024 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci efficacement. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Ta fonction doit gérer efficacement les grandes valeurs de n.\n\n**Entrée :**\n- Un entier `n` ... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(25... |
cbd278e1184fa129d9258a6a427f9aec | [
{
"content": "Tu développes un jeu où les joueurs peuvent collecter divers objets, chacun ayant un nom et un poids uniques. Le joueur peut transporter un poids maximum de 50 unités. Étant donné une liste d'objets et leurs poids respectifs, détermine le nombre maximum d'objets qu'un joueur peut collecter sans dé... | ["\nassert max_items_within_weight({\"Potion\": 2, \"Sword\": 15, \"Shield\": 20, \"Map\": 1, \"Key\": 1, \"Axe\": 10, \"Helmet\": 5}, 50) == [\"Potion\", \"Sword\", \"Shield\", \"Map\", \"Key\", \"Axe\", \"Helmet\"]\n", "\nassert max_items_within_weight({\"Potion\": 2, \"Sword\": 15, \"Shield\": 20, \"Map\": 1, \"Key\... |
efaa93ce33bb4c201d7c28b8977cf880 | [
{
"content": "On te donne une chaîne de caractères représentant une expression d'unité complexe. L'expression peut inclure des préfixes, des unités, des opérations mathématiques et des unités logarithmiques. Ta tâche est d'analyser et de simplifier l'expression sous sa forme la plus simple. Les préfixes corresp... | ["\nassert simplify_unit_expression(\"m\") == ([\"m\"], 1.0)\n", "\nassert simplify_unit_expression(\"km\") == ([\"m\"], 1000.0)\n", "\nassert simplify_unit_expression(\"m^2\") == ([\"m\", \"^\", \"2\"], 1.0)\n", "\nassert simplify_unit_expression(\"kmm^2\") == ([\"m\", \"*\", \"m\", \"^\", \"2\"], 1000.0)\n", "\nasser... |
66a2602c506c635f527362b25a92485b | [
{
"content": "On te donne une chaîne de caractères représentant une fonction Python. Ta tâche est d'analyser la fonction et de renvoyer une liste de tous les noms de variables uniques utilisés dans le corps de la fonction. N'inclus pas les arguments de la fonction ou le nom de la fonction dans ta sortie. La fon... | ["\nassert extract_variable_names(\"def foo():\\n x = 10\\n y = 20\") == [\"x\", \"y\"]\n", "\nassert extract_variable_names(\"def bar():\\n a = 5\\n b = a + 3\\n c = b * 2\") == [\"a\", \"b\", \"c\"]\n", "\nassert extract_variable_names(\"def baz():\\n result = 42\") == [\"result\"]\n", "\nassert extract_variabl... |
ab9b5ddd7e0d9856cfdef18b46ac278b | [
{
"content": "Tu es chargé d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n- `deposit(amount)` : Ajoute le montant spécifié au solde du compte si le montant est valide.\n- `withdraw(amount)` : Déduit le montant spécifié du solde du compte si le mont... | ["\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.deposit(-50)\nassert account.check_balance() == 100\n", "\naccount = BankAccount(10... |
88369814108c8784067d95423fa125cb | [
{
"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 facultatif. Le solde initial ne doit pas être négati... | ["\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount(50).deposit(50) or BankAccount(50).get_balance() == 100\n", "\nassert BankAccount(100).withdraw(50) or BankAccount(100).get_balance() == 50\n", "\nassert BankAccount(100).deposit(0) or BankAccount(1... |
414713db21a45468d9da2633c62fa59d | [
{
"content": "On te donne un fichier texte nommé `input.txt` et un mot à rechercher en tant qu'arguments de ligne de commande. Ta tâche est d'écrire un script qui compte le nombre d'occurrences du mot spécifié dans le fichier et affiche le résultat. La recherche du mot est sensible à la casse et le mot peut app... | ["\nassert count_word_in_file(\"input.txt\", \"test\") == None\n", "\nassert count_word_in_file(\"nonexistentfile.txt\", \"test\") == None\n", "\nassert count_word_in_file(\"input.txt\", \"word\") == None\n", "\nassert count_word_in_file(\"input.txt\", \"\") == None\n", "\nassert count_word_in_file(\"\", \"test\") == N... |
e81e0ec3f2a8067a2b88022bcfd32568 | [
{
"content": "On te donne un ensemble de données `X` constitué de `N` points de données en `D` dimensions, représenté sous forme d'une matrice de forme `(N, D)`. De plus, tu as `M` hypothèses `H` et `M` objectifs `G`, chacun représenté par des matrices de forme `(D, M)`. On te fournit également une matrice de p... | ["\nassert np.allclose(compute_alignment(np.array([[1, 0], [0, 1]]), np.array([[1, 0], [0, 1]]), np.array([[1, 0], [0, 1]]), np.array([[1, 1]]), np.eye(2), np.eye(2)), np.array([[2, 2]]), atol=1e-5)\n", "\nassert np.allclose(compute_alignment(np.array([[1, 1]]), np.array([[1], [1]]), np.array([[1], [1]]), np.array([[1]... |
32dcb14d6ba593d2385a834bd3490d9b | [
{
"content": "On te donne deux chaînes de caractères, `word1` et `word2`, composées uniquement de caractères alphabétiques. Ta tâche est de déterminer si `word2` est la version avec une majuscule initiale de `word1`. Un mot est considéré comme ayant une majuscule initiale si sa première lettre est en majuscule ... | ["\nassert check_capitalized_pair(\"hello\", \"Hello\") == True\n", "\nassert check_capitalized_pair(\"world\", \"World\") == True\n", "\nassert check_capitalized_pair(\"python\", \"Python\") == True\n", "\nassert check_capitalized_pair(\"java\", \"Java\") == True\n", "\nassert check_capitalized_pair(\"hello\", \"hello... |
960687aa22815f82570692e6c7fd4581 | [
{
"content": "On te demande d'implémenter une classe `CircularBuffer` qui supporte les opérations suivantes :\n\n- **Initialisation** : `__init__(self, size)` : Initialise le tampon avec une taille fixe `size`.\n- **Opération d'écriture** : `write(self, value)` : Écrit une valeur dans le tampon. Si le tampon es... | ["\nassert CircularBuffer(3).size == 3\n", "\nassert CircularBuffer(5).buffer == [None, None, None, None, None]\n", "\ncb = CircularBuffer(2)\ncb.write(1)\ncb.write(2)\nassert cb.read() == 1\n", "\ncb = CircularBuffer(2)\ncb.write(1)\ncb.write(2)\ncb.read()\ncb.write(3)\nassert cb.read() == 2\n", "\ncb = CircularBuffer... |
a0755f6cf3da8fac3ee9699b45cf7227 | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer les informations sur les livres. La classe doit stocker les attributs suivants :\n- `title` : une chaîne de caractères représentant le titre du livre.\n- `author` : une chaîne de caractères représentant l'auteur du livre.\n- `isbn` : une cha... | ["\nassert Book(\"Book One\", \"Author A\", \"1234567890\", \"Publisher X\", 2020).get_age() == 3\n", "\nassert Book(\"Book Two\", \"Author B\", \"0987654321\", \"Publisher Y\", 2022).get_age() == 1\n", "\nassert Book(\"Book Three\", \"Author C\", \"1122334455\", \"Publisher Z\", 2023).get_age() == 0\n", "\nassert Book... |
c1bfb30ea5454fb3ced2175c5d6364a8 | [
{
"content": "On te demande d'implémenter une version modifiée de l'indice de lisibilité de Coleman-Liau. Dans cette version, au lieu d'utiliser le nombre moyen de lettres par 100 mots, utilise le nombre moyen de lettres uniques par 100 mots, sans tenir compte de la casse. La formule de l'indice modifié est :\n... | ["\nassert calculate_readability_index(\"Python is an interpreted, high-level and general-purpose programming language.\") == 0.0588 * 24.0 - 0.296 * (1.0 / 14.0 * 100) - 15.8\n", "\nassert calculate_readability_index(\"Hello world!\") == 0.0588 * 10.0 - 0.296 * (1.0 / 2.0 * 100) - 15.8\n", "\nassert calculate_readabil... |
54482874c3551f62e38585b9e3a80517 | [
{
"content": "On te donne deux listes, `keys` et `values`. Ta tâche est de construire un dictionnaire à partir de ces listes. Chaque élément de la liste `keys` doit être utilisé comme clé dans le dictionnaire, et l'élément correspondant de la liste `values` doit être utilisé comme valeur. S'il y a plus de clés ... | ["\nassert merge_lists_to_dict(['a', 'b', 'c'], [1, 2, 3]) == {'a': 1, 'b': 2, 'c': 3}\n", "\nassert merge_lists_to_dict(['a', 'b', 'c'], [1, 2]) == {'a': 1, 'b': 2, 'c': None}\n", "\nassert merge_lists_to_dict(['a', 'b'], [1, 2, 3]) == {'a': 1, 'b': 2}\n", "\nassert merge_lists_to_dict(['a', 'a', 'b'], [1, 2, 3]) == {... |
7286d7e305fcb2eb18f4ac0d88b65a67 | [
{
"content": "On te donne une collection d'images en niveaux de gris représentées comme des tableaux numpy 3D avec des dimensions (canaux, hauteur, largeur). Chaque image a un seul canal, donc la forme de chaque image est (1, hauteur, largeur). Ta tâche est de mettre en œuvre une fonction `crop_images` qui rogn... | ["\nassert np.array_equal(crop_images([np.array([[[255, 0, 0, 255], [0, 128, 128, 0], [0, 128, 128, 0], [255, 0, 0, 255]]], dtype=np.uint8)], (2, 2))[0], np.array([[[255, 0], [0, 128]]], dtype=np.uint8))\n", "\nassert np.array_equal(crop_images([np.array([[[255, 0, 0, 255], [0, 128, 128, 0], [0, 128, 128, 0], [255, 0, ... |
187f459f19467c229ccc9d4312fcac6d | [
{
"content": "On te donne une liste d'entiers, `numbers`, et une chaîne de caractères, `order`, qui peut être soit \"asc\" soit \"desc\". Ta tâche est de trier la liste dans l'ordre spécifié en utilisant l'algorithme de tri par sélection. Tu n'es pas autorisé à utiliser des fonctions ou des bibliothèques de tri... | ["\nassert selection_sort([5, 2, 9, 1, 5, 6], 'asc') is None and [1, 2, 5, 5, 6, 9] == [5, 2, 9, 1, 5, 6]\n", "\nassert selection_sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5], 'desc') is None and [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1] == [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]\n", "\nassert selection_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1... |
17e8a7aeee00fc1d1eb232aa7427f0dc | [
{
"content": "On te donne un graphe non orienté représenté sous forme de matrice d'adjacence. Ta tâche est de déterminer 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 adj... | ["\nassert is_bipartite([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]]) == True\n", "\nassert is_bipartite([[0, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]]) == False\n", "\nassert is_bipartite([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == True\n", "\nassert is_bipartite([[0, 1], [1, 0]]) == True\n", "\nassert... |
7ef70f008a288586b2e0e113281187b1 | [
{
"content": "On te donne une liste d'intervalles, où chaque intervalle est représenté comme un tuple `(début, fin)`. Ta tâche est de fusionner tous les intervalles qui se chevauchent et de renvoyer une liste des intervalles fusionnés. Les intervalles ne sont pas nécessairement triés.\n\n**Entrée :**\n- Une lis... | ["\nassert merge_intervals([(1, 3), (2, 6), (8, 10), (15, 18)]) == [(1, 6), (8, 10), (15, 18)]\n", "\nassert merge_intervals([(1, 4), (4, 5)]) == [(1, 5)]\n", "\nassert merge_intervals([(1, 2), (3, 4), (5, 6)]) == [(1, 2), (3, 4), (5, 6)]\n", "\nassert merge_intervals([(1, 2), (2, 3)]) == [(1, 3)]\n", "\nassert merge_i... |
a39463ef790e570d45229bf9a65787c2 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de trouver et de renvoyer la plus longue sous-chaîne palindromique dans `s`. Un palindrome est défini comme une séquence de caractères qui se lit de la même manière de gauche à droite et de droite à gauche. S'il existe plusieurs sous-chaînes p... | ["\nassert longest_palindrome(\"babad\") in [\"bab\", \"aba\"]\n", "\nassert longest_palindrome(\"cbbd\") == \"bb\"\n", "\nassert longest_palindrome(\"a\") == \"a\"\n", "\nassert longest_palindrome(\"ac\") in [\"a\", \"c\"]\n", "\nassert longest_palindrome(\"racecar\") == \"racecar\"\n", "\nassert longest_palindrome(\"... |
a02b27aeef2459ce2ca9adaf83660b54 | [
{
"content": "On te donne un scénario où tu dois déterminer la probabilité de sélectionner l'une de deux options en fonction de leurs valeurs attendues et d'un paramètre \\( L \\). La valeur attendue pour chaque option est calculée comme \\( EV = (P \\times G) + ((1 - P) \\times L) \\), où \\( P \\) est la prob... | ["\nassert calculate_choice_probability(0.8, 0.5, 100, 75, -50, -30, 0.9, 10, 5) == 0.9999\n", "\nassert calculate_choice_probability(0.5, 0.5, 100, 100, -50, -50, 0.9, 10, 5) == 0.5\n", "\nassert calculate_choice_probability(0.1, 0.9, 100, 75, -50, -30, 0.9, 10, 5) == 0.0001\n", "\nassert calculate_choice_probability(... |
0dd3d094accfd4d684a3c939ebc52e4e | [
{
"content": "On te donne une liste de chaînes de caractères représentant des mots. Ta tâche est de mettre en œuvre une fonction qui renvoie une liste des 3 mots les plus courants de la liste. S'il y a moins de 3 mots uniques, renvoie tous les mots uniques triés par leur fréquence par ordre décroissant. En cas ... | ["\nassert top_three_common_words([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"banana\", \"kiwi\", \"kiwi\", \"kiwi\", \"kiwi\"]) == [\"kiwi\", \"banana\", \"apple\"]\n", "\nassert top_three_common_words([\"cat\", \"dog\", \"cat\", \"dog\", \"cat\"]) == [\"cat\", \"dog\"]\n", "\nassert top_three_common_... |
466b05e5eff3853bda231e640ac76948 | [
{
"content": "On te demande d'implémenter un programme pour calculer les besoins caloriques quotidiens d'une personne en fonction de son niveau d'activité en utilisant un style de programmation fonctionnel avec la récursion. Le programme doit prendre en entrée les informations suivantes : le genre, le poids (en... | ["\nassert main('male', 70, 175, 30, 'moderately_active') == 2493.75\n", "\nassert main('female', 60, 165, 25, 'lightly_active') == 1856.25\n", "\nassert main('male', 80, 180, 40, 'very_active') == 3570.0\n", "\nassert main('female', 55, 160, 35, 'sedentary') == 1332.5\n", "\nassert main('male', 90, 190, 28, 'super_act... |
f36c54e83fc91640644ca54912fb0248 | [
{
"content": "On te donne une liste d'éléments. Ta tâche est d'implémenter une fonction `remove_duplicates` qui traite cette liste et renvoie une nouvelle liste avec tous les éléments dupliqués supprimés, en préservant l'ordre de leur première occurrence.\n\n**Entrée :**\n- Une liste d'éléments (entiers ou chaî... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates(['apple', 'banana', 'apple', 'cherry']) == ['apple', 'banana', 'cherry']\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates(['a', 'b', 'c'... |
87b4ad24fac3c13a57afae385f2f55dd | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres anglaises majuscules et minuscules. Ta tâche est d'écrire une fonction qui supprime toutes les voyelles de la chaîne et renvoie la chaîne résultante. La fonction doit gérer à la fois les voyelles majuscules et minuscules ('a', 'e', 'i', ... | ["\nassert remove_vowels(\"The quick brown fox jumps over the lazy dog\") == \"Th qck brwn fx jmps vr th lzy dg\"\n", "\nassert remove_vowels(\"AEIOUaeiou\") == \"\"\n", "\nassert remove_vowels(\"Python Programming\") == \"Pythn Prgrmmng\"\n", "\nassert remove_vowels(\"Hello World\") == \"Hll Wrld\"\n", "\nassert remov... |
2e9cd018f1f0e8385ada6936adfc6b36 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'identifier et d'afficher les éléments les plus fréquents de la liste ainsi que leurs dénombrements. En cas d'égalité (c'est-à-dire, plusieurs éléments ayant la même fréquence la plus élevée), affiche tous ces éléments. La sortie doit être triée par o... | ["\nassert most_frequent_elements([1, 2, 2, 3, 3]) == None\n", "\nassert most_frequent_elements([4, 4, 4, 6, 6, 6, 8]) == None\n", "\nassert most_frequent_elements([7, 7, 7, 7, 9, 9, 9]) == None\n", "\nassert most_frequent_elements([10, 10, 20, 20, 30]) == None\n", "\nassert most_frequent_elements([1, 1, 2, 2, 3, 3, 4,... |
1335dd172caac8ca40dbcac11c4bdb75 | [
{
"content": "On te demande d'implémenter une fonction pour le système de rémunération d'une entreprise technologique. L'entreprise accorde une prime spéciale aux employés en fonction de la performance de ses actions. Si le cours de l'action augmente de plus de 50 % en un an, les employés reçoivent une prime éq... | ["\nassert calculate_compensation(50000, 55) == \"$500,000.00\"\n", "\nassert calculate_compensation(75000, 45) == \"$75,000.00\"\n", "\nassert calculate_compensation(100000, 50) == \"$100,000.00\"\n", "\nassert calculate_compensation(30000, 60) == \"$300,000.00\"\n", "\nassert calculate_compensation(20000, 51) == \"$2... |
730a69401d9cbc9fe3134d8febb69864 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de trouver la chaîne de caractères lexicographiquement la plus petite qui puisse être obtenue en effectuant zéro ou plusieurs échanges de caractères adjacents. Le but est d'obtenir la chaîne... | ["\nassert lexicographically_smallest_string(\"cba\") == \"abc\"\n", "\nassert lexicographically_smallest_string(\"abc\") == \"abc\"\n", "\nassert lexicographically_smallest_string(\"fed\") == \"def\"\n", "\nassert lexicographically_smallest_string(\"dcba\") == \"abcd\"\n", "\nassert lexicographically_smallest_string(\... |
062f000b87eb3e1720fc4c61dff83207 | [
{
"content": "On te donne un objet de type fichier `f` qui contient des données binaires représentant plusieurs nombres à virgule flottante 64 bits au format IEEE 754. Chaque nombre est stocké en ordre d'octets inversé (little-endian) et occupe exactement 8 octets. Ta tâche est de mettre en œuvre une fonction `... | ["\nassert read_float64(bytearray.fromhex('000000000000f8ff')) == [-1.0]\n", "\nassert read_float64(bytearray.fromhex('000000000000f03f')) == [1.0]\n", "\nassert read_float64(bytearray.fromhex('0000000000000000')) == [0.0]\n", "\nassert read_float64(bytearray.fromhex('0000000000000040')) == [2.0]\n", "\nassert read_flo... |
607706e36d1eb55fecaccbaae7d15b6f | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_largest_prime_factor` qui détermine le plus grand facteur premier de `n`. La fonction doit renvoyer ce plus grand facteur premier en tant qu'entier.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^12).\n\n**Sortie :**\n-... | ["\nassert find_largest_prime_factor(2) == 2\n", "\nassert find_largest_prime_factor(3) == 3\n", "\nassert find_largest_prime_factor(4) == 2\n", "\nassert find_largest_prime_factor(5) == 5\n", "\nassert find_largest_prime_factor(6) == 3\n", "\nassert find_largest_prime_factor(15) == 5\n", "\nassert find_largest_prime_f... |
a2bc64093b812df1ba40b6d392d5ff7b | [
{
"content": "On te demande d'écrire un programme Python qui génère la suite de Fibonacci jusqu'à un nombre de termes spécifié. Le programme doit demander à l'utilisateur d'entrer le nombre de termes qu'il souhaite générer, puis afficher la séquence. De plus, implémente une fonction récursive pour calculer le n... | ["\nassert fibonacci_sequence(0) == []\n", "\nassert fibonacci_sequence(1) == [0]\n", "\nassert fibonacci_sequence(2) == [0, 1]\n", "\nassert fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci_sequence(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert fibonacci_recursive(0) == 0\n", "\nassert fibonac... |
8d4da0b0a0978120134e0bb5a3fd0eba | [
{
"content": "On te demande d'implémenter une fonction `update_product_stock` pour gérer un système d'inventaire de produits. La fonction reçoit deux paramètres : un dictionnaire `inventory` où les clés sont les noms des produits et les valeurs sont les quantités disponibles, et une liste de tuples `sales` où c... | ["\nassert update_product_stock({\"apple\": 10, \"banana\": 20}, [(\"apple\", 5)]) == {\"apple\": 5, \"banana\": 20}\n", "\nassert update_product_stock({\"apple\": 10, \"banana\": 20}, [(\"apple\", 15)]) == {\"apple\": 0, \"banana\": 20}\n", "\nassert update_product_stock({\"apple\": 10, \"banana\": 20}, [(\"grape\", 5... |
1b256d50e8ac86f9df5c426e693b6719 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci en utilisant une approche itérative. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Ta fonction doit gérer les entrées entières non négatives et renvoyer le... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(25... |
ca8bfaace0e415439c739688ebe78ff1 | [
{
"content": "On te donne deux entiers, `n` et `m`. Ta tâche est de déterminer l'entier le plus proche de `n` qui est divisible par `m`. En cas d'égalité, choisis l'entier supérieur à `n`. Tu dois implémenter cette fonction sans utiliser de boucles ni de fonctions intégrées qui effectuent directement des opérat... | ["\nassert closest_divisible(10, 3) == 9\n", "\nassert closest_divisible(10, 4) == 12\n", "\nassert closest_divisible(13, 3) == 15\n", "\nassert closest_divisible(14, 4) == 16\n", "\nassert closest_divisible(0, 5) == 0\n", "\nassert closest_divisible(5, 5) == 5\n", "\nassert closest_divisible(-5, 3) == -6\n", "\nassert... |
79e28554cb9baf3754e32923248a6375 | [
{
"content": "On te donne un défi de programmation : implémenter une fonction nommée `execute_and_log`. Cette fonction doit accepter deux paramètres : un appelable `func` et une chaîne de caractères `file_path`. La fonction `execute_and_log` est responsable de l'exécution de `func` et de la journalisation de to... | ["\nassert execute_and_log(lambda: 42, \"test_log.txt\") == 42\n", "\nassert execute_and_log(lambda: \"hello\", \"test_log.txt\") == \"hello\"\n", "\nassert execute_and_log(lambda: [1, 2, 3], \"test_log.txt\") == [1, 2, 3]\n", "\ntry:\n execute_and_log(lambda: 1/0, \"test_log.txt\")\nexcept ZeroDivisionError:\n p... |
a4bce8183251bce0b437a4e463ebadd0 | [
{
"content": "On te donne le puzzle des Tours de Hanoï avec `n` disques. L'objectif est de déplacer tous les disques de la cheville source vers la cheville de destination en utilisant une cheville auxiliaire, en respectant les règles suivantes :\n1. Un seul disque peut être déplacé à la fois.\n2. Chaque déplace... | ["\nassert tower_of_hanoi(1, 'A', 'C', 'B') == None\n", "\nassert tower_of_hanoi(2, 'A', 'C', 'B') == None\n", "\nassert tower_of_hanoi(3, 'A', 'C', 'B') == None\n", "\nassert tower_of_hanoi(4, 'A', 'C', 'B') == None\n", "\nassert tower_of_hanoi(0, 'A', 'C', 'B') == None\n", "\nassert tower_of_hanoi(1, 'X', 'Y', 'Z') =... |
85c2d4aba79123fb2006775c731101e3 | [
{
"content": "Implémente une classe Python qui respecte le modèle singleton. Ta classe doit garantir qu'une seule instance de la classe est créée, quelle que soit la fréquence à laquelle la classe est instanciée. Ta solution doit inclure une méthode `get_instance()` qui renvoie l'instance singleton.\n\n**Exempl... | ["\nassert Singleton() is Singleton()\n", "\nassert id(Singleton()) == id(Singleton())\n", "\nassert Singleton._instance is None\n", "\nsingleton1 = Singleton()\nassert Singleton._instance is not None\n", "\nsingleton1 = Singleton()\nsingleton2 = Singleton()\nassert singleton1 is singleton2\n", "\nsingleton1 = Singleto... |
16a9f14a3e8880c0cf6511856f8a61a1 | [
{
"content": "Tu participes à un concours de programmation où l'on te donne une liste d'entiers représentant les scores d'un jeu. Ta tâche est d'écrire une fonction qui calcule le \"score de puissance\" pour chaque élément de la liste. Le score de puissance d'un élément est défini comme l'élément élevé à la pui... | ["\nassert calculate_power_scores([1, 2, 3, 4]) == [1, 2, 9, 64]\n", "\nassert calculate_power_scores([0, 0, 0, 0]) == [1, 0, 0, 0]\n", "\nassert calculate_power_scores([2, 2, 2, 2]) == [1, 2, 4, 8]\n", "\nassert calculate_power_scores([10, 10, 10]) == [1, 10, 100]\n", "\nassert calculate_power_scores([1]) == [1]\n", "... |
11b9d6c2572458410aa26fa22065daf0 | [
{
"content": "On te donne une chaîne de caractères `input_string` qui contient des plages de nombres séparées par des points-virgules. Chaque plage est définie par deux entiers séparés par un double underscore (`__`). Ta tâche est d'analyser cette chaîne et de renvoyer une liste de tous les entiers compris dans... | ["\nassert parse_input(\"1__5\") == [1, 2, 3, 4, 5]\n", "\nassert parse_input(\"7__14\") == [8, 9, 10, 11, 12, 13, 15]\n", "\nassert parse_input(\"20__25\") == [20, 21, 22, 23, 24, 25]\n", "\nassert parse_input(\"1__7;8__14\") == [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 15]\n", "\nassert parse_input(\"10__10\") == [10]... |
5001762623a4f25b02291dad26d4af37 | [
{
"content": "On te charge de développer une application web simple en utilisant Flask. L'application doit comporter un formulaire où les utilisateurs peuvent saisir leur nom et leur adresse e-mail. Lors de la soumission, les données du formulaire doivent être stockées dans une base de données SQLite. L'applica... | ["\nassert User.query.filter_by(name=\"John Doe\").first() is None\n", "\nassert User.query.filter_by(email=\"john.doe@example.com\").first() is None\n", "\nassert app.config['SQLALCHEMY_DATABASE_URI'] == 'sqlite:///users.db'\n", "\nassert app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] is False\n", "\nassert isinstance(d... |
37cac7d2b732bf592107f6d5b081d8ba | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de trouver la plus longue sous-chaîne de `s` qui soit à la fois un palindrome et une progression arithmétique. Un palindrome se lit de la même manière de gauche à droite et de droite à gauch... | ["\nassert longest_palindromic_arithmetic_progression(\"abcba\") == \"abcba\"\n", "\nassert longest_palindromic_arithmetic_progression(\"abccba\") == \"abccba\"\n", "\nassert longest_palindromic_arithmetic_progression(\"a\") == \"a\"\n", "\nassert longest_palindromic_arithmetic_progression(\"ab\") == \"a\"\n", "\nasser... |
410f9a67cfa5196a077bd3b1b6e46713 | [
{
"content": "On te donne un fichier CSV nommé `sales_data.csv` contenant des enregistrements de ventes. Chaque enregistrement est composé de trois champs : `product_name`, `quantity` et `price`. Ta tâche est d'écrire une fonction Python `calculate_total_sales` qui lit ce fichier et calcule le chiffre d'affaire... | ["\nassert calculate_total_sales(\"test_sales.csv\") == {'ProductA': 200.0, 'ProductB': 150.0}\n", "\nassert calculate_total_sales(\"empty_sales.csv\") == {}\n", "\nassert calculate_total_sales(\"single_entry_sales.csv\") == {'ProductX': 50.0}\n", "\nassert calculate_total_sales(\"multiple_entries_same_product.csv\") =... |
dd6be19bbc7cb85ba4800ae0925908e2 | [
{
"content": "Tu participes à un concours de programmation où l'on te donne une liste d'éléments, `items_list`, et un entier positif `n`. Chaque élément de `items_list` est un objet avec un attribut `visible`, qui est une valeur booléenne indiquant si l'élément est visible ou non. Ta tâche est de mettre en œuvr... | ["\nassert get_nth_visible_item([], 1) == None\n", "\nassert get_nth_visible_item([{'visible': False}, {'visible': True}], 1) == {'visible': True}\n", "\nassert get_nth_visible_item([{'visible': True}, {'visible': False}, {'visible': True}], 2) == {'visible': True}\n", "\nassert get_nth_visible_item([{'visible': True},... |
2bcdc6618f17813ea39295e627063dce | [
{
"content": "Tu gères un parking avec `num_spots` places de stationnement, chacune identifiée par un index unique à partir de `lowest_spot_index`. Le système de gestion du parking suit les places occupées à l'aide d'une liste d'objets `ParkingSpot`, chacun contenant un `spot_index`, un `reservation_start_time`... | ["\nassert find_vacant_spot(10, [], 0) == 0\n", "\nassert find_vacant_spot(10, [ParkingSpot(0, 0, 10)], 0) == 1\n", "\nassert find_vacant_spot(10, [ParkingSpot(0, 0, 10), ParkingSpot(1, 0, 10)], 0) == 2\n", "\nassert find_vacant_spot(10, [ParkingSpot(0, 0, 10), ParkingSpot(1, 0, 10)], 0, force_parking=True) == 2\n", "\... |
db3e9057eb48c34a2fd0ada08edd6bfa | [
{
"content": "Implémente une structure de données pile en Python en utilisant une classe. Ta classe doit supporter les opérations suivantes :\n- `is_empty()` : Retourne `True` si la pile est vide, sinon `False`.\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime l'élément du sommet ... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().size() == 0\n", "\nassert Stack().peek() == None\n", "\nassert Stack().pop() == None\n", "\ns = Stack(); s.push(1); assert s.peek() == 1\n", "\ns = Stack(); s.push(1); s.push(2); assert s.pop() == 2\n", "\ns = Stack(); s.push(1); s.push(2); s.push(3); assert s... |
5ca79b4fffebcc37f547098b1e6764b4 | [
{
"content": "On te donne une liste de phrases, où chaque phrase est une chaîne de caractères contenant des mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `get_unique_lemmatized_words` qui renvoie une liste de tous les mots lemmatisés uniques dans toutes les phrases. La fonction doit... | ["\nassert get_unique_lemmatized_words([\"Running is fun.\"]) == [\"run\", \"is\", \"fun\"]\n", "\nassert get_unique_lemmatized_words([\"The quick brown foxes jumped over the lazy dogs.\"]) == [\"the\", \"quick\", \"brown\", \"fox\", \"jump\", \"over\", \"lazy\", \"dog\"]\n", "\nassert get_unique_lemmatized_words([\"He... |
2090c67e191e3a653983295e23304632 | [
{
"content": "On te donne un fichier CSV nommé `employees.csv` contenant des données sur les employés avec les champs suivants : `ID`, `Name`, `Department` et `Salary`. Ta tâche est d'écrire une fonction Python qui lit ce fichier CSV et calcule le salaire moyen pour chaque département. Suppose que le fichier CS... | ["\nassert average_salary_per_department('test1.csv') == {'HR': 50000.0, 'Engineering': 75000.0}\n", "\nassert average_salary_per_department('test2.csv') == {'Marketing': 60000.0}\n", "\nassert average_salary_per_department('test3.csv') == {'Sales': 65000.0, 'Support': 55000.0}\n", "\nassert average_salary_per_departme... |
31d4b33eac6c3dafdf2d5afe45b54cad | [
{
"content": "Dans un scénario de tests de performance, tu dois générer un nom de fichier basé sur les paramètres donnés. Le nom de fichier doit inclure les détails suivants :\n\n- Nom de l'expérience : \"Exp32\"\n- Nombre de clients virtuels (doit être un multiple de 5)\n- Nombre de threads de worker middlewar... | ["\nassert generate_filename(10, 5, 1, 2, 500, 3) == \"Exp32_virtualclients_10_middlewareworkerthreads_5_rep_1_client_2_writes_500.txt_Exp32_MW3.txt\"\n", "\nassert generate_filename(15, 1, 20, 0, 100, 0) == \"Exp32_virtualclients_15_middlewareworkerthreads_1_rep_20_client_0_writes_100.txt_Exp32_MW0.txt\"\n", "\nassert... |
033288424c64d75075644c99885ec2bd | [
{
"content": "On te donne une chaîne de caractères `text` composée de plusieurs phrases. Ta tâche est de mettre en œuvre une fonction `count_unique_words` qui traite cette chaîne et renvoie un dictionnaire. Le dictionnaire doit associer chaque mot unique (sans tenir compte de la casse) à sa fréquence dans le te... | ["\nassert count_unique_words(\"Hello, world! This is a test. Hello again, world.\") == {'hello,': 2, 'world!': 2, 'this': 1, 'is': 1, 'a': 1, 'test.': 1, 'again,': 1}\n", "\nassert count_unique_words(\"Python is great. Python is fun.\") == {'python': 2, 'is': 2, 'great.': 1, 'fun.': 1}\n", "\nassert count_unique_words... |
f7ef1afffb6086ead6274f2821ccd714 | [
{
"content": "On te donne une liste d'entiers représentant le nombre de pas effectués par une personne chaque jour pendant un certain nombre de jours. Ta tâche est d'écrire une fonction `analyze_steps(steps)` qui calcule et renvoie un dictionnaire contenant les métriques suivantes :\n- Nombre total de jours ave... | ["\nassert analyze_steps([3000, 7000, 10000, 0, 5000, 6000]) == {\"total_days\": 5, \"max_steps\": 10000, \"min_steps\": 3000, \"avg_steps\": 6200.0, \"activity_level\": \"somewhat active\"}\n", "\nassert analyze_steps([0, 0, 0, 0]) == {\"total_days\": 0, \"max_steps\": 0, \"min_steps\": 0, \"avg_steps\": 0, \"activity... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.