from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Vérifie si dans la liste donnée de nombres, il y a deux nombres plus proches l'un de l'autre que
    le seuil donné.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ L'entrée de cette fonction est une chaîne qui contient plusieurs groupes de parenthèses imbriquées. Votre objectif est
    de séparer ces groupes en chaînes distinctes et de retourner la liste de celles-ci.
    Les groupes séparés sont équilibrés (chaque parenthèse ouverte est correctement fermée) et ne sont pas imbriqués entre eux.
    Ignorez tout espace dans la chaîne d'entrée.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ L'entrée de cette fonction est une chaîne qui contient plusieurs groupes de parenthèses imbriquées. Votre objectif est
    de séparer ces groupes en chaînes distinctes et de renvoyer la liste de celles-ci.
    Les groupes séparés sont équilibrés (chaque parenthèse ouverte est correctement fermée) et ne sont pas imbriqués entre eux.
    Ignorez tout espace dans la chaîne d'entrée.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ Étant donné un nombre à virgule flottante positif, on peut le décomposer en
    une partie entière (le plus grand entier inférieur au nombre donné) et des décimales
    (partie restante toujours inférieure à 1).

    Retourne la partie décimale du nombre.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Étant donné un nombre flottant positif, on peut le décomposer en
    une partie entière (le plus grand entier inférieur au nombre donné) et une partie décimale
    (partie restante toujours inférieure à 1).

    Retourner la partie décimale du nombre.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ On vous donne une liste d'opérations de dépôt et de retrait sur un compte bancaire qui commence avec
    un solde nul. Votre tâche est de détecter si à un moment donné le solde du compte tombe en dessous de zéro, et
    à ce moment-là, la fonction devrait retourner True. Sinon, elle devrait retourner False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ On vous donne une liste d'opérations de dépôt et de retrait sur un compte bancaire qui commence avec
    un solde nul. Votre tâche est de détecter si à un moment donné le solde du compte tombe en dessous de zéro, et
    à ce moment-là la fonction devrait retourner True. Sinon, elle devrait retourner False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Pour une liste donnée de nombres en entrée, calcule la Déviation Absolue Moyenne
    autour de la moyenne de cet ensemble de données.
    La Déviation Absolue Moyenne est la différence absolue moyenne entre chaque
    élément et un point central (moyenne dans ce cas) :
    DAM = moyenne | x - x_moyenne |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Pour une liste donnée de nombres en entrée, calculer l'Ecart Absolu Moyen
    autour de la moyenne de cet ensemble de données.
    L'Ecart Absolu Moyen est la différence absolue moyenne entre chaque
    élément et un point central (moyenne dans ce cas) :
    DAM = moyenne | x - x_moyenne |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Pour une liste donnée de nombres en entrée, calculer la Déviation Absolue Moyenne
    autour de la moyenne de cet ensemble de données.
    La Déviation Absolue Moyenne est la différence absolue moyenne entre chaque
    élément et un point central (moyenne dans ce cas) :
    DAM = moyenne | x - x_moyenne |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Insère un nombre 'delimeter' entre chaque deux éléments consécutifs de la liste d'entrée `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ L'entrée de cette fonction est une chaîne qui représente plusieurs groupes de parenthèses imbriquées séparés par des espaces.
    Pour chacun des groupes, elle renvoie le niveau le plus profond d'imbrication des parenthèses.
    Par exemple, (()()) a un maximum de deux niveaux d'imbrication, tandis que ((())) en a trois.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtre une liste de chaînes d'entrée uniquement par celles qui contiennent la sous-chaîne donnée
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtrer une liste de chaînes d'entrée en considérant uniquement celles qui contiennent la sous-chaîne donnée
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Pour une liste donnée d'entiers, renvoie un tuple consistant en une somme et un produit de tous les entiers dans une liste.
    La somme vide doit être égale à 0 et le produit vide doit être égal à 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ À partir d'une liste donnée d'entiers, génère une liste contenant le maximum cumulatif trouvé jusqu'à chaque instant
    dans la séquence.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ À partir d'une liste donnée d'entiers, générez une liste de l'élément maximum trouvé jusqu'au moment donné
    dans la séquence.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ À partir d'une liste donnée d'entiers, génère une liste de l'élément maximum accumulé trouvé jusqu'à présent
    dans la séquence.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Teste si la chaîne donnée est un palindrome """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Trouve le palindrome le plus court qui commence par une chaîne fournie.
    L'idée de l'algorithme est simple :
    - Trouver le suffixe le plus long de la chaîne fournie qui est un palindrome.
    - Ajouter à la fin de la chaîne l'inverse d'un préfixe de chaîne qui vient avant le suffixe palindromique.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Teste si la chaîne donnée est un palindrome """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Trouve le palindrome le plus court qui commence par une chaîne fournie.
    L'idée de l'algorithme est simple:
    - Trouver le suffixe le plus long de la chaîne fournie qui est un palindrome.
    - Ajouter à la fin de la chaîne l'inverse d'un préfixe de chaîne qui vient avant le suffixe palindromique.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ Les entrées sont deux chaînes a et b qui consistent uniquement en 1s et 0s.
    Effectue un XOR binaire sur ces entrées et renvoie le résultat également sous forme de chaîne.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Les entrées sont deux chaînes a et b uniquement composées de 1 et de 0.
    Effectue un XOR binaire sur ces entrées et renvoie le résultat également sous forme de chaîne.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Les entrées sont deux chaînes a et b qui consistent uniquement en 1s et 0s.
    Effectuez un XOR binaire sur ces entrées et renvoyez le résultat également sous forme de chaîne.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ D'une liste de chaînes, renvoie la plus longue. Renvoie la première en cas de multiples
    chaînes de la même longueur. Renvoie None si la liste d'entrée est vide.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Parmi une liste de chaînes, renvoie la plus longue. Renvoie la première en cas de multiples
    chaînes de la même longueur. Renvoie None si la liste d'entrée est vide.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """


def greatest_common_divisor(a: int, b: int) -> int:
    """ Renvoie le plus grand commun diviseur de deux entiers a et b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Renvoie une liste de tous les préfixes du plus court au plus long de la chaîne d'entrée
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Retourne une chaîne qui contient des nombres délimités par des espaces commençant de 0 jusqu'à n inclus.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Étant donné une chaîne, détermine combien de caractères distincts (sans tenir compte des majuscules ou minuscules) elle contient
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Étant donnée une chaîne, détermine combien de caractères distincts (sans tenir compte des majuscules ou minuscules) elle contient
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ L'entrée de cette fonction est une chaîne qui représente des notes musicales dans un format ASCII spécial.
    Votre tâche est d'analyser cette chaîne et de retourner une liste d'entiers qui correspondent à combien de temps
    dure chaque note.

    Voici la légende :
    'o' - note entière, dure quatre temps
    'o|' - demi-note, dure deux temps
    '.|' - quart de note, dure un temps

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ L'entrée de cette fonction est une chaîne qui représente des notes de musique dans un format ASCII spécial.
    Votre tâche est d'analyser cette chaîne et de renvoyer une liste d'entiers qui correspondent à combien de temps
    dure chaque note.

    Voici la légende :
    'o' - note entière, dure quatre temps
    'o|' - demi-note, dure deux temps
    '.|' - quart de note, dure un temps

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """


