id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
5a94294ee9ffe3df9fd0a02812c62d57 | [
{
"content": "On te donne un arbre binaire où chaque nœud contient une valeur entière. Ta tâche est de trouver la somme maximale du chemin dans l'arbre. Un chemin est défini comme toute séquence de nœuds à partir d'un nœud de départ vers n'importe quel nœud de l'arbre le long des connexions parent-enfant. Le ch... | ["\nassert maxPathSum(TreeNode(1, TreeNode(2), TreeNode(3))) == 6\n", "\nassert maxPathSum(TreeNode(-10, TreeNode(9), TreeNode(20, TreeNode(15), TreeNode(7)))) == 42\n", "\nassert maxPathSum(TreeNode(5, TreeNode(4, TreeNode(11, TreeNode(7), TreeNode(2))), TreeNode(8, TreeNode(13), TreeNode(4, TreeNode(1))))) == 48\n", ... |
18650872baaf6ef33f5feac8e78af4dc | [
{
"content": "On te donne un tableau non trié d'entiers. Ta tâche est de trouver le plus petit entier positif qui n'apparaît pas dans le tableau. L'algorithme doit avoir une complexité temporelle de O(n) et doit utiliser un espace constant.\n\n**Exemple d'entrée :**\n```\n[3, 4, -1, 1]\n```\n\n**Exemple de sort... | ["\nassert first_missing_positive([3, 4, -1, 1]) == 2\n", "\nassert first_missing_positive([1, 2, 0]) == 3\n", "\nassert first_missing_positive([7, 8, 9, 11, 12]) == 1\n", "\nassert first_missing_positive([1, 2, 3]) == 4\n", "\nassert first_missing_positive([0, -1, -2]) == 1\n", "\nassert first_missing_positive([2, 2, ... |
1d221fb0a8ac1bea7f6a3f81d7355728 | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tenseur PyTorch 2D de forme (N, N), où N est le nombre de pixels dans chaque dimension. Ta tâche est de créer une fonction qui génère des patchs décalés de l'image d'entrée.\n\n**Signature de la fonction :**\n```python\ndef generate_shi... | ["\nassert generate_shifted_patches(torch.tensor([[1]]), 1).shape == (1, 1, 2, 2)\n", "\nassert torch.equal(generate_shifted_patches(torch.tensor([[1]]), 1)[0, 0, 0, 0], torch.tensor(1))\n", "\nassert torch.equal(generate_shifted_patches(torch.tensor([[1]]), 1)[0, 0, 1, 1], torch.tensor(0))\n", "\nassert generate_shift... |
0474adb3226dc0eec786114c4b1f2b6b | [
{
"content": "On te donne un extrait de code Python sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction `optimize_code` qui renvoie une version optimisée du code. L'optimisation doit se concentrer sur l'amélioration des performances et la réduction du temps d'exécution. Envisage d'optimiser l... | ["\nassert optimize_code(\"def compute_sum(numbers):\\n result = 0\\n for i in range(len(numbers)):\\n result += numbers[i]\\n return result\\n\") == \"def compute_sum(numbers):\\n\\treturn sum(numbers)\\n\"\n", "\nassert optimize_code(\"def find_max(numbers):\\n max_num = numbers[0]\\n for num in... |
ae199ab94b743974536e1f58a25ce52b | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction `count_vowels` qui renvoie le nombre de voyelles dans la chaîne. La fonction doit être insensible à la casse, ce qui signifie qu'elle doit compter les voyelles majuscules et minuscules.\n\n**Entrée :**\n- Une seule chaîne... | ["\nassert count_vowels(\"Hello, World!\") == 3\n", "\nassert count_vowels(\"Python Programming\") == 4\n", "\nassert count_vowels(\"AEIOUaeiou\") == 10\n", "\nassert count_vowels(\"\") == 0\n", "\nassert count_vowels(\"bcdfg\") == 0\n", "\nassert count_vowels(\"abcdefghijklmnopqrstuvwxyz\") == 5\n", "\nassert count_vo... |
325a2b6680a1a83effc2b13999848c88 | [
{
"content": "On te donne un tableau d'entiers `numbers` et une liste de paires d'indices `pairs`. Chaque paire `(i, j)` dans `pairs` indique une restriction selon laquelle `numbers[i]` doit être inférieur ou égal à `numbers[j]`. Ta tâche est de déterminer si l'une de ces restrictions est violée. Implémente la ... | ["\nassert check_restrictions([1, 2, 3, 4], [(0, 1), (2, 3)]) == False\n", "\nassert check_restrictions([1, 2, 3, 4], [(0, 3), (3, 0)]) == True\n", "\nassert check_restrictions([5, 3, 1, 2], [(0, 1), (1, 2)]) == True\n", "\nassert check_restrictions([1, 1, 1, 1], [(0, 1), (1, 2), (2, 3)]) == False\n", "\nassert check_r... |
7ac70cc93ec36f7bcc82deeb3a89817e | [
{
"content": "On te donne une chaîne de caractères `expression` composée de caractères incluant des parenthèses `()`, des crochets `[]`, et des accolades `{}`. Ta tâche est de déterminer si la chaîne a des parenthèses, des crochets et des accolades équilibrés. Une chaîne est considérée comme équilibrée si chaqu... | ["\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(\"((()))\") == True\n", "\nassert is_balanced_parentheses(... |
dcaa0c3cb1f2dd23ae137453cca9ba22 | [
{
"content": "On te donne une séquence d'ADN représentée sous forme de chaîne de caractères composée des caractères 'A', 'C', 'G' et 'T'. Ta tâche est de calculer une valeur de hachage pour cette séquence en utilisant une fonction de hachage personnalisée. La fonction de hachage doit être efficace et capable de... | ["\nassert dna_hash(\"A\") == 0\n", "\nassert dna_hash(\"C\") == 1\n", "\nassert dna_hash(\"G\") == 2\n", "\nassert dna_hash(\"T\") == 3\n", "\nassert dna_hash(\"ACGT\") == 27\n", "\nassert dna_hash(\"ACGTA\") == 108\n", "\nassert dna_hash(\"ACGTACGTACG\") == 1030301030\n", "\nassert dna_hash(\"AAAAAAAAAAAA\") == 0\n",... |
04ce65a652332ccceecf1826bdbeed61 | [
{
"content": "On te donne une liste de communautés, où chaque communauté est représentée comme une liste d'identifiants de nœuds numériques uniques. De plus, on te fournit un dictionnaire qui mappe ces identifiants numériques à leurs étiquettes de nœuds correspondantes. Ta tâche est de créer une fonction qui tr... | ["\nassert remap_communities([[1, 2, 3], [4, 5], [6, 7, 8, 9]], {1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E', 6: 'F', 7: 'G', 8: 'H', 9: 'I'}) == [['A', 'B', 'C'], ['D', 'E'], ['F', 'G', 'H', 'I']]\n", "\nassert remap_communities([[10, 11, 12], [13, 14]], {10: 'X', 11: 'Y', 12: 'Z'}) == [['X', 'Y', 'Z'], []]\n", "\nassert r... |
834553ffbe1de31124f284fea1b17878 | [
{
"content": "On te donne une chaîne de caractères qui représente un objet JSON. Ta tâche est d'écrire une fonction Python qui convertit cette chaîne JSON en un dictionnaire Python. L'objet JSON peut contenir des objets et des tableaux imbriqués. Ta fonction doit gérer ces cas correctement. De plus, ta fonction... | ["\nassert json_to_dict('{\"name\": \"John\", \"age\": 30}') == {\"name\": \"John\", \"age\": 30}\n", "\nassert json_to_dict('{\"key\": \"value\", \"nested\": {\"subkey\": \"subvalue\"}}') == {\"key\": \"value\", \"nested\": {\"subkey\": \"subvalue\"}}\n", "\nassert json_to_dict('{\"numbers\": [1, 2, 3, 4, 5]}') == {\"... |
35cb8d4142d7307ffba3b627bf117f73 | [
{
"content": "Dans un jeu de cartes, on te donne une liste de cartes, chacune représentée comme un tuple `(valeur, couleur, horodatage)`. La `valeur` est un entier entre 1 et 13, représentant le rang de la carte (As, 2-10, Valet, Dame, Roi). La `couleur` est un entier entre 0 et 3, représentant la couleur de la... | ["\nassert find_winning_card_index([(10, 0, 1609459200), (11, 1, 1609459201), (12, 2, 1609459202), (13, 3, 1609459203)]) == 3\n", "\nassert find_winning_card_index([(10, 0, 1609459200), (11, 0, 1609459201), (12, 0, 1609459202), (13, 0, 1609459203)]) == 3\n", "\nassert find_winning_card_index([(10, 0, 1609459200), (11, ... |
29851388624361fc2ade44add7f13dfa | [
{
"content": "On te donne une chaîne de caractères `text` contenant un mélange de texte et d'adresses e-mail. Ta tâche est d'écrire une fonction `extract_emails(text: str) -> List[str]` qui extrait toutes les adresses e-mail valides de la chaîne. Une adresse e-mail est définie comme une séquence de caractères a... | ["\nassert extract_emails(\"Please contact us at support@example.com\") == [\"support@example.com\"]\n", "\nassert extract_emails(\"No emails here!\") == []\n", "\nassert extract_emails(\"Multiple emails: test1@test.com, test2@test.org\") == [\"test1@test.com\", \"test2@test.org\"]\n", "\nassert extract_emails(\"Email ... |
7e38be47c905daba21d3428106e62622 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si la chaîne est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :*... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\n", "\nassert is_palindrome(\" \") == True\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(... |
95192905547720ccf5cf69622f93a2ce | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_largest_even_number` qui renvoie le plus grand nombre pair de la liste. S'il n'y a pas de nombres pairs, la fonction doit renvoyer `None`. La fonction doit être suffisamment robuste pour gérer les cas limites tels qu'un... | ["\nassert find_largest_even_number([1, 3, 5, 7, 9]) == None\n", "\nassert find_largest_even_number([2, 4, 6, 8, 10]) == 10\n", "\nassert find_largest_even_number([11, 13, 15, 2, 4]) == 4\n", "\nassert find_largest_even_number([]) == None\n", "\nassert find_largest_even_number([1, 1, 1, 1]) == None\n", "\nassert find_l... |
c63b19d184ffbfcd417e538b3dc6c1fd | [
{
"content": "Implémente une classe Python nommée `Vector2D` qui modélise un vecteur bidimensionnel avec des composantes `x` et `y`. La classe doit prendre en charge les opérations suivantes :\n- Addition de deux objets `Vector2D`.\n- Soustraction de deux objets `Vector2D`.\n- Calcul de la magnitude d'un objet ... | ["\nassert Vector2D(1, 2) + Vector2D(3, 4) == Vector2D(4, 6)\n", "\nassert Vector2D(5, 5) - Vector2D(2, 3) == Vector2D(3, 2)\n", "\nassert Vector2D(3, 4).magnitude() == 5.0\n", "\nassert Vector2D(0, 0).magnitude() == 0.0\n", "\nassert Vector2D(-3, -4).magnitude() == 5.0\n", "\nassert Vector2D(1, 0) + Vector2D(0, 1) == ... |
c88d58271f228a245fe42637c40c59be | [
{
"content": "On te demande de traiter un fichier CSV contenant des données sur les étudiants. Chaque ligne du fichier CSV représente un étudiant et comprend les champs suivants : \"ID\", \"Name\", \"Email\", \"School\" et \"Grade\". Ton objectif est de mettre en œuvre une fonction qui lit ce fichier CSV et ren... | ["\nassert process_student_data(\"test.csv\") == {\"total_students\": 0, \"school_student_counts\": {}, \"school_average_grades\": {}, \"school_median_grades\": {}}\n", "\nassert process_student_data(\"test.csv\") == {\"total_students\": 3, \"school_student_counts\": {\"SchoolA\": 2, \"SchoolB\": 1}, \"school_average_g... |
85e00be408fdbe0817edd5e98d2a7c88 | [
{
"content": "On te demande d'implémenter une fonction qui détermine si une URL donnée est accessible. Ta fonction doit renvoyer `True` si l'URL est accessible et renvoie un code d'état de 200, et `False` sinon. Utilise la bibliothèque `requests` pour effectuer la requête HTTP. Ta solution doit gérer les except... | ["\nassert is_url_reachable(\"https://www.google.com\") == True\n", "\nassert is_url_reachable(\"https://www.nonexistentwebsite123456789.com\") == False\n", "\nassert is_url_reachable(\"http://example.com\") == True\n", "\nassert is_url_reachable(\"https://github.com\") == True\n", "\nassert is_url_reachable(\"ftp://ex... |
d84e01964160d1ffcdabcaac17737bb2 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `remove_duplicates` qui supprime tous les éléments dupliqués de la liste tout en conservant l'ordre d'origine des éléments restants.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 10^5), où chaque entier est dan... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates(['a', 'b', 'a', 'c', 'b']) == ['a', 'b', 'c']\n", "\nassert remove_duplicates([True, False, True, True, False]) == [Tru... |
a92c6b3ce3856b8fa4a9edba47f1b4ba | [
{
"content": "On te donne une grille de dimensions `m x n`. En partant du coin supérieur gauche, tu ne peux te déplacer qu'à droite ou vers le bas. Ta tâche est de déterminer le nombre de chemins uniques pour atteindre le coin inférieur droit de la grille. Implémente une fonction récursive `count_paths` pour ré... | ["\nassert count_paths(1, 1) == 1\n", "\nassert count_paths(2, 2) == 2\n", "\nassert count_paths(3, 3) == 6\n", "\nassert count_paths(4, 4) == 20\n", "\nassert count_paths(5, 5) == 70\n", "\nassert count_paths(1, 5) == 1\n", "\nassert count_paths(5, 1) == 1\n", "\nassert count_paths(2, 3) == 3\n", "\nassert count_paths... |
96cf98d942530e0479a1d5f877950845 | [
{
"content": "On te demande d'implémenter une fonction pour générer la suite de Fibonacci jusqu'au `n`-ième terme en utilisant une approche itérative. 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. ... | ["\nassert fibonacci_sequence(0) == []\n", "\nassert fibonacci_sequence(1) == [0]\n", "\nassert fibonacci_sequence(2) == [0, 1]\n", "\nassert fibonacci_sequence(3) == [0, 1, 1]\n", "\nassert fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci_sequence(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert ... |
cb08ed83f7b3a5e764da972ae287d4ef | [
{
"content": "On te demande d'implémenter une fonction `escape_special_characters(word)` qui traite une chaîne de caractères donnée `word` en remplaçant certains caractères spéciaux par leurs séquences d'échappement correspondantes. Les caractères à échapper sont :\n\n- La barre oblique inverse (`\\`) doit être... | ["\nassert escape_special_characters(\"Hello \\\"World\\\"\") == \"Hello \\\\\\\"World\\\\\\\"\"\n", "\nassert escape_special_characters(\"It\\'s a sunny day!\") == \"It\\\\'s a sunny day!\"\n", "\nassert escape_special_characters(\"Path\\\\to\\\\file\") == \"Path\\\\\\\\to\\\\\\\\file\"\n", "\nassert escape_special_ch... |
c8a7cc4b2211f52c6e3e7e9a66066af0 | [
{
"content": "On te donne un nombre décimal `n` et un paramètre optionnel `bit_length`. Ta tâche est de convertir le nombre décimal en sa représentation binaire. Si `bit_length` est fourni, complète la représentation binaire avec des zéros en tête pour qu'elle ait exactement `bit_length` bits. Convertis chaque ... | ["\nassert decimal_to_roman_bits(5, 8) == ['N', 'N', 'N', 'N', 'N', 'I', 'N', 'I']\n", "\nassert decimal_to_roman_bits(5) == ['I', 'N', 'I']\n", "\nassert decimal_to_roman_bits(0, 4) == ['N', 'N', 'N', 'N']\n", "\nassert decimal_to_roman_bits(1, 1) == ['I']\n", "\nassert decimal_to_roman_bits(2, 3) == ['N', 'I', 'N']\n... |
1dff95e01de005f097955d6cb198cd05 | [
{
"content": "On te donne un dictionnaire `dct` où les clés sont des chaînes de caractères uniques et les valeurs sont des entiers. Ta tâche est d'implémenter une fonction `sort_dict_by_value` qui renvoie un nouveau dictionnaire trié par les valeurs par ordre croissant. Si deux valeurs sont égales, leur ordre d... | ["\nassert sort_dict_by_value({'a': 3, 'b': 1, 'c': 2}) == {'b': 1, 'c': 2, 'a': 3}\n", "\nassert sort_dict_by_value({'apple': 5, 'banana': 2, 'cherry': 3}) == {'banana': 2, 'cherry': 3, 'apple': 5}\n", "\nassert sort_dict_by_value({'x': 10, 'y': 10, 'z': 5}) == {'z': 5, 'x': 10, 'y': 10}\n", "\nassert sort_dict_by_val... |
2fde1b3590a01abadb086b1da144837b | [
{
"content": "Implémente une classe Python nommée `Rectangle` qui inclut des méthodes pour calculer l'aire et le périmètre du rectangle. La classe doit être initialisée avec la largeur et la hauteur du rectangle. Ton implémentation doit inclure les méthodes suivantes :\n- `area()` : Retourne l'aire du rectangle... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).perimeter() == 20\n", "\nassert Rectangle(0, 0).area() == 0\n", "\nassert Rectangle(0, 0).perimeter() == 0\n", "\nassert Rectangle(10, 2).area() == 20\n", "\nassert Rectangle(7, 3).perimeter() == 20\n", "\nassert Rectangle(1, 1).area() == 1\n", "\nas... |
bc502059379f0225b30d8994a6fe8a09 | [
{
"content": "On te donne un entier `monthNum` représentant un mois de l'année. Ta tâche est d'écrire une fonction `monthString(monthNum)` qui renvoie le nom du mois sous forme de chaîne de caractères. L'entrée `monthNum` peut être un entier positif compris entre 1 et 12, inclusivement. De plus, l'entrée peut i... | ["\nassert monthString(1) == \"January\"\n", "\nassert monthString(12) == \"December\"\n", "\nassert monthString(\"02\") == \"February\"\n", "\nassert monthString(\"11\") == \"November\"\n", "\nassert monthString(7) == \"July\"\n", "\nassert monthString(\"01\") == \"January\"\n", "\nassert monthString(8) == \"August\"\... |
94b165a4e2402ac29b966fe40f2228b3 | [
{
"content": "On te demande d'implémenter une fonction `get_color_hsluv(category, subcategory)` qui renvoie une couleur dans l'espace colorimétrique HSLuv en fonction de la `category` et de la `subcategory` fournies. La fonction doit respecter les spécifications suivantes :\n\n- **Catégories et Sous-catégories ... | ["\nassert get_color_hsluv('temperature', 'cold') == (220, 100, 50)\n", "\nassert get_color_hsluv('temperature', 'moderate') == (150, 75, 75)\n", "\nassert get_color_hsluv('temperature', 'hot') == (35, 100, 50)\n", "\nassert get_color_hsluv('weather', 'sunny') == (60, 90, 50)\n", "\nassert get_color_hsluv('weather', 'c... |
9d06cf2e1a181d001ba9a110d7fee145 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver les indices des deux nombres dans `nums` qui s'additionnent pour donner `target`. Tu peux supposer que chaque entrée aura exactement une solution, et tu ne peux pas utiliser le même élément deux fois. Retourne l... | ["\nassert two_sum([2, 7, 11, 15], 9) == [0, 1]\n", "\nassert two_sum([3, 2, 4], 6) == [1, 2]\n", "\nassert two_sum([3, 3], 6) == [0, 1]\n", "\nassert two_sum([1, 2, 3, 4, 5], 9) == [3, 4]\n", "\nassert two_sum([10, 20, 30, 40, 50], 90) == [1, 3]\n", "\nassert two_sum([1, 5, 7, -1], 6) == [0, 3]\n", "\nassert two_sum([... |
cc943507c0f686b528cc0ed5ef19ed1d | [
{
"content": "Tu développes un système de notation pour un concours de mathématiques. Le concours se compose de six manches, chacune ayant un poids distinct dans le score final. Les manches sont les suivantes :\n\n1. Manche de calcul rapide (QMR) : Score représenté par `z`.\n2. Manche de maîtrise des formules (... | ["\nassert calculate_total_score(10, 5, 8, 3, 4, 2) == 88\n", "\nassert calculate_total_score(0, 0, 0, 0, 0, 0) == 0\n", "\nassert calculate_total_score(15, 10, 12, 5, 6, 3) == 169\n", "\nassert calculate_total_score(20, 15, 18, 7, 8, 4) == 267\n", "\nassert calculate_total_score(5, 3, 4, 2, 1, 1) == 34\n", "\nassert c... |
dda1ba71447e270b22d9e4d9a4a817f3 | [
{
"content": "On te donne une liste d'entiers, `numbers`, et une fonction `reduce_function` qui traite la liste en supprimant chaque troisième élément et en décalant les éléments restants vers la gauche. Ta tâche est de prédire le prochain entier qui apparaîtrait dans la liste originale si `reduce_function` éta... | ["\nassert predict_next_integer([1, 2, 3, 4, 5, 6, 7, 8, 9], lambda x: x[0] if len(x) == 1 else None, lambda x: x[::3], lambda original, reduced: original[original.index(reduced)]) == 1\n", "\nassert predict_next_integer([10, 20, 30, 40, 50, 60], lambda x: x[0] if len(x) == 1 else None, lambda x: x[::3], lambda origina... |
4c12eb312049b9e3e27a03b423eb6cb6 | [
{
"content": "On te demande d'implémenter une fonction nommée `validate_input` qui interagit avec un utilisateur pour obtenir une entrée entière valide dans une plage spécifiée. La fonction doit inviter l'utilisateur de manière répétée avec une question donnée jusqu'à ce qu'un entier valide soit entré. Si l'uti... | ["\nassert validate_input(\"Enter a number between 1 and 10: \", 1, 10) == 5\n", "\nassert validate_input(\"Enter a number between 1 and 10: \", 1, 10) == 1\n", "\nassert validate_input(\"Enter a number between 1 and 10: \", 1, 10) == 10\n", "\nassert validate_input(\"Enter a number between -5 and 5: \", -5, 5) == -5\n... |
54bc3b41efb9a527cf522400234266b1 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_duplicates` qui identifie et renvoie une liste d'entiers qui apparaissent plus d'une fois dans la liste d'entrée. L'ordre des entiers dans la liste de sortie doit correspondre à la première occurrence de chaque doublon ... | ["\nassert find_duplicates([1, 2, 3, 4, 5, 3, 2, 6]) == [3, 2]\n", "\nassert find_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert find_duplicates([1, 2, 3, 4, 5]) == []\n", "\nassert find_duplicates([]) == []\n", "\nassert find_duplicates([10, 20, 30, 40, 50, 10, 20, 60]) == [10, 20]\n", "\nassert find_duplicates([5, ... |
584fb7bf31a6e5d35c57c526d636f1b1 | [
{
"content": "Dans le domaine des cryptomonnaies, les transactions consistent en des entrées et des sorties, chacune ayant une taille variable en octets. Les entrées varient de 140 à 220 octets, et les sorties varient de 28 à 40 octets. Étant donné une transaction avec une surcharge fixe de 10 octets, ta tâche ... | ["\nassert estimate_transaction_size(0, 0) == 10\n", "\nassert estimate_transaction_size(1, 0) == 175\n", "\nassert estimate_transaction_size(0, 1) == 39\n", "\nassert estimate_transaction_size(2, 3) == 569\n", "\nassert estimate_transaction_size(5, 5) == 1070\n", "\nassert estimate_transaction_size(10, 10) == 2020\n",... |
0d3ea6c793ebfbe473c00e021fbd94f2 | [
{
"content": "On te donne un tableau NumPy 3D `I` représentant une image avec les dimensions `(hauteur, largeur, canaux)`. Ta tâche est d'écrire une fonction `reshape_for_ml_framework(I)` qui transforme l'image d'entrée `I` dans un format adapté à un framework d'apprentissage automatique (par exemple, PyTorch, ... | ["\nassert reshape_for_ml_framework(np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])).shape == (2, 2, 2, 2)\n", "\nassert torch.equal(reshape_for_ml_framework(np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])), torch.tensor([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], [[[8, 7], [6, 5]], [[4, 3], [2, 1]]]]))\n", "\nassert reshape_... |
86be738274b6a9365e77ad74426cbc69 | [
{
"content": "On te demande d'implémenter une fonction `extract_emails(text)` qui traite une chaîne de caractères donnée `text` et extrait toutes les adresses e-mail valides qu'elle contient. La fonction doit utiliser des expressions régulières pour identifier avec précision les adresses e-mail selon les règles... | ["\nassert extract_emails(\"Please contact us at support@example.com\") == [\"support@example.com\"]\n", "\nassert extract_emails(\"Reach out to john.doe@example.co.uk for more info.\") == [\"john.doe@example.co.uk\"]\n", "\nassert extract_emails(\"No emails here!\") == []\n", "\nassert extract_emails(\"Multiple emails... |
5e0510239899cf6bb8d64583b42de099 | [
{
"content": "On te donne deux nombres `a` et `b`, ainsi que deux paramètres de tolérance optionnels `rel_tol` et `abs_tol`. Ta tâche est de déterminer si `a` est suffisamment proche de `b` en fonction des tolérances données. La fonction doit renvoyer `True` si `a` est suffisamment proche de `b`, et `False` sin... | ["\nassert is_close_enough(1.0, 1.0) == True\n", "\nassert is_close_enough(1.0, 1.000000001) == True\n", "\nassert is_close_enough(1.0, 1.00000001) == False\n", "\nassert is_close_enough(1.0, 2.0, rel_tol=0.5) == True\n", "\nassert is_close_enough(1.0, 2.0, rel_tol=0.49) == False\n", "\nassert is_close_enough(float('in... |
8a077a0ec9b220ec461e6d81eec119d5 | [
{
"content": "On te donne une liste d'entiers uniques. Ta tâche est de générer tous les sous-ensembles possibles de cette liste et de les afficher dans l'ordre lexicographique.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10), le nombre d'éléments dans la liste.\n- La deuxième ligne cont... | ["\nassert generate_subsets([1, 2, 3]) == [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]\n", "\nassert generate_subsets([1]) == [[], [1]]\n", "\nassert generate_subsets([]) == [[]]\n", "\nassert generate_subsets([3, 1, 2]) == [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]\n", "\nassert generate_subsets(... |
dbe842d339d0c2c597f570e340c86f6e | [
{
"content": "On te demande d'implémenter une classe Python nommée `FileBackup` qui facilite la sauvegarde et la vérification de fichiers. La classe doit inclure les méthodes suivantes :\n\n- `__init__(self, source_file, backup_file)` : Initialise l'objet `FileBackup` avec les chemins du fichier source et du fi... | ["\nassert FileBackup(\"test.txt\", \"backup.txt\").backup() is None\n", "\nassert FileBackup(\"test.txt\", \"backup.txt\").verify_backup() == True\n", "\nassert FileBackup(\"nonexistent.txt\", \"backup.txt\").backup() is None\n", "\ntry:\n FileBackup(\"nonexistent.txt\", \"backup.txt\").backup()\nexcept FileNotFoun... |
fb095ea8e265744e7fc2e2f7b0847ed0 | [
{
"content": "On te donne un chemin vers un fichier multimédia. Ta tâche est d'écrire une fonction `find_subtitles(media_file)` qui recherche tous les fichiers de sous-titres associés au fichier multimédia donné. Le fichier multimédia et ses fichiers de sous-titres correspondants partagent le même nom de base m... | ["\nassert find_subtitles(\"/path/to/movie.mp4\") == [\"/path/to/movie.en.srt\", \"/path/to/movie.fr.srt\"]\n", "\nassert find_subtitles(\"/another/path/video.mkv\") == [\"/another/path/video.es.srt\", \"/another/path/video.de.srt\"]\n", "\nassert find_subtitles(\"/deeply/nested/folder/film.avi\") == [\"/deeply/nested/... |
b47cfbd07689cdcdf857d3777fd4d4ff | [
{
"content": "On te donne un fichier nommé `filename` contenant du texte. Ta tâche est d'implémenter une fonction `replace_word_in_file` qui lit le contenu du fichier, remplace toutes les occurrences d'un `old_word` spécifié par un `new_word`, et réécrit le contenu modifié dans le même fichier. La fonction doit... | ["\nassert replace_word_in_file(\"test.txt\", \"hello\", \"hi\") is None\n", "\nassert replace_word_in_file(\"test.txt\", \"world\", \"earth\") is None\n", "\nassert replace_word_in_file(\"test.txt\", \"python\", \"java\") is None\n", "\nassert replace_word_in_file(\"test.txt\", \" \", \"_\") is None\n", "\nassert repl... |
83d2cf7ec83504aedac1766b1319f045 | [
{
"content": "On te donne une feuille de calcul représentée comme une liste 2D de chaînes de caractères, où chaque chaîne est une valeur de cellule. Certaines cellules sont fusionnées, et les cellules fusionnées sont représentées comme une liste de plages, où chaque plage est un tuple de deux cellules (ligne_dé... | ["\nassert get_merged_cells_values([[\"A1\", \"A2\", \"A3\", \"A4\"], [\"B1\", \"B2\", \"B3\", \"B4\"], [\"C1\", \"C2\", \"C3\", \"C4\"], [\"D1\", \"D2\", \"D3\", \"D4\"]], [((1, 1), (2, 2)), ((0, 2), (1, 3))]) == {(1, 1): \"B2B3C2C3\", (0, 2): \"A3A4B3B4\"}\n", "\nassert get_merged_cells_values([[\"X\", \"Y\", \"Z\"],... |
f76a71dd0375d52b251d102b3aa01a35 | [
{
"content": "On te donne un dictionnaire Python. Ta tâche est d'implémenter une fonction `convert_to_json` qui convertit ce dictionnaire en une chaîne JSON. La chaîne JSON doit être formatée avec une indentation de 4 espaces pour améliorer la lisibilité.\n\n**Entrée :**\n- Un dictionnaire Python `data`.\n\n**S... | ["\nassert convert_to_json({\"name\": \"John\", \"age\": 30}) == '{\\n \"name\": \"John\",\\n \"age\": 30\\n}'\n", "\nassert convert_to_json({\"city\": \"New York\", \"population\": 8419000}) == '{\\n \"city\": \"New York\",\\n \"population\": 8419000\\n}'\n", "\nassert convert_to_json({\"fruits\": [\"apple... |
cde2be807b3dfd3ab6f7019929ffc0c8 | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python. La classe doit avoir un constructeur qui initialise la largeur et la hauteur du rectangle. De plus, elle doit inclure des méthodes pour calculer l'aire et le périmètre du rectangle. Ton implémentation doit être efficace et respecter les... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).perimeter() == 20\n", "\nassert Rectangle(0, 0).area() == 0\n", "\nassert Rectangle(0, 0).perimeter() == 0\n", "\nassert Rectangle(10, 2).area() == 20\n", "\nassert Rectangle(7, 3).perimeter() == 20\n", "\nassert Rectangle(1, 1).area() == 1\n", "\nas... |
ad90615e4b0fc3c3fc5089bf760488b3 | [
{
"content": "On te donne une liste de mots. Ta tâche est d'écrire une fonction `count_vowels(word_list)` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les mots de la liste, et les valeurs doivent être le nombre de voyelles ('a', 'e', 'i', 'o', 'u') présentes dans chaque mot. Suppose que to... | ["\nassert count_vowels(['apple']) == {'apple': 2}\n", "\nassert count_vowels(['banana']) == {'banana': 3}\n", "\nassert count_vowels(['cherry']) == {'cherry': 2}\n", "\nassert count_vowels(['']) == {'': 0}\n", "\nassert count_vowels(['bcdfg']) == {'bcdfg': 0}\n", "\nassert count_vowels(['AEIOU']) == {'AEIOU': 0}\n", "... |
fb0eadb2f16cc2b7cbf9ff360661fbda | [
{
"content": "On te demande d'implémenter une fonction `format_user_profile` qui traite un dictionnaire représentant un profil utilisateur. Le dictionnaire doit contenir les clés \"first_name\", \"last_name\", \"age\" et \"email\". Ta fonction doit renvoyer une chaîne formatée avec le nom complet de l'utilisate... | ["\nassert format_user_profile({\"first_name\": \"John\", \"last_name\": \"Doe\", \"age\": 30, \"email\": \"john.doe@example.com\"}) == \"Full Name: John Doe, Age: 30, Email: john.doe@example.com\"\n", "\nassert format_user_profile({\"first_name\": \"Jane\", \"last_name\": \"Smith\", \"age\": 25, \"email\": \"jane.smit... |
f533662bcf73b32fc87bea88de32e558 | [
{
"content": "On te donne une liste d'entiers `data` et un entier `absent_value`. Ta tâche est de créer une fonction `encode_data` qui traite la liste en ordre inverse et renvoie une nouvelle liste où chaque élément est soit 1, soit 0. Si un élément de la liste inversée est égal à `absent_value`, il doit être r... | ["\nassert encode_data([1, 2, 3, 4, 5], 3) == [1, 1, 0, 1, 1]\n", "\nassert encode_data([10, 20, 30, 40, 50], 10) == [0, 1, 1, 1, 1]\n", "\nassert encode_data([5, 5, 5, 5, 5], 5) == [0, 0, 0, 0, 0]\n", "\nassert encode_data([1, 2, 3, 4, 5], 6) == [1, 1, 1, 1, 1]\n", "\nassert encode_data([], 1) == []\n", "\nassert enco... |
5e56269ad12dd31a9a863187bde4bc17 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais et d'espaces. Ta tâche est de compresser la chaîne en supprimant tous les espaces et en réduisant chaque séquence de caractères identiques consécutifs à un seul caractère. Implémente la fonction `compress... | ["\nassert compress_string(\"aabb cc dd\") == \"abcd\"\n", "\nassert compress_string(\"hello world\") == \"helo wrd\"\n", "\nassert compress_string(\"aaabbbccc\") == \"abc\"\n", "\nassert compress_string(\"a b c d e\") == \"abcde\"\n", "\nassert compress_string(\" \") == \"\"\n", "\nassert compress_string(\"abc\") ... |
f081cea6daf1300edf6c0878c50f7fb6 | [
{
"content": "On te donne un ensemble de données composé de phrases et de leurs étiquettes correspondantes de parties du discours (POS). Chaque phrase est représentée comme une liste d'entiers, où chaque entier est un index dans un vocabulaire prédéfini. De même, chaque étiquette est une liste d'entiers représe... | ["\nassert torch.equal(pad_and_group_sentences([[1, 2, 3], [4, 5], [6]], [[10, 20, 30], [40, 50], [60]])[0], torch.tensor([[1, 2, 3], [4, 5, 0], [6, 0, 0]], dtype=torch.long))\n", "\nassert torch.equal(pad_and_group_sentences([[1, 2, 3], [4, 5], [6]], [[10, 20, 30], [40, 50], [60]])[1], torch.tensor([[10, 20, 30], [40,... |
49923e897ffb775fdc2e4a0c2cc8b2bc | [
{
"content": "Dans un défi de programmation compétitive, tu dois implémenter une fonction de rappel nommée `save_model_callback` pour sauvegarder un modèle PyTorch pendant l'entraînement. La fonction doit gérer les modèles entraînés sur plusieurs appareils et assurer la compatibilité avec les appareils CPU et C... | ["\nassert save_model_callback(torch.nn.Linear(10, 2), 'test_model.pth') is None\n", "\nassert save_model_callback(torch.nn.Sequential(torch.nn.Linear(10, 20), torch.nn.ReLU()), 'test_model.pth') is None\n", "\nassert save_model_callback(torch.nn.DataParallel(torch.nn.Linear(10, 2)), 'test_model.pth') is None\n", "\nas... |
4310072b5e7a244184f4230c34f88175 | [
{
"content": "On te donne une chaîne de caractères `dna_sequence` représentant une séquence d'ADN. Ta tâche est d'écrire une fonction `get_complement_dna` qui renvoie le brin complémentaire de la séquence d'ADN. La séquence d'ADN en entrée doit contenir uniquement les caractères 'A', 'T', 'C' et 'G'. Si l'entré... | ["\nassert get_complement_dna(\"ATGC\") == \"TACG\"\n", "\nassert get_complement_dna(\"GCTA\") == \"CGAT\"\n", "\nassert get_complement_dna(\"AAAA\") == \"TTTT\"\n", "\nassert get_complement_dna(\"TTTT\") == \"AAAA\"\n", "\nassert get_complement_dna(\"CGCG\") == \"GCGC\"\n", "\nassert get_complement_dna(\"ACGTACGT\") =... |
cc55f322086cede28a09df6c968a662e | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'écrire une fonction qui traite chaque chaîne de caractères de la liste en supprimant les espaces blancs en début et en fin de chaîne, puis en mettant en majuscule la première lettre de la chaîne résultante. La fonction doit renvoye... | ["\nassert capitalize_and_strip([\" hello \", \"world\", \" Python programming \"]) == ['Hello', 'World', 'Python programming']\n", "\nassert capitalize_and_strip([\" test \", \" case \", \" here \"]) == ['Test', 'Case', 'Here']\n", "\nassert capitalize_and_strip([\"python\", \"is\", \"fun\"]) == ['Python', '... |
7b18c98fa7e3bbf78c7c607c06ff8bdc | [
{
"content": "On te donne une liste d'éléments qui peuvent inclure des entiers, des nombres à virgule flottante et des valeurs non numériques. Ta tâche est de mettre en œuvre une fonction `calculate_mean` qui calcule la moyenne arithmétique de toutes les valeurs numériques de la liste. Si la liste ne contient a... | ["\nassert calculate_mean([1, 2, 3, 4, 5]) == 3.0\n", "\nassert calculate_mean([10, 20, 30]) == 20.0\n", "\nassert calculate_mean([1, 2, 'a', 3.5]) == 2.1666666666666665\n", "\nassert calculate_mean(['a', 'b', 'c']) == None\n", "\nassert calculate_mean([]) == None\n", "\nassert calculate_mean([1.5, 2.5, 3.5]) == 2.5\n"... |
3c3362b6057e557ee72b856e22ca42f1 | [
{
"content": "On te donne un arbre de recherche binaire (BST) avec `n` nœuds. Ta tâche est de convertir cet BST en une liste doublement chaînée triée (DLL) sur place. Les pointeurs gauche et droit dans les nœuds BST doivent être utilisés comme les pointeurs précédent et suivant dans la DLL, respectivement. L'or... | ["\nassert BSTToDLL(Node(1)).data == 1\n", "\nassert BSTToDLL(Node(10)).data == 10\n", "\nassert BSTToDLL(Node(10).left = Node(5)).data == 5\n", "\nassert BSTToDLL(Node(10).right = Node(15)).data == 10\n", "\nassert BSTToDLL(Node(10).left = Node(5).right = Node(7)).right.data == 7\n", "\nassert BSTToDLL(Node(10).left =... |
26b97aabfe59e5be0f45c5ec455cc7b2 | [
{
"content": "Dans un système de billetterie, tu dois concevoir une fonction `generate_ticket_id` qui prend un identifiant utilisateur en entrée et renvoie un tuple constitué du hachage SHA-256 de l'identifiant utilisateur et d'un identifiant de ticket unique. L'identifiant de ticket doit être un entier aléatoi... | ["\nassert isinstance(generate_ticket_id(\"user123\")[0], str)\n", "\nassert len(generate_ticket_id(\"user123\")[0]) == 64\n", "\nassert generate_ticket_id(\"user123\")[1] % 7 != 0\n", "\nassert generate_ticket_id(\"user123\")[1] >= 1 and generate_ticket_id(\"user123\")[1] <= 1000000\n", "\nassert generate_ticket_id(\"... |
72f025d54dacfbf85627a3380af4861b | [
{
"content": "On te donne un tableau booléen circulaire `events` de longueur `n`, où chaque élément indique si un événement se produit à cette position. Ta tâche est de créer une fonction `filter_events_circular` qui renvoie un nouveau tableau booléen de la même longueur. Dans le nouveau tableau, un événement d... | ["\nassert filter_events_circular([False, True, False, True, False, False, True, False, True], 2) == [False, False, False, False, False, False, True, False, False]\n", "\nassert filter_events_circular([True, False, False, False, True, False, False, False, True], 1) == [False, False, False, False, False, False, False, F... |
5547f31e2a4d37dbfebb31ddc6f41a0f | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence croissante (PSC) dans la liste. La PSC est définie comme la plus longue sous-séquence où chaque élément est strictement supérieur au précédent. S'il existe plusieurs sous-séquences de longueur maximale identique,... | ["\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 18]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7, 7, 7]) == [7]\n", "\nassert longest_increasing_subsequence([1, 2, 3, 4, 5]) == [1, 2, 3, ... |
370a424b5a2c0e31227d946c746bbc45 | [
{
"content": "On te donne une chaîne de caractères représentant une variable dans un format spécifique. Ce format consiste en un nom de dimension suivi d'une valeur numérique. Le nom de dimension et la valeur numérique sont séparés par un chiffre qui marque le début de la valeur numérique. Ta tâche est de trans... | ["\nassert transform_variable(\"temperature42\", \":\", \"|\", 42, 99) == \"TEMPERATURE:99|\"\n", "\nassert transform_variable(\"voltage\", \":\", \"|\", 42, 99) == \"voltage|\"\n", "\nassert transform_variable(\"height123\", \":\", \"|\", 42, 99) == \"HEIGHT:123|\"\n", "\nassert transform_variable(\"width\", \":\", \"... |
df2e4a0ad4526691e0dbbe7d865eba86 | [
{
"content": "On te donne deux entiers positifs, `base` et `mod`. Ta tâche est de déterminer l'inverse multiplicatif modulaire de `base` modulo `mod`. L'inverse multiplicatif modulaire de `base` est un entier `x` tel que `(base * x) % mod = 1`. Si un tel entier `x` existe, il doit s'agir d'un entier non signé s... | ["\nassert find_modular_inverse(3, 11) == 4\n", "\nassert find_modular_inverse(10, 17) == 12\n", "\nassert find_modular_inverse(10, 20) == None\n", "\nassert find_modular_inverse(7, 26) == 15\n", "\nassert find_modular_inverse(1, 2) == 1\n", "\nassert find_modular_inverse(117, 191) == 178\n", "\nassert find_modular_inv... |
d370cad31df9aebcfae5c5ecf4d23538 | [
{
"content": "On te donne deux séquences d'ADN, `sequence1` et `sequence2`, et un entier positif `k`. Les séquences d'ADN sont composées des caractères 'A', 'C', 'G' et 'T'. Ta tâche est d'identifier toutes les sous-chaînes communes de longueur `k` qui apparaissent dans les deux séquences et qui sont des palind... | ["\nassert common_dna_substrings(\"ATCGTACGATCGATCGTACG\", \"TACGATCGATCGTACGATCG\", 4) == [\"ATCG\", \"TACG\"]\n", "\nassert common_dna_substrings(\"AAAA\", \"AAAA\", 2) == [\"AA\"]\n", "\nassert common_dna_substrings(\"ACGT\", \"TGCA\", 2) == []\n", "\nassert common_dna_substrings(\"GATTACA\", \"ACATTA\", 3) == [\"AT... |
28dda823276181c9a8a88fd15524e42d | [
{
"content": "On te donne une poutre de longueur `beam_length` mètres, divisée en `num_elements` segments égaux. Chaque segment peut initialement supporter une charge maximale de `max_load_per_element` unités. Cependant, la capacité de charge de chaque segment diminue de 10 % pour chaque mètre au-delà du premie... | ["\nassert find_first_breaking_element(1, 5, 100, 600) == 1\n", "\nassert find_first_breaking_element(2, 5, 100, 600) == 0\n", "\nassert find_first_breaking_element(3, 5, 100, 600) == 0\n", "\nassert find_first_breaking_element(4, 5, 100, 600) == 0\n", "\nassert find_first_breaking_element(5, 5, 100, 600) == 0\n", "\na... |
f999d491b2dc7bb90834eb5073d67593 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence croissante dans la liste. Une sous-séquence croissante est définie comme une séquence où chaque élément est supérieur au précédent. La sous-séquence n'a pas besoin d'être contiguë. S'il existe plusieurs sous-séqu... | ["\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 101, 18]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7, 7, 7]) == [7]\n", "\nassert longest_increasing_subsequence([1, 2, 3, 4, 5]) == [1, 2... |
b166221b3c6353146dec6e4d7992d099 | [
{
"content": "On te donne une chaîne hexadécimale représentant une séquence d'octets. Chaque octet est un nombre hexadécimal à deux caractères. Ta tâche est d'écrire une fonction `hex_to_decimal_array` qui convertit cette chaîne hexadécimale en un tableau de nombres décimaux, où chaque nombre décimal correspond... | ["\nassert hex_to_decimal_array(\"0123456789ABCDEF\") == [1, 35, 69, 103, 137, 171, 205, 239]\n", "\nassert hex_to_decimal_array(\"00\") == [0]\n", "\nassert hex_to_decimal_array(\"FF\") == [255]\n", "\nassert hex_to_decimal_array(\"A0B1C2D3\") == [160, 177, 194, 211]\n", "\nassert hex_to_decimal_array(\"abcdef\") == [... |
c20dad034de15d69e4f95edca57cdfec | [
{
"content": "On te donne un dictionnaire imbriqué `data` qui peut contenir d'autres dictionnaires et des listes comme valeurs. Ta tâche est d'écrire une fonction récursive `flatten_dict(data)` qui transforme cette structure imbriquée en un dictionnaire plat. Les clés dans le dictionnaire résultant doivent être... | ["\nassert flatten_dict({'a': 1, 'b': {'c': 2, 'd': {'e': 3}}}) == {'a': 1, 'b.c': 2, 'b.d.e': 3}\n", "\nassert flatten_dict({'x': [1, 2, 3], 'y': {'z': 4}}) == {'x.0': 1, 'x.1': 2, 'x.2': 3, 'y.z': 4}\n", "\nassert flatten_dict({'key': 'value'}) == {'key': 'value'}\n", "\nassert flatten_dict({}) == {}\n", "\nassert fl... |
f40821891e58b933355d7137113b3509 | [
{
"content": "On te donne une fonction `func(x)` qui calcule l'expression `5 * x + 2`. Refactorise la fonction pour améliorer sa lisibilité et ses performances. Ta fonction doit prendre un entier `x` en entrée et renvoyer le résultat de l'expression.\n\n**Exemple d'entrée :**\n```\n3\n```\n\n**Exemple de sortie... | ["\nassert func(0) == 2\n", "\nassert func(1) == 7\n", "\nassert func(-1) == -3\n", "\nassert func(10) == 52\n", "\nassert func(-10) == -48\n", "\nassert func(0.5) == 5.0\n", "\nassert func(-0.5) == -3.0\n", "\nassert func(100) == 502\n", "\nassert func(-100) == -498\n", "\nassert func(123456789) == 617283947\n"] |
e94f863e8f72f8665193df1ea5b36068 | [
{
"content": "On te demande d'implémenter une classe `TemperatureConverter` en Python qui prenne en charge les conversions de température entre Celsius, Fahrenheit et Kelvin. Ta classe doit inclure les méthodes suivantes :\n\n- `celsius_to_fahrenheit(celsius)` : Convertit une température de Celsius en Fahrenhei... | ["\nassert TemperatureConverter().celsius_to_fahrenheit(0) == 32.0\n", "\nassert TemperatureConverter().fahrenheit_to_celsius(32) == 0.0\n", "\nassert TemperatureConverter().celsius_to_kelvin(0) == 273.15\n", "\nassert TemperatureConverter().kelvin_to_celsius(273.15) == 0.0\n", "\nassert TemperatureConverter().fahrenhe... |
8dad26862cdd200f18ecc99a37beb604 | [
{
"content": "On te demande d'implémenter une fonction qui génère une séquence infinie de nombres premiers. Ta fonction doit être un générateur qui renvoie le nombre premier suivant à chaque itération. Le générateur doit commencer par le plus petit nombre premier, qui est 2.\n\n**Signature de la fonction :**\n`... | ["\nassert next(generate_prime_sequence()) == 2\n", "\ngen = generate_prime_sequence()\nnext(gen)\nassert next(gen) == 3\n", "\ngen = generate_prime_sequence()\nnext(gen)\nnext(gen)\nassert next(gen) == 5\n", "\ngen = generate_prime_sequence()\nnext(gen)\nnext(gen)\nnext(gen)\nassert next(gen) == 7\n", "\ngen = generat... |
2943014ac01d8fe881d92e3cb443281b | [
{
"content": "On te donne une structure de liste imbriquée composée d'entiers et d'autres listes. Ta tâche est d'écrire une fonction qui aplatit cette structure en une seule liste contenant tous les entiers dans l'ordre où ils apparaissent. La fonction doit être capable de gérer n'importe quel niveau d'imbricat... | ["\nassert flatten_list([[1, 2, [3, 4]], [5, 6], [7, 8, [9, 10]]]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert flatten_list([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert flatten_list([[1], [2], [3], [4], [5]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten_list([[[[1]]]]) == [1]\n", "\nassert flatten_list([]) == []\... |
464f8a807c10f5af8fa9101022aad49f | [
{
"content": "On te donne deux listes, `predictions` et `ground_truth`, représentant les étiquettes de classe prédites et réelles pour un ensemble de données, respectivement. Les deux listes ont la même longueur et leurs éléments sont alignés de telle sorte que le i-ème élément de `predictions` correspond au i-... | ["\nassert confusion_matrix_v2([1, 2, 3], [1, 2, 3]) == {(1, 1): 1, (2, 2): 1, (3, 3): 1}\n", "\nassert confusion_matrix_v2([1, 2, 2], [1, 1, 2]) == {(1, 1): 1, (2, 1): 1, (2, 2): 1}\n", "\nassert confusion_matrix_v2([[1, 2], [3]], [[1, 2], [3]]) == {(1, 1): 1, (2, 2): 1, (3, 3): 1}\n", "\nassert confusion_matrix_v2([[... |
f59b1883d4098d2018c8a8ce20b43ac2 | [
{
"content": "On te donne une liste de chaînes de caractères représentant différentes couleurs. Ta tâche est de déterminer si cette liste contient toutes les couleurs de l'arc-en-ciel dans n'importe quel ordre. Les couleurs de l'arc-en-ciel sont : scarlet, amber, lemon, chartreuse, azure, ultramarine et magenta... | ["\nassert find_rainbow_colors([\"scarlet\", \"amber\", \"lemon\", \"chartreuse\", \"azure\", \"ultramarine\", \"magenta\"]) == True\n", "\nassert find_rainbow_colors([\"scarlet\", \"amber\", \"lemon\", \"chartreuse\", \"azure\", \"ultramarine\"]) == False\n", "\nassert find_rainbow_colors([\"scarlet\", \"amber\", \"le... |
1bef55c08ef1272e7a90c1094695fa3f | [
{
"content": "On te donne une fonction `divide(a, b)` qui effectue la division de deux nombres `a` et `b`. Ta tâche est de modifier cette fonction pour gérer gracieusement la division par zéro en renvoyant un message d'erreur spécifique. Implémente la fonction modifiée.\n\n**Exemple d'entrée :**\n```\ndivide(10... | ["\nassert divide(10, 2) == 5\n", "\nassert divide(10, 0) == \"Error: Division by zero is not allowed.\"\n", "\nassert divide(0, 10) == 0\n", "\nassert divide(-10, 2) == -5\n", "\nassert divide(10, -2) == -5\n", "\nassert divide(-10, -2) == 5\n", "\nassert divide(1.5, 3) == 0.5\n", "\nassert divide(3, 1.5) == 2\n", "\n... |
47dda0f2465049e1c9207e9af6a8aa79 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `remove_duplicates(lst)` qui traite cette liste et renvoie une nouvelle liste contenant uniquement la première occurrence de chaque entier, en maintenant l'ordre original de leur première apparition.\n\n**Entrée :**\n- Une li... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates(['a', 'b', 'c', 'a', 'b', 'c']) == ['a', 'b', 'c']\n", "\nassert remove_duplicates([10, 20, 30, 40, 50]) == [10, 20, 30... |
dcdc41d9855a1262a45ed896bf039152 | [
{
"content": "On te donne une liste d'entiers `list1` et un entier `target`. Ta tâche est de trouver l'index de la première occurrence de `target` dans `list1`. Si `target` n'est pas trouvé, la fonction doit renvoyer `-1`. Refactorise le code fourni pour améliorer sa lisibilité et son efficacité tout en conserv... | ["\nassert find_target_index([1, 2, 3, 4, 5], 3) == 2\n", "\nassert find_target_index(['a', 'b', 'c', 'd'], 'd') == 3\n", "\nassert find_target_index([10, 20, 30, 40], 10) == 0\n", "\nassert find_target_index([100, 200, 300, 400], 500) == None\n", "\nassert find_target_index([], 1) == None\n", "\nassert find_target_ind... |
957082f9861f8f15e66ed08261281b69 | [
{
"content": "On te demande d'implémenter une classe `Logger` en Python qui supporte l'enregistrement de messages dans un fichier avec différents niveaux de sévérité : `INFO`, `WARNING` et `ERROR`. Chaque entrée de journal doit être préfixée d'un horodatage au format `AAAA-MM-JJ HH:MM:SS`. La classe doit fourni... | ["\nassert Logger('test.log').info('Test info message') is None\n", "\nassert Logger('test.log').warning('Test warning message') is None\n", "\nassert Logger('test.log').error('Test error message') is None\n", "\nlogger = Logger('test.log'); logger.info('Info test'); logger.warning('Warning test'); logger.error('Error ... |
01a68a5eb0079cc00baad8dfa8f4aded | [
{
"content": "Implémente un algorithme de recherche binaire en Python. Étant donné un tableau trié d'entiers et un entier cible, ta tâche est de trouver l'index de la cible dans le tableau. Si la cible n'est pas présente, retourne -1.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), l... | ["\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21], 13) == 6\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21], 1) == 0\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21], 21) == 10\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21], 4) == -1\n", "\nasse... |
ee68ca3bb5be2ce2ec402db481822f9d | [
{
"content": "Implémente une structure de données pile en Python. Ta pile doit prendre en charge les opérations suivantes :\n- `is_empty()` : Renvoie `True` si la pile est vide, sinon `False`.\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élément du sommet de la pi... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().size() == 0\n", "\ns = Stack(); s.push(1); assert s.peek() == 1\n", "\ns = Stack(); s.push(1); s.push(2); assert s.size() == 2\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.size() == 1\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.p... |
b53cafa4c9eabaca393bb62a2d41fb2f | [
{
"content": "On te demande de résoudre le problème des N-Reines sur un échiquier de taille N x N. Place N reines sur le plateau de manière à ce qu'aucune reine ne menace une autre. Une reine peut menacer une autre reine si elles se trouvent sur la même ligne, la même colonne ou le long de la même diagonale. To... | ["\nassert find_queen_positions(1) == [0]\n", "\nassert find_queen_positions(2) == []\n", "\nassert find_queen_positions(3) == []\n", "\nassert find_queen_positions(4) == [1, 3, 0, 2]\n", "\nassert find_queen_positions(5) == [0, 2, 4, 1, 3]\n", "\nassert find_queen_positions(6) == [1, 3, 5, 0, 2, 4]\n", "\nassert find_... |
c789ffca033a5c639cbec4a8f7cc2c61 | [
{
"content": "On te donne une grille 2D représentant une population où chaque cellule peut être dans l'un des trois états suivants :\n- `0` : Mort ou non infecté\n- `1` : Vivant ou infecté\n- `2` : Vivant et infecté (Patient Zéro)\n\nLa grille est initialisée avec une distribution aléatoire de cellules vivantes... | ["\nassert simulate_virus_spread(0, 0, 0) == ([], 0)\n", "\nassert simulate_virus_spread(1, 1, 0) == ([[0]], 0) or simulate_virus_spread(1, 1, 0) == ([[2]], 1)\n", "\nassert simulate_virus_spread(1, 1, 1) == ([[2]], 1) if simulate_virus_spread(1, 1, 0) == ([[2]], 1) else simulate_virus_spread(1, 1, 1) == ([[0]], 0)\n",... |
ff9fd9eabef6240f8f70fef01632cd27 | [
{
"content": "On te demande d'implémenter un décorateur Python nommé `log_function_calls`. Ce décorateur doit être capable d'enregistrer des informations détaillées sur les appels de fonction, notamment le nom de la fonction, ses arguments positionnels et ses arguments nommés, ainsi que sa valeur de retour. Cha... | ["\nassert log_function_calls(lambda x: x)(5) == 5\n", "\nassert log_function_calls(lambda x, y: x + y)(3, 4) == 7\n", "\nassert log_function_calls(lambda x, y=10: x + y)(5) == 15\n", "\nassert log_function_calls(lambda x, y=10: x + y)(5, y=20) == 25\n", "\nassert log_function_calls(lambda x, y, z: x * y + z)(2, 3, 4) ... |
7d3bcbd61205efc8b6f9e7657faa3e16 | [
{
"content": "On te demande d'analyser un fichier journal d'un serveur web pour déterminer la fréquence des requêtes provenant de chaque adresse IP. Chaque entrée de journal dans le fichier est structurée comme suit : `timestamp IP_address request_method request_URL status_code response_size`. Ton objectif est ... | ["\nassert count_ip_addresses(\"test_log.txt\") == {'192.168.1.1': 3, '192.168.1.2': 2, '192.168.1.3': 1}\n", "\nassert count_ip_addresses(\"empty_log.txt\") == {}\n", "\nassert count_ip_addresses(\"single_entry_log.txt\") == {'10.0.0.1': 1}\n", "\nassert count_ip_addresses(\"multiple_entries_same_ip_log.txt\") == {'17... |
b26c8b78d5ef1a9f2adafe8679972bad | [
{
"content": "On te donne une liste contenant des entiers, des nombres à virgule flottante et des chaînes de caractères. Ta tâche est d'écrire une fonction `count_even_numbers` qui compte le nombre d'entiers pairs dans la liste qui sont strictement supérieurs à la moyenne de tous les entiers de la liste. La fon... | ["\nassert count_even_numbers([1, 2, 3, 4, 5, 6]) == 2\n", "\nassert count_even_numbers([10, 20, 30, 40, 50]) == 3\n", "\nassert count_even_numbers([1.5, 2.5, 3.5, 4.5, 5.5]) == 0\n", "\nassert count_even_numbers(['a', 'b', 'c', 2, 4, 6]) == 2\n", "\nassert count_even_numbers([0, 2, 4, 6, 8]) == 2\n", "\nassert count_e... |
b8ab9f286bf1432f8ad1afa2390de6fd | [
{
"content": "On te donne un arbre binaire représenté par une structure basée sur des classes. Ta tâche est d'écrire une fonction qui calcule la profondeur maximale de l'arbre. La profondeur maximale est définie comme le nombre de nœuds le long du chemin le plus long du nœud racine jusqu'au nœud feuille le plus... | ["\nassert maxDepth(None) == 0\n", "\nassert maxDepth(TreeNode(1)) == 1\n", "\nassert maxDepth(TreeNode(1, TreeNode(2))) == 2\n", "\nassert maxDepth(TreeNode(1, None, TreeNode(2))) == 2\n", "\nassert maxDepth(TreeNode(1, TreeNode(2), TreeNode(3))) == 2\n", "\nassert maxDepth(TreeNode(1, TreeNode(2, TreeNode(3)))) == 3\... |
64a7cbc9e825de3628dad8440b786958 | [
{
"content": "On te demande d'implémenter une fonction `bytes2human` qui convertit un nombre d'octets donné en un format lisible par un humain, en fonction du système d'unités spécifié. La fonction doit gérer les valeurs d'entrée entières et à virgule flottante. Si la valeur d'entrée n'est pas un nombre valide,... | ["\nassert bytes2human(1024, 'iec') == \"1.00 KiB\"\n", "\nassert bytes2human(1000, 'customary') == \"1.00 KB\"\n", "\nassert bytes2human(123456789, 'iec_ext') == \"117.74 mebi\"\n", "\nassert bytes2human(987654321, 'customary_ext') == \"987.65 giga\"\n", "\nassert bytes2human(float('nan'), 'iec') == 0\n", "\nassert by... |
48ea20785874a31c8e1e1e4d0f7ff15a | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `count_vowel_substrings(s)` qui compte le nombre de sous-chaînes de `s` qui contiennent au moins une voyelle. Une sous-chaîne est définie comme une séquence contiguë de caractères dans la chaîne. Tu **n'es pas** auto... | ["\nassert count_vowel_substrings(\"abcde\") == 10\n", "\nassert count_vowel_substrings(\"xyz\") == 0\n", "\nassert count_vowel_substrings(\"aeiou\") == 15\n", "\nassert count_vowel_substrings(\"bcd\") == 0\n", "\nassert count_vowel_substrings(\"a\") == 1\n", "\nassert count_vowel_substrings(\"ae\") == 3\n", "\nassert ... |
ddb025f2ace3f6fa754a91cb37c32939 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui calcule la somme de tous les entiers de la liste. Ton implémentation doit être efficace et respecter les directives PEP 8 en matière de lisibilité du code. La fonction doit être bien documentée avec une docstring.\n\n**... | ["\nassert calculate_sum([1, 2, 3, 4, 5]) == 15\n", "\nassert calculate_sum([-1, -2, -3, -4, -5]) == -15\n", "\nassert calculate_sum([0, 0, 0, 0, 0]) == 0\n", "\nassert calculate_sum([100, 200, 300]) == 600\n", "\nassert calculate_sum([]) == 0\n", "\nassert calculate_sum([1.5, 2.5, 3.5]) == 7.5\n", "\nassert calculate_... |
e3d3de61a3c9af8287fb44c5462ca24d | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais et un ensemble de `n` paires de la forme `[x, y]`. Chaque paire `[x, y]` indique que toutes les occurrences de `x` peuvent être échangées avec toutes les occurrences de `y` dans la chaîne `s`. Ta tâche es... | ["\nassert minimizeString(\"abcdef\", [[\"a\", \"b\"], [\"b\", \"c\"], [\"c\", \"d\"], [\"a\", \"e\"]]) == \"abcdee\"\n", "\nassert minimizeString(\"dcba\", [[\"a\", \"b\"], [\"b\", \"c\"], [\"c\", \"d\"]]) == \"abcd\"\n", "\nassert minimizeString(\"xyz\", [[\"x\", \"y\"], [\"y\", \"z\"]]) == \"xyz\"\n", "\nassert mini... |
a2969d683223fb8a122fe142c737f04d | [
{
"content": "On te donne une chaîne de caractères `s` et une sous-chaîne `sub`. Ta tâche est d'implémenter une fonction `count_substrings(s, sub)` qui renvoie le nombre d'occurrences non chevauchantes de `sub` dans `s`. La fonction doit s'exécuter en temps O(n), où n est la longueur de la chaîne `s`.\n\n**Entr... | ["\nassert count_substrings(\"abcabcabc\", \"abc\") == 3\n", "\nassert count_substrings(\"aaaa\", \"aa\") == 3\n", "\nassert count_substrings(\"abababab\", \"aba\") == 3\n", "\nassert count_substrings(\"hello world\", \"world\") == 1\n", "\nassert count_substrings(\"hello world\", \"hello\") == 1\n", "\nassert count_su... |
3477b09f8eb99c6756176833e35291ce | [
{
"content": "On te demande d'implémenter une fonction pour calculer le `n`ième terme de la suite de Fibonacci en utilisant une approche récursive. Pour optimiser ta solution et éviter les calculs redondants, tu dois utiliser la mémoïsation. Ta fonction doit gérer efficacement les grandes valeurs de `n` jusqu'à... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(15) == 610\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(25... |
7726326cdfccb287d818e6ce3b901993 | [
{
"content": "On te demande d'implémenter une fonction `parse_json` qui traite une chaîne JSON et renvoie un dictionnaire. Ta fonction doit gérer avec élégance les chaînes JSON mal formées en renvoyant `None` dans de tels cas. Plus précisément, ta fonction doit renvoyer `None` si la chaîne JSON manque des virgu... | ["\nassert parse_json('{\"name\": \"John\", \"age\": 30}') == {\"name\": \"John\", \"age\": 30}\n", "\nassert parse_json('{\"name\": \"John\", \"age\": 30,}') == None\n", "\nassert parse_json('{\"name\": \"John\" \"age\": 30}') == None\n", "\nassert parse_json('{\"name\": \"John\", \"age\": 30') == None\n", "\nassert p... |
95cb0e3ca9ad635125bb88238bb1098c | [
{
"content": "On te donne un dictionnaire `input_dict` où chaque clé est unique. Ta tâche est de créer une fonction qui renvoie un nouveau dictionnaire avec les clés et les valeurs inversées. S'il y a des valeurs dupliquées dans le dictionnaire d'entrée, ajoute un tiret bas suivi d'un compteur aux nouvelles clé... | ["\nassert swap_keys_values({'a': 1, 'b': 2, 'c': 2}) == {1: 'a', 2: 'b_1', '2_1': 'c'}\n", "\nassert swap_keys_values({'x': 10, 'y': 20, 'z': 10}) == {10: 'x', 20: 'y', '10_1': 'z'}\n", "\nassert swap_keys_values({'one': 1, 'two': 2, 'three': 3}) == {1: 'one', 2: 'two', 3: 'three'}\n", "\nassert swap_keys_values({'a':... |
e829efd6c405e67e038999e2a2874790 | [
{
"content": "On te donne une exception personnalisée `CustomException`, une fonction `func` et une liste d'itérables `iterables`. Ta tâche est d'implémenter une fonction `find_first_valid_result` qui applique `func` aux éléments de `iterables` en parallèle, de manière similaire à `map()`, mais avec une étape d... | ["\nassert find_first_valid_result(ValueError, lambda x, y: x / y, [(10, 5), (20, 0), (30, 3)]) == 2.0\n", "\nassert find_first_valid_result(IndexError, lambda x: x[0], [[1, 2], [], [3, 4]]) == 1\n", "\nassert find_first_valid_result(KeyError, lambda d, k: d[k], [({}, 'a'), ({'a': 1}, 'a'), ({'b': 2}, 'b')]) == 1\n", "... |
0374048ff6d976e2f70f52eda3371393 | [
{
"content": "Tu es chargé d'implémenter une fonction `serialize_object` qui convertit un objet Python donné en une chaîne de caractères au format JSON. La fonction doit utiliser la bibliothèque `json` pour la sérialisation. Cependant, elle doit également gérer les objets non sérialisables, en particulier les o... | ["\nassert serialize_object({\"name\": \"Alice\", \"age\": 30}) == '{\"name\": \"Alice\", \"age\": 30}'\n", "\nassert serialize_object([1, 2, 3, 4, 5]) == '[1, 2, 3, 4, 5]'\n", "\nassert serialize_object({\"nested\": {\"key\": \"value\"}}) == '{\"nested\": {\"key\": \"value\"}}'\n", "\nassert serialize_object(datetime(... |
9cf2df35fbd2be8b1da75be65548dc2f | [
{
"content": "On te demande d'implémenter une fonction `log_search_results` qui traite une liste de résultats de recherche et les enregistre dans un fichier avec un nom unique basé sur un horodatage fourni. Chaque résultat de recherche est représenté comme un dictionnaire avec les clés `title`, `url` et `snippe... | ["\nassert log_search_results([], \"2023-10-01_12-00-00\") == \"Success: Search results saved to search_results_2023-10-01_12-00-00.txt.\"\n", "\nassert log_search_results([{'title': 'Test', 'url': 'http://test.com', 'snippet': 'Test snippet'}], \"2023-10-01_12-00-01\") == \"Success: Search results saved to search_resu... |
f63b4659e15b6dec985e6df93e63d918 | [
{
"content": "On te donne une chaîne de caractères `input_str`, un motif d'expression régulière `regex_pattern`, et un modèle de format `format_template`. Ta tâche est de mettre en œuvre une fonction `format_string_with_regex` qui renvoie un tuple `(is_matched, formatted_str)`. La valeur de `is_matched` doit êt... | ["\nassert format_string_with_regex(\"Alice is 30 years old\", r\"(?P<name>\\w+) is (?P<age>\\d+) years old\", \"{name} ({age})\") == (True, 'Alice (30)')\n", "\nassert format_string_with_regex(\"Bob is 25 years old\", r\"(?P<name>\\w+) is (?P<age>\\d+) years old\", \"{name} ({age})\") == (True, 'Bob (25)')\n", "\nasse... |
544958187544696ac942e432843befa2 | [
{
"content": "On te donne une liste de `n` dictionnaires, où chaque dictionnaire représente les résultats d'un étudiant à un examen. Le dictionnaire de chaque étudiant contient une clé `'results'` qui correspond à un autre dictionnaire avec les scores de l'étudiant pour chaque matière. Ta tâche est d'écrire une... | ["\nassert calculate_harmonic_means([{'results': {'math': 85, 'science': 92, 'history': 78}}, {'results': {'math': 88, 'science': 90, 'history': 82}}, {'results': {'math': 92, 'science': 88, 'history': 85}}]) == {'math': 88.33333333333333, 'science': 89.91452991452991, 'history': 81.66666666666667}\n", "\nassert calcul... |
f1f689e2f28502eb927a1895dc67c818 | [
{
"content": "On te demande d'implémenter une fonction `parse_config(config_str)` qui traite une chaîne de configuration `config_str` et renvoie un dictionnaire d'options de configuration. La chaîne de configuration est constituée de paires clé-valeur, où chaque paire est séparée par un caractère de nouvelle li... | ["\nassert parse_config(\"key1:value1\\nkey2:value2\") == {\"key1\": \"value1\", \"key2\": \"value2\"}\n", "\nassert parse_config(\"username:admin\\npassword:secret\") == {\"username\": \"admin\", \"password\": \"secret\"}\n", "\nassert parse_config(\"host:localhost\\nport:8080\") == {\"host\": \"localhost\", \"port\":... |
1b3d5661b2db1117bb879c7a35eaf02e | [
{
"content": "Tu développes un module d'expédition pour une plateforme de commerce électronique. Étant donné le poids d'une commande et si elle est une expédition internationale, détermine le coût d'expédition en fonction des règles suivantes :\n\n- Pour les commandes pesant moins de 5 kg :\n - Les commandes n... | ["\nassert calculate_shipping_cost(3, False) == 5\n", "\nassert calculate_shipping_cost(3, True) == 20\n", "\nassert calculate_shipping_cost(5, False) == 10\n", "\nassert calculate_shipping_cost(5, True) == 30\n", "\nassert calculate_shipping_cost(10, False) == 10\n", "\nassert calculate_shipping_cost(10, True) == 30\n... |
9e63bdf3d2cac48272d88833f2e0f6fd | [
{
"content": "On te donne un dictionnaire `d` où les clés sont des chaînes de caractères uniques et les valeurs sont des entiers. Ta tâche est d'écrire une fonction `key_with_max_value` qui renvoie la clé associée à la valeur maximale dans le dictionnaire. S'il y a plusieurs clés avec la même valeur maximale, r... | ["\nassert key_with_max_value({'a': 100, 'b': 200, 'c': 50}) == 'b'\n", "\nassert key_with_max_value({'x': 10, 'y': 20, 'z': 30}) == 'z'\n", "\nassert key_with_max_value({'apple': 5, 'banana': 10, 'cherry': 10}) == 'banana'\n", "\nassert key_with_max_value({'one': 1, 'two': 2, 'three': 3}) == 'three'\n", "\nassert key_... |
6897b9422d00a1d9ac61695c4ea8b798 | [
{
"content": "On te donne une liste d'entiers. Détermine si la liste est strictement monotone (soit strictement croissante, soit strictement décroissante) et contient tous des éléments uniques. Une liste est strictement croissante si chaque élément est supérieur au précédent, et strictement décroissante si chaq... | ["\nassert is_monotonic([1, 2, 3, 4]) == True\n", "\nassert is_monotonic([4, 3, 2, 1]) == True\n", "\nassert is_monotonic([1, 2, 2, 3]) == False\n", "\nassert is_monotonic([1, 3, 2]) == False\n", "\nassert is_monotonic([]) == True\n", "\nassert is_monotonic([10]) == True\n", "\nassert is_monotonic([5, 4, 3, 2, 1, 0]) =... |
cf890425a66d0938c40de51aa8492961 | [
{
"content": "On te donne une liste d'entiers représentant l'intensité des ondes sonores à différentes fréquences. Ta tâche est d'écrire une fonction `normalize_intensities` qui normalise ces intensités en utilisant une intensité de référence. La fonction doit prendre deux paramètres : une liste d'entiers (`int... | ["\nassert normalize_intensities([10, 20, 5, 15], 10) == [0.5, 1.0, 1.5, 2.0]\n", "\nassert normalize_intensities([100, 50, 25, 75], 25) == [1.0, 2.0, 3.0, 4.0]\n", "\nassert normalize_intensities([1, 2, 3, 4, 5], 1) == [1.0, 2.0, 3.0, 4.0, 5.0]\n", "\nassert normalize_intensities([], 10) == []\n", "\nassert normalize_... |
9990e9259824258655004f714320ee4a | [
{
"content": "On te demande d'implémenter une classe `Book` avec les attributs `title`, `author` et `ISBN`. Ton objectif est de créer une méthode de classe `from_string` qui construit une instance de `Book` à partir d'une chaîne de caractères formatée comme suit : \"Title: The Great Gatsby; Author: F. Scott Fit... | ["\nassert Book.from_string(\"Title:The Great Gatsby; Author:F. Scott Fitzgerald; ISBN:9780743273565\").title == \"TheGreatGatsby\"\n", "\nassert Book.from_string(\"Title: The Great Gatsby; Author: F. Scott Fitzgerald; ISBN: 9780743273565\").author == \"F.ScottFitzgerald\"\n", "\nassert Book.from_string(\"Title: The Gr... |
f9e37554e38b03f9e92d339ddcc3c00a | [
{
"content": "On te demande d'écrire une fonction `get_real_floor(n)` qui calcule le numéro d'étage réel dans un bâtiment en fonction du numéro d'étage indiqué `n`. Aux États-Unis, les bâtiments omettent souvent le 13e étage par superstition. Par conséquent, l'étage indiqué comme 14 est en réalité le 13e étage,... | ["\nassert get_real_floor(1) == 1\n", "\nassert get_real_floor(13) == 12\n", "\nassert get_real_floor(14) == 13\n", "\nassert get_real_floor(15) == 13\n", "\nassert get_real_floor(0) == 0\n", "\nassert get_real_floor(-5) == -5\n", "\nassert get_real_floor(2) == 2\n", "\nassert get_real_floor(12) == 12\n", "\nassert get... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.