id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
07f105cfe7ed7dfd13816acf3bd70378 | [
{
"content": "On te donne une chaîne de caractères `s` et une liste de sous-chaînes `substrings`. Ta tâche est de mettre en œuvre une fonction `find_substring_occurrences(s, substrings)` qui renvoie un dictionnaire. Le dictionnaire doit associer chaque sous-chaîne de la liste `substrings` au nombre de fois qu'e... | ["\nassert find_substring_occurrences(\"hello world, hello universe\", [\"hello\", \"world\", \"universe\"]) == {\"hello\": 2, \"world\": 1, \"universe\": 1}\n", "\nassert find_substring_occurrences(\"abcabcabc\", [\"abc\", \"ab\", \"c\"]) == {\"abc\": 3, \"ab\": 2, \"c\": 3}\n", "\nassert find_substring_occurrences(\"... |
bb96a09f9a49b23902e52c2ce63a08cc | [
{
"content": "On te demande d'implémenter une fonction pour générer la suite de Fibonacci jusqu'au $n^{ième}$ terme. La suite de Fibonacci est définie comme suit : $F(0) = 0$, $F(1) = 1$, et $F(n) = F(n-1) + F(n-2)$ pour $n > 1$. Écris une fonction en Python qui prend un entier $n$ en entrée et renvoie le $n^{i... | ["\nassert fib(0) == 0\n", "\nassert fib(1) == 1\n", "\nassert fib(2) == 1\n", "\nassert fib(3) == 2\n", "\nassert fib(4) == 3\n", "\nassert fib(5) == 5\n", "\nassert fib(6) == 8\n", "\nassert fib(7) == 13\n", "\nassert fib(8) == 21\n", "\nassert fib(9) == 34\n"] |
184d1a9d5f145ab89c3d7ac3eeb0f7b1 | [
{
"content": "On te demande d'implémenter une classe `Book` pour un système de gestion de bibliothèque. La classe doit encapsuler les propriétés d'un livre et fournir des fonctionnalités pour gérer sa disponibilité. La classe `Book` doit avoir les attributs suivants :\n- `title` : une chaîne de caractères repré... | ["\nassert Book(\"1984\", \"George Orwell\", \"1234567890\", 3).available_copies == 3\n", "\nbook = Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"0987654321\", 2)\nbook.check_out()\nassert book.available_copies == 1\n", "\nbook = Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", \"1122334455\", 1)\nbook.check_out... |
07f1a04667e5a27e2b8b27391f9b51d5 | [
{
"content": "On te donne une chaîne JSON représentant un objet simple. Ta tâche est d'écrire une fonction Python qui convertit cette chaîne JSON en un dictionnaire Python. La fonction doit gérer les structures JSON de base contenant des chaînes de caractères, des nombres et des objets.\n\n**Entrée :**\n- Une s... | ["\nassert json_to_dict('{\"name\": \"Alice\", \"age\": 30, \"city\": \"New York\"}') == {\"name\": \"Alice\", \"age\": 30, \"city\": \"New York\"}\n", "\nassert json_to_dict('{\"key\": \"value\"}') == {\"key\": \"value\"}\n", "\nassert json_to_dict('{}') == {}\n", "\nassert json_to_dict('{\"numbers\": [1, 2, 3, 4, 5]}... |
87eec8a3a8a6d42b0952d52382c5fe63 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente une phrase. Ta tâche est de mettre en œuvre une fonction qui renvoie la phrase contenant le nombre maximum de mots. Si plusieurs phrases ont le même nombre maximum de mots, renvoie la première rencontrée.\n\n**Entrée :**\n... | ["\nassert longest_sentence([\"This is a test\", \"Another test sentence here\"]) == \"Another test sentence here\"\n", "\nassert longest_sentence([\"Short\", \"A bit longer sentence\"]) == \"A bit longer sentence\"\n", "\nassert longest_sentence([\"Equal length\", \"Equal length\"]) == \"Equal length\"\n", "\nassert l... |
6f29c03b4c0e7460c836ac9ee28d19cf | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction `filter_and_sort_strings(strings)` qui traite cette liste en supprimant toutes les chaînes qui ne commencent pas par une voyelle (majuscule ou minuscule) puis en triant les chaînes restantes par ordre alphabéti... | ["\nassert filter_and_sort_strings([\"apple\", \"banana\", \"orange\", \"umbrella\", \"kiwi\", \"elderberry\"]) == [\"apple\", \"elderberry\", \"orange\", \"umbrella\"]\n", "\nassert filter_and_sort_strings([\"grape\", \"kiwi\", \"melon\", \"apricot\"]) == [\"apricot\"]\n", "\nassert filter_and_sort_strings([\"umbrella... |
b62e3926fca44e5370f795866e359754 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python pour gérer les informations sur les livres. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- Initialiser un livre avec son `title`, son `author`, son `publisher` et son `year_published`.\n- Fournir une méthode pour récupé... | ["\nassert Book(\"1984\", \"George Orwell\", \"Secker & Warburg\", 1949).get_details() == \"Title: 1984, Author: George Orwell, Publisher: Secker & Warburg, Year Published: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"J.B. Lippincott & Co.\", 1960).get_details() == \"Title: To Kill a Mockingbi... |
41e71ccbc1678f01d89b43277f15276a | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `k`. Ta tâche est de trouver le nombre maximal de caractères distincts qui peuvent être présents dans n'importe quelle sous-chaîne de `s` ayant une longueur exactement égale à `k`. S'il existe plusieurs sous-chaînes avec le même nombre maximal ... | ["\nassert max_distinct_chars(\"abcdefg\", 3) == 0\n", "\nassert max_distinct_chars(\"aabbcc\", 2) == 0\n", "\nassert max_distinct_chars(\"abcabcabc\", 3) == 0\n", "\nassert max_distinct_chars(\"aabbccddeeff\", 4) == 0\n", "\nassert max_distinct_chars(\"abc\", 4) == -1\n", "\nassert max_distinct_chars(\"aabbcc\", 3) ==... |
81211f75eeb6a146a7dbce6b01abde98 | [
{
"content": "On te demande d'implémenter une fonction `batch_reparameterize_v2` qui effectue l'astuce de reparamétrisation pour un lot de points de données dans un Autoencodeur Variationnel (VAE). La fonction doit calculer manuellement les valeurs epsilon en utilisant une boucle et les appliquer aux moyennes e... | ["\nassert batch_reparameterize_v2(torch.tensor([[0.0, 0.0]]), torch.tensor([[0.0, 0.0]]), 1).shape == (1, 1, 2)\n", "\nassert batch_reparameterize_v2(torch.tensor([[1.0, 2.0], [3.0, 4.0]]), torch.tensor([[0.0, 0.0], [0.0, 0.0]]), 2).shape == (2, 2, 2)\n", "\nassert batch_reparameterize_v2(torch.tensor([[0.0, 0.0]]), t... |
ebfa3ff79a3125f84f4b095149103462 | [
{
"content": "On te donne une liste de `n` points dans un plan 2D, où chaque point est représenté comme un tuple `(x, y)`. Ta tâche est d'écrire une fonction qui calcule la pente moyenne de toutes les lignes qui peuvent être formées en connectant chaque paire de points de la liste. La pente d'une ligne est calc... | ["\nassert average_slope([(1, 2), (3, 4)]) == 1.0\n", "\nassert average_slope([(1, 1), (2, 2), (3, 3)]) == 1.0\n", "\nassert average_slope([(1, 1), (1, 2), (2, 2)]) == 1.0\n", "\nassert average_slope([(0, 0), (1, 1), (2, 2), (3, 3)]) == 1.0\n", "\nassert average_slope([(1, 2), (1, 3)]) == None\n", "\nassert average_slo... |
dafc86f5a2fea46bdb01943da09b9c10 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction `calculate_overlap_percentage` qui calcule le pourcentage d'éléments communs aux deux listes. La fonction doit renvoyer une valeur flottante représentant le pourcentage de chevauchement. Si les deux... | ["\nassert calculate_overlap_percentage([1, 2, 3], [3, 4, 5]) == 33.33333333333333\n", "\nassert calculate_overlap_percentage([1, 2, 3], [4, 5, 6]) == 0.0\n", "\nassert calculate_overlap_percentage([], [1, 2, 3]) == 0.0\n", "\nassert calculate_overlap_percentage([1, 2, 3], []) == 0.0\n", "\nassert calculate_overlap_per... |
6282a19c8adfbe1a950fc81612e91acf | [
{
"content": "Implémente une classe Python `Employee` avec les spécifications suivantes :\n\n- La classe doit avoir un initialiseur qui accepte les paramètres suivants :\n - `name` : une chaîne de caractères représentant le nom de l'employé.\n - `position` : une chaîne de caractères représentant le titre de p... | ["\nassert Employee(\"John Doe\", \"Software Engineer\", 75000, \"2023-01-15\", \"IT\").name == \"John Doe\"\n", "\nassert Employee(\"John Doe\", \"Software Engineer\", 75000, \"2023-01-15\", \"IT\").position == \"Software Engineer\"\n", "\nassert Employee(\"John Doe\", \"Software Engineer\", 75000, \"2023-01-15\", \"I... |
1e02841b5255f7c4c1d0383b5d2eceaa | [
{
"content": "On te donne une matrice représentée comme une liste de listes contenant des entiers. Ta tâche est d'écrire une fonction Python qui trouve et renvoie l'entier le plus grand de la matrice. La matrice aura au moins une ligne et une colonne.\n\n**Exemple d'entrée :**\n```\n[[1, 2, 3], [4, 5, 6], [7, 8... | ["\nassert find_largest_number([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == 9\n", "\nassert find_largest_number([[9, 8, 7], [6, 5, 4], [3, 2, 1]]) == 9\n", "\nassert find_largest_number([[10]]) == 10\n", "\nassert find_largest_number([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) == -1\n", "\nassert find_largest_number([[0, 0, 0... |
9f209ed87e7b395c1b083e4e3a111e9e | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est de mettre en œuvre une fonction qui trouve la plus longue sous-chaîne palindromique dans `s`. S'il existe plusieurs sous-chaînes de longueur maximale identique, retourne celle qui apparaît en premier dans la chaîne.\n\n**Entrée :**\n- Une ... | ["\nassert longest_palindromic_substring(\"babad\") == \"bab\"\n", "\nassert longest_palindromic_substring(\"cbbd\") == \"bb\"\n", "\nassert longest_palindromic_substring(\"a\") == \"a\"\n", "\nassert longest_palindromic_substring(\"ac\") == \"a\"\n", "\nassert longest_palindromic_substring(\"racecar\") == \"racecar\"\... |
95f77fe9c1796a20cf842c70554568fa | [
{
"content": "On te donne deux listes : `timestamps` et `temperatures`. Chaque élément dans `timestamps` correspond au moment auquel la lecture de température dans `temperatures` a été enregistrée. Ta tâche est de trouver le timestamp le plus ancien après un `start_timestamp` donné où la température est dans un... | ["\nassert find_timestamp([1, 2, 3, 4, 5], [20, 22, 21, 23, 24], 2, 10) == 3\n", "\nassert find_timestamp([1, 2, 3, 4, 5], [20, 22, 21, 23, 24], 3, 5) == 4\n", "\nassert find_timestamp([1, 2, 3, 4, 5], [20, 22, 21, 23, 24], 1, 20) == 1\n", "\nassert find_timestamp([1, 2, 3, 4, 5], [20, 22, 21, 23, 24], 5, 10) == None\n... |
48fcfba3b76db38270b1f981966ec8d9 | [
{
"content": "On te donne deux entiers `a` et `b`. Ta tâche est d'écrire une fonction `lcm_iter(a, b)` qui calcule le plus petit commun multiple (PPCM) de ces deux entiers en utilisant une approche itérative. Le PPCM de deux entiers est le plus petit entier positif qui est divisible par les deux nombres.\n\nTa ... | ["\nassert lcm_iter(12, 18) == 36\n", "\nassert lcm_iter(5, 7) == 35\n", "\nassert lcm_iter(21, 6) == 42\n", "\nassert lcm_iter(8, 9) == 72\n", "\nassert lcm_iter(1, 1) == 1\n", "\nassert lcm_iter(0, 5) == 0\n", "\nassert lcm_iter(5, 0) == 0\n", "\nassert lcm_iter(15, 20) == 60\n", "\nassert lcm_iter(7, 13) == 91\n", "... |
0ee2b34b3bc785c8538b85c09b8029a3 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `count_frequencies` qui renvoie une liste de listes, où chaque sous-liste contient un entier de la liste d'entrée et sa fréquence, sans utiliser de fonctions intégrées pour créer ou manipuler des dictionnaires, et sans utiliser d'... | ["\nassert count_frequencies([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) == [[1, 1], [2, 2], [3, 3], [4, 4]]\n", "\nassert count_frequencies(['a', 'b', 'a', 'c', 'b', 'a']) == [['a', 3], ['b', 2], ['c', 1]]\n", "\nassert count_frequencies([]) == []\n", "\nassert count_frequencies([1, 1, 1, 1, 1]) == [[1, 5]]\n", "\nassert count_fr... |
4acc1a54306192ee0f44c95f981ab790 | [
{
"content": "On te donne deux listes de chaînes de caractères, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction `find_common_words` qui renvoie une liste de mots qui apparaissent dans les deux listes, en ignorant les différences de casse. L'ordre des mots dans la liste de sortie n'a pas d'impor... | ["\nassert find_common_words([\"Apple\", \"Banana\", \"Cherry\"], [\"banana\", \"apple\", \"Date\"]) == [\"apple\", \"banana\"]\n", "\nassert find_common_words([\"Cat\", \"Dog\", \"Fish\"], [\"dog\", \"elephant\", \"fish\"]) == [\"dog\", \"fish\"]\n", "\nassert find_common_words([\"Hello\", \"World\"], [\"world\", \"he... |
aff0c95986b05b11117b768c6ccec31d | [
{
"content": "On te demande de traiter un fichier texte qui contient une liste de livres. Chaque ligne du fichier représente un livre, avec le titre, l'auteur et l'année de publication séparés par des tabulations. Ton objectif est d'écrire une fonction `read_books` qui lit ce fichier et renvoie une liste de dic... | ["\nassert read_books(\"test_books.txt\") == [{\"title\": \"Book One\", \"author\": \"Author A\", \"year\": \"2001\"}, {\"title\": \"Book Two\", \"author\": \"Author B\", \"year\": \"2002\"}]\n", "\nassert read_books(\"empty_file.txt\") == []\n", "\nassert read_books(\"file_with_empty_lines.txt\") == [{\"title\": \"Boo... |
0b8049e0d787f0e563f76a4710626767 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction qui renvoie une nouvelle liste avec les entiers triés en fonction de la somme de leurs chiffres par ordre croissant. Si deux entiers ont la même somme de chiffres, ils doivent être triés par leur valeur d'origine par ordr... | ["\nassert custom_sort([56, 34, 12, 23, 45, 67]) == [12, 23, 34, 45, 56, 67]\n", "\nassert custom_sort([111, 22, 3, 44, 5]) == [3, 5, 22, 44, 111]\n", "\nassert custom_sort([99, 18, 81, 27, 72]) == [18, 27, 72, 81, 99]\n", "\nassert custom_sort([102, 21, 12, 201, 120]) == [12, 21, 102, 120, 201]\n", "\nassert custom_so... |
e635230358af9f301160c59c14e0593c | [
{
"content": "Étant donné deux chaînes de caractères `str1` et `str2`, écris une fonction pour trouver la plus longue sous-chaîne commune entre elles. La fonction doit renvoyer la plus longue sous-chaîne commune. S'il existe plusieurs sous-chaînes de longueur maximale identique, renvoie l'une d'entre elles.\n\n... | ["\nassert longest_common_substring(\"abcde\", \"abfce\") == \"ab\"\n", "\nassert longest_common_substring(\"abcdef\", \"zabcf\") == \"abc\"\n", "\nassert longest_common_substring(\"hello\", \"yellow\") == \"ello\"\n", "\nassert longest_common_substring(\"abcd\", \"efgh\") == \"\"\n", "\nassert longest_common_substring... |
d38a0b0a0a491c70929196b77ae1379f | [
{
"content": "On te donne un tableau trié d'entiers et une valeur cible. Implémente un algorithme de recherche binaire pour trouver l'indice de la valeur cible dans le tableau. Si la valeur cible n'est pas présente dans le tableau, retourne -1.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ... | ["\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15], 7) == 3\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15], 1) == 0\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15], 15) == 7\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15], 5) == 2\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15], 10) =... |
a6053ce9d7bff3265e2306fa0c463334 | [
{
"content": "On te donne une liste d'entiers représentant les prix d'une action unique sur une période donnée. Ta tâche est de déterminer le profit maximal qui peut être réalisé en achetant et en vendant l'action au plus deux fois, avec la contrainte que le deuxième achat doit avoir lieu après la première vent... | ["\nassert max_profit_twice([3, 2, 6, 5, 0, 3]) == 7\n", "\nassert max_profit_twice([1, 2, 3, 4, 5]) == 4\n", "\nassert max_profit_twice([5, 4, 3, 2, 1]) == 0\n", "\nassert max_profit_twice([1, 2, 3, 4, 5, 0, 6]) == 8\n", "\nassert max_profit_twice([10, 22, 5, 75, 65, 80]) == 87\n", "\nassert max_profit_twice([1, 1, 1,... |
0da96f4eb59df195d37c85662754fb48 | [
{
"content": "On te donne une liste d'entiers, `input_line`, et un objet `dataset`. L'objet `dataset` contient deux attributs : `pad_idx` et `vocab`. `pad_idx` est un entier représentant un indice de remplissage, et `vocab` est un objet de type dictionnaire avec une méthode `itos` qui mappe les indices entiers ... | ["\nassert convert_to_sentence([1, 2, 3, 4, 5, 0], dataset) == \"word1 word2 word3 word4 word5\"\n", "\nassert convert_to_sentence([1, 2, 3, 2, 0], dataset) == \"word1 word2 word3 word2\"\n", "\nassert convert_to_sentence([1, 2, 3, 4, 5, 6, 2, 0], dataset) == \"word1 word2 word3 word4 word5 word6 word2\"\n", "\nassert ... |
0d75c28df055df236ae5d19d7be60238 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'identifier et de renvoyer une liste d'entiers qui apparaissent plus d'une fois dans la liste d'entrée. L'ordre des éléments dans la liste de sortie n'a pas d'importance, et chaque nombre dupliqué ne doit apparaître qu'une seule fois dans le résultat.... | ["\nassert find_duplicate_numbers([1, 2, 3, 4, 5, 2, 3, 6, 7, 8, 8]) == [2, 3, 8]\n", "\nassert find_duplicate_numbers([1, 1, 1, 1, 1]) == [1]\n", "\nassert find_duplicate_numbers([1, 2, 3, 4, 5]) == []\n", "\nassert find_duplicate_numbers([]) == []\n", "\nassert find_duplicate_numbers([10, 20, 30, 40, 50, 10, 20, 60, ... |
835857041ee664350e988beb6a973242 | [
{
"content": "Tu es chargé de développer une fonction pour traiter et stocker les informations sur les actions d'une entreprise dans une base de données SQL. Chaque action est représentée par un dictionnaire contenant les attributs suivants : `type`, `amount`, `nw` (valeur nominale), `currency` et `voice` (droi... | ["\nassert insert_shares_into_db([], 12345) is None\n", "\nassert insert_shares_into_db([{'type': 'preferred', 'amount': 100, 'nw': 10.5, 'currency': 'USD', 'voice': 2, 'note': 'Important note', 'voting-history': {'2020': 100, '2021': 150}}], 12345) is None\n", "\nassert insert_shares_into_db([{'type': 'common', 'nw': ... |
5e6bebb16e4521f8dbe5b82015011569 | [
{
"content": "Étant donné un entier `n`, ta tâche est d'écrire une fonction `find_prime_factors(n)` qui renvoie une liste de tous les facteurs premiers de `n` dans l'ordre croissant. Chaque facteur premier doit apparaître dans la liste autant de fois qu'il divise `n`. Par exemple, si `n` est `18`, la fonction d... | ["\nassert find_prime_factors(18) == [2, 3, 3]\n", "\nassert find_prime_factors(28) == [2, 2, 7]\n", "\nassert find_prime_factors(1) == []\n", "\nassert find_prime_factors(2) == [2]\n", "\nassert find_prime_factors(3) == [3]\n", "\nassert find_prime_factors(4) == [2, 2]\n", "\nassert find_prime_factors(100) == [2, 2, 5... |
81ec330094766e471630978414b12d7c | [
{
"content": "On te demande d'implémenter une fonction `convert_to_json_string` qui convertit récursivement un dictionnaire ou une liste Python donné en une chaîne JSON. La fonction doit respecter les règles suivantes :\n\n- Si l'entrée est `None`, un entier, un flottant ou une chaîne vide, retourne `None`.\n- ... | ["\nassert convert_to_json_string({'key1': 'value1', 'key2': [1, 2, 'three']}) == '{\"key1\":\"value1\",\"key2\":[1,2]}'\n", "\nassert convert_to_json_string([1, 2, {'subkey': 'subvalue'}]) == '[1,2,{\"subkey\":\"subvalue\"}]'\n", "\nassert convert_to_json_string(\"some string\") == ''\n", "\nassert convert_to_json_str... |
2250a5939039b6d1e46894dcbe9a6a6d | [
{
"content": "On te donne un dictionnaire Python `data`. Ta tâche est d'implémenter une fonction `convert_to_json(data)` qui convertit ce dictionnaire en une chaîne JSON avec une indentation de 4 espaces. La chaîne JSON ne doit pas inclure les paires clé-valeur où la valeur est `None`.\n\n**Entrée :**\n- Un dic... | ["\nassert convert_to_json({\"name\": \"Alice\", \"age\": 30, \"city\": None}) == '{\\n \"name\": \"Alice\",\\n \"age\": 30\\n}'\n", "\nassert convert_to_json({\"key1\": None, \"key2\": None}) == '{}'\n", "\nassert convert_to_json({\"a\": 1, \"b\": 2, \"c\": 3}) == '{\\n \"a\": 1,\\n \"b\": 2,\\n \"c\": ... |
d85fa071bb979bff9bfedd00c077e885 | [
{
"content": "On te demande d'implémenter une fonction pour calculer la factorielle d'un entier non négatif en utilisant la récursion. Ta fonction doit gérer correctement toutes les entrées valides et renvoyer la factorielle du nombre donné.\n\n**Entrée :**\n- Un seul entier `n` (0 ≤ n ≤ 20).\n\n**Sortie :**\n-... | ["\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... |
35440a26710f8c9fbb64df8e57332a1c | [
{
"content": "Implémente une classe Python nommée `Stack` qui prend en charge les opérations suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élément du sommet de la pile. Lève une exception `ValueError` avec le message \"pop from empty stack\" si la pile ... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().peek() == None\n", "\ns = Stack(); s.push(1); assert s.peek() == 1\n", "\ns = Stack(); s.push(1); s.push(2); assert s.pop() == 2\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.peek() == 1\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); s.pop();... |
a63c0914d9420c97805b04b8c66deb5b | [
{
"content": "On te demande de concevoir une fonction pour générer un identifiant de session unique pour une application web. L'identifiant doit être une chaîne de 32 caractères alphanumériques aléatoires. Ta fonction doit garantir que deux identifiants de session ne soient jamais identiques entre différentes s... | ["\nassert len(generate_unique_session_id()) == 32\n", "\nassert generate_unique_session_id().isalnum()\n", "\nassert generate_unique_session_id() != generate_unique_session_id()\n", "\nassert generate_unique_session_id() != generate_unique_session_id()\n", "\nassert generate_unique_session_id() != generate_unique_sess... |
60fdc575c82e4406b793ec92c90cf229 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui renvoie les deux plus grands nombres distincts de la liste. S'il y a moins de deux nombres distincts, la fonction doit renvoyer `None`.\n\n**Exemple d'entrée :**\n```\n[4, 1, 2, 2, 5, 5, 3]\n```\n\n**Exemple de sortie :**\n```... | ["\nassert two_largest_distinct_numbers([4, 1, 2, 2, 5, 5, 3]) == (5, 4)\n", "\nassert two_largest_distinct_numbers([10, 20, 20, 10]) == (20, 10)\n", "\nassert two_largest_distinct_numbers([1, 2, 3, 4, 5]) == (5, 4)\n", "\nassert two_largest_distinct_numbers([5, 5, 5, 5, 5]) == None\n", "\nassert two_largest_distinct_n... |
0b49dc8f449e7a4573e3bffca4d09356 | [
{
"content": "On te donne un entier non négatif `n`. Ta tâche est d'écrire une fonction `prime_factorization(n)` qui renvoie une liste de ses facteurs premiers dans l'ordre croissant. Si `n` est inférieur à 2, renvoie une liste vide.\n\n**Contraintes :**\n- 0 ≤ n ≤ 10^6\n\n**Exemple d'entrée :**\n```\n120\n```\... | ["\nassert prime_factorization(0) == []\n", "\nassert prime_factorization(1) == []\n", "\nassert prime_factorization(2) == [2]\n", "\nassert prime_factorization(3) == [3]\n", "\nassert prime_factorization(4) == [2, 2]\n", "\nassert prime_factorization(5) == [5]\n", "\nassert prime_factorization(6) == [2, 3]\n", "\nasse... |
fe5a2fa92ceb1f1f039e59f94a58b6b4 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python qui simule les fonctionnalités de base d'une voiture. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `make` : une chaîne de caractères représentant la marque de la voiture.\n - `model` : une chaîne de cara... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020).speed == 0\n", "\ncar = Car(\"Honda\", \"Civic\", 2018); car.accelerate(30); assert car.speed == 30\n", "\ncar = Car(\"Ford\", \"Mustang\", 2021); car.accelerate(50); car.brake(20); assert car.speed == 30\n", "\ncar = Car(\"Chevrolet\", \"Camaro\", 2022); car.accelerate(100... |
f0c1ac8f5724c53ed400bf64d4076aeb | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `extract_keywords` qui renvoie une liste des 5 mots-clés les plus fréquents dans la chaîne. Un mot-clé est défini comme un mot qui n'est pas un mot d'arrêt courant (par exemple, \"and\", \"the\", \"is\", etc.)... | ["\nassert extract_keywords(\"The quick brown fox jumps over the lazy dog. The dog barked at the fox.\") == ['the', 'fox', 'dog', 'quick', 'brown']\n", "\nassert extract_keywords(\"Python is great and Python is fun.\") == ['python', 'is', 'great', 'fun']\n", "\nassert extract_keywords(\"Hello world, hello Python. Pytho... |
73185743f00f917db5fce24604f06b14 | [
{
"content": "On te donne trois entiers positifs. Ta tâche est d'écrire une fonction `gcd_three` qui calcule le plus grand commun diviseur (PGCD) de ces trois entiers en utilisant uniquement des opérations arithmétiques de base, des boucles et des instructions conditionnelles. Le PGCD de trois entiers est le pl... | ["\nassert gcd_three(60, 48, 36) == 12\n", "\nassert gcd_three(10, 20, 30) == 10\n", "\nassert gcd_three(7, 14, 28) == 7\n", "\nassert gcd_three(3, 5, 7) == 1\n", "\nassert gcd_three(100, 200, 300) == 100\n", "\nassert gcd_three(45, 90, 135) == 45\n", "\nassert gcd_three(1, 1, 1) == 1\n", "\nassert gcd_three(0, 0, 5) =... |
d3e806803d31ababce8cd9472327a873 | [
{
"content": "On te demande d'implémenter une classe `Library` en Python. La classe doit prendre en charge les opérations suivantes :\n- `add_book(book)` : Ajoute un livre à la bibliothèque.\n- `remove_book(book)` : Supprime un livre de la bibliothèque s'il existe. Si le livre n'est pas trouvé, affiche un messa... | ["\nassert Library().list_books() == []\n", "\nassert Library().add_book(\"1984\") is None\n", "\nassert Library().list_books() == []\n", "\nlib = Library()\nlib.add_book(\"1984\")\nassert lib.list_books() == [\"1984\"]\n", "\nlib = Library()\nlib.add_book(\"1984\")\nlib.add_book(\"Brave New World\")\nassert lib.list_b... |
eab8b206dd6082a4b9ba14c72686687f | [
{
"content": "On te donne trois fonctions `func1`, `func2` et `func3`, ainsi qu’une fonction de délai `delay_func`. Implémente une fonction `sequence_executor` qui applique cycliquement ces fonctions `n` fois, chaque application étant précédée d’un délai. Le délai pour chaque application de fonction est détermi... | ["\nassert sequence_executor(lambda: None, lambda: None, lambda: None, lambda _, __: 0, n=0) == None\n", "\nassert sequence_executor(lambda: None, lambda: None, lambda: None, lambda _, __: 0, n=1) == None\n", "\nassert sequence_executor(lambda: None, lambda: None, lambda: None, lambda _, __: 0, n=5) == None\n", "\nasse... |
620016e64bcd62b3f053f8e45ab99d8d | [
{
"content": "On te demande d'implémenter une fonction `find_numbers_with_k_factors(k, start, end)` qui identifie tous les entiers dans une plage spécifiée `[start, end]` qui possèdent exactement `k` facteurs premiers distincts. Tu dois écrire ta propre logique pour la factorisation première et la vérification ... | ["\nassert find_numbers_with_k_factors(1, 1, 10) == [2, 3, 5, 7]\n", "\nassert find_numbers_with_k_factors(2, 10, 50) == [14, 21, 22, 26, 33, 34, 35, 38, 39, 46, 49]\n", "\nassert find_numbers_with_k_factors(3, 100, 200) == [102, 105, 110, 114, 117, 118, 122, 123, 129, 130, 133, 134, 138, 141, 142, 143, 145, 146, 154, ... |
3decd4432b525d0a727b2570c83ecb65 | [
{
"content": "On te donne une liste d'entiers `a_list`. Ta tâche est d'implémenter une fonction `create_alternating_dict(a_list)` qui construit un dictionnaire selon les règles suivantes :\n\n- Si la liste contient des nombres négatifs, les clés doivent être \"key_odd\" pour les indices pairs et \"key_even\" po... | ["\nassert create_alternating_dict([1, 2, 3, 4, 5]) == {\"key_even_0\": 1, \"key_odd_1\": 2, \"key_even_2\": 3, \"key_odd_3\": 4, \"key_even_4\": 5}\n", "\nassert create_alternating_dict([-1, -2, -3, -4, -5]) == {\"key_odd_0\": -1, \"key_even_1\": -2, \"key_odd_2\": -3, \"key_even_3\": -4, \"key_odd_4\": -5}\n", "\nass... |
bcddb49f18caf3d7c8ef023c5aa1faa9 | [
{
"content": "On te donne un tableau `numbers` composé de `n` entiers. Ta tâche est de réorganiser le tableau sur place de telle sorte que tous les nombres pairs apparaissent avant tous les nombres impairs. L'ordre relatif des nombres pairs et impairs n'a pas besoin d'être conservé. Ta solution doit avoir une c... | ["\nassert partition_even_odd([3, 8, 5, 12, 7, 10, 6, 2]) is None\n", "\nassert all(x % 2 == 0 for x in [3, 8, 5, 12, 7, 10, 6, 2][:4])\n", "\nassert all(x % 2 != 0 for x in [3, 8, 5, 12, 7, 10, 6, 2][4:])\n", "\nassert partition_even_odd([1, 3, 5, 7, 9]) is None\n", "\nassert [1, 3, 5, 7, 9] == [1, 3, 5, 7, 9]\n", "\n... |
2b060d54acf3d19e90b55ad6a609f529 | [
{
"content": "On te donne une chaîne JSON. Ta tâche est d'écrire une fonction Python qui convertit cette chaîne JSON en un dictionnaire Python. Ta fonction doit gérer de manière élégante les erreurs et exceptions potentielles. Si la chaîne JSON est invalide, ta fonction doit renvoyer `None` et afficher un messa... | ["\nassert parse_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}') == {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}\n", "\nassert parse_json('{\"key\": \"value\", \"number\": 123}') == {\"key\": \"value\", \"number\": 123}\n", "\nassert parse_json('{\"nested\": {\"key\": \"value\"}, \"list\"... |
567bb9a11694fe9881f9b6b8e5eda380 | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente les coordonnées (x, y) d'un point dans un plan cartésien. Ta tâche est d'écrire une fonction Python qui trie ces points en fonction de leur distance euclidienne par rapport à l'origine (0, 0). La fonction doit renvoyer une nouvelle liste ... | ["\nassert sort_by_distance([(1, 2), (3, 4), (0, 0), (-1, -1)]) == [(0, 0), (-1, -1), (1, 2), (3, 4)]\n", "\nassert sort_by_distance([(0, 0), (1, 1), (2, 2), (3, 3)]) == [(0, 0), (1, 1), (2, 2), (3, 3)]\n", "\nassert sort_by_distance([(3, 4), (1, 2), (5, 12), (8, 15)]) == [(1, 2), (3, 4), (5, 12), (8, 15)]\n", "\nasser... |
1ebad3a72989e26928253a38d79e4b67 | [
{
"content": "On te donne un tableau trié `arr` de `n` entiers distincts et un entier cible `target`. Ta tâche est de mettre en œuvre une fonction qui utilise la recherche binaire pour trouver l'indice de `target` dans le tableau. Si `target` n'est pas présent dans le tableau, retourne `-1`.\n\n**Entrée :**\n- ... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([1], 1) == 0\n", "\nassert binary_search(... |
94e82c103e300367681571845514453d | [
{
"content": "On te donne un fichier JSON contenant un dictionnaire où les clés sont des chaînes de caractères représentant différentes bibliothèques logicielles et leurs versions au format `<bibliothèque>.<version>`, et les valeurs sont les chemins de mise à niveau correspondants. Par exemple, `numpy.1.18.1`.\... | ["\nassert parse_library_versions('test1.json') == {'numpy': ('path/to/numpy', (1, 19, 2)), 'pandas': ('path/to/pandas', (1, 1, 3))}\n", "\nassert parse_library_versions('test2.json') == {'requests': ('path/to/requests', (2, 24, 0)), 'flask': ('path/to/flask', (1, 1, 2))}\n", "\nassert parse_library_versions('test3.jso... |
a4b7b843999daa32f9ca8c0234fa7459 | [
{
"content": "On te demande d'implémenter une classe `Movie` 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 film.\n - `director` : une chaîne de caractères représentant le réalisateur du film.\n - `year... | ["\nassert Movie(\"Casablanca\", \"Michael Curtiz\", 1942, \"Drama\").is_classic() == True\n", "\nassert Movie(\"Inception\", \"Christopher Nolan\", 2010, \"Sci-Fi\").is_classic() == False\n", "\nassert Movie(\"Gone with the Wind\", \"Victor Fleming\", 1939, \"Drama\").is_classic() == True\n", "\nassert Movie(\"The God... |
23ce1a80670dcbe4b53e1b0e9664e78a | [
{
"content": "On te donne une liste `S` d'entiers positifs. Ta tâche est de calculer le produit des factorielles de tous les éléments de `S`. Étant donné que les nombres peuvent être grands, tu dois t'assurer qu'aucune valeur factorielle intermédiaire ne dépasse 1000. Pour gérer les grands nombres, utilise l'ar... | ["\nassert factorial_product([1, 2, 3]) == 12\n", "\nassert factorial_product([4, 5, 6]) == 34560\n", "\nassert factorial_product([10, 10]) == 800000000\n", "\nassert factorial_product([100, 100]) == 971821303\n", "\nassert factorial_product([1, 1, 1, 1]) == 1\n", "\nassert factorial_product([500, 500]) == 971821303\n"... |
3b254f813c7e1a2791a456d7b37318ce | [
{
"content": "On te donne une chaîne de caractères `s` composée des caractères '(', ')', '{', '}', '[' et ']'. Ta tâche est de déterminer si la chaîne est équilibrée. Une chaîne est considérée comme équilibrée si chaque parenthèse ouvrante a une parenthèse fermante correspondante et qu'elles sont correctement i... | ["\nassert is_balanced_parentheses(\"()\") == True\n", "\nassert is_balanced_parentheses(\"([])\") == True\n", "\nassert is_balanced_parentheses(\"{[()]}\") == True\n", "\nassert is_balanced_parentheses(\"({[]})\") == True\n", "\nassert is_balanced_parentheses(\"([)]\") == False\n", "\nassert is_balanced_parentheses(\"... |
81bc7cbb122ab768c0346462af9bf72f | [
{
"content": "Dans un concours de programmation, tu dois concevoir un décorateur Python nommé `enhance` qui modifie le comportement d'une autre fonction. Le décorateur `enhance` doit accepter deux fonctions : `enhancer` et `to_be_enhanced`. Le décorateur doit s'assurer que `to_be_enhanced` hérite des attributs ... | ["\nassert greet(\"Alice\") == \"Enhanced: Hello, Alice!\"\n", "\nassert greet.__module__ == enhancer.__module__\n", "\nassert greet.__name__ == enhancer.__name__\n", "\nassert greet.__doc__ == enhancer.__doc__\n", "\nassert greet.get_greeting(\"Bob\") == \"Good morning, Bob!\"\n", "\nassert callable(greet.get_greeting... |
f7f18312a47721ff45d6fe5531abe68f | [
{
"content": "On te donne un ensemble de données représenté sous forme de tableau numpy 2D, où la dernière colonne représente la variable cible. Ta tâche est de calculer l'impureté de Gini pour chaque valeur unique dans la première colonne de l'ensemble de données. Retourne un dictionnaire associant chaque vale... | ["\nassert calculate_gini(np.array([[0, 0], [0, 1], [1, 0], [1, 1]])) == {0: 0.5, 1: 0.5}\n", "\nassert calculate_gini(np.array([[0, 0], [0, 0], [1, 1], [1, 1]])) == {0: 0.0, 1: 0.0}\n", "\nassert calculate_gini(np.array([[0, 0], [0, 1], [0, 1], [1, 0]])) == {0: 0.5, 1: 0.5}\n", "\nassert calculate_gini(np.array([[0, 0... |
3e95a81f0a61745b56962eb1aa6ad749 | [
{
"content": "On te donne une liste de valeurs représentant des données numériques. Ta tâche est de mettre en œuvre une fonction `calculate_statistics(data)` qui calcule et renvoie un dictionnaire contenant le minimum, le maximum, la moyenne, la médiane et le mode de la liste. Si la liste est vide ou contient d... | ["\nassert calculate_statistics([1, 2, 2, 3, 4]) == {'min': 1, 'max': 4, 'mean': 2.4, 'median': 2, 'mode': 2}\n", "\nassert calculate_statistics([10, 20, 30, 40, 50]) == {'min': 10, 'max': 50, 'mean': 30.0, 'median': 30, 'mode': None}\n", "\nassert calculate_statistics([5, 5, 5, 5, 5]) == {'min': 5, 'max': 5, 'mean': 5... |
d9167202e0ea34997759cd5aa5b3bfcc | [
{
"content": "On te donne une chaîne de caractères représentant un chemin de fichier. Ta tâche est de mettre en œuvre une fonction `extract_filename` qui extrait le nom de fichier du chemin sans son extension. Le chemin de fichier peut être absolu ou relatif et peut contenir n'importe quelle extension de fichie... | ["\nassert extract_filename('C:\\\\Users\\\\User\\\\Documents\\\\file.txt') == 'file'\n", "\nassert extract_filename('/home/user/Documents/file.txt') == 'file'\n", "\nassert extract_filename('file.txt') == 'file'\n", "\nassert extract_filename('file') == 'file'\n", "\nassert extract_filename('C:\\\\Users\\\\User\\\\Doc... |
0be5eb7e23f25296f0c9bfea03d2c1c8 | [
{
"content": "Dans un jeu de Blackjack, tu reçois une main de cartes représentée sous forme de liste de chaînes de caractères. Chaque chaîne de caractères est composée d'un rang et d'une couleur (par exemple, \"9H\" pour le 9 de Cœur, \"AS\" pour l'As de Pique). Les rangs '2' à '10' valent leur valeur nominale,... | ["\nassert calculate_hand_value(['10H', 'JH']) == 0\n", "\nassert calculate_hand_value(['AH', '10H']) == 0\n", "\nassert calculate_hand_value(['KH', 'QH']) == 20\n", "\nassert calculate_hand_value(['AH', 'AH']) == 12\n", "\nassert calculate_hand_value(['AH', 'AH', 'AH']) == 13\n", "\nassert calculate_hand_value(['7H', ... |
c35766f9c218c8539e771045520fcfa6 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python. La classe doit prendre en charge les fonctionnalités suivantes :\n\n1. **Initialisation** : Un constructeur `__init__` qui prend trois paramètres : `make`, `model` et `year`. Ces paramètres doivent initialiser les attributs respectifs de la c... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020).make == \"Toyota\"\n", "\nassert Car(\"Honda\", \"Civic\", 2018).model == \"Civic\"\n", "\nassert Car(\"Ford\", \"Mustang\", 2021).year == 2021\n", "\ncar = Car(\"Chevrolet\", \"Camaro\", 2019)\ncar.update_year(2022)\nassert car.year == 2022\n", "\ncar = Car(\"BMW\", \"M3\"... |
f93d0020f126d215f6722a45d214e1f6 | [
{
"content": "Tu es chargé d'implémenter une classe `SimpleCalculator` qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. La calculatrice doit également prendre en charge l'annulation de la dernière opération et l'effacement de l'historique des opérati... | ["\nassert SimpleCalculator().get_current_total() == 0\n", "\nassert SimpleCalculator().add(5).get_current_total() == 5\n", "\ncalc = SimpleCalculator(); calc.add(10); calc.subtract(5); assert calc.get_current_total() == 5\n", "\ncalc = SimpleCalculator(); calc.add(10); calc.multiply(2); assert calc.get_current_total()... |
d882bbec2a3836658b60b381fdafa4e2 | [
{
"content": "On te donne deux chaînes de caractères, `s` et `sub`. Ta tâche est de déterminer la plus longue sous-chaîne commune entre `s` et `sub` qui apparaît à la fin de `s` et ne contient pas de caractères répétés. Retourne la longueur de cette sous-chaîne et le nombre d'octets à regarder en arrière à part... | ["\nassert longest_unique_common_suffix(\"abcde\", \"cde\") == (2, 3)\n", "\nassert longest_unique_common_suffix(\"abcdef\", \"ghijk\") == (0, 0)\n", "\nassert longest_unique_common_suffix(\"abcdefg\", \"efg\") == (4, 3)\n", "\nassert longest_unique_common_suffix(\"aabbcc\", \"bbcc\") == (0, 0)\n", "\nassert longest_un... |
9d369f5577d0d8b08fc3be6a261a1246 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de trouver 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. S'il existe plusieurs sous-chaînes de longueur maximale identique, retourn... | ["\nassert longest_palindromic_substring(\"babad\") == \"bab\" or longest_palindromic_substring(\"babad\") == \"aba\"\n", "\nassert longest_palindromic_substring(\"cbbd\") == \"bb\"\n", "\nassert longest_palindromic_substring(\"a\") == \"a\"\n", "\nassert longest_palindromic_substring(\"ac\") == \"a\" or longest_palind... |
8c7a02de4e5b2219636f178bfdeb2537 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui supprime tous les éléments dupliqués de la liste tout en maintenant l'ordre d'origine des éléments.\n\n**Entrée :**\n- Une liste d'entiers `input_list` (1 ≤ len(input_list) ≤ 10^5), où chaque entier est dans la plage [-... | ["\nassert remove_duplicates_preserve_order([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates_preserve_order([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert remove_duplicates_preserve_order([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates_preserve_order([]) == []\n", "\nassert remove_... |
7814c98a48486f60607b6f42ba2bbe03 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `filter_numbers` qui renvoie une nouvelle liste contenant uniquement les nombres qui satisfont les conditions suivantes :\n- Le nombre doit être un nombre premier.\n- Le nombre doit être supérieur à 100.\n- Le nombre ne doit ... | ["\nassert filter_numbers([101, 103, 107, 109, 113]) == [101, 103, 107, 109, 113]\n", "\nassert filter_numbers([102, 104, 105, 106, 108]) == []\n", "\nassert filter_numbers([119, 121, 127, 131, 137, 139]) == [131, 137, 139]\n", "\nassert filter_numbers([151, 157, 163, 167, 173, 179]) == [151, 157, 163, 167, 173, 179]\n... |
e766764e75fc12a3818dcd2734dac8ed | [
{
"content": "On te demande d'implémenter une fonction `method_checker` qui évalue si un objet donné possède un attribut appelable avec un nom spécifié. La fonction doit accepter trois paramètres : l'objet à inspecter, le nom de l'attribut sous forme de chaîne de caractères, et un booléen optionnel `ignore_case... | ["\nassert method_checker(\"hello\", \"upper\") == True\n", "\nassert method_checker(\"hello\", \"UPPER\", ignore_case=True) == True\n", "\nassert method_checker(\"hello\", \"UPPER\", ignore_case=False) == False\n", "\nassert method_checker(123, \"bit_length\") == True\n", "\nassert method_checker(123, \"BIT_LENGTH\", ... |
e983e216597dd6b52f50ba9c5e58593a | [
{
"content": "On te demande d'implémenter une fonction `serialize_data` qui traite un dictionnaire `data`. Le dictionnaire contient des clés de type chaîne de caractères et des valeurs qui peuvent être des entiers, des nombres à virgule flottante, des chaînes de caractères ou des booléens. Ton objectif est de t... | ["\nassert serialize_data({'name': 'Alice'}) == {'name': [69, 108, 105, 99, 65]}\n", "\nassert serialize_data({'age': 30}) == {'age': 30}\n", "\nassert serialize_data({'is_student': False}) == {'is_student': 'false'}\n", "\nassert serialize_data({'height': 5.5}) == {'height': 5.5}\n", "\nassert serialize_data({'greetin... |
e3a2eb1658b6cbd58a1699e7df2a5731 | [
{
"content": "On te donne une liste d'entiers `nums` contenant tous les nombres de 1 à n, avec exactement un nombre manquant. Ta tâche est d'identifier et de renvoyer le nombre manquant. La solution doit être efficace en termes de complexité temporelle.\n\n**Contraintes :**\n- 1 ≤ n ≤ 10^5\n- La liste `nums` co... | ["\nassert find_missing_number([1, 2, 4, 5, 6]) == 3\n", "\nassert find_missing_number([1, 3, 4, 5]) == 2\n", "\nassert find_missing_number([2, 3, 4, 5, 6, 7, 8, 9, 10]) == 1\n", "\nassert find_missing_number([1, 2, 3, 4, 5, 6, 7, 8, 10]) == 9\n", "\nassert find_missing_number([1]) == 2\n", "\nassert find_missing_numbe... |
75a963a9dd2a0f47648aafb0d89a73a1 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer si la chaîne est un pangramme. Un pangramme est défini comme une chaîne qui contient chaque lettre de l'alphabet anglais au moins une fois. Implémente la fonction `is_pangram` ... | ["\nassert is_pangram(\"thequickbrownfoxjumpsoverthelazydog\") == True\n", "\nassert is_pangram(\"abcdefghijklmnopqrstuvwxyz\") == True\n", "\nassert is_pangram(\"hello\") == False\n", "\nassert is_pangram(\"a\") == False\n", "\nassert is_pangram(\"quickbrownfoxjumpsoverthelazydog\") == False\n", "\nassert is_pangram(\... |
3f539c36148f35f950a0355b1dee298f | [
{
"content": "On te demande d'implémenter une version modifiée de l'algorithme de tri rapide appelée `MedianQuickSort`. Cette version doit utiliser la méthode de la médiane à trois pour sélectionner le pivot. La méthode de la médiane à trois consiste à choisir la valeur médiane parmi les premier, milieu et dern... | ["\nassert median_quick_sort([3, 1, 2]) == [1, 2, 3]\n", "\nassert median_quick_sort([5, 2, 9, 1, 5, 6]) == [1, 2, 5, 5, 6, 9]\n", "\nassert median_quick_sort([10, 7, 8, 9, 1, 5]) == [1, 5, 7, 8, 9, 10]\n", "\nassert median_quick_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert median_quick_sort([5, 4, 3, 2, 1]) ... |
ec9789427eb0120032c028bc3853ac27 | [
{
"content": "On te donne un fichier CSV nommé `data.csv` avec au moins deux colonnes. La première ligne contient les en-têtes, et la deuxième colonne contient des valeurs numériques. Ta tâche est d'écrire un script Python qui lit ce fichier et calcule la moyenne des valeurs de la deuxième colonne. Si la deuxiè... | ["\nassert calculate_average_of_second_column('data_with_single_row.csv') == None\n", "\nassert calculate_average_of_second_column('data_with_non_numeric_values.csv') == None\n", "\nassert calculate_average_of_second_column('data_with_only_headers.csv') == None\n", "\nassert calculate_average_of_second_column('data_wit... |
3e0be20099107c099fade5e6664d6769 | [
{
"content": "On te confie la tâche d'implémenter une fonction `generate_model_arguments` qui construit un dictionnaire de paramètres pour déployer un paquet de modèle d'apprentissage automatique. La fonction doit assainir toutes les entrées de type chaîne de caractères pour se conformer aux conventions de nomm... | ["\nassert asyncio.run(generate_model_arguments(\"My Model?Name\", \"This is a test_description!\", {\"key1. \": \"value1!\", \"key=two\": \"value_two\"})) == {'ModelName': 'My-Model-Name', 'ModelDescription': 'This-is-a-test_description-', 'ModelTags': {'key1-': 'value1-', 'key-two': 'value_two'}}\n", "\nassert asynci... |
44e98daf474c000915b9d5b0dab257f6 | [
{
"content": "Étant donné une liste d'entiers, détermine le produit maximal de deux nombres distincts quelconques dans la liste. La fonction doit gérer toutes les paires de nombres possibles.\n\n**Entrée :**\n- Une liste d'entiers `nums` où `2 <= len(nums) <= 10^5` et `-10^9 <= nums[i] <= 10^9`.\n\n**Sortie :**... | ["\nassert max_product([1, 2, 3, 4]) == 12\n", "\nassert max_product([-10, -20, 5, 6]) == 200\n", "\nassert max_product([0, 2, 3, 5]) == 15\n", "\nassert max_product([1, 1, 1, 1]) == 1\n", "\nassert max_product([-1, -2, -3, -4]) == -1\n", "\nassert max_product([100, 200, 3, 5]) == 20000\n", "\nassert max_product([-1, 2... |
bc514a8f582f6fcf0e268ba4c7c83ed7 | [
{
"content": "On te donne une chaîne de caractères `s` et une liste de sous-chaînes `substrings`. Ta tâche est d'implémenter une fonction `highlight_substrings(s, substrings)` qui renvoie une nouvelle chaîne où toutes les occurrences des sous-chaînes de la liste sont mises en évidence en les entourant d'astéris... | ["\nassert highlight_substrings(\"hello world\", [\"hello\", \"world\"]) == \"*hello* *world*\"\n", "\nassert highlight_substrings(\"hello world\", [\"hi\", \"planet\"]) == \"hello world\"\n", "\nassert highlight_substrings(\"banana\", [\"na\"]) == \"ba*na*na\"\n", "\nassert highlight_substrings(\"banana\", [\"ana\"]) ... |
f5fcdff2adede830c924dac9978c41af | [
{
"content": "On te demande d'implémenter une fonction `convert_to_unix_timestamp` qui calcule le timestamp Unix pour une chaîne de date et d'heure donnée. Le timestamp Unix est le nombre de secondes écoulées depuis l'époque Unix, qui est définie comme le 1er janvier 1970 à 00:00:00 UTC. Ton implémentation doit... | ["\nassert convert_to_unix_timestamp(\"1970-01-01 00:00:00\") == 0.0\n", "\nassert convert_to_unix_timestamp(\"1970-01-02 00:00:00\") == 86400.0\n", "\nassert convert_to_unix_timestamp(\"1970-02-28 23:59:59\") == 2591999.0\n", "\nassert convert_to_unix_timestamp(\"1970-03-01 00:00:00\") == 2678400.0\n", "\nassert conve... |
7f5c3d674093abbf0bd9374ac456f61f | [
{
"content": "On te donne une liste imbriquée d'entiers. Ton objectif est d'implémenter une fonction qui crée une copie profonde de cette liste sans utiliser de fonctions de copie profonde intégrées telles que `copy.deepcopy`. La fonction doit gérer des niveaux de nidification arbitraires.\n\n**Exemple d'entrée... | ["\nassert deep_copy_nested_list([1, 2, 3]) == [1, 2, 3]\n", "\nassert deep_copy_nested_list([[1, 2], [3, 4]]) == [[1, 2], [3, 4]]\n", "\nassert deep_copy_nested_list([1, [2, [3, [4]]]]) == [1, [2, [3, [4]]]]\n", "\nassert deep_copy_nested_list([]) == []\n", "\nassert deep_copy_nested_list([[], []]) == [[], []]\n", "\n... |
248828f79e44981d62832564b5c453c1 | [
{
"content": "On te donne deux dictionnaires, `default_settings` et `user_settings`. Ta tâche est d'écrire une fonction `merge_dictionaries` qui fusionne ces deux dictionnaires en un seul. La fonction doit gérer les dictionnaires imbriqués en les fusionnant récursivement. Assure-toi qu'aucune erreur de récursio... | ["\nassert merge_dictionaries({}, {}) == {}\n", "\nassert merge_dictionaries({'a': 1}, {'b': 2}) == {'a': 1, 'b': 2}\n", "\nassert merge_dictionaries({'a': 1}, {'a': 2}) == {'a': 2}\n", "\nassert merge_dictionaries({'a': {'b': 1}}, {'a': {'c': 2}}) == {'a': {'b': 1, 'c': 2}}\n", "\nassert merge_dictionaries({'a': {'b':... |
20a87fa8e5f2ba3a8172cac90ed082a8 | [
{
"content": "On te donne un entier positif `number`. Ta tâche est d'écrire une fonction `generate_palindrome(number)` qui renvoie le plus petit nombre palindrome supérieur ou égal à `number`. Un nombre palindrome est un nombre qui se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée ... | ["\nassert generate_palindrome(123) == 131\n", "\nassert generate_palindrome(1) == 1\n", "\nassert generate_palindrome(9) == 9\n", "\nassert generate_palindrome(10) == 11\n", "\nassert generate_palindrome(11) == 11\n", "\nassert generate_palindrome(20) == 22\n", "\nassert generate_palindrome(121) == 121\n", "\nassert g... |
1f4c306c62bde7e262b4bc047dabd544 | [
{
"content": "On te donne un dictionnaire `d` représentant les statistiques de performance d'un modèle d'apprentissage automatique. Le dictionnaire peut contenir les clés suivantes :\n- `num_pairs` : Le nombre de paires de données utilisées pour entraîner le modèle.\n- `sec_per_pair` : Le temps moyen en seconde... | ["\nassert get_total_training_time({'num_pairs': 500, 'sec_per_pair': 0.2, 'num_epochs': 5}) == 50.0\n", "\nassert get_total_training_time({'num_pairs': 1000, 'sec_per_pair': 0.1, 'num_epochs': 1}) == 100.0\n", "\nassert get_total_training_time({'num_pairs': 2000, 'sec_per_pair': 0.05, 'num_epochs': 3}) == 300.0\n", "\... |
8d25d56fe565bc46d78d9e4789d269ca | [
{
"content": "On te donne pour tâche d'implémenter une fonction qui calcule le nombre de bits nécessaires pour stocker un nombre de bits spécifié, en tenant compte d'une taille d'octet spécifique définie par la base. Chaque 10e octet est compressé, réduisant sa taille de stockage de 20 %. Ta fonction doit gérer... | ["\nassert bytes_required(0, 8) == 0\n", "\nassert bytes_required(8, 8) == 8\n", "\nassert bytes_required(10, 8) == 8\n", "\nassert bytes_required(80, 8) == 80\n", "\nassert bytes_required(90, 8) == 72\n", "\nassert bytes_required(100, 8) == 80\n", "\nassert bytes_required(1024, 8) == 824\n", "\nassert bytes_required(1... |
7fb907da9189de03fd4b51a8023f48fe | [
{
"content": "On te donne un entier `n`. Ta tâche est de déterminer si `n` est un nombre spécial. Un nombre spécial est défini comme une puissance de 2 et est supérieur ou égal à 8. Tu dois implémenter la fonction `is_special_number` en utilisant uniquement des opérations au niveau du bit.\n\n**Entrée :**\n- Un... | ["\nassert is_special_number(8) == True\n", "\nassert is_special_number(16) == True\n", "\nassert is_special_number(32) == True\n", "\nassert is_special_number(4) == False\n", "\nassert is_special_number(2) == False\n", "\nassert is_special_number(1) == False\n", "\nassert is_special_number(0) == False\n", "\nassert is... |
47c6ba472e159c435d5708fde9d0deb5 | [
{
"content": "On te donne deux listes `shape1` et `shape2` représentant les dimensions de deux tableaux multidimensionnels. Ta tâche est de déterminer la forme résultante d'une opération entre ces deux tableaux en fonction des règles de diffusion de NumPy. La fonction doit renvoyer une liste représentant la for... | ["\nassert infer_output_shape([2, 3], [1, 3]) == [2, 3]\n", "\nassert infer_output_shape([2, 3], [2, 4]) == [2, -1]\n", "\nassert infer_output_shape([2, 3], [1, 1]) == [2, 3]\n", "\nassert infer_output_shape([2, 3], [3, 1]) == [-1, 3]\n", "\nassert infer_output_shape([5, 1, 3], [2, 3]) == [5, 1, 3]\n", "\nassert infer_... |
eb340e17f43305bacec090ccbc5a734f | [
{
"content": "On te donne un dictionnaire `d` et une chaîne de caractères `key`. Ta tâche est de mettre en œuvre une fonction `find_value_case_insensitive` qui renvoie la valeur associée à la première clé du dictionnaire qui correspond à la clé d'entrée de manière insensible à la casse. La fonction doit prétrai... | ["\nassert find_value_case_insensitive({\"a\": 1, \"B\": 2, \"c\": 3}, \"b\") == 2\n", "\nassert find_value_case_insensitive({\"Hello\": \"World\", \"Python\": \"Programming\"}, \"hello\") == \"World\"\n", "\nassert find_value_case_insensitive({\"Key\": \"Value\"}, \"key\") == \"Value\"\n", "\nassert find_value_case_in... |
3caaee4cb8cffaed2c0c0df3093f7963 | [
{
"content": "On te donne une liste d'entiers qui peut contenir des listes imbriquées de profondeur arbitraire. Ta tâche est d'aplatir la liste, puis de compter les occurrences consécutives de chaque entier. Retourne une liste de tuples où chaque tuple contient un entier et son nombre d'occurrences consécutives... | ["\nassert count_consecutive_elements([1, 1, 1, 2, 2, 3, 3, 3, 3, -1, -1, 0, 0, 0, 0]) == [(1, 3), (2, 2), (3, 4), (-1, 2), (0, 4)]\n", "\nassert count_consecutive_elements([1, 1, [1, 2], [2, 3, [3, 3]], -1, [-1, 0, [0, 0]], 0]) == [(1, 3), (2, 2), (3, 4), (-1, 2), (0, 4)]\n", "\nassert count_consecutive_elements([1, 2... |
f3706fa76dff5a9d013b2c89e6611d7e | [
{
"content": "On te donne une chaîne binaire `binary_data` composée de '0' et de '1'. Ta tâche est de convertir manuellement cette chaîne binaire en sa représentation encodée en Base64. Tu ne dois pas utiliser de fonctions intégrées qui convertissent directement le binaire en Base64. Au lieu de cela, tu dois im... | ["\nassert convert_to_base64('01011010') == 'Wg=='\n", "\nassert convert_to_base64('00000000') == 'AAAAAAAA'\n", "\nassert convert_to_base64('11111111') == '////'\n", "\nassert convert_to_base64('0100100001100101011011000110110001101111') == 'SGVsbG8='\n", "\nassert convert_to_base64('0100100001100101011011000110110001... |
be32dc7f3d88f7757eebd277e112b370 | [
{
"content": "On te donne une matrice 2x2 `M` et un entier positif `n`. La matrice `M` est définie comme suit :\n\n```\nM = [[1, 1], [1, 0]]\n```\n\nTa tâche est de calculer l'élément en haut à gauche de la matrice `M` élevée à la puissance `n` en utilisant la récursion et d'atteindre une complexité temporelle ... | ["\nassert matrix_power([[1, 1], [1, 0]], 1) == 1\n", "\nassert matrix_power([[1, 1], [1, 0]], 2) == 2\n", "\nassert matrix_power([[1, 1], [1, 0]], 3) == 3\n", "\nassert matrix_power([[1, 1], [1, 0]], 4) == 5\n", "\nassert matrix_power([[1, 1], [1, 0]], 5) == 8\n", "\nassert matrix_power([[1, 1], [1, 0]], 6) == 13\n", ... |
17fcd28dacfc72ae0a1f99e71b5bf0f9 | [
{
"content": "On te donne une chaîne de caractères représentant une liste d'hôtes dans un format spécifique. Chaque hôte est représenté par un nom suivi d'une spécification de remplissage optionnelle et d'une plage de nombres entre crochets. La plage est représentée par un nombre de début et un nombre de fin sé... | ["\nassert parse_hosts(\"host[1-3,5-7]\") == [(\"host001\", 1), (\"host002\", 1), (\"host003\", 1), (\"host005\", 1), (\"host006\", 1), (\"host007\", 1)]\n", "\nassert parse_hosts(\"host@2[1-3,5-7]\") == [(\"host01\", 1), (\"host02\", 1), (\"host03\", 1), (\"host05\", 1), (\"host06\", 1), (\"host07\", 1)]\n", "\nassert... |
c199334e4c28ec7208b92a72f0b9867a | [
{
"content": "On te demande d'implémenter une fonction `escape_special_characters(input_string)` qui traite une chaîne de caractères donnée et renvoie une nouvelle chaîne où tous les caractères spéciaux ayant une signification dans les expressions régulières sont échappés. Les caractères spéciaux à échapper son... | ["\nassert escape_special_characters(\"Hello. World?\") == \"Hello\\\\. World\\\\?\"\n", "\nassert escape_special_characters(\"This is a test!\") == \"This is a test\\\\!\"\n", "\nassert escape_special_characters(\"NoSpecialCharsHere\") == \"NoSpecialCharsHere\"\n", "\nassert escape_special_characters(\"1234567890\") =... |
00cdf18c5de80efa95783bf55eaa6ebb | [
{
"content": "On te donne une séquence d'ADN `seq_x` et un nucléotide spécifique `char`. La séquence peut contenir des nucléotides en majuscules et en minuscules. Ta tâche est d'identifier toutes les positions de départ `j` des fenêtres de taille `lengthW` dans la séquence où le nucléotide à la position `index_... | ["\nassert find_window_starts('ACAGCA', 'A', 1, 3, 6) == [1, 3]\n", "\nassert find_window_starts('acagca', 'a', 1, 3, 6) == [1, 3]\n", "\nassert find_window_starts('ACAGCA', 'a', 1, 3, 6) == [1, 3]\n", "\nassert find_window_starts('ACAGCA', 'C', 0, 2, 6) == [2, 4]\n", "\nassert find_window_starts('ACAGCA', 'G', 2, 3, 6... |
355b5ee853be2c62668e1dd5ed605863 | [
{
"content": "On te demande de créer une API REST en utilisant le framework Flask. L'API doit avoir un seul point de terminaison `/current_time` qui, lorsqu'il est accédé, renvoie un objet JSON contenant la date et l'heure actuelles formatées comme `YYYY-MM-DD HH:MM:SS`. Ton implémentation doit être capable de ... | ["\nassert type(current_time().json['current_time']) == str\n", "\nassert len(current_time().json['current_time'].split(' ')) == 2\n", "\nassert len(current_time().json['current_time'].split('-')) == 3\n", "\nassert len(current_time().json['current_time'].split(':')) == 3\n", "\nassert current_time().json['current_time... |
dafa364cc1c1bf3bd064bf37aff8673f | [
{
"content": "On te demande d'implémenter une fonction `generate_user_ids(s, trim=False, encoding='utf-8')` qui traite une chaîne de caractères `s` contenant des espaces réservés de la forme `$U[n]`, où `n` est un entier positif. Ta fonction doit remplacer chaque espace réservé par un ID utilisateur unique géné... | ["\nassert generate_user_ids(\"Hello $U1, your ID is $U2\", trim=False) == b\"Hello 0x1001, your ID is 0x1002\"\n", "\nassert generate_user_ids(\"Hello $U1, your ID is $U2\", trim=True) == b\"Hello 0x1001, your ID is 0x1002\"\n", "\nassert generate_user_ids(\"$U10\", trim=False) == b\"0x100a\"\n", "\nassert generate_us... |
338bb232462d130043b4ef3614eb0445 | [
{
"content": "On te donne une liste de mots `words` et un ensemble de mots `dictionary`. Ta tâche est de mettre en œuvre une fonction `find_longest_word_in_dict(words, dictionary)` qui renvoie le mot le plus long de la liste qui peut être construit en concaténant des mots du dictionnaire. S'il y a plusieurs mot... | ["\nassert find_longest_word_in_dict([\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\"], {\"a\", \"an\", \"apple\", \"app\", \"ban\", \"ba\", \"na\", \"el\", \"der\", \"berry\", \"ch\", \"er\", \"ry\", \"dat\", \"e\"}) == \"elderberry\"\n", "\nassert find_longest_word_in_dict([\"cat\", \"cats\", \"catsdogcat... |
e3924ea56ed7ef6241a18b08e0561aaa | [
{
"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 - `isbn` : une... | ["\nassert Book(\"1984\", \"George Orwell\", \"0451524934\", 1949, 5).get_info() == \"Title: 1984\\nAuthor: George Orwell\\nISBN: 0451524934\\nPublication Year: 1949\\nCopies Available: 5\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", \"0060935464\", 1960, 10).get_info() == \"Title: To Kill a Mockingbi... |
5b7bc7c0defeaa5345c805c126661eb8 | [
{
"content": "On te demande d'implémenter une fonction `extract_emails` qui identifie et extrait toutes les adresses e-mail valides d'une chaîne de caractères donnée. La fonction doit utiliser des expressions régulières pour faire correspondre les adresses e-mail selon des formats courants. La chaîne d'entrée p... | ["\nassert extract_emails(\"Contact us at info@example.com\") == [\"info@example.com\"]\n", "\nassert extract_emails(\"support@domain.org, info@example.com\") == [\"support@domain.org\", \"info@example.com\"]\n", "\nassert extract_emails(\"No emails here!\") == []\n", "\nassert extract_emails(\"john.doe@website.co.uk\"... |
e0a0ab68e40ba904cee893344de84a83 | [
{
"content": "On te donne deux intervalles de temps, chacun représenté par un tuple de deux entiers `(heure_de_début, heure_de_fin)`. Les intervalles sont au format 24 heures et peuvent chevaucher minuit. Implémente une fonction nommée `time_overlap` qui renvoie `True` si le second intervalle commence pendant l... | ["\nassert time_overlap((9, 17), (12, 13)) == True\n", "\nassert time_overlap((9, 17), (16, 20)) == False\n", "\nassert time_overlap((22, 2), (23, 1)) == True\n", "\nassert time_overlap((23, 3), (2, 5)) == False\n", "\nassert time_overlap((0, 24), (12, 18)) == True\n", "\nassert time_overlap((15, 3), (16, 17)) == True\... |
5fbb0aedb670181f8681520ca2224da9 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la paire de nombres dans la liste dont la somme est la plus proche de zéro. S'il y a plusieurs paires avec la même somme, renvoie l'une d'entre elles. La liste contiendra au moins deux entiers.\n\n**Exemple d'entrée :**\n```\n[1, 3, -5, 7, -... | ["\nassert find_closest_to_zero_pair([1, 3, -5, 7, -3, 2, 1]) == (-3, 3)\n", "\nassert find_closest_to_zero_pair([-1, 2, -3, 4, -5, 6]) == (-1, 2)\n", "\nassert find_closest_to_zero_pair([10, 22, 28, 29, 30, 40]) == (28, 29)\n", "\nassert find_closest_to_zero_pair([-10, -22, -28, -29, -30, -40]) == (-29, -28)\n", "\nas... |
f0762ef161fc88299cef85c2dab5bee3 | [
{
"content": "Tu es chargé de développer une API REST utilisant Flask qui gère les données des utilisateurs. L'API doit accepter une charge utile JSON contenant les informations de l'utilisateur et les stocker dans une base de données SQLite. La charge utile JSON doit inclure le nom et l'adresse e-mail de l'uti... | ["\nassert add_user() == jsonify({'error': 'Bad Request', 'message': 'Name and Email are required.'}), 400\n", "\nassert add_user({'name': 'John Doe'}) == jsonify({'error': 'Bad Request', 'message': 'Name and Email are required.'}), 400\n", "\nassert add_user({'email': 'john@example.com'}) == jsonify({'error': 'Bad Req... |
cf9c5837a6cb488f9b59176890983d66 | [
{
"content": "On te donne un tableau d'entiers `heights` de longueur `n`, où `heights[i]` représente la hauteur du bâtiment à l'index `i`. La ville est planifiée de telle sorte que la hauteur des bâtiments augmente de gauche à droite. Cependant, en raison de certaines erreurs de construction, il y a quelques bâ... | ["\nassert process_queries([1, 2, 3, 4, 5], [(0, 4)]) == [-1]\n", "\nassert process_queries([1, 3, 2, 4, 5], [(0, 4)]) == [1]\n", "\nassert process_queries([5, 4, 3, 2, 1], [(0, 4)]) == [-1]\n", "\nassert process_queries([1, 2, 3, 2, 5, 4, 6, 4, 7], [(0, 8)]) == [7]\n", "\nassert process_queries([1, 2, 3, 2, 5, 4, 6, 4... |
74eb678171baf40393446f2ccdf755ea | [
{
"content": "On te donne une fonction différentiable `g(x)` et sa dérivée `derivative_g(x)`. Implémente une fonction `gradient_descent(g, derivative_g, x0, learning_rate, iterations)` qui utilise l'algorithme de descente de gradient pour trouver le minimum de `g(x)`. La fonction doit partir d'une estimation in... | ["\nassert gradient_descent(lambda x: x**2, lambda x: 2*x, 10, 0.1, 100) == 0.0\n", "\nassert gradient_descent(lambda x: (x-3)**2, lambda x: 2*(x-3), 0, 0.1, 100) == 3.0\n", "\nassert gradient_descent(lambda x: x**4 - 4*x**2 + 4, lambda x: 4*x**3 - 8*x, 2, 0.01, 1000) == 0.0\n", "\nassert gradient_descent(lambda x: x**... |
b6ebd678a4fa93191d9321e048715554 | [
{
"content": "On te donne deux entiers, `x` et `y`. Ta tâche est d'écrire une fonction `difference_of_cubes(x, y)` qui calcule la différence entre la somme des cubes et le cube de la somme pour tous les entiers dans la plage de `x` à `y` (inclus). La fonction doit gérer efficacement les valeurs négatives et nul... | ["\nassert difference_of_cubes(1, 3) == -24\n", "\nassert difference_of_cubes(0, 0) == 0\n", "\nassert difference_of_cubes(-1, 1) == 0\n", "\nassert difference_of_cubes(2, 2) == 0\n", "\nassert difference_of_cubes(-3, -1) == 24\n", "\nassert difference_of_cubes(1, 10) == -19800\n", "\nassert difference_of_cubes(-5, 5) ... |
ba342abdf9062fd6f4ec5c11ead8e426 | [
{
"content": "On te donne une chaîne de caractères `s` composée d'au plus 100 lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer le nombre minimum de caractères qui doivent être insérés dans `s` pour en faire un palindrome. Un palindrome est une chaîne de caractères qui se lit de la même maniè... | ["\nassert min_insertions_to_palindrome(\"abc\") == 2\n", "\nassert min_insertions_to_palindrome(\"a\") == 0\n", "\nassert min_insertions_to_palindrome(\"aa\") == 0\n", "\nassert min_insertions_to_palindrome(\"ab\") == 1\n", "\nassert min_insertions_to_palindrome(\"race\") == 3\n", "\nassert min_insertions_to_palindrom... |
a5bad38364eb894228609c01d2a499ba | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author` et `publication_year`. Implémente des méthodes pour récupérer chacun de ces attributs. De plus, implémente une méthode `update_year` qui met à jour `publication_year` avec l'ann... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_title() == \"1984\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949).get_author() == \"George Orwell\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949).get_publication_year() == 1949\n", "\nbook = Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960)\nboo... |
aa23841507e0eac6878afb69729998a9 | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de refactoriser le code Java fourni pour améliorer ses performances et sa lisibilité. La fonction doit renvoyer un tableau contenant tous les éléments en double du tableau d'entrée. Chaque élément en double doit apparaître une seule fois dans l... | ["\nassert find_duplicates([1, 2, 3, 4, 5]) == []\n", "\nassert find_duplicates([1, 2, 2, 3, 4, 4, 5]) == [2, 4]\n", "\nassert find_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert find_duplicates([]) == []\n", "\nassert find_duplicates([10, 20, 30, 40, 50, 10, 20]) == [10, 20]\n", "\nassert find_duplicates([5, 5, 5, 5... |
ed698c69e07fddf6611e906654a0caf1 | [
{
"content": "On te demande d'implémenter une classe `Inventory` pour gérer une collection d'éléments, chacun identifié par un nom unique et associé à une quantité spécifique. La classe `Inventory` doit prendre en charge les opérations suivantes :\n\n- `add_item(name, quantity)` : Ajoute la quantité spécifiée d... | ["\nassert Inventory().get_inventory() == {}\n", "\nassert Inventory().add_item(\"apple\", 10) is None\n", "\nassert Inventory().add_item(\"banana\", 5) is None\n", "\ninventory = Inventory()\ninventory.add_item(\"apple\", 10)\nassert inventory.get_inventory() == {\"apple\": 10}\n", "\ninventory = Inventory()\ninventor... |
73be4508b78ccfd310ff54392b8e03cb | [
{
"content": "Tu développes une interface en ligne de commande (CLI) pour une application d'entraînement de modèles d'apprentissage automatique. La CLI doit accepter les paramètres suivants :\n\n- `--learning-rate` : un nombre à virgule flottante indiquant le taux d'apprentissage du modèle. La valeur par défaut... | ["\nassert add_model_arguments(argparse.ArgumentParser()).get_default('learning-rate') == 0.01\n", "\nassert add_model_arguments(argparse.ArgumentParser()).get_default('hidden') == [128, 32]\n", "\nassert add_model_arguments(argparse.ArgumentParser()).get_argument('--learning-rate').type == float\n", "\nassert add_mode... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.