def how_many_times(string: str, substring: str) -> int:
    """ Trouve combien de fois une sous-chaîne donnée peut être trouvée dans la chaîne originale. Compte les cas superposés.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ L'entrée est une chaîne délimitée par des espaces de nombres de 'zero' à 'nine'.
    Les options valides sont 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' et 'nine'.
    Renvoie la chaîne avec les nombres triés du plus petit au plus grand
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ À partir d'une liste fournie de nombres (d'une longueur d'au moins deux), sélectionne et renvoie deux qui sont
    les plus proches l'un de l'autre et les renvoie dans l'ordre (nombre plus petit, nombre plus grand).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ À partir d'une liste fournie de nombres (d'une longueur d'au moins deux), en sélectionner et renvoyer deux qui sont
    les plus proches l'un de
    l'autre puis les renvoyer dans l'ordre (nombre plus petit, nombre plus grand).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Étant donné une liste de nombres (d'au moins deux éléments), applique une transformation linéaire à cette liste,
    de sorte que le plus petit nombre devienne 0 et le plus grand devienne 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Étant donné une liste de nombres (d'au moins deux éléments), appliquez une transformation linéaire à cette liste,
    de sorte que le plus petit nombre devienne 0 et le plus grand devienne 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtrer la liste donnée de toute valeur Python uniquement pour les entiers
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtrer la liste donnée de toute valeur python uniquement sur les entiers
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtrez la liste donnée de toute valeur Python uniquement pour les entiers
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Renvoie la longueur de la chaîne donnée
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ Pour un nombre donné n, trouve le plus grand nombre qui divise n exactement, inférieur à n
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Retournez une liste de facteurs premiers de l'entier donné dans l'ordre croissant.
    Chacun des facteurs doit apparaître autant de fois qu'il apparaît dans la factorisation.
    Le nombre d'entrée doit être égal au produit de tous les facteurs
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Retourne une liste de facteurs premiers de l'entier donné dans l'ordre croissant.
    Chacun des facteurs doit apparaître autant de fois qu'il apparaît dans la factorisation.
    Le nombre d'entrée doit être égal au produit de tous les facteurs
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ A partir d'une liste d'entiers, élimine tous les éléments qui apparaissent plus d'une fois.
    Conserve l'ordre des éléments restants tel qu'il apparaît dans l'entrée.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ D'une liste d'entiers, élimine tous les éléments qui apparaissent plus d'une fois.
    Conserve l'ordre des éléments restants tel qu'il est dans l'entrée.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ À partir d'une liste d'entiers, élimine tous les éléments qui apparaissent plus d'une fois.
    Conserve l'ordre des éléments restants tel qu'il est dans l'entrée.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ Pour une chaîne donnée, change les caractères minuscules en majuscules et les caractères majuscules en minuscules.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Pour une chaîne donnée, change les caractères en minuscules en majuscules et les caractères en majuscules en minuscules.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ Concaténer une liste de chaînes en une seule chaîne
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Concaténe une liste de chaînes en une seule chaîne
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Filtrer une liste de chaînes d'entrée en considérant uniquement celles qui commencent par un préfixe donné.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Filtrer une liste de chaînes d'entrée uniquement par celles qui commencent par un préfixe donné.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Renvoie uniquement les nombres positifs dans la liste.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """Renvoie True si un nombre donné est premier, et False sinon.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Renvoie vrai si un nombre donné est premier, et faux sinon.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Renvoie true si un nombre donné est premier, et false sinon.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    Évalue le polynôme avec les coefficients xs au point x.
    renvoie xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs sont les coefficients d'un polynôme.
    find_zero trouve x tel que poly(x) = 0.
    find_zero retourne seulement un point zéro, même s'il y en a plusieurs.
    De plus, find_zero ne prend que la liste xs avec un nombre pair de coefficients
    et le coefficient le plus grand non nul car cela garantit
    une solution.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Évalue le polynôme avec les coefficients xs au point x.
    retourne xs[0] + xs[1] * x + xs[2] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs sont les coefficients d'un polynôme.
    find_zero trouve x tel que poly(x) = 0.
    find_zero retourne uniquement un point zéro, même s'il y en a plusieurs.
    De plus, find_zero ne prend que la liste xs avec un nombre pair de coefficients
    et le coefficient non nul de plus haut degré car cela garantit
    une solution.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Évalue le polynôme avec les coefficients xs au point x.
    retourne xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs sont les coefficients d'un polynôme.
    find_zero trouve x tel que poly(x) = 0.
    find_zero retourne seulement un point zéro, même s'il y en a plusieurs.
    De plus, find_zero ne prend que la liste xs avec un nombre pair de coefficients
    et le coefficient le plus grand non nul car cela garantit
    une solution.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """Cette fonction prend une liste l et renvoie une liste l' telle que
    l' est identique à l aux indices qui ne sont pas divisibles par trois, tandis que ses valeurs aux indices qui sont divisibles par trois sont égales
    aux valeurs des indices correspondants de l, mais triées.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """Renvoie les éléments uniques triés dans une liste
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Renvoie l'élément maximum dans la liste.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """Renvoyer l'élément maximum dans la liste.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """Renvoie le nombre de fois que le chiffre 7 apparaît dans les entiers inférieurs à n qui sont divisibles par 11 ou 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Renvoyer le nombre de fois que le chiffre 7 apparaît dans les entiers inférieurs à n qui sont divisibles par 11 ou 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Cette fonction prend une liste l et renvoie une liste l' telle que
    l' est identique à l aux indices impairs, tandis que ses valeurs aux indices pairs sont égales
    aux valeurs des indices pairs de l, mais triées.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    renvoie une chaîne encodée en cyclant des groupes de trois caractères.
    """
    # divise la chaîne en groupes. Chacun de longueur 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cycle les éléments dans chaque groupe. À moins que le groupe ait moins de 3 éléments.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    prend en entrée une chaîne encodée avec la fonction encode_cyclic. Renvoie la chaîne décodée.
    """

def encode_cyclic(s: str):
    """
    renvoie une chaîne encodée en cyclant des groupes de trois caractères.
    """
    # diviser la chaîne en groupes. Chacun de longueur 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cycler les éléments dans chaque groupe. À moins que le groupe ait moins de 3 éléments.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    prends en entrée une chaîne encodée avec la fonction encode_cyclic. Renvoie la chaîne décodée.
    """

def encode_cyclic(s: str):
    """
    renvoie une chaîne encodée en construisant des cycles de groupes de trois caractères.
    """
    # diviser la chaîne en groupes. Chacun de longueur 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cycler les éléments dans chaque groupe. À moins que le groupe ait moins de 3 éléments.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    prend en entrée une chaîne encodée avec la fonction encode_cyclic. Renvoie la chaîne décodée.
    """


def prime_fib(n: int):
    """
    prime_fib renvoie le n-ième nombre qui est un nombre de Fibonacci et qui est aussi premier.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero prend une liste d'entiers en entrée.
    Il retourne True s'il y a trois éléments distincts dans la liste dont
    la somme est égale à zéro, et False sinon.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero prend une liste d'entiers en entrée.
    renvoie True s'il y a trois éléments distincts dans la liste dont la
    somme est égal à zéro, et False dans le cas contraire.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero prend une liste d'entiers en entrée.
    retourne True s'il y a trois éléments distincts dans la liste qui
    somment à zéro, et False sinon.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    Imaginez une route qui est une ligne parfaitement droite et infiniment longue.
    n voitures conduisent de gauche à droite ; simultanément, un ensemble différent de n voitures
    conduisent de droite à gauche. Les deux ensembles de voitures commencent étant très éloignés
    l'un de l'autre. Toutes les voitures se déplacent à la même vitesse. On dit que deux voitures entrent en collision
    lorsqu'une voiture se déplaçant de gauche à droite heurte une voiture se déplaçant de droite à gauche.
    Cependant, les voitures sont infiniment résistantes et solides ; en conséquence, elles continuent de se déplacer
    sur leur trajectoire comme si elles n'avaient pas été en collision.

    Cette fonction renvoie le nombre de telles collisions.
    """

def car_race_collision(n: int):
    """
    Imaginez une route qui est une ligne parfaitement droite et infiniment longue.
    n voitures conduisent de gauche à droite;  simultanément, un ensemble différent de n voitures
    conduisent de droite à gauche.   Les deux ensembles de voitures commencent étant très éloignés
    l'un de l'autre.  Toutes les voitures se déplacent à la même vitesse.  On dit que deux voitures entrent en collision
    lorsqu'une voiture se déplaçant de gauche à droite heurte une voiture se déplaçant de droite à gauche.
    Cependant, les voitures sont infiniment résistantes et solides; en conséquence, elles continuent de se déplacer
    sur leur trajectoire comme si elles n'avaient pas été en collision.

    Cette fonction renvoie le nombre de telles collisions.
    """


def incr_list(l: list):
    """Renvoie une liste avec des éléments incrémentés de 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero prend une liste d'entiers en entrée.
    Il renvoie True s'il y a deux éléments distincts dans la liste qui
    s'additionnent pour donner zéro, et False sinon.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero prend une liste d'entiers en entrée.
    renvoie True s'il y a deux éléments distincts dans la liste qui
    s'additionnent pour donner zéro, et False sinon.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero prend une liste d'entiers en entrée.
    Renvoie True s'il y a deux éléments distincts dans la liste qui
    s'additionnent pour donner zéro, et False dans le cas contraire.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """Change la base numérique du nombre d'entrée x à la base.
    renvoie la représentation en chaîne après la conversion.
    les chiffres de base sont inférieurs à 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Change la base numérique du nombre d'entrée x vers la base spécifiée.
    renvoie la représentation en chaîne après la conversion.
    les chiffres de base sont inférieurs à 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Étant donné la longueur d'un côté et la hauteur, retourne l'aire d'un triangle.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Étant données la longueur d'un côté et la hauteur, retourne l'aire d'un triangle.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Étant donné la longueur d'un côté et la hauteur, renvoie l'aire d'un triangle.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """La séquence de nombres Fib4 est une séquence similaire à la séquence de Fibonacci qui est définie de la manière suivante :
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Veuillez écrire une fonction pour calculer efficacement le n-ième élément de la séquence de nombres fib4. N'utilisez pas de récursion.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """La séquence de nombres Fib4 est une séquence similaire à la séquence de Fibonacci qui est définie de la manière suivante :
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Veuillez écrire une fonction pour calculer efficacement le n-ième élément de la séquence de nombres fib4.  N'utilisez pas la récursion.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Renvoie la médiane des éléments dans la liste l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Vérifie si la chaîne donnée est un palindrome
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Vérifier si la chaîne donnée est un palindrome
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """Renvoie 2^n modulo p (faites attention aux nombres).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    renvoie une chaîne codée en décalant chaque caractère de 5 positions dans l'alphabet.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    prend en entrée une chaîne codée avec la fonction encode_shift. Renvoie la chaîne décodée.
    """


