def afficherTitre(texte, largeur, just = 'c'):
    """[summary]

    Args:
        texte ([str]): [description]
        largeur ([int]): [description]
        just (str, optional): [justify to left with 'l' or wright with 'r']. Defaults in centering with 'c'.
    
        Le texte donné centré, justifié à gauche ou justifié à         droite dans la largeur indiquée ou dans la longueur de         la plus longue chaine si cette dernière est plus               longue et bordé d'astérisques
        
    ljust() :     Justifie à gauche une chaine de caractère. Si la chaîne passée en paramètre est trop longue, 
                  elle n'est pas tronquée mais renvoyée sans modification. 
    rjust():      justifie à droite le texte.
    center():     permet de centre le texte
    'c' center text, 'l' justify left, 'r' justify right ??
    
    ici la super docu <<== vous pouvez la compléter svp ?
    Example : 
    """
    l = max([len(i) for i in texte] + [largeur])
    print("*"*(l+2))
    if just == 'c':
        for i in texte:
            print('*' + i.center(l, ' ') + '*')
    elif just == 'l':
        for i in texte:
            print('*' + i.ljust(l, ' ') + '*')
    elif just == 'r':
        for i in texte:
            print('*' + i.rjust(l, ' ') + '*')
    print('*'+aligne(s)+'*')
    print("*"*(l+2)) 

## exo3

def incluse(a, b):
    """return True if all chars of a are in b

    Args:
        a ([str]): [description]
        b ([str]): [description]

    Returns:
        [Boolean]: [False if one char of a isn't in b]
    """
    s = set(a)
    return set.intersection(s, set(b)) == s
    
def verifierEntierValide(val, inf, sup):
    return incluse(val, ".0123456789") & \
    (inf is not None or int(val) < inf) & \
    (sup is not None or int(val) > sup)


def verifier_entier_valide(val: float, inf: int, sup: int) -> bool:
    return not(incluse(".", str(val))) and (inf == None or val > inf) and (sup == None or val < sup)

## exo4

def swiping_means(S, n):
    """[summary]

    Args:
        S1 ([list of numbers]): just your list
        n ([uint]): the order of the 

    Returns:
        [list of floats]: [return the floattinf mean(??) of S on n values]
    """
    l = len(S)
    return [sum(S[k:k+n])/n for k in range(l - n + 1)]
    
# Autre proposition de exercice 4

def mobile(liste,taille):
    """
        mobile : Est une fonction qui prend un tableau nommé liste et qui calcule la moyenne mobile de periode taille
        args :
            Liste : designe le tableau de nombre
            taille : la periode (le nombre de chiffre pris dans le tableau pour calculer la moyenne)
            
        Retuns :
                resultat: une liste de moyenne 
        Exemple :
                liste=[1,2,3,4,5,3],
                taille=2
                resultat=[1.5, 2.5, 3.5, 4.5, 4.0]
    """
    resultat=[];
    for i in range(1,len(liste)):
        resultat.append(sum(liste[i:i+taille])/taille);
    return resultat;

## exo5

#c'était mon sujet de TIPE donc j'en ai marre je saute et je fais l'exo6 en prenant mon gouter

def computeMeanAndStdDev(n):
    """
        computeMeanAndStdDev : Est une fonction qui genère des nombres aleatoires.......
        
        Args :
            liste : Tableau de nombre aleatoire compris entre 0 et 1.
            n : la taillle de la liste. Il designe le nombre de variable aleatoire genéré par la fonction random
            
    """
    liste = []
    for i in range(n):
        liste.append(randint(0,1))

## exo6
je fais la docu dans 5 mins

def uniq(uneListe):
    """delete any redondancies

    Args:
        uneListe ([list]): [list with order please]

    Returns:
        [list]
    """
    return list(set(uneListe))
    
def fusion(L1, L2):
    m, n = len(L1), len(L2)
    i, j = 0, 0
    L = []
    while (i < m) & (j < n):
        b = L1[i] < L2[j]
        L.append(b*(L1[i] - L2[j]) + L2[j])
        i += b
        j += not(b)
    return L + L1[i:] + L2[j:]
    
import sys

def sort_and_clean(L):
    """sort the list L and delete any redondancies

    Args:
        L ([list]): [a list of integers or float, or anything or with order]

    Returns:
        [type]: [description]
    """
    l = len(L)//2
    return fusion(sorted(uniq(L[:l])), sorted(uniq(L[l:])))

sys.argv[1 :] = sort_and_clean(sys.argv[1 :])

## exo7

def solution(f, a, b, epsilon = 10**-6):
    """find the root of f between a and b, with epsilon tolerance

    Args:
        f ([function]): [it has to be "continuous" lol, not simple for a computer]
        a ([float]): [lower bound]
        b ([float]): [upper bound]
        epsilon ([float], optional): [tolerance, aka small value]. Defaults to 10**-6.

    Returns:
        [type]: [description]
    """
    x = (a+b)/2 #(a&b) + ((a^b)>>1) if you're galactic brain
    tmp = f(x)
    while abs(tmp) > epsilon:
        a = (tmp < 0)*(x - a) + a
        b = (tmp > 0)*(x - b) + b
        x = (a + b)/2
        tmp = f(x)
    return x
'''