id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
c0804f0c6a5ea01e33fa99f76daa83db | [
{
"content": "On te demande d'écrire une fonction pour valider les adresses e-mail selon les règles de syntaxe générales définies dans RFC 5322. Ta fonction doit renvoyer `True` si l'adresse e-mail est valide et `False` sinon. Note qu'une conformité totale à RFC 5322 est complexe, donc ta solution doit utiliser... | ["\nassert is_valid_email(\"test@example.com\") == True\n", "\nassert is_valid_email(\"name.lastname@domain.co.uk\") == True\n", "\nassert is_valid_email(\"prefix.name+tag+sorting@example.com\") == True\n", "\nassert is_valid_email(\"user@sub-domain.example.com\") == True\n", "\nassert is_valid_email(\"user@domain-one-... |
81ccff990641c027c94f62271112068f | [
{
"content": "On te donne deux entiers, `x` et `y`. Ta tâche est d'écrire une fonction qui calcule et renvoie leur somme. Assure-toi que ton code est propre, respecte le guide de style PEP 8 et inclut une docstring descriptive.\n\n**Exemple d'entrée :**\n```\nx = 5\ny = 7\n```\n\n**Exemple de sortie :**\n```\n1... | ["\nassert calculate_sum(2, 3) == 5\n", "\nassert calculate_sum(-1, 1) == 0\n", "\nassert calculate_sum(0, 0) == 0\n", "\nassert calculate_sum(-5, -5) == -10\n", "\nassert calculate_sum(100, 200) == 300\n", "\nassert calculate_sum(1.5, 2.5) == 4.0\n", "\nassert calculate_sum(-1.5, 1.5) == 0.0\n", "\nassert calculate_su... |
3954d69166c70de2bdc978da216f97f7 | [
{
"content": "On te donne une chaîne de caractères `s` composée uniquement des caractères '(', ')', '{', '}', '[' et ']'. Ta tâche est de déterminer si la chaîne est valide. Une chaîne est considérée comme valide si tous les types de crochets sont correctement fermés et imbriqués.\n\n**Exemples :**\n\n- **Entré... | ["\nassert isValid(\"()\") == True\n", "\nassert isValid(\"()[]{}\") == True\n", "\nassert isValid(\"(]\") == False\n", "\nassert isValid(\"([)]\") == False\n", "\nassert isValid(\"{[]}\") == True\n", "\nassert isValid(\"\") == True\n", "\nassert isValid(\"((((()))))\") == True\n", "\nassert isValid(\"((((())))\") == F... |
b5fa290140625c1426b851b9d189581b | [
{
"content": "On te donne un dé pondéré avec `n` faces. Le poids du dé est déterminé par une distribution normale caractérisée par une moyenne `μ` et un écart type `σ`. Ta tâche est de simuler le lancer de ce dé `m` fois et de calculer la valeur moyenne de ces lancers. Les valeurs des lancers de dé doivent être... | ["\nassert weighted_dice_roll(6, 3.5, 1.0) >= 1 and weighted_dice_roll(6, 3.5, 1.0) <= 6\n", "\nassert weighted_dice_roll(10, 5.5, 2.0) >= 1 and weighted_dice_roll(10, 5.5, 2.0) <= 10\n", "\nassert weighted_dice_roll(20, 10.0, 3.0) >= 1 and weighted_dice_roll(20, 10.0, 3.0) <= 20\n", "\nassert weighted_dice_roll(4, 2.0... |
e678c63c969f578e5e95d552d7a9954b | [
{
"content": "On te donne un objet slice `s` qui peut être un slice unique ou un tuple d'objets slice représentant un découpage multidimensionnel. De plus, on te fournit un tuple `shape` représentant la taille de chaque dimension. Ta tâche est d'écrire une fonction `slice_length(s, shape)` qui renvoie la longue... | ["\nassert slice_length(slice(0, 5), (10,)) == 5\n", "\nassert slice_length(slice(5, 0, -1), (10,)) == 5\n", "\nassert slice_length(slice(0, 10, 2), (10,)) == 5\n", "\nassert slice_length(slice(0, 10, -2), (10,)) == 0\n", "\nassert slice_length(slice(3, 9, 2), (10,)) == 3\n", "\nassert slice_length(slice(9, 3, -2), (10... |
af68a456142d8e782fd1f0f0efb48f4a | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui renvoie l'index de la première occurrence de la valeur maximale dans la liste. Si la liste est vide, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers `lst` (0 ≤ len(lst) ≤ 10^5), où chaque entier... | ["\nassert index_of_first_max([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 5\n", "\nassert index_of_first_max([1, 2, 3, 4, 5]) == 4\n", "\nassert index_of_first_max([5, 4, 3, 2, 1]) == 0\n", "\nassert index_of_first_max([10, 10, 10, 10]) == 0\n", "\nassert index_of_first_max([]) == None\n", "\nassert index_of_first_max([7]) =... |
b693d44b60ee00f04b84d1470dadf5b1 | [
{
"content": "On te demande de générer un graphe non orienté aléatoire avec `n` nœuds et `m` arêtes. Les nœuds sont étiquetés de `0` à `n-1`. Les arêtes doivent être choisies aléatoirement entre les nœuds, et le graphe ne doit pas contenir d'arêtes dupliquées. Ton programme doit afficher la liste d'adjacence du... | ["\nassert generate_random_graph(3, 0) == {0: [], 1: [], 2: []}\n", "\nassert generate_random_graph(3, 3) == {0: [1, 2], 1: [0, 2], 2: [0, 1]}\n", "\nassert generate_random_graph(4, 0) == {0: [], 1: [], 2: [], 3: []}\n", "\nassert generate_random_graph(4, 6) == {0: [1, 2, 3], 1: [0, 2, 3], 2: [0, 1, 3], 3: [0, 1, 2]}\n... |
c894dd155a8a82e24b85ab4393d482a0 | [
{
"content": "On te donne un objet parser représentant les arguments de ligne de commande d'un programme. L'objet parser contient un attribut `_option_string_actions`, qui est un dictionnaire associant les chaînes d'arguments de ligne de commande à leurs objets d'action correspondants. Chaque objet d'action a u... | ["\nassert generate_argument_mapping(parser) == {'--alpha': '-a', '-b': '-b', '--gamma': '--gamma', '--epsilon': '--epsilon'}\n", "\nassert generate_argument_mapping(argparse.ArgumentParser()) == {}\n", "\nassert generate_argument_mapping(parser) != {'--alpha': '--alpha', '-b': '-b', '--gamma': '--gamma', '--epsilon': ... |
6e8aa4267d87ce98663cf04e88a86d5a | [
{
"content": "On te donne une liste de scores pour les participants d'une compétition. Chaque score est un entier, et les participants sont numérotés de 1 à n, où n est la longueur de la liste. Ta tâche est d'écrire une fonction qui prend en entrée la liste des scores et plusieurs intervalles de positions, et q... | ["\nassert highest_scores_in_intervals([10, 20, 30, 40, 50], [(2, 4)]) == [50]\n", "\nassert highest_scores_in_intervals([10, 20, 30, 40, 50], [(1, 3)]) == [30]\n", "\nassert highest_scores_in_intervals([10, 20, 30, 40, 50], [(3, 5)]) == [50]\n", "\nassert highest_scores_in_intervals([10, 20, 30, 40, 50], [(5, 6)]) == ... |
10031baacf3a1bd666ee6e3a54209666 | [
{
"content": "On te demande d'implémenter une fonction `encrypt_message` qui effectue un chiffrement de César sur une chaîne de caractères donnée `message` avec un décalage de 3. Le chiffrement de César décale chaque lettre du texte clair d'un nombre fixe de positions dans l'alphabet. Les caractères non alphabé... | ["\nassert encrypt_message(\"Hello, World!\") == \"Khoor, Zruog!\"\n", "\nassert encrypt_message(\"abc\") == \"def\"\n", "\nassert encrypt_message(\"xyz\") == \"abc\"\n", "\nassert encrypt_message(\"ABC\") == \"DEF\"\n", "\nassert encrypt_message(\"XYZ\") == \"ABC\"\n", "\nassert encrypt_message(\"Python 3.8\") == \"Sb... |
310048e9aad9f9407bb8c3f28d9cff7f | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui calcule la somme des carrés de ces entiers. La fonction doit être optimisée à la fois pour la lisibilité et la performance.\n\n**Exemple d'entrée :**\n```\n[1, 2, 3, 4]\n```\n\n**Exemple de sortie :**\n```\n30\n```\n\nLa f... | ["\nassert sum_of_squares([1, 2, 3]) == 14\n", "\nassert sum_of_squares([0, 0, 0]) == 0\n", "\nassert sum_of_squares([-1, -2, -3]) == 14\n", "\nassert sum_of_squares([4, 5, 6]) == 77\n", "\nassert sum_of_squares([10]) == 100\n", "\nassert sum_of_squares([]) == 0\n", "\nassert sum_of_squares([1.5, 2.5, 3.5]) == 21.25\n"... |
5ebf12ea216c41ec24a9ea14d1d012d8 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_prime_factors` qui renvoie une liste de tous les facteurs premiers de `n`, y compris leurs multiplicités.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^6).\n\n**Sortie :**\n- Une liste d'entiers représentant les facteu... | ["\nassert find_prime_factors(2) == [2]\n", "\nassert find_prime_factors(3) == [3]\n", "\nassert find_prime_factors(4) == [2, 2]\n", "\nassert find_prime_factors(5) == [5]\n", "\nassert find_prime_factors(6) == [2, 3]\n", "\nassert find_prime_factors(28) == [2, 2, 7]\n", "\nassert find_prime_factors(100) == [2, 2, 5, 5... |
53c70af12b23310dc23d21ab42cbd6e7 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si la chaîne est un palindrome, en considérant uniquement les caractères alphanumériques et en ignorant la casse. Un palindrome est une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :*... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\n", "\nassert is_palindrome(\" \") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindro... |
26092e7a0c56f0ec1a2ae198f558e901 | [
{
"content": "On te donne un ensemble de données avec des caractéristiques `X` et des étiquettes `Y`. Implémente une fonction `calculate_custom_error(predict, X, Y, sample_size)` pour calculer l'erreur personnalisée d'une classe d'hypothèses. La fonction `predict` prend un sous-ensemble de `X` et renvoie les ét... | ["\nassert calculate_custom_error(lambda x: [0, 1, 0, 1], [1, 2, 3, 4], [0, 1, 0, 1], 4) == 0\n", "\nassert calculate_custom_error(lambda x: [0, 1, 0, 1], [1, 2, 3, 4], [1, 0, 1, 0], 4) == math.sqrt(2) + math.sqrt(3) + math.sqrt(5)\n", "\nassert calculate_custom_error(lambda x: [0, 1, 0, 1], [1, 2, 3, 4], [1, 0, 1, 0],... |
29a741b6d3f1900883faf2ac5c1f7d9b | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots et des hashtags. Un hashtag est défini comme un mot qui commence par le symbole '#', suivi d'un ou plusieurs caractères alphanumériques (lettres ou chiffres). Ta tâche est d'écrire une fonction `extract_hashtags` qui extrait et renvoie... | ["\nassert extract_hashtags(\"Hello, this is a #sample text with #multiple #hashtags\") == []\n", "\nassert extract_hashtags(\"#Python is #awesome, isn't it? #Python\") == [\"Python\"]\n", "\nassert extract_hashtags(\"#test #test #test\") == [\"test\"]\n", "\nassert extract_hashtags(\"#one #two #three #two #one\") == [... |
1f9bffe5fff6b5f0ffde8e059ae81605 | [
{
"content": "On te demande d'implémenter une fonction génératrice Python qui génère efficacement tous les nombres premiers jusqu'à un entier spécifié `n`. Le générateur doit produire les nombres premiers dans l'ordre croissant. Ta solution doit être optimisée pour la performance.\n\n**Entrée :**\n- Un entier `... | ["\nassert list(prime_generator(10)) == [2, 3, 5, 7]\n", "\nassert list(prime_generator(1)) == []\n", "\nassert list(prime_generator(2)) == [2]\n", "\nassert list(prime_generator(19)) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert list(prime_generator(0)) == []\n", "\nassert list(prime_generator(30)) == [2, 3, 5, 7, 11,... |
b88c0fb7c4a687eb62fe4038666f8081 | [
{
"content": "On te donne deux dictionnaires, `dict_a` et `dict_b`, où chaque clé est un élément unique et chaque valeur est la quantité de cet élément. Ta tâche est de construire un nouveau dictionnaire, `dict_c`, qui agrège les quantités d'éléments identiques provenant de `dict_a` et `dict_b`. Si un élément n... | ["\nassert combine_dictionaries({}, {}) == {}\n", "\nassert combine_dictionaries({'apple': 5}, {}) == {'apple': 5}\n", "\nassert combine_dictionaries({}, {'banana': 4}) == {'banana': 4}\n", "\nassert combine_dictionaries({'apple': 5}, {'banana': 4}) == {'apple': 5, 'banana': 4}\n", "\nassert combine_dictionaries({'appl... |
cd53e9f9aaaeced534388c4635cde023 | [
{
"content": "On te demande d'implémenter un système de gestion de bibliothèque en utilisant Python. Ton système doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un Livre** : Étant donné le titre, l'auteur et l'ISBN d'un livre, ajoute le livre à la bibliothèque.\n2. **Supprimer un Livre** : Éta... | ["\nassert Library().get_number_of_books() == 0\n", "\nassert Library().list_books() == []\n", "\nlibrary = Library()\nbook = Book(\"1984\", \"George Orwell\", \"1234567890\")\nlibrary.add_book(book)\nassert library.get_number_of_books() == 1\n", "\nlibrary = Library()\nbook = Book(\"1984\", \"George Orwell\", \"123456... |
3978494e26dba2a3a41257e14b1b39c7 | [
{
"content": "On te demande d'implémenter une fonction `tree_to_dict` qui construit une représentation de dictionnaire imbriqué d'un arbre à partir d'une liste de listes donnée. Chaque sous-liste de la liste d'entrée représente un nœud de l'arbre, où le premier élément est le nœud parent et les éléments suivant... | ["\nassert tree_to_dict([[1, 2, 3], [2, 4], [2, 5], [3, 6], [3, 7]]) == {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}\n", "\nassert tree_to_dict([[1, 2], [2, 3], [3, 4]]) == {1: {2: {3: {4: {}}}}}\n", "\nassert tree_to_dict([[1]]) == {1: {}}\n", "\nassert tree_to_dict([[1, 2], [1, 3], [1, 4]]) == {1: {2: {}, 3: {}, 4: {}... |
74e6dcf3064e5c8f1645da03cc6fc078 | [
{
"content": "Tu participes à une compétition de machine learning où l'on te fournit un classificateur multi-étiquettes pré-entraîné `clf` et deux ensembles de données : `X_train` et `X_test` avec leurs étiquettes correspondantes `y_train` et `y_test`. Ta tâche est de mettre en œuvre une fonction `evaluate_mult... | ["\nassert evaluate_multilabel_classifier(clf, np.array([[1, 2], [3, 4]]), np.array([[0, 1], [1, 0]]), np.array([[1, 2], [3, 4]]), np.array([[0, 1], [1, 0]])) == (2, 2, 0)\n", "\nassert evaluate_multilabel_classifier(clf, np.array([[1, 2], [3, 4]]), np.array([[0, 1], [1, 0]]), np.array([[1, 2], [3, 4]]), np.array([[1, ... |
ebbae447d0de731a6086a54e3dee52cd | [
{
"content": "Tu dois implémenter une fonction `generate_task_id` qui construit un identifiant alphanumérique unique pour une tâche. L'identifiant doit être basé sur un nom de tâche fourni par l'utilisateur et l'horodatage actuel. Si aucun nom de tâche n'est fourni, l'identifiant doit être généré en utilisant l... | ["\nassert generate_task_id(\"test_task\").startswith(\"TaskID_test_task_\")\n", "\nassert len(generate_task_id(\"test_task\")) == 34 # 11 (prefix) + 9 (task_name) + 1 (_) + 8 (hash) + 3 (_)\n", "\nassert generate_task_id().startswith(\"DefaultID_\")\n", "\nassert len(generate_task_id()) == 34 # 11 (prefix) + 14 (cur... |
ecc25278cf29abddd4f6e43218d2aaf4 | [
{
"content": "On te donne un entier positif `N`. Ta tâche est d'écrire une fonction qui renvoie un dictionnaire où chaque clé est un nombre premier inférieur ou égal à `N`, et la valeur correspondante est la somme des chiffres de tous les nombres premiers inférieurs ou égaux à cette clé.\n\n**Entrée :**\n- Un e... | ["\nassert sum_of_digits_of_primes(10) == {2: 2, 3: 5, 5: 10, 7: 17}\n", "\nassert sum_of_digits_of_primes(1) == {}\n", "\nassert sum_of_digits_of_primes(2) == {2: 2}\n", "\nassert sum_of_digits_of_primes(3) == {2: 2, 3: 5}\n", "\nassert sum_of_digits_of_primes(5) == {2: 2, 3: 5, 5: 10}\n", "\nassert sum_of_digits_of_p... |
54c4314c62970c01134a285d05f132da | [
{
"content": "On te donne un ensemble de données contenant des informations sur divers fruits. L'ensemble de données est stocké dans un DataFrame pandas nommé `fruit_data` avec les colonnes suivantes : 'Name', 'Color', 'Weight', 'Price'. La colonne 'Name' contient les noms des fruits, la colonne 'Color' contien... | ["\nassert fruit_split(pd.DataFrame({\n 'Name': ['Apple', 'Banana', 'Cherry', 'Date', 'Elderberry'],\n 'Color': ['Red', 'Yellow', 'Red', 'Brown', 'Black'],\n 'Weight': [150, 120, 10, 20, 5],\n 'Price': [1.2, 0.5, 3.0, 2.0, 4.0]\n}), 0.2, 42)[0].shape[0] == 4\n", "\nassert fruit_split(pd.DataFrame({\n 'Na... |
686a3c0dd563832fc391676a7d202641 | [
{
"content": "On te donne une liste de chaînes de caractères `words`. Ta tâche est d'implémenter une fonction `remove_duplicates` qui renvoie une nouvelle liste contenant uniquement la première occurrence de chaque chaîne de caractères de la liste d'entrée, en préservant l'ordre original de leur première appari... | ["\nassert remove_duplicates([\"apple\", \"banana\", \"cherry\", \"apple\", \"banana\", \"date\", \"elderberry\", \"cherry\"]) == [\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\"]\n", "\nassert remove_duplicates([\"hello\", \"world\", \"hello\", \"python\", \"world\"]) == [\"hello\", \"world\", \"python\"]\... |
7a75c704ed0d2b4f2ebf4ffe3b9f2f82 | [
{
"content": "Dans une série d'épreuves de Bernoulli indépendantes, chacune ayant une probabilité de succès de `p`, détermine la probabilité que le premier succès survienne après exactement `n` échecs en utilisant la récursion. Implémente la fonction `geometric_distribution(n, p)` sans utiliser de boucles.\n\n*... | ["\nassert geometric_distribution(0, 0.5) == 0.5\n", "\nassert geometric_distribution(1, 0.5) == 0.25\n", "\nassert geometric_distribution(2, 0.5) == 0.125\n", "\nassert geometric_distribution(3, 0.5) == 0.0625\n", "\nassert geometric_distribution(0, 0.7) == 0.7\n", "\nassert geometric_distribution(1, 0.7) == 0.21\n", ... |
4827cae35762221c4f66ee45b12ed208 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est d'écrire une fonction `unique_elements` qui renvoie une nouvelle liste contenant tous les éléments uniques des deux listes d'entrée tout en préservant leur ordre d'apparition d'origine. La fonction doit avoir une complexité tempor... | ["\nassert unique_elements([1, 2, 3], [3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert unique_elements([], [1, 2, 3]) == [1, 2, 3]\n", "\nassert unique_elements([1, 2, 3], []) == [1, 2, 3]\n", "\nassert unique_elements([], []) == []\n", "\nassert unique_elements([1, 1, 1], [1, 1, 1]) == [1]\n", "\nassert unique_elements([-1... |
3d9c6b1e61792d6905a90dc8f22546d3 | [
{
"content": "Tu es chargé d'analyser une ligne d'un langage de balisage personnalisé. La ligne est constituée d'une seule balise avec des attributs et du contenu textuel. La balise, les attributs et le contenu textuel sont séparés par des caractères spécifiques : '<' pour le début de la balise, ' ' pour sépare... | ["\nassert parse_markup(\"<tag attr1=value1 attr2=value2>text</tag>\") == {\"tag\": \"tag\", \"attr1\": \"value1\", \"attr2\": \"value2\", \"text\": \"text\"}\n", "\nassert parse_markup(\"<tag\\\\ with\\\\ space attr1=value1\\\\=value2>text\\\\>text</tag>\") == {\"tag\": \"tag with space\", \"attr1\": \"value1=value2\"... |
fd9893d55cd4e390513b562b28dfbff9 | [
{
"content": "On te donne un fichier CSV nommé `employee_data.csv` contenant des enregistrements d'employés avec les colonnes suivantes : `Name`, `Department` et `Salary`. Ta tâche est d'écrire un script Python qui lit ce fichier, calcule le salaire moyen pour chaque département et affiche les résultats dans le... | ["\nassert capture_output(calculate_average_salary_per_department, 'test_employee_data_1.csv') == \"Average Salary per Department:\\nEngineering: 80000.00\\nHR: 50000.00\\n\"\n", "\nassert capture_output(calculate_average_salary_per_department, 'test_employee_data_2.csv') == \"Average Salary per Department:\\nMarketing... |
171642f869dae3f9d32471cf8fd09e92 | [
{
"content": "On te demande d'implémenter un point de terminaison d'API RESTful en utilisant Flask qui calcule le prix moyen des produits dans une catégorie spécifiée. Le point de terminaison doit accepter une catégorie en tant que paramètre de requête et renvoyer une réponse JSON contenant la catégorie et son ... | ["\nassert average_price() == ({'error': 'Category parameter is required'}, 400)\n", "\nassert average_price(category=\"Electronics\") == ({'category': 'Electronics', 'average_price': None}, 404)\n", "\nassert average_price(category=\"Books\") == ({'category': 'Books', 'average_price': 15.75}, 200)\n", "\nassert averag... |
e63f65c6753291ee74895f7ddc6927ec | [
{
"content": "On te donne une chaîne de caractères `input`. Ta tâche est de mettre en œuvre une fonction `alternate_reverse` qui réarrange les caractères de la chaîne selon un motif alterné basé sur leurs points de code Unicode. Plus précisément, inverse chaque autre caractère en commençant par celui qui a le p... | ["\nassert alternate_reverse(\"abc\") == \"cba\"\n", "\nassert alternate_reverse(\"a\") == \"a\"\n", "\nassert alternate_reverse(\"ab\") == \"ba\"\n", "\nassert alternate_reverse(\"abcd\") == \"cbad\"\n", "\nassert alternate_reverse(\"abcde\") == \"cbade\"\n", "\nassert alternate_reverse(\"abcdef\") == \"cbadef\"\n", "... |
b275b39462f2c119663540ea65fa8c8d | [
{
"content": "Tu es chargé d'implémenter une fonction `create_inventory` qui traite une liste d'articles et leurs quantités. La fonction doit accepter un nombre variable d'arguments nommés, où chaque argument nommé consiste en un nom d'article et sa quantité correspondante. Ton objectif est de construire un dic... | ["\nassert create_inventory(apples=10) == {'apples': [10, 'app']}\n", "\nassert create_inventory(bananas=5, oranges=8) == {'bananas': [5, 'ban'], 'oranges': [8, 'ora']}\n", "\nassert create_inventory() == {}\n", "\nassert create_inventory(grapefruit=3, kiwi=2) == {'grapefruit': [3, 'gra'], 'kiwi': [2, 'kiw']}\n", "\nas... |
003f7be7f9df5e408053592ee6c99ec2 | [
{
"content": "On te donne une liste d'entiers uniques. Ta tâche est de générer tous les sous-ensembles possibles (l'ensemble des parties) de cette liste. Les sous-ensembles peuvent être retournés dans n'importe quel ordre. Écris une fonction `generate_power_set` qui prend une liste d'entiers en entrée et renvoi... | ["\nassert generate_power_set([]) == [[]]\n", "\nassert generate_power_set([1]) == [[], [1]]\n", "\nassert generate_power_set([1, 2]) == [[], [1], [2], [1, 2]]\n", "\nassert generate_power_set([1, 2, 3]) == [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]\n", "\nassert generate_power_set([4, 5, 6]) == [[], [4], [... |
5b2e17fea0a3109767a7832e71be8e39 | [
{
"content": "On te demande de traiter un ensemble de données stocké dans un fichier CSV nommé `data.csv`. Ce fichier contient des enregistrements de divers produits, chacun étant décrit par quatre attributs : `ProductID`, `ProductName`, `Category` et `Price`. Ton objectif est de mettre en œuvre une fonction `s... | ["\nassert sort_products_by_price('data.csv')[0]['Price'] == '10.0'\n", "\nassert sort_products_by_price('data.csv')[-1]['Price'] == '100.0'\n", "\nassert len(sort_products_by_price('data.csv')) == 5\n", "\nassert sort_products_by_price('data.csv')[2]['ProductName'] == 'Product C'\n", "\nassert sort_products_by_price('... |
879cdfecb3496e558d96d069a4f31842 | [
{
"content": "On te demande d'écrire une fonction pour déterminer si une chaîne de caractères donnée est une adresse IPv4 valide. Une adresse IPv4 valide est constituée de quatre octets séparés par des points, chaque octet étant un entier compris entre 0 et 255 inclus. Les zéros non significatifs dans un octet ... | ["\nassert is_valid_ipv4_address(\"192.168.1.1\") == True\n", "\nassert is_valid_ipv4_address(\"255.255.255.255\") == True\n", "\nassert is_valid_ipv4_address(\"0.0.0.0\") == True\n", "\nassert is_valid_ipv4_address(\"256.100.50.25\") == False\n", "\nassert is_valid_ipv4_address(\"192.168.1\") == False\n", "\nassert is... |
fac4a47ee8d32b4476e2f50d1af91651 | [
{
"content": "On te donne une liste chaînée simple composée de valeurs entières. Ta tâche est de déterminer si la liste chaînée est un palindrome. Une liste chaînée est considérée comme un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\nImplémente la fonction `is_linked... | ["\nassert is_linked_list_palindrome(ListNode(1)) == True\n", "\nassert is_linked_list_palindrome(ListNode(1, ListNode(2))) == False\n", "\nassert is_linked_list_palindrome(ListNode(1, ListNode(2, ListNode(1)))) == True\n", "\nassert is_linked_list_palindrome(ListNode(1, ListNode(2, ListNode(2, ListNode(1))))) == True\... |
442f44ff34d1addb9cc2e61c8a7374c6 | [
{
"content": "Implémente une classe `BankAccount` en Python qui prend en charge les opérations suivantes :\n\n- **Constructeur (`__init__`)** : Initialise le compte bancaire avec un solde de 0.\n- **Dépôt (`deposit`)** : Prend un entier positif `amount` et l'ajoute au solde. Si le montant n'est pas positif, aff... | ["\nassert BankAccount().balance == 0\n", "\naccount = BankAccount(); account.deposit(100); assert account.balance == 100\n", "\naccount = BankAccount(); account.deposit(-100); assert account.balance == 0\n", "\naccount = BankAccount(); account.deposit(100); account.withdraw(50); assert account.balance == 50\n", "\nacc... |
cf3f914de90e0bb225e36fe7effad27c | [
{
"content": "On te donne une liste de relevés de température en Kelvin. Ta tâche est de mettre en œuvre une fonction qui convertit chaque température en Celsius et en Fahrenheit, en arrondissant les deux à deux décimales. La fonction doit renvoyer une liste de tuples, où chaque tuple contient les valeurs Celsi... | ["\nassert convert_temperatures([298.15, 300.15, 302.15]) == [(25.0, 77.0), (26.0, 78.96), (28.0, 82.4)]\n", "\nassert convert_temperatures([0]) == [(-273.15, -459.67)]\n", "\nassert convert_temperatures([273.15]) == [(0.0, 32.0)]\n", "\nassert convert_temperatures([373.15]) == [(100.0, 212.0)]\n", "\nassert convert_te... |
b70153e4a9d0182ff70c08e4ff615f02 | [
{
"content": "On te donne une liste d'entiers `numbers` et une liste de tuples `decisive_pairs`. Chaque tuple dans `decisive_pairs` représente une paire décisive `(a, b)`, indiquant que `a` et `b` sont connectés et doivent se trouver dans le même ensemble indépendant. Ta tâche est de partitionner la liste `numb... | ["\nassert find_independent_sets([1, 2, 3, 4, 5], [(1, 2), (3, 4)]) == [[1, 2], [3, 4], [5]]\n", "\nassert find_independent_sets([1, 2, 3, 4, 5], [(1, 3), (2, 4)]) == [[1, 3], [2, 4], [5]]\n", "\nassert find_independent_sets([1, 2, 3, 4, 5], [(1, 2), (2, 3), (3, 4)]) == [[1, 2, 3, 4], [5]]\n", "\nassert find_independen... |
6f6a7391c367442faaf52926411fdb26 | [
{
"content": "On te demande d'implémenter une fonction factorielle robuste en Python. La fonction doit gérer les entrées erronées avec élégance. Plus précisément, elle doit renvoyer un message d'erreur si l'entrée n'est pas un entier, est négative ou est un nombre à virgule flottante. Ta fonction doit renvoyer ... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(-1) == \"Error: Negative number\"\n", "\nassert factorial(1) == 1\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(\"string\") == \"Error: Input must be an integer\"\n", "\nassert factorial(3.5) == \"Error: Input must b... |
3d629b60e07361f36e4de117d5106084 | [
{
"content": "On te donne une liste de dictionnaires et une clé. Ta tâche est d'écrire une fonction Python qui trie la liste de dictionnaires en fonction des valeurs associées à la clé spécifiée. Si un dictionnaire ne contient pas la clé, il doit être placé à la fin de la liste triée. La fonction doit renvoyer ... | ["\nassert sort_dicts_by_key([{\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Bob\", \"age\": 30}, {\"name\": \"Charlie\"}], \"age\") == [{\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Bob\", \"age\": 30}, {\"name\": \"Charlie\"}]\n", "\nassert sort_dicts_by_key([{\"name\": \"Alice\"}, {\"name\": \"Bob\", \"age\": 3... |
b1b477dee74cc31674a6cdea78dfbba3 | [
{
"content": "On te donne une liste d'entiers `numbers`. Implémente une fonction `count_sign_flips(numbers)` qui renvoie le nombre de fois où le signe d'éléments consécutifs dans la liste change, en ne considérant que les paires d'éléments où les deux nombres sont premiers. Un nombre premier est un nombre natur... | ["\nassert count_sign_flips([-11, 2, -3, 4, 5, -6, 7, -8, 13, -17]) == 3\n", "\nassert count_sign_flips([2, 3, 5, 7, 11]) == 0\n", "\nassert count_sign_flips([-2, -3, -5, -7, -11]) == 0\n", "\nassert count_sign_flips([2, -3, 5, -7, 11]) == 4\n", "\nassert count_sign_flips([1, 4, 6, 8, 10]) == 0\n", "\nassert count_sign... |
feaabb5370a41ea0907fdb6d46679c6f | [
{
"content": "On te demande d'implémenter une fonction `normalize_data` pour un pipeline de traitement de données. La fonction doit accepter une liste de valeurs numériques et renvoyer une nouvelle liste où chaque valeur est normalisée dans une plage comprise entre 0 et 1 en utilisant la formule : (x - min) / (... | ["\nassert normalize_data([1, 2, 3, 4, 5]) == [0.0, 0.25, 0.5, 0.75, 1.0]\n", "\nassert normalize_data([10, 10, 10, 10]) == [0, 0, 0, 0]\n", "\nassert normalize_data([5]) == [0]\n", "\nassert normalize_data([0, 100]) == [0.0, 1.0]\n", "\nassert normalize_data([-10, 0, 10]) == [0.0, 0.5, 1.0]\n", "\nassert normalize_dat... |
4565f8138c84890eaebf681373596fd9 | [
{
"content": "On te donne une chaîne de caractères `s` composée de mots séparés par des caractères d'espacement (espaces, tabulations et sauts de ligne). Ton objectif est d'écrire une fonction qui renvoie le nombre de mots uniques dans la chaîne. Les mots ne distinguent pas la casse et les signes de ponctuation... | ["\nassert count_unique_words(\"Hello, world! Hello world.\") == 2\n", "\nassert count_unique_words(\"Python is great. Python is fun.\") == 4\n", "\nassert count_unique_words(\"One fish, two fish, red fish, blue fish.\") == 5\n", "\nassert count_unique_words(\"A quick brown fox jumps over the lazy dog.\") == 8\n", "\na... |
502242d9f958c0ad6cdaaa23c1f5d383 | [
{
"content": "On te donne une liste de nombres `theList` et une liste correspondante de poids `weights`. Ta tâche est de mettre en œuvre une fonction `weighted_meanie(theList, weights)` qui calcule la moyenne pondérée des nombres. La moyenne pondérée est définie comme la somme de chaque nombre multiplié par son... | ["\nassert weighted_meanie([1, 2, 3], [1, 1, 1]) == 2\n", "\nassert weighted_meanie([10, 20, 30], [1, 2, 3]) == 23.333333333333332\n", "\nassert weighted_meanie([5, 5, 5], [0, 0, 0]) == ValueError(\"All weights are zero, cannot compute weighted mean.\")\n", "\nassert weighted_meanie([1, 2, 3], [1, -1, 1]) == ValueError... |
8a4dfd6cc131b95c7a03f8643af67e88 | [
{
"content": "On te demande de traiter une liste d'employés dans une entreprise. Chaque employé est représenté comme un dictionnaire avec les clés suivantes : `name`, `status`, `devices` et `employee_id`. La clé `devices` correspond à une liste de dictionnaires, chacun contenant `device_name` et `device_type`. ... | ["\nassert get_employee_devices([{'name': 'Alice', 'status': 'active', 'employee_id': 101, 'devices': [{'device_name': 'MacBook', 'device_type': 'laptop'}, {'device_name': 'iPhone', 'device_type': 'phone'}]}]) == [{'device_name': 'iPhone', 'device_type': 'phone'}, {'device_name': 'MacBook', 'device_type': 'laptop'}]\n"... |
da347cf43bd45dc9d636da90e63d2af3 | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tableau NumPy 2D de dimensions `N x N`, où chaque valeur de pixel varie de 0 à 255. L'image est divisée en quatre parties égales verticalement, représentant différentes bandes spectrales : Vert (B3), Rouge (B4), Proche Infrarouge (B5) e... | ["\nassert np.array_equal(calculate_mndwi(np.array([[100, 150], [200, 250], [50, 100], [20, 40]]))[:, :, -1], np.array([[-0.66666667, -0.66666667], [-0.88888889, -0.88888889]]))\n", "\nassert np.array_equal(calculate_mndwi(np.array([[128, 128], [128, 128], [128, 128], [128, 128]]))[:, :, -1], np.array([[0., 0.], [0., 0... |
4add876c4a0511b5ce55030ca4e84160 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire un script Python qui visualise la distribution de fréquence de ces entiers à l'aide d'un diagramme à barres. Utilise la bibliothèque `matplotlib` pour générer le diagramme à barres. Le script doit définir une fonction `plot_number_distribu... | ["\nassert isinstance(plot_number_distribution([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]), type(None))\n", "\nassert isinstance(plot_number_distribution([1]), type(None))\n", "\nassert isinstance(plot_number_distribution([]), type(None))\n", "\nassert isinstance(plot_number_distribution([1, 1, 1, 1, 1]), type(None))\n", "\nassert... |
72d90d5ffaf2e02ab49de35b4a830b49 | [
{
"content": "On te donne un fichier texte et une liste d'exclusion de mots. Ta tâche est d'implémenter une fonction `word_frequency_analysis(path, exclusion_list)` qui lit le fichier texte, effectue une analyse de fréquence des mots et renvoie un dictionnaire avec la fréquence de chaque mot qui ne figure pas d... | ["\nassert word_frequency_analysis('test1.txt', {'the', 'and'}) == {'hello': 1, 'world': 1}\n", "\nassert word_frequency_analysis('test2.txt', set()) == {'this': 1, 'is': 1, 'a': 1, 'test': 1, 'file': 1}\n", "\nassert word_frequency_analysis('test3.txt', {'a', 'the'}) == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, '... |
fc3c7a001244c67b5aa29ad6ea1c382d | [
{
"content": "On te donne un fichier CSV nommé \"data.csv\" avec une ligne d'en-tête. Ta tâche est d'écrire un script Python qui lit ce fichier et calcule la moyenne d'une colonne spécifiée. Le nom de la colonne est fourni en tant que paramètre d'entrée à ta fonction. Si la colonne contient des valeurs non numé... | ["\nassert calculate_average_from_csv(\"data.csv\", \"scores\") == 85.0 # Assuming the average of the \"scores\" column in data.csv is 85.0\n", "\nassert calculate_average_from_csv(\"data.csv\", \"non_existent_column\") == 0 # Column does not exist\n", "\nassert calculate_average_from_csv(\"data.csv\", \"empty_column... |
b5a1e934b758d60a3a7d3a611c638b02 | [
{
"content": "On te donne une liste d'entiers `arr`. Ton objectif est d'implémenter une fonction `find_extremes(arr)` qui renvoie un tuple contenant les plus petit et plus grand entiers uniques de la liste, en excluant tous les entiers qui sont divisibles par 3. Si la liste résultante d'entiers est vide, renvoi... | ["\nassert find_extremes([1, 2, 3, 4, 5, 6, 7, 8, 9]) == (1, 8)\n", "\nassert find_extremes([3, 6, 9]) == None\n", "\nassert find_extremes([]) == None\n", "\nassert find_extremes([7]) == (7, 7)\n", "\nassert find_extremes([10, 15, 20, 25, 30]) == (10, 25)\n", "\nassert find_extremes([0, 1, 2, 3, 4, 5]) == (1, 5)\n", "\... |
cbd897fc1c8dba9e02e7a1f4e85c6ca7 | [
{
"content": "On te demande d'implémenter une fonction `parse_json` qui lit un fichier JSON à partir d'un chemin de fichier donné et renvoie le contenu sous forme de dictionnaire Python. Ta fonction doit gérer divers problèmes potentiels avec élégance et renvoyer des messages d'erreur appropriés. Plus préciséme... | ["\nassert parse_json(\"non_existent_file.json\") == \"Error: The file non_existent_file.json was not found.\"\n", "\nassert parse_json(\"invalid_json_file.json\") == \"Error: The file contains invalid JSON format.\"\n", "\nassert parse_json(\"valid_json_file.json\") == {\"key\": \"value\"}\n", "\nassert parse_json(\"e... |
8f472112eceed2c88be9a5d8ee507d43 | [
{
"content": "Étant donné une liste d'entiers, ta tâche est de mettre en œuvre une fonction `largest_product` qui calcule le produit maximal que l'on peut obtenir en multipliant trois nombres distincts quelconques de la liste. Si la liste contient moins de trois nombres, la fonction doit renvoyer `None`.\n\n**E... | ["\nassert largest_product([1, 2, 3]) == 6\n", "\nassert largest_product([-10, -10, 5, 2]) == 500\n", "\nassert largest_product([1, 2]) == None\n", "\nassert largest_product([0, 2, 3, 5]) == 30\n", "\nassert largest_product([-1, -2, -3, -4]) == -6\n", "\nassert largest_product([1, 10, 2, 6, 5, 3]) == 300\n", "\nassert ... |
2d3b490b00235b8199b413727f19f79c | [
{
"content": "On te donne une image représentée comme un tenseur 3D de forme `(c, w, h)`, où `c` est le nombre de canaux, `w` est la largeur et `h` est la hauteur de l'image. Ta tâche est d'écrire une fonction qui divise cette image en un nombre spécifié de tuiles, `num_tiles`, chacune de taille `(tile_w, tile_... | ["\nassert selected_tiles.shape[0] == num_tiles\n", "\nassert selected_tiles.shape[1] == tile_h\n", "\nassert selected_tiles.shape[2] == tile_w\n", "\nassert selected_tiles.shape[3] == c\n", "\nassert selected_coords.shape[0] == num_tiles\n", "\nassert selected_coords.shape[1] == 2\n", "\nassert all_tiles.shape[0] == (... |
591e3f8adca2a8877141e0208ccb6dcd | [
{
"content": "Étant donné deux listes d'entiers, `list1` et `list2`, écris une fonction `find_common_elements(list1, list2)` qui renvoie une liste d'entiers uniques qui sont présents dans les deux listes d'entrée. L'ordre des éléments dans la liste de sortie n'a pas d'importance.\n\n**Exemple d'entrée :**\n- `l... | ["\nassert find_common_elements([1, 2, 2, 3], [2, 3, 4]) == [2, 3]\n", "\nassert find_common_elements([1, 1, 1, 1], [1, 1, 1, 1]) == [1]\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\na... |
f3aa1922f2a17577559d179e71592243 | [
{
"content": "On te donne deux listes triées, `list1` et `list2`. Ta tâche est d'écrire une fonction `merge_sorted_lists` qui fusionne ces deux listes en une seule liste triée en utilisant la technique des deux pointeurs. La fonction doit gérer les cas limites où une ou les deux listes sont vides.\n\n**Signatur... | ["\nassert merge_sorted_lists([1, 3, 5], [2, 4, 6]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_sorted_lists([], [1, 2, 3]) == [1, 2, 3]\n", "\nassert merge_sorted_lists([1, 2, 3], []) == [1, 2, 3]\n", "\nassert merge_sorted_lists([], []) == []\n", "\nassert merge_sorted_lists([1, 2, 3], [4, 5, 6]) == [1, 2, 3, 4, 5, 6]\... |
6f7a03fe89a8fd0f2c26382676b84a68 | [
{
"content": "On te demande d'implémenter une classe `Account` qui simule un compte bancaire. La classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation** : Créer un compte avec le nom du titulaire et un solde initial de 0,0.\n- **Dépôt** : Ajouter un montant spécifié au solde du compte. ... | ["\nassert Account(\"John\").owner == \"John\"\n", "\nassert Account(\"Jane\").balance == 0.0\n", "\nassert Account(\"Alice\").deposit(100) is None\n", "\nassert Account(\"Bob\").deposit(-50) == \"Deposit amount should be positive.\"\n", "\nassert Account(\"Charlie\").withdraw(20) == \"Insufficient funds.\"\n", "\nasse... |
f35ff0379afc19d0a296f82d7d533dfd | [
{
"content": "On te demande d'écrire une fonction nommée `planetary_size` qui calcule la taille apparente d'une planète vue depuis la Terre, en tenant compte de l'orbite elliptique de la planète. La fonction doit utiliser les paramètres suivants :\n- `diameter` : le diamètre de la planète en unités astronomique... | ["\nassert planetary_size(1, 1, 0, 0) == 206265\n", "\nassert planetary_size(1, 1, 0.5, math.pi) == 206265\n", "\nassert planetary_size(2, 1, 0, 0) == 412530\n", "\nassert planetary_size(1, 2, 0, 0) == 103132.5\n", "\nassert planetary_size(1, 1, 0.1, 0) == 206265 / (1 - 0.1)\n", "\nassert planetary_size(1, 1, 0.1, math... |
debb71c71eddde72bcd945071535ad9f | [
{
"content": "On te demande de concevoir une classe en Python qui modélise un système de bibliothèque simple. La classe doit prendre en charge les opérations suivantes :\n- Ajouter un livre à la bibliothèque avec son titre, son auteur et son numéro ISBN.\n- Supprimer un livre de la bibliothèque en utilisant son... | ["\nassert len(Library().books) == 0\n", "\nlib = Library(); lib.add_book(\"1984\", \"George Orwell\", \"1234567890\"); assert len(lib.books) == 1\n", "\nlib = Library(); lib.add_book(\"1984\", \"George Orwell\", \"1234567890\"); lib.add_book(\"To Kill a Mockingbird\", \"Harper Lee\", \"0987654321\"); assert len(lib.bo... |
66590c865b8a8ae0712b9fb6b3f89aed | [
{
"content": "On te donne un tableau trié `nums` d'entiers distincts et un entier `target`. Le tableau est trié par ordre non décroissant, et tous les éléments sont uniques. Ta tâche est de déterminer l'indice de la première occurrence de `target` dans `nums`. Si `target` n'est pas présent dans le tableau, reto... | ["\nassert find_first_occurrence([1, 2, 4, 4, 5, 6, 7], 4) == 2\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5, 6, 7], 5) == 4\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5, 6, 7], 1) == 0\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5, 6, 7], 7) == 6\n", "\nassert find_first_occurrence([1, 2, 3, 4, 5, 6, ... |
70ffb5892e34c756043e8efb4acfd2c7 | [
{
"content": "On te demande d'écrire une fonction pour valider des numéros de téléphone dans un format spécifique. Un numéro de téléphone valide doit respecter le modèle `(XXX) XXX-XXXX`, où chaque `X` est un chiffre de 0 à 9. La fonction doit également tenir compte des espaces blancs de début et de fin faculta... | ["\nassert is_valid_phone_number(\" (123) 456-7890 \") == True\n", "\nassert is_valid_phone_number(\"(123) 456-7890\") == True\n", "\nassert is_valid_phone_number(\" (123)456-7890 \") == False\n", "\nassert is_valid_phone_number(\"123-456-7890\") == False\n", "\nassert is_valid_phone_number(\"1234567890\") == False\n",... |
ec46374c134472b87dc833cc1cb121dd | [
{
"content": "On te demande d'implémenter deux fonctions pour calculer le nième nombre de Fibonacci. La première fonction doit utiliser la récursion, et la seconde doit utiliser une approche itérative. Ton implémentation doit être efficace et gérer les grandes valeurs de n. Fournis les fonctions et compare leur... | ["\nassert fibonacci_recursive(0) == 0\n", "\nassert fibonacci_recursive(1) == 1\n", "\nassert fibonacci_recursive(2) == 1\n", "\nassert fibonacci_recursive(5) == 5\n", "\nassert fibonacci_recursive(10) == 55\n", "\nassert fibonacci_iterative(0) == 0\n", "\nassert fibonacci_iterative(1) == 1\n", "\nassert fibonacci_ite... |
8b31d081edee57f432ebe0863f382579 | [
{
"content": "On te donne une matrice d'entiers `n x n` nommée `matrix`. Ta tâche est de faire pivoter la matrice de 90 degrés dans le sens des aiguilles d'une montre sur place. La fonction ne doit rien retourner ; au lieu de cela, elle doit modifier directement la matrice d'entrée. Tu n'es pas autorisé à utili... | ["\nassert rotate_matrix_90_degrees_clockwise([[1, 2], [3, 4]]) == None and [[3, 1], [4, 2]] == [[3, 1], [4, 2]]\n", "\nassert rotate_matrix_90_degrees_clockwise([[1]]) == None and [[1]] == [[1]]\n", "\nassert rotate_matrix_90_degrees_clockwise([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == None and [[7, 4, 1], [8, 5, 2], [9, 6... |
7746e7e876963a0b826a0f37c072f943 | [
{
"content": "Implémente une classe Python `Car` avec les spécifications suivantes :\n\n- **Constructeur** : `__init__(self, make, model, year)` initialise la marque, le modèle, l'année de la voiture et définit le compteur kilométrique à 0.\n- **Méthode** : `read_odometer(self)` affiche le kilométrage actuel au... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020).make == \"Toyota\"\n", "\nassert Car(\"Honda\", \"Civic\", 2019).model == \"Civic\"\n", "\nassert Car(\"Ford\", \"Mustang\", 2021).year == 2021\n", "\nassert Car(\"Chevrolet\", \"Impala\", 2018).odometer_reading == 0\n", "\ncar = Car(\"BMW\", \"M3\", 2022)\ncar.update_odome... |
0e8f50067e8e77fd3e40cef5c7871f01 | [
{
"content": "On te donne un ensemble `S` contenant des entiers distincts. Ta tâche est d'écrire une fonction `generate_all_subsets` qui renvoie tous les sous-ensembles possibles (l'ensemble des parties) de `S`. Les sous-ensembles doivent être représentés sous forme de liste de listes, où chaque liste interne e... | ["\nassert generate_all_subsets({1, 2, 3}) == [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]\n", "\nassert generate_all_subsets({}) == [[]]\n", "\nassert generate_all_subsets({42}) == [[], [42]]\n", "\nassert generate_all_subsets({1, 2}) == [[], [1], [2], [1, 2]]\n", "\nassert generate_all_subsets({5, 6, 7, 8})... |
070f3fedab4953e7e4c3de30d9f5a760 | [
{
"content": "On te donne un tenseur 3D `coords` de forme `(..., 3)`, représentant des coordonnées barycentriques avec des entrées potentiellement invalides. Ta tâche est de modifier le tenseur en écrêtant et en renormalisant les coordonnées valides tout en laissant inchangées les entrées invalides. Une coordon... | ["\nassert torch.allclose(clip_and_renormalize(torch.tensor([[0.5, 0.5, 0.5]])), torch.tensor([[1/3, 1/3, 1/3]]))\n", "\nassert torch.allclose(clip_and_renormalize(torch.tensor([[0.2, 0.3, 0.5]])), torch.tensor([[0.2, 0.3, 0.5]]))\n", "\nassert torch.allclose(clip_and_renormalize(torch.tensor([[1.2, 0.3, 0.5]])), torch... |
1b2b069fe4e41e4fd721a0b5be7b1d21 | [
{
"content": "On te demande d'implémenter un décorateur Python nommé `log_args`. Ce décorateur doit enregistrer les arguments avec lesquels une fonction est appelée et le résultat qu'elle renvoie. Ton implémentation doit fonctionner pour toute fonction qui prend à la fois des arguments positionnels et des argum... | ["\nassert log_args(lambda x: x)(5) == 5\n", "\nassert log_args(lambda x, y: x + y)(3, 4) == 7\n", "\nassert log_args(lambda x, y, z: x * y + z)(2, 3, 4) == 10\n", "\nassert log_args(lambda x=10: x)(20) == 20\n", "\nassert log_args(lambda x=10, y=20: x + y)() == 30\n", "\nassert log_args(lambda x, y=10: x + y)(5) == 15... |
d415d9e10c0542c4f38782aec78617b5 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de déterminer le nombre de sous-tableaux contigus dans `nums` dont la somme est égale à `target`.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), le nombre d'éléments dans le tableau.\n- La deux... | ["\nassert count_subarrays_with_sum([1, 1, 1], 2) == 2\n", "\nassert count_subarrays_with_sum([1, 2, 3, 4, 5], 5) == 2\n", "\nassert count_subarrays_with_sum([0, 0, 0, 0, 0], 0) == 15\n", "\nassert count_subarrays_with_sum([1, -1, 0], 0) == 3\n", "\nassert count_subarrays_with_sum([10, 2, -2, -20, 10], -10) == 3\n", "\... |
36cfd5b4193eab328ba5286079347465 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour calculer le nième nombre de Fibonacci. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Ta solution doit utiliser la mémoïsation pour optimiser le calcul.\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(20) == 6765\n", "\nassert fibonacci(30) == 832040\n", "\nassert fibonacci... |
e52947534aa375d29abb0c339d11f6af | [
{
"content": "On te donne une matrice 4x4 `X` représentant une transformation dans le groupe spécial euclidien SE(3) dans un système de coordonnées main gauche, où la quatrième ligne et la quatrième colonne sont [0, 0, 0, 1]. Ta tâche est de décomposer cette matrice en ses composantes de rotation et de translat... | ["\nassert np.array_equal(decompose_se3_matrix(np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))[0], np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]))\n", "\nassert np.array_equal(decompose_se3_matrix(np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))[1], np.array([0, 0, 0]))\n", "\nassert... |
7c49440d9b6b2c614f24bf8fa1f4cbac | [
{
"content": "On te donne une liste d'entiers `numbers` et une fonction `operation`. La fonction `operation` prend un seul entier en entrée et renvoie un entier. Ta tâche est de mettre en œuvre une fonction `apply_operation` qui applique la fonction `operation` à chaque élément de la liste `numbers`. Si la fonc... | ["\nassert apply_operation([1, 2, 3], lambda x: x * x) == [1, 4, 9]\n", "\nassert apply_operation([4, 5, 6], lambda x: x + 1) == [5, 6, 7]\n", "\nassert apply_operation([10, 20, 30], lambda x: x / 2) == [5.0, 10.0, 15.0]\n", "\nassert apply_operation([], lambda x: x - 1) == []\n", "\nassert apply_operation([1, -1, 0], ... |
ce098d4658873c36ed0bddfea32e2456 | [
{
"content": "Tu développes un jeu simple de devinettes de nombres à des fins éducatives. Dans ce jeu, un entier aléatoire entre 1 et 100 est sélectionné. Le joueur doit deviner ce nombre. Après chaque tentative, le programme doit informer le joueur si sa supposition est trop basse, trop haute ou correcte. Le j... | ["\nassert guess_number([50, 75, 88, 92, 95, 97, 99, 100]) == 8\n", "\nassert guess_number([100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44,... |
94c6a63441f737330a91dd34a33ed643 | [
{
"content": "Implémente une classe `Car` avec les spécifications suivantes :\n\n- La classe doit avoir un initialiseur qui prend trois paramètres : `make`, `model` et `year`.\n- Implémente une méthode `display_info` qui affiche la marque, le modèle et l'année de la voiture au format : \"Make: {make}, Model: {m... | ["\nassert car.make == \"Toyota\"\n", "\nassert car.model == \"Corolla\"\n", "\nassert car.year == 2022\n", "\nassert car.calculate_age(2023) == 1\n", "\nassert car.calculate_age(2022) == 0\n", "\nassert car.calculate_age(2018) == 4\n", "\nassert car.calculate_age(2017) == 5\n", "\ncar.update_year(2019)\nassert car.yea... |
2bd059ff5eb6843355496922700932b8 | [
{
"content": "On te donne une liste triée d'entiers `sorted_list` et un entier `target`. Implémente une fonction `optimized_search` qui effectue une recherche binaire pour trouver l'index de `target` dans `sorted_list`. Si `target` est trouvé, retourne son index ; sinon, retourne -1.\n\n**Entrée :**\n- Le premi... | ["\nassert optimized_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 7) == 3\n", "\nassert optimized_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 1) == 0\n", "\nassert optimized_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 19) == 9\n", "\nassert optimized_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 20) == -1\n", "\nassert op... |
7d55318bfcd580396ddfb2f39eed84f6 | [
{
"content": "On te donne un fichier texte encodé en UTF-8. Ta tâche est d'écrire un programme qui lit le fichier, compte la fréquence de chaque mot, et affiche les 10 mots les plus fréquents ainsi que leurs fréquences. Les mots sont définis comme des séquences de lettres et sont insensibles à la casse.\n\n**En... | ["\nassert count_words_in_file('test1.txt') == None\n", "\nassert count_words_in_file('test2.txt') == None\n", "\nassert count_words_in_file('empty.txt') == None\n", "\nassert count_words_in_file('singleword.txt') == None\n", "\nassert count_words_in_file('twowords.txt') == None\n", "\nassert count_words_in_file('repea... |
9436fe610b8f1db3c08dcb37fd1fb801 | [
{
"content": "On te donne un tableau d'octets représentant une série d'entiers 32 bits au format little-endian, avec des octets de remplissage possibles intercalés entre eux. Chaque octet de remplissage est marqué avec la valeur `0xFF` et doit être ignoré pendant le processus de décodage. Ta tâche est de mettre... | ["\nassert decode_integer([0x01, 0x02, 0x03, 0x04], 0) == 67305985\n", "\nassert decode_integer([0xFF, 0x01, 0x02, 0x03, 0x04], 1) == 67305985\n", "\nassert decode_integer([0xFF, 0xFF, 0x01, 0x02, 0x03, 0x04], 2) == 67305985\n", "\nassert decode_integer([0x01, 0x02, 0x03, 0x04, 0xFF, 0x05, 0x06, 0x07, 0x08], 0) == 6730... |
d8af60ac1c22483addd770e070bc0e01 | [
{
"content": "On te demande d'implémenter une classe `Book` qui encapsule les détails d'un livre. La classe doit avoir les attributs privés 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 hasattr(Book, '__init__')\n", "\nassert hasattr(Book, 'display_info')\n", "\nassert hasattr(Book, 'update_publisher')\n", "\nbook = Book(\"1984\", \"George Orwell\", \"9780451524935\", \"Signet Classic\", 1950)\nassert book._Book__title == \"1984\"\n", "\nbook = Book(\"1984\", \"George Orwell\", \"9780451524... |
4910b1c16f343edcc05709f9c7f1b711 | [
{
"content": "On te donne un entier positif `num`. Ta tâche est de déterminer si les deux derniers chiffres de `num` sont inférieurs ou égaux à 20 ou supérieurs ou égaux à 80. Implémente la fonction `is_near_hundred(num)` qui renvoie `True` si la condition est remplie, sinon `False`. Tu ne dois pas convertir `n... | ["\nassert is_near_hundred(100) == True\n", "\nassert is_near_hundred(99) == False\n", "\nassert is_near_hundred(80) == True\n", "\nassert is_near_hundred(20) == True\n", "\nassert is_near_hundred(19) == True\n", "\nassert is_near_hundred(81) == True\n", "\nassert is_near_hundred(79) == False\n", "\nassert is_near_hund... |
04c298065b199cb9854765553781b726 | [
{
"content": "On te donne un objet JSON sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction Python qui analyse cet objet JSON et affiche toutes les valeurs associées à chaque clé, en gérant tout niveau d'imbrication. La sortie doit afficher le chemin d'accès à chaque valeur dans la structure ... | ["\nassert print_json_values({\"name\": \"John\"}) == None\n", "\nassert print_json_values({\"name\": \"John\", \"age\": 30}) == None\n", "\nassert print_json_values({\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}) == None\n", "\nassert print_json_values({\"name\": \"John\", \"children\": [{\"name\": \"Alice\... |
a864ec8bcd2958ff46b1d312647fb63d | [
{
"content": "On te donne un ensemble de données de séries temporelles de longueur `series_length`. Ta tâche est de partitionner cet ensemble de données en fenêtres plus petites pour l'analyse. Chaque fenêtre doit avoir une taille de `window_size` et il doit y avoir un chevauchement de `overlap` points entre le... | ["\nassert create_overlapping_windows([1, 2, 3, 4, 5], 2, 1) == [[1, 2], [2, 3], [3, 4], [4, 5]]\n", "\nassert create_overlapping_windows([1, 2, 3, 4, 5], 3, 1) == [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n", "\nassert create_overlapping_windows([1, 2, 3, 4, 5], 5, 0) == [[1, 2, 3, 4, 5]]\n", "\nassert create_overlapping_wind... |
54d62b07b8b641b95fe4527518c9e416 | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente un segment sur une droite numérique défini par ses points de début et de fin. Les segments peuvent avoir des valeurs négatives et peuvent ne pas être dans un ordre spécifique. Ta tâche est de déterminer la distance minimale entre deux seg... | ["\nassert find_min_distance_and_overall_bounds([(1, 3), (5, 7), (8, 10)]) == (2, 1, 10)\n", "\nassert find_min_distance_and_overall_bounds([(1, 3), (3, 5), (5, 7)]) == (0, 1, 7)\n", "\nassert find_min_distance_and_overall_bounds([(1, 3), (4, 6), (7, 9)]) == (1, 1, 9)\n", "\nassert find_min_distance_and_overall_bounds(... |
3969311f4665e0c6c87adfdbe2756663 | [
{
"content": "On te demande d'implémenter un système bancaire simple en Python. Ton système doit prendre en charge la création de comptes bancaires, les dépôts, les retraits et les demandes de solde. Chaque compte bancaire est identifié de manière unique par un numéro de compte et est associé au nom du titulair... | ["\nassert BankAccount('A123456789', 'John Doe').balance == 0.00\n", "\nassert BankAccount('A123456789', 'John Doe', 100.00).balance == 100.00\n", "\naccount = BankAccount('A123456789', 'John Doe', 100.00); account.deposit(50.00); assert account.balance == 150.00\n", "\naccount = BankAccount('A123456789', 'John Doe', 1... |
d5f42c9eb196cffac91f621e55217759 | [
{
"content": "On te donne une chaîne de caractères `s` composée des caractères '(', ')', '{', '}', '[' et ']'. Ta tâche est de déterminer si la chaîne a des parenthèses, des crochets et des accolades équilibrés. Une chaîne est considérée comme équilibrée si chaque parenthèse ouvrante, crochet ou accolade a une ... | ["\nassert is_balanced_parentheses(\"{[()]}([])\") == True\n", "\nassert is_balanced_parentheses(\"{[(])}\") == False\n", "\nassert is_balanced_parentheses(\"{{[[(())]]}}\") == True\n", "\nassert is_balanced_parentheses(\"()[]{}\") == True\n", "\nassert is_balanced_parentheses(\"([)]\") == False\n", "\nassert is_balanc... |
7a6fce27c26e8fc2b612b0fb772952d2 | [
{
"content": "On te donne une chaîne de caractères `expression` représentant une expression mathématique. L'expression est composée d'entiers, des opérateurs `+`, `-`, `*`, `/`, et de parenthèses `()`. Ta tâche est d'évaluer l'expression et de renvoyer le résultat sous forme de nombre à virgule flottante. La fo... | ["\nassert eval_expr(\"2 + 2\") == 4\n", "\nassert eval_expr(\"10 - 5\") == 5\n", "\nassert eval_expr(\"3 * 4\") == 12\n", "\nassert eval_expr(\"8 / 2\") == 4.0\n", "\nassert eval_expr(\"(2 + 3) * 4\") == 20\n", "\nassert eval_expr(\"10 / (2 + 3)\") == 2.0\n", "\nassert eval_expr(\"2 + 3 * 4 - 5\") == 9\n", "\nassert e... |
30a58ce57ef1770aa462c5564cc80d9a | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces simples. Ta tâche est d'écrire une fonction `reverse_words(s)` qui renvoie une nouvelle chaîne de caractères avec les mots dans l'ordre inverse. Suppose que la chaîne d'entrée ne contient pas d'espaces de début ou ... | ["\nassert reverse_words(\"Hello world this is a test\") == \"test a is this world Hello\"\n", "\nassert reverse_words(\"one two three\") == \"three two one\"\n", "\nassert reverse_words(\"Python is fun\") == \"fun is Python\"\n", "\nassert reverse_words(\"a b c d e\") == \"e d c b a\"\n", "\nassert reverse_words(\"sin... |
212026aca8a4d01a6da5f3884cbe957c | [
{
"content": "On te donne une chaîne de caractères `text`. Ta tâche est d'écrire une fonction `character_frequency` qui renvoie un dictionnaire avec la fréquence de chaque caractère dans la chaîne, en ignorant les espaces et la ponctuation. La fonction doit traiter les caractères majuscules et minuscules comme ... | ["\nassert character_frequency(\"Hello, World!\") == {'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}\n", "\nassert character_frequency(\"A quick brown fox jumps over the lazy dog.\") == {'a': 1, 'q': 1, 'u': 2, 'i': 1, 'c': 1, 'k': 1, 'b': 1, 'r': 2, 'o': 4, 'w': 1, 'n': 1, 'f': 1, 'x': 1, 'j': 1, 'm': 1, 'p':... |
97c562c3d8c39b60d72d0b3816bf7e40 | [
{
"content": "On te donne un fichier nommé `data.txt` contenant plusieurs entrées par ligne. Chaque entrée est composée d'un prénom, d'un nom de famille et d'un code postal, séparés par des virgules. Ta tâche est d'écrire une fonction `get_unique_zip_codes(file_name)` qui lit ce fichier et renvoie une liste de ... | ["\nassert get_unique_zip_codes(\"test1.txt\") == [\"12345\", \"67890\"]\n", "\nassert get_unique_zip_codes(\"test2.txt\") == [\"11111\", \"22222\", \"33333\"]\n", "\nassert get_unique_zip_codes(\"test3.txt\") == [\"54321\"]\n", "\nassert get_unique_zip_codes(\"test4.txt\") == []\n", "\nassert get_unique_zip_codes(\"te... |
fbafca1296c5d1a86d1180ff17f86131 | [
{
"content": "On te demande d'implémenter une fonction `calculate_ejection_fraction` qui calcule la fraction d'éjection ventriculaire gauche (FEVG) en utilisant uniquement des opérations au niveau du bit. La fonction ne doit utiliser aucune opération arithmétique (+, -, *, /, %) ni aucune instruction conditionn... | ["\nassert calculate_ejection_fraction(120, 50) == 58\n", "\nassert calculate_ejection_fraction(100, 20) == 80\n", "\nassert calculate_ejection_fraction(150, 50) == 67\n", "\nassert calculate_ejection_fraction(200, 100) == 50\n", "\nassert calculate_ejection_fraction(250, 125) == 50\n", "\nassert calculate_ejection_fra... |
963915155bea1f851ceade1fba564cc2 | [
{
"content": "On te donne une chaîne de caractères `sentence`. Ta tâche est de déterminer si la phrase est une phrase miroir. Une phrase miroir se lit de la même manière de gauche à droite et de droite à gauche, en traitant les mots numériques comme distincts des chiffres numériques, et en ignorant la casse et ... | ["\nassert is_mirrored_sentence(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_mirrored_sentence(\"Was it a car or a cat I saw\") == True\n", "\nassert is_mirrored_sentence(\"No lemon, no melon\") == True\n", "\nassert is_mirrored_sentence(\"Hello World\") == False\n", "\nassert is_mirrored_sentence(\"123... |
4f58f3b6ae1488bf92f433eb39436059 | [
{
"content": "On te donne un fichier CSV nommé `data.csv` avec une ligne d'en-tête. Ta tâche est d'écrire un script Python qui lit ce fichier et calcule la moyenne des valeurs numériques dans la troisième colonne. Suppose que la troisième colonne peut contenir des valeurs non numériques ou être manquante, et ce... | ["\nassert calculate_average_of_third_column('data_with_single_row.csv') == 42.0\n", "\nassert calculate_average_of_third_column('data_with_multiple_rows.csv') == 25.0\n", "\nassert calculate_average_of_third_column('data_with_non_numeric_values.csv') == 50.0\n", "\nassert calculate_average_of_third_column('data_with_e... |
aab2fe9edb2be2163f8d2af959546e31 | [
{
"content": "On te donne un fichier texte et une liste de mots vides. Ta tâche est d'écrire une fonction `count_words_in_file(file_path, stop_words_file_path)` qui lit le fichier texte et renvoie le nombre total de mots, en traitant les mots composés comme un seul mot, tout en excluant les mots présents dans l... | ["\nassert count_words_in_file(\"test_file.txt\", \"stop_words.txt\") == 5\n", "\nassert count_words_in_file(\"empty_file.txt\", \"stop_words.txt\") == 0\n", "\nassert count_words_in_file(\"file_with_only_stop_words.txt\", \"stop_words.txt\") == 0\n", "\nassert count_words_in_file(\"file_with_hyphenated-words.txt\", \"... |
81966676fb18fed4a09bf1c02f5f3b67 | [
{
"content": "On te donne une chaîne de caractères `html` représentant le contenu HTML d'une page web. Ta tâche est de mettre en œuvre une fonction `extract_links(html)` qui extrait toutes les URL des balises `<a>` dans le contenu HTML. La fonction doit renvoyer une liste d'URL trouvées dans les attributs `href... | ["\nassert extract_links('<a href=\"http://example.com\">Example</a>') == [\"http://example.com\"]\n", "\nassert extract_links('<a href=\\'http://example.com\\'>Example</a>') == [\"http://example.com\"]\n", "\nassert extract_links('<a href=\"http://example.com\">Example</a><a href=\"http://test.com\">Test</a>') == [\"h... |
03384f822823f5418ed3a5c658a57dbf | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est d'implémenter une fonction `count_evens_and_odds(nums)` qui calcule le nombre d'entiers pairs et impairs dans la liste. La fonction doit renvoyer un tuple dont le premier élément est le nombre de nombres pairs et le second élément est le nombre ... | ["\nassert count_evens_and_odds([1, 2, 3, 4, 5]) == (2, 3)\n", "\nassert count_evens_and_odds([2, 4, 6, 8, 10]) == (5, 0)\n", "\nassert count_evens_and_odds([1, 3, 5, 7, 9]) == (0, 5)\n", "\nassert count_evens_and_odds([]) == (0, 0)\n", "\nassert count_evens_and_odds([0]) == (1, 0)\n", "\nassert count_evens_and_odds([-... |
631d65022e37549252e5ebf367a350cf | [
{
"content": "On te donne une chaîne de caractères qui peut contenir des espaces, de la ponctuation et une capitalisation variable. Ta tâche est de déterminer si la chaîne est un palindrome, en ignorant les espaces, la ponctuation et la capitalisation. Un palindrome est une chaîne qui se lit de la même manière ... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"hello\") == False\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome... |
f37a588bb2e050bad50875cc98d29bcb | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `find_max` qui renvoie l'entier maximal dans la liste. Si la liste est vide, la fonction doit renvoyer 0.\n\n**Exemple d'entrée 1 :**\n```\n[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]\n```\n**Exemple de sortie 1 :**\n```\n9\n```\n\... | ["\nassert find_max([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 9\n", "\nassert find_max([10, 20, 30, 40, 50]) == 50\n", "\nassert find_max([-10, -20, -30, -40, -50]) == -10\n", "\nassert find_max([0, 0, 0, 0, 0]) == 0\n", "\nassert find_max([100]) == 100\n", "\nassert find_max([]) == 0\n", "\nassert find_max([5, 5, 5, 5, 5]... |
01bec2358c058442979d6694da6a1b58 | [
{
"content": "On te donne une liste de fragments de code. Ta tâche est de classer chaque fragment dans l'une des deux catégories suivantes : \"Fonction\" ou \"Classe\". Chaque fragment doit être étiqueté en conséquence. L'entrée sera une liste de chaînes de caractères, où chaque chaîne représente un fragment de... | ["\nassert isinstance(greet, type(lambda: None))\n", "\nassert greet(\"Alice\") == \"Hello, Alice!\"\n", "\nassert isinstance(Dog, type)\n", "\nassert hasattr(Dog, \"__init__\")\n", "\nassert Dog.__init__.__name__ == \"__init__\"\n", "\nassert Dog(\"Buddy\").name == \"Buddy\"\n", "\nassert not isinstance(Dog, type(lamb... |
b3db9dcbc901ec3ca2673d43d9fbe4cd | [
{
"content": "On te donne une chaîne de caractères `expression` représentant une expression mathématique composée d'entiers, d'addition (+), de soustraction (-), de multiplication (*) et d'opérateurs de division (/). La division doit être effectuée comme une division entière (//). L'expression peut également co... | ["\nassert calculate_expression(\"3 + 5 * (2 - 8)\") == -15\n", "\nassert calculate_expression(\"10 + 2 * 6\") == 22\n", "\nassert calculate_expression(\"100 * 2 + 12\") == 212\n", "\nassert calculate_expression(\"100 * ( 2 + 12 )\") == 1400\n", "\nassert calculate_expression(\"100 * ( 2 + 12 ) / 14\") == 100\n", "\nas... |
206109f76e9f4f6d7597a2ca11d3002a | [
{
"content": "Tu développes une application web et tu dois implémenter une fonction qui construit un dictionnaire imbriqué représentant un sous-menu de barre latérale. La barre latérale contient des éléments de menu principaux, chacun pouvant avoir des sous-menus imbriqués. Chaque élément de menu est représenté... | ["\nassert create_submenu([('Home', 'home.html')]) == {'Home': {'url': 'home.html'}}\n", "\nassert create_submenu([('About', 'about.html', [('Our Team', 'team.html')])]) == {'About': {'url': 'about.html', 'submenu': {'Our Team': {'url': 'team.html'}}}}\n", "\nassert create_submenu([('Services', 'services.html', [('Web ... |
3f25c9820b029df550b84112b1c8d0ca | [
{
"content": "Tu participes à un concours de programmation où tu dois écrire un programme Python pour interagir avec une base de données SQLite nommée \"employees.db\" située dans le même répertoire que ton script. La base de données contient une table nommée \"employees\" avec le schéma suivant :\n\n- `id` INT... | ["\nassert fetch_and_print_employees() is None # Assuming the function prints to stdout and returns None\n", "\nassert CustomSQLiteConnection(\"employees.db\").connect() is not None # Assuming the database file exists and is accessible\n", "\nassert CustomSQLiteConnection(\"nonexistent.db\").connect() is None # Assu... |
8305e8d28f78e4c92ad5ed886ecd92c5 | [
{
"content": "On te donne un fichier CSV nommé `employees.csv` contenant des données sur les employés avec les colonnes suivantes : `id`, `name`, `department` et `salary`. Ta tâche est d'écrire une fonction Python qui lit ce fichier CSV, calcule le salaire total pour chaque département et renvoie un dictionnair... | ["\nassert process_employee_salaries('test1.csv') == None\n", "\nassert process_employee_salaries('test2.csv') == None\n", "\nassert process_employee_salaries('empty.csv') == None\n", "\nassert process_employee_salaries('single_entry.csv') == None\n", "\nassert process_employee_salaries('multiple_departments.csv') == N... |
eb76e4642393283441e8a7b91c4ba1fc | [
{
"content": "On te donne une chaîne de caractères `S` composée de `N` lettres minuscules de l'alphabet anglais. Tu peux effectuer les opérations suivantes sur la chaîne :\n1. Insérer un caractère à n'importe quelle position.\n2. Supprimer un caractère de n'importe quelle position.\n\nDétermine le nombre minimu... | ["\nassert min_operations_to_palindrome(\"abc\") == 2\n", "\nassert min_operations_to_palindrome(\"aa\") == 0\n", "\nassert min_operations_to_palindrome(\"abca\") == 1\n", "\nassert min_operations_to_palindrome(\"race\") == 2\n", "\nassert min_operations_to_palindrome(\"madam\") == 0\n", "\nassert min_operations_to_pal... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.