def remove_vowels(text):
    """
    remove_vowels est une fonction qui prend une chaîne et renvoie la chaîne sans voyelles.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """Renvoie True si tous les nombres dans la liste l sont en dessous du seuil t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Ajoute deux nombres x et y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """Additionne deux nombres x et y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Vérifie si deux mots ont les mêmes caractères.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """Renvoie le n-ième nombre de Fibonacci.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets est une chaîne de "<" et ">".
    renvoie True si chaque chevron ouvrant a un chevron fermant correspondant.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ brackets est une chaîne de "<" et ">".
    renvoie True si chaque parenthèse ouvrante a une parenthèse fermante correspondante.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ brackets est une chaîne de "<" and ">".
    renvoie True si chaque parenthèse ouvrante a une parenthèse fermante correspondante.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


def monotonic(l: list):
    """Renvoie True si les éléments de la liste sont monotoniquement croissants ou décroissants.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Renvoie True si les éléments de la liste sont monotonement croissants ou décroissants.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Renvoie les éléments communs uniques triés pour deux listes.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """Renvoie le plus grand facteur premier de n. Supposons que n > 1 et n'est pas un nombre premier.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n est une fonction qui additionne les nombres de 1 à n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets est une chaîne de "(" et ")".
    renvoie True si chaque parenthèse ouvrante a une parenthèse fermante correspondante.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """


def derivative(xs: list):
    """ xs représente les coefficients d'un polynôme.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Renvoie la dérivée de ce polynôme sous la même forme.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """La séquence de nombres FibFib est une séquence similaire à la séquence de Fibonacci qui est définie de la manière suivante :
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Veuillez écrire une fonction pour calculer efficacement le n-ième élément de la séquence de nombres fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Ajoute plus de cas de test.
"""

def vowels_count(s):
    """Écrivez une fonction vowels_count qui prend une chaîne représentant
    un mot en entrée et renvoie le nombre de voyelles dans la chaîne.
    Les voyelles dans ce cas sont 'a', 'e', 'i', 'o', 'u'. Ici, 'y' est aussi
    une voyelle, mais seulement lorsqu'elle est à la fin du mot donné.

    Exemple :
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Ajouter plus de cas de test.
"""

def vowels_count(s):
    """Écrivez une fonction vowels_count qui prend une chaîne représentant
    un mot en entrée et renvoie le nombre de voyelles dans la chaîne.
    Les voyelles dans ce cas sont 'a', 'e', 'i', 'o', 'u'. Ici, 'y' est aussi
    une voyelle, mais seulement lorsqu'elle est à la fin du mot donné.

    Exemple :
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """Décalage circulaire des chiffres de l'entier x, décale les chiffres vers la droite par shift
    et renvoie le résultat sous forme de chaîne.
    Si shift > nombre de chiffres, renvoie les chiffres inversés.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Tâche
    Écrire une fonction qui prend une chaîne en entrée et renvoie la somme des codes ASCII
    uniquement des caractères en majuscules.

    Exemples :
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Tâche
    Écrivez une fonction qui prend une chaîne en entrée et renvoie la somme des codes ASCII
    uniquement des caractères en majuscules.

    Exemples :
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    Dans cette tâche, on vous donnera une chaîne qui représente un nombre de pommes et d'oranges
    qui sont distribuées dans un panier de fruits. Ce panier contient
    des pommes, des oranges et des mangues. Étant donné la chaîne qui représente le nombre total de
    oranges et de pommes et un entier qui représente le nombre total de fruits
    dans le panier, renvoie le nombre de mangues dans le panier.
    par exemple :
    fruit_distribution("5 pommes et 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 pommes et 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 pommes et 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 pommes et 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    Dans cette tâche, on vous donnera une chaîne qui représente un nombre de pommes et d'oranges
    qui sont distribuées dans un panier de fruits. Ce panier contient
    des pommes, des oranges et des mangues. Étant donnée la chaîne qui représente le nombre total d'
    oranges et de pommes et un entier qui représente le nombre total de fruits
    dans le panier, renvoyer le nombre de mangues dans le panier.
    par exemple :
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    Dans cette tâche, on vous donnera une chaîne qui représente un nombre de pommes et d'oranges
    qui sont distribuées dans un panier de fruits. Ce panier contient
    des pommes, des oranges et des mangues. Étant donné la chaîne qui représente le nombre total de
    oranges et de pommes et un entier qui représente le nombre total de fruits
    dans le panier, renvoie le nombre de mangues dans le panier.
    par exemple :
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "Étant donné un tableau représentant une branche d'un arbre qui a des nœuds entiers non négatifs,
    votre tâche est de retirer un des nœuds et de le renvoyer.
    Le nœud enlevé doit être le nœud avec la plus petite valeur paire.
    Si plusieurs nœuds ont la même plus petite valeur paire, renvoyez le nœud qui a le plus petit indice.

    Le nœud enlevé doit être renvoyé dans une liste, [ plus_petite_valeur, son_indice ],
    Si aucun nœud n'a de valeurs paires ou si le tableau donné est vide, renvoyez [].

    Exemple 1:
        Entrée: [4,2,3]
        Sortie: [2, 1]
        Explication: 2 a la plus petite valeur paire, et 2 a le plus petit indice.

    Exemple 2:
        Entrée: [1,2,3]
        Sortie: [2, 1]
        Explication: 2 a la plus petite valeur paire, et 2 a le plus petit indice.

    Exemple 3:
        Entrée: []
        Sortie: []

    Exemple 4:
        Entrée: [5, 0, 3, 0, 4, 2]
        Sortie: [0, 1]
        Explication: 0 est la plus petite valeur, mais il y a deux zéros,
                     donc nous choisirons le premier zéro, qui a le plus petit indice.

    Contraintes:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Étant donné un tableau représentant une branche d'un arbre qui a des nœuds entiers non négatifs
    votre tâche est d'arracher un des nœuds et de le renvoyer.
    Le nœud arraché doit être le nœud avec la plus petite valeur paire.
    Si plusieurs nœuds ont la même plus petite valeur paire, renvoyez le nœud qui a le plus petit index.

    Le nœud arraché doit être renvoyé dans une liste, [ plus_petite_valeur, son_index ],
    Si aucun nœud n'a de valeurs paires ou si le tableau donné est vide, renvoyez [].

    Exemple 1:
        Entrée: [4,2,3]
        Sortie: [2, 1]
        Explication: 2 a la plus petite valeur paire, et 2 a le plus petit index.

    Exemple 2:
        Entrée: [1,2,3]
        Sortie: [2, 1]
        Explication: 2 a la plus petite valeur paire, et 2 a le plus petit index.

    Exemple 3:
        Entrée: []
        Sortie: []

    Exemple 4:
        Entrée: [5, 0, 3, 0, 4, 2]
        Sortie: [0, 1]
        Explication: 0 est la plus petite valeur, mais il y a deux zéros,
                     donc nous choisirons le premier zéro, qui a le plus petit index.

    Contraintes:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Étant donné un tableau représentant une branche d'un arbre qui a des nœuds entiers non négatifs,
    votre tâche est d'arracher un des nœuds et de le renvoyer.
    Le nœud arraché doit être le nœud avec la plus petite valeur paire.
    Si plusieurs nœuds ont la même plus petite valeur paire, renvoyez le nœud qui a le plus petit indice.

    Le nœud arraché doit être renvoyé dans une liste, [ plus_petite_valeur, son_indice ],
    Si aucun nœud n'a de valeurs paires ou si le tableau donné est vide, renvoyez [].

    Exemple 1:
        Entrée: [4,2,3]
        Sortie: [2, 1]
        Explication: 2 a la plus petite valeur paire, et 2 a le plus petit indice.

    Exemple 2:
        Entrée: [1,2,3]
        Sortie: [2, 1]
        Explication: 2 a la plus petite valeur paire, et 2 a le plus petit indice.

    Exemple 3:
        Entrée: []
        Sortie: []

    Exemple 4:
        Entrée: [5, 0, 3, 0, 4, 2]
        Sortie: [0, 1]
        Explication: 0 est la plus petite valeur, mais il y a deux zéros,
                     donc nous choisirons le premier zéro, qui a le plus petit indice.

    Contraintes:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    On vous donne une liste non vide d'entiers positifs. Renvoie le plus grand entier qui est supérieur à
    zéro, et a une fréquence supérieure ou égale à la valeur de l'entier lui-même.
    La fréquence d'un entier est le nombre de fois qu'il apparaît dans la liste.
    S'il n'existe pas une telle valeur, retourne -1.
    Exemples :
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    On vous donne une liste non vide d'entiers positifs. Retourner le plus grand entier qui est supérieur à
    zéro, et ayant une fréquence supérieure ou égale à la valeur de l'entier lui-même.
    La fréquence d'un entier est le nombre de fois qu'il apparaît dans la liste.
    S'il n'existe pas une telle valeur, retourner -1.
    Exemples :
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    On vous donne une liste non vide d'entiers positifs. Retourne le plus grand entier qui est supérieur à
    zéro, et a une fréquence supérieure ou égale à la valeur de l'entier lui-même.
    La fréquence d'un entier est le nombre de fois qu'il apparaît dans la liste.
    S'il n'existe pas une telle valeur, retourne -1.
    Exemples :
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    Étant donné une liste d'entiers, renvoie la liste dans un ordre étrange.
    Un ordre étrange, c'est quand vous commencez avec la valeur minimale,
    puis le maximum des entiers restants, puis le minimum et ainsi de suite.

    Exemples :
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Étant donné une liste d'entiers, renvoie la liste dans un ordre étrange.
    Ordre étrange, c'est quand vous commencez avec la valeur minimale,
    puis le maximum des entiers restants, puis le minimum et ainsi de suite.

    Exemples :
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    Étant donné les longueurs des trois côtés d'un triangle. Retourne l'aire du
    triangle arrondie à 2 décimales si les trois côtés forment un triangle valide.
    Sinon, retourne -1.
    Trois côtés forment un triangle valide lorsque la somme de deux côtés quelconques est supérieure
    au troisième côté.
    Exemple :
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Étant données les longueurs des trois côtés d'un triangle. Retourne l'aire du
    triangle arrondie à 2 décimales si les trois côtés forment un triangle valide.
    Sinon, retourne -1.
    Trois côtés forment un triangle valide lorsque la somme de deux côtés quelconques est supérieure
    au troisième côté.
    Exemple :
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    Écrire une fonction qui renvoie True si l'objet q volera, et False sinon.
    L'objet q volera s'il est équilibré (c'est une liste palindromique) et la somme de ses éléments est inférieure ou égale au poids maximum possible w.

    Exemple:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 est inférieur au poids maximum possible, mais il n'est pas équilibré.

    will_it_fly([3, 2, 3], 1) ➞ False
    # il est équilibré, mais 3+2+3 est plus que le poids maximum possible.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 est inférieur au poids maximum possible, et il est équilibré.

    will_it_fly([3], 5) ➞ True
    # 3 est inférieur au poids maximum possible, et il est équilibré.
    '''

def will_it_fly(q,w):
    '''
    Écris une fonction qui renvoie True si l'objet q volera, et False sinon.
    L'objet q volera s'il est équilibré (c'est une liste palindromique) et la somme de ses éléments est inférieure ou égale au poids maximum possible w.

    Exemple:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 est inférieur au poids maximum possible, mais il n'est pas équilibré.

    will_it_fly([3, 2, 3], 1) ➞ False
    # il est équilibré, mais 3+2+3 est plus que le poids maximum possible.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 est inférieur au poids maximum possible, et il est équilibré.

    will_it_fly([3], 5) ➞ True
    # 3 est inférieur au poids maximum possible, et il est équilibré.
    '''

def will_it_fly(q,w):
    '''
    Écrire une fonction qui renvoie True si l'objet q va voler, et False sinon.
    L'objet q va voler s'il est équilibré (c'est une liste palindromique) et que la somme de ses éléments est inférieure ou égale au poids maximum possible w.

    Exemple:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 est inférieur au poids maximum possible, mais il n'est pas équilibré.

    will_it_fly([3, 2, 3], 1) ➞ False
    # il est équilibré, mais 3+2+3 est plus que le poids maximum possible.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 est inférieur au poids maximum possible, et il est équilibré.

    will_it_fly([3], 5) ➞ True
    # 3 est inférieur au poids maximum possible, et il est équilibré.
    '''


def smallest_change(arr):
    """
    Étant donné un tableau arr d'entiers, trouve le nombre minimum d'éléments qui
    doivent être changés pour rendre le tableau palindromique. Un tableau palindromique est un tableau qui
    se lit de la même manière dans un sens et dans l'autre. Dans une modification, on peut remplacer un élément par n'importe quel autre élément.

    Par exemple :
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Étant donné un tableau arr d'entiers, trouve le nombre minimum d'éléments qui
    doivent être changés pour rendre le tableau palindromique. Un tableau palindromique est un tableau qui
    se lit de la même manière à l'envers et à l'endroit. Dans un changement, vous pouvez changer un élément par n'importe quel autre élément.

    Par exemple :
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Étant donné un tableau arr d'entiers, trouve le nombre minimum d'éléments qui
    doivent être changés pour rendre le tableau palindromique. Un tableau palindromique est un tableau qui
    se lit de la même manière à l'envers et à l'endroit. Dans un changement, tu peux changer un élément par n'importe quel autre élément.

    Par exemple :
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    Écrire une fonction qui accepte deux listes de chaînes et renvoie la liste qui a
    le nombre total de caractères dans toutes les chaînes de la liste inférieur à l'autre liste.

    Si les deux listes ont le même nombre de caractères, renvoie la première liste.

    Exemples
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Écris une fonction qui accepte deux listes de chaînes et renvoie la liste qui a
    le nombre total de caractères dans toutes les chaînes de la liste inférieur à l'autre liste.

    si les deux listes ont le même nombre de caractères, renvoie la première liste.

    Exemples
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Écrire une fonction qui accepte deux listes de chaînes et renvoie la liste qui a
    le nombre total de caractères dans toutes les chaînes de la liste inférieur à l'autre liste.

    si les deux listes ont le même nombre de caractères, renvoie la première liste.

    Exemples
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """Écrire une fonction qui renvoie vrai si le nombre donné est le produit de 3 nombres premiers
    et faux dans le cas contraire.
    Sachant que (a) est inférieur à 100.
    Exemple:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Écrire une fonction qui renvoie true si le nombre donné est le produit de
    3 nombres premiers
    et false dans le cas contraire.
    Sachant que (a) est inférieur à 100.
    Exemple:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Écrivez une fonction qui renvoie vrai si le nombre donné est le produit de 3 nombres premiers
    et faux dans le cas contraire.
    Sachant que (a) est inférieur à 100.
    Exemple:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """Votre tâche est d'écrire une fonction qui renvoie vrai si un nombre x est une
    puissance simple de n et faux dans d'autres cas.
    x est une puissance simple de n si nk=x où k est un entier
    Par exemple:
    is_simple_power(1, 4) => True
    is_simple_power(2, 2) => True
    is_simple_power(8, 2) => True
    is_simple_power(3, 2) => False
    is_simple_power(3, 1) => False
    is_simple_power(5, 3) => False
    """

def is_simple_power(x, n):
    """Votre tâche est d'écrire une fonction qui renvoie vrai si un nombre x est une
    puissance simple de n et faux dans d'autres cas.
    x est une puissance simple de n si n**entier=x
    Par exemple:
    is_simple_power(1, 4) => True
    is_simple_power(2, 2) => True
    is_simple_power(8, 2) => True
    is_simple_power(3, 2) => False
    is_simple_power(3, 1) => False
    is_simple_power(5, 3) => False
    """

def is_simple_power(x, n):
    """Votre tâche est d'écrire une fonction qui renvoie true si un nombre x est une
    puissance simple de n et false dans les autres cas.
    x est une puissance simple de n si n**int=x
    Par exemple :
    is_simple_power(1, 4) => vrai
    is_simple_power(2, 2) => vrai
    is_simple_power(8, 2) => vrai
    is_simple_power(3, 2) => faux
    is_simple_power(3, 1) => faux
    is_simple_power(5, 3) => faux
    """


def iscube(a):
    '''
    Écrire une fonction qui prend un entier a et renvoie True
    si cet entier est un cube d'un nombre entier.
    Remarque : vous pouvez supposer que l'entrée est toujours valide.
    Exemples :
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Écrire une fonction qui prend un entier a et retourne True
    si cet entier est un cube d'un nombre entier.
    Remarque : vous pouvez supposer que l'entrée est toujours valide.
    Exemples :
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Écrivez une fonction qui prend un entier a et retourne True
    si cet entier est un cube d'un nombre entier.
    Remarque : vous pouvez supposer que l'entrée est toujours valide.
    Exemples :
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """On vous a demandé d'écrire une fonction qui reçoit
    un nombre hexadécimal sous forme de chaîne et compte le nombre de chiffres
    hexadécimaux qui sont des nombres premiers (un nombre premier, ou premier, est un nombre
    naturel supérieur à 1 qui n'est pas le produit de deux nombres naturels plus petits).
    Les chiffres hexadécimaux sont 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Les nombres premiers sont 2, 3, 5, 7, 11, 13, 17,...
    Vous devez donc déterminer un nombre parmi les chiffres suivants : 2, 3, 5, 7,
    B (=décimal 11), D (=décimal 13).
    Remarque : vous pouvez supposer que l'entrée est toujours correcte ou une chaîne vide,
    et les symboles A, B, C, D, E, F sont toujours en majuscules.
    Exemples :
    Pour num = "AB" la sortie devrait être 1.
    Pour num = "1077E" la sortie devrait être 2.
    Pour num = "ABED1A33" la sortie devrait être 4.
    Pour num = "123456789ABCDEF0" la sortie devrait être 6.
    Pour num = "2020" la sortie devrait être 2.
    """


def decimal_to_binary(decimal):
    """On vous donnera un nombre sous forme décimale et votre tâche est de le convertir en
    format binaire. La fonction doit renvoyer une chaîne, avec chaque caractère représentant un nombre
    binaire. Chaque caractère dans la chaîne sera '0' ou '1'.

    Il y aura une paire supplémentaire de caractères 'db' au début et à la fin de la chaîne.
    Les caractères supplémentaires sont là pour aider avec le formatage.

    Exemples :
    decimal_to_binary(15)   # renvoie "db1111db"
    decimal_to_binary(32)   # renvoie "db100000db"
    """

def decimal_to_binary(decimal):
    """On vous donnera un nombre sous forme décimale et votre tâche est de le convertir en
    format binaire. La fonction doit renvoyer une chaîne, avec chaque caractère représentant un nombre
    binaire. Chaque caractère dans la chaîne sera '0' ou '1'.

    Il y aura quelques caractères 'db' supplémentaires au début et à la fin de la chaîne.
    Les caractères supplémentaires sont là pour aider avec le formatage.

    Exemples :
    decimal_to_binary(15)   # renvoie "db1111db"
    decimal_to_binary(32)   # renvoie "db100000db"
    """


def is_happy(s):
    """On vous donne une chaîne s.
    Votre tâche est de vérifier si la chaîne est heureuse ou non.
    Une chaîne est heureuse si sa longueur est d'au moins 3 et que chaque 3 lettres consécutives sont distinctes
    Par exemple :
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """On vous donne une chaîne s.
    Votre tâche est de vérifier si la chaîne est heureuse ou non.
    Une chaîne est heureuse si sa longueur est d'au moins 3 et que chaque ensemble de 3 lettres consécutives sont distinctes
    Par exemple :
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """On vous donne une chaîne s.
    Votre tâche est de vérifier si la chaîne est heureuse ou non.
    Une chaîne est heureuse si sa longueur est d'au moins 3 et que chaque 3 lettres consécutives sont distinctes
    Par exemple:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """C'est la dernière semaine du semestre et le professeur doit donner les notes
    aux étudiants. Le professeur a créé son propre algorithme pour noter.
    Le seul problème est qu'il a perdu le code qu'il a utilisé pour noter.
    Il vous a donné une liste de GPAs pour certains étudiants et vous devez écrire
    une fonction qui peut renvoyer une liste de notes en lettres en utilisant le tableau suivant :
             GPA       |    Note en lettre
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Exemple :
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """C'est la dernière semaine du semestre et le professeur doit donner les notes
    aux étudiants. Le professeur a créé son propre algorithme pour noter.
    Le seul problème est qu'il a perdu le code qu'il a utilisé pour noter.
    Elle vous a donné une liste de GPAs pour certains étudiants et vous devez écrire
    une fonction qui peut renvoyer une liste de notes en lettres en utilisant le tableau suivant:
             GPA       |    Note en lettre
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Exemple:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """Écris une fonction qui prend une chaîne et renvoie True si la longueur
    de la chaîne est un nombre premier ou False dans le cas contraire
    Exemples
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Écrire une fonction qui prend une chaîne et renvoie True si la longueur
    de la chaîne est un nombre premier ou False dans le cas contraire
    Exemples
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Étant donné un nombre entier positif n, retourne le nombre
    d'entiers positifs de n chiffres qui commencent ou se terminent par 1.
    """

def starts_one_ends(n):
    """
    Étant donné un nombre entier positif n, retourne la quantité de nombres de
    n chiffres qui commencent ou se terminent par 1.
    """

def starts_one_ends(n):
    """
    Étant donné un nombre entier positif n, retournez la quantité de nombres de
    n chiffres qui commencent ou se terminent par 1.
    """


def solve(N):
    """Étant donné un entier positif N, renvoie la somme totale de ses chiffres en binaire.

    Exemple
        Pour N = 1000, la somme des chiffres sera 1 et la sortie doit être "1".
        Pour N = 150, la somme des chiffres sera 6 et la sortie doit être "110".
        Pour N = 147, la somme des chiffres sera 12 et la sortie doit être "1100".

    Variables:
        @N entier
             Contraintes : 0 ≤ N ≤ 10000.
    Sortie:
         une chaîne de nombre binaire
    """

def solve(N):
    """Étant donné un entier positif N, renvoie la somme totale de ses chiffres en binaire.

    Exemple
        Pour N = 1000, la somme des chiffres sera 1 et la sortie doit être "1".
        Pour N = 150, a somme des chiffres sera 6 et la sortie doit être "110".
        Pour N = 147, la somme des chiffres sera 12 et la sortie doit être "1100".

    Variables:
        @N entier
             Contraintes: 0 ≤ N ≤ 10000.
    Sortie:
         une chaîne de nombre binaire
    """


def add(lst):
    """Étant donné une liste non vide d'entiers lst, additionne les éléments pairs qui sont à des indices impairs.

    Exemples :
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Étant donné une liste non vide d'entiers lst, additionne les éléments pairs qui sont à des indices impairs..

    Exemples :
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Étant donné une liste non vide d'entiers lst, additionnez les éléments pairs qui sont à des indices impairs.

    Exemples :
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Écris une fonction qui prend une chaîne et renvoie une version triée de celle-ci.
    La version triée de la chaîne est une chaîne où tous les mots (séparés par un espace)
    sont remplacés par un nouveau mot où tous les caractères sont triés par
    ordre croissant basé sur la valeur ascii.
    Remarque : Vous devez conserver l'ordre des mots et les espaces dans la phrase.

    Par exemple :
    anti_shuffle('Hi') renvoie 'Hi'
    anti_shuffle('hello') renvoie 'ehllo'
    anti_shuffle('Hello World!!!') renvoie 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Écris une fonction qui prend une chaîne et renvoie une version triée de celle-ci.
    La version triée de la chaîne est une chaîne où tous les mots (séparés par un espace)
    sont remplacés par un nouveau mot où tous les caractères sont triés par
    ordre croissant basé sur la valeur ascii.
    Remarque : tu dois conserver l'ordre des mots et les espaces dans la phrase.

    Par exemple :
    anti_shuffle('Hi') renvoie 'Hi'
    anti_shuffle('hello') renvoie 'ehllo'
    anti_shuffle('Hello World!!!') renvoie 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Écrire une fonction qui prend une chaîne et renvoie une version triée de celle-ci.
    La version triée de la chaîne est une chaîne où tous les mots (séparés par un espace)
    sont remplacés par un nouveau mot où tous les caractères sont triés par
    ordre croissant basé sur la valeur ascii.
    Remarque : Vous devez conserver l'ordre des mots et les espaces dans la phrase.

    Par exemple :
    anti_shuffle('Hi') renvoie 'Hi'
    anti_shuffle('hello') renvoie 'ehllo'
    anti_shuffle('Hello World!!!') renvoie 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    On vous donne une donnée bidimensionnelle, comme des listes imbriquées,
    qui est similaire à une matrice, cependant, contrairement aux matrices,
    chaque ligne peut contenir un nombre différent de colonnes.
    Étant donné lst, et un entier x, trouvez les entiers x dans la liste,
    et renvoyez une liste de tuples, [(x1, y1), (x2, y2) ...] telle que
    chaque tuple est une coordonnée - (ligne, colonne), en commençant par 0.
    Triez les coordonnées initialement par lignes dans l'ordre croissant.
    De plus, triez les coordonnées de la ligne par colonnes dans l'ordre décroissant.

    Exemples :
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    On vous fournit une donnée bidimensionnelle, comme des listes imbriquées,
    qui est similaire à une matrice, cependant, contrairement aux matrices,
    chaque ligne peut contenir un nombre différent de colonnes.
    Étant donné lst, et un entier x, trouvez les entiers x dans la liste,
    et renvoyez une liste de tuples, [(x1, y1), (x2, y2) ...] telle que
    chaque tuple est une coordonnée - (ligne, colonne), en commençant par 0.
    Triez les coordonnées initialement par lignes dans l'ordre croissant.
    De plus, triez les coordonnées de la ligne par colonnes dans l'ordre décroissant.

    Exemples :
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    Étant donné un tableau d'entiers non négatifs, renvoie une copie du tableau donné après l'avoir trié,
    on triera le tableau donné par ordre croissant si la somme (valeur du premier indice, valeur du dernier indice) est impaire,
    ou on le triera par ordre décroissant si la somme (valeur du premier indice, valeur du dernier indice) est paire.

    Remarque :
    * ne change pas le tableau donné.

    Exemples :
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Étant donné un tableau d'entiers non négatifs, renvoie une copie du tableau donné après l'avoir trié,
    tu trieras le tableau donné par ordre croissant si la somme (valeur du premier indice, valeur du dernier indice) est impaire,
    ou tu le trieras par ordre décroissant si la somme (valeur du premier indice, valeur du dernier indice) est paire.

    Remarque :
    * ne change pas le tableau donné.

    Exemples :
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """Créer une fonction encrypt qui prend une chaîne comme argument et
    retourne une chaîne chiffrée avec une rotation de l'alphabet.
    La rotation de l'alphabet doit être effectuée de telle manière à ce que les lettres
    se déplacent vers le bas de deux multiplié par deux places.
    Par exemple :
    encrypt('hi') retourne 'lm'
    encrypt('asdfghjkl') retourne 'ewhjklnop'
    encrypt('gf') retourne 'kj'
    encrypt('et') retourne 'ix'
    """

def encrypt(s):
    """Créez une fonction encrypt qui prend une chaîne comme argument et
    retourne une chaîne chiffrée avec l'alphabet décalé.
    L'alphabet doit être décalé de manière que les lettres se déplacent de quatre places vers le bas.
    Par exemple:
    encrypt('hi') retourne 'lm'
    encrypt('asdfghjkl') retourne 'ewhjklnop'
    encrypt('gf') retourne 'kj'
    encrypt('et') retourne 'ix'
    """

def encrypt(s):
    """Créer une fonction encrypt qui prend une chaîne comme argument et
    renvoie une chaîne chiffrée avec permutation de l'alphabet.
    L'alphabet doit être permuté de manière que les lettres
    se déplacent vers le bas de deux multiplié par deux places.
    Par exemple :
    encrypt('hi') renvoie 'lm'
    encrypt('asdfghjkl') renvoie 'ewhjklnop'
    encrypt('gf') renvoie 'kj'
    encrypt('et') renvoie 'ix'
    """


def next_smallest(lst):
    """
    On vous donne une liste d'entiers.
    Écrivez une fonction next_smallest() qui renvoie le 2ème élément le plus petit de la liste.
    Renvoie None s'il n'y a pas un tel élément.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    On vous donne une liste d'entiers.
    Écrivez une fonction next_smallest() qui renvoie le 2ème élément le plus petit de la liste.
    Renvoie None si un tel élément n'existe pas.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    On vous donne une liste d'entiers.
    Écrivez une fonction next_smallest() qui renvoie le 2ème élément le plus petit de la liste.
    Renvoyez None s'il n'y a pas de tel élément.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """


def is_bored(S):
    """
    On vous donnera une chaîne de mots, et votre tâche est de compter le nombre
    de phrases d'ennui. Une phrase d'ennui est une phrase qui commence par le mot "I".
    Les phrases sont délimitées par '.', '?' ou '!'.

    Par exemple :
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Vous recevrez une chaîne de mots, et votre tâche sera de compter le nombre
    de phrases d'ennui. Une phrase d'ennui est une phrase qui commence par le mot "I".
    Les phrases sont délimitées par '.', '?' ou '!'.

    Par exemple:
    >>> is_bored("Bonjour tout le monde")
    0
    >>> is_bored("Le ciel est bleu. Le soleil brille. J'aime ce temps")
    1
    """

def is_bored(S):
    """
    On vous donnera une chaîne de mots, et votre tâche sera de compter le nombre
    de phrases d'ennui. Une phrase d'ennui est une phrase qui commence par le mot "I".
    Les phrases sont délimitées par '.', '?' ou '!'.

    Par exemple:
    >>> is_bored("Bonjour le monde")
    0
    >>> is_bored("Le ciel est bleu. Le soleil brille. J'aime ce temps")
    1
    """


def any_int(x, y, z):
    '''
    Créer une fonction qui prend 3 nombres.
    Retourne vrai si l'un des nombres est égal à la somme des deux autres, et que tous les nombres sont entiers.
    Retourne faux dans tout autre cas.

    Exemples
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Créer une fonction qui prend 3 nombres.
    Retourne true si l'un des nombres est égal à la somme des deux autres, et que tous les nombres sont entiers.
    Retourne false dans tous les autres cas.

    Exemples
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Créez une fonction qui prend 3 nombres.
    Retourne vrai si l'un des nombres est égal à la somme des deux autres, et que tous les nombres sont entiers.
    Retourne faux dans tout autre cas.

    Exemples
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    Écrire une fonction qui prend un message et le code de telle
    manière qu'elle change la casse de toutes les lettres, remplace toutes les voyelles dans
    le message par la lettre qui apparaît 2 places après cette
    voyelle dans l'alphabet anglais.
    Supposer qu'on a uniquement des lettres.

    Exemples:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Écris une fonction qui prend un message et le code de telle
    manière qu'elle change la casse de toutes les lettres, remplace
    toutes les voyelles dans le message par la lettre qui apparaît
    2 places après cette voyelle dans l'alphabet anglais.
    Suppose uniquement des lettres.

    Exemples:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Écrire une fonction qui prend un message et le code de telle
    manière qu'elle change la casse de toutes les lettres, remplace
    toutes les voyelles dans le message par la lettre qui apparaît
    2 places après cette voyelle dans l'alphabet anglais.
    Supposer uniquement des lettres.

    Exemples:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """On vous donne une liste d'entiers.
    Vous devez trouver la plus grande valeur première et renvoyer la somme de ses chiffres.

    Exemples :
    Pour lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] la sortie devrait être 10
    Pour lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] la sortie devrait être 25
    Pour lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] la sortie devrait être 13
    Pour lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] la sortie devrait être 11
    Pour lst = [0,81,12,3,1,21] la sortie devrait être 3
    Pour lst = [0,8,1,2,1,7] la sortie devrait être 7
    """

def skjkasdkd(lst):
    """On vous donne une liste d'entiers.
    Vous devez trouver la plus grande valeur première et retourner la somme de ses chiffres.

    Exemples :
    Pour lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] la sortie devrait être 10
    Pour lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] la sortie devrait être 25
    Pour lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] la sortie devrait être 13
    Pour lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] la sortie devrait être 11
    Pour lst = [0,81,12,3,1,21] la sortie devrait être 3
    Pour lst = [0,8,1,2,1,7] la sortie devrait être 7
    """


def check_dict_case(dict):
    """
    Étant donné un dictionnaire, renvoie True si toutes les clés sont des chaînes en minuscules
    ou si toutes les clés sont des chaînes en majuscules, sinon renvoie False.
    La fonction doit renvoyer False si le dictionnaire donné est vide.
    Exemples :
    check_dict_case({"a":"apple", "b":"banana"}) devrait renvoyer True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) devrait renvoyer False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) devrait renvoyer False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) devrait renvoyer False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) devrait renvoyer True.
    """

def check_dict_case(dict):
    """
    Étant donné un dictionnaire, renvoie True si toutes les entrées sont des chaînes en minuscules
    ou si toutes les entrées sont des chaînes en majuscules, sinon renvoie False.
    La fonction doit renvoyer False si le dictionnaire donné est vide.
    Exemples :
    check_dict_case({"a":"apple", "b":"banana"}) devrait renvoyer True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) devrait renvoyer False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) devrait renvoyer False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) devrait renvoyer False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) devrait renvoyer True.
    """


def count_up_to(n):
    """Implémentez une fonction qui prend un entier non négatif et renvoie un tableau des n premiers
    entiers qui sont des nombres premiers et inférieurs à la valeur n.
    par exemple:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Implémentez une fonction qui prend un entier non négatif et renvoie un tableau des premiers n
    entiers qui sont des nombres premiers et inférieurs à n.
    par exemple:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """Complète la fonction qui prend deux entiers et renvoie
    le produit de leurs chiffres des unités.
    On suppose que l'entrée est toujours valide.
    Exemples :
    multiply(148, 412) devrait renvoyer 16.
    multiply(19, 28) devrait renvoyer 72.
    multiply(2020, 1851) devrait renvoyer 0.
    multiply(14,-15) devrait renvoyer 20.
    """

