Algorithmique.

BCPST 1B2014/2015
Algorithmique.
1) Introduction.
Ce cours peut ˆetre d´econnect´e du cours de programmation en Python. Python sera un outil d’illustration,
mais ici nous pr´esentons des algorithmes classiques et d’usage universel.
Nous nous int´eresserons essentiellement `a des probl`emes simples pos´es sur des donn´ees num´eriques struc-
tur´ees dans une liste.
Nous verrons aussi des exemples d’algorithmes r´esolvant des probl`emes sur les chaˆınes de caract`eres, des
images ou permettant de simuler des variables al´eatoires `a l’aide d’un g´en´erateur de nombres pseudo-
al´eatoires.
Commen¸cons par donner les op´erations constituant un algorithme (ce sont les r`egles du jeu) :
a) Lecture d’une valeur dans une variable ou dans un ´el´ement d’une liste.
b) Evaluation d’une expression num´erique avec +, −,∗et /.
c) Affectation d’une valeur `a une variable ou `a un ´el´ement d’une liste. (on utilisera la notation : ←)
d) Comparaison de deux valeurs num´eriques <, = ,6= et >
e) Branchement conditionnel (Si ...)
f) Boucle it´erative (Pour ...)
g) Boucle conditionnelle (Tant que ...)
Dans les algorithmes ´etudi´es nous n’utiliserons (”presque”) que cela,
Les valeurs num´eriques seront enti`eres ou r´eelles.
Remarque : Pour s’entrainer avec la num´erotation Python nous utiliserons la num´erotation de 0 `a n−1.
L(0 : n−1) = (L(0), L(1), ...., L(n−1)) pour une liste de longueur n,
T(0 : n−1) =0T(0)T(1) · · · T(n−1)0pour une chaˆıne de caract`eres de longueur n.
Exemple :
Entr´ees :n: un entier.
Variables :i: un entier, x: un r´eel, L(0 : n−1) : une liste de nombre r´eels.
D´ebut
i←0
Tant que i<nfaire
L(i)←i∗i
i←i+ 1
x←x+L(0)
Pour iallant de 1`a n−1faire
x←L(i)
Sorties : La valeur de x
Remarque importante : L’ensemble des algorithmes de ce cours sont explicitement au programme.
Vous devez ˆetre capable de tous les r´e´ecrire et de les expliquer.
1

2) Recherches dans une liste.
•Recherche d’une valeur dans une liste
Soit nun entier, xun r´eel et Lune liste de nr´eels.
On suppose que xest pr´esent au moins une fois dans la liste.
L’algorithme suivant permet de savoir o`u est le premier xde la liste.
Algorithme 1 : Recherche d’une valeur dans une liste
Entr´ees :n: un entier, x: un r´eel, L(0 : n−1) : une liste de nombre r´eels,
Variables :i: un entier.
D´ebut
i←0
Tant que L(i)6=xfaire
i←i+ 1
Sorties :i
Remarques sur le nombre d’op´erations n´ecessaires :
- Le nombre de comparaisons (minimum = 1, maximum = n),
- Le nombre d’affectations = au nombre de comparaisons,
- Nombre moyen d’affectations : n+ 1
2.
On dit que la complexit´e de cet algorithme est en O(n), cela signifie que le nombre d’op´erations n´ecessaires
est proportionnel `a la taille des donn´ees.
Si on multiplie par 10 la taille de la liste `a l’entr´ee de cet algorithme le nombre d’op´erations n´ecessaires
sera multipli´e par 10. Nous verrons plus tard que cette complexit´e peut ne pas ˆetre lin´eaire.
Traduction en une fonction Python :
def recherche(x,L):
"""float or in,list->int
L est une liste de flottants ou d’entiers contenant x
retourne le plus petit i tel x=L[i]"""
i=0
while x!=L[i]:
i=i+1
return i
•Recherche du maximum des valeurs dans une liste.
Soit nun entier, Lune liste de nr´eels.
L’algorithme suivant permet de calculer le maximum des valeurs de la liste :
Algorithme 2 : Calcul du maximum des valeurs dans une liste.
Entr´ees :nun entier, L(0 : n−1) : une liste de nombre r´eels.
Variables :Mun r´eel
D´ebut
M←L(0)
Pour iallant de 1`a n−1faire
Si L(i)> M alors
M←L(i)
Sorties : La valeur de M
2

