id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
648826c944b3cc279932b9b4a395cbc5 | [
{
"content": "On te demande d'implémenter une classe `Bookstore` en Python qui gère une collection de livres. Chaque livre est caractérisé par son titre, son auteur, son prix et sa quantité. Ta classe doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un livre** : Ajouter un nouveau livre à l'inv... | ["\nassert Bookstore().total_inventory_value() == 0\n", "\nassert Bookstore().find_most_expensive_book() is None\n", "\nbookstore = Bookstore()\nbookstore.add_book(Book(\"Book1\", \"Author1\", 10, 2))\nassert bookstore.total_inventory_value() == 20\n", "\nbookstore = Bookstore()\nbookstore.add_book(Book(\"Book1\", \"Au... |
40c7337b5e18820a768bdf2be7766ae3 | [
{
"content": "On te donne un réseau social représenté comme un graphe non orienté avec `N` nœuds (personnes) et `M` arêtes (amitiés). Chaque nœud est identifié de manière unique par un entier de `0` à `N-1`. Ta tâche est de trouver toutes les composantes connexes (cliques) dans le graphe. Une composante connexe... | ["\nassert find_connected_components({0: [1], 1: [0], 2: [3], 3: [2]}) == [{0, 1}, {2, 3}]\n", "\nassert find_connected_components({0: [1, 2], 1: [0, 2], 2: [0, 1]}) == [{0, 1, 2}]\n", "\nassert find_connected_components({0: [], 1: [], 2: []}) == [{0}, {1}, {2}]\n", "\nassert find_connected_components({}) == []\n", "\n... |
45f8e36e0a2910decbaed9bbe0cb1439 | [
{
"content": "On te demande d'implémenter une classe `Matrix` en Python qui prenne en charge les opérations matricielles de base : l'addition, la soustraction et la multiplication. La classe doit gérer correctement les matrices de différentes dimensions en levant une exception `ValueError` avec un message appro... | ["\nassert str(Matrix([[1, 2], [3, 4]]) + Matrix([[2, 0], [1, 2]])) == \"3 2\\n4 6\"\n", "\nassert str(Matrix([[1, 2], [3, 4]]) - Matrix([[2, 0], [1, 2]])) == \"-1 2\\n2 2\"\n", "\nassert str(Matrix([[1, 2], [3, 4]]) * Matrix([[2, 0], [1, 2]])) == \"4 4\\n10 8\"\n", "\nassert str(Matrix([[1, 2, 3], [4, 5, 6]]) * Matrix... |
88477873786e18a66b442a49aa3d065b | [
{
"content": "Tu développes un système de panier d'achat sophistiqué pour une boutique en ligne. Le système doit permettre aux utilisateurs d'ajouter des articles à leur panier et de confirmer s'ils souhaitent ajouter d'autres articles. Les articles du panier doivent être stockés dans une liste doublement chaîn... | ["\nassert CircularDoublyLinkedList().display_cart() is None\n", "\ncdll = CircularDoublyLinkedList()\ncdll.add_item(\"apple\")\nassert cdll.head.data == \"apple\"\n", "\ncdll = CircularDoublyLinkedList()\ncdll.add_item(\"apple\")\ncdll.add_item(\"banana\")\nassert cdll.head.next.data == \"banana\"\n", "\ncdll = Circul... |
6ab01c7a9e126f10d0bd4c73e0cece00 | [
{
"content": "On te demande d'implémenter une classe nommée `Employee` pour gérer les données des employés. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur doit accepter quatre paramètres : `name` (une chaîne de caractères), `id` (un entier), `salary` (... | ["\nassert Employee(\"John Doe\", 123, 50000, \"HR\").name == \"John Doe\"\n", "\nassert Employee(\"Jane Smith\", 456, 60000, \"IT\").id == 456\n", "\nassert Employee(\"Alice Johnson\", 789, 70000, \"Finance\").salary == 70000\n", "\nassert Employee(\"Bob Brown\", 101, 55000, \"Marketing\").department == \"Marketing\"\... |
b387056e5a22812c194127008bcc0ec5 | [
{
"content": "On te donne une liste d'entiers positifs, `numbers`. Ta tâche est d'implémenter une fonction `remove_duplicates` qui supprime toutes les valeurs dupliquées de la liste tout en maintenant l'ordre d'origine des éléments restants. La fonction doit renvoyer la liste modifiée.\n\n**Entrée :**\n- Une li... | ["\nassert remove_duplicates([1, 2, 3, 4, 3, 2, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([10, 20, 30, 40, 50]) == [10, 20, 30, 40, 50]\n", "\nassert remove_duplicates([5, 4, 3, 2, 1, 1, 2, 3, 4, 5]) == [5, 4,... |
b86590b8fa23c8c82a9fee273c3a5c05 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de réorganiser la liste de sorte qu'elle se compose de trois parties : le dernier tiers, le premier tiers et le tiers du milieu. Si la longueur de la liste n'est pas un multiple de 3, ajoute le plus petit entier impair qui n'est pas déjà présent dans l... | ["\nassert rearrange_thirds([1, 2, 3, 4, 5, 6]) == [5, 6, 1, 2, 3, 4]\n", "\nassert rearrange_thirds([1, 2, 3, 4, 5, 6, 7]) == [6, 7, 1, 2, 3, 4, 5]\n", "\nassert rearrange_thirds([1, 2, 3]) == [1, 2, 3]\n", "\nassert rearrange_thirds([1, 2]) == [1, 2, 3]\n", "\nassert rearrange_thirds([1]) == [1, 3]\n", "\nassert rear... |
639cb549862c412a1f8629170bad92e0 | [
{
"content": "Tu participes à un concours de programmation où tu dois implémenter une fonction pour générer des échantillons aléatoires à partir de la distribution de Gumbel standard en utilisant la bibliothèque PyTorch. La distribution de Gumbel standard a des paramètres mu = 0 et beta = 1. Ta tâche est d'écri... | ["\nassert generate_gumbel_sample((1,), \"cpu\").shape == (1,)\n", "\nassert generate_gumbel_sample((3, 3), \"cpu\").shape == (3, 3)\n", "\nassert generate_gumbel_sample((5, 5, 5), \"cpu\").shape == (5, 5, 5)\n", "\nassert generate_gumbel_sample((10,), \"cuda\").device.type == \"cuda\"\n", "\nassert generate_gumbel_sam... |
e22d987cdf8afc7d63a10fcde949b755 | [
{
"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(\"1984\", \"George Orwell\", 1949, \"1234567890\").is_classic() == True\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960, \"0987654321\").is_classic() == False\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925, \"1122334455\").is_classic() == True\n", "\nassert Boo... |
e031d0f656b21a84c3863e4547e39737 | [
{
"content": "On te donne un fichier binaire nommé `data.bin` contenant une séquence d'entiers en big-endian, chacun représenté comme une chaîne d'octets de longueur variable. Ta tâche est d'écrire un programme qui lit ce fichier binaire et calcule la somme de tous les entiers qu'il contient.\n\nLe fichier bina... | ["\nassert read_variable_length_integers('test1.bin') == 0\n", "\nassert read_variable_length_integers('test2.bin') == 255\n", "\nassert read_variable_length_integers('test3.bin') == 65535\n", "\nassert read_variable_length_integers('test4.bin') == 16777215\n", "\nassert read_variable_length_integers('test5.bin') == 42... |
ddabe40c7e52796af410128e45849302 | [
{
"content": "On te donne une phrase représentée sous forme de chaîne de caractères `sentence`, une liste de caractères `letters`, et une liste de positions entières `positions`. Ta tâche est de remplacer les caractères dans `sentence` aux `positions` spécifiées par les caractères correspondants de `letters`. A... | ["\nassert replace_letters_in_sentence(\"hello world\", [\"a\", \"b\"], [0, 6]) == \"ahello borld\"\n", "\nassert replace_letters_in_sentence(\"abcdef\", [\"x\", \"y\", \"z\"], [1, 3, 5]) == \"axcyezf\"\n", "\nassert replace_letters_in_sentence(\"abcdef\", [\"x\", \"y\", \"z\"], [1, 1, 5]) == \"axcdef\"\n", "\nassert r... |
c3342a50064d817b3272250cdc3291ca | [
{
"content": "Tu participes à un concours de programmation et on te demande de simuler un jeu de « Lancer de Dés Chanceux ». Dans ce jeu, un joueur lance un dé à six faces `n` fois, dans le but d'obtenir une séquence spécifique de nombres dans l'ordre. La séquence est déterminée par le nombre de lancers, c'est-... | ["\nassert simulate_lucky_dice_rolls(1, 1000, [1.0, 0.0, 0.0, 0.0, 0.0, 0.0]) == 1000\n", "\nassert simulate_lucky_dice_rolls(2, 1000, [1.0, 0.0, 0.0, 0.0, 0.0, 0.0]) == 0\n", "\nassert simulate_lucky_dice_rolls(3, 1000, [1/6.0] * 6) == 0 # Fair dice, very low chance of winning\n", "\nassert simulate_lucky_dice_rolls(... |
1cd2a644d1b43263b7b41ded2fda4917 | [
{
"content": "On te donne un tableau trié d'entiers `arr` et un entier cible `target`. Ta tâche est de déterminer le plus petit indice `i` tel que `arr[i] > target`. Si un tel indice n'existe pas, renvoie la longueur du tableau. Implémente cette fonctionnalité sans utiliser de fonctions de recherche binaire int... | ["\nassert find_smallest_index([1, 3, 5, 7, 9], 4) == 2\n", "\nassert find_smallest_index([1, 3, 5, 7, 9], 9) == 5\n", "\nassert find_smallest_index([1, 3, 5, 7, 9], 10) == 5\n", "\nassert find_smallest_index([1, 3, 5, 7, 9], 0) == 0\n", "\nassert find_smallest_index([1, 3, 5, 7, 9], 3) == 2\n", "\nassert find_smallest... |
f817804952280a294524732f4203d7c0 | [
{
"content": "On te donne une chaîne de caractères représentant un document JSON. Ta tâche est de mettre en œuvre une fonction `extract_nested_values` qui prend cette chaîne en entrée et renvoie une liste de toutes les valeurs trouvées dans le document JSON, y compris les valeurs imbriquées. La fonction doit gé... | ["\nassert extract_nested_values('{\"name\": \"John\", \"age\": 30, \"address\": {\"city\": \"New York\", \"zipcode\": 10001}}') == [\"John\", 30, \"New York\", 10001]\n", "\nassert extract_nested_values('{\"name\": \"Alice\", \"age\": 25, \"hobbies\": [\"reading\", \"cycling\", \"hiking\"]}') == [\"Alice\", 25, \"read... |
14eee447d7a850984e3a249019793baf | [
{
"content": "Tu es chargé d'implémenter une classe `TemperatureConverter` en Python. Cette classe doit avoir deux méthodes : `convert_to_celsius` et `convert_to_fahrenheit`. La méthode `convert_to_celsius` doit accepter une température en Fahrenheit et renvoyer la température équivalente en Celsius. Inversemen... | ["\nassert TemperatureConverter().convert_to_celsius(32) == 0.0\n", "\nassert TemperatureConverter().convert_to_celsius(212) == 100.0\n", "\nassert TemperatureConverter().convert_to_celsius(-40) == -40.0\n", "\nassert TemperatureConverter().convert_to_fahrenheit(0) == 32.0\n", "\nassert TemperatureConverter().convert_t... |
d37b69cde4f27ad575bdb31dba7a0060 | [
{
"content": "Tu es chargé d'implémenter une fonction `convert_to_iso8601` qui accepte un objet `datetime` et renvoie sa représentation sous forme de chaîne au format ISO 8601, y compris les millisecondes. La fonction doit gérer les cas où l'objet `datetime` ne contient pas d'informations de fuseau horaire en s... | ["\nassert convert_to_iso8601(datetime(2023, 10, 5, 14, 30, 45, 123456)) == \"2023-10-05T14:30:45.123+00:00\"\n", "\nassert convert_to_iso8601(datetime(2023, 10, 5, 14, 30, 45, 123456, pytz.timezone('US/Eastern'))) == \"2023-10-05T14:30:45.123-04:00\"\n", "\nassert convert_to_iso8601(datetime(2023, 10, 5, 14, 30, 45, 1... |
d8211db9afb857ea759d29ccf457b0ae | [
{
"content": "On te donne un ensemble de données de séries temporelles multiples, représentées sous la forme d'un tenseur 2D `x` de forme `(T, N)`, où `T` est le nombre d'étapes temporelles et `N` est le nombre de séries temporelles. Ta tâche est de mettre en œuvre une fonction qui calcule l'autocorrélation sim... | ["\nassert torch.allclose(autocorrelation_2d(torch.tensor([[1.0, 2.0], [2.0, 1.0], [3.0, 2.0]]), 1), torch.tensor([0.5, 0.5]))\n", "\nassert torch.allclose(autocorrelation_2d(torch.tensor([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]]), 1), torch.tensor([1.0, 1.0]))\n", "\nassert torch.allclose(autocorrelation_2d(torch.tensor([[... |
83595447150a72e883a45d94f20fe014 | [
{
"content": "On te donne une liste de mots et une largeur de ligne maximale. Ta tâche est de formater le texte de sorte que chaque ligne soit entièrement justifiée à la largeur spécifiée. Aucune ligne ne doit dépasser la largeur maximale, et les espaces doivent être distribués aussi uniformément que possible e... | ["\nassert justify_text([\"This\", \"is\", \"an\", \"example\"], 16) == [\"This is an\", \"example \"]\n", "\nassert justify_text([\"What\", \"must\", \"be\", \"acknowledgment\", \"shall\", \"be\"], 16) == [\"What must be\", \"acknowledgment \", \"shall be \"]\n", "\nassert justify_text([\"Science\", ... |
bddbedc5071e6b23453ae0a90d094de7 | [
{
"content": "On te donne un ensemble de données contenant les prix historiques des actions et l'Indice des Prix à la Consommation (IPC) correspondant pour chaque année. Ta tâche est d'écrire une fonction `adjust_for_inflation` qui ajuste les prix des actions en fonction de l'inflation en utilisant la valeur d'... | ["\nassert adjust_for_inflation(pd.DataFrame({'Year': [2000], 'StockPrice': [100], 'CPI': [172.2]}))['AdjustedStockPrice'].iloc[0] == 100\n", "\nassert adjust_for_inflation(pd.DataFrame({'Year': [2000, 2001], 'StockPrice': [100, 105], 'CPI': [172.2, 177.1]}))['AdjustedStockPrice'].iloc[1] == 105\n", "\nassert adjust_fo... |
771b3a46760c85ce52004d38f5463087 | [
{
"content": "Tu développes un système de panier d'achat pour une plateforme de commerce électronique internationale. Le système doit calculer le coût total des articles dans un panier d'achat après avoir appliqué une taxe de vente dynamique, qui varie selon la catégorie de l'article et est mise à jour quotidie... | ["\nassert calculate_total_cost([{'price_usd': 10, 'category': 'electronics', 'daily_tax_rate': 5}], 1) == 10.5\n", "\nassert calculate_total_cost([{'price_usd': 20, 'category': 'books', 'daily_tax_rate': 10}], 1) == 22\n", "\nassert calculate_total_cost([{'price_usd': 5.50, 'category': 'groceries', 'daily_tax_rate': 0... |
f64491df7240e08cd50173298b013565 | [
{
"content": "On te donne un tableau multidimensionnel `arr` (une liste de listes) et une liste d'indices `indices` en base-5. Ta tâche est d'écrire une fonction `traverse_array` qui parcourt le tableau multidimensionnel en utilisant les indices fournis et renvoie la valeur à l'indice final. Si l'indice est hor... | ["\nassert traverse_array([[1, 2, 3], [4, 5, 6]], ['0', '1']) == 2\n", "\nassert traverse_array([[1, 2, 3], [4, 5, 6]], ['1', '2']) == 6\n", "\nassert traverse_array([[1, 2, 3], [4, 5, 6]], ['2', '0']) == None\n", "\nassert traverse_array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], ['1', '0', '1']) == 6\n", "\nassert travers... |
22118f148b64bccb4b47a4eacabf3363 | [
{
"content": "On te donne deux chaînes de caractères non vides `s1` et `s2`. Ta tâche est d'implémenter une fonction `find_common_prefix(s1, s2)` qui renvoie le plus long préfixe commun des deux chaînes. S'il n'y a pas de préfixe commun, renvoie une chaîne vide.\n\n**Entrée :**\n- Deux chaînes `s1` et `s2` (1 ≤... | ["\nassert find_common_prefix(\"flower\", \"flow\") == \"flow\"\n", "\nassert find_common_prefix(\"dog\", \"racecar\") == \"\"\n", "\nassert find_common_prefix(\"interspecies\", \"interstellar\") == \"inters\"\n", "\nassert find_common_prefix(\"throne\", \"throne\") == \"throne\"\n", "\nassert find_common_prefix(\"pref... |
f38fa1c3703e920b56078e4d711bff70 | [
{
"content": "On te donne un fichier texte contenant du contenu HTML avec des attributs de données personnalisés intégrés (par exemple, `<div custom-data-id=\"123\">Contenu</div>`). Ta tâche est d'écrire une fonction `extract_custom_data` qui lit le contenu du fichier, supprime les balises HTML, mais conserve l... | ["\nassert extract_custom_data(\"test1.html\") == b\"Content 123\"\n", "\nassert extract_custom_data(\"test2.html\") == b\"Another content 456\"\n", "\nassert extract_custom_data(\"test3.html\") == b\"More content 789 012\"\n", "\nassert extract_custom_data(\"test4.html\") == b\"Single attribute 321\"\n", "\nassert ext... |
209c4996ee0cc6ef847fec00333f723d | [
{
"content": "On te demande d'implémenter une fonction génératrice Python nommée `generate_primes(limit)`. Cette fonction doit générer des nombres premiers à partir de 2 jusqu'à la `limit` spécifiée (incluse). Un nombre premier est défini comme un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs a... | ["\nassert list(generate_primes(10)) == [2, 3, 5, 7]\n", "\nassert list(generate_primes(1)) == []\n", "\nassert list(generate_primes(2)) == [2]\n", "\nassert list(generate_primes(19)) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert list(generate_primes(0)) == []\n", "\nassert list(generate_primes(30)) == [2, 3, 5, 7, 11,... |
11a9038cd9d81e829ef9843f5af6da1b | [
{
"content": "On te donne une image rectangulaire représentée par ses coordonnées en haut à gauche et en bas à droite sous forme d'une liste de quatre entiers `[xmin, ymin, xmax, ymax]`. Ta tâche est d'écrire une fonction `compute_border(coord, delta)` qui calcule le remplissage nécessaire pour centrer l'image ... | ["\nassert compute_border([1, 1, 3, 3], 5) == ((4, 4), (4, 4), (0, 0))\n", "\nassert compute_border([0, 0, 10, 10], 5) == ((0, 0), (0, 0), (0, 0))\n", "\nassert compute_border([2, 2, 8, 8], 10) == ((2, 2), (2, 2), (0, 0))\n", "\nassert compute_border([5, 5, 5, 5], 10) == ((5, 5), (5, 5), (0, 0))\n", "\nassert compute_b... |
9336579be2d5231bf3b6956258a0e8f3 | [
{
"content": "On te donne trois chiffres distincts (0-9). Ta tâche est de générer tous les nombres à trois chiffres possibles en utilisant ces chiffres sans répétition. Parmi ces nombres, trouve et renvoie le plus petit nombre possible où le chiffre des dizaines est impair. Si un tel nombre n'existe pas, renvoi... | ["\nassert smallest_valid_number([1, 3, 5]) == 135\n", "\nassert smallest_valid_number([2, 4, 6]) == float('inf')\n", "\nassert smallest_valid_number([1, 2, 3]) == 132\n", "\nassert smallest_valid_number([9, 7, 5]) == 579\n", "\nassert smallest_valid_number([8, 6, 4]) == float('inf')\n", "\nassert smallest_valid_number... |
4ada69387f80c5b503c440b8688ee5ff | [
{
"content": "On te demande d'analyser des données de diagnostic provenant d'un système afin de générer une représentation de type diagramme de Gantt pour un attribut spécifique sur une plage de temps donnée. Les données de diagnostic sont fournies sous forme de liste de dictionnaires, où chaque dictionnaire co... | ["\nassert generate_gantt_chart([{'timestamp': '2023-10-01 12:00', 'temp': {'00': 'OK', '01': 'OK', '02': 'ERROR'}}], 'temp', '2023-10-01 12:00', '2023-10-01 12:03') == [{'Task': 'YTLA', 'Start': '2023-10-01 12:00', 'Finish': '2023-10-01 12:02', 'Resource': 'OK'}, {'Task': 'YTLA', 'Start': '2023-10-01 12:02', 'Finish':... |
4ffc7ffa49cf558375d84f0ac86eb7cf | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Chaque caractère de la chaîne représente une \"couleur\". Ta tâche est de déterminer s'il est possible de partitionner la chaîne en une ou plusieurs sous-chaînes non vides telles que chaque sous-chaîne c... | ["\nassert max_even_partitions(\"aabbaabbaabbaabb\") == 4\n", "\nassert max_even_partitions(\"aabbcc\") == 3\n", "\nassert max_even_partitions(\"abcabc\") == 0\n", "\nassert max_even_partitions(\"aaaa\") == 2\n", "\nassert max_even_partitions(\"abababab\") == 4\n", "\nassert max_even_partitions(\"zzzzzzzz\") == 4\n", "... |
f2eefcee71318231c1ebef071d2f5fc7 | [
{
"content": "On te demande d'implémenter une fonction `is_nested_list(x)` en une seule ligne de code. La fonction doit déterminer si l'entrée `x` est une liste où chaque élément est également une liste. Si `x` n'est pas une liste ou si un élément à l'intérieur de `x` n'est pas une liste, la fonction doit renvo... | ["\nassert is_nested_list([[1, 2], [3, 4]]) == True\n", "\nassert is_nested_list([[], []]) == True\n", "\nassert is_nested_list([1, [2, 3]]) == False\n", "\nassert is_nested_list([[], [1, 2], [3, 4]]) == True\n", "\nassert is_nested_list([]) == True\n", "\nassert is_nested_list([[], [1], [2, 3], [4, 5, 6]]) == True\n",... |
2a1c2bf5fb69adff9e123662fbdf33b2 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction qui supprime tous les caractères dupliqués de la chaîne tout en conservant l'ordre d'apparition original de chaque caractère.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10^5) composée de le... | ["\nassert remove_duplicates(\"abracadabra\") == \"abrcd\"\n", "\nassert remove_duplicates(\"hello world\") == \"helo wrd\"\n", "\nassert remove_duplicates(\"aabbcc\") == \"abc\"\n", "\nassert remove_duplicates(\"python\") == \"python\"\n", "\nassert remove_duplicates(\"\") == \"\"\n", "\nassert remove_duplicates(\"123... |
5c57e388c9f8eea43d8524768d48f45e | [
{
"content": "Dans un jeu de programmation compétitif, les joueurs gagnent des points en fonction de leurs performances. Pour chaque réponse correcte, un joueur gagne 10 points, et pour chaque réponse incorrecte, 5 points sont déduits. Implémente une fonction `calculate_score` qui calcule le score final d'un jo... | ["\nassert calculate_score(5, 2) == 30\n", "\nassert calculate_score(0, 0) == 0\n", "\nassert calculate_score(10, 0) == 100\n", "\nassert calculate_score(0, 10) == -50\n", "\nassert calculate_score(3, 3) == 0\n", "\nassert calculate_score(7, 1) == 65\n", "\nassert calculate_score(1, 2) == 0\n", "\nassert calculate_scor... |
f3c256066c5734e429e985b6c01b08fa | [
{
"content": "Tu participes à un concours de programmation où tu dois simuler une fonction qui interagit avec une API météo. L'API nécessite une clé API pour l'authentification, qui doit être incluse dans l'en-tête HTTP personnalisé `X-Auth-Token` de la requête HTTP. Ta tâche est d'implémenter une fonction Pyth... | ["\nassert fetch_weather_data(\"http://api.weather.com/data\", \"valid_api_key\") == {\"temperature\": \"22C\", \"humidity\": \"50%\"}\n", "\nassert fetch_weather_data(\"http://api.weather.com/data\") == {\"temperature\": \"22C\", \"humidity\": \"50%\"}\n", "\nassert fetch_weather_data(\"http://api.weather.com/data\", ... |
b859948ac202572bbc7a70e2aeb9f887 | [
{
"content": "On te donne une liste de chaînes de caractères et une sous-chaîne cible. Ta tâche est de mettre en œuvre une fonction qui filtre la liste, en renvoyant uniquement les chaînes qui contiennent la sous-chaîne cible.\n\n**Entrée :**\n- Une liste de chaînes de caractères `strings_list` (1 ≤ len(strings... | ["\nassert filter_strings_by_substring([\"apple\", \"banana\", \"cherry\"], \"a\") == [\"apple\", \"banana\"]\n", "\nassert filter_strings_by_substring([\"hello\", \"world\", \"python\"], \"o\") == [\"hello\", \"world\"]\n", "\nassert filter_strings_by_substring([\"test\", \"testing\", \"tested\"], \"test\") == [\"test... |
a2cafc82f200faaee111216c6b874748 | [
{
"content": "Tu es chargé de traiter un ensemble de données d'achats clients stocké dans un fichier CSV. L'ensemble de données se compose des colonnes suivantes : `customer_id`, `purchase_date`, `product_category` et `purchase_amount`. Ton objectif est de calculer le montant total des achats pour chaque combin... | ["\nassert calculate_total_purchases('test_data_1.csv') == {(1, 'Electronics'): 1500, (2, 'Clothing'): 200, (1, 'Books'): 50}\n", "\nassert calculate_total_purchases('test_data_2.csv') == {(3, 'Electronics'): 800, (4, 'Clothing'): 150, (5, 'Books'): 75}\n", "\nassert calculate_total_purchases('test_data_3.csv') == {(6,... |
d12afe3edeff28b3ec899a54272b2029 | [
{
"content": "On te demande d'écrire un programme qui prend un chemin de répertoire en entrée et liste récursivement tous les fichiers et sous-répertoires qu'il contient. Ton programme doit afficher le chemin complet de chaque fichier et répertoire rencontré. Suppose que le chemin de répertoire d'entrée est val... | ["\nassert list_files_and_dirs(\"/nonexistent_directory\") is None\n", "\nassert list_files_and_dirs(\"\") is None\n", "\nassert list_files_and_dirs(\"/\") is None\n", "\nassert list_files_and_dirs(\"/tmp\") is None\n", "\nassert list_files_and_dirs(os.path.expanduser(\"~\")) is None\n", "\nassert list_files_and_dirs(o... |
a0c546bdde65ec9e5ad8f2d961b2cbed | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'implémenter une fonction `find_common_elements` qui identifie et renvoie une liste d'entiers uniques présents dans les deux listes d'entrée. L'ordre des éléments dans la liste de sortie n'est pas pertinent.\n\n**Entrée :**\n- Deux listes d'entiers,... | ["\nassert find_common_elements([1, 2, 3, 4], [3, 4, 5, 6]) == [3, 4]\n", "\nassert find_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\nassert find_common_elements([], []) == []\n", "\nassert find_... |
2d3e0965efc429bd8acc34b51bef84dd | [
{
"content": "Dans une API REST hypothétique, tu dois construire une URL pour accéder à une ressource spécifique. L'API suit cette structure :\n\n- URL de base : `https://api.example.com`\n- Version : `v1`\n- Ressource : `/users/{user_id}/posts/{post_id}`\n\nTa tâche est d'implémenter une fonction `generate_url... | ["\nassert generate_url(123, 456) == \"https://api.example.com/v1/users/123/posts/456\"\n", "\nassert generate_url(1, 1) == \"https://api.example.com/v1/users/1/posts/1\"\n", "\nassert generate_url(999999, 999999) == \"https://api.example.com/v1/users/999999/posts/999999\"\n", "\nassert generate_url(123456, 654321) == ... |
247cdb0cf771485ae869b93a0e6d7874 | [
{
"content": "On te donne une grille de taille `N x N` où chaque cellule contient un entier unique de `1` à `N*N`. Tu commences dans une cellule contenant l'entier `S`. Ta tâche est de déterminer s'il est possible de visiter chaque cellule exactement une fois et de revenir à la cellule de départ, formant ainsi ... | ["\nassert find_hamiltonian_cycle([[1, 2], [3, 4]], 1) == False\n", "\nassert find_hamiltonian_cycle([[1, 2], [4, 3]], 1) == True\n", "\nassert find_hamiltonian_cycle([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 1) == True\n", "\nassert find_hamiltonian_cycle([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 5) == False\n", "\nassert find_hami... |
8018e5aa9f00c40c41f0a717e5a54470 | [
{
"content": "On te donne un lexique, représenté comme un dictionnaire où les clés sont des mots et les valeurs sont leurs représentations en octets correspondantes. Ta tâche est de mettre en œuvre un programme qui compresse et décompresse ce lexique en utilisant le multithreading pour améliorer les performance... | ["\nassert compress_word(\"hello\", b\"hello\")[1] != b\"hello\"\n", "\nassert decompress_word((\"hello\", compress_word(\"hello\", b\"hello\")[1])) == (\"hello\", b\"hello\")\n", "\nassert compress_word(\"world\", b\"world\")[1] != b\"world\"\n", "\nassert decompress_word((\"world\", compress_word(\"world\", b\"world\... |
99be74f6f32955614394275f741fbf24 | [
{
"content": "On te donne deux chaînes de caractères, `submission` et `original`, représentant des soumissions de texte. De plus, on te fournit une valeur seuil `t`. Ta tâche est de déterminer si la `submission` est un plagiat de l'`original`. Pour ce faire, ignore les mots vides anglais courants et considère u... | ["\nassert check_plagiarism(\"This is a test\", \"This is a test\", 0.5) == True\n", "\nassert check_plagiarism(\"This is a test\", \"This is a different test\", 0.5) == False\n", "\nassert check_plagiarism(\"Hello world\", \"world hello\", 0.5) == True\n", "\nassert check_plagiarism(\"Running and jumping\", \"run jump... |
f29d4c5bff0b4e31fcfe61592d52494f | [
{
"content": "On te donne un fichier binaire contenant un ensemble de données sérialisé de relevés de température. Chaque relevé est une liste de valeurs de température, qui peut inclure `None` pour indiquer des données manquantes. Ta tâche est d'écrire un programme qui charge cet ensemble de données, filtre to... | ["\nassert clean_and_average([[None, 20, 30], [40, None, 50]]) == 30.0\n", "\nassert clean_and_average([[None, None, None], [None, None, None]]) == None\n", "\nassert clean_and_average([[100, 200, 300], [400, 500, 600]]) == None\n", "\nassert clean_and_average([[-60, -70, -80], [-90, -100, -110]]) == None\n", "\nassert... |
e5a367c52ecbbc196f943328a4d0ba48 | [
{
"content": "On te donne une liste de tuples représentant des produits dans un magasin, où chaque tuple est composé d'un nom de produit (une chaîne de caractères) et de son prix (un nombre à virgule flottante). Ta tâche est d'écrire une fonction qui trie cette liste de produits d'abord par prix par ordre crois... | ["\nassert sort_products_by_price([(\"apple\", 1.2), (\"banana\", 0.8), (\"orange\", 1.2), (\"pear\", 0.9)]) == [(\"banana\", 0.8), (\"pear\", 0.9), (\"apple\", 1.2), (\"orange\", 1.2)]\n", "\nassert sort_products_by_price([(\"grape\", 2.0), (\"kiwi\", 2.0), (\"melon\", 1.5)]) == [(\"melon\", 1.5), (\"grape\", 2.0), (\... |
b8a6e155845a886e01a1f7a27ac5bfff | [
{
"content": "On te donne une chaîne de caractères `s` représentant un objet JSON sérialisé qui n'est pas bien formé en raison de l'absence de crochets fermants. Ta tâche est d'écrire une fonction `fix_json(s)` qui renvoie un objet JSON bien formé en ajoutant les crochets fermants nécessaires. L'objet JSON peut... | ["\nassert fix_json(\"{[}\") == \"{[]}\"\n", "\nassert fix_json(\"{[[]\") == \"{[[]]}\"\n", "\nassert fix_json(\"{[{}\") == \"{[{}]}\"\n", "\nassert fix_json(\"{[{}]\") == \"{[{}]}\"\n", "\nassert fix_json(\"{[{}]}\") == \"{[{}]}\"\n", "\nassert fix_json(\"{[{}][\") == \"{[{}][]}\"\n", "\nassert fix_json(\"{[{}][{\") =... |
572031c0e020479fabb48677dccc7442 | [
{
"content": "On te donne une fonction `divide(a, b)` qui est censée renvoyer le résultat de la division de `a` par `b`. Cependant, la fonction ne gère pas les entrées invalides avec élégance. Ta tâche est de modifier la fonction pour gérer les cas où `a` ou `b` ne sont pas des nombres et lorsque `b` est égal à... | ["\nassert divide(10, 'two') == \"Error: Invalid input type. Please provide numbers.\"\n", "\nassert divide('ten', 2) == \"Error: Invalid input type. Please provide numbers.\"\n", "\nassert divide(10, 0) == \"Error: Division by zero is not allowed.\"\n", "\nassert divide(0, 10) == 0.0\n", "\nassert divide(10, 2) == 5.0... |
cce9fe020a015fe74a33d0305f6d3fe7 | [
{
"content": "On te demande d'implémenter l'algorithme de tri par fusion en Python. Ta fonction doit prendre une liste d'entiers en entrée et renvoyer une nouvelle liste contenant les mêmes entiers dans l'ordre trié. L'algorithme de tri par fusion doit être implémenté de manière récursive. Ta solution doit être... | ["\nassert merge_sort([3, 1, 2]) == [1, 2, 3]\n", "\nassert merge_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([]) == []\n", "\nassert merge_sort([1]) == [1]\n", "\nassert merge_sort([9, 7, 5, 11, 12, 2, 14, 3, 10, 6]) == [2, 3, 5, 6, 7, ... |
3b78c1666c15d6acf0484b3fea125c29 | [
{
"content": "On te demande d'implémenter une fonction pour calculer la factorielle d'un entier non négatif. La fonction doit être suffisamment efficace pour gérer de grandes valeurs d'entrée et renvoyer le résultat sous forme d'entier. Ta fonction doit s'appeler `calculate_factorial` et accepter un seul paramè... | ["\nassert calculate_factorial(0) == 1\n", "\nassert calculate_factorial(1) == 1\n", "\nassert calculate_factorial(2) == 2\n", "\nassert calculate_factorial(5) == 120\n", "\nassert calculate_factorial(10) == 3628800\n", "\nassert calculate_factorial(12) == 479001600\n", "\nassert calculate_factorial(20) == 243290200817... |
474dcc32e615d3ff27ffb22a3b79be85 | [
{
"content": "On te donne une liste de mots. Ton objectif est d'écrire une fonction Python qui renvoie le mot de longueur maximale. Si la liste est vide, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste de chaînes de caractères, `words`.\n\n**Sortie :**\n- Une chaîne de caractères représentant le ... | ["\nassert longest_word([\"apple\", \"banana\", \"cherry\"]) == \"banana\"\n", "\nassert longest_word([\"dog\", \"cat\"]) == \"dog\"\n", "\nassert longest_word([\"hello\", \"world\", \"python\"]) == \"python\"\n", "\nassert longest_word([\"a\", \"ab\", \"abc\"]) == \"abc\"\n", "\nassert longest_word([]) == None\n", "\n... |
863d472459d001b6a1b3d0501e46893e | [
{
"content": "On te donne un tableau 1D et un entier représentant le nombre de colonnes. Ta tâche est de convertir le tableau 1D en une matrice 2D avec le nombre de colonnes spécifié. La dernière ligne de la matrice peut avoir moins d'éléments si le nombre total d'éléments dans le tableau n'est pas parfaitement... | ["\nassert array_to_matrix([1, 2, 3, 4, 5, 6], 2) == [[1, 2], [3, 4], [5, 6]]\n", "\nassert array_to_matrix([1, 2, 3, 4, 5], 2) == [[1, 2], [3, 4], [5]]\n", "\nassert array_to_matrix([1, 2, 3, 4, 5, 6, 7], 3) == [[1, 2, 3], [4, 5, 6], [7]]\n", "\nassert array_to_matrix([1, 2, 3, 4, 5, 6, 7, 8], 4) == [[1, 2, 3, 4], [5,... |
d9a5b904ec958339da4337b372fd474c | [
{
"content": "On te demande d'implémenter une fonction `generate_sequence(start, end, step)` qui génère une séquence de nombres de `start` à `end` (inclus) avec un pas spécifié `step`. La séquence doit progresser dans la direction de `start` à `end`, quel que soit le signe de `step`. La valeur absolue de `step`... | ["\nassert generate_sequence(1, 10, 2) == [1, 3, 5, 7, 9]\n", "\nassert generate_sequence(10, 1, -2) == [10, 8, 6, 4, 2]\n", "\nassert generate_sequence(5, 5, 3) == [5]\n", "\nassert generate_sequence(5, 5, 0) == [5]\n", "\nassert generate_sequence(5, 5, -3) == [5]\n", "\nassert generate_sequence(1, 10, 0) == [1]\n", "... |
ccfd26ad14dc4897f4cd87438922d61d | [
{
"content": "On te demande d'implémenter une fonction `calculate_power(base, exponent)` qui calcule `base` élevé à la puissance de `exponent` pour toutes les valeurs entières de `exponent`. La fonction doit gérer les exposants négatifs en renvoyant l'inverse de la puissance positive. Tu n'es pas autorisé à uti... | ["\nassert calculate_power(2, 10) == 1024\n", "\nassert calculate_power(2, -2) == 0.25\n", "\nassert calculate_power(5, 0) == 1\n", "\nassert calculate_power(3, 3) == 27\n", "\nassert calculate_power(10, 1) == 10\n", "\nassert calculate_power(7, -1) == 1/7\n", "\nassert calculate_power(2, 15) == 32768\n", "\nassert cal... |
adaddfe1f50e0c9ed256d0ee51d22bae | [
{
"content": "On te donne une liste de tuples, où chaque tuple contient un flottant représentant une latitude ou une longitude en degrés décimaux et une chaîne de caractères représentant l'hémisphère ('N' ou 'S' pour la latitude, 'E' ou 'W' pour la longitude). Ta tâche est d'écrire une fonction qui convertit ch... | ["\nassert convert_coordinates([(40.7128, 'N')]) == [(40, 42, 46.08, 'N')]\n", "\nassert convert_coordinates([(-74.0060, 'W')]) == [(74, 0, 21.6, 'W')]\n", "\nassert convert_coordinates([(51.5074, 'N')]) == [(51, 30, 26.64, 'N')]\n", "\nassert convert_coordinates([(0.1278, 'W')]) == [(0, 7, 40.08, 'W')]\n", "\nassert c... |
86bc4d2ad79c4bb9d1112cb93fa00ed6 | [
{
"content": "On te donne une chaîne de caractères `expression` composée de caractères alphanumériques et de parenthèses `(` et `)`. Ta tâche est de déterminer si les parenthèses dans la chaîne sont équilibrées. Une chaîne est considérée comme ayant des parenthèses équilibrées si chaque parenthèse ouvrante `(` ... | ["\nassert is_balanced_parentheses(\"((a + b) * c) + (d / e)\") == True\n", "\nassert is_balanced_parentheses(\"((a + b) * c) + d / e)\") == False\n", "\nassert is_balanced_parentheses(\"(a + b) * (c + d)\") == True\n", "\nassert is_balanced_parentheses(\"a + b * c + d / e\") == True\n", "\nassert is_balanced_parenthes... |
aff7fc8df24e06a2baa19d7c8bbcf334 | [
{
"content": "On te donne deux listes : `durations` et `bitrates`. Chaque élément de `durations` représente la durée d'une chanson en secondes, et chaque élément de `bitrates` représente le débit binaire de la chanson correspondante en kilobits par seconde (kbps). Ta tâche est de calculer le nombre total de bit... | ["\nassert calculate_total_bits([180, 240, 300], [128, 320, 256]) == [27648000.0, 76800000.0, 76800000.0]\n", "\nassert calculate_total_bits([10, 20, 30], [100, 200, 300]) == [800000.0, 3200000.0, 7200000.0]\n", "\nassert calculate_total_bits([0, -1, 5], [128, 320, 256]) == [1280000.0]\n", "\nassert calculate_total_bit... |
09ec89b223af2dfbd21ab1eaf3889785 | [
{
"content": "On te donne un tableau d'entiers `numbers` et un entier `target`. Ta tâche est de mettre en œuvre une fonction `find_two_sum` qui identifie deux éléments distincts dans le tableau dont la somme est égale à `target`. Si une telle paire existe, retourne un tuple contenant leurs indices ; sinon, reto... | ["\nassert find_two_sum([2, 7, 11, 15], 9) == (0, 1)\n", "\nassert find_two_sum([3, 2, 4], 6) == (1, 2)\n", "\nassert find_two_sum([3, 3], 6) == (0, 1)\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 10) == (3, 4)\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 8) == (2, 4)\n", "\nassert find_two_sum([], 0) == None\n", "\nasse... |
f0365686f1cd2e2ea65e1092640a35ec | [
{
"content": "On te demande d'implémenter une fonction `get_month_name` qui accepte une entrée `month`, qui peut être soit un entier, soit une chaîne de caractères. La fonction doit renvoyer le nom du mois correspondant à la valeur entière comprise entre 1 et 12 inclusivement. Si l'entrée est une chaîne de cara... | ["\nassert get_month_name(1) == 'January'\n", "\nassert get_month_name(12) == 'December'\n", "\nassert get_month_name(7) == 'July'\n", "\nassert get_month_name(\" 4 \") == 'April'\n", "\nassert get_month_name(\"11\") == 'November'\n", "\nassert get_month_name(\"0\") == None\n", "\nassert get_month_name(\"13\") == Non... |
0df661ffbb00830080d52e3316cd1d84 | [
{
"content": "Tu es chargé d'implémenter une fonction `convert_to_iso_format` qui accepte un objet datetime et renvoie une chaîne formatée selon la norme ISO 8601. La chaîne de sortie doit inclure la date, l'heure et les informations de fuseau horaire dans le format \"YYYY-MM-DDTHH:MM:SSZ\", où :\n- YYYY est l'... | ["\nassert convert_to_iso_format(datetime(2022, 3, 1, 12, 34, 56, tzinfo=timezone.utc)) == \"2022-03-01T12:34:56Z\"\n", "\nassert convert_to_iso_format(datetime(2020, 2, 29, 23, 59, 59, tzinfo=timezone.utc)) == \"2020-02-29T23:59:59Z\"\n", "\nassert convert_to_iso_format(datetime(2019, 2, 28, 23, 59, 59, tzinfo=timezon... |
9bd15e12d86c877a0db9e176222d5631 | [
{
"content": "On te demande de simuler une expérience de pile ou face. Ton programme doit simuler le lancer d'une pièce `N` fois et afficher le nombre de piles, le nombre de faces et le rapport entre le nombre de piles et le nombre de faces. Utilise le module `random` pour générer des nombres aléatoires. Assure... | ["\nassert simulate_coin_flip(0) == (0, 0, float('inf'))\n", "\nassert simulate_coin_flip(1)[0] + simulate_coin_flip(1)[1] == 1\n", "\nassert simulate_coin_flip(1000)[0] >= 0 and simulate_coin_flip(1000)[1] >= 0\n", "\nassert simulate_coin_flip(1000)[0] + simulate_coin_flip(1000)[1] == 1000\n", "\nassert simulate_coin_... |
ee21cececbf62d6c7a322740210b02a6 | [
{
"content": "On te donne une liste triée de `n` chaînes de caractères distinctes `words` par ordre lexicographique et une chaîne cible `target`. Ta tâche est de mettre en œuvre une fonction qui renvoie l'index de la chaîne `target` dans la liste. Si la chaîne `target` n'est pas présente dans la liste, la fonct... | ["\nassert binary_search([\"apple\", \"banana\", \"cherry\", \"date\", \"fig\", \"grape\"], \"cherry\") == 2\n", "\nassert binary_search([\"apple\", \"banana\", \"cherry\", \"date\", \"fig\", \"grape\"], \"apple\") == 0\n", "\nassert binary_search([\"apple\", \"banana\", \"cherry\", \"date\", \"fig\", \"grape\"], \"gra... |
0b9ac5a739bc267eb9b27900316c387c | [
{
"content": "Tu es chargé d'implémenter une fonction `custom_range` qui génère une séquence de nombres sans utiliser de boucles explicites. La fonction doit utiliser la récursion ou d'autres fonctionnalités de Python pour créer une liste de nombres commençant à `start`, en l'incrémentant de `step` à chaque foi... | ["\nassert custom_range(0, 2, 10) == [0, 2, 4, 6, 8]\n", "\nassert custom_range(1, 3, 15) == [1, 4, 7, 10, 13]\n", "\nassert custom_range(5, 5, 25) == [5, 10, 15, 20]\n", "\nassert custom_range(10, 1, 10) == []\n", "\nassert custom_range(1, 1, 1) == []\n", "\nassert custom_range(0, 1, 0) == []\n", "\nassert custom_rang... |
08d695f0f392349807e530a7223937d5 | [
{
"content": "On te donne un dictionnaire `data_dict` où les clés sont des chaînes de caractères et les valeurs sont des entiers. Ta tâche est de mettre en œuvre une fonction `sort_by_value` qui trie les éléments du dictionnaire par leurs valeurs par ordre décroissant et renvoie une liste de tuples, chacun cont... | ["\nassert sort_by_value({'a': 3, 'b': 1, 'c': 2}) == [('a', 3), ('c', 2), ('b', 1)]\n", "\nassert sort_by_value({'x': 10, 'y': 20, 'z': 5}) == [('y', 20), ('x', 10), ('z', 5)]\n", "\nassert sort_by_value({'one': 1, 'two': 2, 'three': 3}) == [('three', 3), ('two', 2), ('one', 1)]\n", "\nassert sort_by_value({}) == []\n... |
89f60f9e0884265590ea13d9cca84bfc | [
{
"content": "On te donne une liste de chaînes de caractères `text_list`, où chaque chaîne contient un bloc de texte. Ta tâche est d'implémenter une fonction `extract_emails` qui extrait toutes les adresses e-mail valides du texte et les renvoie sous forme de liste de chaînes de caractères. Si aucune adresse e-... | ["\nassert extract_emails([\"hello world\"]) == []\n", "\nassert extract_emails([\"contact us at info@company.com\"]) == [\"info@company.com\"]\n", "\nassert extract_emails([\"user.name@sub.domain.org is the email\"]) == [\"user.name@sub.domain.org\"]\n", "\nassert extract_emails([\"name+surname@domain.co.uk is valid\"... |
8df39c7e1699fa8853263db1f2301653 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ton objectif est d'implémenter une fonction `find_first_unique_char` qui identifie le premier caractère non répétitif dans la chaîne. S'il n'y a pas un tel caractère, la fonction doit renvoyer `None`.\n\... | ["\nassert find_first_unique_char(\"swiss\") == \"w\"\n", "\nassert find_first_unique_char(\"aabbcc\") == None\n", "\nassert find_first_unique_char(\"abcdef\") == \"a\"\n", "\nassert find_first_unique_char(\"aabbccddee\") == None\n", "\nassert find_first_unique_char(\"a\") == \"a\"\n", "\nassert find_first_unique_char(... |
b9cbed1fb6683acfb0756d1a0ee4ac96 | [
{
"content": "On te donne un arbre binaire où chaque nœud représente un clade et est associé à un masque de clade. Chaque bit du masque représente la présence ou l'absence d'un taxon. Ta tâche est de trouver le nœud le plus superficiel qui contient tous les taxons spécifiés dans le masque de clade cible, en ign... | ["\nassert find_shallowest_node(TreeNode(101, [TreeNode(100), TreeNode(001)]), 101) == TreeNode(101, [TreeNode(100), TreeNode(001)])\n", "\nassert find_shallowest_node(TreeNode(101, [TreeNode(100, [TreeNode(100), TreeNode(001)]), TreeNode(001, [TreeNode(001), TreeNode(000)])]), 101) == TreeNode(101, [TreeNode(100, [Tre... |
4b11f358d613ac32ff8c0f730ab70b93 | [
{
"content": "On te donne deux chaînes de caractères, `text1` et `text2`. Ta tâche est de mettre en œuvre une fonction `calculate_similarity(text1, text2)` qui calcule l'indice de similarité de Jaccard entre les deux chaînes. L'indice de similarité de Jaccard est défini comme la taille de l'intersection divisée... | ["\nassert calculate_similarity(\"hello world\", \"hello world\") == 1\n", "\nassert calculate_similarity(\"hello world\", \"world hello\") == 1\n", "\nassert calculate_similarity(\"hello world\", \"hi there\") == 0\n", "\nassert calculate_similarity(\"the quick brown fox\", \"the quick brown fox jumps over the lazy do... |
64e92a4696bb684e08426426843db2c4 | [
{
"content": "On te donne un ensemble de données composé d'étiquettes binaires (0 et 1). Ta tâche est de mettre en œuvre une fonction qui calcule l'impureté de Gini de cet ensemble de données. La fonction doit parcourir les étiquettes exactement une fois et utiliser une mémoire supplémentaire minimale.\n\n**Ent... | ["\nassert gini_impurity([0, 1, 0, 1, 1, 0, 0, 1]) == 0.4375\n", "\nassert gini_impurity([1, 1, 1, 1]) == 0.0\n", "\nassert gini_impurity([0, 0, 0, 0]) == 0.0\n", "\nassert gini_impurity([0, 1]) == 0.5\n", "\nassert gini_impurity([]) == 0.0\n", "\nassert gini_impurity([1, 0, 1, 0, 1, 0]) == 0.5\n", "\nassert gini_impur... |
b7a1d25ba722cb1bf9868bcffd5a1fd4 | [
{
"content": "On te demande de traiter un journal de chat représenté sous forme de chaîne CSV. Chaque ligne de la chaîne CSV correspond à un message unique, structuré comme suit : le premier élément est l'ID de l'utilisateur, le deuxième élément est un horodatage au format \"AAAA-MM-JJTHH:MM:SS\", et les élémen... | ["\nassert parse_chat_history(\"1,2021-09-01T12:34:56,Hello there\") == {'1': [('2021-09-01T12:34:56', 'Hello there')]}\n", "\nassert parse_chat_history(\"2,2021-09-01T12:35:10,Hi\\n1,2021-09-01T12:36:20,How are you?\") == {'2': [('2021-09-01T12:35:10', 'Hi')], '1': [('2021-09-01T12:36:20', 'How are you?')]}\n", "\nass... |
a339948b2938c7a82b9e238befdb8c82 | [
{
"content": "On te demande d'analyser les avis clients pour un produit stocké dans un fichier CSV nommé `reviews.csv`. Chaque ligne du fichier CSV contient un seul avis. Implémente une fonction `read_and_summarize_reviews(file_path)` qui lit le fichier CSV, calcule le score de polarité du sentiment pour chaque... | ["\nassert read_and_summarize_reviews(\"positive_reviews.csv\") > 0.5\n", "\nassert read_and_summarize_reviews(\"negative_reviews.csv\") < -0.5\n", "\nassert read_and_summarize_reviews(\"mixed_reviews.csv\") >= -0.5 and read_and_summarize_reviews(\"mixed_reviews.csv\") <= 0.5\n", "\nassert read_and_summarize_reviews(\"... |
ff6c31bf57389ff27a01ebe8a717bd43 | [
{
"content": "Implémente une classe Python `SimpleGraph` qui représente un graphe non orienté. La classe doit prendre en charge les opérations suivantes :\n- `add_edge(u, v)` : Ajoute une arête non orientée entre les sommets `u` et `v`.\n- `remove_edge(u, v)` : Supprime l'arête non orientée entre les sommets `u... | ["\nassert SimpleGraph().edge_exists(1, 2) == False\n", "\nassert SimpleGraph().degree(1) == 0\n", "\ng = SimpleGraph(); g.add_edge(1, 2); assert g.edge_exists(1, 2) == True\n", "\ng = SimpleGraph(); g.add_edge(1, 2); assert g.degree(1) == 1\n", "\ng = SimpleGraph(); g.add_edge(1, 2); g.add_edge(1, 3); assert g.degree(... |
193171e79996b669dc5bba0f0be9234c | [
{
"content": "On te donne une séquence de directions représentée sous forme de liste de chaînes de caractères. Chaque direction peut être l'une des suivantes : \"NORTH\", \"SOUTH\", \"EAST\" ou \"WEST\". Ta tâche est de simplifier cette séquence en supprimant toutes les paires consécutives de directions opposée... | ["\nassert simplify_directions([\"NORTH\", \"SOUTH\", \"EAST\", \"WEST\"]) == []\n", "\nassert simplify_directions([\"NORTH\", \"EAST\", \"SOUTH\", \"WEST\"]) == [\"NORTH\", \"EAST\", \"SOUTH\", \"WEST\"]\n", "\nassert simplify_directions([\"NORTH\", \"SOUTH\", \"NORTH\", \"SOUTH\"]) == []\n", "\nassert simplify_direct... |
f772966f9a3e8e2b7a83ab24e9b6da6c | [
{
"content": "Tu développes une simulation pour un environnement de machine virtuelle (VM) capable de gérer plusieurs instances de VM simultanément. Chaque instance de VM doit être initialisée avec un nom, un modèle de CPU et une configuration réseau uniques. De plus, chaque VM doit se voir attribuer un nom de ... | ["\nassert setup_vm_env(1)[0].name == \"vm1\"\n", "\nassert setup_vm_env(1)[0].cpu_template == \"GenericCPU\"\n", "\nassert setup_vm_env(1)[0].network_config == \"GenericNetworkConfig\"\n", "\nassert setup_vm_env(1)[0].tap_device_name == \"tapvm1\"\n", "\nassert setup_vm_env(1)[0].host_ip == \"10.0.0.1\"\n", "\nassert ... |
2052d4b1cb0c5c4ba0d5d5e08b1d85bd | [
{
"content": "On te donne une liste de `n` tâches, où chaque tâche est représentée par un tuple `(heure_de_début, heure_de_fin, profit)`. Tu peux effectuer plusieurs tâches simultanément. Ta tâche est de déterminer le profit maximal que tu peux obtenir en planifiant des tâches non chevauchantes.\n\n**Entrée :**... | ["\nassert maximize_profit([(1, 3, 50), (2, 5, 20), (4, 6, 30)]) == 80\n", "\nassert maximize_profit([(1, 2, 50), (3, 5, 20), (6, 8, 30)]) == 100\n", "\nassert maximize_profit([(1, 2, 50), (2, 3, 30), (3, 4, 20)]) == 100\n", "\nassert maximize_profit([(1, 3, 50), (2, 4, 20), (3, 5, 30)]) == 80\n", "\nassert maximize_pr... |
1b6063e53b68478594eab10880d916dc | [
{
"content": "On te demande d'implémenter une fonction `time_converter` qui convertit une durée donnée en secondes en un format lisible par un humain. La sortie doit inclure la durée en années bissextiles, jours, heures, minutes et secondes, mais uniquement si l'unité respective est non nulle. On suppose qu'une... | ["\nassert time_converter(0) == \"0 seconds\"\n", "\nassert time_converter(31536000) == \"1 leap years\"\n", "\nassert time_converter(31536000, show_minutes=False) == \"1 leap years\"\n", "\nassert time_converter(86400) == \"1 days\"\n", "\nassert time_converter(3600) == \"1 hours\"\n", "\nassert time_converter(60) == ... |
29d75e759d123afc8c75084cdcf8897a | [
{
"content": "On te donne une chaîne de caractères non vide `text` composée de caractères ASCII. Ta tâche est de mettre en œuvre une fonction `special_character_distribution` qui traite la chaîne en supprimant les espaces au début et à la fin et en remplaçant chaque occurrence de deux espaces ou plus consécutif... | ["\nassert special_character_distribution(\"hello world\") == {}\n", "\nassert special_character_distribution(\"hello @world\") == {'@': 1/11}\n", "\nassert special_character_distribution(\"hello @world\") == {'@': 1/11}\n", "\nassert special_character_distribution(\"hello @ world\") == {'@': 1/12}\n", "\nassert spec... |
cd0fd36949abdb73625fbc1b9acc193e | [
{
"content": "On te donne un tableau non trié d'entiers `nums` et un entier cible `target`. Ta tâche est de déterminer l'index auquel `target` doit être inséré dans `nums` pour maintenir l'ordre trié du tableau. La fonction doit parcourir le tableau une seule fois et utiliser un espace constant, à l'exclusion d... | ["\nassert find_target_index([1, 3, 5, 7], 4) == 2\n", "\nassert find_target_index([10, 20, 30, 40], 25) == 2\n", "\nassert find_target_index([5, 2, 6, 1, 8], 3) == 2\n", "\nassert find_target_index([1, 2, 3, 4, 5], 6) == 5\n", "\nassert find_target_index([1, 2, 3, 4, 5], 0) == 0\n", "\nassert find_target_index([], 10)... |
fc0752f3d9f6f2d6a89c737faf3aca36 | [
{
"content": "Dans un algorithme génétique, implémente une fonction `select_elite` qui sélectionne les individus d'élite en fonction de leurs scores de fitness moyens à partir d'une population combinée de parents et de descendants. Chaque individu est représenté comme un dictionnaire avec une clé `'fitness_scor... | ["\nassert select_elite([{'fitness_scores': [10, 10, 10]}, {'fitness_scores': [5, 5, 5]}], [{'fitness_scores': [8, 8, 8]}, {'fitness_scores': [2, 2, 2]}], 0.5) == [{'fitness_scores': [10, 10, 10], 'average_fitness': 10.0}, {'fitness_scores': [8, 8, 8], 'average_fitness': 8.0}]\n", "\nassert select_elite([{'fitness_scor... |
f0a239f130300d3cfaa89dfc15aa7dd7 | [
{
"content": "On te demande d'implémenter une fonction `ascii_encode_and_sanitize` qui traite une chaîne de caractères donnée `s` en utilisant le multithreading pour gérer efficacement les grandes entrées. La fonction doit effectuer les opérations suivantes :\n\n1. Convertir la chaîne d'entrée `s` de UTF-8 en U... | ["\nassert ascii_encode_and_sanitize(\"Caf\u00e9 M\u00fbr, it's na\u00efve to think!\") == \"Caf\u00e9_M\u00fbr_it_s_na\u00efve_to_think_\"\n", "\nassert ascii_encode_and_sanitize(\"Hello, World!\") == \"Hello_World_\"\n", "\nassert ascii_encode_and_sanitize(\"12345!@#$%\") == \"12345________\"\n", "\nassert ascii_enco... |
fda7e66a5d64acd8f3820d9052a92daf | [
{
"content": "On te donne un fichier nommé `ids.txt` contenant une liste d'identifiants, chaque identifiant étant une chaîne de caractères anglais en minuscules. Ta tâche est de trouver l'identifiant commun qui diffère d'exactement un caractère de tous les autres identifiants de la liste. Avant de traiter, trie... | ["\nassert find_common_id('test1.txt') == \"abcde\"\n", "\nassert find_common_id('test2.txt') == \"fghij\"\n", "\nassert find_common_id('test3.txt') == \"\"\n", "\nassert find_common_id('test4.txt') == \"mnopq\"\n", "\nassert find_common_id('test5.txt') == \"rstuv\"\n", "\nassert find_common_id('test6.txt') == \"wxyz\"... |
c4e1903af100dc456d05762d2c3b87fc | [
{
"content": "On te donne pour tâche d'implémenter une fonction `sendCommandToAPI` qui interagit avec une API hypothétique nommée `FemtoAPIFile`. Cette API fournit une méthode `setProcessingState` qui accepte une chaîne JSON comme argument. Ta fonction doit envoyer cette commande à l'API et renvoyer le résultat... | ["\nassert sendCommandToAPI(ws, '{\"state\": \"processing\"}') == \"Success\"\n", "\nassert sendCommandToAPI(ws, '{\"state\": \"completed\"}') == \"Completed\"\n", "\nassert sendCommandToAPI(ws, '{\"state\": \"error\"}') == None\n", "\nassert sendCommandToAPI(ws, '{\"state\": \"idle\", \"data\": [1, 2, 3]}') == \"Idle ... |
0cd9d22e8a5df8c41138c0b24a2b82b0 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ton objectif est d'écrire une fonction qui supprime tous les caractères dupliqués consécutifs de la chaîne et renvoie la chaîne résultante.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ... | ["\nassert remove_consecutive_duplicates(\"aabbccddeeff\") == \"abcdef\"\n", "\nassert remove_consecutive_duplicates(\"aaabbbccc\") == \"abc\"\n", "\nassert remove_consecutive_duplicates(\"abcd\") == \"abcd\"\n", "\nassert remove_consecutive_duplicates(\"a\") == \"a\"\n", "\nassert remove_consecutive_duplicates(\"\") =... |
6694d74dc3c484a56403900d64eae11f | [
{
"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 nombres pairs uniques, triés par ordre décroissant.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ ... | ["\nassert filter_even_numbers([1, 2, 3, 4, 5, 6]) == [6, 4, 2]\n", "\nassert filter_even_numbers([10, 20, 20, 30, 40, 50]) == [50, 40, 30, 20, 10]\n", "\nassert filter_even_numbers([7, 11, 13, 17]) == []\n", "\nassert filter_even_numbers([2, 4, 6, 8, 10, 12, 14, 16, 18, 20]) == [20, 18, 16, 14, 12, 10, 8, 6, 4, 2]\n",... |
f1ac09c3a2e3c7ff0188c713368379a3 | [
{
"content": "On te donne une liste de `n` intervalles de temps, chacun représenté par un tuple `(début, fin)`, où `début` et `fin` sont des entiers indiquant les heures de début et de fin des intervalles. Ta tâche est de fusionner tous les intervalles qui se chevauchent et de renvoyer une liste d'intervalles n... | ["\nassert merge_intervals([(1, 5), (2, 3), (7, 10), (8, 12)]) == [(1, 5), (7, 12)]\n", "\nassert merge_intervals([(1, 3), (4, 6), (8, 10), (11, 13)]) == [(1, 3), (4, 6), (8, 10), (11, 13)]\n", "\nassert merge_intervals([(1, 2), (3, 4), (5, 6), (7, 8)]) == [(1, 2), (3, 4), (5, 6), (7, 8)]\n", "\nassert merge_intervals(... |
1585bbcfa634fd639dfc0105744d4ec9 | [
{
"content": "On te demande de développer une fonction `get_climate_data_file` qui navigue dans un répertoire contenant des fichiers de données climatiques au format NetCDF. Chaque fichier est nommé selon la convention `<variable_name>_<time_period>.nc`, où `<variable_name>` est le type de variable climatique (... | ["\nassert get_climate_data_file(\"/path/to/directory\", \"temperature\") == \"/path/to/directory/temperature_2023.nc\"\n", "\nassert get_climate_data_file(\"/path/to/directory\", \"precipitation\") == \"/path/to/directory/precipitation_2022.nc\"\n", "\nassert get_climate_data_file(\"/path/to/directory\", \"pressure\")... |
c6787ee1e707f65c5a4adefe39f88bde | [
{
"content": "On te donne une liste d'entiers où chaque entier est un chiffre de 0 à 9 inclus. La liste peut également contenir un seul `-1` au début pour indiquer que le nombre résultant doit être négatif. Ta tâche est de mettre en œuvre une fonction `list_to_number(lst)` qui construit et renvoie l'entier repr... | ["\nassert list_to_number([1, 2, 3, 4, 5]) == 12345\n", "\nassert list_to_number([9, 8, 7, 6, 5, 4, 3, 2, 1]) == 987654321\n", "\nassert list_to_number([-1, 9, 8, 7, 6]) == -9876\n", "\nassert list_to_number([0, 0, 0, 1]) == 1\n", "\nassert list_to_number([5]) == 5\n", "\nassert list_to_number([-1, 0]) == 0\n", "\nasse... |
64d4cf0e146dc6990acca5f1fc2d05fd | [
{
"content": "On te demande d'implémenter une fonction `merge_and_count` qui accepte deux listes en tant que paramètres. La fonction doit fusionner ces listes en une seule liste `merged_list` en suivant des règles spécifiques et renvoyer le nombre d'éléments uniques dans la liste fusionnée. Les règles de fusion... | ["\nassert merge_and_count([3, 1, 2], [4, 5, 6]) == 6\n", "\nassert merge_and_count([1, 2, 2, 3], [3, 4, 4, 5]) == 5\n", "\nassert merge_and_count([], [1, 2, 3]) == 3\n", "\nassert merge_and_count([3, 2, 1], []) == 3\n", "\nassert merge_and_count([], []) == 0\n", "\nassert merge_and_count([10, 20, 30], [5, 15, 25, 35])... |
4c34ffb20c4d643fc7dcaf6196435497 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction `find_largest_number` qui détermine le plus grand entier de la liste. Tu dois implémenter cette fonctionnalité en utilisant une boucle et tu n'es pas autorisé à utiliser la fonction intégrée `max()`. Si la liste est vide, ta f... | ["\nassert find_largest_number([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 9\n", "\nassert find_largest_number([10, 20, 30, 40, 50]) == 50\n", "\nassert find_largest_number([-10, -20, -30, -40, -50]) == -10\n", "\nassert find_largest_number([0, 0, 0, 0, 0]) == 0\n", "\nassert find_largest_number([100]) == 100\n", "\nassert f... |
9fdaea8a8300a5147af934938e8baa5f | [
{
"content": "On te donne une file d'attente circulaire avec `N` positions. Implémente une fonction `get_next_position` qui détermine la position suivante dans la file d'attente après la position actuelle `P`. La fonction doit gérer les changements dynamiques du nombre de positions, en s'assurant que la positio... | ["\nassert get_next_position(0, 5) == 1\n", "\nassert get_next_position(4, 5) == 0\n", "\nassert get_next_position(2, 3) == 0\n", "\nassert get_next_position(1, 1) == 0\n", "\nassert get_next_position(3, 6) == 4\n", "\nassert get_next_position(5, 10) == 6\n", "\nassert get_next_position(9, 10) == 0\n", "\nassert get_ne... |
63ee888ec2c77207e167e37d435e6bae | [
{
"content": "Implémente une classe `TreeNode` pour représenter un nœud dans un arbre binaire. Chaque nœud doit avoir les attributs suivants :\n- `value` : un entier représentant la valeur stockée dans le nœud.\n- `left` : une référence au nœud enfant gauche, qui est une autre instance de `TreeNode` ou `None` s... | ["\nassert repr(TreeNode(1)) == \"TreeNode(1, None, None)\"\n", "\nassert repr(TreeNode(2, TreeNode(3))) == \"TreeNode(2, TreeNode(3, None, None), None)\"\n", "\nassert repr(TreeNode(4, None, TreeNode(5))) == \"TreeNode(4, None, TreeNode(5, None, None))\"\n", "\nassert repr(TreeNode(6, TreeNode(7), TreeNode(8))) == \"T... |
01ef1bda0ddf68bb846c9402eaa98425 | [
{
"content": "On te demande d'implémenter une fonction génératrice en Python qui génère la suite de Fibonacci jusqu'au `n`-ième terme. La suite de Fibonacci est définie comme suit : le premier terme est 0, le deuxième terme est 1, et chaque terme suivant est la somme des deux termes précédents. Ta fonction doit... | ["\nassert list(fibonacci(0)) == []\n", "\nassert list(fibonacci(1)) == [0]\n", "\nassert list(fibonacci(2)) == [0, 1]\n", "\nassert list(fibonacci(3)) == [0, 1, 1]\n", "\nassert list(fibonacci(5)) == [0, 1, 1, 2, 3]\n", "\nassert list(fibonacci(10)) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert list(fibonacci(15)... |
ed2eef9ac5880387818d961c541da7cd | [
{
"content": "On te donne une liste de dictionnaires. Implémente une fonction `sort_by_key` qui trie cette liste par ordre croissant en fonction de la valeur associée à une clé spécifiée. Si la clé n'est pas présente dans un dictionnaire, considère la valeur correspondante comme `None`. Ta fonction doit gérer c... | ["\nassert sort_by_key([{\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Bob\", \"age\": 20}, {\"name\": \"Charlie\", \"age\": 30}], \"age\") == [{\"name\": \"Bob\", \"age\": 20}, {\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Charlie\", \"age\": 30}]\n", "\nassert sort_by_key([{\"name\": \"Alice\"}, {\"name\": \"Bob... |
88594a689436927dd7aacb1bf28401bb | [
{
"content": "On te donne deux entiers positifs, `a` et `b`. Ta tâche est d'écrire une fonction Python qui calcule le Plus Petit Commun Multiple (PPCM) de ces deux nombres en utilisant la méthode du Plus Grand Diviseur Commun (PGCD). Implémente une fonction auxiliaire pour calculer le PGCD.\n\n**Entrée :**\n- D... | ["\nassert lcm(12, 18) == 36\n", "\nassert lcm(4, 5) == 20\n", "\nassert lcm(7, 3) == 21\n", "\nassert lcm(21, 6) == 42\n", "\nassert lcm(0, 5) == 0\n", "\nassert lcm(5, 0) == 0\n", "\nassert lcm(0, 0) == 0\n", "\nassert lcm(1, 1) == 1\n", "\nassert lcm(13, 17) == 221\n", "\nassert lcm(100, 25) == 100\n"] |
f64934125f3c021495aa7969b8ad7047 | [
{
"content": "On te demande de créer une fonction Python `generate_report()` qui génère un rapport CSV à partir d'une base de données SQLite. Le rapport doit inclure les colonnes suivantes : ID de l'employé, Nom, Département, Salaire mensuel et Prime annuelle. La fonction doit se connecter à une base de données... | ["\nassert generate_report() is None\n", "\nassert 'employee_report.csv' in os.listdir('.')\n", "\nassert open('employee_report.csv').readline().strip() == 'Employee ID,Name,Department,Monthly Salary,Annual Bonus'\n", "\nassert len(open('employee_report.csv').readlines()) > 1 # Assuming there is at least one employee ... |
6e9057d23159d8489a0475fe16aedcf8 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction qui renvoie l'index du premier caractère non répétitif dans la chaîne. S'il n'y a pas un tel caractère, renvoie -1.\n\n**Contraintes :**\n- La chaîne `s` est composée de lettres minuscules de l'alphabet anglais.... | ["\nassert first_unique_char(\"leetcode\") == 0\n", "\nassert first_unique_char(\"loveleetcode\") == 2\n", "\nassert first_unique_char(\"aabbcc\") == -1\n", "\nassert first_unique_char(\"abcdef\") == 0\n", "\nassert first_unique_char(\"aabbccddee\") == -1\n", "\nassert first_unique_char(\"a\") == 0\n", "\nassert first_... |
40f740e85fdce8d884113f5125cbe7f7 | [
{
"content": "On te donne une chaîne de caractères au format snake_case. Ta tâche est d'écrire une fonction Python qui convertit cette chaîne au format camelCase. Le premier mot de la chaîne camelCase doit être en minuscules, et la première lettre de chaque mot suivant doit être en majuscules.\n\n**Entrée :**\n... | ["\nassert snake_to_camel(\"convert_this_string_to_camel_case\") == \"convertThisStringToCamelCase\"\n", "\nassert snake_to_camel(\"hello_world\") == \"helloWorld\"\n", "\nassert snake_to_camel(\"singleword\") == \"singleword\"\n", "\nassert snake_to_camel(\"another_example_here\") == \"anotherExampleHere\"\n", "\nasse... |
c941df5d1df76f22b1d240fcceca0e7c | [
{
"content": "On te demande d'implémenter une fonction pour calculer le gain de couverture à partir des lectures de flanquement des appâts voisins dans l'analyse des données génomiques. Étant donné une liste de tuples, chacun contenant `target_size`, `insert_size` et `gap_size`, ta fonction doit renvoyer une li... | ["\nassert calculate_coverage_gain([(100, 200, 50)]) == [0.25]\n", "\nassert calculate_coverage_gain([(100, 200, 150)]) == [0.0]\n", "\nassert calculate_coverage_gain([(100, 200, 100)]) == [0.0]\n", "\nassert calculate_coverage_gain([(100, 200, 0)]) == [0.25]\n", "\nassert calculate_coverage_gain([(100, 200, 99)]) == [... |
476b523e22ebc1e7d9a28fb8b0e25339 | [
{
"content": "Tu développes une fonction pour gérer les sessions utilisateur dans une application web. La session a une durée maximale et démarre à un moment précis. De plus, l'activité de l'utilisateur peut réinitialiser le minuteur de session si elle se produit dans un certain délai. Ta tâche est de mettre en... | ["\nassert calculate_remaining_session_time(None, 1672531200, 1672534800, 1672534200, 900) == None\n", "\nassert calculate_remaining_session_time(-1, 1672531200, 1672534800, 1672534200, 900) == None\n", "\nassert calculate_remaining_session_time(3600, 1672531200, 1672534800, 1672534200, 900) == 1500\n", "\nassert calcu... |
39283ecac42b78cee6c19212be9a27a8 | [
{
"content": "On te demande de formater une séquence de tâches selon les conventions « Falcon ». La séquence est fournie sous forme de liste d'entiers, et la sortie doit être une seule chaîne de caractères où chaque tâche est séparée par un tiret (-). Si des tâches dupliquées se suivent, elles doivent être fusi... | ["\nassert falcon_format_sequence([1, 2, 3, 4]) == \"1-2-3-4\"\n", "\nassert falcon_format_sequence([1, 1, 2, 2, 3, 3]) == \"1^2-2^2-3^2\"\n", "\nassert falcon_format_sequence([1, 2, 2, 3, 4, 4, 4, 5]) == \"1-2^2-3-4^3-5\"\n", "\nassert falcon_format_sequence([1, 1, 1, 1, 1]) == \"1^5\"\n", "\nassert falcon_format_sequ... |
122a655fb3241c8275e90f5d64bc7fd8 | [
{
"content": "On te demande d'implémenter une fonction `validate_input(x)` qui effectue les opérations suivantes :\n\n- Si `x` est un tableau numpy, retourne `True`.\n- Si `x` est une liste, vérifie récursivement chaque élément de la liste. Si un élément est un tableau numpy, retourne `True`.\n- Si `x` n'est ni... | ["\nassert validate_input(np.array([1, 2, 3])) == True\n", "\nassert validate_input([1, 2, np.array([3, 4])]) == True\n", "\nassert validate_input([1, 2, 3]) == False\n", "\nassert validate_input(42) == False\n", "\nassert validate_input([1, [2, [3, np.array([4])]]]) == True\n", "\nassert validate_input([]) == False\n"... |
0963da5039dff243da1635ad0e2dde44 | [
{
"content": "On te demande d'implémenter une classe nommée `Employee` pour gérer les dossiers des employés dans la base de données d'une entreprise. La classe `Employee` doit encapsuler les attributs suivants :\n- `name` : une chaîne de caractères représentant le nom de l'employé.\n- `id` : un entier représent... | ["\nassert Employee(\"John Doe\", 123, \"HR\", 50000).name == \"John Doe\"\n", "\nassert Employee(\"John Doe\", 123, \"HR\", 50000).id == 123\n", "\nassert Employee(\"John Doe\", 123, \"HR\", 50000).department == \"HR\"\n", "\nassert Employee(\"John Doe\", 123, \"HR\", 50000).salary == 50000\n", "\nemp = Employee(\"Jan... |
90ff5049b6583b125db2f8f7ba680c09 | [
{
"content": "On te donne une grille 2D de taille `n x n`. Chaque cellule de la grille est identifiée par ses indices de ligne et de colonne, en commençant par `0`. Le coin supérieur gauche de la grille est l'origine `(0, 0)`. Ta tâche est de mettre en œuvre une fonction `get_relative_positions(n)` qui renvoie ... | ["\nassert np.array_equal(get_relative_positions(1), np.array([[[2, 3]]]))\n", "\nassert np.array_equal(get_relative_positions(2), np.array([[[2, 3], [2, 4]], [[3, 3], [3, 4]]]))\n", "\nassert np.array_equal(get_relative_positions(3)[0, 0], np.array([2, 3]))\n", "\nassert np.array_equal(get_relative_positions(3)[0, 1],... |
ada5270f3202656e3c350230358576e6 | [
{
"content": "On te demande d'implémenter une fonction nommée `validate_input` qui détermine si une chaîne de caractères donnée peut être interprétée comme un nombre à virgule flottante valide selon la norme IEEE 754. La fonction doit renvoyer `True` si la chaîne représente un nombre à virgule flottante valide ... | ["\nassert validate_input(\"123.456\") == True\n", "\nassert validate_input(\"-123.456\") == True\n", "\nassert validate_input(\"+123.456\") == True\n", "\nassert validate_input(\"123e10\") == True\n", "\nassert validate_input(\"123E-10\") == True\n", "\nassert validate_input(\"0x1A3.4Fp+2\") == True\n", "\nassert vali... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.