def multiply(a, b):
    """Complète la fonction qui prend deux entiers et renvoie
    le produit de leurs chiffres des unités.
    Supposons que l'entrée est toujours valide.
    Exemples :
    multiply(148, 412) devrait renvoyer 16.
    multiply(19, 28) devrait renvoyer 72.
    multiply(2020, 1851) devrait renvoyer 0.
    multiply(14,-15) devrait renvoyer 20.
    """

def multiply(a, b):
    """Complète la fonction qui prend deux entiers et renvoie
    le produit de leurs chiffres des unités.
    Suppose que l'entrée est toujours valide.
    Exemples :
    multiply(148, 412) devrait renvoyer 16.
    multiply(19, 28) devrait renvoyer 72.
    multiply(2020, 1851) devrait renvoyer 0.
    multiply(14,-15) devrait renvoyer 20.
    """


def count_upper(s):
    """
    Étant donné une chaîne s, compte le nombre de voyelles majuscules aux indices pairs.

    Par exemple :
    count_upper('aBCdEf') renvoie 1
    count_upper('abcdefg') renvoie 0
    count_upper('dBBE') renvoie 0
    """

def count_upper(s):
    """
    Étant donnée une chaîne s, compte le nombre de voyelles majuscules aux indices pairs.

    Par exemple :
    count_upper('aBCdEf') renvoie 1
    count_upper('abcdefg') renvoie 0
    count_upper('dBBE') renvoie 0
    """


