id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
ee77b5d7513666f18ed72dc44b041358 | [
{
"content": "On te demande d'implémenter deux fonctions pour la conversion de température. La première fonction, `convert_to_celsius`, doit prendre une température en Fahrenheit en entrée et renvoyer la température équivalente en Celsius. La seconde fonction, `convert_to_fahrenheit`, doit prendre une températu... | ["\nassert convert_to_celsius(32) == 0\n", "\nassert convert_to_celsius(212) == 100\n", "\nassert convert_to_celsius(-40) == -40\n", "\nassert convert_to_fahrenheit(0) == 32\n", "\nassert convert_to_fahrenheit(100) == 212\n", "\nassert convert_to_fahrenheit(-40) == -40\n", "\nassert convert_to_celsius(98.6) == 37\n", "... |
4958ca32bdc8e0b5c94bb0ab0b7c7f3d | [
{
"content": "Tu es chargé d'écrire une fonction qui identifie les URL valides dans un texte donné. Les URL doivent prendre en charge les protocoles `http`, `https` et `ftp` et peuvent éventuellement inclure un numéro de port. Ta fonction doit renvoyer une liste de toutes les URL valides trouvées dans le texte.... | ["\nassert find_urls(\"http://example.com\") == [\"http://example.com\"]\n", "\nassert find_urls(\"https://example.com:8080\") == [\"https://example.com:8080\"]\n", "\nassert find_urls(\"ftp://example.com/resource\") == [\"ftp://example.com/resource\"]\n", "\nassert find_urls(\"http://sub.example.co.uk/path?query=123\"... |
4617d09c00beaa2424edd9d9f8677c5c | [
{
"content": "Étant donné une liste d'entiers `numbers` et un entier cible `target`, ta tâche est de trouver la paire d'entiers dans `numbers` dont la somme est la plus proche de `target`. La fonction doit renvoyer un tuple contenant les deux entiers dans l'ordre où ils apparaissent dans la liste. S'il existe p... | ["\nassert closest_pair([1, 5, 7, -2, 3, 6, 9, 8], 10) == (1, 9)\n", "\nassert closest_pair([1, 2, 3, 4, 5], 8) == (3, 5)\n", "\nassert closest_pair([10, 22, 28, 29, 30, 40], 54) == (22, 30)\n", "\nassert closest_pair([-1, 2, 1, -4], 1) == (2, 1)\n", "\nassert closest_pair([0, 0, 0, 0], 0) == (0, 0)\n", "\nassert close... |
2f34d299bc54be414f4e37b9252bfb50 | [
{
"content": "On te donne la tâche de traiter un large corpus de données textuelles pour en extraire une liste d'échantillons. Le corpus peut être fourni au format JSON ou TXT. Pour le format JSON, chaque échantillon est un dictionnaire avec les clés \"sentence\" et \"tags\", où \"sentence\" est une liste de ca... | ["\nassert read_corpus('test.json') == [{'sentence': ['h', 'e', 'l', 'l', 'o'], 'tags': ['O', 'O', 'O', 'O', 'O']}]\n", "\nassert read_corpus('test.txt') == [{'sentence': ['h', 'e', 'l', 'l', 'o'], 'tags': ['O', 'O', 'O', 'O', 'O']}]\n", "\nassert read_corpus('empty.json') == []\n", "\nassert read_corpus('empty.txt') =... |
d67178d30cbfbe4d373eb5c8a4da4ad0 | [
{
"content": "On te demande d'implémenter une fonction `convert_file_name` qui traite un nom de fichier donné pour le rendre plus adapté à un répertoire. La fonction doit effectuer les transformations suivantes :\n- Remplacer tous les tirets bas (\"_\") par des tirets (\"-\").\n- Remplacer tous les points (\".\... | ["\nassert convert_file_name(\"example_file.txt\") == \"txt/example-file\"\n", "\nassert convert_file_name(\"another_example_file.tar.gz\") == \"gz/tar/another-example-file\"\n", "\nassert convert_file_name(\"no_underscores_or_periods\") == \"no-underscores-or-periods\"\n", "\nassert convert_file_name(\"multiple__under... |
380a599b28fbaa585215029f7a2e74cc | [
{
"content": "On te donne une liste d'entiers `nums`. Implémente une fonction `remove_duplicates(nums)` qui renvoie une nouvelle liste avec tous les éléments dupliqués supprimés, en préservant l'ordre de leur première apparition dans la liste originale.\n\n**Contraintes :**\n- La longueur de `nums` sera compris... | ["\nassert remove_duplicates([1, 2, 3, 2, 1, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([10, 20, 30, 40, 50]) == [10, 20, 30, 40, 50]\n", "\nassert remove_duplicates([5, 4, 3, 2, 1, 1, 2, 3, 4, 5]) == [5, 4,... |
ced943556b1d3110d42213c57363d3f2 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ta tâche est de trouver deux éléments distincts dans la liste qui s'additionnent pour donner `target`. Si une telle paire existe, retourne la paire sous forme de tuple. Si aucune paire ne satisfait cette condition, retourne `None`.\n... | ["\nassert find_two_sum([2, 7, 11, 15], 9) == (2, 7)\n", "\nassert find_two_sum([3, 2, 4], 6) == (2, 4)\n", "\nassert find_two_sum([3, 3], 6) == (3, 3)\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 10) == (5, 5)\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 8) == (3, 5)\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 11) == No... |
adf92e85f5e41c89ce836f9ae9cf90db | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie la valeur maximale dans la liste. Si la liste est vide, la fonction doit renvoyer `None`. Ta solution doit être efficace et facile à comprendre.\n\n**Exemple d'entrée :**\n```\n[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]\n``... | ["\nassert find_maximum_value([1, 2, 3, 4, 5]) == 5\n", "\nassert find_maximum_value([-1, -2, -3, -4, -5]) == -1\n", "\nassert find_maximum_value([10]) == 10\n", "\nassert find_maximum_value([]) == None\n", "\nassert find_maximum_value([5, 5, 5, 5]) == 5\n", "\nassert find_maximum_value([0, -1, -2, -3]) == 0\n", "\nass... |
f6b7632205c0a0a9fe6cecf007199ced | [
{
"content": "On te donne une liste de chaînes de caractères `strings` et un entier `k`. Ta tâche est de mettre en œuvre une fonction qui renvoie une liste des `k` sous-chaînes de longueur 2 les plus fréquemment rencontrées dans la liste de chaînes. En cas d'égalité de fréquence, les sous-chaînes doivent être r... | ["\nassert k_frequent_substrings([\"abcabc\", \"deffed\", \"gheghe\"], 2) == ['ab', 'de']\n", "\nassert k_frequent_substrings([\"aa\", \"bb\", \"cc\", \"aa\"], 1) == ['aa']\n", "\nassert k_frequent_substrings([\"ab\", \"bc\", \"cd\", \"de\", \"ef\"], 3) == ['ab', 'bc', 'cd']\n", "\nassert k_frequent_substrings([\"aabb\... |
60e5a2c3a4b3fd2bd31097769c2017b0 | [
{
"content": "On te demande d'implémenter une fonction `mph_to_ms` qui convertit une vitesse de miles par heure (mph) en mètres par seconde (m/s). La fonction doit gérer les entrées numériques uniques, les listes et les tableaux numpy. La sortie doit être précise à au moins cinq décimales.\n\n**Entrée :**\n- Un... | ["\nassert mph_to_ms(60) == 26.8224\n", "\nassert mph_to_ms(0) == 0.0\n", "\nassert mph_to_ms(1) == 0.44704\n", "\nassert mph_to_ms([30, 45, 60]) == np.array([13.4112, 20.1312, 26.8224])\n", "\nassert mph_to_ms(np.array([15, 30, 45])) == np.array([6.7056, 13.4112, 20.1312])\n", "\nassert mph_to_ms([0, 1, 60]) == np.arr... |
71c405f7ca40c4645d987db34bd26ea2 | [
{
"content": "Implémente une classe `Stack` en Python qui supporte les opérations suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et retourne l'élément au sommet de la pile. Si la pile est vide, retourne `None`.\n- `peek()` : Retourne l'élément au sommet de la pile sa... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().peek() == None\n", "\nassert Stack().pop() == None\n", "\ns = Stack(); s.push(5); assert s.peek() == 5\n", "\ns = Stack(); s.push(5); assert s.pop() == 5\n", "\ns = Stack(); s.push(5); s.push(10); assert s.pop() == 10\n", "\ns = Stack(); s.push(5); s.push(10);... |
4b97e4af55b05d14e23f1057c510b45c | [
{
"content": "Tu mènes une expérience scientifique et as recueilli un ensemble de quatre mesures, chacune représentant une quantité physique distincte. En raison de différentes unités et échelles, ces mesures ne sont pas directement comparables. Ta tâche est de normaliser ces mesures à une échelle commune.\n\nÉ... | ["\nassert normalize_measurements([1.0, 1.0, 1.0, 1.0]) == [1.0 / normalization_factor(0), 1.0 / normalization_factor(1), 1.0 / normalization_factor(2), 1.0 / normalization_factor(3)]\n", "\nassert normalize_measurements([0.0, 0.0, 0.0, 0.0]) == [0.0, 0.0, 0.0, 0.0]\n", "\nassert normalize_measurements([2.0, 4.0, 6.0, ... |
ca3b53b1b6ebd81aedf86b6735e8137d | [
{
"content": "On te donne un fichier CSV avec des en-têtes. Ta tâche est d'écrire une fonction Python qui lit ce fichier et calcule la moyenne d'une colonne spécifiée. La fonction doit gérer les valeurs non numériques en ignorant les lignes correspondantes. Si la colonne spécifiée ne contient aucune valeur numé... | ["\nassert calculate_average_from_csv('data.csv', 'score') == 81.66666666666667\n", "\nassert calculate_average_from_csv('data.csv', 'age') == 25.666666666666668\n", "\nassert calculate_average_from_csv('empty.csv', 'score') == None\n", "\nassert calculate_average_from_csv('single_row.csv', 'score') == 95.0\n", "\nasse... |
0329b6f6a4a7af5e3681fb6bf9d26289 | [
{
"content": "Tu gères l'inventaire d'un magasin en utilisant deux dictionnaires, `dict1` et `dict2`. Chaque dictionnaire associe un symbole de produit (une chaîne de caractères) à sa quantité (un entier). Ta tâche est de calculer l'inventaire mis à jour en fonction des règles suivantes :\n\n- Si un symbole de ... | ["\nassert inventory_update({'apple': 3, 'banana': 5, 'orange': 2}, {'banana': 3, 'orange': 2, 'grape': 4}) == {'apple': 3, 'banana': -2, 'grape': 4}\n", "\nassert inventory_update({'apple': 10, 'banana': 20}, {'banana': 20, 'apple': 10}) == {}\n", "\nassert inventory_update({}, {'banana': 20, 'apple': 10}) == {'banana... |
fa4dd46beb6e11a1a8506d914efc331b | [
{
"content": "On te donne deux structures de données, `structure1` et `structure2`, qui peuvent être soit un dictionnaire, soit un tuple, soit un nombre (entier ou flottant). Ta tâche est d'implémenter une fonction `merge_structures` qui renvoie un tuple `(merged_structure1, merged_structure2)` selon les règles... | ["\nassert merge_structures(5, 3.2) == (3.2, 3.2)\n", "\nassert merge_structures(3.2, 5) == (3.2, 5)\n", "\nassert merge_structures(10, (1, 2, 3)) == ((10, 10, 10), (1, 2, 3))\n", "\nassert merge_structures((1, 2, 3), 10) == ((1, 2, 3), (10, 10, 10))\n", "\nassert merge_structures({'a': 1, 'b': 2}, 10) == ({'a': 1, 'b'... |
35c3ceec358277946d51d36304d746d7 | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de construire un nouveau tableau `result` tel que `result[i]` soit le produit de tous les éléments de `nums` sauf `nums[i]`. Tu dois résoudre ce problème sans utiliser la division et en une complexité temporelle de O(n).\n\n**Entrée :**\n- La p... | ["\nassert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]\n", "\nassert product_except_self([5, 1, 4, 2]) == [8, 40, 10, 20]\n", "\nassert product_except_self([0, 1, 2, 3]) == [6, 0, 0, 0]\n", "\nassert product_except_self([1, 0, 3, 4]) == [0, 12, 0, 0]\n", "\nassert product_except_self([1, 2, 0, 4]) == [0, 0, 8, ... |
2d7be90f72b66b8c30b99d67c23f47e9 | [
{
"content": "On te donne une chaîne de caractères `text` composée de lettres minuscules et d'espaces. Ton objectif est d'implémenter une fonction qui renvoie un dictionnaire où chaque clé est un mot unique de la chaîne, et la valeur correspondante est le nombre de fois que ce mot apparaît dans la chaîne.\n\n**... | ["\nassert word_count(\"this is a test this is only a test\") == {'this': 2, 'is': 2, 'a': 2, 'test': 2, 'only': 1}\n", "\nassert word_count(\"hello world hello\") == {'hello': 2, 'world': 1}\n", "\nassert word_count(\"one two three four five\") == {'one': 1, 'two': 1, 'three': 1, 'four': 1, 'five': 1}\n", "\nassert wo... |
c0d7a3da5655bea838be4c8c9a37fea9 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de calculer la somme des `n` premiers nombres de la suite de Lucas. La suite de Lucas est définie de manière similaire à la suite de Fibonacci, mais elle commence par 2 et 1. Plus précisément, la séquence commence par 2, 1, 3, 4, 7, 11, et ainsi de s... | ["\nassert fibonacci_sum(0) == 0\n", "\nassert fibonacci_sum(1) == 2\n", "\nassert fibonacci_sum(2) == 3\n", "\nassert fibonacci_sum(3) == 6\n", "\nassert fibonacci_sum(4) == 11\n", "\nassert fibonacci_sum(5) == 18\n", "\nassert fibonacci_sum(6) == 29\n", "\nassert fibonacci_sum(7) == 47\n", "\nassert fibonacci_sum(8) ... |
6330ccd8eae2a6fc4710204e8a641fa6 | [
{
"content": "On te demande d'implémenter une fonction `validate_id` qui détermine la validité d'une chaîne d'ID en fonction de critères spécifiques. Un ID est considéré comme valide s'il satisfait toutes les conditions suivantes :\n\n1. L'ID ne doit contenir que des lettres minuscules (a-z), des lettres majusc... | ["\nassert validate_id(\"aB1\") == True\n", "\nassert validate_id(\"aB-1\") == True\n", "\nassert validate_id(\"aB--1\") == False\n", "\nassert validate_id(\"-aB1\") == False\n", "\nassert validate_id(\"aB1-\") == False\n", "\nassert validate_id(\"aB\") == False\n", "\nassert validate_id(\"123\") == False\n", "\nassert... |
bd010ee0ecd37ddd08068334e6adf316 | [
{
"content": "On te demande d'implémenter une fonction `create_link_monitoring_config` qui construit un objet de configuration pour la fonctionnalité de \"Surveillance de Lien\" d'un dispositif réseau. Cette fonctionnalité est conçue pour détecter les pannes de lien entre les dispositifs. L'objet de configurati... | ["\nassert create_link_monitoring_config({'min_poll_interval': 5, 'min_response_interval': 10, 'multiplier': 3, 'jitter_window': 200}) == LinkMonitoringConfig(min_poll_interval=5, min_response_interval=10, initialization_mode=None, multiplier=3, jitter_window=200)\n", "\nassert create_link_monitoring_config({'initializ... |
a813d834e99fda1d66f82cf70e144773 | [
{
"content": "On te donne deux tableaux numpy 2D, `predictions` et `ground_truth`. Le tableau `predictions` contient les probabilités prédites pour chaque classe dans un problème de classification multi-classe, tandis que le tableau `ground_truth` contient les étiquettes de classe réelles pour chaque point de d... | ["\nassert exact_matching_accuracy(np.array([[0.9, 0.1, 0.0], [0.0, 0.9, 0.1]]), np.array([[1, 0, 0], [0, 1, 0]]), 0.5) == 1.0\n", "\nassert exact_matching_accuracy(np.array([[0.9, 0.1, 0.0], [0.0, 0.9, 0.1]]), np.array([[0, 1, 0], [1, 0, 0]]), 0.5) == 0.0\n", "\nassert exact_matching_accuracy(np.array([[0.5, 0.5, 0.0]... |
a63af91e1e258445f675696bafc3f61e | [
{
"content": "On te donne une liste d'ensembles, où chaque ensemble représente une combinaison unique d'éléments. De plus, on te fournit un ensemble central d'éléments qui sont communs à toutes les combinaisons. Ta tâche est de trouver et de renvoyer un ensemble d'ensembles d'éléments optionnels possibles qui p... | ["\nassert find_optional_sets([{'a', 'b', 'c'}, {'a', 'b', 'd'}], {'a', 'b'}) == {('c',), ('d',)}\n", "\nassert find_optional_sets([{'x', 'y', 'z'}, {'x', 'y', 'w'}, {'x', 'y', 'v'}], {'x', 'y'}) == {('z',), ('w',), ('v',)}\n", "\nassert find_optional_sets([{'apple', 'banana', 'cherry'}, {'apple', 'banana', 'date'}], {... |
717be82cafc461257fdbfd4866b8d423 | [
{
"content": "On te donne deux solutions dans un problème d'optimisation multi-objectif, chacune représentée comme une liste d'entiers indiquant les valeurs des différents objectifs. De plus, on te fournit une liste qui définit un ordre personnalisé de ces objectifs. Une solution est dite dominer une autre si e... | ["\nassert dominance_relation([1, 2, 3], [2, 2, 3], [0, 1, 2]) == 0\n", "\nassert dominance_relation([2, 2, 3], [1, 2, 3], [0, 1, 2]) == 2\n", "\nassert dominance_relation([1, 2, 3], [1, 2, 3], [0, 1, 2]) == 0\n", "\nassert dominance_relation([3, 2, 1], [4, 1, 2], [2, 0, 1]) == 0\n", "\nassert dominance_relation([3, 2,... |
649b7c33471c1cf96f55f5dc705284c7 | [
{
"content": "On te donne une date de naissance au format d'un tuple `(année, mois, jour)` et un entier représentant l'âge de la personne en années. Ta tâche est de déterminer la date du prochain anniversaire de la personne. Si l'anniversaire tombe un week-end, renvoie la date du lundi suivant. La fonction doit... | ["\nassert calculate_birthday((1990, 2, 28), 30) == \"Monday, February 28, 2020\"\n", "\nassert calculate_birthday((2000, 2, 29), 20) == \"Tuesday, March 01, 2020\"\n", "\nassert calculate_birthday((1985, 12, 31), 35) == \"Monday, December 31, 2020\"\n", "\nassert calculate_birthday((1985, 12, 31), 36) == \"Monday, Dec... |
a26329600cff67dbc45ff86060c25ecb | [
{
"content": "Dans une suite de tests pytest, tu as pour tâche d'implémenter une fonction `get_test_duration` qui calcule la durée d'un test, en tenant compte du fait que les tests peuvent être exécutés dans des threads parallèles. Ta fonction doit renvoyer la durée du test spécifié par son `nodeid` de la derni... | ["\nassert get_test_duration(\"test_module.py::test_func\") == None\n", "\nassert get_test_duration(\"non_existent_test.py::test_func\") == None\n", "\nassert get_test_duration(\"test_module.py::test_func\") == None\n", "\nassert get_test_duration(\"test_module.py::test_func\") == None\n", "\nassert get_test_duration(\... |
c5a56b5c132bee31bb21f9827e0b4f7b | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_duplicates` qui identifie et renvoie une liste de tous les éléments dupliqués présents dans la liste d'entrée. La fonction doit être optimisée pour minimiser le nombre d'opérations effectuées sur la liste.\n\n**Entrée :... | ["\nassert find_duplicates([1, 2, 3, 4, 5]) == []\n", "\nassert find_duplicates([1, 1, 2, 2, 3, 3]) == [1, 2, 3]\n", "\nassert find_duplicates([10, 20, 30, 40, 50, 10, 20]) == [10, 20]\n", "\nassert find_duplicates([5, 5, 5, 5, 5]) == [5]\n", "\nassert find_duplicates([]) == []\n", "\nassert find_duplicates([1, 2, 3, 4... |
43f687b5e464553e0c0a8daa11c7d23c | [
{
"content": "On te donne une liste de séquences d'ADN, chacune représentée comme une chaîne de caractères provenant de l'ensemble {'A', 'T', 'C', 'G'}. Chaque séquence d'ADN est associée à une classification taxonomique, qui est représentée comme une chaîne de rangs taxonomiques séparés par des points-virgules... | ["\nassert sequences_in_taxonomic_group([], \"Bacteria;Proteobacteria;Gammaproteobacteria\") == []\n", "\nassert sequences_in_taxonomic_group([(\"ATGCTGGTTG\", \"Bacteria;Proteobacteria;Gammaproteobacteria\")], \"Bacteria;Proteobacteria;Gammaproteobacteria\") == [\"ATGCTGGTTG\"]\n", "\nassert sequences_in_taxonomic_gro... |
d2e0c7045cba8867f48261697d342847 | [
{
"content": "On te donne une liste de chaînes de caractères `words`. Ta tâche est de mettre en œuvre une fonction `sort_and_group` qui organise ces mots dans un dictionnaire. Les clés du dictionnaire doivent être la première lettre de chaque mot, et les valeurs doivent être des listes de mots qui commencent pa... | ["\nassert sort_and_group([\"apple\", \"apricot\", \"banana\", \"blueberry\", \"cherry\"]) == {'a': ['apple', 'apricot'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}\n", "\nassert sort_and_group([\"dog\", \"cat\", \"camel\", \"antelope\", \"ant\"]) == {'d': ['dog'], 'c': ['camel', 'cat'], 'a': ['ant', 'antelope']}\n... |
41ec59662c9085262bbb49d718fd156e | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses e-mail selon des règles spécifiques. Ta fonction doit renvoyer `True` si l'adresse e-mail est valide, et `False` sinon. Une adresse e-mail est considérée comme valide si elle répond aux critères suivants :\n\n- La partie locale (av... | ["\nassert validate_email(\"test.email@example.com\") == True\n", "\nassert validate_email(\"te@ex.com\") == True\n", "\nassert validate_email(\"te@e.c\") == False\n", "\nassert validate_email(\"te@ex\") == False\n", "\nassert validate_email(\"t@ex.com\") == False\n", "\nassert validate_email(\"test@exa_mple.com\") == ... |
7dd954458f26f53a1a41473dca5f7a9a | [
{
"content": "On te donne une chaîne de caractères représentant un numéro de téléphone qui peut contenir des espaces, des tirets ou des parenthèses. Ta tâche est de mettre en œuvre une fonction `format_phone_number` qui traite cette chaîne et renvoie le numéro de téléphone au format `(XXX) XXX-XXXX`. Si la chaî... | ["\nassert format_phone_number(\"1234567890\") == \"(123) 456-7890\"\n", "\nassert format_phone_number(\"123-456-7890\") == \"(123) 456-7890\"\n", "\nassert format_phone_number(\"(123) 456-7890\") == \"(123) 456-7890\"\n", "\nassert format_phone_number(\"123 456 7890\") == \"(123) 456-7890\"\n", "\nassert format_phone_... |
693369e62afea5b59e312edf4ae3df37 | [
{
"content": "On te donne un nombre à virgule flottante `x` et un entier `b`. Ta tâche est de mettre en œuvre une fonction qui arrondit `x` à la valeur entière inférieure la plus proche d'un multiple de `b` et renvoie cette valeur arrondie ainsi que le nombre de chiffres après la virgule dans la différence entr... | ["\nassert round_down_and_count_decimal_digits(12.34, 5) == (10, 2)\n", "\nassert round_down_and_count_decimal_digits(-12.34, 5) == (-15, 2)\n", "\nassert round_down_and_count_decimal_digits(0.0, 1) == (0, 1)\n", "\nassert round_down_and_count_decimal_digits(10.0, 10) == (10, 1)\n", "\nassert round_down_and_count_decim... |
7385f9bc6cd7aa23ea7e3f2a11bb28ba | [
{
"content": "On te donne une fonction `double(x)` qui est censée renvoyer le double de l'entier en entrée `x`. Cependant, la fonction doit être modifiée pour gérer les cas où l'entrée n'est pas un entier. Dans de tels cas, la fonction doit renvoyer la chaîne de caractères \"Error: Input must be an integer.\".\... | ["\nassert double(5) == 10\n", "\nassert double(-3) == -6\n", "\nassert double(0) == 0\n", "\nassert double(123456789) == 246913578\n", "\nassert double(\"string\") == \"Error: Input must be an integer.\"\n", "\nassert double(3.14) == \"Error: Input must be an integer.\"\n", "\nassert double(None) == \"Error: Input mus... |
b41c87a63df178f5778f98518df0483b | [
{
"content": "On te donne une chaîne de caractères `sentence`. Ta tâche est de déterminer si c'est un pangramme. Un pangramme est défini comme une phrase qui inclut chaque lettre de l'alphabet anglais au moins une fois. La chaîne d'entrée peut contenir des lettres majuscules et minuscules, ainsi que des caractè... | ["\nassert is_pangram(\"the quick brown fox jumps over the lazy dog\") == True\n", "\nassert is_pangram(\"a quick movement of the enemy will jeopardize five gunboats\") == False\n", "\nassert is_pangram(\"abcdefghijklmnopqrstuvwxyz\") == True\n", "\nassert is_pangram(\"the five boxing wizards jump quickly\") == True\n"... |
6b57b673ea551e2e00daa6fc22217489 | [
{
"content": "Tu es chargé d'implémenter une classe `Library` en Python qui gère une collection de livres. La classe doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un Livre** : Ajouter un livre à la bibliothèque. Si le livre existe déjà, lever une exception `ValueError` avec le message \"Le l... | ["\nassert Library().get_books() == []\n", "\nassert Library().is_book_available(\"1984\") == False\n", "\nlib = Library()\nlib.add_book(\"1984\")\nassert lib.get_books() == [\"1984\"]\n", "\nlib = Library()\nlib.add_book(\"1984\")\nlib.add_book(\"Brave New World\")\nassert lib.get_books() == [\"1984\", \"Brave New Wor... |
1c64f251f50cb1ca53cfb199302caaa9 | [
{
"content": "On te donne une séquence d'entiers représentant différents types de jetons dans une phrase. La séquence est complétée avec un jeton spécifique (représenté par un entier unique) pour s'assurer que toutes les séquences ont la même longueur. Ta tâche est de créer une fonction `generate_mask(sequence,... | ["\nassert generate_mask([1, 2, 3, 4, 5, 0, 0], 0) == ([1, 1, 1, 1, 1, 0, 0], [1, 2, 3, 4, 5, 0, 0])\n", "\nassert generate_mask([0, 0, 0, 0], 0) == ([0, 0, 0, 0], [0, 0, 0, 0])\n", "\nassert generate_mask([1, 2, 3], 0) == ([1, 1, 1], [1, 2, 3])\n", "\nassert generate_mask([1, 0, 2, 0, 3], 0) == ([1, 0, 1, 0, 1], [1, 0... |
0789c38d2845aa2cfa3a9a117394587c | [
{
"content": "On te donne un nombre fractionnaire en base 3 (ternaire) sous forme de chaîne de caractères. Ta tâche est de convertir ce nombre en son équivalent décimal (base 10) sans utiliser d'opérations ou de types de données à virgule flottante. Le résultat doit être renvoyé sous forme de fraction dans un t... | ["\nassert calculate_decimal_from_ternary(\"0\") == (0, 1)\n", "\nassert calculate_decimal_from_ternary(\"1\") == (1, 1)\n", "\nassert calculate_decimal_from_ternary(\"10\") == (3, 1)\n", "\nassert calculate_decimal_from_ternary(\"10.1\") == (10, 3)\n", "\nassert calculate_decimal_from_ternary(\"0.1\") == (1, 3)\n", "\... |
7142acb98b6e517645aaceffa4a5611e | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui renvoie une nouvelle chaîne où chaque mot dans `s` est inversé, mais l'ordre des mots reste le même. Si `s` est une chaîne vide, la fonction doit renvoyer une chaîne vide.\n\n**Entrée :**\n- Une seule chaîne de caract... | ["\nassert reverse_words_in_string(\"Hello world\") == \"olleH dlrow\"\n", "\nassert reverse_words_in_string(\"Python is fun\") == \"nohtyP si nuf\"\n", "\nassert reverse_words_in_string(\"a\") == \"a\"\n", "\nassert reverse_words_in_string(\"\") == \"\"\n", "\nassert reverse_words_in_string(\"123 456\") == \"321 654\"... |
31645887fc6b8647ef9ea6e2f46e3294 | [
{
"content": "On te donne deux fichiers binaires, chacun contenant une liste de propriétés pour un objet \"Robot\" hypothétique. Les propriétés de chaque Robot sont les suivantes :\n\n- `robot_type` : une chaîne de caractères représentant le type de robot.\n- `endianness` : une valeur booléenne indiquant si le ... | ["\nassert CompatibleRobots({\"robot_type\": \"A\", \"endianness\": True, \"bit_size\": 32, \"operating_system\": \"LINUX\"}, {\"robot_type\": \"A\", \"endianness\": True, \"bit_size\": 32, \"operating_system\": \"LINUX\"}) == True\n", "\nassert CompatibleRobots({\"robot_type\": \"A\", \"endianness\": True, \"bit_size\... |
e5f15c0eaf5d8aa9223478e0b1bb3e65 | [
{
"content": "On te demande d'implémenter une fonction `generate_fibonacci(n)` qui génère les `n` premiers nombres de Fibonacci en utilisant un générateur. La fonction doit produire chaque nombre de Fibonacci un par un. La suite de Fibonacci commence par 0 et 1, et chaque nombre suivant est la somme des deux no... | ["\nassert list(generate_fibonacci(0)) == []\n", "\nassert list(generate_fibonacci(1)) == [0]\n", "\nassert list(generate_fibonacci(2)) == [0, 1]\n", "\nassert list(generate_fibonacci(5)) == [0, 1, 1, 2, 3]\n", "\nassert list(generate_fibonacci(10)) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert list(generate_fibon... |
39ebb254cc50191d7b9c3c0cca839f84 | [
{
"content": "On te donne un entier `number`. Ta tâche est d'implémenter une fonction `sum_of_digits(number)` qui calcule la somme de ses chiffres. La fonction doit gérer à la fois les entiers positifs et négatifs.\n\n**Entrée :**\n- Un seul entier `number` (-10^9 ≤ number ≤ 10^9).\n\n**Sortie :**\n- Un entier ... | ["\nassert sum_of_digits(12345) == 15\n", "\nassert sum_of_digits(987654321) == 45\n", "\nassert sum_of_digits(0) == 0\n", "\nassert sum_of_digits(-12345) == 15\n", "\nassert sum_of_digits(1000000001) == 2\n", "\nassert sum_of_digits(999999999) == 81\n", "\nassert sum_of_digits(111111111) == 9\n", "\nassert sum_of_digi... |
d5fe128c4bf170169b00bd29a00e46bc | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'écrire une fonction Python qui traite cette liste et renvoie une nouvelle liste où chaque chaîne a sa première lettre en majuscule et le reste des caractères en minuscules. Si une chaîne est vide, elle doit rester inchangée. La liste o... | ["\nassert capitalize_strings([\"hello\", \"WORLD\", \"python\", \"pROGRAMMING\"]) == ['Hello', 'World', 'Python', 'Programming']\n", "\nassert capitalize_strings([\"\"]) == ['']\n", "\nassert capitalize_strings([\"a\", \"B\", \"c\", \"D\"]) == ['A', 'B', 'C', 'D']\n", "\nassert capitalize_strings([\"123\", \"!@#\", \"... |
d6d2d12d60118bfe875ca8e328af5019 | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Ta tâche est de trouver la plus longue sous-séquence commune (LCS) entre ces deux chaînes. La LCS est la plus longue séquence qui apparaît dans les deux chaînes dans le même ordre, mais pas nécessairement consécutivement. S'il existe plusie... | ["\nassert longest_common_subsequence(\"ABCBDAB\", \"BDCAB\") == \"BCAB\"\n", "\nassert longest_common_subsequence(\"AGGTAB\", \"GXTXAYB\") == \"GTAB\"\n", "\nassert longest_common_subsequence(\"ABC\", \"AC\") == \"AC\"\n", "\nassert longest_common_subsequence(\"XYZ\", \"XYZ\") == \"XYZ\"\n", "\nassert longest_common_s... |
78d1f1d5f6b5f414e9d4a656765f0563 | [
{
"content": "On te donne un objet consommateur Kafka qui est abonné à un seul sujet. Ta tâche est de mettre en œuvre une fonction `get_unconsumed_messages_count` qui calcule le nombre de messages dans le sujet Kafka qui n'ont pas été marqués comme consommés. La fonction doit renvoyer un dictionnaire avec deux ... | ["\nassert get_unconsumed_messages_count(KafkaConsumer('test_topic', bootstrap_servers=['localhost:9092']))[\"status\"] == True\n", "\nassert get_unconsumed_messages_count(KafkaConsumer('non_existent_topic', bootstrap_servers=['localhost:9092']))[\"status\"] == False\n", "\nassert get_unconsumed_messages_count(KafkaCon... |
c8cdaf314a58bcaa57aaa57cdd81df8c | [
{
"content": "On te demande d'implémenter une fonction `leftrotate_numba(x, c)` qui effectue une rotation à gauche d'un entier `x` de `c` bits. La fonction doit gérer les entiers négatifs et gérer efficacement les rotations pour différentes tailles d'octets. La fonction doit renvoyer le résultat de la rotation.... | ["\nassert leftrotate_numba(0b1001, 1) == 0b0011\n", "\nassert leftrotate_numba(0b1001, 2) == 0b0110\n", "\nassert leftrotate_numba(0b1001, 3) == 0b1100\n", "\nassert leftrotate_numba(0b1001, 4) == 0b1001\n", "\nassert leftrotate_numba(0b1001, 5) == 0b0011\n", "\nassert leftrotate_numba(-1, 1) == -1\n", "\nassert leftr... |
e40642411be4d740e4d98332d8d6cbb5 | [
{
"content": "Tu participes à une compétition d'analyse de données où tu dois évaluer la précision d'un modèle prédictif. Étant donné deux listes de nombres, `actual_values` et `predicted_values`, ta tâche est de calculer le coefficient de détermination (score R^2) sans utiliser de fonctions ou de bibliothèques... | ["\nassert coefficient_of_determination([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]) == 1.0\n", "\nassert coefficient_of_determination([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]) == 0.0\n", "\nassert coefficient_of_determination([1, 1, 1, 1, 1], [1, 1, 1, 1, 1]) == 1.0\n", "\nassert coefficient_of_determination([1, 2, 3], [1, 2, 3]) == 1.0... |
436598c68d9b5f609055e890a8abb615 | [
{
"content": "On te donne deux chaînes de caractères `a` et `b`, et un entier `n`. Ta tâche est de trouver toutes les sous-chaînes uniques de longueur `n` qui apparaissent dans les deux chaînes, sans tenir compte de la casse. Les sous-chaînes doivent être renvoyées par ordre lexicographique.\n\n**Entrée :**\n- ... | ["\nassert common_substrings(\"abcabc\", \"bcd\", 2) == [\"bc\"]\n", "\nassert common_substrings(\"abcabc\", \"bcd\", 3) == []\n", "\nassert common_substrings(\"abcabc\", \"abcd\", 2) == [\"ab\", \"bc\"]\n", "\nassert common_substrings(\"HelloWorld\", \"worldhello\", 5) == [\"hello\", \"world\"]\n", "\nassert common_su... |
48c19f36f0db9a90b2e6b4e05699124a | [
{
"content": "On te demande de développer une application web simple en utilisant le framework Flask. L'application doit interagir avec une base de données SQLite pour récupérer et afficher une liste d'éléments. La base de données contient une table nommée `items` avec le schéma suivant :\n\n- `id` : Un entier ... | ["\nassert get_items().json == []\n", "\nassert get_items().json == [{'id': 1, 'name': 'Item1', 'description': 'Description1'}]\n", "\nassert get_items().json == [{'id': 1, 'name': 'Item1', 'description': 'Description1'}, {'id': 2, 'name': 'Item2', 'description': 'Description2'}]\n", "\nassert get_items().json == [{'id... |
a168dfd07b705667c7ca86df62c759d5 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est de créer une fonction qui traite cette liste de telle sorte que chaque nombre pair soit mis au carré et chaque nombre impair soit multiplié par 3. La fonction doit renvoyer une nouvelle liste avec ces nombres transformés. Ta solution doit être effi... | ["\nassert transform_numbers([1, 2, 3, 4, 5]) == [3, 4, 9, 16, 15]\n", "\nassert transform_numbers([10, 15, 20, 25]) == [100, 45, 400, 75]\n", "\nassert transform_numbers([0, -1, -2, -3]) == [0, -3, 4, -9]\n", "\nassert transform_numbers([]) == []\n", "\nassert transform_numbers([7, 11, 13]) == [21, 33, 39]\n", "\nasse... |
ec001f90f5e5b9d493da05772f5d649b | [
{
"content": "Conçois et implémente une application web Flask en Python. L'application doit inclure deux routes :\n1. `/hello` - Lorsqu'elle est accessible, cette route doit renvoyer la chaîne de caractères `\"Hello, World!\"`.\n2. `/user/<username>` - Cette route doit accepter un paramètre `username` et renvoy... | ["\nassert app.name == \"__main__\"\n", "\nassert app.url_map.bind('').match('/hello')[0] == 'hello'\n", "\nassert app.url_map.bind('').match('/user/john')[0] == 'user'\n", "\nassert app.url_map.bind('').match('/user/john')[1]['username'] == 'john'\n", "\nassert hello() == \"Hello, World!\"\n", "\nassert user('alice') ... |
767bca3451328034cf7ec329eb608ace | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tableau numpy 2D avec des valeurs de pixels normalisées dans la plage [0, 1]. Ta tâche est d'écrire une fonction `denormalize_image(normalized_image)` qui dénormalise l'image pour revenir à sa plage de pixels originale de [0, 255]. Ton ... | ["\nassert np.array_equal(denormalize_image(np.array([[0.0, 1.0]])), np.array([[0, 255]], dtype=np.uint8))\n", "\nassert np.array_equal(denormalize_image(np.array([[0.5]])), np.array([[128]], dtype=np.uint8))\n", "\nassert np.array_equal(denormalize_image(np.array([[0.25, 0.75]])), np.array([[64, 191]], dtype=np.uint8)... |
9f8200e057662c3ae9498ac3bc391225 | [
{
"content": "Tu participes à une compétition d'apprentissage automatique où tu dois implémenter un chargeur de modèle polyvalent. Ta tâche est de créer une fonction Python nommée `get_model` qui instancie dynamiquement une classe de modèle en fonction de son nom. La fonction doit accepter les paramètres suivan... | ["\nassert get_model('models.ModelA', [1, 2, 3], {'key': 'value'}, '/path/to/checkpoints', 'cuda').device == 'cuda'\n", "\nassert get_model('models.ModelB', [4, 5, 6], {'key': 'value'}, '/path/to/checkpoints', 'cpu').device == 'cpu'\n", "\nassert get_model('models.ModelA', [1, 2, 3], {'key': 'value'}, '/path/to/checkpo... |
415637df205b671e1863fef769da3848 | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente les coordonnées d'un sommet d'un polygone simple. Les sommets sont fournis dans l'ordre horaire ou antihoraire. Ta tâche est de calculer l'aire du polygone en utilisant la formule des lacets. La fonction doit accepter un seul paramètre, u... | ["\nassert polygon_area([(0, 0), (4, 0), (4, 3), (0, 3)]) == 12.0\n", "\nassert polygon_area([(0, 0), (5, 0), (5, 5), (0, 5)]) == 25.0\n", "\nassert polygon_area([(1, 1), (4, 1), (4, 5)]) == 6.0\n", "\nassert polygon_area([(0, 0), (1, 1), (2, 0)]) == 0.5\n", "\nassert polygon_area([(0, 0), (0, 1), (1, 1), (1, 0)]) == 1... |
5b9499fa76502d83788ff5b62f6ebf6d | [
{
"content": "On te donne une chaîne de caractères `sentence` composée de mots séparés par des espaces et contenant éventuellement des signes de ponctuation. Ta tâche est de mettre en œuvre une fonction `convert_case` qui transforme la chaîne en \"PascalCase\" en supprimant toute ponctuation et en mettant en ma... | ["\nassert convert_case(\"hello world!\") == \"HelloWorld\"\n", "\nassert convert_case(\"this is a test.\") == \"ThisIsATest\"\n", "\nassert convert_case(\"python is fun!\") == \"PythonIsFun\"\n", "\nassert convert_case(\"convert-case to PascalCase\") == \"ConvertCaseToPascalcase\"\n", "\nassert convert_case(\"multiple... |
2395f7ed65ca8d972d0413c920da9781 | [
{
"content": "On te donne une liste de dictionnaires représentant les évaluations des utilisateurs pour des films, ainsi qu'un dictionnaire contenant les sommes des carrés des évaluations pour chaque film. Ta tâche est de mettre en œuvre une fonction qui calcule la similarité cosinus entre deux films spécifiés,... | ["\nassert cosine_similarity(ratings_list_example, squared_sums_example, 1, 2) == 0.9921567416492215\n", "\nassert cosine_similarity(ratings_list_example, squared_sums_example, 2, 3) == 0.9838699100999055\n", "\nassert cosine_similarity(ratings_list_example, squared_sums_example, 1, 3) == 0.9636241116594803\n", "\nasse... |
902c3b02a64b182d2c9aac2a5e32a195 | [
{
"content": "On te demande d'implémenter une calculatrice simple qui prend en charge les opérations arithmétiques de base : l'addition (+), la soustraction (-), la multiplication (*) et la division (/). La calculatrice doit lire trois entrées de l'utilisateur : le premier nombre, l'opérateur et le deuxième nom... | ["\nassert simple_calculator() == \"Error: Invalid input. Please enter numeric values for the numbers.\" if input(\"Enter the first number: \") == \"abc\" else True\n", "\nassert simple_calculator() == \"Error: Invalid input. Please enter numeric values for the numbers.\" if input(\"Enter the second number: \") == \"xy... |
259fbac31a575ab9f683a41e2d3fa6c8 | [
{
"content": "On te demande d'implémenter une fonction `parse_json_file(filename)` qui traite un fichier JSON. Ta fonction doit lire le fichier et renvoyer un dictionnaire avec les données analysées. Si le fichier n'existe pas ou ne peut pas être accédé, ta fonction doit lever une exception `FileNotFoundError` ... | ["\nassert parse_json_file(\"test.json\") == {\"key\": \"value\"}\n", "\nassert parse_json_file(\"empty.json\") == {}\n", "\nassert parse_json_file(\"numbers.json\") == [1, 2, 3, 4, 5]\n", "\nassert parse_json_file(\"nested.json\") == {\"outer\": {\"inner\": \"value\"}}\n", "\nassert parse_json_file(\"complex.json\") =... |
c9be1a0d645027d84e93a9e4b70c3133 | [
{
"content": "On te donne une liste de températures en Fahrenheit. Ton objectif est d'écrire une fonction `convert_fahrenheit_to_celsius` qui prend cette liste en entrée et renvoie une nouvelle liste où chaque température est convertie en Celsius et arrondie à une décimale près. La formule pour convertir Fahren... | ["\nassert convert_fahrenheit_to_celsius([32, 212, 250, 275, 300]) == [0.0, 100.0, 121.1, 135.0, 148.9]\n", "\nassert convert_fahrenheit_to_celsius([-459.67, 0, 100]) == [-273.1, -17.8, 37.8]\n", "\nassert convert_fahrenheit_to_celsius([-500, -459.68, -459.67]) == []\n", "\nassert convert_fahrenheit_to_celsius([212, 32... |
4c5e928cba99e4b4ca3829478afd40aa | [
{
"content": "On te donne une liste de chaînes de caractères. Pour chaque chaîne, trie les mots par ordre alphabétique et renvoie la liste modifiée de chaînes de caractères. Les mots dans chaque chaîne sont séparés par un seul espace.\n\n**Exemple d'entrée :**\n```\n[\"hello world\", \"the quick brown fox\"]\n`... | ["\nassert sort_words_in_strings([\"hello world\"]) == [\"hello world\"]\n", "\nassert sort_words_in_strings([\"the quick brown fox\"]) == [\"brown fox quick the\"]\n", "\nassert sort_words_in_strings([\"a b c\", \"d e f\"]) == [\"a b c\", \"d e f\"]\n", "\nassert sort_words_in_strings([\"zebra apple\", \"dog cat\"]) =... |
e909b7378a799d089d61450a1097d3cd | [
{
"content": "On te donne une liste de mots, où chaque mot est représenté comme une liste de caractères. Ta tâche est d'implémenter une fonction qui renvoie une liste de valeurs binaires indiquant la présence d'espaces entre les caractères de chaque mot. Chaque mot doit être représenté par une liste de 1 et de ... | ["\nassert get_spaces_between_chars([[\"h\", \"e\", \"l\", \"l\", \"o\"]]) == [[1, 1, 1, 1, 0]]\n", "\nassert get_spaces_between_chars([[\"a\"], [\"b\"]]) == [[0], [0]]\n", "\nassert get_spaces_between_chars([[\"c\", \"a\", \"t\"], [\"d\", \"o\", \"g\"]]) == [[1, 1, 0], [1, 1, 0]]\n", "\nassert get_spaces_between_chars... |
b31b0453e39c7dbd632633b6934ca7d7 | [
{
"content": "On te donne un dictionnaire `student_scores` où chaque clé est le nom d'un étudiant et chaque valeur est son score au test respectif, qui peut être positif ou négatif. Ta tâche est de mettre en œuvre une fonction `calculate_percentages` qui calcule le pourcentage du score total que chaque étudiant... | ["\nassert calculate_percentages({'Alice': 85, 'Bob': 90, 'Charlie': 70}) == {'Alice': 0.3469387755102041, 'Bob': 0.3673529411764706, 'Charlie': 0.2857142857142857}\n", "\nassert calculate_percentages({'Alice': 100, 'Bob': 100, 'Charlie': 100}) == {'Alice': 0.3333333333333333, 'Bob': 0.3333333333333333, 'Charlie': 0.33... |
d0a81c71e2f5b333fa83cbbef743f5bd | [
{
"content": "On te donne la tâche d'écrire une fonction `wavelength_to_energy` qui calcule l'énergie d'un photon en fonction de sa longueur d'onde. L'énergie \\( E \\) en électronvolts (eV) peut être déterminée en utilisant la formule suivante :\n\n\\[ E = \\frac{12398.42}{\\lambda} \\]\n\noù \\( \\lambda \\) ... | ["\nassert wavelength_to_energy(12398.42) == 1.0\n", "\nassert wavelength_to_energy(6199.21) == 2.0\n", "\nassert wavelength_to_energy(1.0) == 12398.42\n", "\nassert wavelength_to_energy(0.5) == 24796.84\n", "\nassert wavelength_to_energy(1000000.0) == 0.01239842\n", "\nassert wavelength_to_energy(3.402823466e+38) == 3... |
0bbc67c75986b45302d70be2f15729cd | [
{
"content": "On te demande d'écrire un programme Python qui simule un navigateur web simple. Ton programme doit accepter une URL de l'utilisateur et récupérer le contenu HTML de la page web située à cette URL. Utilise la bibliothèque `requests` pour effectuer la requête HTTP. Si la requête est réussie, affiche... | ["\nassert fetch_html_content(\"http://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: \"\n", "\nassert fetch_html_content(\"f... |
5de675f5fecd730e48d7659177d68bdc | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction génératrice Python nommée `even_numbers` qui ne renvoie que les nombres pairs de la liste d'entrée. La fonction doit utiliser une boucle `for` et le mot-clé `yield`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(n... | ["\nassert list(even_numbers([1, 2, 3, 4, 5, 6])) == [2, 4, 6]\n", "\nassert list(even_numbers([10, 15, 20, 25, 30])) == [10, 20, 30]\n", "\nassert list(even_numbers([11, 13, 17, 19])) == []\n", "\nassert list(even_numbers([])) == []\n", "\nassert list(even_numbers([0, 2, 4, 6, 8])) == [0, 2, 4, 6, 8]\n", "\nassert lis... |
069279680d64b6d7d84306f8fe0fdefd | [
{
"content": "On te donne une série de valeurs de couleur RVB. Pour chaque couleur, convertis les valeurs RVB en leurs codes de couleur hexadécimaux correspondants. La fonction doit gérer efficacement plusieurs entrées.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), le nombre de cou... | ["\nassert from_rgb_to_hex(255, 99, 71) == \"#FF6347\"\n", "\nassert from_rgb_to_hex(0, 0, 0) == \"#000000\"\n", "\nassert from_rgb_to_hex(255, 255, 255) == \"#FFFFFF\"\n", "\nassert from_rgb_to_hex(128, 128, 128) == \"#808080\"\n", "\nassert from_rgb_to_hex(165, 42, 42) == \"#A52A2A\"\n", "\nassert from_rgb_to_hex(255... |
69e5539b0710fc80b207de7cdaa366c2 | [
{
"content": "Dans un jeu, Pac-Man et jusqu'à quatre fantômes sont positionnés sur une grille. La position de chaque personnage est donnée par ses coordonnées x et y. Tu dois écrire une fonction `prepare_input_data` qui traite les données d'entrée pour un modèle d'IA prédisant le prochain mouvement de Pac-Man. ... | ["\nassert prepare_input_data({'pacman': (5, 5)}) == [[5, 5]]\n", "\nassert prepare_input_data({'pacman': (5, 5), 'ghost1': (1, 2)}) == [[5, 5], [1, 2]]\n", "\nassert prepare_input_data({'pacman': (5, 5), 'ghost2': (3, 4)}) == [[5, 5], [3, 4]]\n", "\nassert prepare_input_data({'pacman': (5, 5), 'ghost3': (7, 8)}) == [[... |
77868926e265547883624eacdc5ef096 | [
{
"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 ignorant les espaces, la ponctuation et 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 :**\n- Une seule chaîne de cara... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Not a palindrome\") == False\n", "\nassert... |
f10f652549ad17d207f61c9f249d8527 | [
{
"content": "On te donne un ensemble de données d'avis clients pour un produit dans un fichier CSV nommé `reviews.csv` avec une colonne `review_text`. Ta tâche est de classifier chaque avis comme positif, négatif ou neutre en utilisant un modèle d'apprentissage automatique simple tel que Naive Bayes ou Logisti... | ["\nassert isinstance(load_dataset(), tuple)\n", "\nassert len(load_dataset()) == 2\n", "\nassert isinstance(train_model(load_dataset()[0]), make_pipeline)\n", "\nassert 'sentiment' not in classify_reviews(load_dataset()[1], train_model(load_dataset()[0])).columns\n", "\nassert 'sentiment' in classify_reviews(load_data... |
b5de0fd5bbdc1c1ba085d2317ba347df | [
{
"content": "On te donne un fichier CSV avec une ligne d'en-tête. Ta tâche est d'écrire une fonction Python qui lit ce fichier et calcule le nombre total de valeurs distinctes dans une colonne spécifiée. La colonne d'intérêt est spécifiée par son nom. Le fichier CSV est garanti d'avoir au moins une ligne de do... | ["\nassert count_distinct_values_in_column('data.csv', 'city') == 3\n", "\nassert count_distinct_values_in_column('data.csv', 'name') == 4\n", "\nassert count_distinct_values_in_column('data.csv', 'age') == 4\n", "\nassert count_distinct_values_in_column('data.csv', 'nonexistent_column') == 0\n", "\nassert count_distin... |
fcd187453ac832188b6fed60a8effbff | [
{
"content": "Tu es chargé d'implémenter une fonction `clean_text` qui traite efficacement une grande entrée texte. La fonction doit gérer jusqu'à 10 Mo de texte avec une utilisation minimale de la mémoire et des performances optimales. Le traitement du texte implique les étapes suivantes :\n\n1. Éliminer tous ... | ["\nassert clean_text(\"Hello, World!\") == \"Hello, World!\"\n", "\nassert clean_text(\"Hello,\\nWorld!\") == \"Hello, World!\"\n", "\nassert clean_text(\"Hello,\\rWorld!\") == \"Hello, World!\"\n", "\nassert clean_text(\"Hello,\\\\World!\") == \"Hello,World!\"\n", "\nassert clean_text(\"Hello, World!\") == \"Hello,... |
4efb822bcf9844881a04ac0741ad953c | [
{
"content": "On te donne une liste d'entiers `numbers` représentant les coordonnées y de points sur un plan 2D, où les coordonnées x sont les indices de la liste. Ta tâche est de déterminer le sommet d'une parabole qui passe par chaque ensemble de trois points consécutifs de la liste. La parabole peut s'ouvrir... | ["\nassert find_parabola_vertex([1, 4, 9]) == [(1.0, 0.0)]\n", "\nassert find_parabola_vertex([1, 0, 1]) == [(0.0, -1.0)]\n", "\nassert find_parabola_vertex([0, 1, 4, 9]) == [(1.0, 0.0), (2.0, 0.0)]\n", "\nassert find_parabola_vertex([9, 4, 1, 0]) == [(2.0, 0.0), (3.0, 0.0)]\n", "\nassert find_parabola_vertex([1, 2, 3,... |
5a21038b804b5677da9ade9fe541ca92 | [
{
"content": "On te donne une intersection routière avec quatre routes étiquetées Nord (N), Sud (S), Est (E) et Ouest (W). Chaque route possède un capteur qui détecte le nombre de véhicules à une vitesse de 0 (c'est-à-dire les véhicules à l'arrêt) au pas de temps précédent. Ta tâche est de mettre en œuvre une f... | ["\nassert total_halted_vehicles(MockIntersection([0, 0, 0, 0])) == 0\n", "\nassert total_halted_vehicles(MockIntersection([1, 2, 3, 4])) == 10\n", "\nassert total_halted_vehicles(MockIntersection([100000, 100000, 100000, 100000])) == 400000\n", "\nassert total_halted_vehicles(MockIntersection([100, 200, 300, 400])) ==... |
1346f51c7e93652d75057ae3a3175c96 | [
{
"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(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Hello, World!\") == False\n", "\nassert i... |
b48378ed77caaa698756574e37a8a229 | [
{
"content": "On te demande de développer une fonction pour analyser la progression des étudiants sur une plateforme d'apprentissage en ligne. Étant donné un tableau d'entiers où chaque entier représente le nombre de cours qu'un étudiant a suivis, ta fonction doit calculer et renvoyer la médiane du tableau. La ... | ["\nassert calculate_median([3, 1, 4, 1, 5, 9, 2]) == 3\n", "\nassert calculate_median([1, 2, 3, 4, 5]) == 3\n", "\nassert calculate_median([7, 8, 9]) == 8\n", "\nassert calculate_median([10, 20, 30, 40]) == 25.0\n", "\nassert calculate_median([1]) == 1\n", "\nassert calculate_median([5, 5, 5, 5, 5]) == 5\n", "\nassert... |
89db7f9e424da98ac648bed731274f2a | [
{
"content": "On te donne une liste 2D d'entiers représentant une matrice de dimensions `m x n`. Ta tâche est d'écrire une fonction Python qui transpose la matrice, en convertissant ses lignes en colonnes et ses colonnes en lignes. La fonction doit renvoyer la matrice transposée.\n\n**Entrée :**\n- La première ... | ["\nassert transpose_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [[1, 4, 7], [2, 5, 8], [3, 6, 9]]\n", "\nassert transpose_matrix([[1, 2], [3, 4]]) == [[1, 3], [2, 4]]\n", "\nassert transpose_matrix([[1]]) == [[1]]\n", "\nassert transpose_matrix([[1, 2, 3], [4, 5, 6]]) == [[1, 4], [2, 5], [3, 6]]\n", "\nassert transpo... |
616266ed71d00a72fee32302bc45ac2e | [
{
"content": "On te demande d'implémenter une fonction `generate_random_coordinates` qui génère un nombre spécifié de points de coordonnées 2D aléatoires. Chaque point est représenté comme un tuple de deux nombres à virgule flottante, correspondant aux coordonnées x et y. Les coordonnées doivent être générées a... | ["\nassert len(generate_random_coordinates(0)) == 0\n", "\nassert len(generate_random_coordinates(5)) == 5\n", "\nassert all(-100.0 <= x <= 100.0 and -100.0 <= y <= 100.0 for x, y in generate_random_coordinates(10))\n", "\nassert all(isinstance(x, float) and isinstance(y, float) for x, y in generate_random_coordinates(... |
b97617a60b0ca07e9bd7e04bf749f379 | [
{
"content": "On te donne deux distributions de ressources représentées sous forme de listes d'entiers ou de nombres à virgule flottante, `x` et `y`. Chaque liste peut contenir jusqu'à 10 000 éléments. En utilisant le critère d'équité leximin, détermine si la distribution `x` est plus équitable que la distribut... | ["\nassert is_leximin_fairer([1, 2, 3], [2, 3, 4]) == True\n", "\nassert is_leximin_fairer([2, 3, 4], [1, 2, 3]) == False\n", "\nassert is_leximin_fairer([1, 2, 3], [1, 2, 3]) == False\n", "\nassert is_leximin_fairer([1, 2], [1, 2, 3]) == True\n", "\nassert is_leximin_fairer([1, 2, 3], [1, 2]) == False\n", "\nassert is... |
b1c1fcb06654b911a92b3699c956f6a5 | [
{
"content": "On te demande d'implémenter une classe `Vector2D` en Python qui représente un vecteur 2D avec des composantes x et y. Ta classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation** : Crée un constructeur `__init__(self, x, y)` qui initialise le vecteur avec les composantes x e... | ["\nassert Vector2D(1, 2) + Vector2D(3, 4) == Vector2D(4, 6)\n", "\nassert Vector2D(5, 5) * 2 == Vector2D(10, 10)\n", "\nassert Vector2D(3, 4).magnitude() == 5\n", "\nassert Vector2D(0, 0).magnitude() == 0\n", "\nassert Vector2D(1, 0).normalize() == Vector2D(1, 0)\n", "\nassert Vector2D(0, 1).normalize() == Vector2D(0,... |
be710c6904ddb501d7ea4a3e4d70a633 | [
{
"content": "On te donne une équation de droite sous la forme `Ax + By + C = 0` et un point `(x, y)`. Ton objectif est d'écrire une fonction `find_perpendicular_point(line_equation, point)` qui calcule la coordonnée `x` du point sur la droite donnée qui est le plus proche du point spécifié. La fonction doit êt... | ["\nassert find_perpendicular_point([1, 1, 0], (0, 0)) == 0\n", "\nassert find_perpendicular_point([1, 0, -1], (2, 3)) == 1\n", "\nassert find_perpendicular_point([0, 1, -2], (3, 4)) == 3\n", "\nassert find_perpendicular_point([2, -3, 5], (1, 2)) == 0.6818181818181818\n", "\nassert find_perpendicular_point([3, 4, -12],... |
7094b4b1ec104e0c6be214c785e93351 | [
{
"content": "On te donne une chaîne de caractères représentant deux points dans le système de coordonnées cartésiennes. Chaque point est représenté par une paire de nombres à virgule flottante séparés par un espace (coordonnées x et y). Ta tâche est d'écrire une fonction `calculate_slope` qui calcule la pente ... | ["\nassert calculate_slope(\"1.0 2.0 3.0 4.0\") == \"1.000000\"\n", "\nassert calculate_slope(\"1.0 2.0 1.0 4.0\") == \"undefined\"\n", "\nassert calculate_slope(\"a 2.0 3.0 4.0\") == \"undefined\"\n", "\nassert calculate_slope(\"1.0 2.0 3.0 b\") == \"undefined\"\n", "\nassert calculate_slope(\"1.0 2.0 3.0 4.0 5.0\") =... |
b79555ece4956201b8856f5f46906bd5 | [
{
"content": "On te charge de valider un ensemble de données de localisations géographiques. Chaque localisation est représentée par une ligne dans un DataFrame `df` avec les colonnes suivantes : `id`, `name`, `latitude`, `longitude`, `lat_ok` et `lon_ok`. Les colonnes `lat_ok` et `lon_ok` sont des valeurs bool... | ["\nassert check_location_validity(pd.DataFrame({'id': [1], 'name': ['A'], 'latitude': [40.7128], 'longitude': [-74.0060], 'lat_ok': [True], 'lon_ok': [True]})) == True\n", "\nassert check_location_validity(pd.DataFrame({'id': [1], 'name': ['A'], 'latitude': [40.7128], 'longitude': [-74.0060], 'lat_ok': [False], 'lon_o... |
dddc68c4d863815109c9b86cbd8012f4 | [
{
"content": "On te donne un dictionnaire `input_dict` où chaque clé est associée à une valeur de chaîne de caractères. Ta tâche est de mettre en œuvre une fonction `swap_keys_values` qui construit et renvoie un nouveau dictionnaire. Dans ce nouveau dictionnaire, chaque valeur unique du dictionnaire original de... | ["\nassert swap_keys_values({'name': 'Alice', 'age': '30', 'city': 'New York'}) == {'Alice': 'name', '30': 'age', 'New York': 'city'}\n", "\nassert swap_keys_values({'a': 1, 'b': 2, 'c': 3}) == {1: 'a', 2: 'b', 3: 'c'}\n", "\nassert swap_keys_values({'key1': 'value1', 'key2': 'value2', 'key3': 'value1'}) == {'value1': ... |
4205bbc73193d0d8e53bdc64e634eea3 | [
{
"content": "Tu développes une IA pour un jeu de type Yahtzee. L'IA doit minimiser les risques en évitant la catégorie `CHANCE` sauf si aucune autre option n'est disponible. Elle doit également privilégier les catégories de valeur supérieure lorsque cela est possible. Étant donné un lancer de cinq dés, détermi... | ["\nassert YahtzeeAI().categorize([1, 1, 1, 1, 1]) == (\"YAHTZEE\", 50)\n", "\nassert YahtzeeAI().categorize([2, 2, 2, 2, 3]) == (\"FOUR_OF_A_KIND\", 11)\n", "\nassert YahtzeeAI().categorize([1, 1, 1, 2, 2]) == (\"FULL_HOUSE\", 25)\n", "\nassert YahtzeeAI().categorize([1, 2, 3, 4, 5]) == (\"LARGE_STRAIGHT\", 40)\n", "\... |
e7a38e284807c666d76571ac5a2da1e1 | [
{
"content": "On te demande d'implémenter une fonction `has_robot_interface(obj)` qui détermine si un objet donné `obj` respecte l'interface d'une classe `Robot`. La classe `Robot` est définie par la présence de trois méthodes spécifiques : `get_available_tools()`, `get_available_actions()` et `get_possible_sta... | ["\nassert has_robot_interface(None) == False\n", "\nassert has_robot_interface([]) == False\n", "\nassert has_robot_interface({}) == False\n", "\nassert has_robot_interface(\"string\") == False\n", "\nassert has_robot_interface(123) == False\n", "\nassert has_robot_interface(type('Robot', (object,), {'get_available_to... |
0c47b7248fc6cfa8687a66a5ad9a31b6 | [
{
"content": "On te donne une liste de `recipes`, où chaque recette est représentée comme une liste de tuples. Chaque tuple consiste en un `bag` (une chaîne de caractères) et sa `quantity` correspondante (un entier). Ta tâche est de déterminer si un `bag` spécifié apparaît dans l'une des recettes avec une `quan... | ["\nassert check_bag_in_recipe([[(\"bag1\", 2)], [(\"bag2\", 3)], [(\"bag3\", 4)]], \"bag1\") == True\n", "\nassert check_bag_in_recipe([[(\"bag1\", 4)], [(\"bag2\", 6)], [(\"bag3\", 8)]], \"bag2\") == False\n", "\nassert check_bag_in_recipe([[(\"bag1\", 5)], [(\"bag2\", 7)], [(\"bag3\", 11)]], \"bag3\") == True\n", "\... |
d27e510eb3f7639b6868fe3d8261e530 | [
{
"content": "On te donne un dictionnaire `input_dict` où chaque clé est unique. Ta tâche est de créer une fonction `swap_keys_values` qui renvoie un nouveau dictionnaire avec les clés et les valeurs échangées. S'il y a des valeurs dupliquées dans le dictionnaire original, seule la dernière paire clé-valeur pou... | ["\nassert swap_keys_values({\"a\": 1, \"b\": 2, \"c\": 2, \"d\": 3}) == {1: \"a\", 2: \"c\", 3: \"d\"}\n", "\nassert swap_keys_values({}) == {}\n", "\nassert swap_keys_values({\"x\": 10, \"y\": 20, \"z\": 30}) == {10: \"x\", 20: \"y\", 30: \"z\"}\n", "\nassert swap_keys_values({\"key1\": \"value1\", \"key2\": \"value2... |
2e49be22a15455f75731d3614395b460 | [
{
"content": "On te donne une matrice binaire de $N \\times N$. Ta tâche est de trouver l'aire de la plus grande sous-matrice constituée entièrement de $1$. Une sous-matrice est définie comme un bloc contigu de lignes et de colonnes dans la matrice d'origine. S'il existe plusieurs sous-matrices de même aire max... | ["\nassert maximalSquare([[1, 1], [1, 1]]) == 4\n", "\nassert maximalSquare([[1, 0], [0, 1]]) == 1\n", "\nassert maximalSquare([[0, 0], [0, 0]]) == 0\n", "\nassert maximalSquare([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) == 9\n", "\nassert maximalSquare([[1]]) == 1\n", "\nassert maximalSquare([[0]]) == 0\n", "\nassert maximalS... |
b406b72c37146c205c0b52d254edcdee | [
{
"content": "On te charge de développer un système de recommandation pour un média d'information en utilisant le filtrage collaboratif. Étant donné un dictionnaire représentant les données d'interaction utilisateur-article, implémente une fonction pour recommander les 5 meilleurs articles pour un utilisateur s... | ["\nassert collaborative_filter_recommendation(interaction_data, 'user1') == ['article2', 'article3']\n", "\nassert collaborative_filter_recommendation(interaction_data, 'user2') == ['article3', 'article1']\n", "\nassert collaborative_filter_recommendation(interaction_data, 'user3') == ['article2', 'article1']\n", "\na... |
da0f93425e7c09711d5811079d1dd6cd | [
{
"content": "On te donne une liste d'éléments, chacun avec des dimensions spécifiques, et une grille avec une largeur et une hauteur maximales. Ta tâche est d'emballer tous les éléments dans la grille de manière à ce que la grille conserve un certain rapport d'aspect et soit aussi proche d'un ajustement parfai... | ["\nassert pack_items([(2, 2), (2, 2)], 4, 4) == [[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n", "\nassert pack_items([(1, 1), (1, 1), (1, 1), (1, 1)], 2, 2) == [[1, 1], [1, 1]]\n", "\nassert pack_items([(3, 3), (2, 2)], 5, 5) == [[1, 1, 1, 0, 0], [1, 1, 1, 0, 0], [1, 1, 1, 0, 0], [0, 0, 0, 2, 2], [0, 0, 0... |
28c5b7aa7daa888e24e77a6d118db094 | [
{
"content": "On te demande d'implémenter une classe `InventoryManager` en Python pour gérer un inventaire de produits. La classe doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un Produit** : Ajouter un nouveau produit à l'inventaire avec un nom unique, un prix non négatif et une quantité ent... | ["\nassert InventoryManager().add_product(\"apple\", 1.0, 10) is None\n", "\nassert InventoryManager().add_product(\"banana\", 0.5, 20) is None\n", "\nassert InventoryManager().add_product(\"apple\", 1.0, 10) is None # Duplicate product should not be added\n", "\nassert InventoryManager().remove_product(\"apple\") is ... |
5ec1e811094e716b3b4a4443ed2242e5 | [
{
"content": "On te donne un dictionnaire imbriqué. Ta tâche est d'implémenter une fonction qui effectue une copie profonde de ce dictionnaire. Une copie profonde doit créer un nouveau dictionnaire et copier récursivement toutes les structures imbriquées. Ta fonction doit gérer n'importe quel niveau d'imbricati... | ["\nassert deep_copy_dict({'a': 1, 'b': 2}) == {'a': 1, 'b': 2}\n", "\nassert deep_copy_dict({'a': {'b': {'c': 3}}}) == {'a': {'b': {'c': 3}}}\n", "\nassert deep_copy_dict({}) == {}\n", "\nassert deep_copy_dict({'a': [1, 2, 3]}) == {'a': [1, 2, 3]}\n", "\nassert deep_copy_dict({'a': {'b': [1, 2, {'c': 3}]}}) == {'a': {... |
dac1e733acd229b93eaf44cf5bd77299 | [
{
"content": "On te demande d'optimiser une fonction pour calculer le nième nombre de Fibonacci efficacement. L'approche récursive naïve est trop lente pour les grandes valeurs de n. Implémente une version plus efficace de la fonction Fibonacci.\n\n**Entrée :**\n- Un entier `n` (0 ≤ n ≤ 50)\n\n**Sortie :**\n- L... | ["\nassert fibonacci_memoization(0) == 0\n", "\nassert fibonacci_memoization(1) == 1\n", "\nassert fibonacci_memoization(2) == 1\n", "\nassert fibonacci_memoization(3) == 2\n", "\nassert fibonacci_memoization(4) == 3\n", "\nassert fibonacci_memoization(5) == 5\n", "\nassert fibonacci_memoization(10) == 55\n", "\nassert... |
e8279fd3c7f8bcf27702927bff392c03 | [
{
"content": "Étant donné une chaîne de caractères `s`, ta tâche est de générer toutes les permutations possibles de la chaîne en utilisant un algorithme de retour arrière (backtracking). Les permutations doivent être renvoyées sous forme de liste de chaînes de caractères. Suppose que la chaîne d'entrée contien... | ["\nassert permute_backtracking(\"a\") == [\"a\"]\n", "\nassert permute_backtracking(\"ab\") == [\"ab\", \"ba\"]\n", "\nassert permute_backtracking(\"abc\") == [\"abc\", \"acb\", \"bac\", \"bca\", \"cab\", \"cba\"]\n", "\nassert permute_backtracking(\"abcd\") == [\"abcd\", \"abdc\", \"acbd\", \"acdb\", \"adbc\", \"adcb... |
4839bcf9571899b83d0aa5b3eb0e188f | [
{
"content": "On te donne une structure de liste imbriquée. Ta tâche est d'écrire une fonction qui aplatit cette liste tout en gardant une trace du chemin vers chaque élément. La fonction doit renvoyer une liste de tuples, où chaque tuple est composé d'une liste d'indices représentant le chemin vers l'élément e... | ["\nassert flatten_and_track_path([[1, 2, [3, 4]], [5, 6]]) == [([0, 0], 1), ([0, 1], 2), ([0, 2, 0], 3), ([0, 2, 1], 4), ([1, 0], 5), ([1, 1], 6)]\n", "\nassert flatten_and_track_path([1, [2, [3, [4]]]]) == [([0], 1), ([1, 0], 2), ([1, 1, 0], 3), ([1, 1, 1, 0], 4)]\n", "\nassert flatten_and_track_path([]) == []\n", "\... |
8360cb64a46f8bd049502f3abe8c9d73 | [
{
"content": "On te demande d'implémenter une fonction `pell_sequence_sum(n)` qui calcule la somme des `n` premiers nombres de la suite de Pell. La suite de Pell est définie comme suit : `P(0) = 0`, `P(1) = 1`, et pour `n >= 2`, `P(n) = 2 * P(n-1) + P(n-2)`. Ta fonction doit renvoyer la somme sous forme d'entie... | ["\nassert fibonacci_sum(0) == 0\n", "\nassert fibonacci_sum(1) == 1\n", "\nassert fibonacci_sum(2) == 1\n", "\nassert fibonacci_sum(3) == 2\n", "\nassert fibonacci_sum(4) == 4\n", "\nassert fibonacci_sum(5) == 8\n", "\nassert fibonacci_sum(6) == 16\n", "\nassert fibonacci_sum(7) == 32\n", "\nassert fibonacci_sum(8) ==... |
05b729a77fe809664c89eb1b74f693af | [
{
"content": "On te demande d'écrire un script Python qui interagit avec une API REST pour récupérer des données et les stocker dans un fichier JSON. Ton script doit gérer avec élégance divers problèmes potentiels, tels que les problèmes de réseau ou les réponses JSON invalides, et afficher un message d'erreur ... | ["\nassert fetch_and_save_data(\"https://api.example.com/data\", \"data.json\") is None\n", "\nassert fetch_and_save_data(\"https://api.example.com/nonexistent\", \"nonexistent.json\") is None\n", "\nassert fetch_and_save_data(\"https://api.example.com/data\", \"invalid_path/invalid_file.json\") is None\n", "\nassert f... |
dcebf38f9c1c10d27dfeb88479a6f326 | [
{
"content": "Dans le domaine de l'optimisation, tu rencontres souvent des situations où tu dois alterner entre des problèmes de minimisation et de maximisation pour utiliser des algorithmes spécifiques. Ta tâche est de mettre en œuvre une fonction `get_optimization_direction(objective_name)` qui détermine si u... | ["\nassert get_optimization_direction(\"PROFIT\") == -1\n", "\nassert get_optimization_direction(\"revenue\") == -1\n", "\nassert get_optimization_direction(\"Efficiency\") == -1\n", "\nassert get_optimization_direction(\"throughput\") == -1\n", "\nassert get_optimization_direction(\"quality_score\") == -1\n", "\nasser... |
ad8eba123be19d69a1fa021b7198c625 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'une question et de sa réponse correspondante. Ta tâche est de mettre en œuvre une fonction qui formate ces questions et réponses en une seule chaîne de caractères. Chaque question et sa réponse doivent apparaître sur une nouvelle ligne... | ["\nassert format_questions_and_answers([(\"What is your name?\", \"Alice\")]) == \"What is your name?:Alice\\n\"\n", "\nassert format_questions_and_answers([(\"Your age\", \"30\")]) == \"Your age : 30\\n\"\n", "\nassert format_questions_and_answers([(\"Where do you live?\", \"Wonderland\")]) == \"Where do you live?:Wo... |
92aef25230c3a66a65ebd096add606c1 | [
{
"content": "On te demande d'écrire une fonction `generate_anagrams(word)` qui génère tous les anagrammes possibles d'un mot donné. Un anagramme est un réarrangement des lettres du mot en utilisant toutes les lettres originales exactement une fois. La fonction doit prendre un seul argument de chaîne de caractè... | ["\nassert generate_anagrams(\"abc\") == ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']\n", "\nassert generate_anagrams(\"xyz\") == ['xyz', 'xzy', 'yxz', 'yzx', 'zxy', 'zyx']\n", "\nassert generate_anagrams(\"a\") == ['a']\n", "\nassert generate_anagrams(\"ab\") == ['ab', 'ba']\n", "\nassert generate_anagrams(\"abcd\") == ... |
9c5bb786e4b7d72ef19e8132bd183c4a | [
{
"content": "On te demande de concevoir un modèle Django pour une entité `Book` (Livre). Le modèle `Book` doit inclure les champs suivants :\n- `title` (titre) : une chaîne de caractères représentant le titre du livre, avec une longueur maximale de 200 caractères.\n- `author` (auteur) : une chaîne de caractère... | ["\nassert Book._meta.get_field('title').max_length == 200\n", "\nassert Book._meta.get_field('author').max_length == 100\n", "\nassert Book._meta.get_field('publication_date').get_internal_type() == 'DateField'\n", "\nassert Book._meta.get_field('isbn').max_length == 13\n", "\nassert Book._meta.get_field('isbn').uniqu... |
c6243775c426a7b8557315b74120593b | [
{
"content": "On te donne une liste d'entiers représentant les prix des actions sur des jours consécutifs. Ta tâche est de déterminer le profit maximal que tu peux réaliser en achetant et en vendant l'action exactement une fois. Tu dois acheter avant de vendre. La fonction doit être optimisée pour s'exécuter en... | ["\nassert find_max_profit([7, 1, 5, 3, 6, 4]) == 5\n", "\nassert find_max_profit([7, 6, 4, 3, 1]) == 0\n", "\nassert find_max_profit([1, 2, 3, 4, 5]) == 4\n", "\nassert find_max_profit([3, 3, 5, 0, 0, 3, 1, 4]) == 4\n", "\nassert find_max_profit([1, 2]) == 1\n", "\nassert find_max_profit([1]) == 0\n", "\nassert find_m... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.