id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
4e573115ede5bbd9eedf49c4e80e611a | [
{
"content": "On te demande d'implémenter une fonction pour générer un labyrinthe aléatoire en utilisant l'algorithme de retour arrière récursif. Le labyrinthe doit être représenté comme un tableau 2D de taille `hauteur x largeur`, où `0` représente un mur et `1` représente un chemin. Le labyrinthe doit avoir u... | ["\nassert generate_maze(3, 3) == [[0, 0, 0], [0, 1, 0], [0, 0, 0]]\n", "\nassert generate_maze(5, 5)[0][1] == 1 # Check entrance\n", "\nassert generate_maze(5, 5)[4][3] == 1 # Check exit\n", "\nassert all(row[0] == 0 and row[-1] == 0 for row in generate_maze(7, 7)) # Check vertical walls\n", "\nassert all(col[0] ==... |
6c21867c051af0b5aeb7b1bb052349e2 | [
{
"content": "On te demande d'implémenter une fonction `create_config` pour un système de gestion de configuration. La fonction doit sérialiser un dictionnaire de paramètres dans un fichier au format JSON. La fonction doit respecter les spécifications suivantes :\n\n- **Signature de la fonction** : `create_conf... | ["\nassert create_config({\"key\": \"value\"}, \"test1.json\", 4) == True\n", "\nassert create_config({}, \"test2.json\", 2) == True\n", "\nassert create_config({\"nested\": {\"key\": \"value\"}}, \"test3.json\", 0) == True\n", "\nassert create_config({\"list\": [1, 2, 3]}, \"test4.json\", 4) == True\n", "\nassert crea... |
5f0ff6ceef9c4e151890010da6ba5ca1 | [
{
"content": "On te donne une chaîne de caractères `text`. Ta tâche est d'implémenter une fonction `word_frequencies` qui traite cette chaîne et renvoie un dictionnaire. Les clés du dictionnaire doivent être les mots uniques de la chaîne, et les valeurs doivent être les fréquences de ces mots. La comparaison de... | ["\nassert word_frequencies(\"Hello, world!\") == {\"hello\": 1, \"world\": 1}\n", "\nassert word_frequencies(\"Python, python, PYTHON!\") == {\"python\": 3}\n", "\nassert word_frequencies(\"Is this the real life? Is this just fantasy?\") == {\"is\": 2, \"this\": 2, \"the\": 1, \"real\": 1, \"life\": 1, \"just\": 1, \"... |
0c51fd8c6f0cd396f5c49c264b683d21 | [
{
"content": "On te demande d'implémenter une simulation simple de distributeur automatique en Python. Ton distributeur automatique doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un produit** : Ajouter un nouveau produit au distributeur automatique ou mettre à jour la quantité d'un produit ex... | ["\nassert VendingMachine().add_product(\"Soda\", 1.50, 10) is None\n", "\nassert VendingMachine().insert_money(2.00) == 2.00\n", "\nassert VendingMachine().purchase_product(\"Soda\") == \"Product not found.\"\n", "\nvm = VendingMachine()\nvm.add_product(\"Chips\", 1.25, 5)\nvm.insert_money(1.25)\nassert vm.purchase_pr... |
861f2c7a50931c9e31c8e1c0c30e3607 | [
{
"content": "On te donne une chaîne de caractères `text` contenant divers mots et expressions. Ta tâche est d'écrire une fonction `find_urls` qui extrait toutes les URL de la chaîne. Une URL commence par `http://` ou `https://` et est suivie d'un nom de domaine et d'un chemin d'accès facultatif. Le nom de doma... | ["\nassert find_urls(\"Check out this website: https://www.example.com\") == [\"https://www.example.com\"]\n", "\nassert find_urls(\"Visit http://test.com for more info.\") == [\"http://test.com\"]\n", "\nassert find_urls(\"No URLs here!\") == []\n", "\nassert find_urls(\"Multiple URLs: http://example.com and https://a... |
81fee12a650d4eb52a01dd20e1f8e662 | [
{
"content": "On te demande d'écrire un script Python qui traite un fichier CSV et calcule la somme de toutes les valeurs numériques qu'il contient. Ton programme doit répondre aux critères suivants :\n\n- Accepter un chemin de fichier à partir de l'entrée utilisateur.\n- Lire le fichier CSV situé au chemin fou... | ["\nassert sum_numeric_values(\"test1.csv\") == 15.0 # Assuming test1.csv contains: 1,2,3,4,5\n", "\nassert sum_numeric_values(\"test2.csv\") == 0.0 # Assuming test2.csv contains: a,b,c,d,e\n", "\nassert sum_numeric_values(\"test3.csv\") == 3.0 # Assuming test3.csv contains: 1.5,1.5\n", "\nassert sum_numeric_value... |
a69568d1e3b97ace926c959709776d8e | [
{
"content": "On te demande d'implémenter une classe `SimpleCalculator` en Python qui prenne en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. Ta classe doit gérer la division par zéro avec élégance en renvoyant un message d'erreur spécifique.\n\n**Entrée :**\n... | ["\nassert SimpleCalculator().add(10, 5) == 15\n", "\nassert SimpleCalculator().subtract(10, 5) == 5\n", "\nassert SimpleCalculator().multiply(10, 5) == 50\n", "\nassert SimpleCalculator().divide(10, 5) == 2.0\n", "\nassert SimpleCalculator().divide(10, 0) == \"Error: Division by zero is not allowed.\"\n", "\nassert Si... |
0b39a95aa45242f0cb2eb5138e8c77b2 | [
{
"content": "On te demande d'implémenter une classe `Circle` en Python qui modélise un cercle dans un plan 2D. La classe doit avoir les attributs suivants :\n- `x` : La coordonnée x du centre du cercle.\n- `y` : La coordonnée y du centre du cercle.\n- `radius` : Le rayon du cercle.\n\nLa classe doit également ... | ["\nassert Circle(0, 0, 1).area() == math.pi\n", "\nassert Circle(0, 0, 2).circumference() == 4 * math.pi\n", "\nassert Circle(1, 1, 0).area() == 0\n", "\nassert Circle(0, 0, 5).area() == 25 * math.pi\n", "\nassert Circle(0, 0, 10).circumference() == 20 * math.pi\n", "\ncircle = Circle(0, 0, 1)\ncircle.move(1, 1)\nasse... |
afcdb16fecbcae858d40c9ee088f68d3 | [
{
"content": "On te donne un canevas virtuel de dimensions 100x100 unités. Une image réelle de dimensions `W` x `H` pixels est affichée sur ce canevas avec une distorsion non uniforme. La distorsion est définie par un ensemble de points de contrôle. Chaque point de contrôle mappe une région rectangulaire sur le... | ["\nassert virtual_to_pixel(0, 0, 400, 400, [(0, 0, 100, 100, 0, 0, 400, 400)]) == (0, 0)\n", "\nassert virtual_to_pixel(100, 100, 400, 400, [(0, 0, 100, 100, 0, 0, 400, 400)]) == (400, 400)\n", "\nassert virtual_to_pixel(50, 50, 400, 400, [(0, 0, 100, 100, 0, 0, 400, 400)]) == (200, 200)\n", "\nassert virtual_to_pixel... |
d2b9d8c506af77ce1ba8c5d47dffc5a9 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé de deux éléments. Le premier élément est une clé (chaîne de caractères) et le second élément est une valeur (entier). Ta tâche est de mettre en œuvre une fonction qui convertit cette liste de tuples en un dictionnaire. Si des clés sont d... | ["\nassert tuples_to_dict([('apple', 2), ('banana', 3), ('apple', 5)]) == {'apple': 7, 'banana': 3}\n", "\nassert tuples_to_dict([('car', 10), ('bike', 20), ('car', 30)]) == {'car': 40, 'bike': 20}\n", "\nassert tuples_to_dict([('dog', 1), ('cat', 2), ('dog', 3), ('cat', 4)]) == {'dog': 4, 'cat': 6}\n", "\nassert tuple... |
f0828113c6e2a378a56886ae7a12dc41 | [
{
"content": "On te donne une liste de dictionnaires `dict_list` et une chaîne de caractères `sort_key`. Ta tâche est de trier la liste de dictionnaires en fonction des valeurs associées à `sort_key`. Si un dictionnaire ne contient pas la clé `sort_key`, il doit être considéré comme ayant une valeur de 0.\n\n**... | ["\nassert sort_dict_list_by_key([{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}, {'name': 'Charlie', 'age': 35}], 'age') == [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]\n", "\nassert sort_dict_list_by_key([{'name': 'Alice'}, {'name': 'Bob', 'age': 25}, {'name': '... |
687e2e3decfde7643b7aa32d4f58ce65 | [
{
"content": "On te demande d'implémenter une fonction `paginate_dataframe` qui découpe efficacement un grand ensemble de données représenté sous forme de DataFrame pandas en pages plus petites. Étant donné un DataFrame `df`, un entier `page_size` indiquant le nombre de lignes par page, et un entier `page_numbe... | ["\nassert paginate_dataframe(pd.DataFrame({'A': [1, 2, 3, 4, 5]}), 2, 1).equals(pd.DataFrame({'A': [1, 2]}))\n", "\nassert paginate_dataframe(pd.DataFrame({'A': [1, 2, 3, 4, 5]}), 2, 2).equals(pd.DataFrame({'A': [3, 4]}))\n", "\nassert paginate_dataframe(pd.DataFrame({'A': [1, 2, 3, 4, 5]}), 2, 3).equals(pd.DataFrame(... |
58b1759d771ee2a619ae00c3bb2c1e5a | [
{
"content": "Dans une compétition de programmation, tu disposes d'un ensemble de données contenant les scores des étudiants. L'ensemble de données est structuré sous forme de liste de tuples, chaque tuple étant composé du nom d'un étudiant et de son score. Ton objectif est de déterminer le nombre d'étudiants l... | ["\nassert top_performing_students([(\"Alice\", 95), (\"Bob\", 88), (\"Charlie\", 72), (\"David\", 92), (\"Eve\", 81)], 40) == 3\n", "\nassert top_performing_students([(\"Alice\", 95), (\"Bob\", 88), (\"Charlie\", 72), (\"David\", 92), (\"Eve\", 81)], 50) == 3\n", "\nassert top_performing_students([(\"Alice\", 95), (\"... |
faf51cf3cd8f52d25d2be60abf0c5302 | [
{
"content": "Dans un contexte de Réseau Adversarial Génératif (GAN), tu as pour tâche d'implémenter une fonction pour calculer la perte de pénalité de gradient pour un réseau discriminateur donné. La perte de pénalité de gradient doit incorporer une pondération adaptative basée sur la précision du discriminate... | ["\nassert gradient_penalty_loss(discriminator, torch.randn(10, 3, 32, 32), torch.randn(10, 3, 32, 32), 'cpu') >= 0\n", "\nassert gradient_penalty_loss(discriminator, torch.randn(5, 1, 28, 28), torch.randn(5, 1, 28, 28), 'cpu', lambda_gp=5) >= 0\n", "\nassert gradient_penalty_loss(discriminator, torch.randn(3, 3, 64, 6... |
fc75e70114ca237d3474ba105a002022 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de trouver le plus grand palindrome qui peut être obtenu en multipliant deux nombres à `n` chiffres. Un nombre à `n` chiffres est un nombre qui a exactement `n` chiffres, sans compter les zéros non significatifs. Par exemple, si `n = 2`, tu dois trou... | ["\nassert find_largest_palindrome_product(2) == 9009\n", "\nassert find_largest_palindrome_product(1) == 9\n", "\nassert find_largest_palindrome_product(3) == 906609\n", "\nassert find_largest_palindrome_product(4) == 99000099\n", "\nassert find_largest_palindrome_product(5) == 999000999\n", "\nassert find_largest_pal... |
48793992f909d12bcc4f29d6058c424e | [
{
"content": "On te donne une liste d'entiers `elements` et un entier `target`. Ta tâche est de mettre en œuvre une fonction `count_elements` qui renvoie le nombre de fois que `target` apparaît dans la sous-liste de `elements` qui commence à la première occurrence du nombre 5 et se termine à la dernière occurre... | ["\nassert count_elements([1, 2, 5, 3, 10, 4, 5, 10], 5) == 2\n", "\nassert count_elements([1, 5, 3, 10, 4, 5, 10, 10], 10) == 3\n", "\nassert count_elements([1, 2, 3, 4], 3) == 0\n", "\nassert count_elements([1, 5, 3, 4], 3) == 0\n", "\nassert count_elements([1, 5, 3, 10, 4, 5, 11], 5) == 2\n", "\nassert count_element... |
71c58e861ac08cddf2adea834284e427 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui calcule la somme des deux plus petits nombres distincts de la liste. La fonction doit gérer les cas limites, tels que les listes contenant des nombres négatifs ou des doublons. Si la liste contient moins de deux nom... | ["\nassert sum_of_two_smallest([1, 2, 3, 4, 5]) == 3\n", "\nassert sum_of_two_smallest([-1, -2, -3, -4, -5]) == -6\n", "\nassert sum_of_two_smallest([10, 20, 30, 40, 50]) == 30\n", "\nassert sum_of_two_smallest([5, 5, 5, 5, 5]) == 10\n", "\nassert sum_of_two_smallest([0, 0, 0, 0, 0]) == 0\n", "\nassert sum_of_two_small... |
e9e7227531d8c0cd53e4e5486ebea72d | [
{
"content": "Dans un scénario de jeu dynamique, tu dois implémenter une fonction `calculate_rewards` qui calcule le total des récompenses qu'un joueur gagne en fonction de ses choix et de la configuration du jeu. Le jeu se déroule sur plusieurs manches, et à chaque manche, le joueur sélectionne l'une des deux ... | ["\nassert calculate_rewards([0, 1, 1], [0, 1, 1], [10, 20, 30], [1, 2, 3]) == 140\n", "\nassert calculate_rewards([1, 0, 1], [1, 1, 0], [5, 15, 25], [2, 3, 4]) == 50\n", "\nassert calculate_rewards([0, 0, 0], [0, 0, 0], [1, 1, 1], [1, 1, 1]) == 3\n", "\nassert calculate_rewards([1, 1, 1], [0, 0, 0], [100, 200, 300], [... |
73276b31a21b62e77e74c7230da8bc88 | [
{
"content": "On te demande d'écrire un algorithme efficace pour calculer le nième nombre de Fibonacci. Pour optimiser ta solution, implémente la mémoïsation. Ton programme doit gérer efficacement plusieurs cas de test.\n\n**Entrée :**\n- La première ligne contient un entier T (1 ≤ T ≤ 100), le nombre de cas de... | ["\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(6) == 8\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(14) == 377\n", "\nassert fibonacci(20) ==... |
6bc3206b233038d508a92aa5d241b6e0 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'écrire une fonction Python qui regroupe les indices des anagrammes. Un anagramme est un mot formé en réarrangeant les lettres d'un autre mot. La fonction doit renvoyer une liste de listes, où chaque liste interne contient les indic... | ["\nassert group_anagrams([\"dog\", \"cat\", \"god\", \"tac\"]) == [[0, 2], [1, 3]]\n", "\nassert group_anagrams([\"listen\", \"silent\", \"enlist\"]) == [[0, 1, 2]]\n", "\nassert group_anagrams([\"a\", \"b\", \"c\", \"d\"]) == [[0], [1], [2], [3]]\n", "\nassert group_anagrams([\"abc\", \"cab\", \"bca\", \"xyz\", \"zyx... |
15c804ec505953c723adb3fb82c0d0a0 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne peut contenir des caractères spéciaux. Ta tâche est d'écrire une fonction `filter_text` qui traite chaque chaîne pour ne conserver que les caractères alphanumériques et les espaces, en convertissant tous les caractères en minuscules.... | ["\nassert filter_text([\"Hello, World!\"]) == [\"hello world\"]\n", "\nassert filter_text([\"Python3.8\"]) == [\"python38\"]\n", "\nassert filter_text([\"Special#$%Chars\"]) == [\"specialchars\"]\n", "\nassert filter_text([\"12345\"]) == [\"12345\"]\n", "\nassert filter_text([\"NoSpecialCharsHere\"]) == [\"nospecialch... |
0e10027805a2be504806c19047a54903 | [
{
"content": "On te donne trois entiers : `base`, `exponent` et `modulus`. Ta tâche est de calculer le résultat de `base` élevé à la puissance de `exponent`, modulo `modulus`, en utilisant l'algorithme carré et multiplication. L'algorithme doit calculer efficacement le résultat en temps `O(log exponent)`. Si l'... | ["\nassert modular_exponentiation(2, 3, 5) == 3\n", "\nassert modular_exponentiation(5, 3, 13) == 8\n", "\nassert modular_exponentiation(10, 0, 7) == 1\n", "\nassert modular_exponentiation(3, 4, 5) == 1\n", "\nassert modular_exponentiation(7, 256, 13) == 9\n", "\nassert modular_exponentiation(-2, 3, 5) == 2\n", "\nasse... |
907a8fc8836cde3f092e3bb3d2fbd632 | [
{
"content": "On te donne une liste triée d'entiers et un entier cible. Ta tâche est de mettre en œuvre une fonction qui effectue une recherche binaire pour trouver l'entier cible dans la liste. Si l'entier cible est trouvé, retourne son index ; sinon, retourne `-1`.\n\n**Entrée :**\n- Le premier argument est u... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([1], 1) == 0\n", "\nassert binary_search(... |
b2f5f4a02b80c83318ad99b34d5d000a | [
{
"content": "On te donne une liste de chaînes de caractères, chacune représentant un nom de classe pleinement qualifié dans un langage de programmation hypothétique. Un nom de classe pleinement qualifié se compose d'un espace de noms et d'un nom de classe, séparés par deux-points (:). Par exemple, \"espaceDeNo... | ["\nassert organize_classes([\"com.example:class1\"]) == {\"com.example\": [\"1ssalc\"]}\n", "\nassert organize_classes([\"com.example:class1\", \"com.example:class2\"]) == {\"com.example\": [\"1ssalc\", \"2ssalc\"]}\n", "\nassert organize_classes([\"org.test:sampleClass\", \"org.test:anotherClass\"]) == {\"org.test\":... |
9f78b541ca47fb29ecae178a983a6f76 | [
{
"content": "On te demande de développer un programme pour un organisateur de festival de musique. Le festival propose deux scènes, chacune avec son propre programme de groupes musicaux. Chaque programme est représenté comme une liste d'entiers, où chaque entier correspond à un groupe musical unique.\n\nTon ob... | ["\nassert can_group_perform_today(1, [1, 2, 3], [2, 1, 3]) == False\n", "\nassert can_group_perform_today(1, [1, 2, 3], [3, 2, 1]) == False\n", "\nassert can_group_perform_today(1, [1, 2, 3], [2, 3, 1]) == True\n", "\nassert can_group_perform_today(1, [1, 2, 3, 4], [2, 3, 4, 1]) == True\n", "\nassert can_group_perform... |
6949a8401235f221d8b96e8f5b97f537 | [
{
"content": "On te demande d'implémenter une fonction `file_encrypt` pour un système de chiffrement de fichiers sécurisé. La fonction doit prendre deux paramètres : `filename` (une chaîne de caractères représentant le chemin d'accès au fichier) et `secret_key` (un objet bytes représentant la clé de chiffrement... | ["\nassert file_encrypt(\"testfile1.bin\", b'\\x00') == b'\\x00' * len(open(\"testfile1.bin\", 'rb').read())\n", "\nassert file_encrypt(\"testfile2.bin\", b'\\xff') == bytes([(byte * 251 + 255) % 256 for byte in open(\"testfile2.bin\", 'rb').read()])\n", "\nassert file_encrypt(\"testfile3.bin\", b'\\x01') == bytes([(by... |
59dea8a3007315f9b108b2016b001cda | [
{
"content": "On te donne un arbre binaire où chaque nœud contient une valeur entière. Ta tâche est d'effectuer un parcours en ordre de spirale de l'arbre et de renvoyer le résultat sous forme de liste de listes. Le parcours doit commencer à partir du nœud racine et alterner la direction du parcours à chaque ni... | ["\nassert spiralLevelOrder(TreeNode(1)) == [[1]]\n", "\nassert spiralLevelOrder(TreeNode(1, TreeNode(2), TreeNode(3))) == [[1], [3, 2]]\n", "\nassert spiralLevelOrder(TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7)))) == [[1], [3, 2], [4, 5, 6, 7]]\n", "\nassert spiralLevelOrder... |
686bd7c34b04b2771d53110c961d5753 | [
{
"content": "On te donne une liste de chaînes de temps au format \"HH:MM:SS:ms\", où HH représente les heures, MM les minutes, SS les secondes et ms les millisecondes. Ta tâche est d'écrire une fonction qui convertit chaque chaîne de temps en nombre total de secondes écoulées depuis minuit (00:00:00:00). La fo... | ["\nassert convert_time_to_seconds([\"00:00:00:00\"]) == [0]\n", "\nassert convert_time_to_seconds([\"00:00:01:000\"]) == [1]\n", "\nassert convert_time_to_seconds([\"00:00:00:500\"]) == [1]\n", "\nassert convert_time_to_seconds([\"00:01:00:000\"]) == [60]\n", "\nassert convert_time_to_seconds([\"01:00:00:000\"]) == [3... |
faa7d105ae8feb48781ba81c44b134a9 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui calcule le produit de tous les éléments uniques de la liste. La fonction doit gérer les listes contenant jusqu'à 10^5 éléments, où chaque élément est un entier compris entre -10^9 et 10^9.\n\n**Exemple d'entrée :**\n```\n[... | ["\nassert product_of_unique_elements([1, 2, 3, 4, 5]) == 120\n", "\nassert product_of_unique_elements([2, 3, 4, 2, 4, 5]) == 120\n", "\nassert product_of_unique_elements([1, 1, 1, 1, 1]) == 1\n", "\nassert product_of_unique_elements([0, 1, 2, 3]) == 0\n", "\nassert product_of_unique_elements([-1, -2, -3, -4]) == -24\n... |
02c1e522e38a27d55eda2e2353bc14d3 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si la chaîne est un palindrome, en ignorant les espaces, la ponctuation et la casse. Une chaîne est considérée comme un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :**\n- Une... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Hello, World!\") == False\n", "\nassert is... |
3b2b0ab1b1cc448c4be3eadcee7817ae | [
{
"content": "On te donne une chaîne de caractères `text` et un entier `k`. Ta tâche est de trouver toutes les sous-chaînes les plus courantes de longueur `k` dans le texte. Les sous-chaînes doivent être insensibles à la casse et ne doivent inclure aucun signe de ponctuation. S'il y a plusieurs sous-chaînes ave... | ["\nassert most_common_substrings(\"abcabcabc\", 3) == {'abc': 3}\n", "\nassert most_common_substrings(\"hello world\", 2) == {'ll': 2}\n", "\nassert most_common_substrings(\"aabbcc\", 2) == {'aa': 1, 'bb': 1, 'cc': 1}\n", "\nassert most_common_substrings(\"test test test\", 4) == {'test': 3}\n", "\nassert most_common_... |
5a9932abc3d63852db31d7f67ff25808 | [
{
"content": "On te demande d'implémenter une fonction `convert_to_pig_latin` qui traduit une phrase anglaise donnée en Pig Latin. Les règles du Pig Latin sont les suivantes :\n- Pour les mots qui commencent par une consonne ou un groupe de consonnes, déplace le groupe à la fin du mot et ajoute \"ay\".\n- Pour ... | ["\nassert convert_to_pig_latin(\"hello world\") == \"ellohay orldway\"\n", "\nassert convert_to_pig_latin(\"this is a test\") == \"isthay isway away esttay\"\n", "\nassert convert_to_pig_latin(\"apple orange\") == \"appleway organeway\"\n", "\nassert convert_to_pig_latin(\"umbrella\") == \"umbrellaway\"\n", "\nassert ... |
a3640cd782de55943385496d9f6a9163 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui simule des opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Créer un compte bancaire avec le nom du propriétaire et un solde initial facultatif (par défaut, 0,... | ["\nassert BankAccount(\"Alice\").check_balance() == 0.0\n", "\nassert BankAccount(\"Bob\", 100.0).check_balance() == 100.0\n", "\naccount = BankAccount(\"Charlie\", 200.0)\naccount.deposit(100.0)\nassert account.check_balance() == 300.0\n", "\naccount = BankAccount(\"David\", 300.0)\naccount.withdraw(100.0)\nassert ac... |
25bbea826091766d3e3e560c159bc419 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `make` : une chaîne de caractères représentant la marque de la voiture.\n - `model` : une chaîne de caractères représentant le modèle de la voiture.\n - `ye... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).getMake() == \"Toyota\"\n", "\nassert Car(\"Honda\", \"Civic\", 2018, 20000).getModel() == \"Civic\"\n", "\nassert Car(\"Ford\", \"Mustang\", 2021, 5000).getYear() == 2021\n", "\nassert Car(\"Chevrolet\", \"Impala\", 2019, 30000).getMileage() == 30000\n", "\nassert C... |
29fd193f3989fa20cdebdbf29cfee26a | [
{
"content": "On te donne une séquence de transitions provenant d'un épisode dans un environnement de processus de décision markovien (MDP). Chaque transition est représentée comme un tuple contenant l'état actuel, l'action entreprise, la récompense reçue, l'état suivant résultant et un booléen indiquant si l'é... | ["\nassert np.array_equal(update_mdp_model(np.zeros((2, 2, 2, 3)), np.zeros((2, 2, 2, 3)), [(0, 0, 1, 1, False)])[0], np.array([[[[1., 0., 0.], [0., 0., 0.]], [[0., 0., 0.], [0., 0., 0.]]], [[[0., 0., 0.], [0., 0., 0.]], [[0., 0., 0.], [0., 0., 0.]]]]))\n", "\nassert np.array_equal(update_mdp_model(np.zeros((2, 2, 2, 3... |
fc5e0c658a7852ad24ebd9ba94c901a3 | [
{
"content": "On te donne un dictionnaire `dictionary` avec des clés de type chaîne de caractères et des valeurs entières. Implémente une fonction `sort_and_group_items(dictionary)` qui traite le dictionnaire et renvoie un dictionnaire ordonné. Les clés dans le dictionnaire renvoyé doivent être regroupées par l... | ["\nassert sort_and_group_items({'a': 1, 'bb': 2, 'ccc': 3}) == OrderedDict([(1, 1), (2, 2), (3, 3)])\n", "\nassert sort_and_group_items({'abc': 3, 'de': 5, 'f': 7, 'ghij': 2, 'klmno': 1, '123': 4, 'pqrs': 8, 't': 6, 'uvwxy': 10}) == OrderedDict([(1, 13), (2, 5), (3, 3), (4, 8), (5, 10)])\n", "\nassert sort_and_group_i... |
a71215296824bc1c91877722c39d7eae | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif `n`. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. La factorielle de 0 est définie comme étant 1.\n\n**Entrée :**\n- La premiè... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(2) == 2\n", "\nassert factorial(3) == 6\n", "\nassert factorial(4) == 24\n", "\nassert factorial(5) == 120\n", "\nassert factorial(6) == 720\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factor... |
c580c14f1efadfc07c207214a00d1018 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `find_max` qui renvoie l'entier maximal de la liste. La fonction doit gérer les listes contenant au moins un entier.\n\n**Exemple d'entrée :**\n```\n[-3, -5, -1, -8, -2]\n```\n\n**Exemple de sortie :**\n```\n-1\n```\n\nLa fonction... | ["\nassert find_max([1, 2, 3, 4, 5]) == 5\n", "\nassert find_max([-10, -20, -3, -4, -5]) == -3\n", "\nassert find_max([100]) == 100\n", "\nassert find_max([0, 0, 0, 0]) == 0\n", "\nassert find_max([5, 4, 3, 2, 1]) == 5\n", "\nassert find_max([10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) == 100\n", "\nassert find_max([-1, ... |
fd2b838367e425066902c386c3ee9973 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui renvoie le deuxième plus grand nombre unique de la liste. S'il y a moins de deux nombres uniques, la fonction doit renvoyer `None`.\n\n**Exemple d'entrée :**\n```\n[4, 3, 1, 2, 5, 5, 4]\n```\n\n**Exemple de sortie :... | ["\nassert second_largest_unique([1, 2, 3, 4, 5]) == 4\n", "\nassert second_largest_unique([5, 5, 5, 5, 5]) == None\n", "\nassert second_largest_unique([10, 20]) == 10\n", "\nassert second_largest_unique([1]) == None\n", "\nassert second_largest_unique([2, 2, 3, 3, 4, 4, 5, 5]) == 4\n", "\nassert second_largest_unique(... |
46fe9a7af30579190303f4cbc7dee464 | [
{
"content": "On te demande d'implémenter une fonction `analyze_sentiment` qui évalue le sentiment d'une chaîne de texte donnée. Utilise la bibliothèque TextBlob pour calculer un score de sentiment, qui doit être un nombre à virgule flottante compris entre -1,0 et 1,0. Un score de -1,0 signifie un sentiment ext... | ["\nassert analyze_sentiment(\"I love sunny days!\") == 1.0\n", "\nassert analyze_sentiment(\"This is the worst experience ever.\") == -1.0\n", "\nassert analyze_sentiment(\"It's okay, not great but not bad.\") == 0.0\n", "\nassert analyze_sentiment(\"Absolutely fantastic!\") == 1.0\n", "\nassert analyze_sentiment(\"Te... |
7cb6c4b4d5893a79bddf9d05843263af | [
{
"content": "On te donne une liste de chaînes de caractères et un entier seuil. Ta tâche est de mettre en œuvre une fonction qui filtre toutes les chaînes dont la longueur est inférieure ou égale au seuil. La fonction doit renvoyer une nouvelle liste contenant uniquement les chaînes qui satisfont à l'exigence ... | ["\nassert filter_strings_by_length([\"apple\", \"banana\", \"cherry\", \"date\", \"fig\", \"grape\"], 5) == [\"banana\", \"cherry\"]\n", "\nassert filter_strings_by_length([\"hello\", \"world\", \"python\", \"code\"], 4) == [\"hello\", \"world\", \"python\"]\n", "\nassert filter_strings_by_length([\"a\", \"ab\", \"abc... |
d4a75ae530f174476476b7b70c5466fa | [
{
"content": "Tu es chargé d'implémenter une fonction `generate_random_matrix(rows, cols)` qui construit une matrice avec `rows` lignes et `cols` colonnes. Chaque élément de la matrice doit être un entier aléatoire compris entre 0 et 9, inclusivement. Utilise le module `random` pour générer ces entiers aléatoir... | ["\nassert len(generate_random_matrix(3, 4)) == 3\n", "\nassert all(len(row) == 4 for row in generate_random_matrix(3, 4))\n", "\nassert all(0 <= num <= 9 for row in generate_random_matrix(3, 4) for num in row)\n", "\nassert generate_random_matrix(0, 5) == []\n", "\nassert generate_random_matrix(5, 0) == [[], [], [], [... |
db4791a8da8c00909ad7fbd63495959f | [
{
"content": "On te donne une liste d'entrées de journal sous forme de chaînes de caractères. Chaque entrée de journal commence par un niveau de journal suivi d'un deux-points et d'un message. Les niveaux de journal sont \"INFO\", \"WARNING\", \"ERROR\" et \"CRITICAL\". Ta tâche est d'écrire une fonction `parse... | ["\nassert parse_logs([\"INFO: System started\", \"ERROR: Failed to connect to database\", \"WARNING: Low disk space\", \"ERROR: Failed to connect to database\", \"INFO: User logged in\", \"CRITICAL\"]) == {\"INFO\": 2, \"WARNING\": 1, \"ERROR\": 2, \"CRITICAL\": 1}\n", "\nassert parse_logs([\"INFO: System started\", \... |
1fb9e12c4ec33bbbcb32f601270b512e | [
{
"content": "On te donne deux entiers `a` et `b`. Ta tâche est de générer tous les triplets pythagoriciens uniques `(x, y, z)` tels que `x^2 + y^2 = z^2` et `x <= a`, `y <= b`. Les triplets doivent être triés par ordre croissant d'abord par `x`, puis par `y`, et enfin par `z`.\n\n**Entrée :**\n- Deux entiers `... | ["\nassert generate_pythagorean_triples(3, 4) == [(3, 4, 5)]\n", "\nassert generate_pythagorean_triples(5, 12) == [(3, 4, 5), (5, 12, 13)]\n", "\nassert generate_pythagorean_triples(10, 10) == [(6, 8, 10)]\n", "\nassert generate_pythagorean_triples(15, 15) == [(9, 12, 15)]\n", "\nassert generate_pythagorean_triples(20,... |
d284af034fe4adec50e09eea0184c712 | [
{
"content": "On te donne un tableau de fréquences représenté comme une liste d'entiers. Ce tableau a M lignes et N colonnes, où chaque cellule contient la fréquence d'occurrence d'un événement dans une catégorie spécifique. Les N premiers entiers correspondent aux fréquences des événements dans la première cat... | ["\nassert calculate_expected_frequencies([34, 4567, 16356, 34985737]) == [2.15417057091995, 4598.84582942908, 16387.84582942908, 34985705.15417057]\n", "\nassert calculate_expected_frequencies([1, 1, 1, 1]) == [0.5, 0.5, 0.5, 0.5]\n", "\nassert calculate_expected_frequencies([10, 20, 30, 40]) == [8.333333333333334, 16... |
91fae2a78e5c79cf049d90d352c08576 | [
{
"content": "On te donne deux chaînes de caractères, `inline` et `equation`, représentant des expressions mathématiques. La chaîne `inline` contient des expressions destinées à être affichées en ligne avec du texte, tandis que la chaîne `equation` contient des expressions destinées à être affichées comme des é... | ["\nassert resolve_expression_precedence(\"$a + b$\", \"$$x = y + z$$\") == 2\n", "\nassert resolve_expression_precedence(\"$$a + b$$\", \"$x = y + z$\") == 2\n", "\nassert resolve_expression_precedence(\"$a + b$\", \"$x = y + z$\") == 1\n", "\nassert resolve_expression_precedence(\"$$a + b + c + d$$\", \"$x = y + z$\"... |
5c359a6e2abdc2790207fbc4ae216515 | [
{
"content": "Tu développes un outil de visualisation météo qui doit ajuster dynamiquement la couleur affichée en fonction de la température actuelle. Étant donné une température en Celsius et six seuils de température distincts, chacun associé à une couleur spécifique, ta tâche est de déterminer la couleur app... | ["\nassert temperature_color(10, 0, 15, 20, 25, 30, 35, \"blue\", \"green\", \"yellow\", \"orange\", \"red\", \"purple\") == \"green\"\n", "\nassert temperature_color(5, 0, 15, 20, 25, 30, 35, \"blue\", \"green\", \"yellow\", \"orange\", \"red\", \"purple\") == \"blue\"\n", "\nassert temperature_color(20, 0, 15, 20, 25... |
5656b417ff55e067fdc4f4a2510c4801 | [
{
"content": "On te donne une chaîne de caractères `text` composée de lettres minuscules et de chiffres, ainsi qu'une liste d'entiers `windows`. Ta tâche est de mettre en œuvre une fonction `word_segmenter` qui traite la chaîne de caractères selon les règles suivantes :\n\n1. Pour chaque entier `w` dans `window... | ["\nassert word_segmenter(\"abcabc\", [2, 3]) == []\n", "\nassert word_segmenter(\"aabbcc\", [1, 2]) == []\n", "\nassert word_segmenter(\"abc\", [1, 2, 3]) == ['a', 'b', 'c', 'ab', 'bc', 'abc']\n", "\nassert word_segmenter(\"aabb\", [1, 2]) == ['a', 'b', 'aa', 'bb']\n", "\nassert word_segmenter(\"abcde\", [3, 5]) == ['... |
51a1496dc07c94ee27add26e1fe9f054 | [
{
"content": "On te demande de créer une fonction pour générer un graphe connexe aléatoire avec un nombre spécifié de nœuds et d'arêtes. Le graphe doit être représenté sous forme de liste d'adjacence. Assure-toi que le graphe est connexe, ce qui signifie qu'il existe un chemin entre deux nœuds quelconques. Ta f... | ["\nassert len(generate_random_connected_graph(5, 4)) == 5\n", "\nassert len(generate_random_connected_graph(5, 9)) == 5\n", "\nassert len(generate_random_connected_graph(1, 0)) == 1\n", "\nassert len(generate_random_connected_graph(10, 15)[0]) <= 9\n", "\nassert len(generate_random_connected_graph(10, 15)[9]) <= 9\n",... |
bb3c974b0c287449c62f5d5487f69964 | [
{
"content": "On te donne un arbre de recherche binaire (BST) et un nœud `z` dans l'arbre. Implémente une fonction pour effectuer une rotation gauche sur le sous-arbre enraciné à `z`. La fonction doit renvoyer la nouvelle racine du sous-arbre après la rotation. Suppose que `z` a un enfant droit.\n\n**Entrée :**... | ["\nassert left_rotate(TreeNode(1)).val == 1\n", "\nassert left_rotate(TreeNode(1, TreeNode(2))).val == 1\n", "\nassert left_rotate(TreeNode(1, None, TreeNode(2))).val == 2\n", "\nassert left_rotate(TreeNode(1, None, TreeNode(2, TreeNode(3)))).val == 2\n", "\nassert left_rotate(TreeNode(1, None, TreeNode(2, TreeNode(3)... |
9fa9a0b7038a8d9fc643f697bf678576 | [
{
"content": "On te demande d'implémenter une fonction `gen_fizzbuzz_str_v2(num)` qui prend un entier `num` en entrée et renvoie une chaîne de caractères. La chaîne doit contenir les nombres de 1 à `num` (inclus) si `num` est positif, ou de `num` à -1 (inclus) si `num` est négatif. Pour les multiples de 3, le n... | ["\nassert gen_fizzbuzz_str_v2(1) == \"1\"\n", "\nassert gen_fizzbuzz_str_v2(3) == \"1,2,Fizz\"\n", "\nassert gen_fizzbuzz_str_v2(5) == \"1,2,Fizz,4,Buzz\"\n", "\nassert gen_fizzbuzz_str_v2(15) == \"1,2,Fizz,4,Buzz,Fizz,7,8,Fizz,Buzz,11,Fizz,13,14,FizzBuzz\"\n", "\nassert gen_fizzbuzz_str_v2(-1) == \"-1\"\n", "\nassert... |
76a64d74dd5908e335392b65ce242a6d | [
{
"content": "On te donne un fichier CSV nommé `grades.csv` contenant les notes des élèves. Le fichier a les colonnes suivantes : `student_id`, `name`, `grade1`, `grade2`, `grade3`, `grade4`. Ta tâche est d'écrire un programme qui lit ce fichier et calcule la moyenne des notes de chaque élève. Le programme doit... | ["\nassert calculate_average([85, 90, 78, 92]) == 86.25\n", "\nassert calculate_average([100, 100, 100, 100]) == 100.0\n", "\nassert calculate_average([50, 60, 70, 80]) == 65.0\n", "\nassert calculate_average([0, 0, 0, 0]) == 0.0\n", "\nassert calculate_average([95, 85, 75, 65]) == 80.0\n", "\nassert calculate_average(... |
67fd5b747cfc6663972bc5ee923251fc | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est d'écrire une fonction `elementwise_product` qui calcule le produit élément par élément de ces deux listes. La fonction doit renvoyer une nouvelle liste contenant uniquement les produits qui sont des nombres premiers. Si les longue... | ["\nassert elementwise_product([2, 3, 5], [3, 1, 1]) == None\n", "\nassert elementwise_product([2, 3, 5], [3, 1, 2]) == None\n", "\nassert elementwise_product([2, 3, 5], [3, 1, 3]) == [6, 3, 15]\n", "\nassert elementwise_product([2, 3, 5], [3, 1, 5]) == None\n", "\nassert elementwise_product([2, 3, 5], [3, 1, 7]) == No... |
62140176c30366f244f6ffb66380a6e6 | [
{
"content": "On te donne un dictionnaire `salaries` où les clés sont les noms des employés (chaînes de caractères) et les valeurs sont leurs salaires respectifs (entiers). Ta tâche est de mettre en œuvre une fonction `top_three_employees` qui renvoie une liste des noms des 3 employés les mieux payés. S'il y a ... | ["\nassert top_three_employees({\"John\": 50000, \"Jane\": 60000, \"Alice\": 55000, \"Bob\": 45000, \"Charlie\": 70000}) == [\"Charlie\", \"Jane\", \"Alice\"]\n", "\nassert top_three_employees({\"Alice\": 100000, \"Bob\": 100000, \"Charlie\": 100000, \"David\": 90000}) == [\"Alice\", \"Bob\", \"Charlie\"]\n", "\nassert... |
48cf653b090188a7304e0a89b4748cdc | [
{
"content": "On te donne une liste d'entiers positifs `candidates` et un entier cible `target`. Ta tâche est de trouver toutes les combinaisons uniques dans `candidates` où les nombres candidats additionnés donnent `target`. Le même nombre candidat peut être choisi dans `candidates` un nombre illimité de fois.... | ["\nassert combination_sum([2, 3, 6, 7], 7) == [[2, 2, 3], [7]]\n", "\nassert combination_sum([2, 3, 5], 8) == [[2, 2, 2, 2], [2, 3, 3], [3, 5]]\n", "\nassert combination_sum([2], 1) == []\n", "\nassert combination_sum([1], 1) == [[1]]\n", "\nassert combination_sum([1], 2) == [[1, 1]]\n", "\nassert combination_sum([3, ... |
2aeac4e60013c49569480a76b20b1a0f | [
{
"content": "On te donne la racine d'un arbre de recherche binaire (BST) et une valeur cible `target`. Ta tâche est de trouver dans le BST la valeur la plus proche de la cible. Le BST contient des valeurs uniques. Écris une fonction `closest_value` qui renvoie la valeur la plus proche en tant qu'entier.\n\n**E... | ["\nassert closest_value(TreeNode(4, TreeNode(2), TreeNode(5)), 3.7) == 4\n", "\nassert closest_value(TreeNode(4, TreeNode(2), TreeNode(5)), 2.5) == 2\n", "\nassert closest_value(TreeNode(4, TreeNode(2), TreeNode(5)), 5.1) == 5\n", "\nassert closest_value(TreeNode(4, TreeNode(2), TreeNode(5)), 1.9) == 2\n", "\nassert c... |
019efa0e481b88c40410a4d113837c26 | [
{
"content": "On te donne une chaîne de caractères `text` contenant un mélange de caractères alphanumériques, de symboles et d'espaces. Ta tâche est de mettre en œuvre une fonction `extract_numbers_from_text(text: str) -> str` qui extrait tous les nombres autonomes de la chaîne et les renvoie concaténés sous fo... | ["\nassert extract_numbers_from_text(\"The cost of the item is $12.99, but with a 10% discount, it will be $11.69.\") == \"121011\"\n", "\nassert extract_numbers_from_text(\"abc123def456\") == \"\"\n", "\nassert extract_numbers_from_text(\"123 456 789\") == \"123456789\"\n", "\nassert extract_numbers_from_text(\"no num... |
918737958d923301f6b480a3cdc8a3a7 | [
{
"content": "Tu développes un système pour calculer le coût total des avantages sociaux pour les nouveaux employés en fonction de leur salaire annuel. Le package d'avantages sociaux comprend l'assurance maladie, les cotisations de retraite et les congés payés. L'entreprise propose différents niveaux d'avantage... | ["\nassert calculate_benefits(30000) == 7700\n", "\nassert calculate_benefits(40000) == 7700\n", "\nassert calculate_benefits(50000) == 10200\n", "\nassert calculate_benefits(67345) == 14405.5\n", "\nassert calculate_benefits(67346) == 14405.53\n", "\nassert calculate_benefits(100000) == 20800\n", "\nassert calculate_b... |
ba9e2e16be644548dc2e647e43f22bc0 | [
{
"content": "Dans ce problème, tu dois implémenter une fonction qui calcule le nième nombre de Fibonacci en utilisant une approche récursive. La séquence de Fibonacci est définie comme suit :\n- `fibonacci(0)` doit renvoyer 0.\n- `fibonacci(1)` doit renvoyer 1.\n- Pour tout `n > 1`, `fibonacci(n)` doit renvoye... | ["\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(6) == 8\n", "\nassert fibonacci(7) == 13\n", "\nassert fibonacci(8) == 21\n", "\nassert fibonacci(9) == 34\... |
846044751bcda2d162b1badade2cdb4f | [
{
"content": "Tu participes à un concours de programmation où l'on te donne une liste de tuples, `params`. Chaque tuple est composé d'un nom de paramètre (une chaîne de caractères) et de sa valeur correspondante (qui peut être de n'importe quel type de données). Ta tâche est de mettre en œuvre la fonction `conv... | ["\nassert convert_parameters([(\"name\", \"Alice\"), (\"age\", 30)]) == {\"name\": \"Alice\", \"age\": \"30\"}\n", "\nassert convert_parameters([(\"height\", 5.9), (\"weight\", 150)]) == {\"height\": \"5.9\", \"weight\": \"150\"}\n", "\nassert convert_parameters([(\"is_student\", True), (\"is_employee\", False)]) == {... |
10e7a44f8aa891121ffd10207bc985af | [
{
"content": "On te donne un fichier CSV contenant des données de ventes. Ta tâche est d'écrire une fonction Python qui lit ce fichier et calcule la somme de toutes les valeurs numériques dans une colonne spécifiée. Si une valeur non numérique est rencontrée, la fonction doit afficher un message d'avertissement... | ["\nassert sum_column_values('test.csv', 'amount') == 150.0\n", "\nassert sum_column_values('test.csv', 'quantity') == 10\n", "\nassert sum_column_values('test.csv', 'price') == 15.0\n", "\nassert sum_column_values('test.csv', 'non_existent_column') == 0.0\n", "\nassert sum_column_values('empty.csv', 'amount') == 0.0\n... |
45c4693674e8cd053420373f56ac83c6 | [
{
"content": "On te donne un objet JSON en entrée. Ta tâche est d'écrire une fonction Python `format_json_data` qui renvoie une chaîne JSON formatée avec une indentation de 4 espaces et des clés triées. La fonction doit être capable de gérer tout objet JSON valide, y compris les objets et les tableaux imbriqués... | ["\nassert format_json_data({\"name\": \"John\", \"age\": 30}) == '{\\n \"age\": 30,\\n \"name\": \"John\"\\n}'\n", "\nassert format_json_data([{\"name\": \"Alice\"}, {\"name\": \"Bob\"}]) == '[\\n {\\n \"name\": \"Alice\"\\n },\\n {\\n \"name\": \"Bob\"\\n }\\n]'\n", "\nassert format_js... |
116f0ddb90f6b8a50bf875cf0cb66082 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `limit`. Ta tâche est de trouver tous les entiers compris entre 1 et `limit` (inclus) qui sont des multiples de tous les nombres de la liste `numbers` et qui sont également des palindromes. Un nombre est un palindrome s'il se lit de la même ma... | ["\nassert find_common_multiples([2, 3], 20) == [6, 12, 18]\n", "\nassert find_common_multiples([2, 3], 30) == [6, 12, 18, 24]\n", "\nassert find_common_multiples([5, 10], 100) == [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n", "\nassert find_common_multiples([5, 10], 50) == [10, 20, 30, 40, 50]\n", "\nassert find_common... |
72866bf317e96e00db2b63caf7b64713 | [
{
"content": "On te demande d'implémenter une fonction `calculate_area` qui calcule l'aire d'une forme géométrique donnée en fonction de son nom et de ses dimensions. La fonction doit gérer les formes suivantes :\n\n- **Cercle** : Nécessite un paramètre, le rayon.\n- **Rectangle** : Nécessite deux paramètres, l... | ["\nassert calculate_area(\"circle\", 5) == math.pi * 5 * 5\n", "\nassert calculate_area(\"rectangle\", 3, 4) == 12\n", "\nassert calculate_area(\"triangle\", 5, 10) == 25\n", "\nassert calculate_area(\"circle\", 0) == 0\n", "\nassert calculate_area(\"rectangle\", 0, 10) == 0\n", "\nassert calculate_area(\"triangle\", ... |
740c8e4b2218df68ffac1ed7c53bc0a7 | [
{
"content": "On te demande d'implémenter une fonction `parse_json` qui traite une chaîne JSON et renvoie un dictionnaire représentant les données analysées. Si la chaîne JSON est mal formée, la fonction doit gérer l'erreur avec élégance et renvoyer un dictionnaire vide. Ta fonction sera testée avec diverses en... | ["\nassert parse_json('{\"name\": \"John\", \"age\": 30}') == {\"name\": \"John\", \"age\": 30}\n", "\nassert parse_json('{\"key\": \"value\", \"number\": 42}') == {\"key\": \"value\", \"number\": 42}\n", "\nassert parse_json('{\"nested\": {\"key\": \"value\"}}') == {\"nested\": {\"key\": \"value\"}}\n", "\nassert pars... |
ca1feff5cfedf230d39510142ac75adb | [
{
"content": "Tu développes un système de sécurité réseau qui analyse les paquets de données interceptés. Ta tâche est d'implémenter une fonction `check_packet` qui détermine si une `constraint` donnée apparaît dans un `packet` dans le bon ordre, même s'il y a un nombre quelconque d'octets intermédiaires entre ... | ["\nassert check_packet(b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09', b'\\x01\\x03\\x07') == True\n", "\nassert check_packet(b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09', b'\\x09\\x08\\x07') == False\n", "\nassert check_packet(b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09', b'\\x00\\x01\\x02\\x... |
efb93c6ee80fcc963087ade2137f16cf | [
{
"content": "On te donne un chemin de répertoire. Ta tâche est d'écrire une fonction `find_duplicate_files` qui identifie tous les fichiers avec un contenu identique dans le répertoire et ses sous-répertoires. La fonction doit renvoyer une liste de chemins de fichiers qui ont des doublons. La comparaison doit ... | ["\nassert find_duplicate_files(\"/path/to/empty/dir\") == []\n", "\nassert find_duplicate_files(\"/path/to/dir/with/one/file\") == []\n", "\nassert find_duplicate_files(\"/path/to/dir/with/two/identical/files\") == [\"/path/to/dir/with/two/identical/files/file1.txt\", \"/path/to/dir/with/two/identical/files/file2.txt\... |
afba2f3005b43e729246e9c671fa27bc | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target`. Ta tâche est de trouver tous les sous-ensembles consécutifs de `numbers` qui totalisent `target`. Chaque sous-ensemble doit contenir au moins deux éléments et doit être constitué d'éléments consécutifs de la liste originale. De plus,... | ["\nassert find_consecutive_subsets([1, 2, 3, 4, 5], 9) == [[2, 3, 4]]\n", "\nassert find_consecutive_subsets([1, 2, 3, 4, 5], 6) == [[2, 3, 1]]\n", "\nassert find_consecutive_subsets([1, 2, 3, 4, 5], 12) == [[3, 4, 5]]\n", "\nassert find_consecutive_subsets([1, 2, 3, 4, 5], 15) == [[1, 2, 3, 4, 5]]\n", "\nassert find_... |
260e7486a60c36f047a402dc2053f02b | [
{
"content": "On te demande d'implémenter une fonction `calculate_harmonic_mean` qui calcule la moyenne harmonique d'une liste de nombres donnée. La moyenne harmonique est définie comme le nombre de valeurs `n` divisé par la somme des inverses des valeurs. Ta fonction doit respecter les contraintes suivantes :\... | ["\nassert calculate_average([1, 2, 3, 4, 5]) == 2.5\n", "\nassert calculate_average([2, 4, 4, 4, 5, 5, 7, 9]) == 4.75\n", "\nassert calculate_average([1.5, 3.5, 2.5]) == 2.1666666666666665\n", "\nassert calculate_average([10]) == 10.0\n", "\nassert calculate_average([1, 1, 1, 1, 1]) == 1.0\n", "\nassert calculate_aver... |
547f0e3b5dc9f3c26a8667ab4ce05efb | [
{
"content": "On te donne un entier `total_seconds` représentant le nombre total de secondes. Ta tâche est d'écrire une fonction `convert_seconds_to_time` qui convertit cet entier en une chaîne de caractères représentant l'heure, formatée comme `HH:MM:SS`. Si `total_seconds` est négatif, la sortie doit être au ... | ["\nassert convert_seconds_to_time(3661) == \"01:01:01\"\n", "\nassert convert_seconds_to_time(7200) == \"02:00:00\"\n", "\nassert convert_seconds_to_time(45) == \"00:00:45\"\n", "\nassert convert_seconds_to_time(0) == \"00:00:00\"\n", "\nassert convert_seconds_to_time(3600) == \"01:00:00\"\n", "\nassert convert_second... |
0e0032fc7591f41692cf19f782b2f4f8 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction qui renvoie le nième nombre de Fibonacci. La suite de Fibonacci est définie comme suit : F(1) = 0, F(2) = 1, et F(n) = F(n-1) + F(n-2) pour n > 2.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 50).\n\n**Sortie :**\n- Un seul en... | ["\nassert fibonacci(1) == 0\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 1\n", "\nassert fibonacci(4) == 2\n", "\nassert fibonacci(5) == 3\n", "\nassert fibonacci(6) == 5\n", "\nassert fibonacci(7) == 8\n", "\nassert fibonacci(8) == 13\n", "\nassert fibonacci(9) == 21\n", "\nassert fibonacci(10) == 34... |
1b6791950e69d701027885987667cc37 | [
{
"content": "On te demande d'implémenter une classe `Vector2D` en Python qui représente un vecteur bidimensionnel. La classe doit prendre en charge les opérations suivantes :\n\n- **Initialisation** : Créer un vecteur avec des composantes x et y données.\n- **Addition** : Additionner deux vecteurs.\n- **Soustr... | ["\nassert str(Vector2D(1, 2)) == \"(1, 2)\"\n", "\nassert str(Vector2D(0, 0)) == \"(0, 0)\"\n", "\nassert str(Vector2D(-1, -2)) == \"(-1, -2)\"\n", "\nassert abs(Vector2D(3, 4)) == 5.0\n", "\nassert abs(Vector2D(0, 0)) == 0.0\n", "\nassert abs(Vector2D(-3, 4)) == 5.0\n", "\nassert Vector2D(1, 2) + Vector2D(3, 4) == Ve... |
b4696b3dfee53d2d67d74ec74312e51b | [
{
"content": "On te donne une liste d'entiers représentant des chiffres binaires dans l'ordre inverse (bit de poids faible en premier). Ta tâche est d'implémenter une fonction `binaryToDecimal` qui convertit cette liste en son équivalent décimal. La fonction doit ignorer tous les chiffres non binaires (c'est-à-... | ["\nassert binaryToDecimal([1, 0, 1]) == 5\n", "\nassert binaryToDecimal([1, 1, 1, 1]) == 15\n", "\nassert binaryToDecimal([0, 0, 0, 0]) == 0\n", "\nassert binaryToDecimal([1, 0, 0, 1, 0]) == 18\n", "\nassert binaryToDecimal([2, 3, 4, 5]) == None\n", "\nassert binaryToDecimal([1, 2, 0, 1, 3]) == 5\n", "\nassert binaryT... |
732a48a9a1804fab27b2cb9eb82eddaa | [
{
"content": "On te demande d'implémenter une fonction `generate_unique_id()` qui génère un identifiant unique pour chaque appel. La fonction doit renvoyer une chaîne de caractères formatée comme un UUID (Universally Unique Identifier) valide. Utilise le module `uuid` de la bibliothèque standard de Python pour ... | ["\nassert isinstance(generate_unique_id(), str)\n", "\nassert len(generate_unique_id()) == 36\n", "\nassert generate_unique_id() != generate_unique_id()\n", "\nassert generate_unique_id().count('-') == 4\n", "\nassert all(c in '0123456789abcdef-' for c in generate_unique_id())\n", "\nassert generate_unique_id().split(... |
2109f80f62f04a3a2fe2595e26066ec0 | [
{
"content": "On te donne un fichier texte nommé `input.txt`. Ta tâche est d'écrire un script Python qui lit le fichier, calcule la fréquence de chaque mot tout en ignorant les mots vides courants de l'anglais et la ponctuation, et affiche les 10 mots les plus fréquents ainsi que leurs fréquences. La comparaiso... | ["\nassert get_top_words(\"empty.txt\") == []\n", "\nassert get_top_words(\"single_word.txt\") == []\n", "\nassert get_top_words(\"stopwords_only.txt\") == []\n", "\nassert get_top_words(\"one_common_word.txt\") == [('example', 1)]\n", "\nassert get_top_words(\"two_common_words.txt\") == [('example', 2), ('test', 2)]\n... |
ea43f31ef60c7c1ee8459a348b451cae | [
{
"content": "Tu es chargé de développer une API REST simple utilisant Flask pour gérer une collection de livres. L'API doit prendre en charge les opérations suivantes :\n\n1. **Récupérer tous les livres** : `GET /books`\n - **Réponse** : Un objet JSON contenant une liste de tous les livres.\n\n2. **Ajouter u... | ["\nassert get_books().json == {'books': [{'id': 1, 'title': '1984', 'author': 'George Orwell'}, {'id': 2, 'title': 'The Great Gatsby', 'author': 'F. Scott Fitzgerald'}, {'id': 3, 'title': 'To Kill a Mockingbird', 'author': 'Harper Lee'}]}\n", "\nassert create_book().json == {'id': 4, 'title': 'New Book', 'author': 'Ne... |
42b57b52bc3ac3d48f0b60f829d90776 | [
{
"content": "Tu participes à un concours de conception de réseaux neuronaux et tu dois implémenter une fonction d'activation unique appelée « Custom Leaky Squared ReLU ». Cette fonction doit présenter le comportement suivant :\n\n- Pour toute valeur d'entrée \\( x \\) supérieure à 0, la fonction doit renvoyer ... | ["\nassert custom_leaky_squared_relu(1.0) == 1.0\n", "\nassert custom_leaky_squared_relu(2.0) == 4.0\n", "\nassert custom_leaky_squared_relu(0.0) == 0.0\n", "\nassert custom_leaky_squared_relu(-1.0) == -abs(math.sin(-1.0))\n", "\nassert custom_leaky_squared_relu(-math.pi/2) == -abs(math.sin(-math.pi/2))\n", "\nassert c... |
0d6eadb62565a5833d8e55d0c9ef3f40 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie le deuxième plus grand nombre unique de la liste. S'il y a moins de deux nombres uniques, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^5), où chaque enti... | ["\nassert second_largest_unique([4, 2, 5, 1, 3]) == 4\n", "\nassert second_largest_unique([7, 7, 7, 7]) == None\n", "\nassert second_largest_unique([10, 20, 20, 10, 30]) == 20\n", "\nassert second_largest_unique([1, 1, 1, 1, 1]) == None\n", "\nassert second_largest_unique([5]) == None\n", "\nassert second_largest_uniq... |
f15b6bd12d1f44f2075bab79609e0046 | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `start`. Ta tâche est de mettre en œuvre une fonction `parse_escaped_string(s, start)` qui analyse une chaîne échappée à partir de `s` en commençant à l'index `start`. La chaîne échappée est encadrée par des guillemets doubles (`\"`) et peut co... | ["\nassert parse_escaped_string('\"hello\"', 0) == ('hello', 7)\n", "\nassert parse_escaped_string('\"hello\\\\\"world\"', 0) == ('hello\"world', 13)\n", "\nassert parse_escaped_string('\"hello\\\\\\\\\"world\"', 0) == ('hello\\\\world', 14)\n", "\nassert parse_escaped_string('\"hello\\\\world\"', 0) == ('hello\\\\worl... |
9bf1fcb8e142c6b8ca266bd07d60cffc | [
{
"content": "On te demande d'implémenter une fonction `_running_mean` qui calcule la moyenne mobile pondérée des valeurs absolues d'une série de tenseurs. Étant donné une liste de tenseurs PyTorch et une liste correspondante de poids non négatifs, ta fonction doit calculer la moyenne mobile en sommant les vale... | ["\nassert torch.allclose(_running_mean([torch.tensor([1.0, 2.0]), torch.tensor([3.0, 4.0])], [1, 1]), torch.tensor([2.0, 3.0]))\n", "\nassert torch.allclose(_running_mean([torch.tensor([1.0, -2.0]), torch.tensor([-3.0, 4.0])], [1, 1]), torch.tensor([2.0, 3.0]))\n", "\nassert torch.allclose(_running_mean([torch.tensor(... |
b9b8b2029fc61a892adeb4525ad2cb17 | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de construire un nouveau tableau `result` tel que `result[i]` soit le produit de tous les éléments de `nums` sauf `nums[i]`. Tu dois résoudre ce problème sans utiliser la division.\n\n**Contraintes :**\n- `2 <= len(nums) <= 10^5`\n- `-30 <= num... | ["\nassert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]\n", "\nassert product_except_self([5, 3, 2, 4, 1]) == [24, 40, 60, 30, 120]\n", "\nassert product_except_self([0, 1, 2, 3]) == [6, 0, 0, 0]\n", "\nassert product_except_self([1, 0, 3, 4]) == [0, 12, 0, 0]\n", "\nassert product_except_self([1, 2, 0, 4]) == [... |
fe6da5d2c13d1aa8a968bf87ad205fd9 | [
{
"content": "On te demande d'implémenter une fonction pour calculer l'aire d'un cercle étant donné son rayon. Ta fonction doit respecter les directives de style PEP 8. La fonction doit prendre un seul nombre à virgule flottante en entrée, représentant le rayon, et renvoyer l'aire du cercle sous forme de nombre... | ["\nassert calculate_area(0) == 0\n", "\nassert calculate_area(1) == 3.141592653589793\n", "\nassert calculate_area(2) == 12.566370614359172\n", "\nassert calculate_area(3.5) == 38.48451000647496\n", "\nassert calculate_area(10) == 314.1592653589793\n", "\nassert calculate_area(100) == 31415.926535897932\n", "\nassert ... |
aed4fd41c9f18bb4adcddab891f6d6d8 | [
{
"content": "On te donne un dictionnaire Python `data` représentant un objet JSON. Ta tâche est de mettre en œuvre une fonction `convert_keys_to_snake_case` qui transforme toutes les clés du dictionnaire au format snake_case. La fonction doit gérer les dictionnaires et les listes imbriqués dans le dictionnaire... | ["\nassert convert_keys_to_snake_case({\"firstName\": \"John\"}) == {\"first_name\": \"John\"}\n", "\nassert convert_keys_to_snake_case({\"lastName\": \"Doe\"}) == {\"last_name\": \"Doe\"}\n", "\nassert convert_keys_to_snake_case({\"birthDate\": \"1990-01-01\"}) == {\"birth_date\": \"1990-01-01\"}\n", "\nassert convert... |
eae816a9be835951cba4f81f485017f7 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui calcule la moyenne des nombres dans la liste. Si la liste est vide, la fonction doit renvoyer `None`. Ta fonction doit être efficace et gérer les cas limites de manière appropriée.\n\n**Entrée :**\n- Une liste d'entiers... | ["\nassert calculate_average([1, 2, 3, 4, 5]) == 3.0\n", "\nassert calculate_average([10, 20, 30]) == 20.0\n", "\nassert calculate_average([5]) == 5.0\n", "\nassert calculate_average([]) == None\n", "\nassert calculate_average([1.5, 2.5, 3.5]) == 2.5\n", "\nassert calculate_average([-1, -2, -3, -4]) == -2.5\n", "\nasse... |
1382c3c4968ff247da1fbedc99307dd4 | [
{
"content": "Dans le jeu Puissance 4, les joueurs cherchent à connecter quatre de leurs disques en ligne, soit verticalement, horizontalement ou en diagonale. Étant donné un plateau 6x7 représenté comme une liste 2D où chaque cellule est soit `None` (vide), soit une chaîne de caractères (couleur du disque du j... | ["\nassert connect_four_win_check([['R', 'R', 'R', 'R', None, None, None], [None, None, None, None, None, None, None], [None, None, None, None, None, None, None], [None, None, None, None, None, None, None], [None, None, None, None, None, None, None], [None, None, None, None, None, None, None]], 'R') == [(0, 0), (0, 1),... |
ca69253e3a34929ceb7c04db145eb30a | [
{
"content": "Tu es chargé d'implémenter une fonction `calculate_volume` pour calculer le volume d'un cylindre. La fonction doit accepter deux paramètres obligatoires : `radius` et `height`, et un paramètre optionnel `base_area`. Si `base_area` n'est pas fourni, il doit par défaut être égal à `math.pi * radius ... | ["\nassert calculate_volume(3, 5) == 141.3716694115407\n", "\nassert calculate_volume(3, 5, 28.274333882308138) == 141.37166941154067\n", "\nassert calculate_volume(0, 5) == 0.0\n", "\nassert calculate_volume(3, 0) == 0.0\n", "\nassert calculate_volume(-3, 5) == None\n", "\nassert calculate_volume(3, -5) == 141.3716694... |
26a9aa04f1fb7c48bde8abc7a763c7f2 | [
{
"content": "On te donne une liste de sous-séquences d'ADN (`strs`) et une séquence d'ADN plus longue (`dna`). Ta tâche est de déterminer le nombre maximum de fois que chaque sous-séquence de `strs` apparaît consécutivement dans `dna`, en veillant à ce que les sous-séquences ne se chevauchent pas.\n\n**Entrée ... | ["\nassert max_consecutive_subsequences(['AT'], 'ATATAT') == [3]\n", "\nassert max_consecutive_subsequences(['CG'], 'CGCGCGCG') == [4]\n", "\nassert max_consecutive_subsequences(['AT', 'CG'], 'ATCGATATCGATATCGAT') == [3, 2]\n", "\nassert max_consecutive_subsequences(['AA', 'BB'], 'AABBAAABBBAABB') == [2, 2]\n", "\nasse... |
720302a21731fcdd0bec224b6fd00a81 | [
{
"content": "Tu participes à un défi de détection d'objets où l'on te fournit un ensemble de données d'images et leurs coordonnées de boîtes englobantes correspondantes. Chaque boîte englobante est définie par quatre entiers [xmin, xmax, ymin, ymax], représentant les coordonnées horizontales et verticales en v... | ["\nassert normalise_bounding_box([10, 20, 30, 40], 100, 100) == [0.1, 0.2, 0.3, 0.4]\n", "\nassert normalise_bounding_box([0, 0, 0, 0], 100, 100) == [0.0, 0.0, 0.0, 0.0]\n", "\nassert normalise_bounding_box([50, 50, 50, 50], 100, 100) == [0.5, 0.5, 0.5, 0.5]\n", "\nassert normalise_bounding_box([100, 200, 150, 250], 2... |
15ecb072986a96719b95309953f75ca5 | [
{
"content": "Tu conçois une nouvelle autoroute et tu dois déterminer le nombre optimal de voies en fonction de contraintes spécifiques. La largeur de l'autoroute peut être ajustée à l'aide d'un multiplicateur, et le nombre de voies doit être un multiple d'un diviseur donné. De plus, il existe un nombre minimum... | ["\nassert calculate_optimal_lanes(0, 5, 2, 10) == 10\n", "\nassert calculate_optimal_lanes(1.5, 5, 2, 10) == 12\n", "\nassert calculate_optimal_lanes(2, 5, 3, 10) == 12\n", "\nassert calculate_optimal_lanes(0.5, 5, 2, 10) == 5\n", "\nassert calculate_optimal_lanes(1, 5, 5, 10) == 10\n", "\nassert calculate_optimal_lan... |
61028d4ceaccdbcdad1220d2691a251a | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `k`. Ta tâche est de déterminer la longueur de la plus longue sous-chaîne de `s` qui peut être exprimée comme une répétition de exactement `k` sous-chaînes consécutives identiques. Par exemple, la sous-chaîne \"aaa\" peut être représentée comme... | ["\nassert longest_substring_with_k_repeats(\"ababababa\", 3) == 6\n", "\nassert longest_substring_with_k_repeats(\"aaaaaa\", 2) == 6\n", "\nassert longest_substring_with_k_repeats(\"abcabcabc\", 3) == 9\n", "\nassert longest_substring_with_k_repeats(\"abcabcabcabc\", 4) == 12\n", "\nassert longest_substring_with_k_rep... |
ad02e1db23c06a334b10c8a82231ffae | [
{
"content": "Tu développes un système de gestion de bibliothèque en utilisant une base de données Redis pour stocker une collection de livres. Chaque livre est identifié de manière unique par un `id` et est associé à un `title`, un `author` et un `genre`. Les livres sont indexés par leurs genres en utilisant d... | ["\nassert get_books_by_genre(redis, 'Fiction') == [{'id': '1', 'title': 'Book A', 'author': 'Author X', 'genre': 'Fiction'}, {'id': '3', 'title': 'Book C', 'author': 'Author X', 'genre': 'Fiction'}]\n", "\nassert get_books_by_genre(redis, 'Non-Fiction') == [{'id': '2', 'title': 'Book B', 'author': 'Author Y', 'genre':... |
07eac1b1407e11483014aeb8a6f2b5a6 | [
{
"content": "Tu développes un système de gestion de réseau et tu dois implémenter une classe nommée `NetworkManager` pour surveiller l'état de divers services réseau. Plus précisément, tu dois gérer un service DNS personnalisé. Ta tâche consiste à concevoir la classe `NetworkManager` avec les spécifications su... | ["\nassert isinstance(NetworkManager().get_custom_dns_status(), bool)\n", "\nassert NetworkManager()._custom_dns_status != NetworkManager().get_custom_dns_status()\n", "\nassert NetworkManager()._custom_dns_status != NetworkManager().get_custom_dns_status()\n", "\nassert NetworkManager()._custom_dns_status != NetworkMa... |
1d1c8bf3609473f9fad3a20dc26961df | [
{
"content": "On te demande d'implémenter une fonction `calculate_total` qui traite une chaîne d'opérations arithmétiques et de nombres. Les opérations sont fournies en séquence, séparées par des espaces, et la fonction doit calculer le résultat séquentiellement de gauche à droite. Les opérations valides sont \... | ["\nassert calculate_total(\"3 add 5\") == 8\n", "\nassert calculate_total(\"10 subtract 4\") == 6\n", "\nassert calculate_total(\"7 multiply 6\") == 42\n", "\nassert calculate_total(\"8 divide 2\") == 4.0\n", "\nassert calculate_total(\"5 add 3 multiply 2\") == 16\n", "\nassert calculate_total(\"10 divide 0\") == \"In... |
3357ba5c8ad766207a83b5af07170c49 | [
{
"content": "Tu es chargé d'écrire un test unitaire pour la fonction `add_numbers` en utilisant le framework `unittest` en Python. La fonction `add_numbers` prend deux entiers en entrée et renvoie leur somme. Ton test unitaire doit couvrir divers scénarios, notamment les nombres positifs, les nombres négatifs,... | ["\nassert add_numbers(1, 2) == 3\n", "\nassert add_numbers(-1, -2) == -3\n", "\nassert add_numbers(1, -2) == -1\n", "\nassert add_numbers(0, 0) == 0\n", "\nassert add_numbers(5, 0) == 5\n", "\nassert add_numbers(0, -5) == -5\n", "\nassert add_numbers(1000000, 2000000) == 3000000\n", "\nassert add_numbers(-1000000, 100... |
04c4ee00cd0c9f93fd1f39c567ae7e24 | [
{
"content": "On te donne une liste chaînée simple. Ta tâche est d'écrire une fonction qui renvoie la valeur du nœud central de la liste. Si la liste a un nombre pair de nœuds, renvoie la valeur du deuxième nœud central.\n\n**Entrée :**\n- L'entrée est une liste chaînée simple représentée par son nœud de tête.\... | ["\nassert find_middle(ListNode(1)).value == 1\n", "\nassert find_middle(ListNode(1, ListNode(2))).value == 2\n", "\nassert find_middle(ListNode(1, ListNode(2, ListNode(3)))).value == 2\n", "\nassert find_middle(ListNode(1, ListNode(2, ListNode(3, ListNode(4))))).value == 3\n", "\nassert find_middle(ListNode(1, ListNod... |
6575917b5becf44dd226d5245942623f | [
{
"content": "On te donne une liste de chaînes de caractères. Pour chaque chaîne, détermine si elle contient des caractères répétés. Retourne une liste de booléens où chaque booléen indique si la chaîne correspondante contient des caractères répétés.\n\n**Entrée :**\n- Une liste de chaînes de caractères, `strin... | ["\nassert has_repeated_characters([\"abc\", \"def\", \"ghi\"]) == [False, False, False]\n", "\nassert has_repeated_characters([\"aabb\", \"ccdd\", \"eeff\"]) == [True, True, True]\n", "\nassert has_repeated_characters([\"\", \"\", \"\"]) == [False, False, False]\n", "\nassert has_repeated_characters([\"a\", \"b\", \"c... |
2cef1083879957e099f24addb90ccc01 | [
{
"content": "Étant donné une chaîne de caractères `s`, détermine la longueur de la plus longue sous-séquence palindromique qu'elle contient. Une sous-séquence est une séquence dérivée d'une autre séquence où certains éléments peuvent être supprimés sans modifier l'ordre des éléments restants. Une sous-séquence... | ["\nassert longest_palindromic_subsequence(\"bbbab\") == 4\n", "\nassert longest_palindromic_subsequence(\"cbbd\") == 2\n", "\nassert longest_palindromic_subsequence(\"a\") == 1\n", "\nassert longest_palindromic_subsequence(\"ac\") == 1\n", "\nassert longest_palindromic_subsequence(\"abcba\") == 5\n", "\nassert longest... |
496c524f6b9f59f926eb3787afb6eaf9 | [
{
"content": "On te demande d'implémenter une classe `PortfolioManager` qui gère une collection de titres. Chaque titre a un nom et un prix. Ta classe doit prendre en charge les opérations suivantes :\n\n1. `add_security(security)` : Ajoute un titre au portefeuille. Si l'entrée n'est pas un objet `Security`, lè... | ["\nassert PortfolioManager().get_total_value() == 0\n", "\nassert PortfolioManager().add_security(Security(\"AAPL\", 150)) is None\n", "\nassert PortfolioManager().add_security(Security(\"GOOGL\", 2800)) is None\n", "\npm = PortfolioManager(); pm.add_security(Security(\"AAPL\", 150)); pm.add_security(Security(\"GOOGL\... |
95ed52b465e2ca2815be8c371882daf5 | [
{
"content": "On te donne `n` dés, chacun avec `f` faces numérotées de 1 à `f`. Ta tâche est de déterminer la probabilité d'obtenir une somme spécifique `s` lorsque tous les dés sont lancés.\n\n**Entrée :**\n- La première ligne contient trois entiers `n`, `f` et `s` (1 ≤ n ≤ 30, 1 ≤ f ≤ 20, 1 ≤ s ≤ 180).\n\n**S... | ["\nassert calculate_probability(1, 6, 3) == 1/6\n", "\nassert calculate_probability(2, 6, 7) == 1/6\n", "\nassert calculate_probability(3, 6, 10) == 27/216\n", "\nassert calculate_probability(2, 4, 8) == 1/16\n", "\nassert calculate_probability(1, 10, 1) == 1/10\n", "\nassert calculate_probability(2, 10, 20) == 1/100\... |
aa4c05dfd3e6f3344bc0f23d09c817c9 | [
{
"content": "On te demande d'implémenter une fonction `generate_html_table` qui construit un tableau HTML à partir d'un ensemble de données donné. La fonction accepte deux paramètres : une liste de dictionnaires `data` et une liste de chaînes de caractères `headers`. Chaque dictionnaire dans `data` représente ... | ["\nassert generate_html_table([{'Name': 'Alice', 'Age': 30}, {'Name': 'Bob', 'Age': 25}], ['Name', 'Age']) == \"<table border='1'>\\n <tr>\\n\t<th>Name</th>\\n\t<th>Age</th>\\n </tr>\\n <tr>\\n\t<td>Alice</td>\\n\t<td>30</td>\\n </tr>\\n <tr>\\n\t<td>Bob</td>\\n\t<td>25</td>\\n </tr>\\n</table>\"\n", "\nassert g... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.