def closest_integer(value):
    '''
    Créez une fonction qui prend une valeur (chaîne) représentant un nombre
    et renvoie l'entier le plus proche de celui-ci. Si le nombre est équidistant
    de deux entiers, arrondissez en vous éloignant de zéro.

    Exemples
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Remarque :
    Arrondir en s'éloignant de zéro signifie que si le nombre donné est équidistant
    de deux entiers, celui que vous devez renvoyer est celui qui est le
    plus éloigné de zéro. Par exemple, closest_integer("14.5") devrait
    renvoyer 15 et closest_integer("-14.5") devrait renvoyer -15.
    '''

def closest_integer(value):
    '''
    Créez une fonction qui prend une valeur (chaîne) représentant un nombre
    et renvoie l'entier le plus proche de celui-ci. Si le nombre est équidistant
    de deux entiers, l'arrondir en l'éloignant de zéro.

    Exemples
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Remarque :
    Arrondir en s'éloignant de zéro signifie que si le nombre donné est équidistant
    de deux entiers, celui que vous devez renvoyer est celui qui est le
    plus éloigné de zéro. Par exemple, closest_integer("14.5") devrait
    renvoyer 15 et closest_integer("-14.5") devrait renvoyer -15.
    '''

def closest_integer(value):
    '''
    Créez une fonction qui prend une valeur (chaîne) représentant un nombre
    et renvoie l'entier le plus proche de celui-ci. Si le nombre est équidistant
    de deux entiers, arrondissez en vous éloignant de zéro.

    Exemples
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Remarque:
    Arrondir en s'éloignant de zéro signifie que si le nombre donné est équidistant
    de deux entiers, celui que vous devez renvoyer est celui qui est le plus éloigné de zéro. Par exemple closest_integer("14.5") devrait
    renvoyer 15 et closest_integer("-14.5") devrait renvoyer -15.
    '''


