def move_one_ball(arr):
    """Nous avons un tableau 'arr' de N entiers arr[1], arr[2], ..., arr[N]. Les
    nombres dans le tableau seront ordonnés aléatoirement. Votre tâche est de déterminer s'il
    est possible d'obtenir un tableau ordonné en ordre non décroissant en réalisant
    l'opération suivante sur le tableau donné :
        Vous êtes autorisé à effectuer l'opération de décalage à droite un nombre quelconque de fois.

    Une opération de décalage à droite signifie déplacer tous les éléments du tableau d'une
    position vers la droite. Le dernier élément du tableau se déplacera à
    la position initiale dans le tableau, c'est-à-dire à l'indice 0.

    S'il est possible d'obtenir le tableau ordonné en réalisant l'opération précédente,
    alors renvoyez True, sinon renvoyez False.
    Si le tableau donné est vide, renvoyez True.

    Remarque : Il est garanti que les éléments de la liste donnée sont uniques.

    Par exemple :

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explication : En réalisant 2 opérations de décalage à droite, il est possible
                 d'obtenir un ordre non décroissant pour le tableau donné.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Explication : Il n'est pas possible d'obtenir un ordre non décroissant pour le
                tableau donné en réalisant un nombre quelconque d'opérations de décalage à droite.

    """

def move_one_ball(arr):
    """Nous avons un tableau 'arr' de N entiers arr[1], arr[2], ..., arr[N]. Les
    nombres dans le tableau seront ordonnés aléatoirement. Votre tâche est de déterminer s'il
    est possible d'obtenir un tableau ordonné en ordre non décroissant en réalisant
    l'opération suivante sur le tableau donné :
        Vous êtes autorisé à effectuer l'opération de décalage à droite un nombre quelconque de fois.

    Une opération de décalage à droite signifie déplacer tous les éléments du tableau
    d'une position vers la droite. Le dernier élément du tableau se déplacera à
    la position initiale dans le tableau, c'est-à-dire à l'indice 0.

    S'il est possible d'obtenir le tableau ordonné en réalisant l'opération précédente,
    alors renvoyez True, sinon renvoyez False.
    Si le tableau donné est vide, renvoyez True.

    Remarque : Il est garanti que la liste donnée a des éléments uniques.

    Par exemple :

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explication : En réalisant 2 opérations de décalage à droite, il est possible
                 d'obtenir un ordre non décroissant pour le tableau donné.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Explication : Il n'est pas possible d'obtenir un ordre non décroissant pour le
                tableau donné en réalisant un nombre quelconque d'opérations de décalage à droite.

    """

def move_one_ball(arr):
    """Nous avons un tableau 'arr' de N entiers arr[1], arr[2], ..., arr[N].Les
    nombres dans le tableau seront ordonnés aléatoirement. Votre tâche est de déterminer s'il est possible d'obtenir un tableau ordonné en ordre non décroissant en réalisant
    l'opération suivante sur le tableau donné:
        Vous êtes autorisé à effectuer l'opération de décalage à droite un nombre quelconque de fois.

    Une opération de décalage à droite signifie déplacer tous les éléments du tableau
    d'une position dans la direction droite. Le dernier élément du tableau se déplacera à
    la position initiale dans le tableau, c'est-à-dire à l'indice 0.

    S'il est possible d'obtenir le tableau ordonné en réalisant l'opération précédente,
    alors renvoyez True sinon renvoyez False.
    Si le tableau donné est vide alors renvoyez True.

    Remarque: Il est garanti que la liste donnée a des éléments uniques.

    Par exemple:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explication: En réalisant 2 opérations de décalage à droite, il est possible
                 d'obtenir un ordre non décroissant pour le tableau donné.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Explication:Il n'est pas possible d'obtenir un ordre non décroissant pour le
                tableau donné en réalisant un nombre quelconque d'opérations de décalage à droite.

    """


def exchange(lst1, lst2):
    """Dans ce problème, vous allez implémenter une fonction qui prend deux listes de nombres,
    et détermine s'il est possible de réaliser un échange d'éléments
    entre elles pour faire en sorte que lst1 ne soit qu'une liste de nombres pairs.
    Il n'y a pas de limite au nombre d'éléments échangés entre lst1 et lst2.
    S'il est possible d'échanger des éléments entre lst1 et lst2 pour que
    tous les éléments de lst1 soient pairs, renvoie "YES".
    Sinon, renvoie "NO".
    Par exemple :
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    On suppose que les listes d'entrée ne seront pas vides.
    """

def exchange(lst1, lst2):
    """Dans ce problème, vous allez implémenter une fonction qui prend deux listes de nombres,
    et détermine s'il est possible de réaliser un échange d'éléments
    entre elles pour faire en sorte que lst1 soit une liste de nombres pairs exclusivement.
    Il n'y a pas de limite au nombre d'éléments échangés entre lst1 et lst2.
    S'il est possible d'échanger des éléments entre lst1 et lst2 pour que
    tous les éléments de lst1 soient pairs, renvoyer "YES".
    Sinon, renvoyer "NO".
    Par exemple :
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    On suppose que les listes d'entrée ne seront pas vides.
    """

def exchange(lst1, lst2):
    """Dans ce problème, tu vas implémenter une fonction qui prend deux listes de nombres,
    et détermine s'il est possible de réaliser un échange d'éléments
    entre elles pour faire en sorte que lst1 soit une liste de seuls nombres pairs.
    Il n'y a pas de limite au nombre d'éléments échangés entre lst1 et lst2.
    S'il est possible d'échanger des éléments entre lst1 et lst2 pour que
    tous les éléments de lst1 soient pairs, renvoie "YES".
    Sinon, renvoie "NO".
    Par exemple :
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    On suppose que les listes d'entrée ne seront pas vides.
    """


