id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
4d28fe53c72e23e7d8eb489e2df5c8fc | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence non décroissante dans la liste. Une sous-séquence est une séquence dérivée d'une autre séquence où certains éléments peuvent être supprimés sans modifier l'ordre des éléments restants. S'il existe plusieurs sous-... | ["\nassert longest_non_decreasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 101]\n", "\nassert longest_non_decreasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_non_decreasing_subsequence([7, 7, 7, 7, 7]) == [7, 7, 7, 7, 7]\n", "\nassert longest_non_decreasing_subsequence([1, 2, ... |
69058b55a27f2576a3af6358e4e86f2b | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses e-mail. Ta fonction doit déterminer si une chaîne de caractères donnée est une adresse e-mail valide en fonction des critères suivants :\n- L'adresse e-mail doit être composée d'un ou plusieurs caractères alphanumériques.\n- Cela d... | ["\nassert validate_email(\"user@example.com\") == True\n", "\nassert validate_email(\"user.name@example.co.uk\") == True\n", "\nassert validate_email(\"user@sub.example.com\") == True\n", "\nassert validate_email(\"user@domain\") == False\n", "\nassert validate_email(\"user@domain.c\") == False\n", "\nassert validate_... |
3a096c9559d13f6e41cedab028950aab | [
{
"content": "On te donne une chaîne de caractères `name` représentant le nom d'un utilisateur. Ta tâche est d'écrire une fonction `greet_user` qui renvoie un message d'accueil au format \"Bonjour, [name] !\". La fonction doit respecter les spécifications d'entrée et de sortie fournies.\n\n**Entrée :**\n- Une s... | ["\nassert greet_user(\"Alice\") == \"Hello, Alice!\"\n", "\nassert greet_user(\"Bob\") == \"Hello, Bob!\"\n", "\nassert greet_user(\"\") == \"Hello, !\"\n", "\nassert greet_user(\"123\") == \"Hello, 123!\"\n", "\nassert greet_user(\"!@#\") == \"Hello, !@#!\"\n", "\nassert greet_user(\"John Doe\") == \"Hello, John Doe!... |
7d32015456f67420d0dec9349bb88583 | [
{
"content": "On te donne un graphe non orienté simple représenté par une matrice d'adjacence. Ta tâche est de déterminer le nombre de composantes connexes dans le graphe. Le graphe est défini par une matrice `n x n` où `adj_matrix[i][j]` est `1` s'il y a une arête entre les nœuds `i` et `j`, et `0` sinon.\n\n*... | ["\nassert count_connected_components([[0, 1, 0], [1, 0, 0], [0, 0, 0]]) == 2\n", "\nassert count_connected_components([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == 3\n", "\nassert count_connected_components([[0, 1, 1], [1, 0, 1], [1, 1, 0]]) == 1\n", "\nassert count_connected_components([[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, ... |
94ce145a027ed46c91e26b46e82c4ad1 | [
{
"content": "On te demande de calculer la valeur terminale d'un investissement initial de 1 $ sur une série d'années, étant donné les rendements annuels pour chaque année. Les rendements annuels sont fournis sous forme de liste de listes, chaque liste interne représentant un scénario différent de rendements an... | ["\nassert calculate_terminal_values([[0.05]]) == [1.05]\n", "\nassert calculate_terminal_values([[0.05, 0.05]]) == [1.1025]\n", "\nassert calculate_terminal_values([[0.05, 0.05, 0.05]]) == [1.157625]\n", "\nassert calculate_terminal_values([[0.0, 0.0, 0.0]]) == [1.0]\n", "\nassert calculate_terminal_values([[-0.05, -0... |
25ab6bec0244fb1a1eb3ecd8abfa6785 | [
{
"content": "On te donne une liste de `n` mots, où chaque mot peut apparaître plusieurs fois. Ta tâche est de mettre en œuvre une fonction qui traite cette liste et renvoie deux structures de données :\n\n1. Un dictionnaire (`word_map`) qui associe chaque mot unique non-palindrome à un nombre séquentiel unique... | ["\nassert process_words([\"apple\", \"level\", \"banana\", \"civic\", \"date\", \"apple\", \"banana\", \"fig\", \"racecar\", \"date\"]) == ({\"apple\": 1, \"banana\": 2, \"date\": 3, \"fig\": 4}, [\"apple\", \"banana\", \"date\", \"fig\"])\n", "\nassert process_words([\"radar\", \"madam\", \"refer\", \"deified\"]) == ... |
a451f849376748e71656aee45db4475b | [
{
"content": "On te donne un dictionnaire où chaque clé est associée à une valeur entière. Ta tâche est de créer une fonction qui renvoie un nouveau dictionnaire avec les mêmes clés mais avec chaque valeur doublée. Le dictionnaire d'entrée ne sera pas vide et ne contiendra que des valeurs entières.\n\n**Exemple... | ["\nassert double_values({\"apple\": 1, \"banana\": 2, \"cherry\": 3}) == {\"apple\": 2, \"banana\": 4, \"cherry\": 6}\n", "\nassert double_values({\"x\": 10, \"y\": 20, \"z\": 30}) == {\"x\": 20, \"y\": 40, \"z\": 60}\n", "\nassert double_values({\"a\": 0, \"b\": 0, \"c\": 0}) == {\"a\": 0, \"b\": 0, \"c\": 0}\n", "\n... |
b68ad2de3d141477ecabc93d6281c3e2 | [
{
"content": "On te demande d'implémenter un système bancaire simple en utilisant les principes de la programmation orientée objet. Ton système doit inclure des classes pour `Account`, `SavingsAccount` et `CheckingAccount`. Les classes `SavingsAccount` et `CheckingAccount` doivent hériter de la classe `Account`... | ["\nassert str(Account(\"Alice\", 100)) == \"Account owner: Alice\\nAccount balance: $100\"\n", "\nassert str(SavingsAccount(\"Bob\", 200, 0.03)) == \"Account owner: Bob\\nAccount balance: $200\\nInterest rate: 3.0%\"\n", "\nassert str(CheckingAccount(\"Charlie\", 150, 200)) == \"Account owner: Charlie\\nAccount balanc... |
355d087af2f493d3468e1e49276a54bd | [
{
"content": "On te donne un fichier texte nommé `log.txt` qui contient des entrées de journal formatées comme \"timestamp,level,message\". Chaque entrée se trouve sur une ligne distincte. Ta tâche est de mettre en œuvre une fonction `parse_log_file(filename)` qui lit le fichier et renvoie une liste de dictionn... | ["\nassert parse_log_file(\"log.txt\") == [{'timestamp': '2023-10-01 12:00:00', 'level': 'INFO', 'message': 'System started'}]\n", "\nassert parse_log_file(\"log.txt\") == [{'timestamp': '2023-10-01 12:00:00', 'level': 'INFO', 'message': 'System started'}, {'timestamp': '2023-10-01 12:01:00', 'level': 'ERROR', 'message... |
a3c606470d9cc7c1a4d0267458fe4af7 | [
{
"content": "On te demande d'implémenter une fonction pour déterminer si une université est mécontente de ses admissions actuelles compte tenu d'un nouveau candidat. Une université est considérée comme mécontente si elle a un nombre insuffisant d'étudiants admis (c'est-à-dire si elle a moins d'étudiants admis ... | ["\nassert _check_college_unhappy(\"applicant1\", college) == True if len(college.admitted) < college.capacity else False\n", "\nassert _check_college_unhappy(\"applicant1\", college) == True if college.prefers(\"applicant1\", college.admitted[0]) else False\n", "\nassert _check_college_unhappy(\"applicant2\", college)... |
6f1d2b0f5db0490925b56c5ea0798df8 | [
{
"content": "Implémente une classe `BankAccount` en Python qui prend en charge les opérations suivantes :\n- `deposit(amount)` : Ajoute le montant spécifié au solde du compte. Le montant doit être positif.\n- `withdraw(amount)` : Soustrait le montant spécifié du solde du compte. Le montant doit être positif et... | ["\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount(100).deposit(50) == 150\n", "\nassert BankAccount(100).withdraw(50) == 50\n", "\nassert BankAccount(100).deposit(0) == ValueError\n", "\nassert BankAccount(100).withdraw(150) == ValueError\n", "\nas... |
d56cf25b57ad0487cf4678d1d78bcdac | [
{
"content": "On te demande d'optimiser une fonction Python pour calculer la factorielle d'un entier non négatif donné `n`. Ta solution doit être efficace et gérer les grandes valeurs de `n` dans des limites de temps raisonnables. Écris une fonction `factorial` qui prend un entier `n` en entrée et renvoie la fa... | ["\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(10) == 3628800\n", "\nassert factorial(12) == 479001600\n", "\nassert ... |
65181502886c16f92c9ca9224d2938e2 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui calcule la fréquence de chaque entier dans la liste et renvoie un dictionnaire avec les entiers comme clés et leurs fréquences comme valeurs.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 10^5), où chaque... | ["\nassert integer_frequency([1, 2, 2, 3, 3, 3]) == {1: 1, 2: 2, 3: 3}\n", "\nassert integer_frequency([4, 4, 4, 4]) == {4: 4}\n", "\nassert integer_frequency([1, 1, 2, 2, 3, 3, 4, 4]) == {1: 2, 2: 2, 3: 2, 4: 2}\n", "\nassert integer_frequency([]) == {}\n", "\nassert integer_frequency([7]) == {7: 1}\n", "\nassert inte... |
f58b9d942adfa3ff9da0d386ca0c92c7 | [
{
"content": "On te donne une chaîne de caractères `S` et une clé secrète `K`. Ta tâche est de concevoir une fonction qui calcule un identifiant entier unique pour la paire `(S, K)` en utilisant un algorithme de hachage personnalisé. L'identifiant doit être unique pour chaque paire unique de `S` et `K`.\n\nL'al... | ["\nassert generate_unique_identifier(\"hello\", \"world\") == 112552753579958335\n", "\nassert generate_unique_identifier(\"openai\", \"gpt\") == 112552753579958335\n", "\nassert generate_unique_identifier(\"test\", \"case\") == 112552753579958335\n", "\nassert generate_unique_identifier(\"unique\", \"identifier\") ==... |
624c2ccf0c8f3d4d2b452c3b20c7e2e1 | [
{
"content": "On te donne une matrice binaire 2D de taille `m x n` ne contenant que des 0 et des 1. Ta tâche est de trouver l'aire de la plus grande sous-matrice carrée qui contient uniquement des 1.\n\n**Entrée :**\n- La première ligne contient deux entiers `m` et `n` (1 ≤ m, n ≤ 300), les dimensions de la mat... | ["\nassert find_largest_square([[1, 0, 1, 0, 0], [1, 0, 1, 1, 1], [1, 1, 1, 1, 1], [1, 0, 0, 1, 0]]) == 4\n", "\nassert find_largest_square([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == 0\n", "\nassert find_largest_square([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) == 9\n", "\nassert find_largest_square([[1]]) == 1\n", "\nassert find_l... |
1643f5f40c8d55a6f012356c4049fd14 | [
{
"content": "Dans un système de flux de travail hypothétique, tu dois concevoir une fonction nommée `generate_process_metadata` pour créer des métadonnées pour un processus. La fonction doit accepter un identifiant unique pour le processus (`process_id`) et n'importe quel nombre d'arguments de mots-clés option... | ["\nassert generate_process_metadata(\"P123\") == {'process_id': 'P123'}\n", "\nassert generate_process_metadata(\"P123\", process_name=\"Process One\") == {'process_id': 'P123', 'process_name': 'Process One'}\n", "\nassert generate_process_metadata(\"P123\", process_name=\"Process One\", process_description=\"This is ... |
22e10ed2028257da1431ddaf4f115f83 | [
{
"content": "On te demande d'optimiser une fonction récursive pour calculer les nombres de Fibonacci en implémentant un mécanisme de mise en cache. Ton objectif est de modifier la fonction `fibonacci` fournie pour utiliser un dictionnaire afin de stocker les nombres de Fibonacci précédemment calculés, évitant ... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(30) == 832040\n", "\nassert fibonacci... |
893bd9866d3673dfc85eb663b47a42f6 | [
{
"content": "On te donne une main de cinq cartes de poker représentée comme une liste de chaînes de caractères, où chaque chaîne de caractères représente le rang d'une carte. Les rangs sont ordonnés du plus petit au plus grand comme suit : '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A'. Déterm... | ["\nassert has_four_of_kind([\"A\", \"A\", \"A\", \"A\", \"7\"]) == True\n", "\nassert has_four_of_kind([\"A\", \"A\", \"A\", \"7\", \"7\"]) == False\n", "\nassert has_four_of_kind([\"K\", \"K\", \"K\", \"K\", \"Q\"]) == True\n", "\nassert has_four_of_kind([\"2\", \"2\", \"2\", \"2\", \"3\"]) == True\n", "\nassert has_... |
5721306959679158dbe28be0df3f87b5 | [
{
"content": "On te donne une chaîne de caractères `sentence` qui peut contenir des URL et des adresses e-mail intégrées. Ta tâche est de mettre en œuvre une fonction `count_capitalized_words` qui renvoie le nombre de mots dans la phrase qui commencent par une lettre majuscule. Les URL et les adresses e-mail do... | ["\nassert count_capitalized_words(\"Hello world\") == 1\n", "\nassert count_capitalized_words(\"This is a Test Sentence.\") == 4\n", "\nassert count_capitalized_words(\"no capitals here\") == 0\n", "\nassert count_capitalized_words(\"https://example.com is not counted\") == 0\n", "\nassert count_capitalized_words(\"Vi... |
d288938ca2616754ff95cdf65f2e3092 | [
{
"content": "On te donne une liste de villes sur un plan 2D, chacune représentée par ses coordonnées. Ta tâche est de trouver un itinéraire qui visite chaque ville exactement une fois et retourne à la ville de départ, en minimisant la distance totale parcourue. Implémente une fonction `optimize_route` qui util... | ["\nassert optimize_route([(0, 0), (1, 1)]) == [0, 1]\n", "\nassert optimize_route([(0, 0), (0, 1), (1, 0), (1, 1)]) == [0, 1, 3, 2] or optimize_route([(0, 0), (0, 1), (1, 0), (1, 1)]) == [0, 2, 3, 1]\n", "\nassert optimize_route([(0, 0), (1, 0), (2, 0), (3, 0)]) == [0, 1, 2, 3]\n", "\nassert optimize_route([(0, 0), (0... |
766d860e6ab4efde0dbc192f27fe3414 | [
{
"content": "On te demande d'implémenter une fonction `validate_comment` qui évalue la validité d'un commentaire en fonction de critères spécifiques. La fonction doit renvoyer `True` si le commentaire répond à toutes les conditions, sinon `False`.\n\n**Critères :**\n1. La longueur du commentaire doit être comp... | ["\nassert validate_comment(\"This is a valid comment with two Capitalized Words and various punctuation and symbols!\", min_length=50, max_length=200, max_symbols=10, max_ellipses=0) == True\n", "\nassert validate_comment(\"This is an invalid comment because it has more than 90 characters \" * 2, min_length=50, max_le... |
2d1ca8accc47928e9a5746e2875ad44e | [
{
"content": "On te demande d'analyser les données de vente des produits d'une entreprise sur un mois donné. Les données de vente sont fournies sous forme de dictionnaire où chaque clé est le nom d'un produit et chaque valeur est une liste des montants des ventes pour diverses transactions. Ton objectif est de ... | ["\nassert calculate_total_sales({\"ProductA\": [100, 200, 150], \"ProductB\": [300, 250], \"ProductC\": [400]}) == {\"ProductA\": 450, \"ProductB\": 550, \"ProductC\": 400}\n", "\nassert calculate_total_sales({\"ProductX\": [10, 20, 30], \"ProductY\": [5, 15, 25]}) == {\"ProductX\": 60, \"ProductY\": 45}\n", "\nassert... |
8a4d0af802c99f7678ec863cf0b3df08 | [
{
"content": "On te donne deux tableaux triés, `arr1` et `arr2`, par ordre croissant. Ta tâche est d'implémenter une fonction `merge_descending(arr1, arr2)` qui fusionne ces deux tableaux en un seul tableau par ordre décroissant. Avant la fusion, inverse l'ordre des éléments dans `arr1` qui sont des nombres pre... | ["\nassert merge_descending([2, 3, 5], [1, 4, 6]) == [6, 5, 4, 3, 2, 1]\n", "\nassert merge_descending([7, 11, 13], [8, 9, 10]) == [13, 11, 10, 9, 8, 7]\n", "\nassert merge_descending([2, 4, 6], [1, 3, 5]) == [6, 5, 4, 3, 2, 1]\n", "\nassert merge_descending([], [1, 2, 3]) == [3, 2, 1]\n", "\nassert merge_descending([1... |
3eca12705e1031087cd4e22761097f5e | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de calculer la somme de tous les éléments du tableau qui ne sont pas des multiples de 3.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^3), le nombre d'éléments du tableau.\n- La deuxième ligne contient `n` entiers séparés par... | ["\nassert sum_of_non_multiples_of_3([3, 6, 9, 10, 11, 12, 13, 14, 15]) == 48\n", "\nassert sum_of_non_multiples_of_3([1, 2, 3, 4, 5, 6]) == 12\n", "\nassert sum_of_non_multiples_of_3([0, 3, 6, 9]) == 0\n", "\nassert sum_of_non_multiples_of_3([1, 2, 4, 5, 7, 8, 10, 11]) == 48\n", "\nassert sum_of_non_multiples_of_3([])... |
823d94ffb2403ca50c7c720f3aab02c3 | [
{
"content": "On te donne un fichier texte nommé `input.txt` qui contient une grande quantité de texte. Ta tâche est d'écrire une fonction Python qui lit ce fichier, compte la fréquence de chaque mot, et renvoie les 10 mots les plus fréquents ainsi que leurs dénombrements. Les mots doivent être considérés sans ... | ["\nassert get_top_10_words('test1.txt') == [('the', 4), ('and', 3), ('of', 3), ('to', 2), ('a', 2), ('in', 2), ('that', 2), ('is', 2), ('it', 1), ('was', 1)]\n", "\nassert get_top_10_words('test2.txt') == [('hello', 5), ('world', 3), ('this', 2), ('is', 2), ('a', 2), ('test', 2), ('file', 1), ('with', 1), ('some', 1),... |
9053372223be1fbaf7e13ad885db5a26 | [
{
"content": "On te demande d'implémenter une fonction pour calculer la suite de Fibonacci jusqu'au n-ième terme en utilisant la programmation dynamique. La fonction doit être optimisée pour les grandes valeurs de n. Ta solution doit renvoyer une liste contenant la suite de Fibonacci jusqu'au n-ième terme.\n\n*... | ["\nassert fibonacci(0) == []\n", "\nassert fibonacci(1) == [0]\n", "\nassert fibonacci(2) == [0, 1]\n", "\nassert fibonacci(3) == [0, 1, 1]\n", "\nassert fibonacci(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert fibonacci(15) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,... |
6565c8815bd2298015de53306f863060 | [
{
"content": "On te donne une fonction `f` qui traite une chaîne de texte et renvoie un tuple de valeurs qui peuvent être converties en nombres à virgule flottante. Ta tâche est de mettre en œuvre une fonction `create_score_function` qui génère une nouvelle fonction `score_function`. Cette `score_function` doit... | ["\nassert create_score_function(lambda x: 0.5)(\"test\") == 0.5\n", "\nassert create_score_function(lambda x: 1.5)(\"test\") == 1.0\n", "\nassert create_score_function(lambda x: -0.5)(\"test\") == 0.0\n", "\nassert create_score_function(lambda x: \"0.7\")(\"test\") == 0.7\n", "\nassert create_score_function(lambda x: ... |
16871115ff2b5fadc2a54fe021c06cf7 | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction `count_words` qui renvoie le nombre de mots dans la chaîne. Un mot est défini comme une séquence de caractères séparés par des espaces.\n\n**Entrée :**\n- Une seule chaîne de car... | ["\nassert count_words(\"hello world this is a test\") == 6\n", "\nassert count_words(\"one two three\") == 3\n", "\nassert count_words(\"singleword\") == 1\n", "\nassert count_words(\"\") == 0\n", "\nassert count_words(\" \") == 0\n", "\nassert count_words(\"multiple spaces between words\") == 4\n", "\nassert cou... |
154b01e4acb8243e2678341bfc5ecbe5 | [
{
"content": "On te demande de concevoir une classe Python `InventoryItem` pour gérer les détails d'un article d'inventaire. La classe doit avoir les attributs suivants : `item_id`, `name`, `quantity` et `price`. Implémente les méthodes suivantes :\n\n- `__init__(self, item_id, name, quantity, price)` : Initial... | ["\nassert str(InventoryItem(1, \"Laptop\", 10, 800)) == \"InventoryItem [item_id: 1, name: Laptop, quantity: 10, price: 800, total_value: 8000]\"\n", "\nassert InventoryItem(2, \"Mouse\", 50, 20).get_total_value() == 1000\n", "\nassert InventoryItem(3, \"Keyboard\", 25, 50).get_total_value() == 1250\n", "\nitem = Inve... |
c7b903f18d4951fc2ae0e1d1001b9570 | [
{
"content": "On te donne une structure de liste imbriquée où chaque liste interne contient des tuples représentant des valeurs de couleur RVB. Ta tâche est d'aplatir cette structure en une seule liste de tuples, de filtrer tous les tuples où l'une des composantes de couleur est inférieure à 64, puis de constru... | ["\nassert process_colors([[(128, 128, 128)], [(64, 64, 64)]]) == {'red': [128, 64], 'green': [128, 64], 'blue': [128, 64]}\n", "\nassert process_colors([[(63, 63, 63)], [(64, 64, 64)]]) == {'red': [64], 'green': [64], 'blue': [64]}\n", "\nassert process_colors([[(0, 0, 0)], [(255, 255, 255)]]) == {'red': [255], 'green... |
43749a44f9e35e4230e5eb6697d17b34 | [
{
"content": "On te donne une séquence d'ADN `dna_seq` et une sous-séquence `subseq`. Ton objectif est de déterminer combien de fois `subseq` apparaît dans `dna_seq`, en incluant les occurrences qui se chevauchent. Écris une fonction `count_subsequence(dna_seq: str, subseq: str) -> int` pour accomplir cela.\n\n... | ["\nassert count_subsequence(\"ATATAT\", \"ATA\") == 3\n", "\nassert count_subsequence(\"AAAA\", \"AA\") == 3\n", "\nassert count_subsequence(\"GCTAGCTAGCTA\", \"GCTA\") == 3\n", "\nassert count_subsequence(\"ACGT\", \"ACG\") == 1\n", "\nassert count_subsequence(\"ACGT\", \"T\") == 1\n", "\nassert count_subsequence(\"A... |
98f6ef1870069c3144053ff8f09831a4 | [
{
"content": "On te donne une liste d'entiers et un entier positif `k`. Ta tâche est de mettre en œuvre une fonction qui renvoie les `k` plus petits éléments de la liste par ordre croissant. Utilise une structure de données de type tas pour y parvenir efficacement.\n\n**Entrée :**\n- Une liste d'entiers `lst` (... | ["\nassert k_smallest_elements([7, 10, 4, 3, 20, 15], 3) == [3, 4, 7]\n", "\nassert k_smallest_elements([1, 2, 3, 4, 5], 2) == [1, 2]\n", "\nassert k_smallest_elements([5, 4, 3, 2, 1], 3) == [1, 2, 3]\n", "\nassert k_smallest_elements([10, 22, 5, 75, 65, 80], 4) == [5, 10, 22, 65]\n", "\nassert k_smallest_elements([1, ... |
aa3ccf531060b6eb1c979d6d5f145be5 | [
{
"content": "On te demande de développer un script Python qui utilise la bibliothèque `watchdog` pour surveiller un répertoire spécifié à la recherche de nouveaux fichiers ou de fichiers modifiés. Ton script doit enregistrer le chemin absolu de chaque fichier et le type d'événement (soit 'created' ou 'modified... | ["\nassert isinstance(ChangeHandler(), FileSystemEventHandler)\n", "\nassert hasattr(ChangeHandler(), 'on_modified')\n", "\nassert hasattr(ChangeHandler(), 'on_created')\n", "\nassert callable(ChangeHandler().on_modified)\n", "\nassert callable(ChangeHandler().on_created)\n", "\nassert 'file_changes.log' in setup_loggi... |
6fc01c93b361ceec3dce0f01f3a519ae | [
{
"content": "On te demande d'implémenter une fonction `add_numbers(a, b)` qui prend deux entiers `a` et `b` en entrée et renvoie leur somme. Ton travail consiste à écrire une suite de tests unitaires complète en Python pour assurer l'exactitude de cette fonction. La fonction doit gérer divers cas, notamment le... | ["\nassert add_numbers(1, 2) == 3\n", "\nassert add_numbers(-1, -2) == -3\n", "\nassert add_numbers(-1, 1) == 0\n", "\nassert add_numbers(0, 0) == 0\n", "\nassert add_numbers(0, 5) == 5\n", "\nassert add_numbers(5, 0) == 5\n", "\nassert add_numbers(100, 200) == 300\n", "\nassert add_numbers(-100, 100) == 0\n", "\nasser... |
545f83ae9bda1ebeeb8d2f096201207d | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ton objectif est d'écrire une fonction qui calcule la fréquence de chaque caractère dans la chaîne et renvoie un dictionnaire où les caractères sont les clés et leurs fréquences respectives sont les vale... | ["\nassert char_frequency(\"hello\") == {'h': 1, 'e': 1, 'l': 2, 'o': 1}\n", "\nassert char_frequency(\"test\") == {'t': 2, 'e': 1, 's': 1}\n", "\nassert char_frequency(\"aabbcc\") == {'a': 2, 'b': 2, 'c': 2}\n", "\nassert char_frequency(\"\") == {}\n", "\nassert char_frequency(\"123321\") == {'1': 2, '2': 2, '3': 2}\n... |
e8457de59b3f567b35a94dbf06fc431b | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est de mettre en œuvre une fonction `sort_by_length_ignorecase` qui traite cette liste et renvoie une nouvelle liste de chaînes de caractères triées selon les critères suivants :\n1. Les chaînes de caractères sont triées par leur longueur pa... | ["\nassert sort_by_length_ignorecase([\"apple\", \"Banana\", \"cherry\", \"date\"]) == [\"date\", \"apple\", \"Banana\", \"cherry\"]\n", "\nassert sort_by_length_ignorecase([\"1apple\", \"Banana\", \"cherry\", \"2date\"]) == [\"Banana\", \"cherry\"]\n", "\nassert sort_by_length_ignorecase([\"kiwi\", \"Kiwi\", \"KIWI\",... |
12eb118a57fac42050dc9522b94b8e1c | [
{
"content": "On te donne une liste de chaînes de caractères non vides. Ta tâche est d'implémenter une fonction `longest_common_prefix` qui détermine le plus long préfixe commun partagé par toutes les chaînes de caractères de la liste. Si aucun préfixe commun n'existe, la fonction doit renvoyer une chaîne vide.... | ["\nassert longest_common_prefix([\"flower\", \"flow\", \"flight\"]) == \"fl\"\n", "\nassert longest_common_prefix([\"dog\", \"racecar\", \"car\"]) == \"\"\n", "\nassert longest_common_prefix([\"interspecies\", \"interstellar\", \"interstate\"]) == \"inters\"\n", "\nassert longest_common_prefix([\"throne\", \"throne\"]... |
63f3f3d250299a52941f896375b0998c | [
{
"content": "On te demande d'écrire un script Python qui interagit avec une base de données SQLite. Ton script doit effectuer les opérations suivantes :\n1. Se connecter à une base de données SQLite nommée `example.db`.\n2. Créer une table nommée `employees` avec le schéma suivant :\n - `id` : INTEGER, clé p... | ["\nassert create_connection(\"test.db\") is not None\n", "\nassert create_connection(\":memory:\") is not None\n", "\nconn = create_connection(\"test.db\")\nassert create_table(conn) is None\n", "\nconn = create_connection(\"test.db\")\ncreate_table(conn)\nassert insert_data(conn, (\"Jane Doe\", 75000.0)) is None\n", ... |
c986af42f37e8eaea62ca141e1b15021 | [
{
"content": "On te demande d'implémenter une classe Python `DataAnalyzer` pour traiter un ensemble de données stocké dans un fichier CSV. Chaque ligne du fichier CSV représente un point de données, et chaque colonne représente une caractéristique. Ta classe doit prendre en charge les opérations suivantes :\n\n... | ["\nassert isinstance(DataAnalyzer('data.csv').get_summary(), dict)\n", "\nassert DataAnalyzer('data.csv').get_summary()[\"number_of_rows\"] == len(pd.read_csv('data.csv'))\n", "\nassert DataAnalyzer('data.csv').get_summary()[\"number_of_columns\"] == len(pd.read_csv('data.csv').columns)\n", "\nassert DataAnalyzer('dat... |
8f8f78b9227032f2ca4a200ab9a3d71c | [
{
"content": "On te donne un fichier texte nommé `numbers.txt` contenant une liste de nombres, chacun sur une nouvelle ligne. Les nombres peuvent être des entiers, des nombres décimaux ou en notation scientifique. Ta tâche est d'écrire un programme qui lit le fichier, extrait tous les nombres et calcule leur so... | ["\nassert read_and_process_numbers(\"test1.txt\") == (15.0, 3.0)\n", "\nassert read_and_process_numbers(\"test2.txt\") == (0.0, 0.0)\n", "\nassert read_and_process_numbers(\"test3.txt\") == (1.0001, 1.0001)\n", "\nassert read_and_process_numbers(\"test4.txt\") == (1.23456789e+10, 1.23456789e+10)\n", "\nassert read_and... |
27a2b839ed0f07cb6b325bfdd8e78254 | [
{
"content": "On te donne une liste de `n` points distincts dans un plan 2D, où chaque point est représenté comme un tuple `(r, c)`. Ta tâche est de déterminer la distance euclidienne minimale entre deux points quelconques. Assure-toi qu'aucun point n'est considéré plus d'une fois comme point de départ dans tes... | ["\nassert min_distance([(1, 2), (3, 4)]) == math.sqrt(8)\n", "\nassert min_distance([(0, 0), (1, 1), (2, 2)]) == math.sqrt(2)\n", "\nassert min_distance([(1, 1), (1, 1)]) == 0.0\n", "\nassert min_distance([(0, 0)]) == 0.0\n", "\nassert min_distance([]) == 0.0\n", "\nassert min_distance([(10, 10), (10, 11), (11, 10), (... |
233031ce3a66af55f4ce4bf73b352ace | [
{
"content": "On te donne deux entiers non négatifs, `a` et `b`. Ta tâche est d'écrire une fonction Python qui calcule le plus grand commun diviseur (PGCD) de ces deux nombres en utilisant l'algorithme d'Euclide. Ta fonction doit renvoyer le PGCD sous forme d'entier.\n\n**Entrée :**\n- Deux entiers non négatifs... | ["\nassert gcd(48, 18) == 6\n", "\nassert gcd(101, 10) == 1\n", "\nassert gcd(56, 98) == 14\n", "\nassert gcd(270, 192) == 6\n", "\nassert gcd(0, 5) == 5\n", "\nassert gcd(5, 0) == 5\n", "\nassert gcd(0, 0) == 0\n", "\nassert gcd(1, 1) == 1\n", "\nassert gcd(123456, 789012) == 12\n", "\nassert gcd(81, 27) == 27\n"] |
7206628c506644a64ab44dda7147fe6a | [
{
"content": "On te demande d'écrire une fonction Python qui génère tous les nombres premiers jusqu'à un entier donné `n` (inclus). Ta solution doit être efficace et utiliser un algorithme optimal.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 10^6)\n\n**Sortie :**\n- Une liste de tous les nombres premiers jusqu'à ... | ["\nassert generate_primes(10) == [2, 3, 5, 7]\n", "\nassert generate_primes(1) == []\n", "\nassert generate_primes(0) == []\n", "\nassert generate_primes(2) == [2]\n", "\nassert generate_primes(19) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_primes(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_... |
cb732000fdd0a2e3b9b3cd4e32018c7b | [
{
"content": "On te donne un fichier texte. Ta tâche est d'implémenter une fonction `countWordsInFile(path)` qui lit le fichier et renvoie un dictionnaire. Le dictionnaire doit contenir des trigrammes (séquences de trois mots consécutifs) comme clés et leurs décomptes respectifs comme valeurs. Les trigrammes do... | ["\nassert countWordsInFile(\"test1.txt\") == {('hello', 'beautiful', 'world'): 1}\n", "\nassert countWordsInFile(\"test2.txt\") == {('sometimes', 'people', 'wonder'): 1, ('people', 'wonder', 'why'): 1, ('wonder', 'why', 'they'): 1, ('why', 'they', 'are'): 1, ('they', 'are', 'so'): 1, ('are', 'so', 'happy'): 1}\n", "\n... |
a91bac0cfd7af2c35fb9f63d82b8318a | [
{
"content": "On te demande d'implémenter une fonction `validate_username` qui détermine la validité d'un nom d'utilisateur donné en fonction de critères spécifiques. Le nom d'utilisateur est considéré comme valide s'il répond à toutes les conditions suivantes :\n\n1. Le nom d'utilisateur ne doit pas contenir d... | ["\nassert validate_username(\"abc\") == True\n", "\nassert validate_username(\"a\") == False\n", "\nassert validate_username(\"ab\") == False\n", "\nassert validate_username(\"abc_def\") == True\n", "\nassert validate_username(\"abc_def_\") == False\n", "\nassert validate_username(\"_abc_def\") == False\n", "\nassert ... |
6ae865a3b218482397c86ee579013201 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'écrire une fonction Python qui supprime toutes les voyelles de chaque chaîne de caractères dans la liste. La fonction doit renvoyer la liste modifiée de chaînes de caractères.\n\n**Exemple d'entrée :**\n```\n[\"Hello\", \"world\", \"Py... | ["\nassert remove_vowels([\"Hello\", \"world\", \"Python\", \"programming\"]) == ['Hll', 'wrld', 'Pythn', 'prgrmmng']\n", "\nassert remove_vowels([\"AEIOU\", \"aeiou\"]) == ['', '']\n", "\nassert remove_vowels([\"bcd\", \"fgh\", \"jkl\"]) == ['bcd', 'fgh', 'jkl']\n", "\nassert remove_vowels([\"\"]) == ['']\n", "\nasser... |
af7ee8cd8a528ab58a5c1a0b5942e4ea | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `has_lowercase` qui détermine s'il existe au moins une lettre minuscule dans la chaîne qui n'est pas immédiatement adjacente à une autre lettre minuscule. La fonction doit renvoyer `True` si une telle lettre existe, ... | ["\nassert has_lowercase(\"a\") == True\n", "\nassert has_lowercase(\"A\") == False\n", "\nassert has_lowercase(\"abc\") == False\n", "\nassert has_lowercase(\"aBc\") == True\n", "\nassert has_lowercase(\"abC\") == True\n", "\nassert has_lowercase(\"aBC\") == True\n", "\nassert has_lowercase(\"a b c\") == True\n", "\na... |
c627236ab6f903582806cd3f017a6220 | [
{
"content": "On te donne une chaîne de caractères `code` représentant une séquence d'identifiants de livres. Chaque identifiant est un segment de 10 caractères où les 9 premiers caractères sont des chiffres (0-9) et le dernier caractère peut être soit un chiffre, soit la lettre majuscule 'X'. Un segment est co... | ["\nassert validate_book_code(\"0306406152\") == True\n", "\nassert validate_book_code(\"030640615X\") == True\n", "\nassert validate_book_code(\"0306406153\") == False\n", "\nassert validate_book_code(\"0306406152030640615X\") == True\n", "\nassert validate_book_code(\"03064061520306406153\") == False\n", "\nassert va... |
a5083d354deaf7116c8af485e6cf9bd2 | [
{
"content": "On te demande d'écrire une fonction Python `calculate_pi` qui approxime la valeur de π en utilisant la méthode de Monte Carlo. Ta fonction doit générer `num_samples` points aléatoires dans le carré unité (0,0) à (1,1) et déterminer combien de ces points se trouvent à l'intérieur du cercle unité ce... | ["\nassert abs(calculate_pi(1000) - 3.14) < 0.5\n", "\nassert abs(calculate_pi(10000) - 3.14) < 0.2\n", "\nassert abs(calculate_pi(100000) - 3.14) < 0.1\n", "\nassert abs(calculate_pi(1000000) - 3.14) < 0.05\n", "\nassert abs(calculate_pi(10000000) - 3.14) < 0.02\n", "\nassert calculate_pi(1) in [0, 4]\n", "\nassert ca... |
b5982778157cd4da37168121bde50032 | [
{
"content": "Tu es chargé d'implémenter une fonction `index_sentences` qui traite un texte donné contenant plusieurs phrases. La fonction doit renvoyer un dictionnaire où chaque clé est un mot unique (sans tenir compte de la casse et sans ponctuation) et la valeur est une liste d'indices représentant les posit... | ["\nassert index_sentences(\"Hello there! This is a sample sentence. Isn't it? Hello again.\") == {'hello': [0, 5], 'there': [1], 'this': [2], 'is': [3, 6], 'a': [4], 'sample': [7], 'sentence': [8], 'isnt': [9], 'it': [10], 'again': [11]}\n", "\nassert index_sentences(\"Python is great. Python is fun!\") == {'python': ... |
d76bcbccc5d0ca497a0a50df30bb0515 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ton objectif est d'écrire une fonction qui traite cette chaîne et renvoie une nouvelle chaîne où tous les caractères consécutifs en double sont réduits à une seule instance. Par exemple, si la chaîne d'e... | ["\nassert reduce_consecutive_duplicates(\"aaabbbccdaa\") == \"abcd\"\n", "\nassert reduce_consecutive_duplicates(\"\") == \"\"\n", "\nassert reduce_consecutive_duplicates(\"abcdef\") == \"abcdef\"\n", "\nassert reduce_consecutive_duplicates(\"aabbccddeeff\") == \"abcdef\"\n", "\nassert reduce_consecutive_duplicates(\"... |
3d92c996bb8dafa1cfade31ac14fc675 | [
{
"content": "On te donne un dictionnaire `d` où chaque clé est une chaîne de caractères représentant un chemin de clé imbriqué séparé par des points, et chaque valeur est la valeur correspondante pour ce chemin. Ta tâche est d'écrire une fonction `unflatten_dict(d)` qui reconstruit et renvoie un dictionnaire i... | ["\nassert unflatten_dict({'a': 1, 'b.x': 2, 'b.y': 3, 'b.z.t': 5, 'b.z.u': 6, 'c': 4}) == {'a': 1, 'b': {'x': 2, 'y': 3, 'z': {'t': 5, 'u': 6}}, 'c': 4}\n", "\nassert unflatten_dict({'x': 10, 'y.z': 20, 'y.w': 30}) == {'x': 10, 'y': {'z': 20, 'w': 30}}\n", "\nassert unflatten_dict({'root.child.grandchild': 'value'}) =... |
520e23a3b8f08f7d5f82fc2e1bfd0d86 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui calcule le produit maximal de deux nombres distincts de la liste. Si la liste contient moins de deux nombres, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers `nums` où `0 <= len(nums) <= 10^3` et `... | ["\nassert max_product_of_two([1, 2, 3, 4, 5]) == 20\n", "\nassert max_product_of_two([-10, -20, 1, 3]) == 200\n", "\nassert max_product_of_two([0, 2, 3, 5]) == 15\n", "\nassert max_product_of_two([1, 1, 1, 1]) == 1\n", "\nassert max_product_of_two([-1, -2, -3, -4]) == -1\n", "\nassert max_product_of_two([5]) == None\n... |
1717126a921c3372076eef918d6bd472 | [
{
"content": "Tu gères le système d'inventaire d'une grande entreprise de construction. Chaque projet nécessite des matières premières spécifiques, chacune avec une quantité requise et une durée de conservation. Ta tâche est de déterminer si l'inventaire de l'entreprise peut répondre aux exigences d'un nouveau ... | ["\nassert can_start_project({\"wood\": (100, 30)}, {\"wood\": [(100, 30)]}) == True\n", "\nassert can_start_project({\"wood\": (100, 30)}, {\"wood\": [(50, 30), (50, 30)]}) == True\n", "\nassert can_start_project({\"wood\": (100, 30)}, {\"wood\": [(50, 30), (20, 30)]}) == \"Not enough wood: needed 100, have 70 within ... |
b18705b6e0c18d8f6ee5c17e0eb189c3 | [
{
"content": "On te donne une fonction `convert_string_type(constant_string, input_string)` qui accepte deux paramètres : une `constant_string` et une `input_string`. Ta tâche est de convertir `constant_string` au même type que `input_string` (soit `bytes` soit `unicode`), en s'assurant que `constant_string` ne... | ["\nassert convert_string_type(\"hello\", \"world\") == \"hello\"\n", "\nassert convert_string_type(\"hello\", b\"world\") == b\"hello\"\n", "\nassert convert_string_type(\"abc\", \"def\") == \"abc\"\n", "\nassert convert_string_type(\"abc\", b\"def\") == b\"abc\"\n", "\nassert convert_string_type(\"123\", \"456\") == ... |
6ea1484f93f350e1a67adf881d15da3c | [
{
"content": "On te donne la tâche de calculer la somme des `n` premiers nombres d'une suite de Fibonacci généralisée, où la suite commence par 1 et 3. Chaque nombre suivant dans la suite est la somme des deux nombres précédents. Ta tâche est de mettre en œuvre une fonction `fib_sum(n)` qui renvoie cette somme.... | ["\nassert fib_sum(0) == 0\n", "\nassert fib_sum(1) == 1\n", "\nassert fib_sum(2) == 4\n", "\nassert fib_sum(3) == 8\n", "\nassert fib_sum(4) == 15\n", "\nassert fib_sum(5) == 26\n", "\nassert fib_sum(6) == 44\n", "\nassert fib_sum(7) == 73\n", "\nassert fib_sum(8) == 120\n", "\nassert fib_sum(9) == 193\n"] |
cc72742f9a3a6cc7e0e20fb19f8e6280 | [
{
"content": "On te demande d'implémenter une fonction `encode_message` qui traite un message donné et l'encode en octets en utilisant un schéma d'encodage spécifié. La fonction doit gérer le multithreading pour encoder différentes parties du message simultanément, en utilisant un nombre fixe de threads. La fon... | ["\nassert encode_message(\"Hello, World!\") == b'Hello, World!'\n", "\nassert encode_message(\"Hello, World!\", encoding='ascii') == b'Hello, World!'\n", "\nassert encode_message(\"Caf\u00e9\", encoding='utf-8') == b'Caf\\xc3\\xa9'\n", "\nassert encode_message(\"Caf\u00e9\", encoding='latin-1') == b'Caf\\xe9'\n", "\na... |
bd9ebc6c694f9470ed78f31bcad4a7f7 | [
{
"content": "On te donne une liste de positions d'un objet en mouvement (`obj_positions`), une liste des accélérations de l'objet (`obj_accelerations`), une liste des masses de l'objet à chaque position (`obj_masses`), et une force constante (`force`). Pour chaque position, calcule le centre de force (CdF) en ... | ["\nassert calculate_center_of_force([0.0, 1.0, 2.0], [None, 2.0, 3.0], [1.0, 1.0, 1.0], 1.0) == [None, 4.0, 5.0]\n", "\nassert calculate_center_of_force([0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0], 1.0) == [2.0, 2.0, 2.0]\n", "\nassert calculate_center_of_force([1.0, 2.0, 3.0], [None, None, None], [1.0, 1.0, 1.0... |
9f67387aec5409d320f0c7d0c247e609 | [
{
"content": "On te donne un fichier CSV nommé `data.csv` avec la structure suivante : la première ligne contient les en-têtes, et les lignes suivantes contiennent les données. Ta tâche est d'écrire un programme Python qui lit ce fichier et calcule la moyenne des nombres dans la troisième colonne. Si la troisiè... | ["\nassert calculate_average_of_third_column('data_with_single_row.csv') == None # Assuming 'data_with_single_row.csv' has only a header row\n", "\nassert calculate_average_of_third_column('data_with_no_third_column.csv') == None # Assuming 'data_with_no_third_column.csv' has less than 3 columns in data rows\n", "\na... |
a82048b97a167df26b89553a8ba9e56b | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots séparés par des espaces. Chaque mot peut contenir de la ponctuation. Ta tâche est de mettre en œuvre une fonction `find_longest_word` qui renvoie le mot le plus long de la chaîne. S'il y a plusieurs mots de longueur maximale identique, r... | ["\nassert find_longest_word(\"The quick brown fox\") == \"quick\"\n", "\nassert find_longest_word(\"jumps over the lazy dog\") == \"jumps\"\n", "\nassert find_longest_word(\"a\") == \"a\"\n", "\nassert find_longest_word(\"equal length words\") == \"equal\"\n", "\nassert find_longest_word(\"punctuation,should!be:includ... |
3b7eda937569fe62908885756f2680b2 | [
{
"content": "On te donne un tableau `A` de `n` entiers et un entier cible `T`. Ta tâche est de trouver toutes les paires uniques d'entiers dans `A` dont la somme est égale à `T`. Chaque paire doit être représentée comme un tuple avec les entiers dans l'ordre croissant. Le tableau d'entrée peut contenir des ent... | ["\nassert find_unique_pairs([1, 2, 3, 4, 5, 3, 2], 5) == [(1, 4), (2, 3)]\n", "\nassert find_unique_pairs([1, 1, 1, 1], 2) == [(1, 1)]\n", "\nassert find_unique_pairs([1, 2, 3, 4, 5], 10) == []\n", "\nassert find_unique_pairs([0, 0, 0, 0], 0) == [(0, 0)]\n", "\nassert find_unique_pairs([-1, 0, 1, 2, -1, -4], 0) == [(-... |
6f9bee40a413f8b9357f9ee809101a9b | [
{
"content": "On te demande d'implémenter une fonction `find_optimal_interval` qui calcule l'intervalle optimal pour analyser un ensemble de données de séries temporelles en fonction d'une fréquence donnée en jours. La fonction doit gérer les cas limites tels que les années bissextiles et les longueurs de mois ... | ["\nassert str(find_optimal_interval(1)) == \"<DateOffset: days=1>\"\n", "\nassert str(find_optimal_interval(365)) == \"<DateOffset: days=365>\"\n", "\nassert str(find_optimal_interval(30)) == \"<DateOffset: days=30>\"\n", "\nassert str(find_optimal_interval(7)) == \"<DateOffset: days=7>\"\n", "\nassert str(find_optima... |
765e8713fe93fe95e0791943afd1b06a | [
{
"content": "On te demande d'implémenter une fonction `clean_username(username)` qui traite une chaîne de caractères de nom d'utilisateur donnée selon des règles spécifiques. La fonction doit d'abord inverser la chaîne d'entrée, puis appliquer les étapes de nettoyage suivantes :\n\n1. Supprimer tous les caract... | ["\nassert clean_username(\"User123!\") == \"321resu\"\n", "\nassert clean_username(\"Python3.8\") == \"83nohtyp\"\n", "\nassert clean_username(\"12345\") == \"invalid\"\n", "\nassert clean_username(\"!@#$%^&*()\") == \"invalid\"\n", "\nassert clean_username(\"Clean_This-Username!\") == \"emmusenamuhTnaelc\"\n", "\nass... |
589d1a0903bc23083f0dc6a1896c8d70 | [
{
"content": "On te donne une liste de séquences d'ADN, où chaque séquence est une chaîne de caractères composée des caractères 'A', 'C', 'G' et 'T'. Ta tâche est de calculer l'entropie de Shannon de chaque nucléotide à chaque position dans toutes les séquences. La fonction doit renvoyer une liste 2D où chaque ... | ["\nassert calculate_nucleotide_frequency([\"ATCG\", \"ATCG\", \"ATCG\"]) == [['A', 0.0, 0.0, 0.0, 0.0], ['C', 0.0, 0.0, 0.0, 0.0], ['G', 0.0, 0.0, 0.0, 0.0], ['T', 0.0, 0.0, 0.0, 0.0]]\n", "\nassert calculate_nucleotide_frequency([\"ACGT\", \"TGCA\"]) == [['A', 1.0, 0.0, 0.0, 1.0], ['C', 0.0, 1.0, 1.0, 0.0], ['G', 1.0... |
64eae7dd7382d5b4319c30ed1e3fdbd3 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `make` : une chaîne de caractères représentant le constructeur de la voiture.\n - `model` : une chaîne de caractères représentant le modèle de la voiture.\n ... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020).make == \"Toyota\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020).model == \"Corolla\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020).year == 2020\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020).speed == 0\n", "\ncar = Car(\"Honda\", \"Civic\", 2018)\ncar.accelerate(50... |
18f767141e17a2d8bfeb97eccb633217 | [
{
"content": "On te donne un tableau 2D `X` de forme `(m, k)` représentant un ensemble de données de séries temporelles, où `m` est le nombre de séries temporelles et `k` est le nombre d'étapes temporelles. Ta tâche est de mettre en œuvre une fonction `reduce_dimensions(X, n, d, p)` qui réduit la dimensionnalit... | ["\nassert np.array_equal(reduce_dimensions(np.array([[1, 2, 3, 4, 5, 6]]), 1, 3, 1), np.array([[1, 2, 3, 4, 5, 6]]))\n", "\nassert np.array_equal(reduce_dimensions(np.array([[1, 2, 3, 4, 5, 6]]), 2, 3, 1), np.array([[1, 2, 3]]))\n", "\nassert np.array_equal(reduce_dimensions(np.array([[1, 2, 3, 4, 5, 6]]), 1, 3, 2), n... |
12f7e2202f99ad14a178fd45d8a74a17 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie le nombre d'éléments distincts dans la liste. La fonction doit avoir une complexité temporelle de O(n).\n\n**Entrée :**\n- Une liste d'entiers, `lst`, où 1 ≤ len(lst) ≤ 10^5 et -10^9 ≤ lst[i] ≤ 10^9.\n\n**Sortie :*... | ["\nassert count_distinct_elements([1, 2, 2, 3, 4, 4, 4, 5, 6, 7, 8, 8, 9, 10]) == 10\n", "\nassert count_distinct_elements([1, 1, 1, 1, 1, 1, 1]) == 1\n", "\nassert count_distinct_elements([]) == 0\n", "\nassert count_distinct_elements([10, 20, 30, 40, 50]) == 5\n", "\nassert count_distinct_elements([-1, -2, -3, -4, -... |
16c498d2e82ceac35c805bb45c4d2025 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_max_value` qui renvoie l'entier maximal dans la liste. Si la liste contient un seul entier, renvoie cet entier. Si la liste est vide, renvoie `None`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (0 ≤ len(numbers) ≤ ... | ["\nassert find_max_value([1, 3, 2]) == 3\n", "\nassert find_max_value([5]) == 5\n", "\nassert find_max_value([]) == None\n", "\nassert find_max_value([-1, -3, -2]) == -1\n", "\nassert find_max_value([0, 0, 0]) == 0\n", "\nassert find_max_value([100]) == 100\n", "\nassert find_max_value([10, 20, 30, 40, 50]) == 50\n", ... |
4c82bd4efebf2ac00c27369bd9ee0921 | [
{
"content": "On te donne une liste de noms de couleurs sous forme de chaînes de caractères. Chaque nom de couleur correspond à une valeur RVB unique. Ta tâche est de trier la liste des couleurs selon les critères suivants :\n1. Trie les couleurs par leurs valeurs RVB par ordre croissant.\n2. Si deux couleurs o... | ["\nassert sort_colors([\"Red\", \"Green\", \"Blue\"]) == [\"Blue\", \"Green\", \"Red\"]\n", "\nassert sort_colors([\"Yellow\", \"Black\", \"White\"]) == [\"Black\", \"White\", \"Yellow\"]\n", "\nassert sort_colors([\"Red\", \"Blue\", \"Red\"]) == [\"Blue\", \"Red\", \"Red\"]\n", "\nassert sort_colors([\"Green\", \"Gre... |
b72135d4bf3319d6022e8650b391c867 | [
{
"content": "On te donne une fonction quadratique sous la forme `f(x) = ax^2 + bx + c`. Ta tâche est d'écrire une fonction `calculate_vertex(a, b, c)` qui prend les coefficients `a`, `b` et `c` en arguments et renvoie les coordonnées du sommet de la parabole formée par la fonction quadratique. Le sommet d'une ... | ["\nassert calculate_vertex(1, -2, 1) == (1, 0)\n", "\nassert calculate_vertex(2, 3, 1) == (-1, -0.5)\n", "\nassert calculate_vertex(1, 0, -4) == (0, -4)\n", "\nassert calculate_vertex(-1, 2, 1) == (1, 2)\n", "\nassert calculate_vertex(1, 4, 4) == (-2, 0)\n", "\nassert calculate_vertex(3, -6, 5) == (1, 2)\n", "\nassert... |
4ed921cd7d8f86c0782ab6cbe420c98e | [
{
"content": "On te donne une chaîne de caractères `s` contenant des caractères alphanumériques, des espaces et des caractères spéciaux. Ta tâche est d'écrire une fonction qui supprime tous les caractères spéciaux de la chaîne et renvoie la chaîne nettoyée. Les caractères spéciaux sont définis comme tout caract... | ["\nassert remove_special_characters(\"Hello, World!\") == \"Hello World\"\n", "\nassert remove_special_characters(\"Python@3.9#\") == \"Python39\"\n", "\nassert remove_special_characters(\"NoSpecialCharsHere\") == \"NoSpecialCharsHere\"\n", "\nassert remove_special_characters(\"1234567890\") == \"1234567890\"\n", "\na... |
9aa85ed6b7e17960990b30b7b09cc522 | [
{
"content": "On te donne deux listes : `numLst` et `weightLst`. La liste `numLst` contient des nombres à virgule flottante positifs, chacun supérieur à 1, et `weightLst` contient des poids entiers non négatifs correspondant à chaque nombre dans `numLst`. Ta tâche est de mettre en œuvre une fonction `weighted_m... | ["\nassert weighted_mean([2.0, 3.0, 4.0], [1, 2, 3]) == 3.3333333333333335\n", "\nassert weighted_mean([1.5, 2.5, 3.5], [0, 0, 0]) == 0\n", "\nassert weighted_mean([2.5, 3.5], [1, 1]) == 3.0\n", "\nassert weighted_mean([5.0, 6.0, 7.0], [3, 2, 1]) == 5.666666666666667\n", "\nassert weighted_mean([10.0, 20.0], [1, 2]) ==... |
bb27bf9f4166ac3204de15c7da03d1a4 | [
{
"content": "On te demande d'écrire une fonction Python pour calculer la factorielle d'un entier non négatif donné en utilisant la récursion. Ta fonction doit gérer les entrées invalides avec élégance en levant une exception `ValueError` avec un message approprié si l'entrée n'est pas un entier non négatif.\n\... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(3) == 6\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(15) == 1307674368000\n", "\ntry: factorial(-1); assert False except ValueError: assert True\n",... |
378c0e4640c04904f3475730e9f02c4d | [
{
"content": "On te donne une chaîne de caractères contenant plusieurs phrases séparées par des points. Ta tâche est de déterminer si chaque phrase est une phrase miroir. Une phrase miroir est définie comme une phrase où la séquence des mots, lorsqu'elle est inversée, est identique à la séquence originale. La p... | ["\nassert check_multiple_sentences(\"A Santa at NASA.\") == [True]\n", "\nassert check_multiple_sentences(\"A Santa at NASA. A Santa at NASA.\") == [True, True]\n", "\nassert check_multiple_sentences(\"A Santa at NASA. Hello, World!\") == [True, False]\n", "\nassert check_multiple_sentences(\"Was it a car or a cat I s... |
121e7d72f2bd8e35e3d5e164e47dbaa6 | [
{
"content": "On te donne une chaîne JSON et une clé cible. Ta tâche est d'écrire une fonction Python qui analyse la chaîne JSON et extrait toutes les valeurs associées à la clé cible. La fonction doit renvoyer une liste de ces valeurs. La chaîne JSON peut contenir des dictionnaires et des listes imbriqués.\n\n... | ["\nassert extract_values('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}', 'name') == ['John']\n", "\nassert extract_values('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\", \"children\": [{\"name\": \"Ann\", \"age\": 10}, {\"name\": \"Billy\", \"age\": 12}]}', 'name') == ['John', 'Ann', 'Billy']\n... |
a7a08fbd7bbe74461913a13123ca9af9 | [
{
"content": "On te donne pour tâche d'implémenter une fonction `create_mock_user` qui génère un objet utilisateur factice à des fins de test. L'objet utilisateur factice doit avoir les propriétés suivantes :\n\n- `id` : un identifiant unique pour l'utilisateur, généré à l'aide de `uuid.uuid4()`.\n- `name` : le... | ["\nassert create_mock_user(False, True) is None\n", "\nassert create_mock_user(True, True)['is_admin'] is True\n", "\nassert create_mock_user(True, False)['is_admin'] is False\n", "\nassert 'id' in create_mock_user(True, True)\n", "\nassert 'name' in create_mock_user(True, True)\n", "\nassert 'email' in create_mock_us... |
0b4792cc759e855e8abc0e18b9abace8 | [
{
"content": "On te donne une chaîne de caractères `s` qui peut contenir plusieurs sous-chaînes enfermées entre des doubles accolades `{{...}}`. Ta tâche est d'écrire une fonction `clean_string(s)` qui traite la chaîne selon les règles suivantes :\n- Remplace chaque sous-chaîne non vide enfermée entre `{{...}}`... | ["\nassert clean_string(\"The {{quick}} {{}} brown {{fox}} jumps {{}} over {{the}} lazy dog\") == \"The brown fox jumps over the lazy dog\"\n", "\nassert clean_string(\"{{}}Hello{{}} world\") == \"Hello World\"\n", "\nassert clean_string(\"{{}}hello{{world}}\") == \"hello world\"\n", "\nassert clean_string(\"{{}}\") ==... |
24af035829bc8d26f2368fda5a29f467 | [
{
"content": "On te donne une chaîne de caractères `sequence` représentant une séquence d'ADN. Ton objectif est d'écrire une fonction `dna_complement` qui renvoie le complément de la séquence d'ADN donnée. Dans l'ADN, le complément d'une base est défini comme suit : A <-> T, C <-> G. Par exemple, le complément ... | ["\nassert dna_complement(\"ATCG\") == \"TAGC\"\n", "\nassert dna_complement(\"GCTA\") == \"CGAT\"\n", "\nassert dna_complement(\"ACGTACGT\") == \"TCGATCGA\"\n", "\nassert dna_complement(\"AAAA\") == \"TTTT\"\n", "\nassert dna_complement(\"TTTT\") == \"AAAA\"\n", "\nassert dna_complement(\"CGCG\") == \"GCGC\"\n", "\nas... |
978fc260380d71e03a99d40d47257ea1 | [
{
"content": "On te donne un ensemble de données représenté par un dictionnaire `data_dict` où chaque clé est un `sample_id` unique et chaque valeur est la valeur d'échantillon correspondante. On te fournit également une liste `selected_samples` contenant les `sample_id` d'intérêt et un dictionnaire `all_sample... | ["\nassert get_category_values({'S1': 10.5, 'S2': 20.3, 'S3': 30.1}, ['S1', 'S2', 'S3', 'S4'], {'S1': 'CatA', 'S2': 'CatB', 'S3': 'CatA', 'S4': 'CatC'}) == {'CatA': [10.5, 0.0, 30.1, 0.0], 'CatB': [0.0, 20.3, 0.0, 0.0], 'CatC': [0.0, 0.0, 0.0, 0.0]}\n", "\nassert get_category_values({'S1': 10.5, 'S2': 20.3, 'S3': 30.1}... |
683d400e7d54ff58a122b71c63142e61 | [
{
"content": "On te demande d'implémenter un décorateur `freeze_attributes` pour une classe en Python. Le décorateur doit garantir que, une fois qu'un attribut est marqué comme gelé, toute tentative de modification de celui-ci doit lever une `AttributeError` uniquement lors de la première tentative. Les tentati... | ["\nassert hasattr(MyClass, 'freeze')\n", "\nassert hasattr(obj, '_frozen_attributes')\n", "\nassert 'x' in obj._frozen_attributes\n", "\nassert not obj._frozen\n", "\nobj.freeze()\nassert obj._frozen\n", "\ntry: obj.x = 30; assert False except AttributeError: assert True\n", "\nobj.x = 40 # This should not raise an e... |
73ba9b3bf8c58dcb9ec4eab9b4073b7b | [
{
"content": "On te donne une liste de noms écrits dans divers alphabets non latins et un dictionnaire personnalisé pour la translittération. Ta tâche est de mettre en œuvre une fonction `convert_names_to_latin` qui convertit chaque nom dans sa forme alphabétique latine en utilisant le dictionnaire fourni. Le d... | ["\nassert convert_names_to_latin([\"\u0438\u0432\u0430\u043d\"], {\"\u0438\u0432\u0430\u043d\": \"ivan\"}) == [\"ivan\"]\n", "\nassert convert_names_to_latin([\"\u043f\u0435\u0442\u0440\"], {\"\u043f\": \"p\", \"\u0435\": \"e\", \"\u0442\": \"t\", \"\u0440\": \"r\"}) == [\"petr\"]\n", "\nassert convert_names_to_latin(... |
2dbf2c95b53a78c0946f007271a1c661 | [
{
"content": "On te donne la tâche d'implémenter une classe `MetricsUpdater` qui maintient un dictionnaire de métriques. Chaque métrique est associée à une valeur moyenne pondérée. Ta classe doit prendre en charge les mises à jour simultanées du dictionnaire des métriques. Les mises à jour doivent être thread-s... | ["\nassert metrics_updater.metrics == {'metric1': (13.333333333333334, 3), 'metric2': (23.333333333333332, 3)}\n", "\nmetrics_updater.update_metrics({'metric3': 30}, 1)\nassert metrics_updater.metrics == {'metric1': (13.333333333333334, 3), 'metric2': (23.333333333333332, 3), 'metric3': (30, 1)}\n", "\nmetrics_updater.... |
9621501e333b474c57d27d615304ba07 | [
{
"content": "Implémente une classe Python `BankAccount` qui simule les opérations bancaires de base. La classe doit avoir les fonctionnalités suivantes :\n- Un initialiseur qui définit le solde initial à 100.\n- Une méthode `deposit` qui ajoute un montant spécifié au solde si le montant est positif.\n- Une mét... | ["\nassert BankAccount().balance == 100\n", "\nassert BankAccount(200).balance == 200\n", "\naccount = BankAccount(); account.deposit(50); assert account.balance == 150\n", "\naccount = BankAccount(); account.deposit(-50); assert account.balance == 100\n", "\naccount = BankAccount(); account.withdraw(50); assert accoun... |
e52fd6354e881f70c250992a0e87d688 | [
{
"content": "On te donne la tâche de calculer la capacité thermique d'un type spécifique d'essence en unités SI (Joules par kilogramme par degré Celsius) en utilisant la méthode \"Petroskills\". La fonction doit accepter trois paramètres :\n\n- `gamma_gasoline` : La densité spécifique de l'essence par rapport ... | ["\nassert calculate_heat_capacity(0.75, 25, {'molecule1': 1.0}) == 1324455.0\n", "\nassert calculate_heat_capacity(0.80, 0, {'molecule1': 1.0}) == 1372620.0\n", "\nassert calculate_heat_capacity(0.75, 25, {'molecule1': 0.5, 'molecule2': 0.5}) == 1324455.0\n", "\nassert calculate_heat_capacity(1.0, 100, {'molecule1': 1... |
0b34afb29f3ef4fc814c9e30e3b5483c | [
{
"content": "On te demande d'implémenter une fonction `safe_division` qui effectue une division entre deux entiers, `numerator` et `denominator`. La fonction doit renvoyer un tuple constitué du résultat de la division et d'un booléen indiquant si la division a été effectuée en utilisant une représentation exac... | ["\nassert safe_division(1, 2) == (0.5, True)\n", "\nassert safe_division(1, 3) == (1/3, True)\n", "\nassert safe_division(2, 0) == (0, False)\n", "\nassert safe_division(0, 1) == (0.0, True)\n", "\nassert safe_division(5, 2) == (2.5, True)\n", "\nassert safe_division(7, 3) == (7/3, True)\n", "\nassert safe_division(-1... |
f85270c16a01efdba0d804aa13fd7907 | [
{
"content": "On te demande d'écrire une fonction Python qui récupère le contenu HTML d'une page web à partir de son URL. Ta fonction doit utiliser la bibliothèque `requests` pour effectuer la requête HTTP. Elle doit gérer les exceptions qui peuvent survenir en raison de problèmes de réseau ou d'URL invalides. ... | ["\nassert fetch_html_content(\"https://www.example.com\").startswith(\"<!doctype html>\")\n", "\nassert fetch_html_content(\"https://www.google.com\").startswith(\"<!doctype html>\")\n", "\nassert fetch_html_content(\"https://nonexistentwebsite123456789.com\") == \"An error occurred: HTTPConnectionPool(host='nonexiste... |
a783ba4ae57100f3ae3c7312aa639978 | [
{
"content": "On te demande d'implémenter une fonction `execute_or_return(maybe_func)` qui traite une entrée `maybe_func`. L'entrée peut être soit une fonction appelable, soit une valeur non appelable. Ta fonction doit se comporter comme suit :\n\n- Si `maybe_func` est une fonction appelable, exécute-la et reto... | ["\nassert execute_or_return(lambda: 42) == 42\n", "\nassert execute_or_return(42) == 42\n", "\nassert execute_or_return(lambda: \"hello\") == \"hello\"\n", "\nassert execute_or_return(\"hello\") == \"hello\"\n", "\nassert execute_or_return(lambda: [1, 2, 3]) == [1, 2, 3]\n", "\nassert execute_or_return([1, 2, 3]) == [... |
33036af5746016857d6c5630e5d50a64 | [
{
"content": "Tu développes un outil en ligne de commande pour gérer et exécuter plusieurs instances d'une application de benchmarking qui teste les performances d'un serveur distant en utilisant le protocole gRPC. L'application de benchmarking prend en charge divers types de benchmarks (par exemple, `benchmark... | ["\nassert build_command(\"localhost:50051\", \"logserver:9000\", \"benchmark1\", \"setting1\", 1) == \"screen -dmS benchmark_1 python benchmark_runner.py --grpc_server_address=localhost:50051 --log_host=logserver:9000 --benchmark=benchmark1 --setting=setting1 --index=1\"\n", "\nassert build_command(\"192.168.1.1:50051... |
f7afc4dae1d1f0eecd182214adb9846c | [
{
"content": "On te donne une liste de mots. Ton objectif est d'écrire une fonction qui renvoie la fréquence de chaque mot dans la liste, en ignorant la casse et en traitant les différentes ponctuations de la même manière. La fonction doit renvoyer un dictionnaire où les clés sont les mots normalisés et les val... | ["\nassert word_frequencies([\"Hello\", \"world!\", \"HELLO\", \"world\", \"world?\", \"hello!\"]) == {'hello': 3, 'world': 3}\n", "\nassert word_frequencies([\"Python\", \"python\", \"PYTHON\", \"pyThOn\"]) == {'python': 4}\n", "\nassert word_frequencies([\"Test\", \"test.\", \"TEST!\", \"test?\"]) == {'test': 4}\n", ... |
ce41dcb78370f8b83ea6c340b9979888 | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par un seul espace. Le premier mot de la chaîne est garanti d'être un palindrome. Ta tâche est de diviser la chaîne en mots et d'inverser l'ordre des mots, en excluant tout mot qui est un palindrome. Si la chaîne d'entrée ne comme... | ["\nassert split_and_reverse(\"racecar apple banana\") == ['banana', 'apple']\n", "\nassert split_and_reverse(\"level\") == None\n", "\nassert split_and_reverse(\"deified\") == None\n", "\nassert split_and_reverse(\"madam arora teaches malayalam\") == ['teaches']\n", "\nassert split_and_reverse(\"civic\") == None\n", "... |
dd86bce6977c3dc3de780db7692ca747 | [
{
"content": "On te donne une chaîne de caractères `html_text` représentant un document HTML. Ta tâche est de mettre en œuvre une fonction `extract_content` qui extrait le contenu principal du document tout en excluant des sections spécifiques en fonction de leurs noms de classe ou de leurs balises HTML. Les se... | ["\nassert extract_content(\"<html><body><div class='main-content'><p>Content</p></div></body></html>\") == \"Content\"\n", "\nassert extract_content(\"<html><body><header>Header</header><div class='main-content'><p>Content</p></div></body></html>\") == \"Content\"\n", "\nassert extract_content(\"<html><body><div class... |
80b69201202eb662827a460162016d37 | [
{
"content": "On te donne une chaîne de caractères `text`. Ta tâche est d'implémenter une fonction `word_frequency(text)` qui calcule la fréquence de chaque mot dans la chaîne, en traitant les mots de manière insensible à la casse. La fonction doit renvoyer un dictionnaire où les clés sont les mots et les valeu... | ["\nassert word_frequency(\"Hello world\") == {'hello': 1, 'world': 1}\n", "\nassert word_frequency(\"Hello hello\") == {'hello': 2}\n", "\nassert word_frequency(\"Python, python!\") == {'python': 2}\n", "\nassert word_frequency(\"A quick brown fox jumps over the lazy dog.\") == {'a': 1, 'quick': 1, 'brown': 1, 'fox': ... |
c5d6c2bc4c552202b2ca73d6af30ac4f | [
{
"content": "On te demande d'implémenter une fonction `calculate_discount` qui calcule le prix final d'un article après application d'une réduction. La fonction accepte deux paramètres : `price`, qui représente le prix initial de l'article, et `discount_rate`, qui peut être fourni soit en pourcentage (par exem... | ["\nassert calculate_discount(100, 20) == 80.0\n", "\nassert calculate_discount(100, 0.2) == 80.0\n", "\nassert calculate_discount(200, 50) == 100.0\n", "\nassert calculate_discount(200, 0.5) == 100.0\n", "\nassert calculate_discount(50, 10) == 45.0\n", "\nassert calculate_discount(50, 0.1) == 45.0\n", "\nassert calcul... |
31b39c1c641ab3fd7acd07c769f202c0 | [
{
"content": "Tu développes une API RESTful en utilisant Flask pour gérer une base de données d'utilisateurs. Ta tâche est d'implémenter un point de terminaison DELETE `/users/{user_id}` qui supprime un utilisateur avec l'`user_id` spécifié. La suppression ne doit être autorisée que si la requête inclut un jeto... | ["\nassert simulate_user_deletion(client, 1, \"admin_token_1\").status_code == 200\n", "\nassert simulate_user_deletion(client, 2, \"admin_token_2\").json == {\"message\": \"User 2 deleted successfully\"}\n", "\nassert simulate_user_deletion(client, 4, \"admin_token_1\").status_code == 404\n", "\nassert simulate_user_d... |
39d2bc4b9204ad312a38902643aa4aa2 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `count_vowels` qui renvoie un dictionnaire avec les voyelles présentes dans la chaîne comme clés et leurs dénombrements respectifs comme valeurs. Les voyelles à considérer sont 'a', 'e', 'i', 'o', 'u' (en majuscules ... | ["\nassert count_vowels(\"Hello World!\") == {'e': 1, 'o': 2}\n", "\nassert count_vowels(\"A quick brown fox jumps over the lazy dog\") == {'A': 1, 'u': 2, 'i': 1, 'o': 4, 'e': 3, 'a': 1}\n", "\nassert count_vowels(\"Python Programming\") == {'o': 1, 'a': 1, 'i': 2}\n", "\nassert count_vowels(\"AEIOUaeiou\") == {'A': 1... |
cffbd938615108c047ded4e93da01223 | [
{
"content": "On te donne un dictionnaire `data` où chaque clé est une chaîne de caractères et chaque valeur est une liste d'entiers. Ta tâche est de mettre en œuvre une fonction `sort_values(data)` qui renvoie un nouveau dictionnaire avec les mêmes clés mais avec les valeurs triées par ordre croissant. La fonc... | ["\nassert sort_values({\"a\": [3, 1, 2], \"b\": [5, 4]}) == {\"a\": [1, 2, 3], \"b\": [4, 5]}\n", "\nassert sort_values({\"x\": [10, 9, 8], \"y\": [7, 6, 5]}) == {\"x\": [8, 9, 10], \"y\": [5, 6, 7]}\n", "\nassert sort_values({\"z\": [1], \"w\": [2]}) == {\"z\": [1], \"w\": [2]}\n", "\nassert sort_values({\"m\": [], \... |
f241fcfaaa465fdf455d28f491023a9c | [
{
"content": "On te donne un arbre binaire représenté comme une liste de listes en Python, où chaque sous-liste contient les valeurs des nœuds à ce niveau de l'arbre. Ta tâche est d'écrire une fonction qui calcule la somme de tous les nœuds à chaque niveau et renvoie ces sommes sous forme de liste.\n\n**Entrée ... | ["\nassert sum_of_levels([[1]]) == [1]\n", "\nassert sum_of_levels([[1], [2, 3]]) == [1, 5]\n", "\nassert sum_of_levels([[1], [2, 3], [4, 5, 6]]) == [1, 5, 15]\n", "\nassert sum_of_levels([[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]) == [1, 5, 15, 34]\n", "\nassert sum_of_levels([[0], [0, 0], [0, 0, 0]]) == [0, 0, 0]\n", "\... |
834c4b14abef4c5e15a716389fe4816b | [
{
"content": "On te donne une table de hachage `ht` implémentée comme une liste de listes chaînées. Chaque indice dans la liste représente un compartiment, et chaque compartiment contient une liste chaînée de paires clé-valeur. La fonction de hachage mappe les clés aux compartiments, et les collisions sont géré... | ["\nassert hash_table_stats([[], [], []]) == (0.0, 0.0, 0)\n", "\nassert hash_table_stats([[('key1', 'value1')], [], []]) == (1/3, 1.0, 12)\n", "\nassert hash_table_stats([[('key1', 'value1'), ('key2', 'value2')], [], []]) == (1/3, 2.0, 24)\n", "\nassert hash_table_stats([[('key1', 'value1')], [('key2', 'value2')], []]... |
6551cdc246ac48329ebf785e875a1e87 | [
{
"content": "Tu es chargé d'implémenter une fonction `parse_identifier(identifier: str) -> List[str]` qui traite une chaîne de caractères donnée `identifier` et renvoie une liste de chaînes de caractères représentant ses composants. La chaîne d'entrée peut être un mélange de segments `camelCase`, `snake_case` ... | ["\nassert parse_identifier(\"camelCase\") == [\"camel\", \"Case\"]\n", "\nassert parse_identifier(\"snake_case\") == [\"snake\", \"_\", \"case\"]\n", "\nassert parse_identifier(\"normal\") == [\"normal\"]\n", "\nassert parse_identifier(\"mixedCamel_case\") == [\"mixed\", \"Camel\", \"_\", \"case\"]\n", "\nassert parse... |
6f57bad9051f90d436527bf525a31bbf | [
{
"content": "On te demande d'implémenter une classe `Employee` pour gérer les détails des employés dans la base de données d'une entreprise. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Attributs :**\n - `name` : une chaîne de caractères représentant le nom de l'employé.\n - `emplo... | ["\nassert Employee(\"John Doe\", \"E123\", \"HR\", 50000.0).name == \"John Doe\"\n", "\nassert Employee(\"John Doe\", \"E123\", \"HR\", 50000.0).employee_id == \"E123\"\n", "\nassert Employee(\"John Doe\", \"E123\", \"HR\", 50000.0).department == \"HR\"\n", "\nassert Employee(\"John Doe\", \"E123\", \"HR\", 50000.0).s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.