def make_a_pile(n):
    """
    Étant donné un nombre entier positif n, vous devez faire une pile de n niveaux de pierres.
    Le premier niveau a n pierres.
    Le nombre de pierres au niveau suivant est :
        - le nombre impair suivant si n est impair.
        - le nombre pair suivant si n est pair.
    Retourne le nombre de pierres à chaque niveau dans une liste, où l'élément à l'indice
    i représente le nombre de pierres au niveau (i+1).

    Exemples :
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Étant donné un nombre entier positif n, vous devez faire une pile de n niveaux de pierres.
    Le premier niveau a n pierres.
    Le nombre de pierres au niveau suivant est:
        - le nombre impair suivant si n est impair.
        - le nombre pair suivant si n est pair.
    Retourne le nombre de pierres à chaque niveau dans une liste, où l'élément à l'indice
    i représente le nombre de pierres au niveau (i+1).

    Exemples:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Étant donné un nombre entier positif n, vous devez faire une pile de n niveaux de pierres.
    Le premier niveau a n pierres.
    Le nombre de pierres au niveau suivant est :
        - le nombre impair suivant si n est impair.
        - le nombre pair suivant si n est pair.
    Retourner le nombre de pierres à chaque niveau dans une liste, où l'élément à l'indice
    i représente le nombre de pierres au niveau (i+1).

    Exemples :
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    On vous donnera une chaîne de mots séparés par des virgules ou des espaces. Votre tâche est
    de diviser la chaîne en mots et de retourner un tableau des mots.

    Par exemple :
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    On vous donnera une chaîne de mots séparés par des virgules ou des espaces. Votre tâche est
    de diviser la chaîne en mots et de retourner un tableau des mots.

    Par exemple:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """Cette fonction prend deux nombres positifs x et y et renvoie le
    plus grand nombre entier pair qui se trouve dans l'intervalle [x, y] inclus. Si
    aucun tel nombre n'existe, alors la fonction doit renvoyer -1.

    Par exemple :
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Cette fonction prend deux nombres positifs x et y et renvoie le
    plus grand nombre entier pair qui se trouve dans l'intervalle [x, y] inclus. Si
    aucun nombre tel que celui-ci n'existe, alors la fonction doit renvoyer -1.

    Par exemple :
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Cette fonction prend deux nombres positifs x et y et renvoie le
    plus grand nombre entier pair qui se trouve dans l'intervalle [x, y] inclus. Si
    aucun tel nombre n'existe, alors la fonction doit renvoyer -1.

    Par exemple:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """On vous donne deux entiers positifs n et m, et votre tâche est de calculer la
    moyenne des entiers de n à m (y compris n et m).
    Arrondissez la réponse à l'entier le plus proche et convertissez-la en binaire.
    Si n est supérieur à m, renvoyez -1.
    Exemple :
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Étant donné une liste d'entiers positifs x, renvoie une liste triée de tous
    les éléments qui n'ont aucun chiffre pair.

    Remarque : La liste renvoyée doit être triée par ordre croissant.

    Par exemple :
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Étant donné un tableau d'entiers, triez les entiers qui sont entre 1 et 9 inclus,
    inversez le tableau résultant, puis remplacez chaque chiffre par son nom correspondant de
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Par exemple :
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> trier arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> inverser arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Si le tableau est vide, renvoie un tableau vide :
      arr = []
      return []

      Si le tableau contient un nombre étrange, ignorez-le :
      arr = [1, -1 , 55]
            -> trier arr -> [-1, 1, 55]
            -> inverser arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Pour un tableau d'entiers, triez les entiers qui sont entre 1 et 9 inclus,
    inversez le tableau résultant, puis remplacez chaque chiffre par son nom correspondant de
    "Un", "Deux", "Trois", "Quatre", "Cinq", "Six", "Sept", "Huit", "Neuf".

    Par exemple:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> trier arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> inverser arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Huit", "Cinq", "Quatre", "Trois", "Deux", "Deux", "Un", "Un"]

      Si le tableau est vide, renvoie un tableau vide:
      arr = []
      return []

      Si le tableau contient un nombre non valide, ignorez-le:
      arr = [1, -1 , 55]
            -> trier arr -> [-1, 1, 55]
            -> inverser arr -> [55, 1, -1]
      return = ['Un']
    """