def histogram(test):
    """Étant donné une chaîne qui représente des lettres minuscules séparées par des espaces, retourne un dictionnaire
    de la lettre avec le plus de répétitions et qui contient le compte correspondant.
    Si plusieurs lettres ont la même occurrence, les retourner toutes.

    Exemple:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Étant donnée une chaîne représentant des lettres minuscules séparées par des espaces, retourne un dictionnaire
    de la lettre avec le plus de répétitions et contenant le compte correspondant.
    Si plusieurs lettres ont la même occurrence, les retourne toutes.

    Exemple:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Étant donné une chaîne qui représente des lettres minuscules séparées par des espaces, renvoie un dictionnaire
    de la lettre avec le plus de répétitions et qui contient le compte correspondant.
    Si plusieurs lettres ont la même occurrence, renvoie-les toutes.

    Exemple:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """Tâche
    On nous donne deux chaînes s et c, vous devez supprimer tous les caractères dans s qui sont égaux à n'importe quel caractère dans c
    puis vérifier si la chaîne résultante est un palindrome.
    Une chaîne est appelée palindrome si elle se lit de la même manière de l'avant vers l'arrière que de l'arrière vers l'avant.
    Vous devez retourner un tuple contenant la chaîne résultante et True/False pour la vérification.
    Exemple
    Pour s = "abcde", c = "ae", le résultat devrait être ('bcd',False)
    Pour s = "abcdef", c = "b" le résultat devrait être ('acdef',False)
    Pour s = "abcdedcba", c = "ab", le résultat devrait être ('cdedc',True)
    """

def reverse_delete(s,c):
    """Tâche
    On nous donne deux chaînes s et c, vous devez supprimer tous les caractères dans s qui sont égaux à n'importe quel caractère dans c
    puis vérifier si la chaîne résultante est un palindrome.
    Une chaîne est appelée palindrome si elle se lit de la même manière de l'avant vers l'arrière que de l'arrière vers l'avant.
    Vous devez renvoyer un tuple contenant la chaîne résultante et True/False pour la vérification.
    Exemple
    Pour s = "abcde", c = "ae", le résultat devrait être ('bcd',False)
    Pour s = "abcdef", c = "b" le résultat devrait être ('acdef',False)
    Pour s = "abcdedcba", c = "ab", le résultat devrait être ('cdedc',True)
    """


def odd_count(lst):
    """Étant donné une liste de chaînes, où chaque chaîne ne consiste qu'en chiffres, renvoie une liste.
    Chaque élément i de la sortie doit être "le nombre d'éléments impairs dans la
    chaîne i de l'entrée." où tous les i doivent être remplacés par le nombre
    de chiffres impairs dans la i-ème chaîne de l'entrée.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """Étant donnée une liste de chaînes, où chaque chaîne ne consiste qu'en chiffres, renvoie une liste.
    Chaque élément i de la sortie doit être "le nombre d'éléments impairs dans la
    chaîne i de l'entrée." où tous les i doivent être remplacés par le nombre
    de chiffres impairs dans la i-ème chaîne de l'entrée.

    >>> odd_count(['1234567'])
    ["le nombre d'éléments impairs d4ns la cha4ne 4 de l'4ntrée."]
    >>> odd_count(['3',"11111111"])
    ["le nombre d'éléments impairs d1ns la cha1ne 1 de l'1ntrée.",
     "le nombre d'éléments impairs d8ns la cha8ne 8 de l'8ntrée."]
    """

def odd_count(lst):
    """Étant donné une liste de chaînes, où chaque chaîne ne consiste qu'en chiffres, renvoie une liste.
    Chaque élément i de la sortie doit être "le nombre d'éléments impairs dans la
    chaîne i de l'entrée." où tous les i doivent être remplacés par le nombre
    de chiffres impairs dans la i-ème chaîne de l'entrée.

    >>> odd_count(['1234567'])
    ["le nombre d'éléments 4mpa4rs dans la chaîne 4 de l'entrée."]
    >>> odd_count(['3',"11111111"])
    ["le nombre d'éléments impairs dans la chaîne 1 de l'entrée.",
     "le nombre d'éléments impairs dans la chaîne 8 de l'entrée."]
    """


def minSubArraySum(nums):
    """
    Étant donné un tableau d'entiers nums, trouve la somme minimale de tout sous-tableau
    non vide de nums.
    Exemple
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    On vous donne une grille rectangulaire de puits. Chaque ligne représente un seul puits,
    et chaque 1 dans une ligne représente une seule unité d'eau.
    Chaque puits a un seau correspondant qui peut être utilisé pour extraire de l'eau de celui-ci,
    et tous les seaux ont la même capacité.
    Votre tâche est d'utiliser les seaux pour vider les puits.
    Retournez le nombre de fois que vous devez descendre les seaux.

    Exemple 1:
        Entrée:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Sortie: 6

    Exemple 2:
        Entrée:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Sortie: 5

    Exemple 3:
        Entrée:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Sortie: 0

    Contraintes:
        * tous les puits ont la même longueur
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    On vous donne une grille rectangulaire de puits. Chaque ligne représente un seul puits,
    et chaque 1 dans une ligne représente une seule unité d'eau.
    Chaque puits a un seau correspondant qui peut être utilisé pour en extraire de l'eau,
    et tous les seaux ont la même capacité.
    Votre tâche est d'utiliser les seaux pour vider les puits.
    Indiquez en sortie le nombre de fois que vous devez vider les seaux.

    Exemple 1:
        Entrée:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Sortie: 6

    Exemple 2:
        Entrée:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Sortie: 5

    Exemple 3:
        Entrée:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Sortie: 0

    Contraintes:
        * tous les puits ont la même longueur
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    On vous donne une grille rectangulaire de puits. Chaque ligne représente un seul puits,
    et chaque 1 dans une ligne représente une seule unité d'eau.
    Chaque puits a un seau correspondant qui peut être utilisé pour extraire de l'eau de celui-ci,
    et tous les seaux ont la même capacité.
    Votre tâche est d'utiliser les seaux pour vider les puits.
    Sortez le nombre de fois que vous devez descendre les seaux.

    Exemple 1:
        Entrée:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Sortie: 6

    Exemple 2:
        Entrée:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Sortie: 5

    Exemple 3:
        Entrée:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Sortie: 0

    Contraintes:
        * tous les puits ont la même longueur
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    Dans ce Kata, vous devez trier un tableau d'entiers non négatifs selon
    le nombre de uns dans leur représentation binaire en ordre croissant.
    Pour un nombre similaire de uns, trier basé sur la valeur décimale.

    Doit être implémenté ainsi :
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    Dans ce Kata, vous devez trier un tableau d'entiers non négatifs selon
    le nombre de uns dans leur représentation binaire en ordre croissant.
    Pour un nombre similaire de uns, trier basé sur la valeur décimale.

    Doit être implémenté ainsi:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    Dans ce Kata, vous devez trier un tableau d'entiers non négatifs selon
    le nombre de uns dans leur représentation binaire en ordre croissant.
    Pour un nombre similaire de uns, trie en te basant sur la valeur décimale.

    Il faut que ce soit implémenté ainsi :
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """Étant donné une chaîne s et un nombre naturel n, on vous a chargé de
    mettre en œuvre une fonction qui renvoie une liste de tous les mots de la chaîne s
    qui contiennent exactement n consonnes, dans l'ordre où ces mots apparaissent dans la chaîne s.
    Si la chaîne s est vide, alors la fonction doit renvoyer une liste vide.
    Remarque : vous pouvez supposer que la chaîne d'entrée contient uniquement des lettres et des espaces.
    Exemples :
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Étant donnés une chaîne s et un nombre naturel n, on vous a chargé d'implémenter
    une fonction qui renvoie une liste de tous les mots de la chaîne s qui contiennent exactement
    n consonnes, dans l'ordre où ces mots apparaissent dans la chaîne s.
    Si la chaîne s est vide, alors la fonction doit renvoyer une liste vide.
    Remarque : vous pouvez supposer que la chaîne d'entrée contient uniquement des lettres et des espaces.
    Exemples :
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Étant donné une chaîne s et un nombre naturel n, on vous a chargé d'implémenter
    une fonction qui renvoie une liste de tous les mots de la chaîne s
    qui contiennent exactement n consonnes, dans l'ordre où ces mots apparaissent dans la chaîne s.
    Si la chaîne s est vide, alors la fonction doit renvoyer une liste vide.
    Remarque : vous pouvez supposer que la chaîne d'entrée contient uniquement des lettres et des espaces.
    Exemples :
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """On vous donne un mot. Votre tâche est de trouver la voyelle la plus proche qui se trouve entre
    deux consonnes depuis le côté droit du mot (sensible à la casse).

    Les voyelles au début et à la fin ne comptent pas. Retourne une chaîne vide si vous ne trouvez
    aucune voyelle qui satisfait la condition précédente.

    Vous pouvez supposer que la chaîne donnée contient uniquement des lettres en anglais.

    Exemple :
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """On vous donne un mot. Votre tâche est de trouver la voyelle la plus proche qui se trouve entre
    deux consonnes depuis le côté droit du mot (sensible à la casse).

    Les voyelles au début et à la fin ne comptent pas. Retournez une chaîne vide si vous
    n'avez
    trouvé aucune voyelle satisfaisant la condition précédente.

    Vous pouvez supposer que la chaîne donnée contient uniquement des lettres en anglais.

    Exemple :
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    On vous donne une liste de deux chaînes, les deux chaînes ne consistent qu'en
    parenthèses ouvertes '(' ou parenthèses fermées ')'.
    Votre tâche est de vérifier s'il est possible de concaténer les deux chaînes dans
    un certain ordre, de sorte que la chaîne résultante soit bonne.
    Une chaîne S est considérée comme bonne si et seulement si toutes les parenthèses dans S
    sont équilibrées. Par exemple : la chaîne '(())()' est bonne, tandis que la chaîne
    '())' ne l'est pas.
    Retourne 'Yes' s'il y a un moyen de faire une bonne chaîne, et retourne 'No' sinon.

    Exemples :
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    On vous donne une liste de deux chaînes, les deux chaînes ne consistent qu'en
    parenthèses ouvertes '(' ou parenthèses fermées ')'.
    Votre tâche est de vérifier s'il est possible de concaténer les deux chaînes dans
    un certain ordre, de sorte que la chaîne résultante soit bonne.
    Une chaîne S est considérée comme bonne si et seulement si toutes les parenthèses dans S
    sont équilibrées. Par exemple : la chaîne '(())()' est bonne, tandis que la chaîne
    '())' ne l'est pas.
    Renvoie 'Yes' s'il y a un moyen de faire une bonne chaîne, et renvoie 'No' dans le cas contraire.

    Exemples :
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Étant donné un tableau arr d'entiers et un entier positif k, retourne une liste triée
    de longueur k avec les k nombres maximums dans arr.

    Exemple 1 :

        Entrée : arr = [-3, -4, 5], k = 3
        Sortie : [-4, -3, 5]

    Exemple 2 :

        Entrée : arr = [4, -4, 4], k = 2
        Sortie : [4, 4]

    Exemple 3 :

        Entrée : arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Sortie : [2]

    Remarque :
        1. La longueur du tableau sera dans la plage de [1, 1000].
        2. Les éléments dans le tableau seront dans la plage de [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Étant donné un tableau arr d'entiers et un entier positif k, retourne une liste triée
    de longueur k avec les k nombres maximums dans arr.

    Exemple 1:

        Entrée: arr = [-3, -4, 5], k = 3
        Sortie: [-4, -3, 5]

    Exemple 2:

        Entrée: arr = [4, -4, 4], k = 2
        Sortie: [4, 4]

    Exemple 3:

        Entrée: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Sortie: [2]

    Remarque:
        1. La longueur du tableau sera dans la plage de [1, 1000].
        2. Les éléments dans le tableau seront dans la plage de [-1000, 1000].
        3. 0 <= k <= len(arr)
    """


def solution(lst):
    """Étant donné une liste non vide d'entiers, renvoie la somme de tous les éléments impairs qui sont en positions paires.

    Exemples
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Étant donné une liste non vide d'entiers, renvoie la somme de tous les éléments impairs qui sont en position paire.

    Exemples
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Étant donnée une liste non vide d'entiers, renvoie la somme de tous les éléments impairs qui sont en positions paires.

    Exemples
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    Étant donné un tableau non vide d'entiers arr et un entier k, renvoie
    la somme des éléments ayant au maximum deux chiffres parmi les k premiers éléments de arr.

    Exemple :

        Entrée : arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Sortie : 24 # somme de 21 + 3

    Contraintes :
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Étant donné un tableau non vide d'entiers arr et un entier k, renvoie
    la somme des éléments ayant au maximum deux chiffres parmi les k premiers éléments de arr.

    Exemple:

        Entrée: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Sortie: 24 # somme de 21 + 3

    Contraintes:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Étant donné un entier positif n, renvoie une liste triée contenant les nombres impairs dans la séquence de Collatz.

    La conjecture de Collatz est une conjecture en mathématiques qui se réfère à une séquence définie
    de la manière suivante : commencez avec n'importe quel entier positif n. Ensuite, chaque terme est obtenu à partir du
    terme précédent de la manière suivante : si le terme précédent est pair, le terme suivant est la moitié du
    terme précédent. Si le terme précédent est impair, le terme suivant est 3 fois le terme
    précédent plus 1. La conjecture est que, peu importe la valeur de n, la séquence atteindra toujours 1.

    Remarque :
        1. Collatz(1) est [1].
        2. la liste renvoyée est triée par ordre croissant.

    Par exemple :
    get_odd_collatz(5) renvoie [1, 5] # La séquence de Collatz pour 5 est [5, 16, 8, 4, 2, 1], donc les nombres impairs sont seulement 1 et 5.
    """

def get_odd_collatz(n):
    """
    Étant donné un entier positif n, renvoie une liste triée contenant les nombres impairs dans la séquence de Collatz.

    La conjecture de Collatz est une conjecture en mathématiques qui se réfère à une séquence définie
    de la manière suivante: commencez avec n'importe quel entier positif n. Ensuite, chaque terme est obtenu à partir du
    terme précédent de la manière suivante: si le terme précédent est pair, le terme suivant est la moitié du
    terme précédent. Si le terme précédent est impair, le terme suivant est 3 fois le terme précédent plus 1. La conjecture est que, peu importe la valeur de n, la séquence atteindra toujours 1.

    Remarque:
        1. Collatz(1) est [1].
        2. la liste renvoyée est triée par ordre croissant.

    Par exemple:
    get_odd_collatz(5) renvoie [1, 5] # La séquence de Collatz pour 5 est [5, 16, 8, 4, 2, 1], donc les nombres impairs sont seulement 1, et 5.
    """

def get_odd_collatz(n):
    """
    Étant donné un entier positif n, renvoie une liste triée contenant les nombres impairs dans la séquence de Collatz.

    La conjecture de Collatz est une conjecture en mathématiques qui se réfère à une séquence définie
    de la manière suivante : commencez avec n'importe quel entier positif n. Ensuite, chaque terme est obtenu à partir du
    terme précédent de la manière suivante : si le terme précédent est pair, le terme suivant est la moitié du
    terme précédent. Si le terme précédent est impair, le terme suivant est 3 fois le terme précédent
    plus 1. La conjecture est que, peu importe la valeur de n, la séquence atteindra toujours 1.

    Remarque :
        1. Collatz(1) est [1].
        2. la liste renvoyée est triée par ordre croissant.

    Par exemple :
    get_odd_collatz(5) returns [1, 5] # La séquence de Collatz pour 5 est [5, 16, 8, 4, 2, 1], donc les nombres impairs sont seulement 1 et 5.
    """


def valid_date(date):
    """Vous devez écrire une fonction qui valide une chaîne de date donnée et
    renvoie True si la date est valide, False sinon.
    La date est valide si toutes les règles suivantes sont respectées :
    1. La chaîne de date n'est pas vide.
    2. Le nombre de jours n'est pas inférieur à 1 ni supérieur à 31 jours pour les mois 1,3,5,7,8,10,12. Et le nombre de jours n'est pas inférieur à 1 ni supérieur à 30 jours pour les mois 4,6,9,11. Et, le nombre de jours n'est pas inférieur à 1 ni supérieur à 29 pour le mois 2.
    3. Les mois ne doivent pas être inférieurs à 1 ni supérieurs à 12.
    4. La date doit être au format : mm-dd-yyyy

    par exemple :
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """Vous devez écrire une fonction qui valide une chaîne de date donnée et
    renvoie True si la date est valide, sinon False.
    La date est valide si toutes les règles suivantes sont respectées :
    1. La chaîne de date n'est pas vide.
    2. Le nombre de jours n'est pas inférieur à 1 ni supérieur à 31 jours pour les mois 1,3,5,7,8,10,12. Et le nombre de jours n'est pas inférieur à 1 ni supérieur à 30 jours pour les mois 4,6,9,11. Et, le nombre de jours n'est pas inférieur à 1 ni supérieur à 29 pour le mois 2.
    3. Les mois ne doivent pas être inférieurs à 1 ni supérieurs à 12.
    4. La date doit être au format : mm-dd-yyyy

    par exemple :
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    Étant donné une chaîne de mots, renvoie une liste de mots divisés par des espaces, si le texte ne contient pas d'espaces vous
    devez séparer les mots par des virgules ',' si aucune virgule n'existe vous devez renvoyer le nombre de lettres minuscules avec un ordre impair dans
    l'alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Exemples
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Étant donné une chaîne de mots, renvoie une liste de mots divisés par des espaces, si aucun espace n'existe dans le texte
    vous devez diviser par des virgules ',' si aucune virgule n'existe, vous devez renvoyer le nombre de lettres minuscules avec un ordre impair dans le
    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Exemples
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Étant donné une liste de nombres, renvoie si elle est ou non triée
    en ordre croissant. Si la liste a plus de 1 doublon du même
    nombre, renvoie False. Suppose qu'il n'y a pas de nombres négatifs et seulement des entiers.

    Exemples
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """On vous donne deux intervalles,
    où chaque intervalle est une paire d'entiers. Par exemple, intervalle = (début, fin) = (1, 2).
    Les intervalles donnés sont fermés, ce qui signifie que l'intervalle (début, fin)
    inclut à la fois le début et la fin.
    Pour chaque intervalle donné, on suppose que son début est inférieur ou égal à sa fin.
    Votre tâche est de déterminer si la longueur de l'intersection de ces deux
    intervalles est un nombre premier.
    Par exemple, l'intersection des intervalles (1, 3), (2, 4) est (2, 3)
    dont la longueur est 1, qui n'est pas un nombre premier.
    Si la longueur de l'intersection est un nombre premier, renvoyez "YES",
    sinon, renvoyez "NO".
    Si les deux intervalles ne s'intersectent pas, renvoyez "NO".

    [exemples d'entrée/sortie]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """On vous donne deux intervalles,
    où chaque intervalle est une paire d'entiers. Par exemple, intervalle = (début, fin) = (1, 2).
    Les intervalles donnés sont fermés, ce qui signifie que l'intervalle (début, fin)
    inclut à la fois le début et la fin.
    Pour chaque intervalle donné, on suppose que son début est inférieur ou égal à sa fin.
    Votre tâche est de déterminer si la longueur de l'intersection de ces deux
    intervalles est un nombre premier.
    Par exemple, l'intersection des intervalles (1, 3), (2, 4) est (2, 3)
    dont la longueur est 1, qui n'est pas un nombre premier.
    Si la longueur de l'intersection est un nombre premier, renvoyez "YES",
    sinon, renvoyez "NO".
    Si les deux intervalles ne s'intersectent pas, renvoyez "NO".

    exemples [entrée/sortie]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """On vous donne deux intervalles,
    où chaque intervalle est une paire d'entiers. Par exemple, intervalle = (début, fin) = (1, 2).
    Les intervalles donnés sont fermés, ce qui signifie que l'intervalle (début, fin)
    inclut à la fois le début et la fin.
    Pour chaque intervalle donné, on suppose que son début est inférieur ou égal à sa fin.
    Votre tâche est de déterminer si la longueur de l'intersection de ces deux
    intervalles est un nombre premier.
    Exemple, l'intersection des intervalles (1, 3), (2, 4) is (2, 3)
    dont la longueur est 1, qui n'est pas un nombre premier.
    Si la longueur de l'intersection est un nombre premier, renvoyez "YES",
    sinon, renvoyez "NO".
    Si les deux intervalles ne s'intersectent pas, renvoyez "NO".

    exemples de [entrée/sortie]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    On vous donne un tableau arr d'entiers et vous devez retourner
    la somme des magnitudes des entiers multipliée par le produit de tous les signes
    de chaque nombre dans le tableau, représenté par 1, -1 ou 0.
    Remarque : renvoie None pour un arr vide.

    Exemple :
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    On vous donne un tableau arr d'entiers et vous devez retourner
    la somme des magnitudes des entiers multipliée par le produit de tous les signes
    de chaque nombre dans le tableau, représenté par 1, -1 or 0.
    Remarque: renvoie None pour un arr vide.

    Exemple:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Étant donné une grille avec N lignes et N colonnes (N >= 2) et un entier positif k,
    chaque cellule de la grille contient une valeur. Chaque entier dans l'intervalle [1, N * N]
    inclus apparaît exactement une fois dans les cellules de la grille.

    Vous devez trouver le chemin minimum de longueur k dans la grille. Vous pouvez commencer
    depuis n'importe quelle cellule, et à chaque étape, vous pouvez vous déplacer vers l'une des cellules voisines,
    en d'autres termes, vous pouvez aller vers des cellules qui partagent un bord avec votre cellule actuelle.
    Notez qu'un chemin de longueur k signifie visiter exactement k cellules (pas
    nécessairement distinctes).
    Vous NE pouvez PAS sortir de la grille.
    Un chemin A (de longueur k) est considéré comme plus petit qu'un chemin B (de longueur k) si
    après avoir fait les listes triées des valeurs dans les cellules par lesquelles A et B passent
    (appelons-les lst_A et lst_B), lst_A est lexicographiquement plus petit que lst_B, en d'autres termes,
    il existe un indice entier i (1 <= i <= k) tel que lst_A[i] < lst_B[i] et pour tout j (1 <= j < i) nous avons
    lst_A[j] = lst_B[j].
    Il est garanti que la réponse est unique.
    Retournez une liste triée des valeurs dans les cellules par lesquelles passe le chemin minimum.

    Exemples :

        Entrée : grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Sortie : [1, 2, 1]

        Entrée : grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Sortie : [1]
    """

def minPath(grid, k):
    """
    Étant donné une grille avec N lignes et N colonnes (N >= 2) et un entier positif k,
    chaque cellule de la grille contient une valeur. Chaque entier dans l'intervalle [1, N * N]
    inclus apparaît exactement une fois dans les cellules de la grille.

    Vous devez trouver le chemin minimum de longueur k dans la grille. Vous pouvez commencez depuis n'importe quelle cellule, et à chaque étape, vous pouvez vous déplacer vers l'une des cellules voisines, en d'autres termes, vous pouvez aller vers des cellules qui partagent un bord avec votre cellule actuelle.
    Notez qu'un chemin de longueur k signifie visiter exactement k cellules (pas
    nécessairement distinctes).
    Vous NE POUVEZ PAS sortir de la grille.
    Un chemin A (de longueur k) est considéré comme plus petit qu'un chemin B (de longueur k) si après avoir fait les listes triées des valeurs dans les cellules par lesquelles A et B passent (appelons-les lst_A et lst_B), lst_A est lexicographiquement plus petit que lst_B, en d'autres termes, il existe un indice entier i (1 <= i <= k)
    tel que lst_A[i] < lst_B[i] et pour tout j (1 <= j < i) nous avons
    lst_A[j] = lst_B[j].
    Il est garanti que la réponse est unique.
    Retournez une liste triée des valeurs dans les cellules par lesquelles passe le chemin minimum.

    Exemples:

        Entrée: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Sortie: [1, 2, 1]

        Entrée: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Sortie: [1]
    """

def minPath(grid, k):
    """
    Étant donnée une grille avec N lignes et N colonnes (N >= 2) et un entier positif k,
    chaque cellule de la grille contient une valeur. Chaque entier dans l'intervalle [1, N * N]
    inclus apparaît exactement une fois dans les cellules de la grille.

    Vous devez trouver le chemin minimum de longueur k dans la grille. Vous pouvez commencer
    depuis n'importe quelle cellule, et à chaque étape, vous pouvez vous déplacer vers n'importe laquelle des cellules voisines,
    en d'autres termes, vous pouvez aller vers des cellules qui partagent un bord avec votre cellule actuelle.
    Notez qu'un chemin de longueur k signifie visiter exactement k cellules (pas
    nécessairement distinctes).
    Vous NE POUVEZ PAS sortir de la grille.
    Un chemin A (de longueur k) est considéré comme plus petit qu'un chemin B (de longueur k) si
    après avoir fait les listes triées des valeurs dans les cellules par lesquelles A et B passent
    (appelons-les lst_A et lst_B), lst_A est lexicographiquement plus petit
    que lst_B, en d'autres termes, il existe un indice entier i (1 <= i <= k)
    tel que lst_A[i] < lst_B[i] et pour tout j (1 <= j < i) nous avons
    lst_A[j] = lst_B[j].
    Il est garanti que la réponse est unique.
    Retournez une liste triée des valeurs dans les cellules par lesquelles passe le chemin minimum.

    Exemples :

        Entrée : grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Sortie : [1, 2, 1]

        Entrée : grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Sortie : [1]
    """


def tri(n):
    """Tout le monde connaît la suite de Fibonacci, elle a été étudiée en profondeur par les mathématiciens
    au cours des derniers siècles. Cependant, ce que les gens ne savent pas, c'est la suite de Tribonacci.
    La suite de Tribonacci est définie par la récurrence :
    tri(1) = 3
    tri(n) = 1 + n / 2, si n est pair.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), si n est impair.
    Par exemple :
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    On vous donne un nombre entier non négatif n, vous devez retourner une liste des
    n + 1 premiers nombres de la suite de Tribonacci.
    Exemples :
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Tout le monde connaît la suite de Fibonacci, elle a été étudiée en profondeur par les mathématiciens au cours
    des derniers siècles. Cependant, ce que les gens ne connaissent pas, c'est la suite de Tribonacci.
    La suite de Tribonacci est définie par la récurrence :
    tri(1) = 3
    tri(n) = 1 + n / 2, si n est pair.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), si n est impair.
    Par exemple :
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    On vous donne un nombre entier non négatif n, vous devez retourner une liste des
    n + 1 premiers nombres de la suite de Tribonacci.
    Exemples :
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Tout le monde connaît la suite de Fibonacci, elle a été étudiée en profondeur par les mathématiciens au cours des derniers siècles. Cependant, ce que les gens ne savent pas, c'est la suite de Tribonacci.
    La suite de Tribonacci est définie par la récurrence:
    tri(1) = 3
    tri(n) = 1 + n / 2, if n est pair.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n est impair.
    Par exemple:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    On vous donne un nombre entier non négatif n, vous devez retourner une liste des
    n + 1 premiers nombres de la suite de Tribonacci.
    Exemples:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Étant donné un nombre entier positif n, renvoie le produit des chiffres impairs.
    Renvoie 0 si tous les chiffres sont pairs.
    Par exemple :
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    Créez une fonction qui prend une chaîne en entrée contenant uniquement des crochets.
    La fonction doit retourner True si et seulement s'il existe une sous-séquence valide de crochets
    où au moins un crochet dans la sous-séquence est imbriqué.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """On vous donne une liste de nombres.
    Vous devez retourner la somme des nombres au carré dans la liste donnée,
    en arrondissant d'abord chaque élément de la liste à l'entier supérieur (Plafond).
    Exemples :
    Pour lst = [1,2,3] la sortie devrait être 14
    Pour lst = [1,4,9] la sortie devrait être 98
    Pour lst = [1,3,5,7] la sortie devrait être 84
    Pour lst = [1.4,4.2,0] la sortie devrait être 29
    Pour lst = [-2.4,1,1] la sortie devrait être 6

    """

def sum_squares(lst):
    """On vous donne une liste de nombres.
    Vous devez retourner la somme des nombres au carré dans la liste donnée,
    arrondir d'abord chaque élément de la liste à l'entier supérieur int(Ceiling).
    Exemples:
    Pour lst = [1,2,3] la sortie devrait être 14
    Pour lst = [1,4,9] la sortie devrait être 98
    Pour lst = [1,3,5,7] la sortie devrait être 84
    Pour lst = [1.4,4.2,0] la sortie devrait être 29
    Pour lst = [-2.4,1,1] la sortie devrait être 6

    """

def sum_squares(lst):
    """On vous donne une liste de nombres.
    Vous devez renvoyer la somme des nombres au carré dans la liste donnée,
    en arrondissant d'abord chaque élément de la liste au int(Ceiling) supérieur.
    Exemples :
    Pour lst = [1,2,3] la sortie devrait être 14
    Pour lst = [1,4,9] la sortie devrait être 98
    Pour lst = [1,3,5,7] la sortie devrait être 84
    Pour lst = [1.4,4.2,0] la sortie devrait être 29
    Pour lst = [-2.4,1,1] la sortie devrait être 6
    """


def check_if_last_char_is_a_letter(txt):
    '''
    Créer une fonction qui renvoie True si le dernier caractère
    d'une chaîne donnée est un caractère alphabétique et ne fait pas
    partie d'un mot, et False dans le cas contraire.
    Remarque : "mot" est un groupe de caractères séparés par un espace.

    Exemples :
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Créez une fonction qui renvoie True si le dernier caractère
    d'une chaîne donnée est un caractère alphabétique et n'est pas
    partie d'un mot, et False dans le cas contraire.
    Remarque : "mot" est un groupe de caractères séparés par un espace.

    Exemples :
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Créer une fonction qui renvoie True si le dernier caractère
    d'une chaîne donnée est un caractère alphabétique et n'est pas
    partie d'un mot, et False dans le cas contraire.
    Remarque : "mot" est un groupe de caractères séparés par un espace.

    Exemples :
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Crée une fonction qui renvoie l'indice le plus grand d'un élément qui
    n'est pas supérieur ou égal à l'élément immédiatement précédent. S'il
    n'existe pas un tel élément, renvoie -1. Le tableau donné ne contiendra pas de
    valeurs dupliquées.

    Exemples :
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Créez une fonction qui renvoie l'indice le plus grand d'un élément qui
    n'est pas supérieur ou égal à l'élément qui le précède immédiatement. S'il n'existe
    pas un tel élément, renvoie -1. Le tableau donné ne contiendra pas de valeurs dupliquées.

    Exemples :
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Créez une fonction qui renvoie l'indice le plus grand d'un élément qui
    n'est pas supérieur ou égal à l'élément immédiatement précédent. S'il n'existe
    pas un tel élément, renvoie -1. Le tableau donné ne contiendra pas de valeurs dupliquées.

    Exemples:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Créer une fonction qui renvoie un tuple (a, b), où 'a' est
    le plus grand des entiers négatifs, et 'b' est le plus petit
    des entiers positifs dans une liste.
    S'il n'y a pas d'entiers négatifs ou positifs, les renvoyer comme None.

    Exemples:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Crée une fonction qui renvoie un tuple (a, b), où 'a' est
    le plus grand des entiers négatifs, et 'b' est le plus petit
    des entiers positifs dans une liste.
    S'il n'y a pas d'entiers négatifs ou positifs, les renvoie comme None.

    Exemples :
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Crée une fonction qui renvoie un tuple (a, b), où 'a' est
    le plus grand des entiers négatifs, et 'b' est le plus petit
    des entiers positifs dans une liste.
    S'il n'y a pas d'entiers négatifs ou positifs, les renvoyer comme None.

    Exemples :
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Créer une fonction qui prend des entiers, des flottants ou des chaînes qui représentent
    des nombres réels, et renvoie la variable la plus grande dans son type de variable donné.
    Renvoie None si les valeurs sont égales.
    Remarque : Si un nombre réel est représenté comme une chaîne, le point flottant pourrait être . ou ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Créez une fonction qui prend des entiers, des flottants ou des chaînes qui représentent
    des nombres réels, et renvoie la variable la plus grande dans son type de variable donné.
    Renvoie None si les valeurs sont égales.
    Remarque : Si un nombre réel est représenté comme une chaîne, le point flottant pourrait être . ou ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """Évaluez si le nombre donné n peut être écrit comme la somme de exactement 4 nombres pairs positifs
    Exemple
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Évalue si le nombre donné n peut être écrit comme la somme de exactement 4 nombres pairs positifs
    Exemple
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """Le factoriel brésilien est défini comme :
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    où n > 0

    Par exemple :
    >>> special_factorial(4)
    288

    La fonction recevra un entier en entrée et doit retourner le factoriel
    spécial de cet entier.
    """

def special_factorial(n):
    """Le factoriel brésilien est défini comme:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    où n > 0

    Par exemple:
    >>> special_factorial(4)
    288

    La fonction recevra un entier en entrée et doit retourner le factoriel
    spécial de cet entier.
    """


def fix_spaces(text):
    """
    Étant donné une chaîne de texte, remplace tous les espaces par des underscores,
    et si une chaîne a plus de 2 espaces consécutifs,
    alors remplace tous les espaces consécutifs par -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Étant donnée une chaîne de texte, remplace tous les espaces par des underscores,
    et si une chaîne a plus de 2 espaces consécutifs,
    alors remplace tous les espaces consécutifs par -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """


def file_name_check(file_name):
    """Créez une fonction qui prend une chaîne représentant le nom d'un fichier, et renvoie
    'Yes' si le nom du fichier est valide, et renvoie 'No' sinon.
    On considère qu'un nom de fichier est valide si et seulement si toutes les conditions suivantes sont remplies :
    - Il ne doit pas y avoir plus de trois chiffres ('0'-'9') dans le nom du fichier.
    - Le nom du fichier contient exactement un point '.'
    - La sous-chaîne avant le point ne doit pas être vide, et doit commencer par une lettre de
    l'alphabet latin ('a'-'z' et 'A'-'Z').
    - La sous-chaîne après le point doit être l'une de celles-ci : ['txt', 'exe', 'dll']
    Exemples :
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (le nom doit commencer par une lettre de l'alphabet latin)
    """

def file_name_check(file_name):
    """Créez une fonction qui prend une chaîne représentant le nom d'un fichier, et renvoie
    'Yes' si le nom du fichier est valide, et renvoie 'No' dans le cas contraire.
    On considère qu'un nom de fichier est valide si et seulement si toutes les conditions suivantes sont remplies :
    - Il ne doit pas y avoir plus de trois chiffres ('0'-'9') dans le nom du fichier.
    - Le nom du fichier contient exactement un point '.'
    - La sous-chaîne avant le point ne doit pas être vide, et doit commencer par une lettre de
    l'alphabet latin ('a'-'z' et 'A'-'Z').
    - La sous-chaîne après le point doit être l'une de celles-ci : ['txt', 'exe', 'dll']
    Exemples :
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (le nom doit commencer par une lettre de l'alphabet latin)
    """


def sum_squares(lst):
    """
    Cette fonction prendra une liste d'entiers. Pour toutes les entrées dans la liste, la fonction élèvera au carré l'entrée entière si son indice est un
    multiple de 3 et élèvera au cube l'entrée entière si son indice est un multiple de 4 et non un multiple de 3. La fonction ne
    changera pas les entrées dans la liste dont les indices ne sont pas des multiples de 3 ou 4. La fonction renverra ensuite la somme de toutes les entrées.

    Exemples :
    Pour lst = [1,2,3] la sortie devrait être 6
    Pour lst = [] la sortie devrait être 0
    Pour lst = [-1,-5,2,-1,-5] la sortie devrait être -126
    """


def words_in_sentence(sentence):
    """
    On vous donne une chaîne qui représente une phrase,
    la phrase contient quelques mots séparés par un espace,
    et vous devez retourner une chaîne qui contient les mots de la phrase originale,
    dont les longueurs sont des nombres premiers,
    l'ordre des mots dans la nouvelle chaîne doit être le même que l'original.

    Exemple 1 :
        Entrée : sentence = "This is a test"
        Sortie : "is"

    Exemple 2 :
        Entrée : sentence = "lets go for swimming"
        Sortie : "go for"

    Contraintes :
        * 1 <= len(sentence) <= 100
        * la phrase contient seulement des lettres
    """

def words_in_sentence(sentence):
    """
    On vous donne une chaîne qui représente une phrase,
    la phrase contient quelques mots séparés par un espace,
    et vous devez retourner une chaîne qui contient les mots de la phrase originale,
    dont les longueurs sont des nombres premiers,
    l'ordre des mots dans la nouvelle chaîne doit être le même que l'original.

    Exemple 1:
        Entrée: sentence = "This is a test"
        Sortie: "is"

    Exemple 2:
        Entrée: sentence = "lets go for swimming"
        Sortie: "go for"

    Contraintes:
        * 1 <= len(sentence) <= 100
        * la phrase contient seulement des lettres
    """


def simplify(x, n):
    """Votre tâche est d'implémenter une fonction qui simplifie l'expression
    x * n. La fonction renvoie True si x * n évalue à un nombre entier et False
    sinon. Tant x que n sont des représentations en chaîne d'une fraction, et ont le format suivant,
    <numérateur>/<dénominateur> où tant le numérateur que le dénominateur sont des nombres entiers positifs.

    Vous pouvez supposer que x et n sont des fractions valides, et n'ont pas zéro comme dénominateur.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Votre tâche est d'implémenter une fonction qui simplifie l'expression
    x * n. La fonction renvoie True si x * n évalue à un nombre entier et False
    sinon. x et n, sont tous deux des représentations en chaîne d'une fraction, et ont le format suivant,
    <numérateur>/<dénominateur> où tous deux numérateur et dénominateur sont des nombres entiers positifs.

    Vous pouvez supposer que x, et n sont des fractions valides, et n'ont pas zéro comme dénominateur.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """


def order_by_points(nums):
    """
    Écrire une fonction qui trie la liste donnée d'entiers
    en ordre croissant selon la somme de leurs chiffres.
    Remarque : s'il y a plusieurs éléments avec une somme similaire de leurs chiffres,
    triez-les selon leur indice dans la liste originale.

    Par exemple :
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Écris une fonction qui trie la liste donnée d'entiers
    en ordre croissant selon la somme de leurs chiffres.
    Remarque : s'il y a plusieurs éléments avec une somme similaire de leurs chiffres,
    trie-les selon leur indice dans la liste originale.

    Par exemple :
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Écrivez une fonction qui prend un tableau de nombres en entrée et
    renvoie le nombre d'éléments dans le tableau qui sont supérieurs à 10 et
    dont le premier et le dernier chiffre d'un nombre sont impairs (1, 3, 5, 7, 9).
    Par exemple :
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Écrit une fonction qui prend un tableau de nombres en entrée et renvoie
    le nombre d'éléments dans le tableau qui sont supérieurs à 10 et dont à la fois
    le premier et le dernier chiffre d'un nombre sont impairs (1, 3, 5, 7, 9).
    Par exemple :
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Écrire une fonction qui prend un tableau de nombres en entrée et
    renvoie le nombre d'éléments dans le tableau qui sont supérieurs à 10 et
    dont le premier et le dernier chiffre d'un nombre sont impairs (1, 3, 5, 7, 9).
    Par exemple :
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    On vous donne un entier positif n. Vous devez créer un tableau d'entiers a de longueur n.
        Pour chaque i (1 ≤ i ≤ n), la valeur de a[i] = i * i - i + 1.
        Retourne le nombre de triplets (a[i], a[j], a[k]) de a où i < j < k,
    et a[i] + a[j] + a[k] est un multiple de 3.

    Exemple :
        Entrée : n = 5
        Sortie : 1
        Explication :
        a = [1, 3, 7, 13, 21]
        Le seul triplet valide est (1, 7, 13).
    """

