id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
b69845308ad38d801f9ed0dbf016cd7c | [
{
"content": "Tu participes à un concours d'analyse de données où tu dois organiser efficacement les jeux de données. On te fournit deux listes : une contenant `n` noms de jeux de données et une autre contenant `n` jeux de données correspondants. Ta tâche est de construire manuellement un dictionnaire à partir ... | ["\nassert create_dataset_dict([\"dataset1\"], [[1, 2, 3]]) == {\"dataset1\": [1, 2, 3]}\n", "\nassert create_dataset_dict([\"set1\", \"set2\"], [[4, 5], [6, 7]]) == {\"set1\": [4, 5], \"set2\": [6, 7]}\n", "\nassert create_dataset_dict([], []) == {}\n", "\nassert create_dataset_dict([\"a\", \"b\", \"c\"], [[1], [2], [... |
7d0d09df07b5a9de1a41f84f15c32d62 | [
{
"content": "On te donne une liste de mots et une chaîne de caractères. Un mot est considéré comme « constructible » s'il peut être formé en utilisant les caractères de la chaîne, où chaque caractère peut être utilisé plusieurs fois mais pas plus de fois qu'il apparaît dans la chaîne. Ta tâche est de détermine... | ["\nassert count_constructible_words([\"bat\", \"rat\", \"car\", \"cat\", \"tar\", \"bar\", \"code\"], \"arctb\") == 6\n", "\nassert count_constructible_words([\"hello\", \"world\"], \"helloworld\") == 2\n", "\nassert count_constructible_words([\"hello\", \"world\"], \"owrld\") == 0\n", "\nassert count_constructible_wo... |
b8f9c19c68c71c6cba3e04779c761acd | [
{
"content": "On te donne la tâche de concevoir un décorateur Python nommé `execution_time_logger` qui mesure le temps d'exécution de toute fonction qu'il décore. Le décorateur doit effectuer les actions suivantes :\n\n1. Afficher un message indiquant le début de l'exécution de la fonction, y compris le nom de ... | ["\nassert test_function(0) == \"Slept for 0 seconds\"\n", "\nassert test_function(1) == \"Slept for 1 seconds\"\n", "\nassert test_function(2) == \"Slept for 2 seconds\"\n", "\nassert test_function(0.5) == \"Slept for 0.5 seconds\"\n", "\nassert test_function(1.5) == \"Slept for 1.5 seconds\"\n", "\nassert test_functi... |
eda8e578f00b4fb95052f90c2ce12560 | [
{
"content": "On te donne une chaîne de caractères `s` et une chaîne de caractères `chars`. Ta tâche est de mettre en œuvre une fonction `filter_string(s, chars)` qui renvoie une nouvelle chaîne qui est une copie de `s` avec tous les caractères qui apparaissent dans `chars` supprimés. Tu n'es pas autorisé à uti... | ["\nassert filter_string(\"hello\", \"l\") == \"heo\"\n", "\nassert filter_string(\"world\", \"rld\") == \"wo\"\n", "\nassert filter_string(\"python\", \"yth\") == \"pon\"\n", "\nassert filter_string(\"programming\", \"aeiou\") == \"prgrmmng\"\n", "\nassert filter_string(\"1234567890\", \"13579\") == \"24680\"\n", "\na... |
9816385c76d1410b6fe3eefc5b4c9d4c | [
{
"content": "On te donne un arbre binaire représenté comme une liste d'entiers. Chaque élément de la liste représente un nœud, et la relation parent-enfant est définie par l'index : pour un nœud à l'index `i`, son enfant gauche est à l'index `2*i + 1` et son enfant droit est à l'index `2*i + 2`. Si un nœud est... | ["\nassert max_depth([1, 2, 3, 4, 5, 6, 7]) == 3\n", "\nassert max_depth([1, None, 3, None, None, 6, 7]) == 3\n", "\nassert max_depth([1, 2, None, 4, 5]) == 3\n", "\nassert max_depth([1, 2, 3, 4, None, None, 5, 6, 7]) == 4\n", "\nassert max_depth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) == 4\n", "\nassert m... |
84f6c0e4447929348857ba50ce3bbfbd | [
{
"content": "On te donne une liste de phrases, où chaque phrase est une chaîne de caractères contenant des mots séparés par des espaces. Ta tâche est d'écrire une fonction qui renvoie une liste de tous les mots palindromiques uniques dans les phrases, en préservant leur ordre d'origine. Un mot palindromique es... | ["\nassert find_unique_palindromic_words([\"Madam Arora teaches malayalam\"]) == ['madam', 'arora', 'malayalam']\n", "\nassert find_unique_palindromic_words([\"Nurses run\"]) == ['nurses']\n", "\nassert find_unique_palindromic_words([\"Was it a car or a cat I saw\"]) == ['wasitaacaroracitaws']\n", "\nassert find_unique... |
dff590b243e6d3501327402c398e3644 | [
{
"content": "On te donne un ensemble de fragments d'images en niveaux de gris représentés sous forme de tableau 2D ou 3D `patches`. Le tableau 2D représente un seul fragment avec les dimensions `(patch_height, patch_width)`, tandis que le tableau 3D représente plusieurs fragments avec les dimensions `(patches_... | ["\nassert np.array_equal(flatten_patches(np.array([[1, 2], [3, 4]])), np.array([[1, 2, 3, 4]]))\n", "\nassert np.array_equal(flatten_patches(np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])), np.array([[1, 2, 3, 4], [5, 6, 7, 8]]))\n", "\nassert np.array_equal(flatten_patches(csr_matrix([[1, 2], [3, 4]])), np.array([[1,... |
f7941052cd456bbf15f12e662f8eef78 | [
{
"content": "On te donne un fichier JSON contenant une liste d'objets, chacun représentant un rectangle englobant (bounding box) dans une image, avec des rectangles potentiellement qui se chevauchent. Ta tâche est d'écrire une fonction `JSON_reader(file_path)` qui lit le fichier et renvoie une liste de rectang... | ["\nassert JSON_reader('test1.json') == [[10, 20, 30, 40]]\n", "\nassert JSON_reader('test2.json') == [[50, 60, 70, 80], [150, 160, 170, 180]]\n", "\nassert JSON_reader('test3.json') == [[100, 100, 50, 50]]\n", "\nassert JSON_reader('test4.json') == [[0, 0, 100, 100]]\n", "\nassert JSON_reader('test5.json') == []\n", "... |
97d4d9629ccde706d851b532140b6553 | [
{
"content": "On te donne une chaîne de caractères `text` représentant un document avec plusieurs paragraphes. Chaque paragraphe est séparé par deux caractères de nouvelle ligne consécutifs `\\n\\n`, et chaque ligne à l'intérieur d'un paragraphe est séparée par un seul caractère de nouvelle ligne `\\n`. Ta tâch... | ["\nassert split_paragraphs(\"Hello\\nWorld\\n\\nThis\\nis\\na\\ntest\") == [[\"Hello\", \"World\"], [\"This\", \"is\", \"a\", \"test\"]]\n", "\nassert split_paragraphs(\"Single\\nline\\nparagraph\") == [[\"Single\", \"line\", \"paragraph\"]]\n", "\nassert split_paragraphs(\"\\n\\n\") == []\n", "\nassert split_paragrap... |
722c5e2f79a97b26292de7bc9d9f3212 | [
{
"content": "On te demande d'implémenter une fonction de vue Django nommée `register` qui gère l'inscription des utilisateurs. La fonction doit effectuer les tâches suivantes :\n- Accepter les requêtes HTTP POST contenant les données d'inscription de l'utilisateur.\n- Valider les données saisies à l'aide d'un ... | ["\nassert register(request).status_code == 200\n", "\nassert 'form' in register(request).context\n", "\nassert register(request).template_name == 'registration/register.html'\n", "\nassert register(request).context['form'].__class__.__name__ == 'RegistrationForm'\n", "\nassert register(request).status_code == 302 if r... |
4c5dfda2c484211fcf1a67cfea6443f2 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie la valeur maximale dans la liste. Tu n'es pas autorisé à utiliser des fonctions intégrées pour trouver la valeur maximale. Si la liste est vide, la fonction doit renvoyer `None`.\n\n**Exemple d'entrée :**\n```\n[3,... | ["\nassert find_maximum([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 9\n", "\nassert find_maximum([10, 20, 30, 40, 50]) == 50\n", "\nassert find_maximum([-10, -20, -30, -40, -50]) == -10\n", "\nassert find_maximum([0, 0, 0, 0, 0]) == 0\n", "\nassert find_maximum([100]) == 100\n", "\nassert find_maximum([]) == None\n", "\nasse... |
06cd3bbc5785dbf3ef28ad0120865388 | [
{
"content": "On te donne un chemin de répertoire. Ta tâche est d'écrire une fonction Python qui liste tous les fichiers et sous-répertoires dans le répertoire spécifié, en excluant tous les fichiers cachés (ceux qui commencent par un point `.`). Ta fonction doit renvoyer une liste de ces entrées.\n\n**Entrée :... | ["\nassert list_files_and_subdirectories(\"/tmp\") == [entry for entry in os.listdir(\"/tmp\") if not entry.startswith('.')]\n", "\nassert list_files_and_subdirectories(\"/\") == [entry for entry in os.listdir(\"/\") if not entry.startswith('.')]\n", "\nassert list_files_and_subdirectories(\"/nonexistent\") == []\n", "... |
5a940829b3eaea49e254ebdbd8f741f8 | [
{
"content": "On te donne un dictionnaire Python `data` représentant un objet JSON avec des structures imbriquées contenant des entiers, des chaînes de caractères, des listes et des dictionnaires. Ta tâche est de mettre en œuvre une fonction `flatten_dict` qui parcourt récursivement le dictionnaire et renvoie u... | ["\nassert flatten_dict({\"a\": 1, \"b\": 2}) == {\"a\": 1, \"b\": 2}\n", "\nassert flatten_dict({\"a\": {\"b\": 2}}) == {\"a.b\": 2}\n", "\nassert flatten_dict({\"a\": {\"b\": {\"c\": 3}}}) == {\"a.b.c\": 3}\n", "\nassert flatten_dict({\"a\": [1, 2, 3]}) == {\"a.0\": 1, \"a.1\": 2, \"a.2\": 3}\n", "\nassert flatten_di... |
1f174b92f7240d944e352f5b7a2cd022 | [
{
"content": "On te donne une séquence d'ADN représentée comme une chaîne de nucléotides. Ta tâche est d'écrire une fonction qui calcule le complément inverse de cette séquence. La fonction doit être insensible à la casse et capable de gérer des séquences contenant jusqu'à 100 000 nucléotides efficacement.\n\n*... | ["\nassert reverse_complement(\"ATCG\") == \"CGAT\"\n", "\nassert reverse_complement(\"aTcG\") == \"CGAT\"\n", "\nassert reverse_complement(\"GCTA\") == \"TAGC\"\n", "\nassert reverse_complement(\"gcta\") == \"TAGC\"\n", "\nassert reverse_complement(\"ACGTACGT\") == \"ACGTACGT\"\n", "\nassert reverse_complement(\"acgta... |
4e6c110b213bcb346d2081abc99b7fb3 | [
{
"content": "On te donne deux images binaires représentées comme des listes 2D d'entiers (0 ou 1). Ta tâche est d'implémenter la fonction `fowlkes_mallows_index` qui calcule l'indice de Fowlkes-Mallows (FMI) pour ces images en utilisant uniquement des opérations au niveau du bit et des boucles. Le FMI est défi... | ["\nassert fowlkes_mallows_index([[1, 0], [0, 1]], [[1, 0], [0, 1]]) == 1.0\n", "\nassert fowlkes_mallows_index([[1, 1], [1, 1]], [[0, 0], [0, 0]]) == 0.0\n", "\nassert fowlkes_mallows_index([[1, 1], [1, 1]], [[1, 1], [1, 1]]) == 1.0\n", "\nassert fowlkes_mallows_index([[0, 0], [0, 0]], [[0, 0], [0, 0]]) == 0.0\n", "\n... |
742210cf086dcfd5d76bcd850ece15e8 | [
{
"content": "On te donne une fonction `apply_conversion` qui prend un objet `x` et une fonction de conversion `conversion_function`. La fonction de conversion est une fonction qui prend un seul argument et renvoie une version convertie de cet argument. Ta tâche est de modifier la fonction `apply_conversion` po... | ["\nassert apply_conversion(['3', '4', 'five'], int) == [3, 4, 'five']\n", "\nassert apply_conversion(('1', '2', 'three'), int) == (1, 2, 'three')\n", "\nassert apply_conversion({'6', '7', 'eight'}, int) == {6, 7, 8}\n", "\nassert apply_conversion([1.1, 2.2, 'three'], int) == [1, 2, 'three']\n", "\nassert apply_convers... |
fd0bb821e22259af7495928f1d959253 | [
{
"content": "On te demande d'implémenter un système bancaire simple en Python. Le système doit prendre en charge les opérations suivantes :\n- **Dépôt** : Ajouter un montant spécifié au solde du compte.\n- **Retrait** : Soustraire un montant spécifié du solde du compte si des fonds suffisants sont disponibles.... | ["\nassert BankAccount(12345, 'John Doe').account_info['balance'] == 0.0\n", "\nassert BankAccount(12345, 'John Doe', 100.0).account_info['balance'] == 100.0\n", "\naccount = BankAccount(12345, 'John Doe', 100.0); account.deposit(50); assert account.account_info['balance'] == 150.0\n", "\naccount = BankAccount(12345, '... |
6d8f5ecafb8d19a7347644e1c3c79b24 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `clean_text` qui traite cette chaîne selon les règles suivantes :\n- Supprime tous les caractères qui ne sont pas alphanumériques, à l'exception des espaces, des tirets et des apostrophes.\n- Remplace toute sé... | ["\nassert clean_text(\"Hello, World! This is a test.\") == \"Hello World This is a test\"\n", "\nassert clean_text(\"I'm a little teapot, short and stout.\") == \"I'm a little teapot short and stout\"\n", "\nassert clean_text(\"This is a test\tstring.\") == \"This is a test string\"\n", "\nassert clean_text(\"No ... |
6bed8f97d73b764d10e66d96889d81dd | [
{
"content": "On te demande d'implémenter une classe `Matrix` en Python qui supporte les opérations matricielles de base : addition, soustraction, multiplication et transposition. La classe doit être initialisée avec une liste 2D de nombres. Implémente les méthodes suivantes :\n\n- `__init__(self, data)` : Init... | ["\nassert Matrix([[1, 2], [3, 4]]).add(Matrix([[5, 6], [7, 8]])).data == [[6, 8], [10, 12]]\n", "\nassert Matrix([[1, 2], [3, 4]]).subtract(Matrix([[5, 6], [7, 8]])).data == [[-4, -4], [-4, -4]]\n", "\nassert Matrix([[1, 2], [3, 4]]).multiply(Matrix([[5, 6], [7, 8]])).data == [[19, 22], [43, 50]]\n", "\nassert Matrix(... |
c95cba2d29dc12b78648d1d53d8e6046 | [
{
"content": "On te donne un ensemble d'entiers. Ta tâche est de déterminer si l'ensemble contient le nombre 5 ou s'il existe une paire de nombres distincts dans l'ensemble qui s'additionnent à 5. La fonction doit renvoyer `True` si l'une des conditions est remplie, sinon renvoyer `False`. La solution doit avoi... | ["\nassert has_five_or_subset({1, 2, 3, 4, 5}) == True\n", "\nassert has_five_or_subset({1, 2, 3, 4}) == True\n", "\nassert has_five_or_subset({6, 7, 8}) == False\n", "\nassert has_five_or_subset({5}) == True\n", "\nassert has_five_or_subset({2, 3}) == True\n", "\nassert has_five_or_subset({-1, 6}) == True\n", "\nasser... |
3f2643289e8021a76bcb352de2a792cd | [
{
"content": "On te demande d'implémenter une fonction `format_date_time(t)` qui traite des entrées de date et d'heure. La fonction doit gérer deux types d'entrées : un objet `datetime` ou une chaîne de caractères. Si l'entrée est un objet `datetime`, la fonction doit renvoyer une chaîne formatée comme `'%d-%m-... | ["\nassert format_date_time(datetime(2022, 1, 1, 12, 30, 45)) == '01-01-2022 12:30:45'\n", "\nassert format_date_time('2022-01-01 12:30:45') == '2022-01-01 12:30:45'\n", "\nassert format_date_time(datetime(2023, 12, 31, 23, 59, 59, tzinfo=pytz.utc)) == '31-12-2023 23:59:59'\n", "\nassert format_date_time(datetime(2021,... |
bd4bf03a3023c1747001e2a7264f5818 | [
{
"content": "On te donne un objet caméra avec une méthode `get_image_data()` qui renvoie une liste 2D représentant les données de pixels d'une image capturée par la caméra. Ta tâche est d'implémenter une fonction `calculate_image_area` qui calcule l'aire de l'image. La fonction ne doit pas utiliser de méthodes... | ["\nassert calculate_image_area(camera) == 0 if camera.get_image_data() == [] else True\n", "\nassert calculate_image_area(camera) == 4 if camera.get_image_data() == [[1, 2], [3, 4]] else True\n", "\nassert calculate_image_area(camera) == 9 if camera.get_image_data() == [[1, 2, 3], [4, 5, 6], [7, 8, 9]] else True\n", "... |
2f1d18e5a0a7c23b27b7c1e7147f0d83 | [
{
"content": "On te donne une liste de chaînes de caractères, chacune représentant une date au format \"AAAA-MM-JJ\". Ton objectif est d'implémenter une fonction `sort_dates` qui trie ces dates par ordre chronologique. La fonction doit renvoyer une nouvelle liste de chaînes de caractères avec les dates triées.\... | ["\nassert sort_dates([\"2022-01-01\", \"2021-12-31\", \"2023-01-01\"]) == [\"2021-12-31\", \"2022-01-01\", \"2023-01-01\"]\n", "\nassert sort_dates([\"2020-02-29\", \"2020-02-28\", \"2020-03-01\"]) == [\"2020-02-28\", \"2020-02-29\", \"2020-03-01\"]\n", "\nassert sort_dates([\"2019-12-31\", \"2020-01-01\", \"2019-01-0... |
aff452cfac492390ed175fc56ff7f2e4 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui renvoie une nouvelle liste contenant uniquement les nombres premiers de la liste originale. La fonction doit être optimisée pour la performance avec une complexité temporelle meilleure que O(n^2) pour les grandes entrées. Util... | ["\nassert filter_primes([2, 3, 4, 5, 6, 7, 8, 9, 10]) == [2, 3, 5, 7]\n", "\nassert filter_primes([11, 13, 17, 19, 23, 29]) == [11, 13, 17, 19, 23, 29]\n", "\nassert filter_primes([0, 1, 4, 6, 8, 9, 10]) == []\n", "\nassert filter_primes([31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]) == [31, 37, 41, 43,... |
6c4bbebadc5b5cdc4eabd22a4c073021 | [
{
"content": "On te donne un plateau de jeu représenté comme une liste 2D, où chaque liste interne représente une ligne du plateau. Chaque ligne contient des entiers non négatifs représentant le nombre de pierres dans chaque pile de cette ligne. Deux joueurs jouent à tour de rôle en retirant des pierres des pil... | ["\nassert evaluate_board([[0, 0], [0, 0]]) == (1.0, 0)\n", "\nassert evaluate_board([[1, 1], [1, 1]]) == (0.0, 27)\n", "\nassert evaluate_board([[3, 0], [0, 5], [0, 0]]) == (0.3333333333333333, 27)\n", "\nassert evaluate_board([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == (1.0, 0)\n", "\nassert evaluate_board([[1, 2, 3], [4, ... |
4353bc0b3c6f0fff955a92401a32b2c6 | [
{
"content": "On te demande d'implémenter une fonction pour déterminer si une chaîne de caractères donnée est une URL valide. L'URL peut ou non inclure le schéma `http` ou `https`, et elle doit correctement gérer les URL avec des sous-domaines, des ports, des chemins, des paramètres de requête et des identifian... | ["\nassert is_valid_url(\"http://example.com\") == True\n", "\nassert is_valid_url(\"https://www.example.com\") == True\n", "\nassert is_valid_url(\"example.com\") == True\n", "\nassert is_valid_url(\"https://example.com/path/to/page?query=123#section\") == True\n", "\nassert is_valid_url(\"http://sub.domain.com:80/pat... |
6cda03f06107d8eb9450be9d618cfbf0 | [
{
"content": "On te donne deux listes d'entiers, `li` et `weights`, représentant un ensemble de nombres et leurs poids correspondants. Ta tâche est de mettre en œuvre une fonction `weighted_mean(li, weights)` qui calcule la moyenne pondérée des nombres, en ignorant les nombres et leurs poids correspondants dont... | ["\nassert weighted_mean([1, 2, 3], [1, 1, 1]) == 2\n", "\nassert weighted_mean([1, 2, 3], [0, 0, 0]) == 0\n", "\nassert weighted_mean([1, 2, 3], [1, 0, 2]) == 2.3333333333333335\n", "\nassert weighted_mean([10, 20, 30], [1, 2, 3]) == 23.333333333333332\n", "\nassert weighted_mean([5, 10, 15], [-1, 0, 2]) == 15\n", "\n... |
46939c4355e21273f25cac2336108078 | [
{
"content": "On te donne une chaîne de caractères `expression` représentant une expression mathématique impliquant les opérateurs `+`, `-`, `*`, et `/`. Ta tâche est d'évaluer l'expression et de renvoyer le résultat sous forme de nombre à virgule flottante. L'expression peut contenir des espaces, qui doivent ê... | ["\nassert evaluate_expression(\"3 + 5\") == 8.0\n", "\nassert evaluate_expression(\"10 - 2\") == 8.0\n", "\nassert evaluate_expression(\"4 * 6\") == 24.0\n", "\nassert evaluate_expression(\"20 / 4\") == 5.0\n", "\nassert evaluate_expression(\"3 + 5 * 2\") == 13.0\n", "\nassert evaluate_expression(\"3 + 5 * (2 - 8) / 4... |
ec37b9f248b10c1189c2cfa52b1f959f | [
{
"content": "On te donne une chaîne de caractères `s` de longueur `n` composée de lettres anglaises. Ton objectif est de déterminer le nombre de sous-séquences non vides de `s` telles que la différence entre le caractère maximal et le caractère minimal de la sous-séquence est au plus égale à 1. Par exemple, da... | ["\nassert count_valid_subsequences(\"a\") == 1\n", "\nassert count_valid_subsequences(\"aa\") == 3\n", "\nassert count_valid_subsequences(\"ab\") == 4\n", "\nassert count_valid_subsequences(\"abc\") == 7\n", "\nassert count_valid_subsequences(\"aab\") == 6\n", "\nassert count_valid_subsequences(\"abb\") == 6\n", "\nas... |
73c6af4a775fa08ffe520b040e953fda | [
{
"content": "On te donne une séquence d'entiers. Ta tâche est d'implémenter une fonction qui extrait et renvoie une nouvelle séquence contenant uniquement les éléments uniques de la séquence originale, tout en conservant leur ordre d'apparition initial. Note que tu n'es pas autorisé à utiliser des fonctions ou... | ["\nassert unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3]\n", "\nassert unique_elements([4, 5, 6, 4, 7, 5]) == [4, 5, 6, 7]\n", "\nassert unique_elements([10, 10, 10]) == [10]\n", "\nassert unique_elements([]) == []\n", "\nassert unique_elements([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert unique_elements(['a', 'b'... |
9e4a7483a25e51c3277206dddc3e58ab | [
{
"content": "On te demande d'implémenter une fonction `filter_books_by_year` qui traite une liste de livres. Chaque livre est représenté comme un tuple contenant le titre, l'auteur et l'année de publication. Ta fonction doit renvoyer une liste de titres pour les livres qui ont été publiés au cours d'une année ... | ["\nassert filter_books_by_year(books, 1925) == [\"The Great Gatsby\"]\n", "\nassert filter_books_by_year(books, 1960) == [\"To Kill a Mockingbird\"]\n", "\nassert filter_books_by_year(books, 1949) == [\"1984\"]\n", "\nassert filter_books_by_year(books, 1932) == [\"Brave New World\"]\n", "\nassert filter_books_by_year(... |
1342517eec08c9fd59038173346b48fd | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author`, `isbn`, `price`, `publisher` et `year`. Implémente les méthodes suivantes :\n\n- `__init__(self, title, author, isbn, price, publisher, year)` : Initialise le livre avec les at... | ["\nassert Book(\"1984\", \"George Orwell\", \"1234567890\", 15.99, \"Secker & Warburg\", 1949).get_details() == \"Title: 1984, Author: George Orwell, ISBN: 1234567890, Price: 15.99, Publisher: Secker & Warburg, Year: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"0987654321\", 12.99, \"J.B. Lip... |
148fca61e99afedb84145ac86fe788b7 | [
{
"content": "On te donne une liste triée d'entiers, `numbers`, et une valeur flottante, `percentile`, qui varie de 0.0 à 1.0. Ta tâche est de mettre en œuvre une fonction `calculate_weighted_average` qui calcule la moyenne pondérée des deux éléments les plus proches du percentile donné dans la liste triée. La ... | ["\nassert calculate_weighted_average([1, 2, 3, 4, 5], 0.0) == 1\n", "\nassert calculate_weighted_average([1, 2, 3, 4, 5], 1.0) == 5\n", "\nassert calculate_weighted_average([1, 2, 3, 4, 5], 0.5) == 3\n", "\nassert calculate_weighted_average([1, 2, 3, 4, 5], 0.25) == 1.75\n", "\nassert calculate_weighted_average([1, 2,... |
34b566aef98c7701fa1119b6c1d95269 | [
{
"content": "On te donne une séquence `seq` d'éléments. Ta tâche est d'implémenter une fonction récursive `divisible_by_three_chunks(seq)` qui divise la séquence en blocs où chaque bloc a une longueur qui est un multiple de trois. La fonction doit renvoyer une liste de ces blocs. La séquence peut être une list... | ["\nassert divisible_by_three_chunks([1, 2, 3, 4, 5, 6, 7, 8, 9]) == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", "\nassert divisible_by_three_chunks([1, 2, 3, 4, 5, 6]) == [[1, 2, 3], [4, 5, 6]]\n", "\nassert divisible_by_three_chunks([1, 2]) == []\n", "\nassert divisible_by_three_chunks([]) == []\n", "\nassert divisible_by_... |
815323693bafd5ea3806545caf2639bd | [
{
"content": "On te demande d'implémenter une fonction pour générer un graphe non orienté aléatoire en utilisant une matrice d'adjacence. Le graphe doit avoir `n` nœuds, et chaque arête possible entre deux nœuds distincts doit exister avec une probabilité `p`. La matrice d'adjacence doit être symétrique, et il ... | ["\nassert (generate_random_graph(0, 0.5) == np.array([[]])).all()\n", "\nassert (generate_random_graph(1, 0.5) == np.array([[0]])).all()\n", "\nassert (generate_random_graph(2, 1.0) == np.array([[0, 1], [1, 0]])).all() or (generate_random_graph(2, 1.0) == np.array([[0, 0], [0, 0]])).all()\n", "\nassert (generate_rando... |
8024314ef0e356f94a19c2c1ce76f72c | [
{
"content": "On te donne une chaîne de caractères `expression` représentant une expression mathématique valide composée d'entiers non négatifs, d'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. Les o... | ["\nassert evaluate_expression(\"3 + 5\") == 8.0\n", "\nassert evaluate_expression(\"10 - 2\") == 8.0\n", "\nassert evaluate_expression(\"4 * 3\") == 12.0\n", "\nassert evaluate_expression(\"20 / 4\") == 5.0\n", "\nassert evaluate_expression(\"3 + 5 * 2 - 8\") == 5.0\n", "\nassert evaluate_expression(\"3 + (5 * 2) - 8\... |
799304b9348fea6adfd1999f55b761bf | [
{
"content": "On te donne une liste d'entiers, `numbers`, et un entier `divisor`. Ta tâche est d'implémenter une fonction `mod_list(numbers, divisor)` qui renvoie une nouvelle liste. Cette liste doit contenir le modulo de chaque nombre dans `numbers` lorsqu'il est divisé par `divisor`, mais avec la condition qu... | ["\nassert mod_list([10, 20, 30, 40], 5) == [0, 0, 0, 0]\n", "\nassert mod_list([1, 2, 3, 4, 5], 2) == [1, 1, 1, 0, 1]\n", "\nassert mod_list([7, 14, 21, 28], 7) == [0, 0, 0, 0]\n", "\nassert mod_list([12, 15, 18, 21], 3) == [0, 0, 0, 0]\n", "\nassert mod_list([100, 200, 300], 101) == [99, 98, 97]\n", "\nassert mod_lis... |
49eac9b64e926f5d8743779298f181f4 | [
{
"content": "On te donne un nœud d'un Arbre de Syntaxe Abstraite (AST). Ta tâche est de déterminer si le nœud représente une chaîne qui respecte un format spécifique. La chaîne est considérée comme étant dans un format spécial si elle répond aux critères suivants :\n\n1. Elle est composée exactement de deux so... | ["\nassert is_special_string(ast.Str(s=\"a_2\")) == True\n", "\nassert is_special_string(ast.Str(s=\"abc_3\")) == True\n", "\nassert is_special_string(ast.Str(s=\"a_4\")) == False\n", "\nassert is_special_string(ast.Str(s=\"a_11\")) == True\n", "\nassert is_special_string(ast.Str(s=\"a_123\")) == False\n", "\nassert is... |
cdf7aa487287d9cbb87eaa48d8310f6f | [
{
"content": "On te donne un DataFrame pandas `df` contenant des données boursières pour une entreprise spécifique. Le DataFrame inclut les colonnes suivantes : `Date`, `Open`, `High`, `Low`, `Close` et `Volume`. Avant d'effectuer des calculs, trie le DataFrame par `Date` en ordre décroissant et supprime toutes... | ["\nassert compute_rate_of_change(pd.DataFrame({'Date': ['2023-01-01', '2023-01-02', '2023-01-03'], 'Close': [100, 105, 110]}), window=1).iloc[0]['ROC'] == 4.761904761904762\n", "\nassert compute_rate_of_change(pd.DataFrame({'Date': ['2023-01-01', '2023-01-02', '2023-01-03'], 'Close': [100, 105, 110]}), window=2).iloc[... |
53269e61ddb91e394a41109901576da6 | [
{
"content": "On te donne un mot et une liste de mots. Ta tâche est d'écrire une fonction `find_anagrams` qui identifie et renvoie tous les anagrammes du mot donné dans la liste. Un anagramme est un mot formé en réarrangeant les lettres d'un autre mot. Par exemple, les anagrammes de \"listen\" dans la liste `[\... | ["\nassert find_anagrams(\"listen\", [\"enlist\", \"google\", \"inlets\", \"banana\"]) == [\"enlist\", \"inlets\"]\n", "\nassert find_anagrams(\"abc\", [\"cab\", \"bac\", \"bca\", \"xyz\"]) == [\"cab\", \"bac\", \"bca\"]\n", "\nassert find_anagrams(\"hello\", [\"world\", \"hello\", \"olelh\", \"loleh\"]) == [\"hello\",... |
f6f59af19fa6586c720e3294b932ab4e | [
{
"content": "On te demande d'implémenter une fonction qui calcule la racine carrée d'un nombre donné. La fonction doit être capable de gérer à la fois les nombres entiers et les nombres complexes. Ta fonction doit renvoyer la racine carrée sous forme de nombre complexe pour prendre en compte les résultats réel... | ["\nassert sqrt(4) == 2\n", "\nassert sqrt(9) == 3\n", "\nassert sqrt(0) == 0\n", "\nassert sqrt(-1) == 1j\n", "\nassert sqrt(-4) == 2j\n", "\nassert sqrt(16) == 4\n", "\nassert sqrt(1) == 1\n", "\nassert sqrt(2) == cmath.sqrt(2)\n", "\nassert sqrt(-9) == 3j\n", "\nassert sqrt(1+1j) == cmath.sqrt(1+1j)\n"] |
bddbf23e99c7008c934f22fdda7eb743 | [
{
"content": "On te donne un polynôme représenté par un tuple de coefficients par ordre décroissant de leurs puissances. Ta tâche est d'écrire une fonction `compute_integral` qui calcule l'intégrale indéfinie de ce polynôme et, éventuellement, d'évaluer l'intégrale définie sur un intervalle spécifié `[a, b]`. L... | ["\nassert compute_integral((1, 3, 2)) == ((1/3, 3/2, 2, 0), None)\n", "\nassert compute_integral((1, 3, 2), 0, 1) == ((1/3, 3/2, 2, 0), 16/3)\n", "\nassert compute_integral((2, 0, 1)) == ((2/3, 0, 1, 0), None)\n", "\nassert compute_integral((2, 0, 1), 0, 2) == ((2/3, 0, 1, 0), 14/3)\n", "\nassert compute_integral((0, ... |
a3c4268a86820314f338394c63c5dd8e | [
{
"content": "On te donne un DataFrame pandas `df` où chaque cellule peut contenir une chaîne de caractères avec des balises HTML. Ta tâche est d'écrire une fonction `strip_html_tags` qui traite le DataFrame et renvoie un nouveau DataFrame avec toutes les balises HTML supprimées des chaînes de caractères. La fo... | ["\nassert strip_html_tags(pd.DataFrame({'Text': ['<p>Hello World</p>']})).equals(pd.DataFrame({'Text': ['Hello World']}))\n", "\nassert strip_html_tags(pd.DataFrame({'Text': ['<a href=\"#\">Link</a>']})).equals(pd.DataFrame({'Text': ['Link']}))\n", "\nassert strip_html_tags(pd.DataFrame({'Text': ['<strong>Bold</strong... |
fa11977c40df4fae3c933c8e6bcf38ce | [
{
"content": "On te demande de développer un chatbot pour une équipe de service client. Le chatbot doit gérer diverses entrées utilisateur et fournir des réponses appropriées. Ton travail consiste à implémenter une fonction `generate_response(user_input)` qui génère une réponse en fonction de l'entrée. La fonct... | ["\nassert generate_response(\"Hi\") == \"Hello! How can I assist you today?\"\n", "\nassert generate_response(\"Hello, how are you?\") == \"Hello! How can I assist you today?\"\n", "\nassert generate_response(\"Do you have iPhone 14s in stock?\") == \"Thank you for asking! Let me check on the availability of the iPhon... |
a8b2a944fbcb7b0b394b2c13505f97bf | [
{
"content": "On te donne un fichier et un nombre d'octets à lire. Ta tâche est d'implémenter une fonction `check_non_ascii_chars` qui détermine s'il y a des caractères non-ASCII dans les premiers `number_of_bytes` du fichier. La fonction doit lire le fichier par blocs de 1 Mo et filtrer tous les caractères qui... | ["\nassert check_non_ascii_chars(\"ascii_file.txt\", 100) == False\n", "\nassert check_non_ascii_chars(\"non_ascii_file.txt\", 100) == True\n", "\nassert check_non_ascii_chars(\"empty_file.txt\", 100) == False\n", "\nassert check_non_ascii_chars(\"ascii_file.txt\", 0) == False\n", "\nassert check_non_ascii_chars(\"asci... |
c20c35229c49bf3602502a6b02ab77d0 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\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 - `year` : un ... | ["\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925, \"9780743273565\").get_summary() == \"Title: The Great Gatsby, Author: F. Scott Fitzgerald, Year: 1925, ISBN: 9780743273565\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"9780451524935\").get_summary() == \"Title: 1984, Author: George Orwel... |
7c39485b0e18b0903e2051dda2d26f2d | [
{
"content": "On te donne une liste de transactions financières représentées sous forme de chaînes de caractères. Chaque chaîne de transaction est formatée comme `<Type de transaction> <Montant> <Devise>`. Par exemple, une chaîne de transaction pourrait être `\"Sales 1000 USD\"`. Ta tâche est d'écrire une fonct... | ["\nassert aggregate_transactions([\"Sales 1000 USD\", \"Purchases 500 USD\", \"Losses 200 USD\", \"Profits 300 USD\"]) == {'Sales': 1000, 'Purchases': 500, 'Losses': 200, 'Profits': 300}\n", "\nassert aggregate_transactions([\"Sales 1000 USD\", \"Sales 2000 USD\"]) == {'Sales': 3000, 'Purchases': 0, 'Losses': 0, 'Prof... |
54a02e9755a0afab59dea30fe964241d | [
{
"content": "Implémente une fonction récursive pour calculer la factorielle d'un entier non négatif `n`. Ta fonction doit gérer les cas limites, tels que les entrées négatives, en renvoyant un message spécifique.\n\n**Entrée :**\n- Un seul entier `n` où `-10 <= n <= 10`.\n\n**Sortie :**\n- Si `n` est un entier... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(3) == 6\n", "\nassert factorial(-1) == \"Factorial is not defined for negative numbers\"\n", "\nassert factorial(-5) == \"Factorial is not defined for negative numbers\"\n", "\nassert factorial(10) == ... |
a33d37a74781704ca53e44d822374a69 | [
{
"content": "On te demande d'implémenter une fonction `decode_version` qui traite une chaîne de version et renvoie un tuple d'entiers. La chaîne de version est formatée de telle sorte que chaque segment, séparé par un point (`.`), peut être un entier positif ou un seul caractère représentant un entier négatif.... | ["\nassert decode_version(\"3.2.1\") == (3, 2, 1)\n", "\nassert decode_version(\"3.y.1\") == (3, -1, 1)\n", "\nassert decode_version(\"q.r.s\") == (-9, -8, -7)\n", "\nassert decode_version(\"10.20.30\") == (10, 20, 30)\n", "\nassert decode_version(\"5.x.6\") == (5, -2, 6)\n", "\nassert decode_version(\"u.v.w\") == (-5,... |
d952667b79129dc9c8de23c557c942a5 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci efficacement. Pour ce faire, tu dois utiliser la mémoïsation pour stocker les nombres de Fibonacci déjà calculés. Ta fonction doit gérer efficacement les grandes valeurs de n.\n\n**Entrée :**\n- Un entier `n` (0 ≤ ... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(25... |
5d3ebe54db62a8896631420d3c293000 | [
{
"content": "On te donne une séquence qui peut être une liste, une chaîne de caractères, ou tout autre itérable. Ta tâche est d'écrire une fonction `generate_permutations(sequence)` qui génère toutes les permutations possibles de la séquence donnée. La fonction doit retourner une liste de toutes les permutatio... | ["\nassert generate_permutations(\"abc\") == [['a', 'b', 'c'], ['a', 'c', 'b'], ['b', 'a', 'c'], ['b', 'c', 'a'], ['c', 'a', 'b'], ['c', 'b', 'a']]\n", "\nassert generate_permutations(\"a\") == [['a']]\n", "\nassert generate_permutations(\"\") == [[]]\n", "\nassert generate_permutations([1, 2, 3]) == [[1, 2, 3], [1, 3,... |
b559ac4ba7672063449b18fd18b78d4a | [
{
"content": "On te donne une liste d'URL. Ton objectif est d'écrire une fonction Python `get_url_status` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les URL, et les valeurs doivent être les codes de statut HTTP obtenus en effectuant une requête GET à chaque URL en utilisant la bibliothèq... | ["\nassert get_url_status([\"http://example.com\"]) == {\"http://example.com\": 200}\n", "\nassert get_url_status([\"http://nonexistentwebsite123456789.com\"]) == {\"http://nonexistentwebsite123456789.com\": 0}\n", "\nassert get_url_status([\"https://www.google.com\", \"https://www.example.com\"]) == {\"https://www.goo... |
98e044b5f9ae90dd45f99509b247a87f | [
{
"content": "On te donne une chaîne de caractères `expression` représentant une expression mathématique simple composée d'entiers et des opérateurs `+`, `-`, `*` et `/`. Ta tâche est de mettre en œuvre une fonction `evaluate_expression` qui évalue cette expression et renvoie le résultat sous forme de nombre à ... | ["\nassert evaluate_expression(\"3 + 5 * 2 - 8 / 4\") == 11.0\n", "\nassert evaluate_expression(\"10 - 2 * 3\") == 4\n", "\nassert evaluate_expression(\"100 / 10 + 5\") == 15.0\n", "\nassert evaluate_expression(\"5 * (3 + 2)\") == 25\n", "\nassert evaluate_expression(\"10 / 0\") == \"Error: division by zero\"\n", "\nas... |
2a35d336e624ee6315e7aad1ea4f6dd5 | [
{
"content": "On te demande d'implémenter une fonction `generate_report` qui traite une liste de transactions de vente et calcule le revenu total généré par chaque produit. Chaque transaction est représentée comme un dictionnaire avec les clés suivantes : `date`, `product_id`, `quantity_sold` et `unit_price`. T... | ["\nassert generate_report([{\"date\": \"2023-03-01\", \"product_id\": 1, \"quantity_sold\": 10, \"unit_price\": 15.99}]) == {1: 159.9}\n", "\nassert generate_report([{\"date\": \"2023-03-02\", \"product_id\": 2, \"quantity_sold\": 5, \"unit_price\": 29.99}]) == {2: 149.95}\n", "\nassert generate_report([{\"date\": \"2... |
a2d3978fe5b4c84acd2792eaf6878239 | [
{
"content": "On te demande d'implémenter une fonction qui gère efficacement la création de plusieurs fichiers temporaires à partir d'une longue liste de contenus de chaînes de caractères. La fonction doit utiliser le traitement concurrent pour accélérer le processus de création des fichiers. Chaque chaîne de c... | ["\nassert isinstance(create_temp_files([\"test\"]), list)\n", "\nassert len(create_temp_files([\"test\", \"another test\"])) == 2\n", "\nassert all(isinstance(name, str) for name in create_temp_files([\"test\", \"another test\"]))\n", "\nassert len(create_temp_files([])) == 0\n", "\nassert len(create_temp_files([\"sho... |
c6100367c822607a48064c6ad652bf39 | [
{
"content": "On te charge de simuler la population initiale d'un organisme simple dans une étude génétique. Le génome de chaque organisme est encodé en utilisant un code génétique modifié où chaque gène est représenté par un codon ternaire, composé de trois chiffres de l'ensemble {0, 1, 2}. Étant donné la long... | ["\nassert generate_initial_population(0, 0) == []\n", "\nassert generate_initial_population(1, 1) == [[[0, 0, 0]]] or [[[0, 0, 1]]] or [[[0, 0, 2]]] or [[[0, 1, 0]]] or [[[0, 1, 1]]] or [[[0, 1, 2]]] or [[[0, 2, 0]]] or [[[0, 2, 1]]] or [[[0, 2, 2]]] or [[[1, 0, 0]]] or [[[1, 0, 1]]] or [[[1, 0, 2]]] or [[[1, 1, 0]]] ... |
a425ae03fb470b3cb8d2a8eda7ffbeed | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction qui inverse l'ordre des mots dans la chaîne. Les mots dans la chaîne inversée doivent être séparés par un seul espace. Suppose que la chaîne d'entrée ne contient pas d'espaces au... | ["\nassert reverse_words(\"Hello world this is a test\") == \"test a is this world Hello\"\n", "\nassert reverse_words(\"Python is fun\") == \"fun is Python\"\n", "\nassert reverse_words(\"OpenAI GPT-4\") == \"GPT-4 OpenAI\"\n", "\nassert reverse_words(\"a b c d e\") == \"e d c b a\"\n", "\nassert reverse_words(\"singl... |
28c6db866556ef459f0d1cd3e2c983c9 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui prend en charge les opérations bancaires de base. La classe doit inclure des méthodes pour déposer et retirer de l'argent, ainsi que pour récupérer le solde actuel. De plus, tu dois implémenter une méthode pour appliquer des intérê... | ["\nassert BankAccount(1000).get_balance() == 1000\n", "\nassert BankAccount(1000).apply_interest(5); BankAccount(1000).get_balance() == 1050.0\n", "\nassert BankAccount(0).apply_interest(10); BankAccount(0).get_balance() == 0\n", "\nassert BankAccount(500).apply_interest(0); BankAccount(500).get_balance() == 500\n", "... |
1f650975ffc1e3a94bafb5b3aa6ca8da | [
{
"content": "On te donne une liste de mots. Ta tâche est de créer une fonction qui construit un dictionnaire où chaque mot de la liste est une clé, et sa valeur correspondante est la longueur de ce mot.\n\n**Entrée :**\n- Une liste de chaînes de caractères, `words`, où chaque chaîne est composée de lettres ang... | ["\nassert words_to_length_dict([\"apple\", \"banana\", \"cherry\"]) == {'apple': 5, 'banana': 6, 'cherry': 6}\n", "\nassert words_to_length_dict([\"hello\", \"world\"]) == {'hello': 5, 'world': 5}\n", "\nassert words_to_length_dict([]) == {}\n", "\nassert words_to_length_dict([\"a\", \"ab\", \"abc\"]) == {'a': 1, 'ab'... |
d87df6982055f270e2f76caf50014bb7 | [
{
"content": "On te donne une liste imbriquée contenant des entiers et d'autres listes imbriquées. Ta tâche est d'écrire une fonction Python qui aplatit cette liste imbriquée en une seule liste d'entiers. La fonction doit gérer des niveaux de nidification arbitraires.\n\n**Exemple d'entrée :**\n```\n[[1, 2, [3]... | ["\nassert flatten([[1, 2, [3]], 4, [5, 6]]) == [1, 2, 3, 4, 5, 6]\n", "\nassert flatten([1, [2, [3, [4, [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert flatten([]) == []\n", "\nassert flatten([[], [], []]) == []\n", "\nassert flatten([[[[[]]]]]) == []\n", "\nassert f... |
d85c3b47f65b9b1a279dc4b6998ea967 | [
{
"content": "Dans le jeu du pendu, l'ordinateur sélectionne un mot aléatoirement dans une liste donnée. Le mot doit respecter les contraintes suivantes :\n- Il ne doit pas contenir d'apostrophes ou de tirets.\n- Il doit comporter au moins 5 caractères.\n- Il ne doit pas contenir de lettres répétées.\n\nTa tâch... | ["\nassert choose_word([\"apple\", \"banana\", \"cherry\"]) == \"APPLE\" or choose_word([\"apple\", \"banana\", \"cherry\"]) == \"BANANA\" or choose_word([\"apple\", \"banana\", \"cherry\"]) == \"CHERRY\"\n", "\nassert choose_word([\"grape\", \"kiwi\", \"melon\", \"orange\"]) == \"MELON\" or choose_word([\"grape\", \"k... |
117277c420dfcb5aa150f33c3180075a | [
{
"content": "On te demande d'implémenter une fonction `generate_package_url` qui construit une URL pour une version spécifique d'un paquet logiciel hébergé sur un registre de paquets. La fonction doit accepter trois paramètres : `package_name`, `version` et `registry_url`.\n\nLa fonction doit renvoyer une URL ... | ["\nassert generate_package_url('seven_zip', '1.0-4', 'https://supermarket.chef.io/api/v1') == 'https://supermarket.chef.io/api/v1/packages/seven_zip/versions/1.0_4'\n", "\nassert generate_package_url('my_package', '2.3.1', 'https://example.com') == 'https://example.com/packages/my_package/versions/2.3.1'\n", "\nassert... |
bda50a106e21180bfe042db94f3c7c7b | [
{
"content": "On te demande d'implémenter une fonction qui calcule un taux d'apprentissage pour un modèle d'apprentissage automatique en utilisant un schéma de décroissance exponentielle avec une période d'échauffement. La fonction doit être optimisée pour l'efficacité computationnelle et les contraintes de mém... | ["\nassert exponential_decay_with_warmup(0, 0.01, 1000, 10000, 0.96) == 0.0\n", "\nassert exponential_decay_with_warmup(500, 0.01, 1000, 10000, 0.96) == 0.005\n", "\nassert exponential_decay_with_warmup(1000, 0.01, 1000, 10000, 0.96) == 0.01\n", "\nassert exponential_decay_with_warmup(1500, 0.01, 1000, 10000, 0.96) == ... |
f384728e1c31908bd2e5e595b06f6bc3 | [
{
"content": "On te donne un dictionnaire `bags` où chaque clé est un sac et sa valeur est une liste de tuples. Chaque tuple contient un sous-sac et un entier représentant la profondeur à laquelle le sous-sac est contenu dans le sac de départ. Ta tâche est d'écrire une fonction `find_all_subbags(bags, bag)` qui... | ["\nassert find_all_subbags(bags, \"big_bag\") == [\"big_bag\", \"medium_bag\", \"tiny_bag\", \"small_bag\"]\n", "\nassert find_all_subbags(bags, \"medium_bag\") == [\"medium_bag\", \"tiny_bag\"]\n", "\nassert find_all_subbags(bags, \"small_bag\") == [\"small_bag\"]\n", "\nassert find_all_subbags(bags, \"tiny_bag\") ==... |
d49e818d8b8c0bd655168fec1745b2e9 | [
{
"content": "On te donne deux listes d'entiers, `allowed_numbers` et `test_numbers`. Ta tâche est d'implémenter une fonction `validate_numbers(allowed_numbers, test_numbers)` qui détermine si chaque entier dans `test_numbers` est également présent dans `allowed_numbers`. Si `allowed_numbers` est vide, tous les... | ["\nassert validate_numbers([1, 2, 3, 4, 5], [2, 4]) == True\n", "\nassert validate_numbers([1, 2, 3, 4, 5], [2, 6]) == False\n", "\nassert validate_numbers([], [2, 4]) == True\n", "\nassert validate_numbers([1, 2, 3, 4, 5], []) == True\n", "\nassert validate_numbers([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]) == True\n", "\nass... |
7b2cccab33c1d51f0a61fb456307c4b2 | [
{
"content": "On te donne un dictionnaire où les clés sont les noms des étudiants et les valeurs sont des listes de leurs notes. Ta tâche est de déterminer l'étudiant ayant la moyenne la plus élevée. En cas d'égalité, renvoie l'étudiant dont le nom est le plus petit lexicographiquement.\n\n**Entrée :**\n- Un di... | ["\nassert student_with_highest_average({\"Alice\": [90, 85, 88], \"Bob\": [90, 91, 92], \"Charlie\": [88, 88, 89]}) == \"Bob\"\n", "\nassert student_with_highest_average({\"Alice\": [90, 90, 90], \"Bob\": [90, 90, 90], \"Charlie\": [90, 90, 90]}) == \"Alice\"\n", "\nassert student_with_highest_average({\"David\": [70,... |
b12ae450b692cb71ad47bcd16f9ee3d9 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'inverser l'ordre de toutes les consonnes dans la chaîne tout en gardant toutes les voyelles à leurs positions d'origine. Les voyelles sont définies comme 'a', 'e', 'i', 'o', 'u' (en majuscules et en minuscules).\n\n**Entrée :**\n- Une seule ... | ["\nassert reverse_string_except_vowels(\"hello world\") == \"holle werld\"\n", "\nassert reverse_string_except_vowels(\"abcdef\") == \"edcbaf\"\n", "\nassert reverse_string_except_vowels(\"a\") == \"a\"\n", "\nassert reverse_string_except_vowels(\"aeiou\") == \"aeiou\"\n", "\nassert reverse_string_except_vowels(\"AEIO... |
dfe3c0897643e0801f9eece9ceebce05 | [
{
"content": "On te donne un plan d'un labyrinthe représenté comme un graphe, où chaque nœud représente une pièce et les arêtes représentent les portes reliant les pièces. Le labyrinthe est considéré comme infini, mais tu ne t'intéresses qu'aux pièces accessibles à partir d'une pièce de départ donnée. Ta tâche ... | ["\nassert dfs({1: [2, 3], 2: [4, 5], 3: [6], 4: [7], 5: [8], 6: [], 7: [], 8: []}, 1, lambda x, y: x > y) == [1, 3, 6, 2, 5, 8, 4, 7]\n", "\nassert dfs({1: [2, 3], 2: [4, 5], 3: [6], 4: [7], 5: [8], 6: [], 7: [], 8: []}, 1, lambda x, y: x < y) == [1, 2, 4, 7, 5, 8, 3, 6]\n", "\nassert dfs({1: [2, 3], 2: [4, 5], 3: [6]... |
f77f2d48d7a280397c219535e3ed77b9 | [
{
"content": "On te demande d'implémenter une fonction `parse_json_config(config_str)` qui traite une chaîne de caractères formatée en JSON `config_str` et renvoie un dictionnaire représentant les paramètres de configuration. La fonction doit gérer des structures JSON complexes, y compris des dictionnaires et d... | ["\nassert parse_json_config('{\"name\": \"John\", \"age\": 30}') == {\"name\": \"John\", \"age\": 30}\n", "\nassert parse_json_config('{\"nested\": {\"key\": \"value\"}}') == {\"nested\": {\"key\": \"value\"}}\n", "\nassert parse_json_config('{\"list\": [1, 2, 3, 4]}') == {\"list\": [1, 2, 3, 4]}\n", "\nassert parse_j... |
7d46c445d243a2e520b9e147dd0c1968 | [
{
"content": "Tu es chargé de mettre en œuvre une simulation de système bancaire basique en Python. Ton système doit consister en deux classes : `Account` et `Customer`. Chaque `Customer` peut avoir plusieurs objets `Account`. La classe `Account` doit prendre en charge les opérations suivantes :\n- `deposit(amo... | ["\nassert Account(123).get_balance() == 0.0\n", "\nassert Account(123, 100.0).get_balance() == 100.0\n", "\nassert Account(123, 100.0).deposit(50) == None and Account(123, 100.0).get_balance() == 150.0\n", "\nassert Account(123, 100.0).withdraw(50) == None and Account(123, 100.0).get_balance() == 50.0\n", "\nassert Ac... |
3edca7ba2bd530723bd7cc5d399638f4 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `filter_even_numbers` qui traite cette liste et renvoie une nouvelle liste contenant uniquement les entiers pairs de la liste originale. La fonction doit parcourir la liste d'entrée, vérifier chaque nombre et l'ajouter à ... | ["\nassert filter_even_numbers([1, 2, 3, 4, 5, 6]) == [2, 4, 6]\n", "\nassert filter_even_numbers([10, 22, 35, 47, 53, 67]) == [10, 22]\n", "\nassert filter_even_numbers([2, 4, 6, 8, 10]) == [2, 4, 6, 8, 10]\n", "\nassert filter_even_numbers([1, 3, 5, 7, 9]) == []\n", "\nassert filter_even_numbers([-2, -4, -5, -6]) == ... |
36eddc80f04919ed4f1add0325aeb951 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction qui calcule la fréquence de chaque mot unique dans la liste, en ignorant la casse et la ponctuation. La fonction doit renvoyer un dictionnaire où les clés sont les mots uniques et les valeurs sont leurs fréquen... | ["\nassert word_frequency([\"Hello world!\", \"Hello there.\", \"World of code.\"]) == {'hello': 2, 'world': 2, 'there': 1, 'of': 1, 'code': 1}\n", "\nassert word_frequency([\"Python, Python, Python!\"]) == {'python': 3}\n", "\nassert word_frequency([\"A quick brown fox.\", \"The quick brown fox jumps over the lazy dog... |
ac29ac0e74fb9c5a0b0265ac97d5f0a7 | [
{
"content": "On te donne une chaîne de caractères `s` et une sous-chaîne `t`. La chaîne `s` est composée de mots séparés par des espaces et peut contenir des espaces au début et à la fin ainsi qu'un mélange de ponctuation. La sous-chaîne `t` est garantie d'apparaître exactement une fois dans `s`. Ta tâche est ... | ["\nassert extract_name_and_rest(\" ...Hello, world! This is a test. \", \"world\") == ('Hello', 'world! This is a test')\n", "\nassert extract_name_and_rest(\" ...Hello, world! This is a test. \", \"This\") == ('Hello', 'This is a test')\n", "\nassert extract_name_and_rest(\" ...Hello, world! This is a test.... |
84f7fd2335dd584e2809e7bc6a943499 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules d'une longueur maximale de 500, et une liste `d` contenant jusqu'à 500 chaînes de caractères, chacune d'une longueur maximale de 300. Ta tâche est de trouver la chaîne de caractères la plus longue dans `d` qui est une sous-séq... | ["\nassert find_longest_subsequence(\"abcde\", [\"a\", \"bb\", \"ac\", \"ace\", \"abc\", \"abcd\", \"abcde\"]) == \"abcde\"\n", "\nassert find_longest_subsequence(\"abc\", [\"a\", \"b\", \"c\", \"ab\", \"bc\", \"abc\"]) == \"abc\"\n", "\nassert find_longest_subsequence(\"abc\", [\"d\", \"e\", \"f\"]) == \"\"\n", "\nass... |
7b0ce682d375db34355e619cdc1c0cb9 | [
{
"content": "On te donne une fonction `f` et une liste d'arguments `args`. Ta tâche est de mettre en œuvre une fonction `optimize_function` qui renvoie l'argument de `args` qui maximise la fonction `f`. Si plusieurs arguments donnent la même valeur maximale, renvoie le premier rencontré. Suppose que `f` est un... | ["\nassert optimize_function(lambda x: x**2, [1, 2, 3, 4]) == 4\n", "\nassert optimize_function(lambda x: -x**2 + 4*x + 1, [0, 1, 2, 3, 4, 5]) == 4\n", "\nassert optimize_function(lambda x: x, [-10, -5, 0, 5, 10]) == 10\n", "\nassert optimize_function(lambda x: 1/x, [0.1, 0.5, 1, 2, 5]) == 0.1\n", "\nassert optimize_fu... |
3f0c722564d6a75ee09dd58abe7c7e22 | [
{
"content": "On te donne une liste d'objets `Person`, chacun ayant les attributs suivants : `id`, `name`, `age` et `city`. Chaque objet `Person` peut avoir un attribut `_tl_ref`, qui est soit `None`, soit une instance de la classe `Location`. La classe `Location` a une méthode `get_coordinates()` qui renvoie u... | ["\nassert id_to_coordinates([]) == {}\n", "\nassert id_to_coordinates([Person(1, \"Alice\", 17, \"Wonderland\", Location(1.0, 2.0))]) == {}\n", "\nassert id_to_coordinates([Person(2, \"Bob\", 18, \"Metropolis\", Location(3.0, 4.0))]) == {2: (3.0, 4.0)}\n", "\nassert id_to_coordinates([Person(3, \"Charlie\", 20, \"Atla... |
cc4ff086b613b1f3384eec73246fcafe | [
{
"content": "On te demande d'implémenter une fonction `calculate_average` qui accepte un nombre variable d'arguments. Chaque argument peut être un entier, un flottant, ou une liste imbriquée contenant des entiers et/ou des flottants. Ta fonction doit calculer la moyenne de tous les nombres, y compris ceux cont... | ["\nassert calculate_average(1, 2, 3, 4) == \"2.50\"\n", "\nassert calculate_average(1.5, 2.5, 3.5) == \"2.50\"\n", "\nassert calculate_average(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) == \"5.50\"\n", "\nassert calculate_average(1, [2, 3], [4, [5, 6]], 7) == \"4.00\"\n", "\nassert calculate_average(10) == \"10.00\"\n", "\nassert... |
3cf6a988ef263b5256ba0d2766d4877d | [
{
"content": "On te donne un système de panneaux solaires avec les paramètres `voltage`, `current`, `theoretical_max_power` et `resistance`. La puissance réelle générée par le système est calculée comme `(voltage - (current * resistance)) * current`. L'efficacité du système est déterminée par le rapport entre l... | ["\nassert determine_efficiency(12, 5, 60, 0.5) == \"High Efficiency\"\n", "\nassert determine_efficiency(12, 5, 60, 1) == \"Medium Efficiency\"\n", "\nassert determine_efficiency(12, 5, 60, 2) == \"Low Efficiency\"\n", "\nassert determine_efficiency(12, 5, 60, 3) == \"Critically Low Efficiency\"\n", "\nassert determin... |
639016da4c31c8eec0942dfa9a7ab5f1 | [
{
"content": "On te charge d'implémenter une fonction `pack_week(timestamp=None)` qui traite un horodatage donné ou l'heure actuelle, en l'abaissant à 00:00:00 le lundi le plus proche, et renvoie une chaîne d'octets compressée en utilisant le module `struct`. La fonction doit gérer les horodatages sous forme de... | ["\nassert pack_week(1672531200) == b'\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00'\n", "\nassert pack_week(1675123200) == b'\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00'\n", "\nassert pack_week(1675209600) == b'\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00'\n", "\nassert pack_week(1675296000) == b'\\x00\\x00\\x01\\x00\\x00\\x00\\x... |
97dc9009e3cb3e8d819afb50a93321c9 | [
{
"content": "On te demande d'écrire une fonction `generate_palindrome_sequence(n)` qui génère une liste des `n` premiers nombres palindromes. Un nombre palindrome est un nombre qui se lit de la même manière de gauche à droite et de droite à gauche. La séquence doit commencer à partir de 1 et inclure des nombre... | ["\nassert generate_palindrome_sequence(1) == [1]\n", "\nassert generate_palindrome_sequence(5) == [1, 2, 3, 4, 5]\n", "\nassert generate_palindrome_sequence(10) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11]\n", "\nassert generate_palindrome_sequence(15) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66]\n", "\nassert generat... |
144f46ba749468722d6910350a298ee9 | [
{
"content": "On te demande d'implémenter une fonction `setup_monitoring` pour un système de surveillance d'un service de stockage en nuage. La fonction doit enregistrer des informations détaillées sur chaque requête et réponse dans un fichier journal persistant nommé `monitoring.log` avec des horodatages. La f... | ["\nassert setup_monitoring(CloudStorageService(), 'ch-1234', 'email', 'user@example.com')['channel_id'] == 'ch-1234'\n", "\nassert setup_monitoring(CloudStorageService(), 'ch-5678', 'sms', '1234567890')['channel_type'] == 'sms'\n", "\nassert setup_monitoring(CloudStorageService(), 'ch-9101', 'webhook', 'https://exampl... |
e1cb80f5250b7534e4e3f873add499bd | [
{
"content": "On te donne une chaîne de caractères `message` et une liste de fonctions de hachage `hash_functions`. Ta tâche est d'implémenter la fonction `hash_chain` qui applique chaque fonction de hachage de la liste séquentiellement au message. La sortie de chaque fonction de hachage doit être utilisée comm... | ["\nassert hash_chain(\"hello\", [hash]) == bin(int(hash(\"hello\").hexdigest(), 16))[2:]\n", "\nassert hash_chain(\"world\", [hash, hash]) == bin(int(hash(hash(\"world\").hexdigest()).hexdigest(), 16))[2:]\n", "\nassert hash_chain(\"test\", [hash, hash, hash]) == bin(int(hash(hash(hash(\"test\").hexdigest()).hexdigest... |
7d9e8fbb45a681d97188c435665a4670 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer la longueur du plus long palindrome qui peut être construit en utilisant les caractères de la chaîne. Tu n'es pas tenu de construire le palindrome lui-même, mais de trouver la ... | ["\nassert longest_palindrome(\"abccccdd\") == 7\n", "\nassert longest_palindrome(\"a\") == 1\n", "\nassert longest_palindrome(\"aa\") == 2\n", "\nassert longest_palindrome(\"abc\") == 1\n", "\nassert longest_palindrome(\"aabbb\") == 5\n", "\nassert longest_palindrome(\"racecar\") == 7\n", "\nassert longest_palindrome(... |
97244ac9e829c11e348b97d330f52055 | [
{
"content": "On te donne un polygone convexe non dégénéré défini par une liste de sommets `[(x1, y1), (x2, y2), ..., (xn, yn)]`. Implémente une fonction `interpolate` qui calcule la valeur interpolée en un point `(x, y)` à l'intérieur du polygone. L'interpolation est basée sur les coordonnées barycentriques gé... | ["\nassert interpolate([(0, 0), (1, 0), (1, 1), (0, 1)], 0.5, 0.5, [1, 2, 3, 4]) == 2.5\n", "\nassert interpolate([(0, 0), (2, 0), (2, 2), (0, 2)], 1, 1, [10, 20, 30, 40]) == 25.0\n", "\nassert interpolate([(0, 0), (1, 0), (0.5, 1)], 0.5, 0.5, [1, 2, 3]) == 2.0\n", "\nassert interpolate([(0, 0), (1, 0), (1, 1)], 0.25, ... |
2c399d91b973824da047805670fbde4b | [
{
"content": "On te donne un fichier texte contenant un ou plusieurs blocs encodés en Base64. Chaque bloc commence par une ligne qui commence par '-----BEGIN' et se termine par une ligne qui commence par '-----END'. Les lignes entre ces marqueurs contiennent des données encodées en Base64. Ta tâche est d'écrire... | ["\nassert read_and_decode_base64('test1.txt') == 'Hello, World!'\n", "\nassert read_and_decode_base64('test2.txt') == 'Nested Base64 Decoding Test'\n", "\nassert read_and_decode_base64('test3.txt') == 'No Base64 Here'\n", "\nassert read_and_decode_base64('test4.txt') == 'Deeply Nested Test'\n", "\nassert read_and_deco... |
3d00cfbb0a936fb8807b4e311a6248e5 | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer les informations sur les livres. La classe doit stocker les attributs suivants : `title`, `author` et `year`. Implémente les méthodes suivantes :\n\n- `__init__(self, title, author, year)` : Initialise une nouvelle instance de la classe `Boo... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_info() == \"Title: 1984, Author: George Orwell, Year: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).get_info() == \"Title: To Kill a Mockingbird, Author: Harper Lee, Year: 1960\"\n", "\nassert Book(\"Pride and Prejudice\", \"Jane Austen... |
2ca154372b9d34465170d8152a4b8de9 | [
{
"content": "On te donne la tâche d'implémenter une fonction `is_numeric_array(arr)` qui détermine si une entrée donnée est un tableau numpy constitué uniquement d'éléments entiers 32 bits. Ta fonction doit renvoyer `True` si le tableau répond aux critères, et `False` sinon.\n\n**Contraintes :**\n- La fonction... | ["\nassert is_numeric_array(np.array([1, 2, 3], dtype=np.int32)) == True\n", "\nassert is_numeric_array(np.array([1, 2, 3], dtype=np.float32)) == False\n", "\nassert is_numeric_array(np.array([1, 2, 3], dtype=np.int64)) == False\n", "\nassert is_numeric_array(np.array([], dtype=np.int32)) == False\n", "\nassert is_nume... |
a7b095b1131cbc34cf1b3bc571958f4d | [
{
"content": "On te demande d'implémenter une fonction pour générer les `n` premiers nombres de la suite de Fibonacci en utilisant une approche récursive. 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 >= 2`. Ta fonction doit renvoyer une liste contena... | ["\nassert fibonacci_recursive(0) == []\n", "\nassert fibonacci_recursive(1) == [0]\n", "\nassert fibonacci_recursive(2) == [0, 1]\n", "\nassert fibonacci_recursive(3) == [0, 1, 1]\n", "\nassert fibonacci_recursive(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci_recursive(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\na... |
bd0af6a57a3d50d891c15a9f260bab78 | [
{
"content": "On te demande d'implémenter une fonction `encode_message` qui traite une chaîne de caractères `message` donnée selon des règles d'encodage spécifiques. Les règles sont les suivantes :\n\n- Remplace chaque voyelle minuscule (a, e, i, o, u) par son caractère encodé correspondant (a -> 4, e -> 3, i -... | ["\nassert encode_message(\"Hello World\") == \"H3ll0 W0rld\"\n", "\nassert encode_message(\"aAeEiIoOuU\") == \"aAeEiIoOuU\"\n", "\nassert encode_message(\"abc def\") == \"4bc d3f\"\n", "\nassert encode_message(\"Encode THIS message\") == \"3nc0d3 TH1S m3ss4g3\"\n", "\nassert encode_message(\"Umbrella\") == \"#mbrell4\... |
3641cefe995a3ec3337996006ac1ee33 | [
{
"content": "On te donne une chaîne de caractères `snake_case_str` au format snake_case. Ton objectif est d'écrire une fonction Python `convert_to_pascal_case(snake_case_str)` qui convertit cette chaîne en PascalCase. En PascalCase, chaque mot commence par une lettre majuscule et il n'y a pas de tirets bas ent... | ["\nassert convert_to_pascal_case(\"hello_world\") == \"HelloWorld\"\n", "\nassert convert_to_pascal_case(\"convert_to_pascal_case\") == \"ConvertToPascalCase\"\n", "\nassert convert_to_pascal_case(\"this_is_a_test\") == \"ThisIsATest\"\n", "\nassert convert_to_pascal_case(\"singleword\") == \"Singleword\"\n", "\nasser... |
f057efea7d5ffbf940296daf6c47bbd1 | [
{
"content": "On te demande d'implémenter une fonction nommée `get_valid_input` qui demande à l'utilisateur une entrée entière. La fonction doit gérer les entrées non valides (non entières), les interruptions clavier et limiter le nombre de tentatives à 5. Si l'utilisateur dépasse le nombre maximum de tentative... | ["\nassert get_valid_input(\"Enter a number: \") == 42 # Assuming user inputs '42'\n", "\nassert get_valid_input(\"Enter a number: \") == 0 # Assuming user inputs '0'\n", "\nassert get_valid_input(\"Enter a number: \") == -10 # Assuming user inputs '-10'\n", "\nassert get_valid_input(\"Enter a number: \") == 1000000... |
6e026557fa2c6660c587cfd17985d548 | [
{
"content": "Tu gères une compagnie de bus avec une flotte de bus, chacun ayant une capacité d'accueil distincte. Chaque jour, tu dois sélectionner un bus pour un itinéraire en fonction de la demande de passagers. Étant donné une liste de tailles de bus et la taille de bus actuelle en cours d'utilisation, tu s... | ["\nassert len(next_bus_size([10, 20, 30], 20, 5)) == 5\n", "\nassert all(size in [10, 20, 30] for size in next_bus_size([10, 20, 30], 20, 5))\n", "\nassert next_bus_size([10, 20, 30], 20, 1)[0] in [10, 30] or next_bus_size([10, 20, 30], 20, 1)[0] == 20\n", "\nassert next_bus_size([10, 20, 30], 10, 1)[0] in [20, 30]\n"... |
f7994cc1fa5850d88528514e67bff520 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'écrire une fonction Python qui renvoie un dictionnaire. Chaque clé du dictionnaire doit être une chaîne de caractères (en minuscules) provenant de la liste, et la valeur correspondante doit être une liste d'indices où cette chaîne ... | ["\nassert find_string_indices([\"Apple\", \"Banana\", \"apple\", \"Cherry\", \"banana\", \"Cherry\"]) == {'apple': [0, 2], 'banana': [1, 4], 'cherry': [3, 5]}\n", "\nassert find_string_indices([\"Dog\", \"Cat\", \"dog\", \"CAT\", \"Mouse\"]) == {'dog': [0, 2], 'cat': [1, 3], 'mouse': [4]}\n", "\nassert find_string_ind... |
e6c3748443dd831181b87555c6ea1597 | [
{
"content": "On te donne une liste de noms de processus et ta tâche est de déterminer si chaque processus est actuellement en cours d'exécution sur le système. Pour chaque nom de processus, renvoie son ID de processus s'il est en cours d'exécution, ou `None` s'il ne l'est pas. Ta solution doit gérer efficaceme... | ["\nassert check_processes_running(['python.exe']) == {'python.exe': None} or {'python.exe': <some_pid>}\n", "\nassert check_processes_running(['nonexistent_process.exe']) == {'nonexistent_process.exe': None}\n", "\nassert check_processes_running(['chrome.exe', 'firefox.exe']) == {'chrome.exe': None, 'firefox.exe': Non... |
3118d4cfc6707779f99e06e9e15caea4 | [
{
"content": "Tu es un criquet qui doit sauter sur une série de pierres pour atteindre la pierre finale. Chaque pierre a un coût énergétique associé, représentant l'énergie nécessaire pour sauter sur cette pierre. Ton objectif est d'atteindre la pierre finale avec le coût énergétique total minimum. Tu peux saut... | ["\nassert min_cost_path(1, [0]) == (0, [0])\n", "\nassert min_cost_path(2, [0, 3]) == (3, [0, 1])\n", "\nassert min_cost_path(3, [0, 3, 2]) == (2, [0, 2])\n", "\nassert min_cost_path(4, [0, 3, 2, 1]) == (3, [0, 2, 3])\n", "\nassert min_cost_path(5, [0, 3, 2, 1, 10]) == (4, [0, 2, 3, 4])\n", "\nassert min_cost_path(6, ... |
b5a9239d9440c7530ee2f9c6f173cbb5 | [
{
"content": "Tu développes une simulation pour un système de réseau électrique composé de `N` générateurs, chacun ayant une probabilité de défaillance unique tirée d'une distribution uniforme entre 0,05 et 0,25. Le système a une probabilité de défaillance maximale acceptable, `P_max`. Ta tâche est de détermine... | ["\nassert grid_failure_combinations(0.10, ['Gen1', 'Gen2'], [0.05, 0.05]) == [(0,), (1,), (0, 1)]\n", "\nassert grid_failure_combinations(0.01, ['Gen1', 'Gen2'], [0.05, 0.05]) == []\n", "\nassert grid_failure_combinations(0.20, ['Gen1', 'Gen2', 'Gen3'], [0.05, 0.05, 0.05]) == [(0,), (1,), (2,), (0, 1), (0, 2), (1, 2),... |
7b35145ce9894d559e069a2dbc6b3d8f | [
{
"content": "On te donne une chaîne de caractères `card_number` représentant un numéro de carte de crédit qui peut contenir des espaces et des tirets. Ta tâche est de déterminer si le numéro de carte de crédit est valide selon l'algorithme de Luhn. L'algorithme de Luhn fonctionne comme suit :\n1. Supprime tous... | ["\nassert is_valid_credit_card(\"4532-0151-1283-0366\") == True\n", "\nassert is_valid_credit_card(\"1234-5678-9012-3456\") == False\n", "\nassert is_valid_credit_card(\"49927398716\") == True\n", "\nassert is_valid_credit_card(\"49927398717\") == False\n", "\nassert is_valid_credit_card(\"1234 5678 1234 5670\") == Fa... |
4f69648c559d0aa0cfb0db865d8fc4bc | [
{
"content": "On te demande d'implémenter une fonction `clean_string` qui traite une chaîne de caractères donnée selon des règles spécifiques. La fonction doit gérer les caractères accentués de différentes langues, en les remplaçant par leurs équivalents non accentués. De plus, elle doit effectuer plusieurs rem... | ["\nassert clean_string(\"Caf\u00e9: M\u00e9lange / \u00c9tude\\t\u00bfQu\u00e9 tal? `Test` . \") == \"Cafe - M\u00e9lange __EtudeQu\u00e9 talTest\"\n", "\nassert clean_string(\"\u00e1\u00e9\u00ed\u00f3\u00fa\u00c1\u00c9\u00cd\u00d3\u00da\") == \"aeiouAEIOU\"\n", "\nassert clean_string(\"Caf\u00e9: M\u00e9lange / \u0... |
d97aac210825fa4fd7662b24ceec84a5 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction `filter_strings(strings: List[str]) -> Set[str]` qui renvoie un ensemble de chaînes de caractères qui ne sont pas des sous-chaînes d'une autre chaîne de caractères dans la liste. La fonction doit gérer effi... | ["\nassert filter_strings([\"a\", \"ab\", \"abc\"]) == {\"abc\"}\n", "\nassert filter_strings([\"abc\", \"ab\", \"a\"]) == {\"abc\"}\n", "\nassert filter_strings([\"hello\", \"world\", \"o\"]) == {\"hello\", \"world\"}\n", "\nassert filter_strings([\"test\", \"testing\", \"testing123\"]) == {\"testing123\"}\n", "\nasse... |
6a5172fc792881e76101c28aa923c331 | [
{
"content": "On te donne une chaîne de caractères représentant un chemin de répertoire. Ta tâche est d'écrire une fonction Python qui recherche récursivement tous les fichiers avec l'extension `.py` dans le répertoire spécifié et ses sous-répertoires. La fonction doit afficher les chemins absolus de ces fichie... | ["\nassert find_py_files('/nonexistent/directory') is None\n", "\nassert find_py_files('/usr') is None\n", "\nassert find_py_files('.') is None\n", "\nassert find_py_files('') is None\n", "\nassert find_py_files('/path/to/directory/with/no/py/files') is None\n", "\nassert find_py_files('/path/to/directory/with/one/py/f... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.