def par_longueur(arr):
    """
    Étant donné un tableau d'entiers, triez les entiers qui sont entre 1 et 9 inclus,
    inversez le tableau résultant, puis remplacez chaque chiffre par son nom correspondant de
    "Un", "Deux", "Trois", "Quatre", "Cinq", "Six", "Sept", "Huit", "Neuf".

    Par exemple:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> trier arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> inverser arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Huit", "Cinq", "Quatre", "Trois", "Deux", "Deux", "Un", "Un"]

      Si le tableau est vide, renvoie un tableau vide:
      arr = []
      return []

      Si le tableau contient un nombre étrange, ignorez-le:
      arr = [1, -1 , 55]
            -> trier arr -> [-1, 1, 55]
            -> inverser arr -> [55, 1, -1]
      return ['Un']
    """


def f(n):
    """ Implémentez la fonction f qui prend n comme paramètre,
    et renvoie une liste de taille n, telle que la valeur de l'élément à l'indice i soit le factoriel de i si i est pair
    ou la somme des nombres de 1 à i sinon.
    i commence à partir de 1.
    le factoriel de i est la multiplication des nombres de 1 à i (1 * 2 * ... * i).
    Exemple :
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Implémente la fonction f qui prend n comme paramètre,
    et renvoie une liste de taille n, telle que la valeur de l'élément à l'indice i soit le factoriel de i si i est pair
    ou la somme des nombres de 1 à i sinon.
    i commence à partir de 1.
    le factoriel de i est la multiplication des nombres de 1 à i (1 * 2 * ... * i).
    Exemple :
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Étant donné un entier positif n, renvoie un tuple qui contient le nombre de palindromes
    entiers pairs et impairs qui se trouvent dans l'intervalle (1, n), inclus.

    Exemple 1 :

        Entrée : 3
        Sortie : (1, 2)
        Explication :
        Les palindromes entiers sont 1, 2, 3. L'un d'eux est pair, et deux d'entre eux sont impairs.

    Exemple 2 :

        Entrée : 12
        Sortie : (4, 6)
        Explication :
        Les palindromes entiers sont 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Quatre d'entre eux sont pairs, et 6 d'entre eux sont impairs.

    Remarque :
        1. 1 <= n <= 10^3
        2. le tuple retourné contient le nombre de palindromes entiers pairs et impairs respectivement.
    """

