id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
0d1e01bbc0f3b26e2b5eb3aab63ff911 | [
{
"content": "On te donne une liste d'URL. Ton objectif est d'écrire un script Python qui récupère le contenu de chaque URL de manière concurrente en utilisant la programmation asynchrone. Utilise la bibliothèque `aiohttp` pour effectuer les requêtes HTTP de manière asynchrone. Gère les exceptions telles que le... | ["\nassert fetch_urls_concurrently([]) == {}\n", "\nassert fetch_urls_concurrently([\"http://example.com\"]) is not None\n", "\nassert fetch_urls_concurrently([\"http://example.com\", \"http://example.org\"]) is not None\n", "\nassert fetch_urls_concurrently([\"http://nonexistentwebsite12345.com\"]) == {\"http://nonexi... |
81a852fcae14c6782c16c5b1efe10409 | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer les informations sur les livres. La classe doit prendre en charge les fonctionnalités suivantes :\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ésent... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_info() == \"Title: 1984, Author: George Orwell, Year: 1949, Genres: \"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960, [\"Fiction\", \"Classic\"]).get_info() == \"Title: To Kill a Mockingbird, Author: Harper Lee, Year: 1960, Genres: Fiction, Cla... |
3629c678a3190456bbd144aa2f7785a7 | [
{
"content": "On te donne une liste d'entiers `lst` et un entier `k`. Ta tâche est de réorganiser les éléments de `lst` en la divisant en quatre quarts. Si la longueur de la liste n'est pas divisible par quatre, distribue les éléments restants parmi les premiers quarts. Après le réarrangement, décale toute la s... | ["\nassert rearrange_sequence_by_quarters([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 3) == [13, 14, 15, 16, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, 8]\n", "\nassert rearrange_sequence_by_quarters([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 2) == [9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, 8]\n", "\nassert rearrange_seq... |
b3b4873afc728d0d562aa296994d0d8e | [
{
"content": "Tu es chargé d'implémenter une fonction `get_weather(city_name)` qui interroge une API météo externe pour récupérer la température actuelle et la description de la météo pour une ville donnée. La fonction doit renvoyer un tuple `(temperature, description)` où `temperature` est la température actue... | ["\nassert get_weather(\"\") is None\n", "\nassert get_weather(\"NonExistentCity123\") is None\n", "\nassert get_weather(\" \") is None\n", "\nassert get_weather(None) is None\n", "\nassert isinstance(get_weather(\"London\"), tuple) or get_weather(\"London\") is None\n", "\nassert isinstance(get_weather(\"New York\"), ... |
42a3098f8ee4c58b454ca0e267a5cdd4 | [
{
"content": "On te donne une liste de mots. Ton objectif est d'écrire une fonction qui renvoie le mot le plus long de la liste. En cas d'égalité de longueur, la fonction doit renvoyer le mot lexicographiquement le plus petit. La comparaison doit être sensible à la casse.\n\n**Entrée :**\n- Une liste de chaînes... | ["\nassert longest_word([\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\"]) == \"elderberry\"\n", "\nassert longest_word([\"dog\", \"cat\", \"elephant\", \"antelope\"]) == \"elephant\"\n", "\nassert longest_word([\"zebra\", \"giraffe\", \"hippopotamus\", \"rhinoceros\"]) == \"hippopotamus... |
5fb4d7cbb6708c9a429c6895343e9a78 | [
{
"content": "On te donne un dictionnaire `d` où chaque clé est une chaîne de caractères et chaque valeur est également une chaîne de caractères. Ta tâche est d'écrire une fonction `invert_dict(d)` qui construit et renvoie un nouveau dictionnaire. Dans ce nouveau dictionnaire, les clés et les valeurs du diction... | ["\nassert invert_dict({'a': 1, 'b': 2, 'c': 3}) == {1: 'a', 2: 'b', 3: 'c'}\n", "\nassert invert_dict({'a': 1, 'b': 1, 'c': 1}) == {1: 'c'}\n", "\nassert invert_dict({'x': 10, 'y': 20, 'z': 10}) == {10: 'z', 20: 'y'}\n", "\nassert invert_dict({'apple': 'fruit', 'banana': 'fruit', 'carrot': 'vegetable'}) == {'fruit': '... |
879e5bdf5117134e717d18e2cf51f8f1 | [
{
"content": "On te donne une chaîne de caractères au format camelCase. Ta tâche est d'écrire une fonction `convert_to_snake_case` qui convertit cette chaîne au format snake_case. La chaîne d'entrée ne contiendra ni espaces ni caractères de soulignement et sera toujours au format camelCase.\n\n**Entrée :**\n- U... | ["\nassert convert_to_snake_case(\"thisIsAnExample\") == \"this_is_an_example\"\n", "\nassert convert_to_snake_case(\"camelCase\") == \"camel_case\"\n", "\nassert convert_to_snake_case(\"oneTwoThree\") == \"one_two_three\"\n", "\nassert convert_to_snake_case(\"helloWorld\") == \"hello_world\"\n", "\nassert convert_to_s... |
02c6d583b7083a58d1126475f262435b | [
{
"content": "On te demande d'implémenter une classe `DynamicCumulativeSums` qui prend en charge les mises à jour dynamiques d'une liste d'entiers. La classe doit gérer efficacement l'insertion et la suppression d'éléments à n'importe quelle position dans la liste et maintenir deux listes cumulatives :\n\n- `cu... | ["\nassert CumulativeSums([1, 2, 3, 4]).get_cumulative_sums() == ([1, 3, 6, 10], [1, 5, 14, 30])\n", "\nassert CumulativeSums([5, 10, 15]).get_cumulative_sums() == ([5, 15, 30], [25, 125, 275])\n", "\nassert CumulativeSums([]).get_cumulative_sums() == ([], [])\n", "\nassert CumulativeSums([0, 0, 0]).get_cumulative_sums... |
4b3c740b9f2d13e77c026d09ae6f6511 | [
{
"content": "On te donne une liste d'entiers, qui peut inclure des valeurs positives et négatives. Ta tâche est d'écrire une fonction Python qui calcule la somme de tous les nombres pairs de la liste.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^3), où chaque entier `num` satisfait -... | ["\nassert sum_of_even_numbers([1, 2, 3, 4, -5, -6]) == 0\n", "\nassert sum_of_even_numbers([2, 4, 6, 8, 10]) == 30\n", "\nassert sum_of_even_numbers([-2, -4, -6, -8, -10]) == -30\n", "\nassert sum_of_even_numbers([1, 3, 5, 7, 9]) == 0\n", "\nassert sum_of_even_numbers([-1, -3, -5, -7, -9]) == 0\n", "\nassert sum_of_ev... |
7b1f817e91fa7279dc256e824ae2c28c | [
{
"content": "On te donne une liste d'éléments. Ta tâche est d'écrire une fonction `average` qui calcule la moyenne des entiers dans la liste. La fonction doit gérer deux types d'erreurs avec élégance :\n1. Si la liste est vide, la fonction doit renvoyer la chaîne de caractères \"The list is empty.\".\n2. Si la... | ["\nassert average([1, 2, 3, 4]) == 2.5\n", "\nassert average([]) == \"The list is empty.\"\n", "\nassert average([1, 2, 'a', 4]) == \"The list contains non-integer values.\"\n", "\nassert average([10, 20, 30]) == 20.0\n", "\nassert average([5]) == 5.0\n", "\nassert average([1, 2, 3, '4']) == \"The list contains non-in... |
43108c504434c173decd104e7ac7c62e | [
{
"content": "On te donne une grille 2D d'entiers représentant un plateau de jeu. Chaque cellule peut contenir une valeur ou être vide (représentée par 0). Le jeu consiste à fusionner des cellules de même valeur pour créer une seule cellule avec une valeur égale à la somme des cellules fusionnées. Le processus ... | ["\nassert merge_and_move([[2, 0, 2, 4], [0, 0, 0, 4], [2, 0, 2, 2], [0, 0, 0, 0]]) == [[4, 4, 4, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n", "\nassert merge_and_move([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) == [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n", "\nassert merge_and_move(... |
f1157dccb24841e724cff48bb0ae716e | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction `list_intersection` qui renvoie une liste d'entiers représentant les éléments communs entre `list1` et `list2`. La liste renvoyée ne doit contenir aucun élément en double. S'il n'y a pas d'éléments ... | ["\nassert list_intersection([1, 2, 3], [3, 4, 5]) == [3]\n", "\nassert list_intersection([1, 2, 3], [4, 5, 6]) == []\n", "\nassert list_intersection([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert list_intersection([], [1, 2, 3]) == []\n", "\nassert list_intersection([1, 2, 3], []) == []\n", "\nassert list_intersecti... |
5876dbee9d70e6b52987065b804d93af | [
{
"content": "On te demande d'implémenter une classe `BankAccount` qui prend en charge les opérations bancaires de base. La classe doit avoir les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur doit accepter un solde initial.\n- **Dépôt** : Une méthode pour ajouter un montant spécifié au s... | ["\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount(0).get_balance() == 0\n", "\nassert BankAccount(-50).get_balance() == -50\n", "\nassert BankAccount(100).deposit(50) or BankAccount(100).get_balance() == 150\n", "\nassert BankAccount(100).deposit(-50) or BankAccount(100).get_balance() == 100\n"... |
93034b7027deba145e95384b2ce983a4 | [
{
"content": "Dans le domaine de la mécanique quantique, les particules peuvent exister dans une superposition d'états, représentée par des nombres complexes. L'état d'une particule quantique dans l'espace 3D peut être décrit par un vecteur complexe à trois composantes. Le produit vectoriel de deux vecteurs dan... | ["\nassert np.array_equal(quantum_cross([1+2j, 3+4j, 5+6j], [7+8j, 9+10j, 11+12j]), np.array([-6-24j, 12+24j, -6-24j]))\n", "\nassert np.array_equal(quantum_cross([1j, 0, 0], [0, 1j, 0]), np.array([0, 0, -1]))\n", "\nassert np.array_equal(quantum_cross([0, 0, 1], [0, 1, 0]), np.array([-1, 0, 0]))\n", "\nassert np.array... |
9a1088ef226d45813a9e181b33ae0547 | [
{
"content": "Dans un système de calendrier modifié, une année bissextile est définie comme suit :\n- Une année est bissextile si elle est divisible par 5.\n- Cependant, si l'année est une année de fin de siècle (c'est-à-dire divisible par 100), elle doit également être divisible par 500 pour être une année bis... | ["\nassert count_leap_years(1900, 2100) == 41\n", "\nassert count_leap_years(2000, 2020) == 5\n", "\nassert count_leap_years(1600, 2000) == 81\n", "\nassert count_leap_years(1800, 1800) == 0\n", "\nassert count_leap_years(2000, 2000) == 1\n", "\nassert count_leap_years(4000, 4000) == 1\n", "\nassert count_leap_years(1,... |
7e4617e146b694970a07029564a36760 | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `rotate_string(s, n)` qui fait pivoter la chaîne `s` vers la droite de `n` positions. Si `n` dépasse la longueur de la chaîne, elle doit revenir au début. La fonction doit renvoyer la chaîne piv... | ["\nassert rotate_string(\"abcdef\", 2) == \"efabcd\"\n", "\nassert rotate_string(\"abcdef\", 6) == \"abcdef\"\n", "\nassert rotate_string(\"abcdef\", 8) == \"efabcd\"\n", "\nassert rotate_string(\"abcdef\", 0) == \"abcdef\"\n", "\nassert rotate_string(\"\", 3) == \"\"\n", "\nassert rotate_string(\"a\", 1) == \"a\"\n",... |
ee7ae48345fd680cbeb9c3946803e969 | [
{
"content": "On te donne une grille 2D de cellules, où chaque cellule est définie par ses sommets. Les sommets sont représentés comme un tableau numpy 2D, où chaque ligne correspond à un sommet et chaque colonne correspond à une coordonnée (x, y). Chaque cellule peut avoir un nombre différent de points de quad... | ["\nassert np.array_equal(compute_quadrature_points(np.array([[0, 0], [1, 0], [1, 1], [0, 1]]), np.array([[0, 1, 2, 3]]), [[0.25, 0.25, 0.25, 0.25]]), np.array([[0.5, 0.5]]))\n", "\nassert np.array_equal(compute_quadrature_points(np.array([[0, 0], [2, 0], [2, 2], [0, 2]]), np.array([[0, 1, 2, 3]]), [[0.5, 0.5, 0.5, 0.5... |
9e4c1010dbcf507636a6ff6f2eeaaf14 | [
{
"content": "On te demande d'implémenter une fonction pour générer tous les nombres premiers jusqu'à une limite donnée inclusivement, en utilisant l'algorithme du crible d'Ératosthène. Ta fonction doit être efficace et gérer de grandes tailles d'entrée.\n\n**Signature de la fonction :**\n```python\ndef generat... | ["\nassert generate_prime_numbers(10) == [2, 3, 5, 7]\n", "\nassert generate_prime_numbers(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_prime_numbers(1) == []\n", "\nassert generate_prime_numbers(2) == [2]\n", "\nassert generate_prime_numbers(0) == []\n", "\nassert generate_prime_numbers(30) == [2, 3, 5, ... |
08b38c2b1eac1b4cc560da8accce4929 | [
{
"content": "On te donne une liste de probabilités `probabilities` représentant la probabilité qu'un événement se produise à chaque pas de temps. Ta tâche est de calculer la probabilité de survie cumulative, qui est la probabilité que l'événement ne se soit pas produit jusqu'à chaque pas de temps. Retourne une... | ["\nassert cumulative_survival_below_threshold([0.1, 0.2, 0.3], 0.5) == [0.504]\n", "\nassert cumulative_survival_below_threshold([0.5, 0.5, 0.5], 0.5) == [0.125]\n", "\nassert cumulative_survival_below_threshold([0.1, 0.1, 0.1, 0.1], 0.8) == [0.729]\n", "\nassert cumulative_survival_below_threshold([0.9, 0.9, 0.9], 0.... |
fb8576a172107b566f80db714e7145e8 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trier cette liste par ordre décroissant en fonction de la fréquence de chaque entier. Si deux entiers ont la même fréquence, ils doivent être triés par ordre croissant. Implémente une fonction `sort_by_frequency` qui accomplit cela.\n\n**Entrée :**\... | ["\nassert sort_by_frequency([4, 6, 2, 6, 4, 4, 8, 2, 2, 2]) == [2, 2, 2, 2, 4, 4, 4, 6, 6, 8]\n", "\nassert sort_by_frequency([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) == [4, 4, 4, 4, 3, 3, 3, 2, 2, 1]\n", "\nassert sort_by_frequency([5, 5, 5, 5, 5]) == [5, 5, 5, 5, 5]\n", "\nassert sort_by_frequency([10, 9, 8, 7, 6, 5, 4, 3, 2... |
d4c6bbbe0d924606d7221a0581a43380 | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de trouver le produit maximal de tout sous-tableau contigu dans `nums`. Un sous-tableau est défini comme une séquence contiguë non vide d'éléments dans un tableau.\n\n**Entrée :**\n- Un tableau d'entiers `nums` où `-10^4 <= nums[i] <= 10^4` et ... | ["\nassert maxProduct([2, 3, -2, 4]) == 6\n", "\nassert maxProduct([-2, 0, -1]) == 0\n", "\nassert maxProduct([0, 2]) == 2\n", "\nassert maxProduct([-2, 3, -4]) == 24\n", "\nassert maxProduct([2, -5, -2, -4, 3]) == 24\n", "\nassert maxProduct([-1, -2, -9, -6]) == 108\n", "\nassert maxProduct([1, -2, 3, 4, -5, 8]) == 96... |
f839ae8de0d1a75d0f19c76711ba2e62 | [
{
"content": "On te donne une grille de dimensions `n x m` remplie de deux types de créatures : '>' (orientée vers l'est) et 'v' (orientée vers le sud). Ces créatures se déplacent dans leur direction respective, et si elles rencontrent un espace vide (représenté par '.'), elles s'y déplacent. Si une créature re... | ["\nassert simulate_movement([['.', '>', '.', '.'], ['.', '.', 'v', '.'], ['.', '.', '.', '>'], ['v', '.', '.', '.']]) == (4, False)\n", "\nassert simulate_movement([['>', '.', '.', '.'], ['.', '.', '.', '.'], ['.', '.', '.', '.'], ['.', '.', '.', '.']]) == (1, False)\n", "\nassert simulate_movement([['.', '.', '.', '.... |
443097d980504b9f93c7eca196bb0a89 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `check_palindrome` qui détermine si la chaîne est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne est un palindrome si elle se lit de la même manière de ga... | ["\nassert check_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert check_palindrome(\"Hello World\") == False\n", "\nassert check_palindrome(\"racecar\") == True\n", "\nassert check_palindrome(\"No lemon, no melon\") == True\n", "\nassert check_palindrome(\"Was it a car or a cat I saw?\") == True\n",... |
63462320979b419dd014b93bd4013fff | [
{
"content": "On te demande d'implémenter une fonction `parse_csv_string` qui analyse une chaîne de caractères formatée en CSV et la transforme en une liste de champs. La chaîne CSV peut contenir des champs entre guillemets doubles, qui peuvent inclure des virgules et des guillemets doubles échappés (représenté... | ["\nassert parse_csv_string('apple,banana,cherry') == ['apple', 'banana', 'cherry']\n", "\nassert parse_csv_string('\"apple\",\"banana\",\"cherry\"') == ['\"apple\"', '\"banana\"', '\"cherry\"']\n", "\nassert parse_csv_string('apple,\"banana, with, commas\",cherry') == ['apple', 'banana, with, commas', 'cherry']\n", "\... |
0ec3fc66615a696ed99278834c62bffa | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Propriétés :**\n - `balance` : un float représentant le solde actuel du compte.\n - `account_number` : une chaîne de caractères représentant le numéro de compte... | ["\nassert BankAccount(\"123456789\").get_balance() == 0.0\n", "\nassert BankAccount(\"123456789\", 100.0).get_balance() == 100.0\n", "\nassert BankAccount(\"123456789\", 100.0).deposit(50.0) is None\n", "\nassert BankAccount(\"123456789\", 100.0).deposit(-50.0) == \"Deposit amount must be positive.\"\n", "\nassert Ban... |
95049142aea6aac0880ff6dd5aeb167e | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `find_max(numbers)` qui renvoie la valeur maximale dans la liste. Tu n'es pas autorisé à utiliser des fonctions intégrées telles que `max()`. Si la liste est vide, ta fonction doit lever une exception `ValueError` avec le... | ["\nassert find_max([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 9\n", "\nassert find_max([10, 20, 30, 40, 50]) == 50\n", "\nassert find_max([-10, -20, -30, -40, -5]) == -5\n", "\nassert find_max([0, 0, 0, 0, 0]) == 0\n", "\nassert find_max([100]) == 100\n", "\nassert find_max([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 10\n", "\nass... |
96aa2a578f3d25b4a575d6ec3ea81811 | [
{
"content": "On te donne un fichier texte situé à un chemin spécifié. Ta tâche est d'écrire un programme Python qui lit ce fichier et affiche les 10 mots les plus courants par ordre décroissant de fréquence, en excluant un ensemble prédéfini de mots vides courants. Les mots vides à exclure sont : \"the\", \"an... | ["\nassert read_and_count_words(\"nonexistentfile.txt\") is None\n", "\nassert read_and_count_words(\"emptyfile.txt\") is None\n", "\nassert read_and_count_words(\"singlewordfile.txt\") is None\n", "\nassert read_and_count_words(\"stopwordsfile.txt\") is None\n", "\nassert read_and_count_words(\"commonwordsfile.txt\") ... |
ada0e402e794c282992843054b00dc71 | [
{
"content": "On te donne un dictionnaire `params` qui spécifie si certaines bibliothèques sont requises pour un projet. Le dictionnaire contient des valeurs booléennes pour les clés `use_lib_b` et `use_lib_c`, et `compile_lib_c`. Tu dois générer une chaîne de dépendances de bibliothèque en fonction de ces para... | ["\nassert generate_library_dependencies({}, \"/usr/local/lib\", \"example.so\") == \"static lib_a /usr/local/lib/example.so\"\n", "\nassert generate_library_dependencies({'use_lib_b': True}, \"/usr/local/lib\", \"example.so\") == \"static lib_a dynamic lib_b /usr/local/lib/example.so\"\n", "\nassert generate_library_d... |
dbc7011f4ebb530ebdaa4f70ec8d4c4e | [
{
"content": "Tu participes à une compétition de synthèse de modèles de réseaux neuronaux. On te fournit deux ensembles de modèles pré-entraînés, `content_models` et `style_models`, chacun contenant des modèles de différentes échelles mais partageant la même architecture. Les `content_models` sont entraînés pou... | ["\nassert len(swap_weights([nn.Linear(10, 10)], [nn.Linear(10, 10)])) == 1\n", "\nassert swap_weights([nn.Linear(10, 10)], [nn.Linear(10, 10)])[0].children().__iter__().__next__().weight is not swap_weights([nn.Linear(10, 10)], [nn.Linear(10, 10)])[0].children().__iter__().__next__().weight\n", "\nassert swap_weights(... |
b53b63c6f5b921ed382a00b255edea59 | [
{
"content": "On te donne une pression fixe \\( P_0 \\), un nombre fixe de moles \\( n \\) et la constante des gaz \\( R \\). Ta tâche est de mettre en œuvre une fonction qui calcule la température idéale du gaz pour une liste de volumes spécifiques \\( V_s \\). La loi des gaz parfaits est définie comme \\( PV ... | ["\nassert calculate_temperatures(101325, 1, 8.314, [10, 20, 30]) == [12185.340312701859, 6092.67015635093, 4061.78005090062]\n", "\nassert calculate_temperatures(100, 2, 8.314, [5, 10, 15]) == [48.12254237288135, 24.061271186440677, 16.04084745762712]\n", "\nassert calculate_temperatures(200, 1, 8.314, [1, 2, 3]) == [... |
b80d4fba3e1d1573548c9b13cf2b0c1a | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `find_longest_substring(s)` qui renvoie la plus longue sous-chaîne sans caractères répétés. Si plusieurs sous-chaînes ont la même longueur maximale, renvoie la première rencontrée. La fonction doit gérer les cas... | ["\nassert find_longest_substring(\"dvdf\") == \"vdf\"\n", "\nassert find_longest_substring(\"anviaj\") == \"anviaj\"\n", "\nassert find_longest_substring(\"abcabcbb\") == \"abc\"\n", "\nassert find_longest_substring(\"bbbbb\") == \"b\"\n", "\nassert find_longest_substring(\"pwwkew\") == \"wke\"\n", "\nassert find_long... |
88d5fa11545a5531c3ffa100486b9921 | [
{
"content": "On te donne une fonction JavaScript qui calcule l'indice de masse corporelle (IMC) en fonction du poids et de la taille d'une personne. Ta tâche est de réécrire cette fonction en Python tout en conservant sa fonctionnalité. L'IMC est calculé à l'aide de la formule : IMC = poids / (taille * taille)... | ["\nassert calculate_bmi(70, 1.75) == 22.857142857142858\n", "\nassert calculate_bmi(50, 1.6) == 19.53125\n", "\nassert calculate_bmi(80, 1.8) == 24.691358024691358\n", "\nassert calculate_bmi(100, 2) == 25.0\n", "\nassert calculate_bmi(60, 1.7) == 20.761245674740486\n", "\nassert calculate_bmi(0, 1.75) == 0.0\n", "\na... |
6db7513224a2a695faeb6ea1efd71ccf | [
{
"content": "Dans un système de stockage dans le cloud, tu as pour tâche de générer des URL pour les conteneurs de blobs au sein de divers comptes de stockage. Étant donné une liste de tuples, où chaque tuple consiste en un nom de compte de stockage et une liste de ses noms de conteneurs de blobs, écris une fo... | ["\nassert generate_blob_container_urls([]) == {}\n", "\nassert generate_blob_container_urls([(\"account1\", [\"container1\"])]) == {\"container1\": \"https://account1.blob.core.windows.net/container1\"}\n", "\nassert generate_blob_container_urls([(\"account1\", [\"container1\", \"container2\"])]) == {\"container1\": \... |
286871a27b723b56a34a70f731f59950 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `sum_of_squares` qui calcule la somme des carrés des entiers dans la liste. Pour optimiser la fonction, tu dois éliminer l'utilisation de boucles explicites et utiliser plutôt une approche plus efficace.\n\n**Entrée :**\n- Un... | ["\nassert sum_of_squares([1, 2, 3, 4]) == 30\n", "\nassert sum_of_squares([0, 0, 0]) == 0\n", "\nassert sum_of_squares([-1, -2, -3]) == 14\n", "\nassert sum_of_squares([10, 20, 30]) == 1400\n", "\nassert sum_of_squares([1.5, 2.5, 3.5]) == 21.25\n", "\nassert sum_of_squares([]) == 0\n", "\nassert sum_of_squares([5]) ==... |
6bef3ae1406de22b8219ece83fc700a9 | [
{
"content": "Tu développes une application de chat qui nécessite la gestion d'une liste de noms d'utilisateur uniques. Implémente un mécanisme thread-safe pour gérer les enregistrements d'utilisateurs concurrents. Chaque tentative d'enregistrement doit vérifier si le nom d'utilisateur est déjà pris et l'ajoute... | ["\nassert isinstance(UsernameRegistry().usernames, set)\n", "\nassert UsernameRegistry().register_username(\"user1\") == True\n", "\nassert UsernameRegistry().register_username(\"user1\") == False\n", "\nassert UsernameRegistry().register_username(\"user2\") == True\n", "\nassert UsernameRegistry().register_username(\... |
2238e6f693da40f692977663fcc3281a | [
{
"content": "Tu es chargé d'implémenter une fonction `convert_to_color` qui traite une chaîne de caractères représentant un nom de couleur et renvoie sa forme canonique. La fonction doit reconnaître les noms de couleurs primaires suivants : 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta', 'black' et 'white... | ["\nassert convert_to_color('red') == 'red'\n", "\nassert convert_to_color('GREEN') == 'green'\n", "\nassert convert_to_color('Blue') == 'blue'\n", "\nassert convert_to_color('YELLOW') == 'yellow'\n", "\nassert convert_to_color('CYAN') == 'cyan'\n", "\nassert convert_to_color('aqua') == 'cyan'\n", "\nassert convert_to_... |
68d64a8182a9a79c23e53834cf4b3393 | [
{
"content": "On te donne une liste de vecteurs de sortie provenant d'un réseau de neurones (NN) qui classifie des images en deux catégories : chats et chiens. Chaque vecteur de sortie est un tableau unidimensionnel de longueur 2, où le premier élément représente la probabilité que l'image soit un chat, et le d... | ["\nassert compute_confidence([[0.9, 0.1]]) == [0.8]\n", "\nassert compute_confidence([[0.5, 0.5]]) == [0.0]\n", "\nassert compute_confidence([[0.7, 0.3]]) == [0.6]\n", "\nassert compute_confidence([[0.01, 0.01]]) == [0.98]\n", "\nassert compute_confidence([[0.0, 0.0]]) == [1.0]\n", "\nassert compute_confidence([[0.25,... |
0a90b71f608f660b5b3fe9ee05f0f055 | [
{
"content": "Tu participes à une compétition de vision par ordinateur où l'on te fournit un modèle de classification d'images pré-entraîné utilisant PyTorch. Le modèle produit un tenseur de probabilités pour chaque classe étant donné une image en entrée. Ta tâche est de mettre en œuvre une fonction qui calcule... | ["\nassert topk_accuracy(torch.tensor([[0.1, 0.2, 0.7], [0.6, 0.2, 0.2], [0.1, 0.8, 0.1]]), torch.tensor([2, 0, 1]), (1, 2)) == {1: 33.33333333333333, 2: 66.66666666666666}\n", "\nassert topk_accuracy(torch.tensor([[0.9, 0.1], [0.2, 0.8], [0.3, 0.7]]), torch.tensor([0, 1, 1]), (1,)) == {1: 100.0}\n", "\nassert topk_acc... |
22fca3d60de57a9881195ae735b62b01 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `count_adjacent_sums(numbers)` qui renvoie le nombre de paires d'entiers adjacents dans la liste dont la somme est paire, en excluant toute paire où l'un des entiers est un multiple de 3.\n\n**Entrée :**\n- Une liste d'entier... | ["\nassert count_adjacent_sums([1, 2, 3, 4, 5, 6, 7, 8, 9]) == 3\n", "\nassert count_adjacent_sums([2, 4, 6, 8, 10]) == 4\n", "\nassert count_adjacent_sums([1, 3, 5, 7, 9]) == 0\n", "\nassert count_adjacent_sums([3, 6, 9, 12, 15]) == 0\n", "\nassert count_adjacent_sums([2, 3, 4, 5, 6]) == 1\n", "\nassert count_adjacent... |
4dbeb96bf74613163600d63bbacc5f8b | [
{
"content": "On te demande d'implémenter une fonction `fib_evens(n)` qui calcule le n-ième nombre de Fibonacci pair en temps logarithmique. 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. Les nombres de Fibonacci pairs sont ceux de la suite de Fibonacci... | ["\nassert fib_evens(1) == 0\n", "\nassert fib_evens(2) == 2\n", "\nassert fib_evens(3) == 8\n", "\nassert fib_evens(4) == 34\n", "\nassert fib_evens(5) == 144\n", "\nassert fib_evens(6) == 610\n", "\nassert fib_evens(7) == 2584\n", "\nassert fib_evens(8) == 10946\n", "\nassert fib_evens(9) == 46368\n", "\nassert fib_e... |
163a248546e219d006f38949365878c8 | [
{
"content": "On te donne un tuple `t` de `n` entiers et un entier `k`. Ta tâche est d'implémenter une fonction `rotate_tuple(t, k)` qui fait pivoter les éléments du tuple `t` vers la droite de `k` positions. Si `k` est négatif, la rotation doit se faire vers la gauche. La rotation doit être effectuée en utilis... | ["\nassert rotate_tuple((1, 2, 3, 4, 5), 2) == (4, 5, 1, 2, 3)\n", "\nassert rotate_tuple((1, 2, 3, 4, 5), -1) == (5, 1, 2, 3, 4)\n", "\nassert rotate_tuple((1, 2, 3, 4, 5), 5) == (1, 2, 3, 4, 5)\n", "\nassert rotate_tuple((1, 2, 3, 4, 5), 0) == (1, 2, 3, 4, 5)\n", "\nassert rotate_tuple((1, 2, 3, 4, 5), -5) == (1, 2, ... |
f78332a95356c75dd3d0ef51740499ff | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'un nom de produit et de son prix correspondant. Ta tâche est de mettre en œuvre une fonction `sort_products_by_price(products)` qui trie la liste de tuples par ordre croissant en fonction du prix. Tu dois implémenter l'algorithme de tr... | ["\nassert sort_products_by_price([(\"apple\", 1.2), (\"banana\", 0.5), (\"orange\", 0.8), (\"pear\", 1.0)]) == [(\"banana\", 0.5), (\"orange\", 0.8), (\"pear\", 1.0), (\"apple\", 1.2)]\n", "\nassert sort_products_by_price([(\"grape\", 2.0), (\"kiwi\", 1.5)]) == [(\"kiwi\", 1.5), (\"grape\", 2.0)]\n", "\nassert sort_pr... |
a4dfcd8ca74fc1cce27fe57f2ae437f1 | [
{
"content": "On te donne un fichier contenant jusqu'à 1 million de lignes de données. Chaque ligne consiste en une paire séparée par une virgule, contenant le nom d'un animal et son poids. Ta tâche est d'écrire un programme qui lit ce fichier et renvoie un dictionnaire où chaque clé est le nom d'un animal et l... | ["\nassert read_animal_weights(\"test1.txt\") == {\"Dog\": 10.0, \"Cat\": 5.0}\n", "\nassert read_animal_weights(\"test2.txt\") == {\"Elephant\": 5000.0, \"Lion\": 200.0, \"Tiger\": 180.0}\n", "\nassert read_animal_weights(\"test3.txt\") == {\"Dog\": 12.5, \"Cat\": 6.0}\n", "\nassert read_animal_weights(\"test4.txt\") ... |
8e9712e19a17625c93a37da7a61a87ee | [
{
"content": "On te donne un entier non négatif `number` et un entier `base` (2 ≤ base ≤ 36). Ta tâche est d'écrire une fonction `convert_to_base(number, base)` qui renvoie une chaîne de caractères représentant le nombre dans la base spécifiée. Pour les bases supérieures à 10, utilise des chiffres et des lettre... | ["\nassert convert_to_base(0, 2) == \"0\"\n", "\nassert convert_to_base(10, 2) == \"1010\"\n", "\nassert convert_to_base(255, 16) == \"FF\"\n", "\nassert convert_to_base(12345, 10) == \"12345\"\n", "\nassert convert_to_base(1, 36) == \"1\"\n", "\nassert convert_to_base(35, 36) == \"Z\"\n", "\nassert convert_to_base(123... |
b577f30fca7c9775fe74be5b424a69a3 | [
{
"content": "On te demande d'implémenter une fonction `calculate_factorial` qui calcule la factorielle d'un entier non négatif `n`. Ta fonction doit gérer les entrées invalides en levant une exception `ValueError` avec le message \"Input must be a non-negative integer\".\n\n**Entrée :**\n- Un seul entier `n`.\... | ["\nassert calculate_factorial(0) == 1\n", "\nassert calculate_factorial(1) == 1\n", "\nassert calculate_factorial(5) == 120\n", "\nassert calculate_factorial(10) == 3628800\n", "\nassert calculate_factorial(3) == 6\n", "\nassert calculate_factorial(7) == 5040\n", "\nassert calculate_factorial(15) == 1307674368000\n", ... |
6394574ae2fba161162a7da3a9bcb752 | [
{
"content": "On te demande d'implémenter un jeu de devinettes de nombres. Le programme doit générer un entier aléatoire entre 1 et 100 (inclus) et demander à l'utilisateur de deviner ce nombre. Après chaque devinette, le programme doit fournir un retour d'information indiquant si la devinette est trop petite, ... | ["\nassert number_guessing_game([\"50\", \"75\", \"88\", \"92\", \"100\"]) == [\"Too low! Try again.\", \"Too low! Try again.\", \"Too low! Try again.\", \"Too low! Try again.\", \"Congratulations! You've guessed the number 100 correctly in 5 attempts.\"]\n", "\nassert number_guessing_game([\"100\", \"99\", \"98\", \"9... |
a709f74c19fd16cb7defc1b369cf74bd | [
{
"content": "On te donne une liste d'entiers distincts. Ta tâche est d'écrire une fonction récursive en Python qui génère toutes les permutations possibles de la liste. La fonction doit renvoyer une liste de listes, où chaque liste interne est une permutation unique de la liste d'entrée.\n\n**Entrée :**\n- Une... | ["\nassert permute([1, 2, 3]) == [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 2, 1], [3, 1, 2]]\n", "\nassert permute([1]) == [[1]]\n", "\nassert permute([]) == [[]]\n", "\nassert permute([0, 1]) == [[0, 1], [1, 0]]\n", "\nassert permute([1, 2, 3, 4]) == [[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2], [1, ... |
5ec1387422c7855f95a8a1c28cb2c127 | [
{
"content": "On te donne un ensemble de données représentant la croissance d'une colonie bactérienne au fil du temps. L'ensemble de données est fourni sous forme de liste de tuples, où chaque tuple est constitué d'un point temporel et de la taille de population correspondante. Ta tâche est de mettre en œuvre u... | ["\nassert fit_population_growth_curve([(0, 1), (1, 1), (2, 1)]) == (1.0, 1.0, 1.0, 0.0)\n", "\nassert fit_population_growth_curve([(0, 1), (1, 2), (2, 4), (3, 8)]) == (8.0, 1.0, 1.0, 0.0)\n", "\nassert fit_population_growth_curve([(0, 10), (1, 20), (2, 30), (3, 40)]) == (40.0, 10.0, 1.0, 0.0)\n", "\nassert fit_populat... |
f633994c4f395ccd66598e97c93ea63c | [
{
"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 et la casse. Un palindrome est une chaîne qui se lit de la même manière à l'endroit et à l'envers.\n\n**Entrée :**\n- Une seule ligne contenant la chaîne `s` (1 ≤ |s| ≤ 1000... | ["\nassert is_palindrome(\"A man a plan a canal Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw\") == True\n", "\nassert is_palindrome(\"No lemon no melon\") == True\n", "\nassert is_palindrome(\"Hello World\") == False\n", "\nassert is_palind... |
078a5221a41d05a83dd54e00b6af4458 | [
{
"content": "On te donne une liste d'entiers `vals` et deux entiers `min_val` et `max_val`. Ta tâche est de mettre à l'échelle les valeurs dans `vals` vers une nouvelle plage définie par `min_val` et `max_val`. La mise à l'échelle doit être effectuée manuellement sans utiliser de fonctions intégrées de tri ou ... | ["\nassert scale_to_min_max([1, 2, 3, 4, 5], 0, 10) == [0.0, 2.5, 5.0, 7.5, 10.0]\n", "\nassert scale_to_min_max([10, 20, 30, 40, 50], 5, 15) == [5.0, 7.5, 10.0, 12.5, 15.0]\n", "\nassert scale_to_min_max([5, 5, 5, 5], 1, 10) == [1.0, 1.0, 1.0, 1.0]\n", "\nassert scale_to_min_max([], 0, 10) == []\n", "\nassert scale_to... |
2be394da11ca3d9306391c88b156e544 | [
{
"content": "On te donne une liste de mots. Ta tâche est de déterminer le mot le plus long de la liste. S'il y a plusieurs mots de longueur maximale identique, renvoie le premier rencontré.\n\n**Entrée :**\n- Une liste de chaînes de caractères, `words`, où chaque chaîne est composée de lettres anglaises minusc... | ["\nassert find_longest_word([\"apple\", \"banana\", \"cherry\", \"date\"]) == \"banana\"\n", "\nassert find_longest_word([\"dog\", \"cat\"]) == \"dog\"\n", "\nassert find_longest_word([\"hello\", \"world\", \"python\", \"programming\"]) == \"programming\"\n", "\nassert find_longest_word([\"a\", \"ab\", \"abc\", \"abcd... |
36872a213f34e8395d1cdd8c2e2e2cb9 | [
{
"content": "On te donne un tenseur 4-dimensionnel `input_tensor` de forme `(batch_size, channels, height, width)`. Ta tâche est de rembourrer manuellement ce tenseur sans utiliser la fonction `F.pad`. Le rembourrage est spécifié par un tuple `(pad_left, pad_right, pad_top, pad_bottom)`, qui indique le nombre ... | ["\nassert torch.equal(process_with_custom_padding(torch.tensor([[[[1, 2], [3, 4]]]]), (1, 1, 1, 1)), torch.tensor([[[[0, 0, 0, 0], [0, 1, 2, 0], [0, 3, 4, 0], [0, 0, 0, 0]]]]))\n", "\nassert torch.equal(process_with_custom_padding(torch.tensor([[[[5, 6], [7, 8]]]]), (0, 0, 0, 0)), torch.tensor([[[[5, 6], [7, 8]]]]))\n... |
3ec8ff5c37f09a81a9f92fecf9c9db63 | [
{
"content": "On te donne une chaîne de caractères `s` qui peut contenir des espaces, des tirets et d'autres caractères non alphanumériques. Ta tâche est de convertir cette chaîne en une version modifiée du snake case. Dans cette version modifiée, chaque voyelle de la chaîne snake case résultante doit être remp... | ["\nassert convert_to_snake_case(\"Hello-World--This_is-a_test-String\") == \"h1ll15_w15rld_th15s_15_t35t_str15ng\"\n", "\nassert convert_to_snake_case(\"Python Programming\") == \"pyth1n_pr1gr4mm1ng\"\n", "\nassert convert_to_snake_case(\"a e i o u A E I O U\") == \"1_5_9_15_21_1_5_9_15_21\"\n", "\nassert convert_to_s... |
74fbaece2069d5f45e381c17c6edf32e | [
{
"content": "On te donne une liste de dictionnaires, chacun représentant un enregistrement avec diverses attributs. Ta tâche est de mettre en œuvre une fonction qui filtre ces enregistrements en fonction de la valeur d'un attribut spécifique. La fonction doit renvoyer une nouvelle liste contenant uniquement le... | ["\nassert filter_dicts_by_key_value([{\"a\": 10}, {\"a\": 20}, {\"b\": 30}], \"a\", 15) == [{\"a\": 20}]\n", "\nassert filter_dicts_by_key_value([{\"x\": 5}, {\"y\": 10}, {\"z\": 15}], \"x\", 4) == [{\"x\": 5}]\n", "\nassert filter_dicts_by_key_value([{\"value\": 100}, {\"value\": 200}, {\"value\": 300}], \"value\", 1... |
0ce5451ca4a965eee8d0b773a5aad081 | [
{
"content": "On te donne la tâche de simuler les quantités annuelles de précipitations pour une ville en utilisant un générateur de nombres pseudo-aléatoires personnalisé. Implémente la fonction `simulate_rainfall` qui génère une quantité de précipitations aléatoire basée sur une méthode de générateur congruen... | ["\nassert 0 <= simulate_rainfall(100) <= 200\n", "\nassert 0 <= simulate_rainfall(0) <= 0\n", "\nassert 0 <= simulate_rainfall(500) <= 1000\n", "\nassert 0 <= simulate_rainfall(1000) <= 2000\n", "\nassert 0 <= simulate_rainfall(1.5) <= 3\n", "\nassert 0 <= simulate_rainfall(0.1) <= 0.2\n", "\nassert 0 <= simulate_rain... |
69f5e60e00020c9ab474d99d4bfc9ade | [
{
"content": "On te demande d'implémenter une fonction `num_to_month` qui convertit une représentation numérique donnée d'un mois en son nom en majuscules correspondant. La fonction doit gérer les entrées invalides avec élégance en renvoyant un message d'erreur. Ta solution doit être efficace et robuste.\n\n**E... | ["\nassert num_to_month(1) == 'JANUARY'\n", "\nassert num_to_month(12) == 'DECEMBER'\n", "\nassert num_to_month(7) == 'JULY'\n", "\nassert num_to_month(0) == 'Invalid input: Please enter a number between 1 and 12.'\n", "\nassert num_to_month(13) == 'Invalid input: Please enter a number between 1 and 12.'\n", "\nassert ... |
ba5e2559583db7275548778eb8288144 | [
{
"content": "On te donne deux listes de longueur égale, `letters` et `numbers`. La liste `letters` est composée de caractères alphabétiques en minuscules, et la liste `numbers` est composée d'entiers. Ta tâche est de mettre en œuvre une fonction qui renvoie deux nouvelles listes, `filtered_numbers` et `filtere... | ["\nassert filter_most_frequent(['a', 'b', 'c', 'a', 'b', 'a', 'd', 'b', 'c'], [10, 20, 30, 40, 50, 60, 70, 80, 90]) == ([10, 20, 40, 50, 80], ['a', 'b', 'a', 'b', 'b'])\n", "\nassert filter_most_frequent(['x', 'y', 'x', 'y', 'x', 'z'], [1, 2, 3, 4, 5, 6]) == ([1, 3, 5, 2, 4], ['x', 'x', 'x', 'y', 'y'])\n", "\nassert f... |
ebe85d1e1617f7a139f16f1dcff44fc6 | [
{
"content": "On te donne une liste de nombres à virgule flottante `values_list` et un tuple `bounds` représentant les bornes inférieure et supérieure pour la mise à l'échelle de ces valeurs. Ta tâche est de mettre en œuvre la fonction `scale_values(values_list, bounds)` qui met à l'échelle chaque valeur dans `... | ["\nassert scale_values([1.0, 2.0, 3.0, 4.0, 5.0], (0.0, 10.0)) == [0.0, 2.5, 5.0, 7.5, 10.0]\n", "\nassert scale_values([10.0, 20.0, 30.0], (0.0, 100.0)) == [0.0, 50.0, 100.0]\n", "\nassert scale_values([5.0, 15.0, 25.0], (10.0, 20.0)) == [10.0, 15.0, 20.0]\n", "\nassert scale_values([0.0, 100.0], (0.0, 1.0)) == [0.0,... |
88d8a9156a6e051e743ded09d7fb29f7 | [
{
"content": "Tu es chargé d'implémenter une fonction `time_converter` qui convertit un timestamp Unix en un format d'heure locale lisible par l'homme. Le timestamp Unix est un entier représentant le nombre de secondes depuis l'époque Unix (1970-01-01 00:00:00 UTC). Ta fonction doit renvoyer une chaîne formatée... | ["\nassert time_converter(0) == \"00:00 Jan 01\"\n", "\nassert time_converter(60) == \"00:01 Jan 01\"\n", "\nassert time_converter(3600) == \"01:00 Jan 01\"\n", "\nassert time_converter(86400) == \"00:00 Jan 02\"\n", "\nassert time_converter(1609459200) == \"00:00 Jan 01\"\n", "\nassert time_converter(1612137600) == \"... |
73404b82b9f530eea442ecd3e24dd82f | [
{
"content": "On te donne deux entiers `n` et `k`. Ta tâche est de générer toutes les combinaisons possibles de `k` nombres distincts choisis dans l'intervalle `[1, n]`. Les combinaisons doivent être renvoyées sous forme de liste de listes, où chaque liste interne représente une combinaison unique. L'ordre des ... | ["\nassert generate_combinations(4, 2) == [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n", "\nassert generate_combinations(5, 3) == [[1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 3, 5], [1, 4, 5], [2, 3, 4], [2, 3, 5], [2, 4, 5], [3, 4, 5]]\n", "\nassert generate_combinations(3, 1) == [[1], [2], [3]]\n", "\nasser... |
bf753deffbacd4e3faf69b7d741a5f6b | [
{
"content": "On te donne une liste de chaînes de caractères, chacune représentant un chemin de fichier. Ta tâche est de déterminer la validité de chaque chemin de fichier en fonction de son existence dans le système de fichiers. Un chemin de fichier est valide si le fichier ou le répertoire correspondant exist... | ["\nassert check_file_paths_validity(['/']) == {'/': True}\n", "\nassert check_file_paths_validity(['']) == {'': False}\n", "\nassert check_file_paths_validity(['nonexistentfile.txt']) == {'nonexistentfile.txt': False}\n", "\nassert check_file_paths_validity(['.', '..']) == {'.': True, '..': True}\n", "\nassert check_f... |
a4fd1cb094e83eb6f0a49557ef832bb4 | [
{
"content": "On te donne une chaîne de caractères non vide `s` et une liste de chaînes de caractères non vides `wordDict`. Ta tâche est de déterminer toutes les façons possibles de segmenter la chaîne `s` en une séquence séparée par des espaces d'un ou plusieurs mots du dictionnaire. La fonction doit renvoyer ... | ["\nassert wordBreak(\"leetcode\", [\"leet\", \"code\"]) == [\"leet code\"]\n", "\nassert wordBreak(\"applepenapple\", [\"apple\", \"pen\"]) == [\"apple pen apple\"]\n", "\nassert wordBreak(\"catsanddog\", [\"cat\", \"cats\", \"and\", \"sand\", \"dog\"]) == [\"cat sand dog\", \"cats and dog\"]\n", "\nassert wordBreak(\... |
7c4fe11bc686e07b7c8fc02607e4ed7c | [
{
"content": "Tu es chargé d'implémenter une fonction `encrypt_message` qui chiffre un message donné. Le processus de chiffrement consiste à décaler chaque caractère alphabétique d'une valeur déterminée par sa position dans la suite de Fibonacci, en commençant par le troisième terme (où le premier terme est 0 e... | ["\nassert encrypt_message(\"abc\") == \"bdf\"\n", "\nassert encrypt_message(\"Hello, World!\") == \"Jgnnq, Yqtnf!\"\n", "\nassert encrypt_message(\"xyz\") == \"zab\"\n", "\nassert encrypt_message(\"ABC\") == \"BDF\"\n", "\nassert encrypt_message(\"XYZ\") == \"ZAB\"\n", "\nassert encrypt_message(\"a\") == \"b\"\n", "\n... |
605761df1f156f9bca8f027e5800ad36 | [
{
"content": "Tu es chargé d'implémenter une fonction `sum_of_squares` qui calcule la somme des carrés des `n` premiers nombres naturels. La fonction doit accepter un entier `n` et renvoyer la somme des carrés de 1 à `n`. Si `n` est inférieur à 1, la fonction doit renvoyer 0.\n\n**Entrée :**\n- Un entier `n` (o... | ["\nassert sum_of_squares(3) == 14\n", "\nassert sum_of_squares(5) == 55\n", "\nassert sum_of_squares(-1) == 0\n", "\nassert sum_of_squares(0) == 0\n", "\nassert sum_of_squares(1) == 1\n", "\nassert sum_of_squares(10) == 385\n", "\nassert sum_of_squares(100) == 338350\n", "\nassert sum_of_squares(1000) == 333833500\n",... |
1cd2f834f40a9bd88a877fb7006d827e | [
{
"content": "Implémente une classe Python `Car` avec les spécifications suivantes :\n\n- **Attributs :**\n - `make` : Une chaîne de caractères représentant la marque de la voiture.\n - `model` : Une chaîne de caractères représentant le modèle de la voiture.\n - `year` : Un entier représentant l'année de fab... | ["\nassert my_car.make == 'Toyota'\n", "\nassert my_car.model == 'Corolla'\n", "\nassert my_car.year == 2020\n", "\nassert my_car.color == 'Red'\n", "\nassert my_car.odometer_reading == 0\n", "\nmy_car.update_color('Blue'); assert my_car.color == 'Blue'\n", "\nmy_car.drive(150); assert my_car.odometer_reading == 150\n"... |
8ede2fb15fd94523414e776a1a1bcdeb | [
{
"content": "Tu es chargé d'analyser un ensemble de données de ventes de produits. L'ensemble de données est représenté sous forme de DataFrame pandas avec les colonnes suivantes : `product_name`, `quantity_sold` et `sale_price_per_unit`. Ton objectif est de calculer le revenu total généré par chaque produit. ... | ["\nassert calculate_total_revenue(pd.DataFrame({'product_name': ['A', 'B', 'A', 'C', 'B'], 'quantity_sold': [10, 5, 3, 8, 7], 'sale_price_per_unit': [100, 150, 95, 75, 130]})).equals(pd.DataFrame({'product_name': ['A', 'B', 'C'], 'total_revenue': [1335, 1525, 600]}))\n", "\nassert calculate_total_revenue(pd.DataFrame(... |
03a0a01a579dc63ed1394ee668beaefb | [
{
"content": "Tu participes à un concours de programmation où l'on te donne une liste d'entiers représentant les scores de divers éléments. Ton objectif est de calculer les probabilités softmax normalisées L2 de ces scores. La norme L2 d'un vecteur est définie comme la racine carrée de la somme des carrés de se... | ["\nassert l2_normalized_softmax([1, 2, 3]) == [0.18807936507936508, 0.5021894894354067, 0.8137311454852287]\n", "\nassert l2_normalized_softmax([0, 0, 0]) == [0.5773502691896257, 0.5773502691896257, 0.5773502691896257]\n", "\nassert l2_normalized_softmax([10, 10, 10]) == [0.5773502691896257, 0.5773502691896257, 0.5773... |
4ff80182ef2b5f375bc338b2aef8629c | [
{
"content": "On te demande d'implémenter une fonction `format_phone_number(phone_number)` qui traite une chaîne de caractères représentant un numéro de téléphone. La fonction doit supprimer tous les caractères non numériques de la chaîne d'entrée et formater la chaîne résultante dans le format standard de numé... | ["\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_... |
6d5a9fcbebc229056ccb3fadbac234b7 | [
{
"content": "On te demande d'implémenter une fonction `convert_to_int(input_str, base=10, custom_chars=None)` qui convertit une chaîne de caractères donnée `input_str` en un entier en fonction de la `base` spécifiée. La fonction doit gérer les scénarios suivants :\n\n1. Si `input_str` est une chaîne vide et qu... | ["\nassert convert_to_int(\"10\", 2) == 2\n", "\nassert convert_to_int(\"1a\", 16) == 26\n", "\nassert convert_to_int(\"z\", 36) == 35\n", "\nassert convert_to_int(\"10\", 2, {\"1\": 0, \"0\": 1}) == 2\n", "\nassert convert_to_int(\"\", 10) == 0\n", "\nassert convert_to_int(\"\", 2) == 0\n", "\nassert convert_to_int(\"... |
56b01c8671e900ac434c2deb825c4b7d | [
{
"content": "Tu participes à un concours de programmation où tu dois implémenter une fonction en Python qui interagit avec une API REST pour récupérer et analyser des données JSON. Ta tâche est de créer une fonction nommée `list_containers` qui prend deux paramètres : `api` et `num_threads`. Le paramètre `api`... | ["\nassert list_containers(api, num_threads=1) == [{'Id': '123', 'Names': ['/container1']}, {'Id': '456', 'Names': ['/container2']}]\n", "\nassert list_containers(api, num_threads=3) == [{'Id': '123', 'Names': ['/container1']}, {'Id': '456', 'Names': ['/container2']}]\n", "\nassert list_containers(api, num_threads=5) =... |
e1bccf6283e6ff891fc00f6e1e0dc57b | [
{
"content": "On te donne un DataFrame Pandas `df` avec diverses colonnes de données. Ta tâche est de mettre en œuvre une fonction `transform_data` qui effectue les opérations suivantes sur une colonne spécifiée :\n\n1. Ajouter une valeur constante à chaque élément de la colonne.\n2. Calculer le logarithme natu... | ["\nassert transform_data(pd.DataFrame({'inactive_days': [10, 20, 0, None, 30]}), 'inactive_days', constant=5, return_df=False).equals(pd.Series([2.397895, 2.995732, 1.609438, 2.484907, 3.401197]))\n", "\nassert transform_data(pd.DataFrame({'inactive_days': [10, 20, 0, None, 30]}), 'inactive_days', constant=5, new_col_... |
3ce038b349f8ebb71d597188e62aded2 | [
{
"content": "On te donne une liste d'entiers non négatifs. Ta tâche est d'écrire une fonction Python qui identifie et renvoie le premier nombre qui apparaît un nombre impair de fois dans la liste. Il est garanti qu'il y a au moins un tel nombre.\n\n**Exemple d'entrée :**\n```\n[1, 2, 3, 2, 3, 1, 3]\n```\n\n**E... | ["\nassert find_odd_occurrence([1, 2, 3, 2, 3, 1, 3]) == 3\n", "\nassert find_odd_occurrence([4, 1, 2, 2, 5, 1, 4]) == 5\n", "\nassert find_odd_occurrence([10, 10, 10]) == 10\n", "\nassert find_odd_occurrence([1, 1, 2, 2, 3, 3, 4, 4, 5]) == 5\n", "\nassert find_odd_occurrence([7, 7, 7, 7, 7]) == 7\n", "\nassert find_od... |
d5b5ba4c9817c11d19150e8f5bf764ee | [
{
"content": "On te donne une grille 2D de taille `rows x cols` où chaque cellule est soit vide (0) soit contient un obstacle (1). Un robot démarre à un point de départ donné `(start_x, start_y)` et doit atteindre un point de destination spécifique `(destination_x, destination_y)`. Le robot peut se déplacer ver... | ["\nassert shortestPath([[0, 0, 0], [0, 0, 0], [0, 0, 0]], (0, 0), (2, 2)) == ['D', 'D', 'R', 'R']\n", "\nassert shortestPath([[0, 1, 0], [0, 1, 0], [0, 0, 0]], (0, 0), (2, 2)) == ['D', 'D', 'R', 'R']\n", "\nassert shortestPath([[0, 0, 0], [0, 1, 0], [0, 0, 0]], (0, 0), (0, 2)) == ['R', 'R']\n", "\nassert shortestPath(... |
483c3b9b2e9891fa812a5130e019b0c7 | [
{
"content": "On te donne une chaîne de caractères `s` et une liste de motifs `patterns`. Ta tâche est de mettre en œuvre une fonction `find_occurrences(s, patterns)` qui renvoie un dictionnaire. Chaque clé du dictionnaire doit être un motif de `patterns`, et sa valeur correspondante doit être une liste de tous... | ["\nassert find_occurrences(\"abababa\", [\"aba\", \"bab\"]) == {\"aba\": [0, 2, 4], \"bab\": [1, 3]}\n", "\nassert find_occurrences(\"aaaa\", [\"aa\"]) == {\"aa\": [0, 1, 2]}\n", "\nassert find_occurrences(\"abcabcabc\", [\"abc\", \"cab\"]) == {\"abc\": [0, 3, 6], \"cab\": [2, 5]}\n", "\nassert find_occurrences(\"miss... |
d5bfde24c5e2b123f7cd0a44ff4e9452 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui calcule la moyenne, la médiane, le mode, l'écart type et la variance de la liste. La fonction doit afficher ces statistiques dans le format spécifié.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ ... | ["\nassert calculate_statistics([1, 2, 2, 3, 4]) == None\n", "\nassert calculate_statistics([1, 1, 1, 1, 1]) == None\n", "\nassert calculate_statistics([10, 20, 30, 40, 50]) == None\n", "\nassert calculate_statistics([5, 5, 5, 5, 5, 5, 5, 5, 5, 5]) == None\n", "\nassert calculate_statistics([1, 2, 3, 4, 5, 6, 7, 8, 9, ... |
b244731d520acf53221eba9aa394bf09 | [
{
"content": "On te donne un arbre binaire où chaque nœud contient une valeur entière. Ta tâche est de trouver la somme maximale du chemin entre deux nœuds quelconques dans l'arbre. Le chemin peut commencer et se terminer à n'importe quel nœud et ne passe pas nécessairement par la racine.\n\n**Entrée :**\n- L'e... | ["\nassert maxPathSum(TreeNode(1)) == 1\n", "\nassert maxPathSum(TreeNode(-10)) == -10\n", "\nassert maxPathSum(TreeNode(10)) == 10\n", "\nassert maxPathSum(TreeNode(2) if (TreeNode(2).left := TreeNode(-1)) else None) == 2\n", "\nassert maxPathSum(TreeNode(1) if (TreeNode(1).left := TreeNode(2), TreeNode(1).right := Tr... |
bc21f81e3b1c5082628451fc8ecb9a15 | [
{
"content": "Tu as pour tâche de traiter un fichier CSV nommé \"employees.csv\" qui contient des données sur les employés d'une entreprise. Chaque ligne du fichier représente un employé et comprend les colonnes suivantes : \"ID\", \"First Name\", \"Last Name\", \"Position\", \"Department\" et \"Salary\".\n\nTo... | ["\nassert get_employee_data(\"nonexistentfile.csv\") == []\n", "\nassert get_employee_data(\"employees.csv\") == [{'73100': '1', '70111115116327897109101': 'John', '7697115116327897109101': 'Doe', '8011111510574111110': 'Software Engineer', '686970617274656d656e74': 'Engineering', '83616c617279': '75000'}] if os.path.... |
1270249c67ed06c8384c28ee239f1a7c | [
{
"content": "Tu es chargé de traiter une série d'enregistrements de journal. Chaque enregistrement de journal est représenté comme un tuple constitué d'un niveau de journal entier et d'un message de journal chaîne de caractères. Le message de journal inclut un horodatage au format \"AAAA-MM-JJ HH:MM:SS\" suivi... | ["\nassert filter_logs_by_logger(log_records, \"my_logger\") == [(1, \"2023-10-01 10:00:00 my_logger INFO This is an info message\"), (3, \"2023-10-01 10:02:00 my_logger ERROR This is an error message\")]\n", "\nassert filter_logs_by_logger(log_records, \"another_logger\") == [(2, \"2023-10-01 10:01:00 another_logger W... |
6c6c0114a4fc32eb4b50bf8615396d8a | [
{
"content": "On te donne un tableau représenté comme une liste de listes, où chaque liste interne correspond à une ligne du tableau. Ta tâche est de formater ce tableau de telle sorte que toutes les valeurs de chaque colonne soient alignées à droite et séparées par un caractère de tabulation. La sortie doit êt... | ["\nassert format_table([['Name', 'Age'], ['Alice', '30'], ['Bob', '25']]) == \"Name\\t Age\\nAlice\\t 30\\nBob\\t 25\"\n", "\nassert format_table([['X', 'Y'], ['1', '22'], ['333', '4444']]) == \" X\\t Y\\n 1\\t 22\\n333\\t4444\"\n", "\nassert format_table([['A', 'B', 'C'], ['1', '2', '3'], ['44', '555', '6666']]... |
fcd6efa16b9d1bf9ca7c2faa4ede76e3 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction `filter_even_numbers(numbers)` qui traite cette liste et renvoie une nouvelle liste contenant uniquement les entiers pairs de la liste originale. Tu n'es pas autorisé à utiliser des fonctions intégrées qui filtrent les élément... | ["\nassert filter_even_numbers([1, 2, 3, 4, 5, 6]) == [2, 4, 6]\n", "\nassert filter_even_numbers([10, 15, 20, 25, 30]) == [10, 20, 30]\n", "\nassert filter_even_numbers([0, -2, -4, -5, -6]) == [0, -2, -4, -6]\n", "\nassert filter_even_numbers([]) == []\n", "\nassert filter_even_numbers([1, 3, 5, 7, 9]) == []\n", "\nas... |
59e50fa801fd3c9be900d235d25db392 | [
{
"content": "Dans ce problème, tu dois implémenter une fonction pour générer la suite de Fibonacci. La suite de Fibonacci est une série de nombres où chaque nombre est la somme des deux nombres précédents, généralement en commençant par 0 et 1. Ta fonction, `generate_fibonacci_sequence(n)`, doit renvoyer une l... | ["\nassert generate_fibonacci_sequence(0) == []\n", "\nassert generate_fibonacci_sequence(1) == [0]\n", "\nassert generate_fibonacci_sequence(2) == [0, 1]\n", "\nassert generate_fibonacci_sequence(3) == [0, 1, 1]\n", "\nassert generate_fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert generate_fibonacci_sequence(1... |
a55250e64bf872ae606cbf67132a7a52 | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente les coordonnées d'un point dans un plan 2D. Ta tâche est d'écrire une fonction Python qui identifie et renvoie le tuple de coordonnées qui est le plus proche de l'origine (0, 0). La distance entre deux points \\((x_1, y_1)\\) et \\((x_2, ... | ["\nassert closest_to_origin([(3, 4), (1, 2), (0, 0), (-2, -2)]) == (0, 0)\n", "\nassert closest_to_origin([(1, 1), (2, 2), (3, 3)]) == (1, 1)\n", "\nassert closest_to_origin([(5, 12), (2, 2), (3, 4)]) == (2, 2)\n", "\nassert closest_to_origin([(0, 0), (10, 10), (-10, -10)]) == (0, 0)\n", "\nassert closest_to_origin([(... |
3487e2bf362a03c93018f85f325adeef | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif `n`. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. Ta fonction doit gérer les cas de base où `n` est 0 ou 1, en renvoyant 1 da... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(2) == 2\n", "\nassert factorial(3) == 6\n", "\nassert factorial(4) == 24\n", "\nassert factorial(5) == 120\n", "\nassert factorial(6) == 720\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factor... |
6f4ff1bdd9d23de7966ddb5360f36407 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ta tâche est d'implémenter une fonction récursive `find_target_index(numbers, target)` qui renvoie l'index de la première occurrence de `target` dans `numbers`. Si `target` n'est pas trouvé dans la liste, renvoie la longueur de la li... | ["\nassert find_target_index([1, 2, 3, 4, 5], 3) == 2\n", "\nassert find_target_index([1, 2, 3, 4, 5], 6) == 5\n", "\nassert find_target_index([], 1) == 0\n", "\nassert find_target_index([10, 20, 30, 40, 50], 10) == 0\n", "\nassert find_target_index([10, 20, 30, 40, 50], 50) == 4\n", "\nassert find_target_index([5, 5, ... |
ad7a7e570baec73ba9bf678b05295b1a | [
{
"content": "On te donne une liste d'éléments distincts. Ta tâche est d'écrire une fonction Python qui génère toutes les combinaisons possibles de ces éléments, y compris la combinaison vide. La fonction doit renvoyer une liste de listes, où chaque liste interne représente une combinaison unique. L'ordre des c... | ["\nassert all_combinations(['a', 'b', 'c']) == [[], ['a'], ['b'], ['c'], ['a', 'b'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']]\n", "\nassert all_combinations(['x', 'y']) == [[], ['x'], ['y'], ['x', 'y']]\n", "\nassert all_combinations([]) == [[]]\n", "\nassert all_combinations(['single']) == [[], ['single']]\n", "\nass... |
d8f34d06f62ef0e0bf5ad118b1dceba0 | [
{
"content": "On te donne une liste d'incidents criminels, chacun représenté comme un dictionnaire avec les clés 'crime_type', 'date' et 'location'. Ta tâche est d'écrire une fonction qui filtre les incidents qui se sont produits les week-ends (samedi ou dimanche) et compte le nombre d'incidents de cambriolage.... | ["\nassert count_burglary_incidents([{'crime_type': 'Burglary', 'date': '2023-10-01', 'location': 'Store A'}]) == 1\n", "\nassert count_burglary_incidents([{'crime_type': 'Burglary', 'date': '2023-10-07', 'location': 'Store A'}]) == 0\n", "\nassert count_burglary_incidents([{'crime_type': 'Robbery', 'date': '2023-10-01... |
06cfd1ee7bb4f8fa574106c640959351 | [
{
"content": "On te donne un fichier CSV nommé `data.csv` situé dans le même répertoire que ton script. La première ligne du fichier CSV contient les en-têtes de colonnes. Ta tâche est d'écrire un script Python qui lit ce fichier et calcule la moyenne de chaque colonne contenant des données numériques. Pour cha... | ["\nassert calculate_column_averages('test_data_1.csv') == None # Assuming test_data_1.csv has columns with numerical data\n", "\nassert calculate_column_averages('test_data_2.csv') == None # Assuming test_data_2.csv has mixed data types\n", "\nassert calculate_column_averages('test_data_3.csv') == None # Assuming t... |
6c0f10aabf925e1009ebfe8bea75999a | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence strictement croissante dans cette liste. La sous-séquence doit être renvoyée sous forme de liste d'entiers. Par exemple, pour la liste d'entrée `[3, 4, -1, 0, 6, 2, 3]`, la sortie doit être `[-1, 0, 2, 3]` car c'... | ["\nassert longest_increasing_subsequence([3, 4, -1, 0, 6, 2, 3]) == [-1, 0, 2, 3]\n", "\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 18]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7, 7, ... |
136b947915e901ab786aa020a3370674 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si `s` est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche. Renvoi... | ["\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... |
a8049c634d748c1f3d3c0a40a71530d9 | [
{
"content": "On te donne une valeur `v` et un diviseur `divisible_by`. Ta tâche est d'écrire une fonction `adjust_value` qui renvoie la plus petite valeur entière supérieure ou égale à `v` qui est divisible par `divisible_by`. Si une valeur `min_value` est fournie, la valeur renvoyée doit également être supéri... | ["\nassert adjust_value(1000, 10) == 1000\n", "\nassert adjust_value(900, 10) == 900\n", "\nassert adjust_value(1100, 10) == 1100\n", "\nassert adjust_value(899, 10) == 900\n", "\nassert adjust_value(1101, 10) == 1100\n", "\nassert adjust_value(1050, 100, 1100) == 1100\n", "\nassert adjust_value(950, 50, 1000) == 1000\... |
471c9e3fcc31b1c6bb11216b95bf2c8d | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de trouver la longueur de la plus longue sous-chaîne palindromique dans `s`. Une sous-chaîne palindromique est une sous-chaîne qui se lit de la même manière à l'endroit et à l'envers.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ ... | ["\nassert longest_palindromic_substring_length(\"babad\") == 3\n", "\nassert longest_palindromic_substring_length(\"cbbd\") == 2\n", "\nassert longest_palindromic_substring_length(\"a\") == 1\n", "\nassert longest_palindromic_substring_length(\"ac\") == 1\n", "\nassert longest_palindromic_substring_length(\"racecar\")... |
10637653fc647a7ecf7218b0c4688967 | [
{
"content": "On te donne une liste de chaînes de caractères non vides. Ta tâche est de concaténer ces chaînes en une seule chaîne avec une règle de séparation spécifique. Pour chaque paire de chaînes consécutives, le séparateur doit être un tiret ('-') dont la longueur est égale à la longueur de la chaîne la p... | ["\nassert compress_string([\"hello\", \"world\", \"python\", \"code\"]) == \"hello-world-py-code\"\n", "\nassert compress_string([\"a\", \"bb\", \"ccc\", \"dddd\"]) == \"a-bb-ccc-dddd\"\n", "\nassert compress_string([\"abc\", \"de\", \"fghi\", \"jk\"]) == \"abc-de-fg-hi-jk\"\n", "\nassert compress_string([\"same\", \"... |
49ee2645e453b7b2dddf7f41f6045262 | [
{
"content": "On te demande d'implémenter une fonction `sum_of_squares` qui calcule la somme des carrés de tous les entiers de 1 à `n`, où `n` est un entier positif. Si `n` n'est pas un entier positif, la fonction doit renvoyer `None`. Ta solution doit être efficace et gérer les cas limites de manière approprié... | ["\nassert sum_of_squares(1) == 1\n", "\nassert sum_of_squares(2) == 5\n", "\nassert sum_of_squares(3) == 14\n", "\nassert sum_of_squares(4) == 30\n", "\nassert sum_of_squares(5) == 55\n", "\nassert sum_of_squares(10) == 385\n", "\nassert sum_of_squares(0) == None\n", "\nassert sum_of_squares(-5) == None\n", "\nassert ... |
ff1529a4f1bbdccf741dd0744685db6d | [
{
"content": "On te demande d'implémenter un algorithme efficace pour trouver tous les nombres premiers jusqu'à un entier donné `max_prime`. Ta solution doit utiliser la méthode du crible d'Ératosthène. La fonction doit renvoyer une liste de tous les nombres premiers inférieurs ou égaux à `max_prime`. Si `max_p... | ["\nassert sieve_of_eratosthenes(10) == [2, 3, 5, 7]\n", "\nassert sieve_of_eratosthenes(1) == []\n", "\nassert sieve_of_eratosthenes(2) == [2]\n", "\nassert sieve_of_eratosthenes(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert sieve_of_eratosthenes(0) == []\n", "\nassert sieve_of_eratosthenes(30) == [2, 3, 5, 7, 11,... |
a7d7b6f0fc7031366b639881c971dd7a | [
{
"content": "On te demande de concevoir une API REST en utilisant Flask pour gérer une simple liste de tâches. L'API doit prendre en charge les opérations suivantes :\n\n1. **Ajouter une tâche** : Accepte une charge utile JSON avec une description de la tâche et renvoie l'ID de la tâche et un message de succès... | ["\nassert add_task().status_code == 201\n", "\nassert add_task().json['message'] == \"Task added\"\n", "\nassert get_tasks().status_code == 200\n", "\nassert delete_task(1).status_code == 200\n", "\nassert delete_task(999).status_code == 404\n", "\nassert delete_task(999).json['error'] == \"Task not found\"\n", "\nass... |
eb7822e2d91abd049de53988d22aad38 | [
{
"content": "On te donne la tâche d'implémenter une fonction pour valider les numéros de téléphone internationaux selon la norme E.164. Ta fonction doit prendre une chaîne de caractères en entrée et renvoyer une valeur booléenne indiquant si la chaîne d'entrée est un numéro de téléphone international formaté E... | ["\nassert is_valid_e164(\"+1234567890\") == True\n", "\nassert is_valid_e164(\"+123456789012345\") == True\n", "\nassert is_valid_e164(\"+1234567890123456\") == False\n", "\nassert is_valid_e164(\"1234567890\") == False\n", "\nassert is_valid_e164(\"+123-456-7890\") == False\n", "\nassert is_valid_e164(\"+123 456 7890... |
d6fffe845a965f48cf28f3af44aa2e48 | [
{
"content": "On te donne une liste d'entiers qui peut contenir des éléments en double. Ta tâche est d'écrire une fonction `remove_duplicates` qui renvoie une nouvelle liste avec tous les doublons supprimés, en préservant l'ordre d'apparition original de chaque élément.\n\n**Entrée :**\n- Une liste d'entiers `l... | ["\nassert remove_duplicates([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 2, 2, 3, 3]) == [1, 2, 3]\n", "\nassert remove_duplicates(['a', 'b', 'a', 'c', 'b']) == ['a', 'b', 'c']\n", "\nassert remove_duplicates([True, False, True, True]) == [True, False]\n", "\nassert remove_duplicates([]) ... |
b984e9a89fe5ffdcbfe32f6ac3df51a6 | [
{
"content": "On te charge d'évaluer la faisabilité économique de la rénovation d'un bâtiment existant pour améliorer sa résistance sismique. La décision dépend du calcul du Ratio Coût-Bénéfice (RCB) en utilisant la formule suivante :\n\n\\[ \\text{RCB} = \\frac{(\\text{PALo} - \\text{PALr})(1 - \\exp(-r \\cdot... | ["\nassert calculate_bcr(100000, 50000, 0.05, 20, 500000) == 0.18268347224761286\n", "\nassert calculate_bcr(200000, 100000, 0.03, 30, 1000000) == 0.1395612425482788\n", "\nassert calculate_bcr(150000, 75000, 0.04, 25, 750000) == 0.2049395720708312\n", "\nassert calculate_bcr(50000, 25000, 0.06, 15, 250000) == 0.247464... |
83b602a5e4442f3828c24944845e4a77 | [
{
"content": "On te donne une chaîne de caractères `word` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `rotate_left` qui fait pivoter la chaîne `word` vers la gauche de `n` positions. La fonction ne doit pas utiliser de découpage ou de concaténation de chaînes.\n\n**Entrée :**\n- Une chaîne de... | ["\nassert rotate_left(\"abcdef\", 2) == \"cdefab\"\n", "\nassert rotate_left(\"abcdef\", 6) == \"abcdef\"\n", "\nassert rotate_left(\"abcdef\", 0) == \"abcdef\"\n", "\nassert rotate_left(\"abcdef\", 7) == \"bcdefa\"\n", "\nassert rotate_left(\"hello\", 1) == \"elloh\"\n", "\nassert rotate_left(\"world\", 5) == \"world... |
c6bee2d445d39ceae86c521a32c98e98 | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python. La classe doit avoir les fonctionnalités suivantes :\n\n- Un constructeur qui prend deux paramètres : `width` et `height`.\n- Une méthode `area` qui renvoie l'aire du rectangle.\n- Une méthode `perimeter` qui renvoie le périmètre du rec... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).perimeter() == 20\n", "\nassert Rectangle(0, 0).area() == 0\n", "\nassert Rectangle(10, 2).perimeter() == 24\n", "\nassert Rectangle(7, 3).area() == 21\n", "\nassert Rectangle(1, 1).perimeter() == 4\n", "\nassert Rectangle(15, 10).area() == 150\n", "... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.