Remarques sur le nombre d’op´erations n´ecessaires :
- Le nombre de comparaisons : n−1
- Le nombre d’affectations (Minimum : 1, Maximum : n)
- Nombre moyen d’affectations : Pas facile.
Avec un peu de connaissance en probabilit´e on montre que pour ngrand ce nombre vaut `a peu pr`es ln(n)
def maximum(L):
"""List->float or int
L est une liste de flottants ou d’entiers
retourne la plus grande valeur de L"""
M=L[0]
for k in range(len(L)):
if M<L[k]:
M=L[k]
return M
•Recherche d’un mot dans une chaˆıne de caract`eres.
Position du probl`eme :
On cherche la position d’un mot dans un texte. Plus pr´ecis´ement, on cherche la place de la premi`ere
apparition du mot Wdans le texte T.
Soit n, m deux entiers naturels non nuls, Tune chaˆıne de ncaract`eres et Wune chaˆıne de mcaract`eres,
on suppose que m6n.
L’algorithme suivant permet de d´eterminer l’indice du d´ebut de la premi`ere apparition de Wdans T
Algorithme 3 : Recherche d’une sous-chaine.
Entr´ees :net mdeux entiers, T(0 : n−1) et W(0 : m−1) : deux chaˆınes de caract`eres.
Variables :i,j: deux entiers
D´ebut
i←0
x← −1
Tant que i<n−m+ 1 faire
j←0
Tant que j < m et T(i+j) = W(j)faire
j←j+ 1
Si j=malors
x←i
i←n−m+ 1
sinon
i←i+ 1
Sorties : La valeur de x, (la valeur −1 signifiant que la sous-chaine n’est pas pr´esente).
Remarque :
Dans le pire des cas, en prenant T=AAAAA....AAA et W=AAA...AAB :
le nombre de comparaisons est ´egal `a (n−m+ 1)m.
3

Traduction en une fonction Python :
def recherche_mot(W,T):
"""str,str->int
retourne la position de la premi`ere apparition de W dans T """
x=-1
n=len(T)
m=len(W)
i=0
while i<n-m+1:
j=0
while j<m and W[j]==T[i+j]
j=j+1
if j==m:
x=i
i=n-m+1 # Arr^ete la boucle en i
else:
i=i+1
return x
On peut faire plus simple en Python :
def recherche_mot(W,T):
n=len(T)
m=len(W)
for i in range(n-m+1):
if T[i:i+m]==W:
return i
return None
3) Calcul d’une somme, d’un produit, d’une moyenne..
Un algorithme pour calculer la somme des valeurs dans une liste :
Algorithme 4 : Somme
Entr´ees :nun entier, L(0 : n−1) : une liste de nombre r´eels
Variables :Sun r´eel
D´ebut
S←L(0)
Pour iallant de 1`a n−1faire
S←S+L(i)
Sorties : La valeur de S
Remarque : naffectations pour calculer une somme.
Traduction en une fonction Python :
def somme(L):
"""List->float or int
L est une liste de flottants ou d’entiers
retourne la somme des valeurs de L"""
S=L[0]
for k in range(1,len(L)):
S=S+L[k]
return S
4

Un algorithme pour calculer le produit des valeurs dans une liste :
Algorithme 5 : Produit
Entr´ees :nun entier, L(0 : n−1) : une liste de nombre r´eels
Variables :Pun r´eel
D´ebut
P←L(0)
Pour iallant de 1`a n−1faire
P←P∗L(i)
Sorties : La valeur de P
Remarque : naffectations pour calculer un produit.
Traduction en une fonction Python :
def produit(L):
"""List->float or int
L est une liste de flottants ou d’entiers
retourne le produit des valeurs de L"""
P=L[0]
for k in range(1,len(L)):
P=P*L[k]
return S
Un algorithme pour calculer la moyenne des valeurs dans une liste :
Algorithme 6 : Moyenne
Entr´ees :nun entier, L(0 : n−1) : une liste de nombre r´eels
Variables :Mun r´eel
D´ebut
M←L(0)
Pour iallant de 1`a n−1faire
M←M+L(i)
M←M/n
Sorties : La valeur de M
Remarque : n+ 1 affectations pour calculer une moyenne.
Traduction en une fonction Python :
def somme(L):
"""List->float or int
L est une liste de flottants ou d’entiers
retourne la somme des valeurs de L"""
S=L[0]
for k in range(1,len(L)):
S=S+L[k]
return S/len(L)
5