def even_odd_palindrome(n):
    """
    Étant donné un entier positif n, renvoie un tuple qui contient le nombre de palindromes
    entiers pairs et impairs qui se trouvent dans l'intervalle (1, n), inclusivement.

    Exemple 1 :

        Entrée : 3
        Sortie : (1, 2)
        Explication :
        Les palindromes entiers sont 1, 2, 3. L'un d'eux est pair, et deux d'entre eux sont impairs.

    Exemple 2 :

        Entrée : 12
        Sortie : (4, 6)
        Explication :
        Les palindromes entiers sont 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Quatre d'entre eux sont pairs, et 6 d'entre eux sont impairs.

    Remarque :
        1. 1 <= n <= 10^3
        2. le tuple retourné contient le nombre de palindromes entiers pairs et impairs respectivement.
    """


def count_nums(arr):
    """
    Écris une fonction count_nums qui prend un tableau d'entiers et renvoie
    le nombre d'éléments ayant une somme de chiffres > 0.
    Si un nombre est négatif, alors son premier chiffre avec signe sera négatif :
    par exemple, -123 a des chiffres avec signe -1, 2 et 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Écrire une fonction count_nums qui prend un tableau d'entiers et renvoie
    le nombre d'éléments ayant une somme de chiffres > 0.
    Si un nombre est négatif, alors son premier chiffre avec signe sera négatif:
    par exemple -123 a des chiffres avec signe -1, 2, et 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Écrire une fonction count_nums qui prend un tableau d'entiers et renvoie
    le nombre d'éléments ayant une somme de chiffres > 0.
    Si un nombre est négatif, alors son premier chiffre avec signe sera négatif :
    par exemple, -123 a des chiffres avec signe -1, 2 et 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """