# 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)
```
Google Drive
Gist
Clipboard
Sign in with Wallet
