id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
4c29fb6fd5a836370b07abc90c9209f8 | [
{
"content": "On te demande d'implémenter une fonction `get_project_url` qui récupère l'URL de la page d'accueil d'un projet logiciel en fonction de son langage de programmation, de son nom et de sa version. La fonction doit gérer trois langages de programmation : Python, JavaScript et Ruby. Pour chaque langage... | ["\nassert get_project_url(\"Python\", \"requests\", \"2.25.1\") == \"https://requests.readthedocs.io\"\n", "\nassert get_project_url(\"JavaScript\", \"lodash\", \"4.17.21\") == \"https://lodash.com/\"\n", "\nassert get_project_url(\"Ruby\", \"rails\", \"6.1.4\") == \"https://rubyonrails.org\"\n", "\nassert get_project... |
f9fc8b744600b900f4fafbe6757e84b2 | [
{
"content": "On te donne un graphe orienté représenté par une liste d'arêtes. Chaque arête est un tuple de deux entiers, où le premier entier est le nœud d'origine et le second entier est le nœud de destination. Ta tâche est de déterminer si un numéro de nœud spécifique apparaît dans le graphe en tant que nœud... | ["\nassert check_node_presence(1, [(1, 2), (3, 4)]) == True\n", "\nassert check_node_presence(5, [(1, 2), (3, 4)]) == False\n", "\nassert check_node_presence(2, [(1, 2), (2, 3)]) == True\n", "\nassert check_node_presence(3, [(1, 2), (2, 3)]) == True\n", "\nassert check_node_presence(4, [(1, 2), (2, 3)]) == False\n", "\... |
bac2a01113c4fa25089798832a2d9487 | [
{
"content": "On te donne un dictionnaire `all_mods` représentant les modifications des acides aminés dans une séquence protéique. Chaque clé dans `all_mods` est un type de modification, et la valeur correspondante est un dictionnaire associant les résidus d'acides aminés à leurs fréquences respectives pour ce ... | ["\nassert assign_modification_symbols({'mod1': {'A': 0.1, 'B': 0.2}, 'mod2': {'A': 0.1, 'B': 0.2}}, {'A': 0.1, 'B': 0.2}) == {'mod1': None, 'mod2': None}\n", "\nassert assign_modification_symbols({'mod1': {'A': 0.1, 'B': 0.2}, 'mod2': {'A': 0.2, 'B': 0.1}}, {'A': 0.1, 'B': 0.2}) == {'mod1': None, 'mod2': '*'}\n", "\na... |
949c4bd6b62e221e9cd99d920083ee32 | [
{
"content": "On te donne une liste d'entiers `nums` et un entier `target`. Ta tâche est de mettre en œuvre une fonction qui renvoie le nombre de fois que `target` apparaît dans `nums`. Si `target` n'est pas présent dans `nums`, la fonction doit renvoyer 0.\n\n**Entrée :**\n- Une liste d'entiers `nums` (1 ≤ len... | ["\nassert count_occurrences([1, 2, 3, 4, 5, 2, 2, 3, 1, 2], 2) == 4\n", "\nassert count_occurrences([1, 1, 1, 1, 1], 1) == 5\n", "\nassert count_occurrences([10, 20, 30, 40, 50], 30) == 1\n", "\nassert count_occurrences([7, 8, 9, 10, 11], 6) == 0\n", "\nassert count_occurrences([], 1) == 0\n", "\nassert count_occurren... |
0266c74633ef4c153b32ce70eceb1e9a | [
{
"content": "On te donne une liste triée d'entiers `nums` et un entier `target`. Ta tâche est de mettre en œuvre une fonction `find_target_range` qui renvoie les indices de début et de fin de la valeur `target` dans la liste. Si la `target` n'est pas présente dans la liste, la fonction doit renvoyer `[-1, -1]`... | ["\nassert find_target_range([5,7,7,8,8,10], 8) == [3, 4]\n", "\nassert find_target_range([1], 1) == [0, 0]\n", "\nassert find_target_range([1], 0) == [-1, -1]\n", "\nassert find_target_range([], 0) == [-1, -1]\n", "\nassert find_target_range([1,2,2,2,3,4,5], 2) == [1, 3]\n", "\nassert find_target_range([1,2,3,4,5,6,7]... |
31219050975b786900e0cb141a985b81 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction récursive `reverse_r` qui renvoie une nouvelle liste avec les éléments dans l'ordre inverse. Tu n'es pas autorisé à utiliser d'itération, de fonctions intégrées ou de découpage pour inverser la liste.\n\n**Entrée :**\n- Une liste ... | ["\nassert reverse_r([1, 2, 3, 4, 5]) == [5, 4, 3, 2, 1]\n", "\nassert reverse_r([10, 20, 30]) == [30, 20, 10]\n", "\nassert reverse_r([1]) == [1]\n", "\nassert reverse_r([]) == []\n", "\nassert reverse_r([7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert reverse_r([1, 1, 1, 1, 1]) == [1, 1, 1, 1, 1]\n", "\n... |
085ac7d01df3933a2b017dae4685fd9a | [
{
"content": "On te demande d'implémenter une fonction Python pour calculer la factorielle d'un entier non négatif donné `n` en utilisant une approche récursive terminale. Cependant, pour optimiser la récursion, tu dois utiliser un décorateur qui convertit la fonction récursive en une fonction itérative. Le déc... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(5) == 120\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(3) == 6\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(15) == 1307674368000\n", "\nassert factorial(20) == 2432902008176640000\n", "\ntry:\n factor... |
d1f335be21aed20c1061d5ebcfd396be | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `remove_duplicates_and_sort` qui traite cette liste et renvoie une nouvelle liste avec les caractéristiques suivantes :\n\n- La nouvelle liste doit contenir uniquement les éléments uniques de la liste originale.\n- L'ordr... | ["\nassert remove_duplicates_and_sort([4, 2, 2, 1, 3, 3, 4]) == [1, 2, 3, 4]\n", "\nassert remove_duplicates_and_sort([10, 9, 8, 7, 6, 5]) == [5, 6, 7, 8, 9, 10]\n", "\nassert remove_duplicates_and_sort([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates_and_sort([]) == []\n", "\nassert remove_duplicates_and_sort([... |
929559b5a040c89efa08a0f069bf0513 | [
{
"content": "On te donne deux chaînes de caractères `s1` et `s2`. Ta tâche est de mettre en œuvre une fonction `find_common_substring(s1: str, s2: str) -> str` qui renvoie la plus longue sous-chaîne commune entre `s1` et `s2`. S'il existe plusieurs sous-chaînes de longueur maximale identique, renvoie celle qui... | ["\nassert find_common_substring(\"abcdef\", \"zabcf\") == \"abc\"\n", "\nassert find_common_substring(\"hello\", \"yellow\") == \"ello\"\n", "\nassert find_common_substring(\"abc\", \"def\") == \"\"\n", "\nassert find_common_substring(\"abcde\", \"abfgh\") == \"ab\"\n", "\nassert find_common_substring(\"abcdef\", \"xy... |
506e7ff9c59087b4788568d772b8766b | [
{
"content": "On te donne un dictionnaire où chaque clé est associée à une liste d'entiers. Ta tâche est d'écrire une fonction `sort_by_value_length` qui trie les éléments du dictionnaire dans une liste de tuples en fonction de la longueur des listes. Si deux listes ont la même longueur, les tuples doivent être... | ["\nassert sort_by_value_length({'a': [1, 2], 'b': [3], 'c': [4, 5, 6]}) == [('b', [3]), ('a', [1, 2]), ('c', [4, 5, 6])]\n", "\nassert sort_by_value_length({'x': [1], 'y': [2, 3], 'z': [4, 5, 6, 7]}) == [('x', [1]), ('y', [2, 3]), ('z', [4, 5, 6, 7])]\n", "\nassert sort_by_value_length({'m': [1, 2, 3], 'n': [4, 5], 'o... |
c0dc636057d173ea65a27878889b62fe | [
{
"content": "On te donne une grille 9x9 où chaque cellule est identifiée de manière unique par un entier `n` dans l'ordre des lignes, allant de 0 à 80. Ta tâche est d'implémenter une fonction `find_subgrid(n)` qui détermine les coordonnées du coin supérieur gauche `(a, b)` de la sous-grille 3x3 contenant la ce... | ["\nassert find_subgrid(0) == (0, 0)\n", "\nassert find_subgrid(8) == (0, 6)\n", "\nassert find_subgrid(9) == (3, 0)\n", "\nassert find_subgrid(23) == (6, 0)\n", "\nassert find_subgrid(47) == (3, 6)\n", "\nassert find_subgrid(80) == (6, 6)\n", "\nassert find_subgrid(81) == (-1, -1)\n", "\nassert find_subgrid(-5) == (-1... |
8dc5657d3a953dc8d0ff74ac5b7de5d7 | [
{
"content": "On te donne une liste non triée d'entiers `nums`. Ta tâche est de trouver la longueur de la plus longue séquence consécutive dans la liste. Une séquence consécutive est définie comme une séquence de nombres où chaque nombre est exactement un de plus que le précédent. Ta solution doit avoir une com... | ["\nassert longest_consecutive_sequence([100, 4, 200, 1, 3, 2]) == 4\n", "\nassert longest_consecutive_sequence([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]) == 9\n", "\nassert longest_consecutive_sequence([]) == 0\n", "\nassert longest_consecutive_sequence([1, 2, 3, 4, 5]) == 5\n", "\nassert longest_consecutive_sequence([10, 5, 12,... |
4bce4fb1f409c2b35d1de72306f9713c | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de déterminer si la liste est un palindrome. Une liste est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche. Implémente la fonction `is_palindrome_list` qui prend une liste d'entiers en entrée et renvoie `True` s... | ["\nassert is_palindrome_list([1, 2, 3, 2, 1]) == True\n", "\nassert is_palindrome_list([1, 2, 3, 4, 5]) == False\n", "\nassert is_palindrome_list([]) == True\n", "\nassert is_palindrome_list([1]) == True\n", "\nassert is_palindrome_list([1, 2, 2, 1]) == True\n", "\nassert is_palindrome_list([1, 2, 3, 3, 2, 1]) == True... |
aadcdb3b8534a2eaed5999c94c6fdecf | [
{
"content": "On te donne une chaîne de caractères `s` composée de parenthèses ouvrantes et fermantes : `{`, `}`, `[`, `]`, `(`, et `)`. Ta tâche est de déterminer si la chaîne est une séquence valide de parenthèses. Une séquence valide signifie que chaque parenthèse ouvrante a une parenthèse fermante correspon... | ["\nassert validate_brackets(\"{[()]}\") == True\n", "\nassert validate_brackets(\"{[(])}\") == False\n", "\nassert validate_brackets(\"()[]{}\") == True\n", "\nassert validate_brackets(\"([{}])\") == True\n", "\nassert validate_brackets(\"(]\") == False\n", "\nassert validate_brackets(\"([)]\") == False\n", "\nassert ... |
89c0244e5e32240717bdadae32682ed3 | [
{
"content": "On te donne un fichier CSV contenant des données sur des individus. Ta tâche est d'écrire une fonction Python qui lit ce fichier CSV et renvoie un DataFrame en excluant toutes les lignes où une colonne spécifiée a une valeur manquante ou vide. La fonction doit gérer à la fois les valeurs `NaN` et ... | ["\nassert filter_rows_with_empty_column('test1.csv', 'Name').equals(pd.DataFrame({'Name': ['Alice', 'Bob'], 'Age': [25, 30]}))\n", "\nassert filter_rows_with_empty_column('test2.csv', 'Email').equals(pd.DataFrame({'Name': ['Charlie'], 'Email': ['charlie@example.com']}))\n", "\nassert filter_rows_with_empty_column('tes... |
31a92860dbda1d071f29fe8022b58e88 | [
{
"content": "On te donne une liste d'éléments, qui peut inclure des listes imbriquées. Certains éléments sont des chaînes de caractères vides. Ta tâche est de remplir ces chaînes vides avec la chaîne non vide la plus proche à leur gauche, mais uniquement au sein du même niveau d'imbrication. Si une liste imbri... | ["\nassert fill_gaps(['A', '', '', 'B', '', 'C', '', '', 'D']) == ['A', 'A', 'A', 'B', 'B', 'C', 'C', 'C', 'D']\n", "\nassert fill_gaps(['', '', 'A', '', '', 'B', '', '', '']) == ['', '', 'A', 'A', 'A', 'B', 'B', 'B', 'B']\n", "\nassert fill_gaps(['A', '', '', '', '', '', '', '', 'B']) == ['A', 'A', 'A', 'A', 'A', 'A',... |
0aa610cc3778a085eeb914e7fc78910b | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui simule des opérations bancaires basiques. La classe doit supporter les fonctionnalités suivantes :\n\n- **Dépôt** : Ajouter un montant spécifié au solde du compte. Le montant doit être positif.\n- **Retrait** : Soustraire un montan... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount(50).deposit(50) or BankAccount(50).get_balance() == 100\n", "\nassert BankAccount(100).withdraw(50) or BankAccount(100).get_balance() == 50\n", "\nassert BankAccount(100).transfer(BankAccount(), 50)... |
e5e1988cb949f6c6437bfae2d62ec8fa | [
{
"content": "On te demande de créer une fonction Python `generate_report` qui formate et affiche un rapport à partir d'une liste de dictionnaires de projets. Chaque dictionnaire contient les clés suivantes : 'Project_Name', 'Project_Manager', 'Start_Date', 'End_Date' et 'Budget'. Le rapport doit être formaté s... | ["\nassert generate_report([]) == None\n", "\nassert generate_report([{'Project_Name': 'Test Project', 'Project_Manager': 'John', 'Start_Date': '2023-01-01', 'End_Date': '2023-01-31', 'Budget': 10000}]) == None\n", "\nassert generate_report([{'Project_Name': 'Short', 'Project_Manager': 'Doe', 'Start_Date': '2023-01-01'... |
334255f914e3fdef6f39bc09e527cf08 | [
{
"content": "On te demande d'implémenter une fonction de rétropropagation pour une fonction d'activation tangente hyperbolique scalaire utilisée dans les réseaux de neurones. La fonction doit calculer la dérivée de la perte par rapport à l'entrée `x` étant donné l'entrée `x`, la sortie `out` de la fonction tan... | ["\nassert tanh_backprop(0, np.tanh(0), 1) == 1\n", "\nassert tanh_backprop(1, np.tanh(1), 1) == 1 - np.tanh(1)**2\n", "\nassert tanh_backprop(-1, np.tanh(-1), 1) == 1 - np.tanh(-1)**2\n", "\nassert tanh_backprop(10, np.tanh(10), 1) == 1 - np.tanh(10)**2\n", "\nassert tanh_backprop(-10, np.tanh(-10), 1) == 1 - np.tanh(... |
a951d62f636bd96422344903c9f0a0e5 | [
{
"content": "Tu es chargé de mettre en œuvre un système de classification de texte en utilisant un classificateur naïf de Bayes. Ton système doit catégoriser le texte d'entrée dans l'une des trois catégories suivantes : 'positive', 'negative' ou 'neutral'. Un petit ensemble de données te sera fourni pour entra... | ["\nassert classify_text(\"I love this product\") == \"positive\"\n", "\nassert classify_text(\"This is the worst thing I've ever bought\") == \"negative\"\n", "\nassert classify_text(\"It's okay, not great but not bad\") == \"neutral\"\n", "\nassert classify_text(\"Absolutely fantastic!\") == \"positive\"\n", "\nasser... |
108804e3284479d9bf29885a8492cb99 | [
{
"content": "On te donne un réseau de `N` ordinateurs connectés par `M` liens bidirectionnels, chacun ayant une bande passante spécifique. Chaque ordinateur est représenté par un nœud dans le graphe, et chaque lien est représenté par une arête avec un poids correspondant à la bande passante du lien. Ta tâche e... | ["\nassert max_bandwidth_path(graph, 'A', 'D') == (5, ['A', 'C', 'D'])\n", "\nassert max_bandwidth_path(graph, 'A', 'B') == (100, ['A', 'B'])\n", "\nassert max_bandwidth_path(graph, 'B', 'D') == (50, ['B', 'D'])\n", "\nassert max_bandwidth_path(graph, 'C', 'D') == (5, ['C', 'D'])\n", "\nassert max_bandwidth_path(graph,... |
72b92370fe2e2cfb2203b775062db005 | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est d'écrire une fonction qui construit un nouveau tableau où chaque élément à l'index `i` est le produit de tous les nombres premiers du tableau original, à l'exception de celui à l'index `i`. Si le tableau contient moins de deux nombres premiers, la fon... | ["\nassert product_of_primes_except_self([2, 3, 5, 7, 10]) == [105, 70, 42, 30, 105]\n", "\nassert product_of_primes_except_self([11, 13, 17]) == [221, 187, 143]\n", "\nassert product_of_primes_except_self([2, 3, 5]) == [15, 10, 6]\n", "\nassert product_of_primes_except_self([4, 6, 8, 10]) == None\n", "\nassert product... |
dd417bd9e57cdc6ac03656e578f816c7 | [
{
"content": "Tu es chargé de générer un labyrinthe aléatoire de taille `n x n` en utilisant l'algorithme de recherche en profondeur (DFS). Le labyrinthe doit être représenté comme une liste 2D où `0` indique un chemin et `1` indique un mur. L'entrée du labyrinthe est située dans le coin supérieur gauche `(0, 0... | ["\nassert generate_maze(1) == [[0]]\n", "\nassert generate_maze(2) == [[0, 0], [0, 0]]\n", "\nassert generate_maze(3)[0][0] == 0 and generate_maze(3)[2][2] == 0\n", "\nassert generate_maze(4)[0][0] == 0 and generate_maze(4)[3][3] == 0\n", "\nassert generate_maze(5)[0][0] == 0 and generate_maze(5)[4][4] == 0\n", "\nass... |
5f14dbd38a945920993fd53516532153 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `calculate_statistics` qui calcule et renvoie un dictionnaire contenant les valeurs minimale, maximale, moyenne et médiane de la liste. Si la liste est vide, la fonction doit lever une exception `ValueError` avec le messa... | ["\nassert calculate_statistics([1, 2, 3, 4, 5]) == {'minimum': 1, 'maximum': 5, 'average': 3.0, 'median': 3}\n", "\nassert calculate_statistics([10, 20, 30]) == {'minimum': 10, 'maximum': 30, 'average': 20.0, 'median': 20}\n", "\nassert calculate_statistics([5]) == {'minimum': 5, 'maximum': 5, 'average': 5.0, 'median'... |
c76ab405b261ca806f48a8ef9220b46f | [
{
"content": "Implémente une classe Python nommée `Vehicle` avec les spécifications suivantes :\n\n- **Attributs :**\n - `make` : une chaîne de caractères représentant le fabricant du véhicule.\n - `model` : une chaîne de caractères représentant le modèle du véhicule.\n - `year` : un entier représentant l'an... | ["\nassert Vehicle(\"Toyota\", \"Corolla\", 2020).get_info() == \"Make: Toyota, Model: Corolla, Year: 2020\"\n", "\nassert Vehicle(\"Honda\", \"Civic\", 2018).get_info() == \"Make: Honda, Model: Civic, Year: 2018\"\n", "\nassert Vehicle(\"Ford\", \"Mustang\", 2022).get_info() == \"Make: Ford, Model: Mustang, Year: 2022... |
ae4633365f1a78fd96097ea09302eeb5 | [
{
"content": "Tu es chargé d'implémenter une fonction qui génère une table de multiplication pour un entier donné `n`. La fonction doit renvoyer la table de multiplication sous forme de liste de listes, où chaque liste interne représente une ligne du tableau. Par exemple, si `n = 5`, la sortie doit être :\n\n``... | ["\nassert generate_multiplication_table(1) == [[1]]\n", "\nassert generate_multiplication_table(2) == [[1, 2], [2, 4]]\n", "\nassert generate_multiplication_table(3) == [[1, 2, 3], [2, 4, 6], [3, 6, 9]]\n", "\nassert generate_multiplication_table(4) == [[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]\n", "\... |
be0e118986265deac0d7ad111c7f5ec6 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction `sum_primes` qui renvoie la somme de tous les nombres premiers de la liste. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même.\n\n**Entrée :**\n- Une liste d'entie... | ["\nassert sum_primes([2, 3, 5, 7, 11]) == 28\n", "\nassert sum_primes([4, 6, 8, 9, 10]) == 0\n", "\nassert sum_primes([1, 2, 3, 4, 5]) == 10\n", "\nassert sum_primes([13, 17, 19, 23, 29]) == 91\n", "\nassert sum_primes([0, 1, 4, 6, 8]) == 0\n", "\nassert sum_primes([31, 37, 41, 43, 47]) == 193\n", "\nassert sum_primes... |
6333bc8462e876b6134eeda1a8fc67a2 | [
{
"content": "On te donne un dictionnaire où chaque clé est associée à une valeur entière unique. Ta tâche est de créer une fonction `invert_and_sort_dict` qui inverse le dictionnaire (c'est-à-dire qu'elle échange les clés et les valeurs) et renvoie une liste de tuples. Chaque tuple doit consister en une valeur... | ["\nassert invert_and_sort_dict({}) == []\n", "\nassert invert_and_sort_dict({'a': 1}) == [(1, 'a')]\n", "\nassert invert_and_sort_dict({'b': 2, 'a': 1}) == [(1, 'a'), (2, 'b')]\n", "\nassert invert_and_sort_dict({'c': 3, 'b': 2, 'a': 1}) == [(1, 'a'), (2, 'b'), (3, 'c')]\n", "\nassert invert_and_sort_dict({'x': 10, 'y... |
8ef4794f60b8e8457a98d25a2e3eb34a | [
{
"content": "On te donne deux tableaux, `real_parts` et `imaginary_parts`, chacun de longueur `n`, représentant les parties réelles et imaginaires de `n` nombres complexes, respectivement. Ta tâche est de mettre en œuvre une fonction `complex_to_cartesian` qui traite ces tableaux et renvoie un nouveau tableau ... | ["\nassert np.array_equal(complex_to_cartesian([1], [1]), np.array([[0.71, 1.21]]))\n", "\nassert np.array_equal(complex_to_cartesian([0], [1]), np.array([[-0.71, 0.71]]))\n", "\nassert np.array_equal(complex_to_cartesian([1], [0]), np.array([[0.71, 0.71]]))\n", "\nassert np.array_equal(complex_to_cartesian([-1], [-1])... |
ea93721fb6f3660dc23cdc8a50081ff8 | [
{
"content": "On te demande de créer un décorateur Python nommé `log_execution_time` qui mesure et enregistre le temps d'exécution de toute fonction qu'il décore. Le décorateur doit afficher le nom de la fonction et son temps d'exécution en millisecondes. Ton implémentation doit être efficace et gérer toute fon... | ["\nassert log_execution_time(lambda: None) is not None\n", "\nassert log_execution_time(lambda: None)() is None\n", "\nassert log_execution_time(lambda x: x)(42) == 42\n", "\nassert log_execution_time(lambda x, y: x + y)(10, 20) == 30\n", "\nassert log_execution_time(lambda x, y, z: x * y * z)(2, 3, 4) == 24\n", "\nas... |
62db2c38f78202ed359328f9b67ff26a | [
{
"content": "Tu participes à un défi de sécurité où tu dois vérifier l'intégrité de plusieurs fichiers. Ta tâche est d'écrire un programme qui accepte une liste de chemins de fichiers et leurs valeurs de hachage attendues correspondantes. Le programme doit vérifier simultanément chaque paire fichier-hachage et... | ["\nassert compute_file_hash('test_file.txt', 'sha256') == 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'\n", "\nassert compute_file_hash('non_existent_file.txt', 'sha256') == 'File not found: non_existent_file.txt'\n", "\nassert check_file_integrity('test_file.txt', 'e3b0c44298fc1c149afbf4c8996fb92... |
ade35e57b110724f60ff55b0d87557a8 | [
{
"content": "On te donne pour tâche d'implémenter une fonction `is_feature_x_enabled` qui détermine si une fonctionnalité spécifique, \"Feature X\", est activée sur une page web. La fonction doit prendre deux paramètres : `title` (une chaîne de caractères représentant le titre de la page web) et `site` (un obj... | ["\nassert is_feature_x_enabled(\"Hello World\", Site()) == None\n", "\nassert is_feature_x_enabled(\"Even Vowels\", Site()) == None\n", "\nassert is_feature_x_enabled(\"Aeiou\", Site()) == None\n", "\nassert is_feature_x_enabled(\"Beautiful Day\", Site()) == None\n", "\nassert is_feature_x_enabled(\"Ice Cream\", Site(... |
c9ac6f795185ae3c1fd87153c4aa78f3 | [
{
"content": "On te donne une chaîne de caractères qui peut contenir des balises HTML. Ton objectif est d'écrire une fonction Python qui supprime toutes les balises HTML de la chaîne et renvoie la chaîne nettoyée. Utilise des expressions régulières pour y parvenir. Ta fonction doit gérer toutes les balises HTML... | ["\nassert remove_html_tags(\"<p>This is a <strong>bold</strong> paragraph.</p>\") == \"This is a bold paragraph.\"\n", "\nassert remove_html_tags(\"<div><span>Text</span></div>\") == \"Text\"\n", "\nassert remove_html_tags(\"<a href='#'>Link</a>\") == \"Link\"\n", "\nassert remove_html_tags(\"<img src='image.jpg' alt=... |
dc7463ae30505d049fd6f4ccb7fa5c27 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction qui renvoie une nouvelle liste contenant les éléments de `list1` qui ne sont pas présents dans `list2`. L'ordre des éléments dans la liste résultante doit être le même que leur ordre dans `list1`. L... | ["\nassert list_difference([1, 2, 3, 4, 5], [3, 4]) == [1, 2, 5]\n", "\nassert list_difference([10, 20, 30, 40, 50], [10, 30, 50]) == [20, 40]\n", "\nassert list_difference([1, 1, 2, 2, 3, 3], [1, 2]) == [3, 3]\n", "\nassert list_difference([], [1, 2, 3]) == []\n", "\nassert list_difference([1, 2, 3], []) == [1, 2, 3]\... |
3c64e057038df48470e0cae2ed087431 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'identifier l'entier qui apparaît un nombre impair de fois dans la liste. S'il y a plusieurs entiers avec des occurrences impaires, retourne le plus petit. Par exemple, étant donné la liste `[1, 2, 3, 2, 3, 1, 3]`, la fonction doit retourner `3`.\n\n*... | ["\nassert find_odd_occurrence([1, 2, 3, 2, 3, 1, 3]) == 3\n", "\nassert find_odd_occurrence([4, 4, 7, 7, 7]) == 7\n", "\nassert find_odd_occurrence([10, 10, 10]) == 10\n", "\nassert find_odd_occurrence([1, 1, 2, 2, 3, 3, 4]) == 4\n", "\nassert find_odd_occurrence([5, 7, 5, 7, 5]) == 5\n", "\nassert find_odd_occurrence... |
e6d8513d7905b7f3ba17b8e97d8465b6 | [
{
"content": "On te donne un graphe orienté représenté par une matrice d'adjacence `adj_matrix` de taille `N x N`. Ta tâche est d'écrire une fonction `symmetrize_matrix` qui symétrise cette matrice. La symétrisation consiste à ajouter la transposée de la matrice à elle-même. Si le paramètre `clip_to_one` est dé... | ["\nassert symmetrize_matrix([[0, 1, 0], [0, 0, 1], [1, 0, 0]]) == [[0, 1, 1], [1, 0, 1], [1, 1, 0]]\n", "\nassert symmetrize_matrix([[0, 1, 0], [0, 0, 1], [1, 0, 0]], clip_to_one=True) == [[0, 1, 1], [1, 0, 1], [1, 1, 0]]\n", "\nassert symmetrize_matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == [[1, 0, 0], [0, 1, 0], [0, ... |
3ecbd04455c6adec966a55be77884af5 | [
{
"content": "Tu dois implémenter une classe `Queue` en Python qui supporte les opérations suivantes :\n\n- `enqueue(item)` : Ajoute un élément à la fin de la file d'attente.\n- `dequeue()` : Supprime et retourne l'élément au début de la file d'attente. Si la file d'attente est vide, retourne `None`.\n- `peek()... | ["\nassert Queue().is_empty() == True\n", "\nassert Queue().peek() == None\n", "\nassert Queue().dequeue() == None\n", "\nq = Queue()\nq.enqueue(1)\nassert q.is_empty() == False\n", "\nq = Queue()\nq.enqueue(1)\nassert q.peek() == 1\n", "\nq = Queue()\nq.enqueue(1)\nassert q.dequeue() == 1\n", "\nq = Queue()\nq.enqueue... |
09bca0106b169dd3453187f8a2a15ba4 | [
{
"content": "Tu es chargé de développer un outil d'analyse des sentiments pour un ensemble de données de critiques de films. Implémente une fonction `analyze_sentiment` qui traite une liste de critiques de films et renvoie une liste de scores de sentiments. Chaque score doit être un nombre à virgule flottante ... | ["\nassert analyze_sentiment([\"Great movie!\"]) == [1.0]\n", "\nassert analyze_sentiment([\"Terrible movie!\"]) == [0.0]\n", "\nassert analyze_sentiment([\"Average movie.\"]) == [0.5]\n", "\nassert analyze_sentiment([\"\", \"\"]) == [0.5, 0.5]\n", "\nassert analyze_sentiment([\"I loved it!\", \"I hated it.\"]) == [1.0... |
19839842643570108cf6a989da6a65fa | [
{
"content": "On te donne une liste de chaînes de caractères `S` et une liste de sous-chaînes `T`. Ta tâche est d'implémenter une fonction qui renvoie une nouvelle liste contenant uniquement les chaînes de caractères de `S` qui incluent toutes les sous-chaînes de `T`. L'ordre des chaînes de caractères dans la l... | ["\nassert filter_strings_by_substrings([\"hello world\", \"world\", \"hello\"], [\"hello\"]) == [\"hello world\", \"hello\"]\n", "\nassert filter_strings_by_substrings([\"apple\", \"banana\", \"grape\"], [\"ap\"]) == [\"apple\", \"grape\"]\n", "\nassert filter_strings_by_substrings([\"test\", \"testing\", \"tested\"],... |
18e522e0592cc168162af8f7f033d49b | [
{
"content": "Tu participes à un concours de programmation où tu dois interagir avec l'API GitHub. Ta tâche est d'implémenter une fonction `is_repo_private` qui vérifie si un utilisateur GitHub donné possède un dépôt spécifique et détermine s'il est privé. La fonction doit gérer la limitation de débit de manièr... | ["\nassert is_repo_private('octocat', 'Hello-World') == False\n", "\nassert is_repo_private('octocat', 'nonexistent-repo') == False # This will raise RuntimeError, so this test is incorrect\n", "\nassert is_repo_private('torvalds', 'linux') == False\n", "\nassert is_repo_private('torvalds', 'nonexistent-repo') == Fals... |
90c3f5b7c9e21b6bef2ca4e01b029952 | [
{
"content": "On te donne une chaîne de caractères `sentence` qui peut contenir des lettres majuscules et minuscules, des chiffres et des caractères spéciaux. Ta tâche est de mettre en œuvre une fonction `word_analysis` qui traite cette chaîne et renvoie un dictionnaire avec les clés suivantes :\n- `'vowels'`: ... | ["\nassert word_analysis(\"Hello World\") == {'vowels': 3, 'consonants': 7, 'words': 2, 'palindromes': 0}\n", "\nassert word_analysis(\"Madam Arora teaches malayalam\") == {'vowels': 11, 'consonants': 13, 'words': 5, 'palindromes': 3}\n", "\nassert word_analysis(\"A Santa at NASA\") == {'vowels': 8, 'consonants': 8, 'w... |
312ab8eb02778568f86287f86903947e | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ta tâche est de trouver toutes les combinaisons uniques de nombres de la liste qui s'additionnent pour atteindre la cible. Chaque nombre de la liste peut être utilisé plusieurs fois dans la combinaison. Retourne une liste de tuples, ... | ["\nassert find_combinations([2, 3, 6, 7], 7) == [(2, 2, 3), (7,)]\n", "\nassert find_combinations([2, 3, 5], 8) == [(2, 2, 2, 2), (2, 3, 3), (3, 5)]\n", "\nassert find_combinations([1, 2, 3], 6) == [(1, 1, 1, 1, 1, 1), (1, 1, 1, 1, 2), (1, 1, 2, 2), (1, 1, 1, 3), (1, 2, 3), (2, 2, 2), (3, 3)]\n", "\nassert find_combin... |
aba639165aaa4d9c16c216f6e952c990 | [
{
"content": "On te donne une chaîne de caractères `s` et une liste de listes d'indices `indices`. Chaque sous-liste dans `indices` contient quatre entiers : `[start_index, end_index, start_position, end_position]`. Ta tâche est d'extraire des sous-chaînes de `s` en utilisant ces indices. `start_index` et `end_... | ["\nassert extract_substring(\"hello world\", [[0, 4, 0, 10]]) == [\"hello\"]\n", "\nassert extract_substring(\"hello world\", [[5, 10, 0, 10]]) == [\"world\"]\n", "\nassert extract_substring(\"hello world\", [[0, 10, 0, 10]]) == [\"hello world\"]\n", "\nassert extract_substring(\"hello world\", [[-1, 4, 0, 10]]) == [\... |
30f6618edcae38b9076becd3678e907c | [
{
"content": "On te donne deux listes d'entiers, `gold_list` et `predicted_list`. Ta tâche est de calculer le score de rappel pour `predicted_list` par rapport à `gold_list`. Le score de rappel est défini comme le rapport du nombre d'éléments correctement prédits (vrais positifs) au nombre total d'éléments dans... | ["\nassert recall_score([1, 2, 2, 3, 4], [1, 3, 4, 4]) == 1.0\n", "\nassert recall_score([1, 1, 2, 3, 3, 4], [2, 4]) == 1.0\n", "\nassert recall_score([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]) == 1.0\n", "\nassert recall_score([1, 1, 2, 2, 3, 3], [1, 2, 3]) == 0.0\n", "\nassert recall_score([1, 2, 3, 4, 5], [6, 7, 8]) == 0.0\n... |
04189a660cbc6c1a7b79dc15cf4e595c | [
{
"content": "Tu développes un chargeur de configuration pour une application logicielle. La configuration est stockée dans un fichier JSON qui peut se trouver dans le même répertoire que ton script ou dans un package. Ta tâche est de mettre en œuvre une fonction `load_config` qui lit ce fichier JSON et renvoie... | ["\nassert load_config(\"simple_config.json\") == {\"key\": \"value\"}\n", "\nassert load_config(\"nested_config.json\") == {\"outer\": {\"inner\": \"value\"}}\n", "\nassert load_config(\"array_config.json\") == {\"items\": [1, 2, 3]}\n", "\nassert load_config(\"complex_config.json\") == {\"key1\": \"value1\", \"key2\"... |
a27cbd90024d5d27c926974abb523d07 | [
{
"content": "On te donne un entier `n`. Ta tâche est de déterminer si `n` est un nombre premier. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même. Pour optimiser ta solution, implémente la règle des 6k ± 1, qui stipule que tous les nombres premier... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(9) == False\n", "\nassert is_prime(11) == True\n", "\nassert is_prime(15) == False\n", "\nassert is_prime(17) == True\n", "\nassert is_prime(19) == True\n", "\nass... |
ef169ddf859a3979b16dbd6307552f41 | [
{
"content": "On te demande d'implémenter une fonction `truncate_book_title` qui traite les titres de livres à des fins d'affichage. Étant donné un titre de livre sous forme de chaîne de caractères `title` et un entier `limit`, ta fonction doit renvoyer une version tronquée du titre si sa longueur dépasse `limi... | ["\nassert truncate_book_title(\"The Great Gatsby\", 15) == \"The Great ...\"\n", "\nassert truncate_book_title(\"War and Peace\", 10) == \"War and ...\"\n", "\nassert truncate_book_title(\"To Kill a Mockingbird\", 20) == \"To Kill a Mocking...\"\n", "\nassert truncate_book_title(\"1984\", 5) == \"1984\"\n", "\nassert ... |
3d574a07609aa58d85fb3337a46eb553 | [
{
"content": "On te donne une liste de `n` entiers non négatifs où chaque entier représente la hauteur d'un bâtiment à cet indice. Après une tempête, de l'eau s'accumule entre les bâtiments. Ta tâche est de calculer le volume total d'eau qui peut s'accumuler.\n\n**Entrée :**\n- Une liste d'entiers `heights` où ... | ["\nassert trap([0,1,0,2,1,0,1,3,2,1,2,1]) == 6\n", "\nassert trap([4,2,0,3,2,5]) == 9\n", "\nassert trap([0,0,0,0,0]) == 0\n", "\nassert trap([1,2,3,4,5]) == 0\n", "\nassert trap([5,4,3,2,1]) == 0\n", "\nassert trap([2,0,2]) == 2\n", "\nassert trap([3,0,1,3,0,5]) == 8\n", "\nassert trap([1,0,2,1,0,1,3]) == 4\n", "\nas... |
77f49f58d087cbf3541a6a040d5576aa | [
{
"content": "On te demande d'implémenter une fonction `translate_network_configurations` qui traite un dictionnaire imbriqué représentant des configurations réseau. La fonction doit traduire les clés dans le dictionnaire `input_config` selon les correspondances fournies dans le dictionnaire `translated_config`... | ["\nassert translate_network_configurations({}, {}) == {}\n", "\nassert translate_network_configurations({'hostname': 'server1'}, {'hostname': 'name'}) == {'name': 'server1'}\n", "\nassert translate_network_configurations({'networks': [{'ip': '192.168.1.1'}]}, {'ip': 'address'}) == {'networks': [{'address': '192.168.1.... |
834b95b717eab2490970f85fadeb92ee | [
{
"content": "On te donne un rectangle défini par les coordonnées de ses coins supérieur gauche et inférieur droit. Les coordonnées sont fournies sous forme de liste de quatre entiers `[x1, y1, x2, y2]`, où `(x1, y1)` est le coin supérieur gauche et `(x2, y2)` est le coin inférieur droit. Ta tâche est de calcul... | ["\nassert calculate_rectangle_properties([0, 0, 3, 3]) == (4, 4, (2, 2))\n", "\nassert calculate_rectangle_properties([1, 1, 4, 4]) == (4, 4, (2, 2))\n", "\nassert calculate_rectangle_properties([0, 0, 0, 0]) == (1, 1, (0, 0))\n", "\nassert calculate_rectangle_properties([1, 1, 1, 1]) == (1, 1, (1, 1))\n", "\nassert c... |
10d33aa9cb54d1b0b866e2b84f10b65f | [
{
"content": "Tu développes un système de comptes bancaires concurrents où chaque compte a un dépôt initial et un pourcentage de limite de découvert. La limite de découvert spécifie le montant maximal dont le solde du compte peut être négatif, par rapport au dépôt initial. Implémente la classe `BankAccount` ave... | ["\nassert BankAccount(100, 10).overdraft_limit == 110\n", "\nassert BankAccount(200, 5).overdraft_limit == 210\n", "\nassert BankAccount(0, 20).overdraft_limit == 0\n", "\nassert BankAccount(50, 0).overdraft_limit == 50\n", "\nassert BankAccount(100, 100).overdraft_limit == 200\n", "\naccount = BankAccount(100, 10); a... |
cfbdc596fa0ffbec8f9c5edf0e035247 | [
{
"content": "On te donne un ensemble de données représentant les conditions météorologiques d'une ville sur plusieurs jours. L'ensemble de données est fourni sous la forme d'un DataFrame pandas nommé `weather_data` avec les colonnes suivantes : `Time`, `Temperature`, `Humidity` et `Pressure`. La colonne `Time`... | ["\nassert hourly_weather_averages(pd.DataFrame({\n 'Time': ['2023-01-01 12:00:00', '2023-01-01 12:30:00', '2023-01-01 13:00:00'],\n 'Temperature': [20, 22, 21],\n 'Humidity': [35, 40, 25],\n 'Pressure': [1010, 1012, 1008]\n})).equals(pd.DataFrame({\n 'Temperature': [21.0],\n 'Humidity': [35.0],\n ... |
598304c5e7da53cf5c73f555e4a26fdd | [
{
"content": "On te demande d'implémenter une fonction pour déterminer si un entier donné est un nombre premier. Un nombre premier est défini comme un nombre supérieur à 1 qui n'a pas de diviseurs autres que 1 et lui-même. Ta fonction doit être optimisée pour la performance, capable de gérer efficacement de gra... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(9) == False\n", "\nassert is_prime(11) == True\n", "\nassert is_prime(15) == False\n", "\nassert is_prime(17) == True\n", "\nassert is_prime(1) == False\n", "\nass... |
c85febb2285f0e0d0b2d312691934195 | [
{
"content": "Dans le pays fictif de CodeLand, chaque citoyen se voit attribuer un identifiant unique de 13 chiffres connu sous le nom de CodeNumber. La structure d'un CodeNumber est la suivante :\n\n- Le premier chiffre (S) indique le siècle de naissance.\n- Les deux chiffres suivants (AA) indiquent l'année de... | ["\nassert generate_code_number(2, 23, 5, 12, 1, 456) == \"22300512014563\"\n", "\nassert generate_code_number(1, 99, 31, 99, 99, 999) == \"19903199999995\"\n", "\nassert generate_code_number(2, 0, 1, 1, 1, 1) == \"20000101010017\"\n", "\nassert generate_code_number(2, 10, 10, 10, 10, 10) == \"21001001010109\"\n", "\na... |
47a7313efee9bc9afb9a3ef4d7b4c347 | [
{
"content": "On te donne un fichier CSV nommé `input.csv` contenant des lignes de données textuelles. Ta tâche est d'écrire un programme Python qui lit ce fichier, convertit tout le texte de chaque ligne en majuscules, et écrit les données traitées dans un nouveau fichier CSV nommé `output.csv`. Le programme d... | ["\nassert process_csv('test_input_1.csv', 'test_output_1.csv') is None\n", "\nassert process_csv('test_input_2.csv', 'test_output_2.csv') is None\n", "\nassert process_csv('test_input_3.csv', 'test_output_3.csv') is None\n", "\nassert process_csv('test_input_4.csv', 'test_output_4.csv') is None\n", "\nassert process_c... |
464d50de7c40cada90c656cf9f5fb544 | [
{
"content": "Tu participes à une compétition de science des données et tu dois prétraiter un ensemble de données avant de l'introduire dans un modèle d'apprentissage automatique. L'ensemble de données est composé de caractéristiques numériques avec quelques valeurs manquantes. Ta tâche est de mettre en œuvre u... | ["\nassert preprocess_data(pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})).equals(pd.DataFrame(StandardScaler().fit_transform(pd.DataFrame({'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8]})), columns=['A', 'B']))\n", "\nassert preprocess_data(pd.DataFrame({'X': [10, 20, 30], 'Y': [40, 50, 60]})).equals(pd.DataFrame(St... |
21ceef0db20a40c6ea8e731a72ce7c4b | [
{
"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 : le premier terme est 0, le deuxième terme est 1, et chaque terme suivant est la somme des deux termes précédents. Ta fonction doit renvoyer une liste ... | ["\nassert fibonacci_sequence(1) == [0]\n", "\nassert fibonacci_sequence(2) == [0, 1]\n", "\nassert fibonacci_sequence(3) == [0, 1, 1]\n", "\nassert fibonacci_sequence(4) == [0, 1, 1, 2]\n", "\nassert fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci_sequence(6) == [0, 1, 1, 2, 3, 5]\n", "\nassert fibona... |
a04c990fe9da68f053fdb1d4253b7a13 | [
{
"content": "Dans un système de gestion universitaire, tu dois implémenter une fonction `enrollment_factory` qui crée un enregistrement de l'inscription d'un étudiant à un cours. La fonction doit accepter deux paramètres : `student_id` (un entier représentant l'identifiant unique de l'étudiant) et `course_id` ... | ["\nassert enrollment_factory(1, 'CS101')['student_id'] == 1\n", "\nassert enrollment_factory(1, 'CS101')['course_id'] == 'CS101'\n", "\nassert isinstance(enrollment_factory(1, 'CS101')['timestamp'], str)\n", "\nassert len(enrollment_factory(1, 'CS101')['timestamp'].split()) == 2\n", "\nassert len(enrollment_factory(1,... |
b38781fe0600e2aaeacea57094eca22b | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche consiste à écrire une fonction qui catégorise chaque caractère de la chaîne comme une lettre, un chiffre ou un caractère spécial, et qui renvoie un dictionnaire contenant les décomptes de chaque catégorie. Une lettre est définie comme tout caractè... | ["\nassert categorize_characters(\"Hello World! 123\") == {'letters': 10, 'digits': 3, 'special_characters': 4}\n", "\nassert categorize_characters(\"1234567890\") == {'letters': 0, 'digits': 10, 'special_characters': 0}\n", "\nassert categorize_characters(\"abcdef\") == {'letters': 6, 'digits': 0, 'special_characters'... |
48a4d989fefd983ae3f7a05762634a34 | [
{
"content": "On te donne une chaîne de caractères `time_str` représentant une durée au format \"HH:MM:SS\", où HH, MM et SS sont des entiers compris entre 0 et 99. Ta tâche est d'écrire une fonction `timeStringToSeconds` qui calcule et renvoie le nombre total de secondes représenté par cette durée.\n\n**Entrée... | ["\nassert timeStringToSeconds(\"00:00:00\") == 0\n", "\nassert timeStringToSeconds(\"01:00:00\") == 3600\n", "\nassert timeStringToSeconds(\"00:01:00\") == 60\n", "\nassert timeStringToSeconds(\"00:00:01\") == 1\n", "\nassert timeStringToSeconds(\"99:99:99\") == 359999\n", "\nassert timeStringToSeconds(\"10:20:30\") =... |
c59b1231265fb5b6e7e2f29c8a3c49ee | [
{
"content": "On te donne une séquence d'entiers. Ta tâche est de déterminer la longueur de la plus longue sous-séquence croissante dans cette séquence. Une sous-séquence croissante est définie comme une sous-séquence où chaque élément est strictement supérieur au précédent. Implémente une fonction `longest_inc... | ["\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == 4\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == 4\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7, 7, 7]) == 1\n", "\nassert longest_increasing_subsequence([1, 2, 3, 4, 5]) == 5\n", "\nassert longest_increasing_... |
1d17a29d582e4b5d0eec513cfdb719aa | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les fonctionnalités suivantes :\n\n- **Initialisation** : Un constructeur `__init__` qui prend trois paramètres : `title` (une chaîne de caractères), `author` (une chaîne de caractères) et `year_published` (un entier). C... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_age(2023) == 74\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).get_age(2023) == 63\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925).get_age(2023) == 98\n", "\nassert Book(\"Pride and Prejudice\", \"Jane Austen\", 1813).ge... |
98e932c4998de9bbf0073c16339d467f | [
{
"content": "On te demande d'implémenter un système de compte bancaire basique en Python. Ton système doit prendre en charge les opérations suivantes :\n\n1. **deposit(amount)** : Ajoute le montant spécifié au solde du compte. Renvoie `True` si l'opération réussit, sinon `False`.\n2. **withdraw(amount)** : Sou... | ["\nassert BankAccount().check_balance() == 0\n", "\nassert BankAccount(100).check_balance() == 100\n", "\nassert BankAccount().deposit(100) == True\n", "\nassert BankAccount().deposit(-100) == False\n", "\nassert BankAccount(100).withdraw(50) == True\n", "\nassert BankAccount(100).withdraw(150) == False\n", "\nassert ... |
88ff5714b93d2f78ac204a9b382cbd27 | [
{
"content": "On te donne une chaîne de caractères représentant un objet JSON, mais qui utilise des guillemets simples au lieu de guillemets doubles, ce qui n'est pas un format JSON valide. Ta tâche est de mettre en œuvre une fonction `parse_json_string` qui convertit cette chaîne en un dictionnaire. La fonctio... | ["\nassert parse_json_string(\"{'key': 'value'}\") == {\"key\": \"value\"}\n", "\nassert parse_json_string(\"{'number': 123}\") == {\"number\": 123}\n", "\nassert parse_json_string(\"{'boolean': true}\") == {\"boolean\": True}\n", "\nassert parse_json_string(\"{'null': null}\") == {\"null\": None}\n", "\nassert parse_j... |
d2b4aa200f2082c2335da2682cf9b72c | [
{
"content": "On te donne une chaîne de caractères qui peut contenir des balises HTML. Ta tâche est d'écrire une fonction Python qui supprime toutes les balises HTML de la chaîne et renvoie la chaîne nettoyée. Utilise des expressions régulières pour accomplir cette tâche. Tu n'es pas autorisé à utiliser d'autre... | ["\nassert remove_html_tags(\"<p>This is a <strong>sample</strong> string with <a href='#'>HTML</a> tags.</p>\") == \"This is a sample string with HTML tags.\"\n", "\nassert remove_html_tags(\"<div><span>Text</span></div>\") == \"Text\"\n", "\nassert remove_html_tags(\"No HTML here!\") == \"No HTML here!\"\n", "\nasser... |
3c3bdee6239426465a60d1b0bee57694 | [
{
"content": "On te demande d'implémenter une classe `Book` en Python pour gérer l'inventaire d'une bibliothèque. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Un livre est initialisé avec un titre, un auteur, une année de publication, un ISBN et un statut de disponi... | ["\nassert Book(\"1984\", \"George Orwell\", 1949, \"1234567890\", True).get_details() == \"Title: 1984, Author: George Orwell, Published Year: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960, \"0987654321\", False).check_out() == \"The book 'To Kill a Mockingbird' is not available for checkou... |
f70b739e37aac463163f23935053ada5 | [
{
"content": "On te donne un entier positif `number` représenté sous forme de chaîne de caractères. Ta tâche est de calculer la somme de ses chiffres, puis de multiplier cette somme par le nombre total de chiffres dans `number`. La fonction doit gérer des entiers extrêmement grands sans convertir l'ensemble de ... | ["\nassert digit_sum_product(\"123\") == 12\n", "\nassert digit_sum_product(\"0\") == 0\n", "\nassert digit_sum_product(\"999\") == 27\n", "\nassert digit_sum_product(\"1111111111\") == 45\n", "\nassert digit_sum_product(\"54321\") == 75\n", "\nassert digit_sum_product(\"1000000000\") == 1\n", "\nassert digit_sum_produ... |
7ff296c4c87c4b25636e24f538329571 | [
{
"content": "On te donne un bloc de texte et un entier `k`. Ta tâche est d'écrire une fonction Python `most_common_words(text, k)` qui identifie les `k` mots les plus courants dans le texte, en excluant un ensemble prédéfini de mots vides. La fonction doit renvoyer une liste de tuples, où chaque tuple contient... | ["\nassert most_common_words(\"Python is a great language.\", 1) == [('python', 1)]\n", "\nassert most_common_words(\"The quick brown fox jumps over the lazy dog.\", 2) == [('quick', 1), ('brown', 1)]\n", "\nassert most_common_words(\"Hello world, hello Python. Python is great!\", 2) == [('hello', 2), ('python', 2)]\n"... |
f255e11e7e478d5a9cba6d14b9a5c1ea | [
{
"content": "On te donne un fichier CSV nommé `students.csv` contenant des informations sur les élèves avec les colonnes suivantes : `Name`, `Age` et `Grade`. Ta tâche est d'écrire un programme Python qui lit ce fichier et calcule la moyenne des notes de tous les élèves. Suppose que le fichier CSV est correcte... | ["\nassert calculate_average_grade('students.csv') == 85.0\n", "\nassert calculate_average_grade('students.csv') == 90.5\n", "\nassert calculate_average_grade('students.csv') == 78.25\n", "\nassert calculate_average_grade('students.csv') == 100.0\n", "\nassert calculate_average_grade('students.csv') == 0.0\n", "\nasser... |
1d6e1a2fb7020b9f4ad5f4bf775ef944 | [
{
"content": "On te donne une liste de caractères et un décalage entier. Ta tâche est d'implémenter la fonction `shift_characters` qui décale chaque caractère de la liste vers la droite de la valeur du décalage, en respectant les contraintes suivantes :\n\n- Si la valeur ASCII d'un caractère est inférieure à 32... | ["\nassert shift_characters(['a', 'b', 'c'], 1) == ['b', 'c', 'd']\n", "\nassert shift_characters(['z', 'y', 'x'], 2) == ['|', '}', '{']\n", "\nassert shift_characters(['!', '@', '#'], 5) == [' ', ' ', ' ']\n", "\nassert shift_characters(['~', '`', '^'], 3) == ['}', '~', '~']\n", "\nassert shift_characters(['\"', \"'\"... |
061b06f5bbd6459d052503d65f4d4848 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères de la table ASCII. Ta tâche est de mettre en œuvre une fonction `remove_duplicate_chars` qui supprime tous les caractères dupliqués de la chaîne tout en préservant l'ordre de la première occurrence de chaque caractère. La fonction doi... | ["\nassert remove_duplicate_chars(\"aabbbcccddd\") == \"abcd\"\n", "\nassert remove_duplicate_chars(\"hello\") == \"helo\"\n", "\nassert remove_duplicate_chars(\"aA!@#bbCC\") == \"aA!@#bC\"\n", "\nassert remove_duplicate_chars(\"abcdefg\") == \"abcdefg\"\n", "\nassert remove_duplicate_chars(\"aabbccddeeff\") == \"abcde... |
50f009600ca270dca465a72b968cc40f | [
{
"content": "On te donne un tableau d'entiers `sequence` et un entier `target`. Ta tâche est de trouver tous les sous-tableaux dans `sequence` dont la somme est égale à `target`. Retourne une liste de listes, où chaque liste interne contient les indices de début et de fin d'un sous-tableau dont la somme est ég... | ["\nassert find_subarrays_with_target_sum([3, 2, 7, 1, 5], 5) == [[1, 2], [3, 4]]\n", "\nassert find_subarrays_with_target_sum([1, 2, 3, 4, 5], 5) == [[0, 1], [2]]\n", "\nassert find_subarrays_with_target_sum([1, 2, 3, 4, 5], 9) == [[1, 3], [3, 4]]\n", "\nassert find_subarrays_with_target_sum([1, 2, 3, 4, 5], 10) == [[... |
e75014fcb03a2a671df27ed9c22ab9d5 | [
{
"content": "On te donne une chaîne de caractères `s` et un caractère `char`. Ta tâche est de mettre en œuvre une fonction `find_last_occurrence` qui renvoie l'index de la dernière occurrence de `char` dans `s`, en ne considérant que les caractères alphanumériques et en ignorant la casse. Si `char` n'apparaît ... | ["\nassert find_last_occurrence(\"Hello World!\", \"l\") == 9\n", "\nassert find_last_occurrence(\"Python Programming\", \"z\") == -1\n", "\nassert find_last_occurrence(\"123abcABC\", \"a\") == 7\n", "\nassert find_last_occurrence(\"123abcABC\", \"3\") == 2\n", "\nassert find_last_occurrence(\"No matches here!\", \"x\"... |
094dbbb1ef036ab2f1a61720308625ba | [
{
"content": "On te donne une chaîne de caractères contenant plusieurs CURIE (Compact Uniform Resource Identifiers) séparés par des points-virgules. Chaque CURIE est composé d'un préfixe et d'un identifiant local, séparés par deux-points. Ta tâche est d'écrire une fonction `extract_prefix(curie: str) -> List[Op... | ["\nassert extract_prefix(\"obo:DOID_1234\") == [\"obo\"]\n", "\nassert extract_prefix(\"obo:DOID_1234;rdf:type\") == [\"obo\", \"rdf\"]\n", "\nassert extract_prefix(\"obo:DOID_1234;rdf:type;invalid-curie\") == [\"obo\", \"rdf\", None]\n", "\nassert extract_prefix(\"obo:DOID_1234;rdf:type;prefix:value\") == [\"obo\", \... |
f8ce320918a5285ff04af35db9c02839 | [
{
"content": "On te donne un arbre binaire. Ta tâche est d'écrire une fonction qui calcule le nombre total de nœuds dans l'arbre. Implémente la classe `TreeNode` et la fonction `count_nodes`. La classe `TreeNode` doit avoir un initialisateur qui accepte une valeur et des enfants gauche et droit optionnels. La f... | ["\nassert count_nodes(None) == 0\n", "\nassert count_nodes(TreeNode(1)) == 1\n", "\nassert count_nodes(TreeNode(1, TreeNode(2))) == 2\n", "\nassert count_nodes(TreeNode(1, None, TreeNode(3))) == 2\n", "\nassert count_nodes(TreeNode(1, TreeNode(2), TreeNode(3))) == 3\n", "\nassert count_nodes(TreeNode(1, TreeNode(2, Tr... |
fd55d895b5531c782e735ec7a8cca2d9 | [
{
"content": "On te donne un tuple imbriqué où chaque paire d'éléments représente une paire clé-valeur. Le tuple a toujours un nombre pair d'éléments. Si une valeur est un tuple, elle doit être convertie récursivement en un dictionnaire. Ta tâche est d'écrire une fonction `convert_nested_tuple_to_dict(nested_tu... | ["\nassert convert_nested_tuple_to_dict(('a', 1, 'b', 2)) == {'a': 1, 'b': 2}\n", "\nassert convert_nested_tuple_to_dict(('x', ('y', 3, 'z', 4), 'w', 5)) == {'x': {'y': 3, 'z': 4}, 'w': 5}\n", "\nassert convert_nested_tuple_to_dict(('key1', 'value1', 'key2', ('subkey1', 'subvalue1', 'subkey2', ('subsubkey1', 'subsubval... |
a6fbd79c6ee9e91304124ee1ec21f839 | [
{
"content": "On te donne une matrice carrée `A` de taille `N x N` représentant une matrice d'adjacence pondérée d'un graphe. Chaque élément `A[i][j]` représente le poids de l'arête entre le nœud `i` et le nœud `j`. S'il n'y a pas d'arête entre deux nœuds, la cellule correspondante dans la matrice aura une vale... | ["\nassert average_weighted_degree([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == 0.0\n", "\nassert average_weighted_degree([[0, 1, 2], [1, 0, 3], [2, 3, 0]]) == 3.6666666666666665\n", "\nassert average_weighted_degree([[0, 5], [5, 0]]) == 5.0\n", "\nassert average_weighted_degree([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, ... |
a0a2f98c4c7ca0ef0f8173fad602e236 | [
{
"content": "On te donne un tableau d'entiers `arr` et un booléen `ascend`. Implémente une fonction `custom_sort` qui trie le tableau par ordre croissant si `ascend` est `True`, et par ordre décroissant si `ascend` est `False`. Tu dois utiliser l'algorithme de tri à bulles avec une optimisation pour s'arrêter ... | ["\nassert custom_sort([64, 34, 25, 12, 22, 11, 90], True) == [11, 12, 22, 25, 34, 64, 90]\n", "\nassert custom_sort([64, 34, 25, 12, 22, 11, 90], False) == [90, 64, 34, 25, 22, 12, 11]\n", "\nassert custom_sort([1, 2, 3, 4, 5], True) == [1, 2, 3, 4, 5]\n", "\nassert custom_sort([5, 4, 3, 2, 1], False) == [5, 4, 3, 2, ... |
1e505f4cfbe39dc92ab7bc57bdd876de | [
{
"content": "Tu participes à un concours de programmation où tu dois traiter efficacement de gros fichiers CSV. Ta tâche est d'écrire un programme qui lit un fichier CSV et convertit son contenu en un fichier JSON Lines (JSONL). Le fichier CSV contiendra des données sur divers livres, chaque ligne représentant... | ["\nassert csv_to_json_line_by_line('empty.csv', 'empty.jsonl') == None\n", "\nassert csv_to_json_line_by_line('single_row.csv', 'single_row.jsonl') == None\n", "\nassert csv_to_json_line_by_line('multiple_rows.csv', 'multiple_rows.jsonl', indent=2) == None\n", "\nassert csv_to_json_line_by_line('sorted_keys.csv', 'sor... |
eca37aa14c1ecb638cb5471a018bba13 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules en anglais et d'espaces. Ta tâche est d'écrire une fonction qui renvoie un dictionnaire où chaque clé est un mot unique de la chaîne et la valeur correspondante est le nombre de fois que ce mot apparaît dans la chaîne.\n\n**En... | ["\nassert word_count(\"the quick brown fox jumps over the lazy dog\") == {'the': 1, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nassert word_count(\"hello hello world\") == {'hello': 2, 'world': 1}\n", "\nassert word_count(\"a a a a a\") == {'a': 5}\n", "\nassert word_count(\"py... |
ee4def1b06fca9243e53b08f362d5658 | [
{
"content": "On te donne un tableau trié `nums` d'entiers distincts et une valeur cible `target`. Ta tâche est de déterminer l'index auquel la cible doit être insérée pour maintenir l'ordre trié du tableau. Si la cible est déjà présente dans le tableau, renvoie son index. Sinon, renvoie l'index où elle serait ... | ["\nassert search_insert([1,3,5,6], 5) == 2\n", "\nassert search_insert([1,3,5,6], 2) == 1\n", "\nassert search_insert([1,3,5,6], 7) == 4\n", "\nassert search_insert([1,3,5,6], 0) == 0\n", "\nassert search_insert([], 1) == 0\n", "\nassert search_insert([1], 1) == 0\n", "\nassert search_insert([1], 2) == 1\n", "\nassert... |
4df287b16ae74da9442f35a9f96e0956 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de déterminer si `n` est un nombre premier. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même. Ta solution doit être suffisamment efficace pour gérer de grandes valeurs de `n`.\n\n**Entré... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(29) == True\n", "\nassert is_prime(1) == False\n", "\nassert is_prime(0) == False\n", "\nassert is_prime(-7) == False\n", "\nassert is_prime(97) == True\n", "\nass... |
6fc10118e89ec5e34290291d4c45adb9 | [
{
"content": "Tu es un chasseur de trésors qui a découvert un coffre contenant `n` objets, chacun ayant un poids et une valeur uniques. Ton sac à dos ne peut transporter qu'un poids maximal de `maxW`. Tu ne peux prendre qu'un seul exemplaire de chaque objet, et tu ne peux pas retourner au coffre une fois parti.... | ["\nassert knapsack([2, 3, 4, 5], [3, 4, 5, 6], 5) == 7\n", "\nassert knapsack([1, 2, 3], [10, 15, 40], 6) == 65\n", "\nassert knapsack([10, 20, 30], [60, 100, 120], 50) == 220\n", "\nassert knapsack([1, 2, 3, 4], [10, 20, 30, 40], 10) == 70\n", "\nassert knapsack([5, 4, 6, 3], [10, 40, 30, 50], 10) == 90\n", "\nassert... |
e1081f9f83c01ae35a2c23e2ad9cd231 | [
{
"content": "On te donne un modèle d'apprentissage automatique représenté comme un objet et un ensemble de paires clé-valeur sous forme d'arguments de mots-clés (`**kwargs`). Ta tâche est de mettre en œuvre une fonction `store_tracker_data` qui stockera ces paires clé-valeur dans un attribut spécial `_tracker_... | ["\nassert store_tracker_data(type('Model', (object,), {})(), a=1, b=2) == {'a': 1, 'b': 2}\n", "\nassert store_tracker_data(type('Model', (object,), {'_tracker_data': {'a': 1}})(), b=2) == {'a': 1, 'b': 2}\n", "\nassert store_tracker_data(type('Model', (object,), {'_tracker_data': {'a': 1, 'b': 2}})(), a=3) == {'a': 3... |
14a872a350f970d2a23dc6292be85fb0 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ta tâche est de déterminer le nombre de sous-ensembles non vides de `numbers` dont la somme est divisible par `target`. Implémente une fonction en utilisant la programmation dynamique pour résoudre ce problème.\n\n**Entrée :**\n- Une... | ["\nassert count_divisible_subsets([3, 5, 1, 4], 3) == 4\n", "\nassert count_divisible_subsets([1, 2, 3, 4, 5], 5) == 5\n", "\nassert count_divisible_subsets([1, 1, 1, 1], 2) == 7\n", "\nassert count_divisible_subsets([0, 0, 0], 1) == 7\n", "\nassert count_divisible_subsets([10, 20, 30], 10) == 7\n", "\nassert count_di... |
9ea4b95c2f7dec835415dc69fdc7b9b2 | [
{
"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 Python nommée `flatten_list` qui prend cette liste imbriquée en entrée et renvoie une liste aplatie unique contenant tous les entiers de la liste d'origine dans le même ordre.\n\n... | ["\nassert flatten_list([1, 2, [3, 4], [5, 6], 7]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert flatten_list([[1, 2, [3]], 4, [5, [6, 7]]]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert flatten_list([[[[1]]], 2, 3, [4, [5, [6]]]]) == [1, 2, 3, 4, 5, 6]\n", "\nassert flatten_list([]) == []\n", "\nassert flatten_list([[], [], []]) ==... |
ee677198c1e42f25a30794502df6a46d | [
{
"content": "On te donne un fichier texte nommé `data.txt` contenant un tableau de réactions chimiques avec leurs plages de température respectives au format `reaction_name;T_min;T_max`. La première ligne du fichier est un en-tête `Reaction;T_min;T_max`. Ta tâche est d'écrire une fonction qui lit ce fichier et... | ["\nassert calculate_average_temperatures('data.txt') == {'Reaction1': 250.0, 'Reaction2': 300.0} if open('data.txt', 'w').write('Reaction;T_min;T_max\\nReaction1;200;300\\nReaction2;250;350') else None\n", "\nassert calculate_average_temperatures('data.txt') == {'ReactionA': 150.0, 'ReactionB': 200.0, 'ReactionC': 250... |
3ee7ccea2c5c26ce06fbbf12b60f57c6 | [
{
"content": "On te donne une liste de mains de poker, chacune représentée comme un tuple. Le premier élément du tuple est une liste de 9 valeurs booléennes indiquant la présence (True) ou l'absence (False) de diverses combinaisons de poker, ordonnées de la plus haute à la plus basse : Quinte Flush Royale, Quin... | ["\nassert determine_best_hand([([False, True, False, False, False, True, False, False, False], 7), ([False, False, False, True, False, False, True, False, False], 10)]) == ([False, False, False, True, False, False, True, False, False], 10)\n", "\nassert determine_best_hand([([True, False, False, False, False, False, F... |
5bc4527993dd72a0314fa2e083b6084d | [
{
"content": "On te donne une liste de chaînes de caractères `sentences`, où chaque chaîne représente une phrase. Ta tâche est de mettre en œuvre une fonction `average_sentence_length(sentences)` qui calcule le nombre moyen de mots par phrase. On suppose que les mots sont séparés par des espaces. Si la liste es... | ["\nassert average_sentence_length([\"This is a test\", \"Another sentence here\", \"Short\"]) == 2.3333333333333335\n", "\nassert average_sentence_length([\"Hello world\", \"Python is great\"]) == 3.0\n", "\nassert average_sentence_length([\"One\", \"Two\", \"Three\"]) == 1.0\n", "\nassert average_sentence_length([\"\... |
c07d47fba7a4d42fd8e98893f49369dc | [
{
"content": "On te donne une chaîne de caractères `s` qui peut contenir des caractères Unicode. Ta tâche est de mettre en œuvre une fonction `check_last_character` qui détermine si le dernier caractère de la chaîne est un chiffre. La fonction doit renvoyer `True` si le dernier caractère est un chiffre, et `Fal... | ["\nassert check_last_character(\"hello123\") == True\n", "\nassert check_last_character(\"hello\") == False\n", "\nassert check_last_character(\"12345\") == True\n", "\nassert check_last_character(\"\") == False\n", "\nassert check_last_character(\"hello world 9\") == True\n", "\nassert check_last_character(\"hello wo... |
499463303f6ad4419fa6e458eefc8d94 | [
{
"content": "On te donne une chaîne de caractères `data` composée d'un mélange de caractères alphabétiques, de chiffres et de caractères spéciaux. Ta tâche est de mettre en œuvre une fonction `extract_numbers` qui extrait toutes les séquences de chiffres d'au moins 3 caractères de la chaîne et les renvoie sous... | ["\nassert extract_numbers(\"abc123def\") == [123]\n", "\nassert extract_numbers(\"1234 5678 90\") == [1234, 5678]\n", "\nassert extract_numbers(\"no numbers here!\") == []\n", "\nassert extract_numbers(\"12 345 6789\") == [345, 6789]\n", "\nassert extract_numbers(\"000123 456000\") == [123, 456000]\n", "\nassert extra... |
53f7615f89395888180c50cbb515f656 | [
{
"content": "On te donne une chaîne de caractères `text` chiffrée en utilisant un chiffrement de César avec une valeur de décalage connue `shift`. Le chiffrement de César décale chaque lettre du texte clair d'un nombre fixe de positions dans l'alphabet. Ta tâche est de mettre en œuvre une fonction `decrypt_cae... | ["\nassert decrypt_caesar_cipher(\"KHOOR ZRUOG\", 3) == \"HELLO WORLD\"\n", "\nassert decrypt_caesar_cipher(\"URYYB JBEYQ\", 13) == \"HELLO WORLD\"\n", "\nassert decrypt_caesar_cipher(\"VHFUHW PHVVDJH\", 10) == \"HELLO WORLD\"\n", "\nassert decrypt_caesar_cipher(\"ZRUOG\", 3) == \"WORLD\"\n", "\nassert decrypt_caesar_c... |
42222b59bfb1dae6ed9979767cae91a1 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `get_unique_characters` qui renvoie un ensemble de caractères uniques de la chaîne, en ignorant les différences de casse. La fonction doit être insensible à la casse, ce qui signifie que 'A' et 'a' doivent être ... | ["\nassert get_unique_characters(\"Hello World\") == {'h', 'e', 'l', 'o', ' ', 'w', 'r', 'd'}\n", "\nassert get_unique_characters(\"Python\") == {'p', 'y', 't', 'h', 'o', 'n'}\n", "\nassert get_unique_characters(\"AaBbCc\") == {'a', 'b', 'c'}\n", "\nassert get_unique_characters(\"12345\") == {'1', '2', '3', '4', '5'}\n... |
ed6011caa00f4cc9a2a97f85a6d0ae5c | [
{
"content": "On te demande d'implémenter une fonction qui génère une liste de `n` entiers aléatoires uniques compris entre 1 et 1000 inclus. La fonction doit s'assurer qu'aucun nombre de la liste ne soit identique et que l'ordre des nombres soit aléatoire. Si `n` dépasse 1000, la fonction doit lever une `Value... | ["\nassert len(generate_unique_random_numbers(10)) == 10\n", "\nassert len(generate_unique_random_numbers(0)) == 0\n", "\nassert len(generate_unique_random_numbers(1)) == 1\n", "\nassert len(generate_unique_random_numbers(1000)) == 1000\n", "\nassert all(isinstance(num, int) for num in generate_unique_random_numbers(5)... |
413b46f73c920717d81c36c17a708af6 | [
{
"content": "On te demande d'implémenter une fonction `encode_number(n, padding=None)` qui encode un entier positif `n` en une chaîne de caractères en utilisant un schéma d'encodage personnalisé. Le processus d'encodage implique les étapes suivantes :\n\n1. Convertir l'entier `n` en blocs de 8 bits, en commenç... | ["\nassert encode_number(0) == chr(((ord('\\x00') - 32 + 5) % 95) + 32)\n", "\nassert encode_number(1) == chr(((ord('\\x01') - 32 + 5) % 95) + 32)[::-1]\n", "\nassert encode_number(255) == chr(((ord('\\xFF') - 32 + 5) % 95) + 32)[::-1]\n", "\nassert encode_number(256) == chr(((ord('\\x00') - 32 + 5) % 95) + 32) + chr((... |
cec0b3e0e950331a2824955d9ddf2e1a | [
{
"content": "On te donne un graphe orienté représenté sous forme de liste d'adjacence. Ta tâche est de déterminer si le graphe contient un cycle. Le graphe est composé de `n` nœuds et de `m` arêtes orientées. Chaque nœud est identifié par un entier de `0` à `n-1`. Écris une fonction `has_cycle(graph)` qui renv... | ["\nassert has_cycle({0: [1], 1: [2], 2: []}) == False\n", "\nassert has_cycle({0: [1], 1: [2], 2: [0]}) == True\n", "\nassert has_cycle({0: [1, 2], 1: [2], 2: [3], 3: []}) == False\n", "\nassert has_cycle({0: [1, 2], 1: [2], 2: [0, 3], 3: [3]}) == True\n", "\nassert has_cycle({0: [], 1: [], 2: []}) == False\n", "\nass... |
f67d789e1de08c956a1c6575372dba3e | [
{
"content": "On te demande d'implémenter une fonction `get_special_primes(n)` qui renvoie une liste des `n` premiers nombres premiers. Ton implémentation ne doit utiliser aucune fonction intégrée pour la génération ou la vérification des nombres premiers, et doit uniquement utiliser des tableaux ou des listes ... | ["\nassert get_special_primes(1) == [2]\n", "\nassert get_special_primes(2) == [2, 3]\n", "\nassert get_special_primes(3) == [2, 3, 5]\n", "\nassert get_special_primes(5) == [2, 3, 5, 7, 11]\n", "\nassert get_special_primes(10) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n", "\nassert get_special_primes(0) == []\n", "\nass... |
b45a83208e4213ef15b921a073bed23d | [
{
"content": "On te donne deux lignes 3D, `l1` et `l2`, représentées comme des tuples de six éléments chacun : `(x0, y0, z0, a0, f0, e0)` et `(xa, ya, za, aa, fa, ea)`, respectivement. Chaque tuple contient les coordonnées x, y et z du point de départ de la ligne, suivies de trois paramètres supplémentaires (`a... | ["\nassert min_distance((0, 0, 0, 0, 0, 0), (1, 1, 1, 0, 0, 0), (0.5, 0.5, 0.5, 0, 0, 0)) == 0\n", "\nassert min_distance((0, 0, 0, 0, 0, 0), (1, 1, 1, 0, 0, 0), (1, 1, 1, 0, 0, 0)) == 0\n", "\nassert min_distance((0, 0, 0, 0, 0, 0), (1, 1, 1, 0, 0, 0), (2, 2, 2, 0, 0, 0)) == np.sqrt(3)\n", "\nassert min_distance((0, 0... |
8b392263feb0edf37763cc7ee9d9bb40 | [
{
"content": "On te donne une liste d'entiers représentant les distances parcourues lors d'une série de trajets en voiture. Ta tâche est d'écrire une fonction Python qui calcule la distance totale parcourue. La fonction doit accepter une liste d'entiers en entrée et renvoyer la somme de ces entiers.\n\n**Entrée... | ["\nassert total_distance([10, 20, 30]) == 60\n", "\nassert total_distance([5, 15, 25, 35]) == 80\n", "\nassert total_distance([100, 200, 300, 400]) == 1000\n", "\nassert total_distance([0, 0, 0, 0]) == 0\n", "\nassert total_distance([1]) == 1\n", "\nassert total_distance([]) == 0\n", "\nassert total_distance([-10, 20,... |
6c85cb85f745c6ee456a5811a254088b | [
{
"content": "On te demande d'implémenter une fonction `format_bytes_with_padding` qui traite une chaîne de caractères donnée `data` et la formate en octets selon des règles spécifiques. La fonction doit encoder la chaîne d'entrée en utilisant le schéma d'encodage `utf-16be`. Si la séquence d'octets résultante ... | ["\nassert format_bytes_with_padding(\"hello\", 10, \" \") == b'\\x00h\\x00e\\x00l\\x00l\\x00o\\x00 \\x00'\n", "\nassert format_bytes_with_padding(\"world\", 12, \"x\") == b'\\x00w\\x00o\\x00r\\x00l\\x00d\\x00x\\x00x'\n", "\nassert format_bytes_with_padding(\"test\", 8, \"a\") == b'\\x00t\\x00e\\x00s\\x00t\\x00a\\x00a'... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.