id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
5bb5bbfd235b728075ccbd83676835f3 | [
{
"content": "On te demande d'implémenter une classe `Calculator` en Python qui supporte les opérations arithmétiques de base : addition, soustraction, multiplication et division. La calculatrice doit démarrer avec une valeur initiale de 0. Implémente les méthodes suivantes :\n\n- `__init__` : Initialise la cal... | ["\nassert Calculator().get_value() == 0\n", "\nassert Calculator().add(5).get_value() == 5\n", "\ncalc = Calculator()\ncalc.add(10)\ncalc.subtract(3)\nassert calc.get_value() == 7\n", "\ncalc = Calculator()\ncalc.multiply(5)\ncalc.multiply(2)\nassert calc.get_value() == 10\n", "\ncalc = Calculator()\ncalc.add(20)\ncal... |
5c7e6b6e7977d13dc6037163fb3f6d2e | [
{
"content": "On te donne pour tâche d'implémenter une fonction `color_to_cmyk` qui convertit les noms de couleurs ou les codes de couleur hexadécimaux en leurs valeurs CMJN correspondantes. La fonction doit accepter un seul argument de chaîne de caractères représentant soit un nom de couleur, soit un code de c... | ["\nassert color_to_cmyk('azure') == (0.0000, 0.0000, 0.0000, 0.0000)\n", "\nassert color_to_cmyk('auburn') == (0.0000, 0.5882, 0.8824, 0.3255)\n", "\nassert color_to_cmyk('rose') == (0.0000, 0.5961, 0.3725, 0.0000)\n", "\nassert color_to_cmyk('copper') == (0.0000, 0.4000, 0.7500, 0.2824)\n", "\nassert color_to_cmyk('s... |
476a0457cb6cbfa1c27287c110d3307c | [
{
"content": "On te donne une chaîne de caractères `s` composée des caractères '(', ')', '[', ']', '{' et '}'. Ta tâche est de déterminer si la chaîne est équilibrée. Une chaîne est considérée comme équilibrée si chaque parenthèse ouvrante a une parenthèse fermante correspondante du même type et que les paires ... | ["\nassert is_balanced(\"{[()]}\") == True\n", "\nassert is_balanced(\"{[(])}\") == False\n", "\nassert is_balanced(\"{{[[(())]]}}\") == True\n", "\nassert is_balanced(\"()[]{}\") == True\n", "\nassert is_balanced(\"([)]\") == False\n", "\nassert is_balanced(\"{[}\") == False\n", "\nassert is_balanced(\"\") == True\n",... |
f1f5131194032dd91ba08fd2f862741b | [
{
"content": "On te donne un entier `number`. Ta tâche est d'écrire une fonction `count_factors(number)` qui renvoie le nombre de ses facteurs qui sont des carrés parfaits. Un carré parfait est un entier qui est le carré d'un entier. Par exemple, 1, 4, 9, 16, 25, etc., sont des carrés parfaits.\n\n**Entrée :**\... | ["\nassert count_factors(1) == 1\n", "\nassert count_factors(4) == 2\n", "\nassert count_factors(9) == 2\n", "\nassert count_factors(16) == 3\n", "\nassert count_factors(25) == 2\n", "\nassert count_factors(36) == 3\n", "\nassert count_factors(49) == 2\n", "\nassert count_factors(64) == 4\n", "\nassert count_factors(10... |
31addaacb97ebad40a0c3683d2911cee | [
{
"content": "On te donne un entier `n`. Ta tâche est de déterminer si `n` est une puissance de 3. Un nombre est considéré comme une puissance de 3 s'il peut être exprimé sous la forme 3^k où `k` est un entier non négatif. Implémente une fonction récursive `is_power_of_3(n)` qui renvoie `True` si `n` est une pu... | ["\nassert is_power_of_3(1) == True\n", "\nassert is_power_of_3(3) == True\n", "\nassert is_power_of_3(9) == True\n", "\nassert is_power_of_3(27) == True\n", "\nassert is_power_of_3(81) == True\n", "\nassert is_power_of_3(243) == True\n", "\nassert is_power_of_3(10) == False\n", "\nassert is_power_of_3(0) == False\n", ... |
9cbf210e04ad9f2bf130a8d7182ff441 | [
{
"content": "On te demande d'implémenter une fonction `precision_tolerance` qui calcule une valeur de tolérance en fonction du `precision_level` et du `sampling_rate` donnés. La fonction doit gérer efficacement les grandes valeurs de `sampling_rate` sans problèmes de performance. Si le `precision_level` est 24... | ["\nassert precision_tolerance(24, 1000000) == 10946\n", "\nassert precision_tolerance(12, 1000000) == 0.000012\n", "\nassert precision_tolerance(24, 1) == 10946\n", "\nassert precision_tolerance(1, 1000000) == 0.000001\n", "\nassert precision_tolerance(50, 1000000) == 0.00005\n", "\nassert precision_tolerance(24, 1000... |
644e5c3c7184ccf938626dbfe4eadfef | [
{
"content": "On te demande d'implémenter une fonction `time_complexity_analyzer` qui agit comme un décorateur. Ce décorateur doit mesurer et afficher le temps d'exécution de toute fonction qu'il décore, en nanosecondes. Le décorateur doit être capable de gérer des fonctions avec n'importe quel nombre d'argumen... | ["\nassert time_complexity_analyzer(lambda: 1)(1) == 1\n", "\nassert time_complexity_analyzer(lambda x: x + 1)(2) == 3\n", "\nassert time_complexity_analyzer(lambda x, y: x * y)(3, 4) == 12\n", "\nassert time_complexity_analyzer(lambda x: x)([1, 2, 3]) == [1, 2, 3]\n", "\nassert time_complexity_analyzer(lambda: \"hello... |
610d035047701f7ae188ac3588f57666 | [
{
"content": "On te donne une chaîne de caractères représentant une date et une liste de formats de date. Ton objectif est d'implémenter une fonction `parse_recent_date` qui tente d'analyser la chaîne de caractères de la date en utilisant chaque format de la liste, dans l'ordre. Si un format analyse correctemen... | ["\nassert parse_recent_date(\"25/12/2023\", [\"%d/%m/%Y\"]).date() == datetime.now().date().replace(day=25, month=12)\n", "\nassert parse_recent_date(\"01-01-2020\", [\"%d-%m-%Y\"]).date() == datetime.now().date().replace(day=1, month=1)\n", "\nassert parse_recent_date(\"15/08/2015\", [\"%d/%m/%Y\"]).date() == datetim... |
320ec554465b259fd32beab7b81c3a0b | [
{
"content": "On te donne un entier `n`. Ta tâche est d'implémenter une fonction `find_closest_square` qui renvoie l'entier `x` le plus proche tel que `x^2` soit inférieur ou égal à `n`. Si `n` est négatif, renvoie l'entier `x` dont le carré est le plus proche de `n` sans le dépasser en valeur absolue. S'il y a... | ["\nassert find_closest_square(10) == 3\n", "\nassert find_closest_square(16) == 4\n", "\nassert find_closest_square(0) == 0\n", "\nassert find_closest_square(1) == 1\n", "\nassert find_closest_square(2) == 1\n", "\nassert find_closest_square(-10) == -3\n", "\nassert find_closest_square(-16) == -4\n", "\nassert find_cl... |
02fe376904f623b153551ba360dfd9d1 | [
{
"content": "On te donne un polygone avec jusqu'à 10 000 sommets, qui peut s'auto-intersecter, formant des trous ou des zones qui se chevauchent. Ta tâche est de calculer l'aire totale du polygone. Les sommets du polygone sont fournis sous forme de liste de tuples, où chaque tuple contient les coordonnées x et... | ["\nassert polygon_area([(0, 0), (4, 0), (4, 4), (0, 4), (0, 0)]) == 16\n", "\nassert polygon_area([(0, 0), (0, 5), (5, 5), (5, 0), (0, 0)], precision=1) == 25\n", "\nassert polygon_area([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]) == 1\n", "\nassert polygon_area([(0, 0), (2, 0), (2, 2), (0, 2), (0, 0)], precision=10) == ... |
661166ea89f72b36117f72269e30fe55 | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `shift_string` qui décale les caractères de la chaîne `s` vers la droite de `n` positions. Si `n` est négatif, la chaîne doit être décalée vers la gauche de `|n|` positions. La fonction doit gér... | ["\nassert shift_string(\"abcdef\", 2) == \"efabcd\"\n", "\nassert shift_string(\"abcdef\", -2) == \"cdefab\"\n", "\nassert shift_string(\"abcdef\", 6) == \"abcdef\"\n", "\nassert shift_string(\"abcdef\", 0) == \"abcdef\"\n", "\nassert shift_string(\"abcdef\", 8) == \"efabcd\"\n", "\nassert shift_string(\"abcdef\", -8)... |
7c1be669d91d3766e2a785200cc67218 | [
{
"content": "On te donne un tableau d'entiers, `numbers`, et un entier, `n`. Ta tâche est d'implémenter une fonction `bootstrap_mean(numbers, n)` qui calcule la moyenne de `n` échantillons bootstrap tirés de `numbers`. Chaque échantillon bootstrap est un échantillon de la même taille que l'ensemble de données ... | ["\nassert bootstrap_mean([1, 2, 3, 4, 5], 1) == 3.0\n", "\nassert bootstrap_mean([10, 20, 30, 40, 50], 100) == 30.0\n", "\nassert bootstrap_mean([1, 1, 1, 1, 1], 1000) == 1.0\n", "\nassert bootstrap_mean([], 10) == 0.0\n", "\nassert bootstrap_mean([5], 1) == 5.0\n", "\nassert bootstrap_mean([2, 4, 6, 8, 10], 5) == 6.0... |
29b0d4c0a8706d47ef7647b58fbec2aa | [
{
"content": "On te donne une chaîne de caractères `numbers_str` qui contient une liste d'entiers séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `sum_of_evens` qui convertit cette chaîne en une liste d'entiers et renvoie la somme des nombres pairs de la liste. S'il n'y a pas de nombres pa... | ["\nassert sum_of_evens(\"1 2 3 4 5 6 7 8 9 10\") == 30\n", "\nassert sum_of_evens(\"2 4 6 8 10\") == 30\n", "\nassert sum_of_evens(\"1 3 5 7 9\") == 0\n", "\nassert sum_of_evens(\"0\") == 0\n", "\nassert sum_of_evens(\"11 22 33 44 55\") == 66\n", "\nassert sum_of_evens(\"\") == 0\n", "\nassert sum_of_evens(\"100 200 3... |
e26f2d246a621e803c85bc71958784d3 | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer les informations et la disponibilité des livres. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `title` : une chaîne de caractères représentant le titre du livre.\n - `author` : une chaîne de caractères ... | ["\nassert Book(\"Example Title\", \"Author Name\", 2023, \"1234567890123\").is_new() == True\n", "\nassert Book(\"Example Title\", \"Author Name\", 2022, \"1234567890123\").is_new() == False\n", "\nassert Book(\"Example Title\", \"Author Name\", datetime.now().year, \"1234567890123\").is_new() == True\n", "\nassert Bo... |
5337576d364cfca41932a1880211ca34 | [
{
"content": "On te donne un arbre ternaire représenté comme un dictionnaire. Chaque nœud de l'arbre est un dictionnaire avec les clés \"val\" pour la valeur du nœud et \"children\" pour une liste de ses nœuds enfants (chaque nœud peut avoir jusqu'à trois enfants). Ta tâche est de mettre en œuvre une fonction `... | ["\nassert find_parent(ternary_tree, ternary_tree[\"children\"][0]) == ternary_tree\n", "\nassert find_parent(ternary_tree, ternary_tree[\"children\"][1]) == ternary_tree\n", "\nassert find_parent(ternary_tree, ternary_tree[\"children\"][0][\"children\"][0]) == ternary_tree[\"children\"][0]\n", "\nassert find_parent(te... |
fe4390c65ec79ed6aee891c27aabd447 | [
{
"content": "Implémente une liste chaînée simple avec les fonctionnalités suivantes :\n- `add(data)` : Ajoute un nœud avec les données spécifiées à la fin de la liste.\n- `remove(data)` : Supprime le premier nœud avec les données spécifiées.\n- `display()` : Affiche tous les éléments de la liste chaînée dans l... | ["\nassert LinkedList().display() is None\n", "\nll = LinkedList(); ll.add(1); assert ll.display() is None\n", "\nll = LinkedList(); ll.add(1); ll.add(2); assert ll.display() is None\n", "\nll = LinkedList(); ll.add(1); ll.add(2); ll.remove(2); assert ll.display() is None\n", "\nll = LinkedList(); ll.add(1); ll.add(2);... |
a0c91a6ae9001fcf66a54a1d13b6a2e1 | [
{
"content": "On te donne une liste non triée d'entiers `nums` et un entier `k`. Ta tâche est de mettre en œuvre une fonction `find_kth_largest(nums: List[int], k: int) -> int` qui renvoie le kième plus grand élément de la liste. La liste peut contenir des éléments en double. Tu es autorisé à utiliser n'importe... | ["\nassert find_kth_largest([3,2,1,5,6,4], 2) == 5\n", "\nassert find_kth_largest([3,2,3,1,2,4,5,5,6], 4) == 4\n", "\nassert find_kth_largest([1], 1) == 1\n", "\nassert find_kth_largest([7,6,5,4,3,2,1], 7) == 1\n", "\nassert find_kth_largest([10,9,8,7,6,5,4,3,2,1], 1) == 10\n", "\nassert find_kth_largest([1,2,3,4,5,6,7... |
c7ff90cb4bec68341576370613a77838 | [
{
"content": "On te donne une chaîne de caractères `S` composée de caractères distincts. Ta tâche est de générer toutes les combinaisons possibles non vides des caractères dans `S`. Les combinaisons doivent être renvoyées sous forme de liste de chaînes de caractères, triées par ordre lexicographique. Par exempl... | ["\nassert generate_combinations(\"abc\") == [\"a\", \"b\", \"c\", \"ab\", \"bc\", \"ac\", \"abc\"]\n", "\nassert generate_combinations(\"a\") == [\"a\"]\n", "\nassert generate_combinations(\"\") == []\n", "\nassert generate_combinations(\"ab\") == [\"a\", \"b\", \"ab\"]\n", "\nassert generate_combinations(\"xyz\") == ... |
78c9cbaef818bbb7033a0ba3199ef78a | [
{
"content": "On te demande d'implémenter une fonction `convert_array_to_xml` qui transforme un tableau numérique 2D donné en un format XML personnalisé. Le document XML doit avoir un élément racine nommé `<array>`, et chaque sous-tableau doit être encapsulé dans un élément `<row>`. Les éléments de chaque sous-... | ["\nassert convert_array_to_xml([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == \"<array>\\n <row>1 2 3</row>\\n <row>4 5 6</row>\\n <row>7 8 9</row>\\n</array>\"\n", "\nassert convert_array_to_xml([[0, 0, 0], [0, 0, 0]]) == \"<array>\\n <row>0 0 0</row>\\n <row>0 0 0</row>\\n</array>\"\n", "\nassert convert_array_to_xml([[... |
fa654f3fbaff916299f450b1bf93ef72 | [
{
"content": "On te donne un arbre binaire avec `N` nœuds, où chaque nœud contient une valeur entière. Ta tâche est de mettre en œuvre une fonction `sumAlternateLevels` qui calcule la somme de toutes les valeurs des nœuds situés aux niveaux alternés de l'arbre, en commençant par le niveau 0 (le niveau racine). ... | ["\nassert sumAlternateLevels(TreeNode(1)) == 1\n", "\nassert sumAlternateLevels(TreeNode(1, TreeNode(2), TreeNode(3))) == 4\n", "\nassert sumAlternateLevels(TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7)))) == 8\n", "\nassert sumAlternateLevels(TreeNode(1, TreeNode(2, TreeNode(... |
2f8ddf57d919825b827e2df3e354aad7 | [
{
"content": "On te demande d'implémenter une classe `Matrix` en Python qui prenne en charge les opérations matricielles de base. La classe doit être capable de gérer les fonctionnalités suivantes :\n\n1. **Initialisation** : Créer une matrice avec des dimensions spécifiées (lignes et colonnes) et initialiser é... | ["\nassert Matrix(2, 3).get_element(0, 0) == 0\n", "\nassert Matrix(2, 3, 5).get_element(1, 2) == 5\n", "\nmatrix = Matrix(2, 2)\nmatrix.set_element(0, 0, 10)\nassert matrix.get_element(0, 0) == 10\n", "\nmatrix1 = Matrix(2, 2, 1)\nmatrix2 = Matrix(2, 2, 2)\nresult = matrix1.add_matrix(matrix2)\nassert result.get_eleme... |
546a5853f14366fff3e5eed4bf2bc791 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui calcule les différences entre chaque paire d'éléments consécutifs dans la liste. La fonction doit renvoyer une nouvelle liste contenant ces différences.\n\n**Entrée :**\n- Une liste d'entiers `nums` (1 ≤ len(nums) ≤ 10^5),... | ["\nassert consecutive_differences([1, 2, 4, 7]) == [1, 2, 3]\n", "\nassert consecutive_differences([10, 5, 1]) == [-5, -4]\n", "\nassert consecutive_differences([1, 1, 1, 1]) == [0, 0, 0]\n", "\nassert consecutive_differences([5]) == []\n", "\nassert consecutive_differences([]) == []\n", "\nassert consecutive_differen... |
1fd9415cc82b5378a5d0e9f247e815a5 | [
{
"content": "On te donne une matrice carrée symétrique de taille `n x n` remplie d'entiers. Ta tâche est d'écrire une fonction qui prend la matrice et une paire d'indices `(i, j)` et renvoie l'indice de l'élément correspondant dans le triangle supérieur aplati de la matrice, en excluant les éléments diagonaux.... | ["\nassert index_in_upper_triangle([[1, 2], [3, 4]], 0, 1) == 0\n", "\nassert index_in_upper_triangle([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 0, 2) == 2\n", "\nassert index_in_upper_triangle([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 1, 2) == 1\n", "\nassert index_in_upper_triangle([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13,... |
97df78f3be57bc1a3009ad063880511c | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer le nombre de voyelles distinctes présentes dans la chaîne. Les voyelles sont 'a', 'e', 'i', 'o', 'u', et le comptage doit être insensible à la casse.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 1000), composé... | ["\nassert count_distinct_vowels(\"Hello World\") == 2\n", "\nassert count_distinct_vowels(\"AEIOU\") == 5\n", "\nassert count_distinct_vowels(\"abcdefghijklmnopqrstuvwxyz\") == 5\n", "\nassert count_distinct_vowels(\"bcdfghjklmnpqrstvwxyz\") == 0\n", "\nassert count_distinct_vowels(\"A quick brown fox jumps over the l... |
d7a1edddfae70789267976c9efa06e61 | [
{
"content": "On te donne une série de `total_episodes` et un nombre de `num_evaluations` que tu dois distribuer uniformément sur ces épisodes. Les évaluations ne doivent pas avoir lieu aux points médians de deux épisodes consécutifs. Ta tâche est de déterminer les numéros d'épisodes auxquels les évaluations do... | ["\nassert generate_evaluation_schedule(10, 1) == [5]\n", "\nassert generate_evaluation_schedule(10, 2) == [3, 7]\n", "\nassert generate_evaluation_schedule(10, 3) == [2, 5, 8]\n", "\nassert generate_evaluation_schedule(10, 4) == [2, 4, 6, 8]\n", "\nassert generate_evaluation_schedule(15, 3) == [4, 8, 12]\n", "\nassert... |
eeeb10c8d77c9090c66798278586492a | [
{
"content": "On te demande d'implémenter une fonction `generate_blame_url` qui construit une URL pour visualiser le \"blame\" d'un fichier spécifique dans un dépôt Git à une révision donnée. La fonction doit accepter trois paramètres : `repo_url` (une chaîne de caractères représentant l'URL du dépôt), `revisio... | ["\nassert generate_blame_url('https://github.com/user/repo', '1a2b3c4', 'src/main.py') == 'https://github.com/user/repo/blame/1a2b3c4/src/main.py'\n", "\nassert generate_blame_url('https://github.com/user/repo/', '1a2b3c4', 'src/main.py') == 'https://github.com/user/repo/blame/1a2b3c4/src/main.py'\n", "\nassert genera... |
cdd53e088c7a26df5e34f5649a1de105 | [
{
"content": "On te donne un tableau numpy 2D `x`. Ta tâche est d'écrire une fonction `max_absolute_difference(x)` qui calcule la différence absolue maximale entre deux éléments quelconques du tableau. La différence absolue entre deux éléments `a` et `b` est définie comme `abs(a - b)`. Tu dois implémenter cette... | ["\nassert max_absolute_difference(np.array([[1, 2], [3, 4]])) == 3\n", "\nassert max_absolute_difference(np.array([[5, -5], [10, -10]])) == 20\n", "\nassert max_absolute_difference(np.array([[0, 0], [0, 0]])) == 0\n", "\nassert max_absolute_difference(np.array([[100]])) == 0\n", "\nassert max_absolute_difference(np.ar... |
08b979d9b8c98f0bb380b0aef389e197 | [
{
"content": "On te donne une liste de fonctions `func_stack` et une liste de valeurs initiales `initial_values`. Chaque fonction dans `func_stack` prend un argument obligatoire et peut prendre des arguments supplémentaires et des arguments nommés. Ta tâche est de créer un générateur qui produit des fonctions. ... | ["\nassert [f() for f in create_function_generators([lambda x: x + 1], [0])] == [1]\n", "\nassert [f() for f in create_function_generators([lambda x: x * 2], [3])] == [6]\n", "\nassert [f() for f in create_function_generators([lambda x: x - 1], [5])] == [4]\n", "\nassert [f() for f in create_function_generators([lambda... |
3da1cec3d1185296084a75a8bf430963 | [
{
"content": "On te donne une chaîne de caractères `s` composée des caractères '(', ')', '{', '}', '[' et ']'. Ta tâche est de déterminer si la chaîne est valide. Une chaîne est considérée comme valide si toutes les parenthèses ouvrantes sont fermées par le même type de parenthèses dans le bon ordre. Implémente... | ["\nassert is_valid_parentheses(\"()\") == True\n", "\nassert is_valid_parentheses(\"()[]{}\") == True\n", "\nassert is_valid_parentheses(\"(]\") == False\n", "\nassert is_valid_parentheses(\"([)]\") == False\n", "\nassert is_valid_parentheses(\"{[]}\") == True\n", "\nassert is_valid_parentheses(\"\") == True\n", "\nas... |
028f634173ccd0ecd70c1ddb6098b95e | [
{
"content": "Tu es chargé d'implémenter une classe `TemperatureConverter` en Python qui prenne en charge les conversions de température entre Celsius, Fahrenheit et Kelvin. La classe doit fournir trois méthodes : `to_celsius`, `to_fahrenheit` et `to_kelvin`. Chaque méthode doit accepter une valeur de températu... | ["\nassert TemperatureConverter().to_celsius(32, 'F') == 0.0\n", "\nassert TemperatureConverter().to_celsius(212, 'F') == 100.0\n", "\nassert TemperatureConverter().to_celsius(373.15, 'K') == 100.0\n", "\nassert TemperatureConverter().to_fahrenheit(0, 'C') == 32.0\n", "\nassert TemperatureConverter().to_fahrenheit(100,... |
652d2908891de0f7b09cd97f303e5174 | [
{
"content": "On te donne une liste d'entiers `nums` contenant à la fois des nombres positifs et négatifs. Ta tâche est de mettre en œuvre une fonction `find_largest_product_of_three(nums)` qui renvoie le plus grand produit possible de trois nombres quelconques de la liste.\n\n**Contraintes :**\n- La liste `num... | ["\nassert find_largest_product_of_three([1, 2, 3]) == 6\n", "\nassert find_largest_product_of_three([-10, -10, 5, 2]) == 500\n", "\nassert find_largest_product_of_three([1, 10, 2, 6, 5, 3]) == 300\n", "\nassert find_largest_product_of_three([-1, -2, -3, -4]) == -6\n", "\nassert find_largest_product_of_three([-10, 0, 1... |
63feb26e7f2c9cc78283d531be4f8466 | [
{
"content": "On te donne une liste d'entiers `event_counts` où chaque entier représente le nombre de fois qu'un événement spécifique s'est produit dans une série d'essais. Ta tâche est de calculer la Fonction de Masse de Probabilité Pondérée (WPMF) pour ces événements. La WPMF attribue une probabilité à chaque... | ["\nassert weighted_probability_mass_function([1, 2, 3]) == [0.0, 0.46153846153846156, 0.5384615384615384]\n", "\nassert weighted_probability_mass_function([10, 20, 30, 40]) == [0.0, 0.18181818181818182, 0.36363636363636365, 0.45454545454545453]\n", "\nassert weighted_probability_mass_function([0, 0, 0]) == [0.0, 0.0, ... |
0f47de9181ed5c34e2c4ffe6913f43f7 | [
{
"content": "On te donne deux arbres binaires. Ta tâche est de déterminer si ces deux arbres sont structurellement identiques et ont les mêmes valeurs de nœuds. Écris une fonction `are_identical_trees` qui prend les racines des deux arbres binaires en entrée et renvoie `True` si les arbres sont identiques, et ... | ["\nassert are_identical_trees(TreeNode(1, TreeNode(2), TreeNode(3)), TreeNode(1, TreeNode(2), TreeNode(3))) == True\n", "\nassert are_identical_trees(TreeNode(1, TreeNode(2), TreeNode(3)), TreeNode(1, TreeNode(3), TreeNode(2))) == False\n", "\nassert are_identical_trees(TreeNode(1), TreeNode(1)) == True\n", "\nassert ... |
3dc49a875bb7d3fead5455486b9c99f9 | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses e-mail. Une adresse e-mail est considérée comme valide si elle répond aux critères suivants :\n- Elle est composée d'une partie locale, d'un symbole \"@\" et d'une partie domaine.\n- La partie locale peut contenir des lettres (maju... | ["\nassert is_valid_email(\"example@domain.com\") == True\n", "\nassert is_valid_email(\"example@domain\") == False\n", "\nassert is_valid_email(\"example@domain.c\") == False\n", "\nassert is_valid_email(\"example@domain.co.uk\") == True\n", "\nassert is_valid_email(\"ex-ample_123@domain.com\") == True\n", "\nassert i... |
3e5911e676e13c316a4bf84ba04bce37 | [
{
"content": "On te demande d'implémenter une fonction `generate_report` qui traite une liste de données de produits et génère un rapport formaté. Chaque produit est représenté comme un dictionnaire avec les clés `name`, `price` et `quantity`. Ta fonction doit calculer la valeur totale pour chaque produit (calc... | ["\nassert generate_report([{\"name\": \"Apple\", \"price\": 0.5, \"quantity\": 10}, {\"name\": \"Banana\", \"price\": 0.3, \"quantity\": 20}, {\"name\": \"Cherry\", \"price\": 2.0, \"quantity\": 5}]) == \"Product Report\\n--------------\\nBanana: $6.00\\nCherry: $10.00\\nApple: $5.00\\n\"\n", "\nassert generate_report... |
57935f164d7e1571374779df363c0482 | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `find_largest_prime_factor(n: int) -> int` qui renvoie le plus grand facteur premier de `n`. Si `n` n'a aucun facteur premier (c'est-à-dire que `n` est inférieur ou égal à 1), la fonction doit renvoyer `None`. Pour les entiers négatifs,... | ["\nassert find_largest_prime_factor(28) == 7\n", "\nassert find_largest_prime_factor(13195) == 29\n", "\nassert find_largest_prime_factor(2) == 2\n", "\nassert find_largest_prime_factor(3) == 3\n", "\nassert find_largest_prime_factor(1) == None\n", "\nassert find_largest_prime_factor(0) == None\n", "\nassert find_larg... |
2aeea42912f07ab7dda1a638c8b2147f | [
{
"content": "On te demande d'implémenter une fonction `format_text` qui formate une chaîne de caractères `text` donnée selon des règles d'alignement et de remplissage spécifiées. La fonction doit gérer correctement les caractères multibytes.\n\n**Signature de la fonction :**\n```python\ndef format_text(text: s... | ["\nassert format_text(\"Hello\", \"left\", \"*\", 10) == \"Hello*****\"\n", "\nassert format_text(\"Hello\", \"right\", \"*\", 10) == \"*****Hello\"\n", "\nassert format_text(\"Hello\", \"center\", \"*\", 10) == \"**Hello***\"\n", "\nassert format_text(\"Hello\", \"left\", \"*\", 5) == \"Hello\"\n", "\nassert format_t... |
6f7b2f823bbd9a91166f1e3afe8ea68d | [
{
"content": "On te donne un dé personnalisé à 9 faces où chaque face a une probabilité distincte d'être obtenue. Les probabilités sont fournies dans une liste `p` de longueur 9, où `p[i]` est la probabilité d'obtenir le nombre `i+1`. Assure-toi que la somme des probabilités dans `p` est égale à 1. Ta tâche est... | ["\nassert simulate_dice_rolls(0, [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) == []\n", "\nassert simulate_dice_rolls(1, [1, 0, 0, 0, 0, 0, 0, 0, 0]) == [1]\n", "\nassert simulate_dice_rolls(1, [0, 0, 0, 0, 0, 0, 0, 0, 1]) == [9]\n", "\nassert all(1 <= roll <= 9 for roll in simulate_dice_rolls(100, [0.1] * 9))\n", "... |
b51e41da228b55d9fe2778ad59c268d2 | [
{
"content": "Tu es chargé d'implémenter une fonction `clean_url(url)` qui traite une chaîne d'URL donnée selon les règles suivantes :\n\n1. Supprime tous les paramètres de requête de l'URL.\n2. Convertis l'URL entière en minuscules.\n3. Remplace tous les caractères spéciaux (à l'exception des tirets et des bar... | ["\nassert clean_url(\"https://www.example.com/path/to/resource?query=param\") == \"https://www-example-com/path/to/resource\"\n", "\nassert clean_url(\"HTTPS://WWW.EXAMPLE.COM/PATH/TO/RESOURCE\") == \"https://www-example-com/path/to/resource\"\n", "\nassert clean_url(\"https://www.example123.com/path/to/resource\") ==... |
c298e22a6533c0e6a9afab5280a3cdda | [
{
"content": "On te demande d'implémenter une fonction `convert_to_roman` qui convertit un entier donné en sa représentation en chiffres romains. La fonction doit gérer tous les entiers de 1 à 3999 inclus. Ta solution doit être efficace et concise.\n\n**Entrée :**\n- Un entier `num` (1 ≤ num ≤ 3999)\n\n**Sortie... | ["\nassert convert_to_roman(1) == \"I\"\n", "\nassert convert_to_roman(4) == \"IV\"\n", "\nassert convert_to_roman(9) == \"IX\"\n", "\nassert convert_to_roman(58) == \"LVIII\"\n", "\nassert convert_to_roman(1994) == \"MCMXCIV\"\n", "\nassert convert_to_roman(3999) == \"MMMCMXCIX\"\n", "\nassert convert_to_roman(500) ==... |
9f069a519757fb238be7600b1534cf7a | [
{
"content": "On te charge de gérer l'agencement des livres sur une étagère de bibliothèque. Chaque livre est représenté par un tuple contenant sa position initiale sur l'étagère, son titre et son auteur. On te fournit également un dictionnaire qui spécifie de combien de positions déplacer certains livres. Si l... | ["\nassert update_book_positions([(1, \"Book A\", \"Author X\"), (3, \"Book B\", \"Author Y\"), (5, \"Book C\", \"Author Z\")], {(3,): 1, (5,): 2}) == [(1, \"Book A\", \"Author X\"), (2, \"Book B\", \"Author Y\"), (3, \"Book C\", \"Author Z\")]\n", "\nassert update_book_positions([(2, \"Book A\", \"Author X\"), (4, \"B... |
a7e6228094bbacb9bd048b2d26f00087 | [
{
"content": "On te donne une liste d'intervalles de temps, chacun représenté comme un tuple de chaînes de caractères au format \"HH:MM\". Ta tâche est de fusionner les intervalles qui se chevauchent et de renvoyer une liste d'intervalles fusionnés dans le même format. Si la liste d'entrée est vide, renvoie une... | ["\nassert merge_intervals([(\"09:00\", \"10:30\"), (\"09:45\", \"11:00\"), (\"11:30\", \"12:00\")]) == [(\"09:00\", \"11:00\"), (\"11:30\", \"12:00\")]\n", "\nassert merge_intervals([(\"08:00\", \"09:00\"), (\"09:00\", \"10:00\"), (\"10:00\", \"11:00\")]) == [(\"08:00\", \"11:00\")]\n", "\nassert merge_intervals([(\"0... |
0b51d0f6cc6a18e718e54e22117166f7 | [
{
"content": "On te demande d'implémenter un système de gestion d'`Inventory` pour un petit magasin. Le système doit prendre en charge l'ajout d'articles, la suppression d'articles, la vérification des niveaux de stock et la liste de tous les articles en inventaire. Ta tâche est de créer une classe Python `Inve... | ["\nassert Inventory().list_inventory() == []\n", "\nassert Inventory().get_stock(\"apple\") == 0\n", "\ninv = Inventory(); inv.add_item(\"apple\", 10); assert inv.get_stock(\"apple\") == 10\n", "\ninv = Inventory(); inv.add_item(\"apple\", 10); inv.add_item(\"apple\", 5); assert inv.get_stock(\"apple\") == 15\n", "\ni... |
78a36a3deeac6d93784d4151bd507470 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `first_unique_element` qui identifie le premier élément de la liste qui apparaît plus d'une fois, en excluant tous les éléments qui apparaissent exactement trois fois. Si un tel élément n'existe pas, la fonction doit renv... | ["\nassert first_unique_element([4, 3, 2, 4, 1, 2, 3, 5, 6, 7]) == 4\n", "\nassert first_unique_element([1, 2, 2, 3, 3, 3, 4, 4, 5]) == 1\n", "\nassert first_unique_element([1, 1, 1, 2, 2, 3, 3, 3, 4, 4]) == 2\n", "\nassert first_unique_element([1, 2, 3, 4, 5, 6, 7, 8, 9]) == None\n", "\nassert first_unique_element([1,... |
9610fc48d927794f09e6e16255ae5c0b | [
{
"content": "Implémente l'algorithme \"Tri à bulles avec échange bidirectionnel et sélection de pivot contigu\". Cet algorithme est une variante du tri à bulles classique avec échange bidirectionnel, où, pendant chaque passage, une sous-séquence contiguë (pivot) d'éléments est sélectionnée et comparée à la sou... | ["\nassert bubble_sort_bidirectional_with_pivot([3, 21, 5, 17, 33, 50, 4, 1, 9], 2) == [1, 3, 4, 5, 9, 17, 21, 33, 50]\n", "\nassert bubble_sort_bidirectional_with_pivot([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 1) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert bubble_sort_bidirectional_with_pivot([1, 2, 3, 4, 5, 6, 7, 8, 9, ... |
96be77001f2accfec01698f371d4c11e | [
{
"content": "On te donne un fichier texte contenant une séquence de protéines et ses valeurs d'indice d'acide aminé (AAindex). L'AAindex est une base de données d'indices numériques représentant diverses propriétés physicochimiques et biochimiques des acides aminés. Chaque ligne du fichier représente une propr... | ["\nassert parse_aaindex_file('test1.txt') == [{'Property1': [[1.0, 2.0], [3.0, 4.0]]}]\n", "\nassert parse_aaindex_file('test2.txt') == [{'Property1': [[1.0, 2.0], [3.0, 4.0]]}, {'Property2': [[5.0, 6.0], [7.0, 8.0]]}]\n", "\nassert parse_aaindex_file('test3.txt') == [{'Property1': [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [... |
3e3f984c72d38ae9802827bd773eb8f8 | [
{
"content": "On te demande d'implémenter une classe `Book` pour gérer l'inventaire d'une bibliothèque. La classe doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un Livre** : Ajouter un nouveau livre à la bibliothèque. Si un livre avec le même ISBN existe déjà, mettre à jour le nombre d'exempl... | ["\nassert Book.total_books == 0\n", "\nBook.add_book(\"1984\", \"George Orwell\", 1949, \"978-0451524935\", 3); assert Book.total_books == 3\n", "\nBook.add_book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960, \"978-0060935467\", 2); assert Book.total_books == 5\n", "\nassert Book.check_availability(\"978-0451524935\... |
40f932e87d17b4048e83739933589545 | [
{
"content": "On te demande d'implémenter une fonction `validate_config` qui traite les paramètres de configuration d'une application. La fonction accepte un dictionnaire `config` en entrée. Si `config` est `None` ou vide, la fonction doit renvoyer un dictionnaire de configuration par défaut. Sinon, elle doit f... | ["\nassert validate_config(None) == {'log_level': 'INFO', 'database_url': 'sqlite:///app.db', 'cache_timeout': 60}\n", "\nassert validate_config({}) == {'log_level': 'INFO', 'database_url': 'sqlite:///app.db', 'cache_timeout': 60}\n", "\nassert validate_config({'log_level': 'DEBUG'}) == {'log_level': 'DEBUG', 'database... |
611646f4919e504eefd25cee4070a931 | [
{
"content": "On te donne une liste de chaînes de caractères représentant des arguments de ligne de commande. Ta tâche est de construire une seule chaîne de caractères qui représente une commande. Cette chaîne de commande doit respecter les règles suivantes :\n- Concatène toutes les chaînes de caractères de la ... | ["\nassert format_command([\"echo\", \"hello\\\\world\"]) == \"echo hello\\\\\\\\world\\n\"\n", "\nassert format_command([\"cost=10$\", \"path\\\\to\\\\file\"]) == \"cost\\\\$10 path\\\\\\\\to\\\\\\\\file\\n\"\n", "\nassert format_command([\"ls\", \"-l\", \"/home/user\"]) == \"ls -l /home/user\\n\"\n", "\nassert format... |
d0adf50eb6689a396875c6d312661ec5 | [
{
"content": "On te donne deux entiers, `a` et `b`. Ta tâche est d'écrire une fonction Python qui renvoie leur somme. Assure-toi que ton code respecte les directives de style PEP 8 de Python.\n\n**Exemple d'entrée :**\n```\n3, 5\n```\n\n**Exemple de sortie :**\n```\n8\n```\n\nLa fonction (ou classe) doit s'appe... | ["\nassert sum_of_nums(2, 3) == 5\n", "\nassert sum_of_nums(-1, 1) == 0\n", "\nassert sum_of_nums(0, 0) == 0\n", "\nassert sum_of_nums(100, 200) == 300\n", "\nassert sum_of_nums(-5, -5) == -10\n", "\nassert sum_of_nums(1.5, 2.5) == 4.0\n", "\nassert sum_of_nums(-1.5, 1.5) == 0.0\n", "\nassert sum_of_nums(0, 1000) == 10... |
43549b153811347426d4ef4023a9d91f | [
{
"content": "On te donne un fichier CSV nommé `sales_data.csv` contenant des enregistrements de ventes. Chaque enregistrement est composé de trois champs : `date`, `product` et `amount`. Ta tâche est d'écrire un script Python qui lit ce fichier CSV, calcule le montant total des ventes pour chaque produit et af... | ["\nassert read_sales_data('test_sales_data_1.csv') == {'ProductA': 150.0, 'ProductB': 200.0, 'ProductC': 50.0}\n", "\nassert read_sales_data('test_sales_data_2.csv') == {'ProductX': 300.0, 'ProductY': 100.0}\n", "\nassert read_sales_data('test_sales_data_3.csv') == {'Product1': 100.0, 'Product2': 200.0, 'Product3': 30... |
7ef7b59aef2122c25d75f65d1e04022c | [
{
"content": "On te donne un dictionnaire `dic` où chaque clé est une chaîne de caractères unique et chaque valeur est une liste de chaînes de caractères. Toutes les chaînes de caractères dans les listes sont en minuscules. Ta tâche est de mettre en œuvre une fonction `find_key_in_list(dic, val)` qui prend ce d... | ["\nassert find_key_in_list({\"fruits\": [\"apple\", \"banana\", \"cherry\"], \"vegetables\": [\"carrot\", \"broccoli\"]}, \"banana\") == \"fruits\"\n", "\nassert find_key_in_list({\"fruits\": [\"apple\", \"banana\", \"cherry\"], \"vegetables\": [\"carrot\", \"broccoli\"]}, \"BROCCOLI\") == \"vegetables\"\n", "\nassert... |
55e197523bd6539b1fa11e9bb98e2996 | [
{
"content": "On te donne une chaîne de caractères `secret_key` composée de caractères alphanumériques. Ta tâche est de mettre en œuvre une fonction `generate_shift_values` qui traite cette chaîne et renvoie une liste d'entiers. Chaque entier de la liste doit représenter la valeur ASCII d'un caractère alphabéti... | ["\nassert generate_shift_values(\"Hello123\") == [79, 108, 108, 101, 72]\n", "\nassert generate_shift_values(\"abcXYZ\") == [89, 88, 90, 99, 98, 97]\n", "\nassert generate_shift_values(\"a1b2c3\") == [99, 98, 97]\n", "\nassert generate_shift_values(\"NoDigitsHere\") == [78, 111, 104, 101, 114, 101, 100, 105, 103, 116,... |
bdde12ea3c939030a5576efbd19a6f0c | [
{
"content": "On te donne une liste d'entiers représentant les prix des actions d'une entreprise particulière. Ta tâche est de déterminer les 25e et 75e percentiles des prix des actions, mais en ne considérant que la seconde moitié de l'ensemble de données. Tu ne dois pas utiliser de fonctions de tri intégrées ... | ["\nassert calculate_thresholds([10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) == (65, 85)\n", "\nassert calculate_thresholds([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == (6, 8)\n", "\nassert calculate_thresholds([100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]) == (650, 850)\n", "\nassert calculate_thresholds([5, 5, 5, 5, 5, 5,... |
3180a95404c25815b1fc91424524b5b6 | [
{
"content": "On te donne une liste d'entiers `lst` et un entier cible `k`. Ta tâche est de mettre en œuvre une fonction qui renvoie l'index de la première occurrence de `k` dans `lst`. Si `k` n'apparaît pas dans la liste, la fonction doit renvoyer `-1`.\n\n**Entrée :**\n- Le premier argument est une liste d'en... | ["\nassert find_first_occurrence([1, 2, 3, 4, 2, 5], 2) == 1\n", "\nassert find_first_occurrence([1, 3, 5, 7], 2) == -1\n", "\nassert find_first_occurrence([], 1) == -1\n", "\nassert find_first_occurrence([1, 1, 1, 1], 1) == 0\n", "\nassert find_first_occurrence([10, 20, 30, 40, 50], 50) == 4\n", "\nassert find_first_o... |
e0421c69eb2ef280cc6814580fb72c41 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais et d'espaces. Ta tâche est de convertir cette chaîne en camel case. En camel case, le premier mot est en minuscules et chaque mot suivant commence par une majuscule, sans espaces entre les mots. Écris une... | ["\nassert convert_to_camel_case(\"hello world\") == \"helloWorld\"\n", "\nassert convert_to_camel_case(\"convert to camel case\") == \"convertToCamelCase\"\n", "\nassert convert_to_camel_case(\"python programming\") == \"pythonProgramming\"\n", "\nassert convert_to_camel_case(\"make this work\") == \"makeThisWork\"\n"... |
45faf7e1a2af1e77d4bc769a7d71e840 | [
{
"content": "Tu es chargé de traiter deux fichiers : `infile_books` et `infile_reviews`. Le fichier `infile_books` contient des informations sur les livres au format `[titre, auteur, année_de_publication, isbn, éditeur]`, chaque champ étant séparé par une tabulation. Le fichier `infile_reviews` contient des in... | ["\nassert parse_books_and_reviews('books1.txt', 'reviews1.txt') == ([[1, 'Book A', 'Author A', '2001', 'ISBN1', 'Publisher A']], [[1, 1]])\n", "\nassert parse_books_and_reviews('books2.txt', 'reviews2.txt') == ([[1, 'Book B', 'Author B', '2002', 'ISBN2', 'Publisher B'], [2, 'Book C', 'Author C', '2003', 'ISBN3', 'Publ... |
8d59c9b75bc23cec1f9b3a0d29eb9da0 | [
{
"content": "On te demande d'implémenter une classe Python `Employee` pour gérer les détails des employés dans le système de paie d'une entreprise. La classe doit encapsuler les attributs suivants :\n- `employee_id` : un entier représentant l'identifiant unique de l'employé.\n- `name` : une chaîne de caractère... | ["\nassert Employee(1, \"John Doe\", 50000).get_salary() == 50000\n", "\nassert Employee(2, \"Jane Smith\", 60000).calculate_annual_bonus() == 6000.0\n", "\nassert Employee(3, \"Alice Johnson\", 75000).get_salary() == 75000\n", "\nassert Employee(4, \"Bob Brown\", 80000).calculate_annual_bonus() == 8000.0\n", "\nassert... |
9b02d83436c3ba796db79a8586a470bb | [
{
"content": "On te donne un nombre rationnel positif exprimé sous forme de fraction `p/q`, où `p` et `q` sont des entiers positifs. Ta tâche est de mettre en œuvre une fonction `continued_fraction` qui calcule le développement en fraction continue de cette fraction jusqu'à un nombre maximal de termes spécifié.... | ["\nassert continued_fraction((41, 13), 5) == [3, 4, 1, 1, 2]\n", "\nassert continued_fraction((10, 3), 5) == [3, 3, 3, 3, 3]\n", "\nassert continued_fraction((22, 7), 5) == [3, 7, 15, 1, 292]\n", "\nassert continued_fraction((1, 2), 5) == [0, 2, 0, 0, 0]\n", "\nassert continued_fraction((1, 1), 5) == [1, 0, 0, 0, 0]\n... |
64331cd2218248581ae743240bf97c73 | [
{
"content": "On te donne une liste d'entiers uniques. Ta tâche est de générer tous les sous-ensembles possibles de cette liste, y compris l'ensemble vide et la liste originale elle-même. Les sous-ensembles doivent être générés par ordre lexicographique. Tu n'es pas autorisé à utiliser des fonctions intégrées q... | ["\nassert generate_subsets([1, 2, 3]) == [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]\n", "\nassert generate_subsets([3, 1, 2]) == [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]\n", "\nassert generate_subsets([0]) == [[], [0]]\n", "\nassert generate_subsets([]) == [[]]\n", "\nassert generate_subsets(... |
d54f11213a35c38f76feebbf7edb989a | [
{
"content": "On te demande de créer une fonction `generate_html_table` qui construit un tableau HTML à partir d'une liste de dictionnaires. Chaque dictionnaire de la liste représente une ligne du tableau, les clés servant d'en-têtes de colonne et les valeurs de données de cellule. Les clés du premier dictionna... | ["\nassert generate_html_table([{\"Name\": \"Alice\", \"Age\": 25}, {\"Name\": \"Bob\", \"Age\": 30}]) == \"<table>\\n <tr>\\n\t<th>Name</th><th>Age</th>\\n </tr>\\n <tr>\\n\t<td>Alice</td><td>25</td>\\n </tr>\\n <tr>\\n\t<td>Bob</td><td>30</td>\\n </tr>\\n</table>\"\n", "\nassert generate_html_table([{\"City\": ... |
74e1569cf1098595e3961ea9ad5c7550 | [
{
"content": "On te donne une grille 2D représentant un labyrinthe de taille `n x n`. Chaque cellule de la grille est soit un mur (indiqué par `-1`) soit un espace ouvert (indiqué par `0`). Le labyrinthe a un point de départ à `(0, 0)` et un point d'arrivée à `(n-1, n-1)`. Ta tâche est de modifier le labyrinthe... | ["\nassert mutate_maze([[0, 0], [0, 0]], is_solvable, [(0, 0), (0, 1), (1, 1)]) == [[0, 0], [0, 0]]\n", "\nassert mutate_maze([[0, -1], [0, 0]], is_solvable, [(0, 0), (1, 0), (1, 1)]) == [[0, -1], [0, 0]]\n", "\nassert mutate_maze([[0, 0], [-1, 0]], is_solvable, [(0, 0), (0, 1), (1, 1)]) == [[0, 0], [-1, 0]]\n", "\nass... |
85b45825b4d40dbc081b3f9bc9156bde | [
{
"content": "On te donne un tableau `arr` de `n` entiers. Ta tâche est d'implémenter une fonction `find_smallest_number(arr)` qui renvoie le plus petit entier du tableau. Si le tableau est vide, la fonction doit renvoyer `None`. Ta solution doit être efficace en termes de nombre de comparaisons effectuées.\n\n... | ["\nassert find_smallest_number([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 1\n", "\nassert find_smallest_number([10, 20, 30, 40, 50]) == 10\n", "\nassert find_smallest_number([-10, -20, -30, -40, -50]) == -50\n", "\nassert find_smallest_number([0, 0, 0, 0, 0]) == 0\n", "\nassert find_smallest_number([100]) == 100\n", "\nass... |
250af9e85577e6548f1312e084dc0328 | [
{
"content": "On te donne une liste de chaînes de caractères composée à la fois de caractères alphabétiques et numériques. Ta tâche est de trier cette liste par ordre croissant en fonction des valeurs numériques intégrées dans chaque chaîne, en ignorant tous les caractères non numériques. Suppose que chaque cha... | ["\nassert sort_strings_numerically([\"abc123\", \"def456\", \"ghi789\", \"jkl10\"]) == [\"jkl10\", \"abc123\", \"def456\", \"ghi789\"]\n", "\nassert sort_strings_numerically([\"a1\", \"b2\", \"c3\", \"d4\"]) == [\"a1\", \"b2\", \"c3\", \"d4\"]\n", "\nassert sort_strings_numerically([\"z9\", \"y8\", \"x7\", \"w6\"]) ==... |
9443470bb5d8c80e79266d16a90fb66f | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de calculer la factorielle de `n` efficacement. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. Ta solution doit viser à minimiser la complexité temporelle.\n\n**Entrée :**\n- Un seul ... | ["\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(10) == 3628800\n", "\nassert factorial(12) == 479001600\n", "\nassert ... |
6f421ec0d97ae10bdda4a3ed752bd63d | [
{
"content": "On te donne deux listes, `HbR` et `CBV`, représentant des données physiologiques, et trois nombres à virgule flottante `parameter1`, `parameter2` et `parameter3`. Ta tâche est de calculer le signal BOLD en utilisant la formule :\n\n\\[ \\text{Signal BOLD} = \\text{parameter1} \\times \\text{HbR} +... | ["\nassert compute_bold_signal([0.1, 0.2], [0.05, -0.02], 2.0, 1.5, 0.01) == [0.315, 0.255]\n", "\nassert compute_bold_signal([0.1, 0.2, 0.3], [0.05, -0.02], 2.0, 1.5, 0.01) == [0.315, 0.255]\n", "\nassert compute_bold_signal([0.1], [0.05], 2.0, 1.5, 0.01) == [0.315]\n", "\nassert compute_bold_signal([], [], 2.0, 1.5, ... |
21bb8b7dbf57373841bab7d7cae59acb | [
{
"content": "On te donne un quaternion représenté comme une liste de quatre nombres `[x, y, z, w]`. Ta tâche est d'écrire une fonction `quaternion2euler_angles(quaternion)` qui convertit ce quaternion en un ensemble d'angles d'Euler dans l'ordre roulis, tangage, lacet. Les angles d'Euler représentent la rotati... | ["\nassert quaternion2euler_angles([0, 0, 0, 1]) == [0, 0, 0]\n", "\nassert quaternion2euler_angles([1, 0, 0, 0]) == [3.141592653589793, 0, 0]\n", "\nassert quaternion2euler_angles([0, 1, 0, 0]) == [0, 3.141592653589793, 0]\n", "\nassert quaternion2euler_angles([0, 0, 1, 0]) == [0, 0, 3.141592653589793]\n", "\nassert q... |
9943aa0ffaac312e099cb0dd00e2f223 | [
{
"content": "Tu développes une application en ligne de commande qui nécessite un numéro de port serveur en argument. Ton application doit valider l'entrée pour s'assurer qu'il s'agit d'un numéro de port valide (un entier compris entre 1 et 65535) et qu'il n'est pas déjà utilisé. Si l'entrée est invalide ou si ... | ["\nassert get_server_port([]) == 8000\n", "\nassert get_server_port([\"script.py\", \"8080\"]) == 8080\n", "\nassert get_server_port([\"script.py\", \"1\"]) == 1\n", "\nassert get_server_port([\"script.py\", \"65535\"]) == 65535\n", "\nassert get_server_port([\"script.py\", \"0\"]) == 8000 # This should actually prin... |
6339b3b2a988b71a8702655acf2178fb | [
{
"content": "On te donne un ensemble de nombres réels et un scalaire `range_limiter`. Ta tâche est de mettre en œuvre une fonction `calculate_pdf_extremes` qui estime la fonction de densité de probabilité (PDF) de l'ensemble de données en utilisant `scipy.stats.gaussian_kde`, mais qui ne considère que les poin... | ["\nassert calculate_pdf_extremes([1, 2, 3, 4, 5], 0.1) == (1.0, 5.0)\n", "\nassert calculate_pdf_extremes([10, 20, 30, 40, 50], 0.05) == (10.0, 50.0)\n", "\nassert calculate_pdf_extremes([1, 1, 1, 1, 1], 0.1) == (1.0, 1.0)\n", "\nassert calculate_pdf_extremes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0.01) == (1.0, 10.0)\n", "... |
fee573a8262ea58b2abeb49c256c165a | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les caractères uniques présents dans la chaîne, et les valeurs doivent être le nombre de fois que chaque caractère apparaît dans la chaîne.\n\n*... | ["\nassert count_characters(\"hello\") == {'h': 1, 'e': 1, 'l': 2, 'o': 1}\n", "\nassert count_characters(\"test\") == {'t': 2, 'e': 1, 's': 1}\n", "\nassert count_characters(\"aabbcc\") == {'a': 2, 'b': 2, 'c': 2}\n", "\nassert count_characters(\"\") == {}\n", "\nassert count_characters(\"123321\") == {'1': 2, '2': 2,... |
42ab210410f7459d44af4497ad4c5ebc | [
{
"content": "On te donne un timestamp Unix sous forme d'entier. Ta tâche est d'écrire une fonction Python `format_timestamp(timestamp)` qui convertit ce timestamp en une chaîne de date et d'heure lisible par l'homme, formatée comme \"AAAA-MM-JJ HH:MM:SS\". Utilise le module `datetime` pour effectuer la convers... | ["\nassert format_timestamp(0) == \"1970-01-01 00:00:00\"\n", "\nassert format_timestamp(1609459200) == \"2021-01-01 00:00:00\"\n", "\nassert format_timestamp(1633072800) == \"2021-10-01 00:00:00\"\n", "\nassert format_timestamp(946684800) == \"2000-01-01 00:00:00\"\n", "\nassert format_timestamp(1577836800) == \"2020-... |
33333f5fb16407770e88b287e0f5b397 | [
{
"content": "On te donne une liste de `n` intervalles, où chaque intervalle est représenté par un tuple de deux entiers `(s, e)`, indiquant respectivement le début et la fin de l'intervalle. Les intervalles sont spécifiés en coordonnées absolues, le début global du groupe d'intervalles étant `0`. Ta tâche est ... | ["\nassert adjust_intervals([(1, 3), (5, 7), (9, 11)], 3) == [(-2, 0), (2, 4), (6, 8)]\n", "\nassert adjust_intervals([(0, 0), (1, 1), (2, 2)], 1) == [(0, 0), (1, 1)]\n", "\nassert adjust_intervals([(10, 20), (20, 30), (30, 40)], 25) == [(-5, 5), (5, 15)]\n", "\nassert adjust_intervals([(5, 10), (15, 20), (25, 30)], 12... |
d4225f52413b760b53d31d868b80f424 | [
{
"content": "On te donne un fichier CSV nommé `employees.csv` contenant des informations sur les employés, notamment leur département et leur salaire. Ta tâche est d'écrire un script Python qui lit ce fichier et calcule le salaire moyen pour chaque département. Le script doit afficher les noms des départements... | ["\nassert calculate_average_salaries(\"non_existent_file.csv\") == None # This will print an error message\n", "\nassert calculate_average_salaries(\"invalid_format.txt\") == None # This will print an error message\n", "\nassert calculate_average_salaries(\"empty_file.csv\") == None # Assuming the file is empty, th... |
7c8a9cca0c85b6bea71670c684ca2c41 | [
{
"content": "On te donne une liste de nombres complexes, où chaque nombre complexe est représenté comme un tuple de deux entiers : la partie réelle et la partie imaginaire. Ta tâche est de calculer la somme des modules de ces nombres complexes et de renvoyer le résultat arrondi au 1/128ème d'unité le plus proc... | ["\nassert complex_modulus_sum([(3, 4)]) == 5.0\n", "\nassert complex_modulus_sum([(1, 1), (1, -1)]) == 2.828125\n", "\nassert complex_modulus_sum([(0, 0)]) == 0.0\n", "\nassert complex_modulus_sum([(1, 0), (0, 1), (-1, 0), (0, -1)]) == 4.0\n", "\nassert complex_modulus_sum([(2, 2), (-2, -2)]) == 5.65625\n", "\nassert ... |
d627c336846db0d69c35e92713c6c876 | [
{
"content": "Tu dois implémenter un serveur web simple en utilisant le module HTTP intégré de Python. Le serveur doit répondre aux spécifications suivantes :\n\n- Fonctionner sur `localhost` et écouter sur le port `8000`.\n- Servir des fichiers statiques depuis le répertoire `./static`.\n- Répondre avec un mes... | ["\nassert requests.get(\"http://localhost:8000/index.html\").status_code == 200\n", "\nassert requests.get(\"http://localhost:8000/index.html\").headers['X-Server-Info'] == 'MyCustomServer'\n", "\nassert requests.get(\"http://localhost:8000/nonexistent.html\").status_code == 404\n", "\nassert requests.get(\"http://loc... |
8642f4c0957f27f2ebb69bba860340a7 | [
{
"content": "On te donne une liste de chaînes de caractères représentant des langages de programmation. Ta tâche est d'implémenter une fonction `classify_languages` qui prend cette liste en entrée et renvoie un dictionnaire. Chaque clé du dictionnaire doit être un nom de langage de la liste d'entrée, et la val... | ["\nassert classify_languages([\"Python\"]) == {\"Python\": False}\n", "\nassert classify_languages([\"Java\"]) == {\"Java\": True}\n", "\nassert classify_languages([\"C++\"]) == {\"C++\": True}\n", "\nassert classify_languages([\"JavaScript\"]) == {\"JavaScript\": False}\n", "\nassert classify_languages([\"Ruby\"]) ==... |
0e7c72ca93e9ea6e6c9586cf7233bab1 | [
{
"content": "On te donne une liste de mots et une chaîne de caractères interdits. Ta tâche est d'implémenter une fonction `filter_words(word_list, forbidden_letters)` qui renvoie une nouvelle liste contenant uniquement les mots de la liste d'entrée qui ne contiennent aucune des lettres interdites. La liste rés... | ["\nassert filter_words([\"hello\", \"world\", \"python\", \"java\"], \"aeiou\") == [\"java\", \"python\"]\n", "\nassert filter_words([\"apple\", \"banana\", \"cherry\", \"date\"], \"aeiou\") == [\"bcd\"]\n", "\nassert filter_words([\"abc\", \"def\", \"ghi\", \"jkl\"], \"xyz\") == [\"abc\", \"def\", \"ghi\", \"jkl\"]\n... |
3d31f3f8de192eee5c6433374d8ec786 | [
{
"content": "On te donne la racine d'un arbre binaire. Implémente une fonction qui effectue un parcours en profondeur de l'arbre et renvoie un tuple contenant deux listes : la première liste doit contenir les valeurs des nœuds dans l'ordre où ils sont visités en utilisant une approche récursive, et la deuxième... | ["\nassert binary_tree_dfs(TreeNode(1)) == ([1], [1])\n", "\nassert binary_tree_dfs(TreeNode(1, TreeNode(2), TreeNode(3))) == ([1, 2, 3], [1, 3, 2])\n", "\nassert binary_tree_dfs(TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3))) == ([1, 2, 4, 5, 3], [1, 3, 2, 5, 4])\n", "\nassert binary_tree_dfs(TreeNode... |
69d9a20930b3fd47dd5b67402f44f5cd | [
{
"content": "On te demande d'implémenter une fonction `is_iterable_but_not_string(x)` qui détermine si un objet donné `x` est un objet itérable, à l'exclusion des chaînes de caractères et des objets générateurs. La fonction doit renvoyer `True` si `x` répond à ces critères, et `False` sinon. Ta solution doit ê... | ["\nassert is_iterable_but_not_string([1, 2, 3]) == True\n", "\nassert is_iterable_but_not_string(\"hello\") == False\n", "\nassert is_iterable_but_not_string((1, 2, 3)) == True\n", "\nassert is_iterable_but_not_string({1, 2, 3}) == True\n", "\nassert is_iterable_but_not_string({'a': 1, 'b': 2}) == True\n", "\nassert i... |
868fd6ca88d8e9f00edfad26153ee5eb | [
{
"content": "On te donne deux chaînes de caractères représentant des heures, `time1` et `time2`, au format \"HH:MM:SS\". Ta tâche est de calculer la différence en secondes entre `time2` et `time1`. Suppose que `time2` est toujours postérieure à `time1` et que les deux heures peuvent chevaucher minuit. Par exem... | ["\nassert calculate_time_difference(\"23:59:59\", \"00:00:01\") == 2\n", "\nassert calculate_time_difference(\"12:34:56\", \"13:00:00\") == 1804\n", "\nassert calculate_time_difference(\"00:00:00\", \"23:59:59\") == 86399\n", "\nassert calculate_time_difference(\"00:00:00\", \"00:00:01\") == 1\n", "\nassert calculate_... |
0814afcbcd39d5712a97749029b31d9b | [
{
"content": "On te demande d'implémenter une fonction `find_room_name_secure` qui récupère le nom d'une pièce étant donné son identifiant unique. La fonction ne doit utiliser aucune méthode intégrée de dictionnaire telle que `get`, `keys`, `values`, `items`, ou toute autre méthode qui accède directement au con... | ["\nassert find_room_name_secure('room1', {'room1': 'Kitchen'}) == 'Kitchen'\n", "\nassert find_room_name_secure('room2', {'room1': 'Kitchen', 'room2': 'Living Room'}) == 'Living Room'\n", "\nassert find_room_name_secure('room3', {'room1': 'Kitchen', 'room2': 'Living Room', 'room3': 'Bedroom'}) == 'Bedroom'\n", "\nasse... |
8f031c15ac79cb385f2bdad895b6f2d9 | [
{
"content": "On te donne un dictionnaire où toutes les clés sont des chaînes de caractères. Ta tâche est d'écrire une fonction `swap_keys_values(dictionary)` qui renvoie un nouveau dictionnaire avec les clés et les valeurs échangées. S'il y a des valeurs dupliquées dans le dictionnaire original, seule la derni... | ["\nassert swap_keys_values({\"a\": 1, \"b\": 2, \"c\": 3}) == {1: \"a\", 2: \"b\", 3: \"c\"}\n", "\nassert swap_keys_values({\"x\": 10, \"y\": 20, \"z\": 10}) == {10: \"z\", 20: \"y\"}\n", "\nassert swap_keys_values({\"key1\": \"value1\", \"key2\": \"value2\"}) == {\"value1\": \"key1\", \"value2\": \"key2\"}\n", "\nas... |
bc3167bfe473e63bf128bdf7346cb05e | [
{
"content": "On te donne une base de données de bibliothèque avec deux tables : `Books` et `BorrowedBooks`. La table `Books` contient les colonnes `title` et `id`, tandis que la table `BorrowedBooks` contient les colonnes `book_id` et `user_id`. Ta tâche est d'écrire une requête SQL qui récupère les titres des... | ["\nassert find_unborrowed_books() == \"SELECT title FROM Books WHERE id NOT IN (SELECT book_id FROM BorrowedBooks)\"\n", "\nassert find_unborrowed_books() != \"SELECT title FROM Books WHERE id IN (SELECT book_id FROM BorrowedBooks)\"\n", "\nassert find_unborrowed_books() != \"SELECT title FROM Books WHERE id NOT IN (S... |
779b70587371dd76eac21b61003a3ae1 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'implémenter une fonction qui renvoie une liste de tous les nombres premiers inférieurs ou égaux à `n` en utilisant l'algorithme du crible d'Ératosthène.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^6)\n\n**Sortie :**\n- Une liste d'entiers rep... | ["\nassert sieve_of_eratosthenes(10) == [2, 3, 5, 7]\n", "\nassert sieve_of_eratosthenes(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert sieve_of_eratosthenes(1) == []\n", "\nassert sieve_of_eratosthenes(2) == [2]\n", "\nassert sieve_of_eratosthenes(30) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n", "\nassert sieve_of_e... |
cae333ae2dfd82900c56d0f5687e265b | [
{
"content": "On te donne une liste d'entiers représentant les prix d'une action particulière sur des jours consécutifs. Ta tâche est de déterminer le profit maximal qui peut être réalisé en achetant et en vendant l'action exactement une fois. Tu dois acheter avant de vendre. Si aucun profit ne peut être réalis... | ["\nassert maximize_profit([7, 1, 5, 3, 6, 4]) == 5\n", "\nassert maximize_profit([7, 6, 4, 3, 1]) == 0\n", "\nassert maximize_profit([1, 2, 3, 4, 5]) == 4\n", "\nassert maximize_profit([3, 3, 5, 0, 0, 3, 1, 4]) == 4\n", "\nassert maximize_profit([1, 2]) == 1\n", "\nassert maximize_profit([1]) == 0\n", "\nassert maximi... |
55101d7843bc2bb5104e44514e7579ee | [
{
"content": "On te donne un ensemble de données de commandes clients, où chaque commande est représentée comme un dictionnaire avec les clés suivantes : `order_id`, `customer_id`, `product_id` et `quantity`. Ta tâche est d'écrire une fonction qui agrège la quantité totale commandée pour chaque produit sur tout... | ["\nassert aggregate_product_quantities([]) == {}\n", "\nassert aggregate_product_quantities([{'order_id': 1, 'customer_id': 101, 'product_id': 201, 'quantity': 5}]) == {201: 5}\n", "\nassert aggregate_product_quantities([{'order_id': 1, 'customer_id': 101, 'product_id': 201, 'quantity': 5}, {'order_id': 2, 'customer_i... |
789693f485f8c9c1b3724ca0b96fe809 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est de transformer cette chaîne de sorte que chaque autre caractère soit converti en majuscule, en commençant par le premier caractère, tandis que les caractères restants sont convertis en minuscule. La fonction doit renvoyer la chaîne tran... | ["\nassert alternate_case('hello world') == 'HeLlO WoRlD'\n", "\nassert alternate_case('Python') == 'PyThOn'\n", "\nassert alternate_case('') == ''\n", "\nassert alternate_case('a') == 'A'\n", "\nassert alternate_case('ab') == 'Ab'\n", "\nassert alternate_case('12345') == '12345'\n", "\nassert alternate_case('!@#$%') =... |
52869ab91824e5d8eba60e23cc7fc473 | [
{
"content": "On te donne une chaîne JSON bien formée et une clé cible. Ta tâche est d'écrire une fonction qui analyse la chaîne JSON et extrait toutes les valeurs uniques associées à la clé cible. Si la clé n'existe pas dans le JSON, la fonction doit renvoyer une liste vide. La chaîne JSON peut contenir des ob... | ["\nassert extract_unique_values('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}', 'name') == ['John']\n", "\nassert extract_unique_values('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\", \"children\": [{\"name\": \"Anna\", \"age\": 10}, {\"name\": \"Alex\", \"age\": 7}]}', 'name') == ['John', 'Ann... |
6e51bcfcc6a79d1f0d6abb7488749373 | [
{
"content": "Étant donné une liste d'entiers, écris une fonction `most_common_integers` qui renvoie une liste des entiers les plus fréquemment rencontrés. Si plusieurs entiers ont la même fréquence la plus élevée, renvoie-les tous dans n'importe quel ordre. La fonction doit gérer une liste vide en renvoyant un... | ["\nassert most_common_integers([1, 2, 2, 3, 3, 4, 4, 4]) == [4]\n", "\nassert most_common_integers([1, 2, 2, 3, 3]) == [2, 3]\n", "\nassert most_common_integers([5, 5, 5, 5, 5]) == [5]\n", "\nassert most_common_integers([1, 1, 2, 2, 3, 3, 4, 4]) == [1, 2, 3, 4]\n", "\nassert most_common_integers([]) == []\n", "\nasser... |
5900330fa46fc6a6febdf6c76e692729 | [
{
"content": "On te demande de développer une API REST simple en utilisant Flask qui prend en charge les opérations CRUD de base sur une collection de livres. Chaque livre est identifié de manière unique par un ID et comprend des attributs pour le titre, l'auteur et l'année de publication. Ton API doit gérer le... | ["\nassert get_books().get_json() == [{'id': 1, 'title': '1984', 'author': 'George Orwell', 'year': 1949}, {'id': 2, 'title': 'To Kill a Mockingbird', 'author': 'Harper Lee', 'year': 1960}]\n", "\nassert get_book(1).get_json() == {'id': 1, 'title': '1984', 'author': 'George Orwell', 'year': 1949}\n", "\nassert get_book... |
40eb0600503ee388f8042af1b84987d9 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste d'entrée, triés par ordre décroissant. Un élément est considéré comme unique s'il apparaît exactement une fois dans la liste d'entrée. S'il n... | ["\nassert unique_sorted_descending([1, 2, 2, 3, 4, 4, 5, 6, 6, 7]) == [7, 5, 3, 1]\n", "\nassert unique_sorted_descending([10, 20, 20, 30, 40, 40, 50]) == [50, 30, 10]\n", "\nassert unique_sorted_descending([1, 1, 1, 1, 1]) == []\n", "\nassert unique_sorted_descending([]) == []\n", "\nassert unique_sorted_descending([... |
2a0a159fd08c0d0fa7e25164a9e494ab | [
{
"content": "On te donne un fichier nommé `data.txt` contenant des informations sur des particules dans un espace 3D. Chaque ligne du fichier représente une seule particule et inclut les données suivantes :\n\n- Les coordonnées x, y et z de la position de la particule (dans cet ordre)\n- Les composantes x, y e... | ["\nassert readPositionAndVelocity(\"data1.txt\") == ([1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0710678118654755, 11.180339887498949])\n", "\nassert readPositionAndVelocity(\"data2.txt\") == ([], [], [], [])\n", "\nassert readPositionAndVelocity(\"data3.txt\") == ([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0... |
9bd0868843f187a5bd7214bf0e05db46 | [
{
"content": "On te donne une chaîne de caractères `word` et un entier `count`. Ta tâche est de créer une fonction `wrap_brackets` qui renvoie une nouvelle chaîne où le `word` original est entouré de `count` crochets carrés `[]`. Les crochets doivent être placés de manière à ce que deux crochets adjacents ne so... | ["\nassert wrap_brackets(\"hello\", 3) == \"[[[hello]]]\"\n", "\nassert wrap_brackets(\"world\", 0) == \"world\"\n", "\nassert wrap_brackets(\"test\", 1) == \"[test]\"\n", "\nassert wrap_brackets(\"a\", 5) == \"[[[[[a]]]]]\"\n", "\nassert wrap_brackets(\"\", 2) == \"[[]]\"\n", "\nassert wrap_brackets(\"Python\", 4) == ... |
f414a5befc0c6a85f4c2ac52ac4bae51 | [
{
"content": "On te donne un parc rectangulaire de dimensions `park_width` et `park_length`. Pour des raisons esthétiques, un tiers de la largeur du parc est occupé par des pierres décoratives. Chaque arbre nécessite un espace de `tree_width` pour grandir, et il doit y avoir un espace supplémentaire de `tree_wi... | ["\nassert max_trees_in_row(30, 100, 5) == 2\n", "\nassert max_trees_in_row(60, 100, 10) == 2\n", "\nassert max_trees_in_row(90, 100, 15) == 2\n", "\nassert max_trees_in_row(120, 100, 20) == 2\n", "\nassert max_trees_in_row(150, 100, 25) == 2\n", "\nassert max_trees_in_row(180, 100, 30) == 2\n", "\nassert max_trees_in_... |
78b22ca656da20352ef7cf4a7dc86244 | [
{
"content": "On te donne une chaîne de caractères ASCII. Ta tâche est d'écrire une fonction qui convertit cette chaîne en sa représentation binaire. Chaque caractère de la chaîne doit être converti en un nombre binaire sur 8 bits, et tous les nombres binaires doivent être concaténés pour former la chaîne de so... | ["\nassert string_to_binary(\"Hello\") == \"0100100001100101011011000110110001101111\"\n", "\nassert string_to_binary(\"world\") == \"0111011101101111011100100110110001100100\"\n", "\nassert string_to_binary(\"Python\") == \"01010000011101000111100101110100011010000110111101101110\"\n", "\nassert string_to_binary(\"123... |
04867d23f70c0ca389a51ba4a4cd10b8 | [
{
"content": "On te donne une liste de mots. Pour chaque mot, détermine le nombre de caractères distincts qui apparaissent exactement deux fois. Implémente une fonction `countTwice` qui prend une liste de chaînes de caractères en entrée et renvoie une liste d'entiers. Chaque entier dans la liste de sortie doit ... | ["\nassert countTwice([\"apple\", \"banana\", \"character\"]) == [1, 1, 2]\n", "\nassert countTwice([\"test\", \"example\", \"assert\"]) == [1, 2, 1]\n", "\nassert countTwice([\"hello\", \"world\", \"python\"]) == [0, 0, 0]\n", "\nassert countTwice([\"aabbcc\", \"abcabc\", \"aabb\"]) == [3, 0, 2]\n", "\nassert countTwi... |
33398f52c9f5edad64faf60f9108c5e8 | [
{
"content": "On te donne une expression mathématique sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction Python `cpp_code_generator` qui convertit cette expression en code C++ équivalent. La fonction doit gérer les fonctions trigonométriques de base (`sin`, `cos`, `tan`) et générer du code C... | ["\nassert cpp_code_generator(\"x + y\") == \"#include <cmath>\\n\\nint main() {\\n\\tdouble var_x = /* assign value */;\\n\\tdouble var_y = /* assign value */;\\n\\n\\tdouble result = var_x + var_y;\\n\\treturn 0;\\n}\"\n", "\nassert cpp_code_generator(\"sin(x)\") == \"#include <cmath>\\n#include <thread>\\n#include <... |
2aaf3c0d6af4496b6fc86f4df6ec390f | [
{
"content": "On te donne une liste d'entiers représentant les taux de croissance annuels du chiffre d'affaires d'une entreprise sur plusieurs années. Chaque taux de croissance est un pourcentage, une valeur positive indiquant une croissance et une valeur négative indiquant une diminution du chiffre d'affaires.... | ["\nassert calculate_revenue_growth([5, 10, -3, 7, 12], 2) == -3\n", "\nassert calculate_revenue_growth([0, 0, 0, 0, 0], 0) == 0\n", "\nassert calculate_revenue_growth([-100, 100, -50, 50], 1) == 100\n", "\nassert calculate_revenue_growth([15.5, 20.3, -12.7, 8.9], 3) == 8.9\n", "\nassert calculate_revenue_growth([10, 2... |
71ae36697147301d452a5588f4049a0f | [
{
"content": "On te donne une liste de `n` éléments, chacun associé à un poids entier positif. Ta tâche est de mettre en œuvre une fonction qui sélectionne aléatoirement un élément de la liste, la probabilité de sélectionner un élément étant proportionnelle à son poids. Chaque élément ne peut être sélectionné q... | ["\nassert isinstance(WeightedRandomSampler(['apple'], [1]).sample(), str)\n", "\nassert WeightedRandomSampler(['apple'], [1]).sample() == 'apple'\n", "\nassert WeightedRandomSampler(['apple', 'banana'], [1, 1]).sample() in ['apple', 'banana']\n", "\nassert WeightedRandomSampler(['apple', 'banana'], [1, 9]).sample() in... |
42b332113acae8894c2dbc700b302c57 | [
{
"content": "On te demande d'implémenter une fonction `generate_tsv_header` qui traite une liste de noms de variables qui peuvent être imbriqués et génère une chaîne formatée TSV (Tab Separated Values). La fonction doit aplatir récursivement toutes les listes imbriquées et concaténer les noms de variables en u... | ["\nassert generate_tsv_header(['name', 'age', 'height']) == 'name\\tage\\theight'\n", "\nassert generate_tsv_header(['name', ['age', 'height'], 'address']) == 'name\\tage\\theight\\taddress'\n", "\nassert generate_tsv_header(['name', ['age', ['height', 'weight']], 'address']) == 'name\\tage\\theight\\tweight\\taddress... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.