def get_max_triples(n):
    """
    On vous donne un entier positif n. Vous devez créer un tableau d'entiers a de longueur n.
        Pour chaque i (1 ≤ i ≤ n), la valeur de a[i] = i * i - i + 1.
        Retourner le nombre de triplets (a[i], a[j], a[k]) de a où i < j < k,
    et a[i] + a[j] + a[k] est un multiple de 3.

    Exemple :
        Entrée : n = 5
        Sortie : 1
        Explication :
        a = [1, 3, 7, 13, 21]
        Le seul triplet valide est (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    Il y a huit planètes dans notre système solaire : la plus proche du Soleil
    est Mercure, suivie de Vénus, puis Terre, Mars, Jupiter, Saturne,
    Uranus, Neptune.
    Écrivez une fonction qui prend deux noms de planètes sous forme de chaînes planet1 et planet2.
    La fonction doit renvoyer un tuple contenant toutes les planètes dont les orbites sont
    situées entre l'orbite de planet1 et l'orbite de planet2, triées par
    proximité au soleil.
    La fonction doit renvoyer un tuple vide si planet1 ou planet2
    ne sont pas des noms de planètes corrects.
    Exemples
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Il y a huit planètes dans notre système solaire : la plus proche du Soleil
    est Mercure, suivie de Vénus, puis Terre, Mars, Jupiter, Saturne,
    Uranus, Neptune.
    Écrivez une fonction qui prend deux noms de planètes sous forme de chaînes planet1 et planet2.
    La fonction doit renvoyer un tuple contenant toutes les planètes dont les orbites sont
    situées entre l'orbite de planet1 et l'orbite de planet2, ordonnées par
    proximité au soleil.
    La fonction doit renvoyer un tuple vide si planet1 ou planet2
    ne sont pas des noms de planètes corrects.
    Exemples
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """Écrire une fonction qui accepte une liste de chaînes comme paramètre,
    supprime les chaînes qui ont des longueurs impaires de celle-ci,
    et renvoie la liste résultante dans l'ordre trié.
    La liste est toujours une liste de chaînes et jamais un tableau de nombres,
    et peut contenir des doublons.
    L'ordre de la liste doit être ascendant par la longueur de chaque mot, et vous
    devez renvoyer la liste triée selon cette règle.
    Si deux mots ont la même longueur, triez la liste par ordre alphabétique.
    La fonction doit renvoyer une liste de chaînes dans l'ordre trié.
    Vous pouvez supposer que tous les mots auront la même longueur.
    Par exemple :
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Écrivez une fonction qui accepte une liste de chaînes comme paramètre,
    supprime les chaînes qui ont des longueurs impaires de celle-ci,
    et renvoie la liste résultante dans l'ordre trié.
    La liste est toujours une liste de chaînes et jamais un tableau de nombres,
    et peut contenir des doublons.
    L'ordre de la liste doit être ascendant par la longueur de chaque mot, et
    vous devez renvoyer la liste triée selon cette règle.
    Si deux mots ont la même longueur, triez la liste par ordre alphabétique.
    La fonction doit renvoyer une liste de chaînes dans l'ordre trié.
    Vous pouvez supposer que tous les mots auront la même longueur.
    Par exemple :
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Écrire une fonction qui accepte une liste de chaînes comme paramètre,
    supprime les chaînes qui ont des longueurs impaires de celle-ci,
    et renvoie la liste résultante dans l'ordre trié,
    La liste est toujours une liste de chaînes et jamais un tableau de nombres,
    et peut contenir des doublons.
    L'ordre de la liste doit être ascendant par la longueur de chaque mot, et
    vous devez renvoyer la liste triée selon cette règle.
    Si deux mots ont la même longueur, triez la liste par ordre alphabétique.
    La fonction doit renvoyer une liste de chaînes dans l'ordre trié.
    Vous pouvez supposer que tous les mots auront la même longueur.
    Par exemple:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Un programme simple qui devrait retourner la valeur de x si n est
    un nombre premier et devrait retourner la valeur de y dans le cas contraire.

    Exemples :
    pour x_or_y(7, 34, 12) == 34
    pour x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Un programme simple qui devrait retourner la valeur de x si n est
    un nombre premier et devrait retourner la valeur de y sinon.

    Exemples :
    pour x_or_y(7, 34, 12) == 34
    pour x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Étant donné une liste de nombres, renvoie la somme des carrés des nombres
    dans la liste qui sont impairs. Ignorer les nombres qui sont négatifs ou non entiers.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Si la liste d'entrée est vide, renvoie 0.
    '''

def double_the_difference(lst):
    '''
    Étant donné une liste de nombres, renvoie la somme des carrés des nombres
    dans la liste qui sont impairs. Ignore les nombres qui sont négatifs ou non entiers.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Si la liste d'entrée est vide, renvoie 0.
    '''

def double_the_difference(lst):
    '''
    Étant donnée une liste de nombres, renvoie la somme des carrés des nombres
    dans la liste qui sont impairs. Ignore les nombres qui sont négatifs ou non entiers.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Si la liste d'entrée est vide, renvoie 0.
    '''


def compare(game,guess):
    """Je pense que nous nous souvenons tous de cette sensation lorsque le résultat d'un événement
    très attendu est enfin connu. Les sentiments et pensées qu'on a à ce moment-là valent
    vraiment la peine d'être notés et comparés.
    Votre tâche est de déterminer si une personne a correctement deviné les résultats d'une série de matchs.
    On vous donne deux tableaux de scores et de suppositions de même longueur, où chaque indice correspond à un match.
    Retournez un tableau de la même longueur qui indique à quel point chaque supposition était éloignée. S'ils ont deviné correctement,
    la valeur est 0, et sinon, la valeur est la différence absolue entre la supposition et le score.

    exemple:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Je pense que nous nous souvenons tous de cette sensation lorsque nous connaissons enfin le résultat d'un événement tant attendu. Les sentiments et pensées que vous avez à ce moment-là valent
    vraiment la peine d'être notés et comparés.
    Votre tâche est de déterminer si une personne a correctement deviné les résultats d'une série de matchs.
    On vous donne deux tableaux de scores et de suppositions de même longueur, où chaque indice montre un match.
    Retourne un tableau de la même longueur qui indique à quel point chaque supposition était éloignée. S'ils ont deviné correctement,
    la valeur est 0, et sinon, la valeur est la différence absolue entre la supposition et le score.

    exemple:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Je pense que nous nous souvenons tous de cette sensation lorsque nous connaissons enfin le résultat d'un événement tant attendu.
    Les sentiments et pensées que vous avez à ce moment-là valent vraiment la peine d'être notés et comparés.
    Votre tâche est de déterminer si une personne a correctement deviné les résultats d'une série de matchs.
    On vous donne deux tableaux de scores et de suppositions de même longueur, où chaque indice montre un match.
    Renvoie un tableau de la même longueur qui indique à quel point chaque supposition était éloignée. S'ils ont deviné correctement,
    la valeur est 0, et sinon, la valeur est la différence absolue entre la supposition et le score.

    exemple:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """


def Strongest_Extension(class_name, extensions):
    """On vous donnera le nom d'une classe (une chaîne) et une liste d'extensions.
    Les extensions seront utilisées pour charger des classes supplémentaires à la classe. La
    force de l'extension est la suivante : Soit CAP le nombre de lettres majuscules
    dans le nom de l'extension, et soit SM le nombre de lettres minuscules
    dans le nom de l'extension, la force est donnée par la fraction CAP - SM.
    Vous devez trouver l'extension la plus forte et retourner une chaîne dans ce
    format : ClassName.StrongestExtensionName.
    S'il y a deux ou plusieurs extensions avec la même force, vous devez
    choisir celle qui apparaît en premier dans la liste.
    Par exemple, si on vous donne "Slices" comme la classe et une liste des
    extensions : ['SErviNGSliCes', 'Cheese', 'StuFfed'] alors vous devriez
    retourner 'Slices.SErviNGSliCes' car 'SErviNGSliCes' est l'extension la plus forte
    (sa force est -1).
    Exemple :
    pour Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """On vous donnera le nom d'une classe (une chaîne) et une liste d'extensions.
    Les extensions seront utilisées pour charger des classes supplémentaires à la classe. La
    force de l'extension est la suivante: Soit CAP le nombre de lettres majuscules
    dans le nom de l'extension, et soit SM le nombre de lettres minuscules
    dans le nom de l'extension, la force est donnée par la fraction CAP - SM.
    Vous devez trouver l'extension la plus forte et retourner une chaîne dans ce
    format: ClassName.StrongestExtensionName.
    S'il y a deux ou plusieurs extensions avec la même force, vous devez
    choisir celle qui apparaît en premier dans la liste.
    Par exemple, si on vous donne "Slices" acomme la classe et une liste des
    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] alors vous devriez
    retourner 'Slices.SErviNGSliCes' car 'SErviNGSliCes' est l'extension la plus forte
    (sa force est is -1).
    Exemple:
    pour Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """On te donne 2 mots. Tu dois retourner True si le deuxième mot ou l'une de ses rotations est une sous-chaîne dans le premier mot
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Étant donné un nombre entier, renvoie un tuple qui contient le nombre de chiffres pairs et impairs respectivement.

     Exemple :
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Étant donné un nombre entier, renvoie un tuple qui contient respectivement le nombre de chiffres pairs et impairs.

     Exemple :
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    Étant donné un nombre entier positif, obtenir son équivalent en chiffres romains sous forme de chaîne,
    et le retourner en minuscules.
    Contraintes : 1 <= num <= 1000

    Exemples :
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Étant donné un nombre entier positif, obtenir son équivalent en chiffres romains sous forme de chaîne,
    et le retourner en minuscules.
    Contraintes: 1 <= num <= 1000

    Exemples:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Étant donné un nombre entier positif, obtient son équivalent en chiffres romains sous forme de chaîne,
    et le retourne en minuscules.
    Contraintes : 1 <= num <= 1000

    Exemples :
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Étant donnés les longueurs des trois côtés d'un triangle. Renvoie True si les trois
    côtés forment un triangle rectangle, False sinon.
    Un triangle rectangle est un triangle dans lequel un angle est droit ou
    de 90 degrés.
    Exemple :
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Étant données les longueurs des trois côtés d'un triangle. Retourne True si les trois
    côtés forment un triangle rectangle, False sinon.
    Un triangle rectangle est un triangle dans lequel un angle est droit ou
    de 90 degrés.
    Exemple :
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Étant donnés les longueurs des trois côtés d'un triangle. Retourne True si les trois
    côtés forment un triangle rectangle, False sinon.
    Un triangle rectangle est un triangle dans lequel un angle est droit ou
    de 90 degrés.
    Exemple :
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Écrire une fonction qui accepte une liste de chaînes.
    La liste contient différents mots. Retourner le mot avec le nombre maximum
    de caractères uniques. Si plusieurs chaînes ont le nombre maximum de caractères
    uniques, retourne celle qui apparaît en premier dans l'ordre lexicographique.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """

def find_max(words):
    """Écris une fonction qui accepte une liste de chaînes.
    La liste contient différents mots. Renvoie le mot avec le nombre maximum
    de caractères uniques. Si plusieurs chaînes ont le nombre maximum de caractères
    uniques, retourne celle qui apparaît en premier dans l'ordre lexicographique.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """

def find_max(words):
    """Écrire une fonction qui accepte une liste de chaînes.
    La liste contient différentes mots. Retourne le mot avec le nombre maximum
    de caractères uniques. Si plusieurs chaînes ont le nombre maximum de caractères
    uniques, retourne celle qui apparaît en premier dans l'ordre lexicographique.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    Vous êtes un lapin affamé, et vous avez déjà mangé un certain nombre de carottes,
    mais maintenant vous devez manger plus de carottes pour compléter les repas de la journée.
    Vous devez retourner un tableau de [ nombre total de carottes mangées après vos repas,
                                    le nombre de carottes restantes après vos repas ]
    s'il n'y a pas assez de carottes restantes, vous mangerez toutes les carottes restantes, mais vous aurez encore faim.

    Exemple:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variables:
    @number : entier
        le nombre de carottes que vous avez mangées.
    @need : entier
        le nombre de carottes que vous devez manger.
    @remaining : entier
        le nombre de carottes restantes qui existent en stock

    Restriction:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Amusez-vous :)
    """

def eat(number, need, remaining):
    """
    Vous êtes un lapin affamé, et vous avez déjà mangé un certain nombre de carottes,
    mais maintenant vous devez manger plus de carottes pour compléter les repas de la journée.
    vous devez retourner un tableau de [ nombre total de carottes mangées après vos repas,
                                    le nombre de carottes restantes après vos repas ]
    s'il n'y a pas assez de carottes restantes, vous mangerez toutes les carottes restantes, mais vous aurez encore faim.

    Exemple:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variables:
    @number : entier
        le nombre de carottes que vous avez mangées.
    @need : entier
        le nombre de carottes que vous devez manger.
    @remaining : entier
        le nombre de carottes restantes qui existent en stock

    Restriction:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Amusez-vous :)
    """

def eat(number, need, remaining):
    """
    Vous êtes un lapin affamé, et vous avez déjà mangé un certain nombre de carottes,
    mais maintenant vous devez manger plus de carottes pour compléter les repas de la journée.
    vous devez retourner un tableau de [ nombre total de carottes mangées après vos repas,
                                        le nombre de carottes restantes après vos repas ]
    s'il n'y a pas assez de carottes restantes, vous mangerez toutes les carottes restantes, mais vous aurez encore faim.

    Exemple:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variables:
    @number : integer
        le nombre de carottes que vous avez mangées.
    @need : integer
        le nombre de carottes que vous devez manger.
    @remaining : integer
        le nombre de carottes restantes qui existent en stock

    Restriction:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Amusez-vous :)
    """


def do_algebra(operator, operand):
    """
    Étant donné deux listes operator et operand. La première liste contient des opérations algébriques de base, et
    la deuxième liste est une liste d'entiers. Utilisez les deux listes données pour construire l'expression
    algébrique et renvoyez l'évaluation de cette expression.

    Les opérations algébriques de base :
    Addition ( + )
    Soustraction ( - )
    Multiplication ( * )
    Division entière ( // )
    Exponentiation ( ** )

    Exemple :
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Remarque :
        La longueur de la liste operator est égale à la longueur de la liste operand moins un.
        Operand est une liste d'entiers non négatifs.
        La liste operator a au moins un opérateur, et la liste operand a au moins deux opérandes.

    """

def do_algebra(operator, operand):
    """
    Étant données deux listes operator et operand. La première liste contient des opérations algébriques de base, et
    la deuxième liste est une liste d'entiers. Utilisez les deux listes données pour construire l'expression
    algébrique et renvoyez l'évaluation de cette expression.

    Les opérations algébriques de base :
    Addition ( + )
    Soustraction ( - )
    Multiplication ( * )
    Division entière ( // )
    Exponentiation ( ** )

    Exemple :
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Remarque :
        La longueur de la liste operator est égale à la longueur de la liste operand moins un.
        Operand est une liste d'entiers non négatifs.
        La liste operator a au moins un opérateur, et la liste operand a au moins deux opérandes.

    """

def do_algebra(operator, operand):
    """
    Étant donné deux listes operator et operand. La première liste contient des opérations algébriques de base, et
    la deuxième liste est une liste d'entiers. Utilisez les deux listes données pour construire l'expression
    algébrique et renvoyez l'évaluation de cette expression.

    Les opérations algébriques de base:
    Addition ( + )
    Soustraction ( - )
    Multiplication ( * )
    Division entière ( // )
    Exponentiation ( ** )

    Exemple:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Remarque:
        La longueur de la liste operator est égale à la longueur de la liste operand moins un.
        Operand est une liste d'entiers non négatifs.
        La liste operator a au moins un opérateur, et la liste operand a au moins deux opérandes.

    """


def solve(s):
    """On vous donne une chaîne s.
    si s[i] est une lettre, inversez sa casse de minuscule à majuscule ou vice versa,
    sinon, gardez-la telle quelle.
    Si la chaîne ne contient pas de lettres, inversez la chaîne.
    La fonction doit renvoyer la chaîne résultante.
    Exemples
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """On vous donne une chaîne s.
    si s[i] est une lettre, inversez son cas de minuscule à majuscule ou vice versa,
    sinon, gardez-la telle quelle.
    Si la chaîne ne contient pas de lettres, inversez la chaîne.
    La fonction doit renvoyer la chaîne résultante.
    Exemples
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    Étant donné une chaîne 'text', renvoie sa chaîne de hachage md5 équivalente.
    Si 'text' est une chaîne vide, renvoie None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Étant donné une chaîne 'text', renvoie sa chaîne équivalente par hachage md5..
    Si 'text' est une chaîne vide, renvoie None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Étant donné une chaîne 'text', renvoyer sa chaîne de hachage md5 équivalente.
    Si 'text' est une chaîne vide, renvoyer None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


def generate_integers(a, b):
    """
    Étant donnés deux entiers positifs a et b, renvoie les chiffres pairs entre a
    et b, dans l'ordre croissant.

    Par exemple :
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """