---
# System prepended metadata

title: GR 1 EQ 5

---

# GR 1 EQ 5

## Exercice 2

```python=
def afficherTitre(texte,largeur=0,alignement="C"):
    '''
    Affiche un texte sous la forme d'un titre entouré d'astérisques
    :param texte: liste contenant le texte à afficher
    :param largeur: largeur en caractères de l'affichage à produire; si omis ou inférieur à la largueur minimale
    requise, sera déterminé pour s'ajuster sans marges à la plus longue ligne du texte
    :param alignement: détermine si le texte doit être centré (C, par défaut), aligné à gauche (G) ou à droite (D)
    :return: sortie directe dans la console
    '''
    largeur = max(len(sorted(texte,key=len)[-1]) + 2,largeur)
    print("*"*largeur)
    for ligne in texte:
        if alignement.upper() == "C":
            print("*" + str(ligne).center(largeur-2) + "*")
        elif alignement.upper() == "G":
            print("*" + str(ligne).ljust(largeur-2) + "*")
        elif alignement.upper() == "D":
            print("*" + str(ligne).rjust(largeur-2) + "*")
        else:
            raise ValueError
    print("*" * largeur)
```

## Exercice 3
```python=
def incluse(a,b):
    '''
    Détermine si tous les caractères de la chaîne a sont présents dans la chaîne b
    :param a: chaîne contenant les caractères dont la présence est à vérifier
    :param b: chaîne contenant les caractères de référence
    :return: un booléen valant True si tous les caractères de a sont présents dans b et False sinon
    '''
    return set(a).issubset(set(b))

def verifierEntierValide(val, inf=None, sup=None):
    '''
    Vérifie si une saisie est bien un nombre entier compris entre une borne inférieure et une borne supérieure
    :param val: chaîne de caractères à vérifier
    :param inf: borne inférieure, fixée à None si l'intervalle de test n'a pas de borne inférieure
    :param sup: borne supérieure, fixée à None si l'intervalle de test n'a pas de borne supérieure
    :return: un booléen valant True si la saisie est bien un entier compris dans l'intervalle et False sinon
    '''
    return incluse(val,"0123456789") and ((inf is None) or (int(val) >= inf)) and ((sup is None) or (int(val) <= sup))
```

## Exercice 4
```python=
def moyenneMobile(S_1,n):
    '''
    Calcule la moyenne mobile d'une liste de nombres avec une période n
    :param S_1: liste de valeurs
    :param n: période de calcul de la moyenne mobile
    :return: Liste S_2 contenant len(S_1) - n + 1 valeurs
    '''
    S_2 = list()
    for i in range(0,len(S_1)-n+1):
        S_2.append(sum(S_1[i:i+n])/n)
    return(S_2)
```

## Exercice 5
```python=
from math import sqrt
from random import random
from random import randint
from random import choice

def computeMeanAndStdDev(liste):
    '''
    Calcule la moyenne et l'écart-type empirique d'une liste de valeurs
    :param liste: liste de valeurs numériques
    :return: tuple(Moyenne, Ecart-Type)
    '''
    N = len(liste)
    S = sum(liste)
    Q = sum([x**2 for x in liste])
    moyenne = S/N
    std = sqrt(Q/N-(moyenne**2))
    return (moyenne, std)

def testRandom(n):
    '''
    Teste la qualité de la fonction random en mesurant la moyenne et l'écart-type d'une série de nombres aléatoires
    :param n: longueur de la série de nombres aléatoires
    :return: affichage de la valeur absolue de l'écart entre la moyenne/écart-type empirique et théorique
    '''
    liste = [random() for i in range(n)]
    moyenne, std = computeMeanAndStdDev(liste)
    print(abs(moyenne-0.5),abs(std-sqrt(1/12)))
    
def testRandint(n,a,b):
    '''
    Teste la qualité de la fonction randint en déterminant la fonction de réparatition empirique d'une série de n nombres tirés entre a et b
    :param n: longueur de la série de nombres aléatoires
    :param a: borne inférieure du tirage aléatoire
    :param b: borne supérieure du tirage aléatoire
    :return: affichage de la fonction de répartition empirique de la série aléatoire
    '''
    liste = [randint(a,b) for i in range(n)]
    repartition = dict()
    for i in range(a,b+1):
        repartition[i] = liste.count(i)/n
    print(repartition)

def genADN(n):
    '''
    Génère une séquence ADN aléatoire de longueur n
    :param n: longueur de la séquence ADN
    :return: Chaîne correspondant à la séquence ADN générée
    '''
    sequence = [choice(['A','T','G','C']) for i in range (n)]
    return ''.join(sequence)
    
def permut(liste):
    '''
    Retourne une liste dont les éléments ont été aléatoirement permutés
    :param liste: liste à permuter
    :return: liste permutée
    '''
    liste = list(liste)
    permutee = list()
    iterations = len(liste)
    for i in range(iterations):
        permutee.append(liste.pop(randint(0,len(liste)-1)))
    return permutee

def permutShuffle(liste):
    '''
    Retourne une liste dont les éléments ont été aléatoirement permutés avec la fonction shuffle
    :param liste: liste à permuter
    :return: liste permutée
    '''
    liste = list(liste)
    shuffle(liste)
    return liste
```

## Exercice 6
```python=
def trierListe(liste):
    '''
    Trie une liste de valeurs numériques par ordre croissant
    :param liste: liste à tirer
    :return: liste triée
    '''
    liste = list(liste)
    liste.sort()
    return liste

def trierListe2(liste):
    '''
    Trie une liste de valeurs numériques par ordre croissant
    :param liste: liste à tirer
    :return: liste triée
    '''
    liste = list(liste)
    return sorted(liste)

def uniq(liste):
    '''
    Retourne une liste triée et dédoublonnée à partir d'une liste de valeurs numériques
    :param liste: liste à trier
    :return: liste dédoublonnée triée
    '''
    return sorted(set(liste))
    
def fusion(liste1, liste2):
    '''
    Fusionne en une liste unique 2 listes numériques triées
    :param liste1: 1ère liste triée à fusionner
    :param liste2: 2ème liste triée à fusionner
    :return: Liste fusionnée triée
    '''
    listef = list()
    while len(liste1) + len(liste2) > 0:
        if len(liste2) == 0 or (len(liste1) > 0 and liste1[0] <= liste2[0]):
            listef.append(liste1.pop(0))
        else:
            listef.append(liste2.pop(0))
    return listef
```

## Exercice 7
```python=
from math import cos

def solution(f,a,b,epsilon):
    '''
    Détermine par dichotomie la solution de l'équation f(x)=0 sur l'intervalle [a,b]
    :param f: fonction
    :param a: borne inférieure
    :param b: borne supérieure
    :param epsilon: degré d'approximation
    :return: valeur approchée de x tel que f(x) = 0
    '''
    binf = a
    bsup = b
    while abs(binf-bsup) > epsilon:
        c = (binf+bsup)/2
        if f(c) <= 0:
            if f(binf) <= 0:
                binf = c
            else:
                bsup = c
        else:
            if f(binf) > 0:
                binf = c
            else:
                bsup = c
    return (binf+bsup)/2
    
    solution(cos,0,3,0.001)
    solution(lambda x: x**2 - 2,1,2,0.0000001)
```