Algorithique 0.1 Probl`eme 1 - Site de la PCSI du lycée Paul Eluard

Ann´ee scolaire 2013/2014
PCSI Informatique: Cours5
Algorithique
0.1 Probl`eme 1
Comment d´emontrer qu’un algorithme fait bien ce qu’on veut en un temps fini.
1. D´emontrer qu’une boucle se termine effectivement
Solution On identifie un variant de boucle c’est-`a-dire une expression (le plus souvent une variable)
qui est un entier positif et qui diminue strictement `a chaque it´eration.
Th´eor`eme math´ematique : Il n’existe pas une suite d’entiers naturels strictement d´ecroissante.
En cons´equence : il ne peut y avoir qu’un nombre fini d’it´erations.
2. D´emontrer que la boucle fait bien ce qu’on veut
Solution On identifie un invariant de boucle c’est-`a-dire une propri´et´e qui
– est v´erifi´ee avant l’entr´ee dans la boucle
– si elle est v´erifi´ee avant une it´eration, est v´erifi´ee apr`es celle-ci.
– permet d’en d´eduire, en sortie de boucle, que le programme est correct.
Exemple 1 La division euclidienne des nombres entiers.
Th´eor`eme math´ematique : Pour tous entiers (a, b) o`u b6= 0, il existe un couple (q, r) unique d’entiers tel
que (a=bq +r
0≤r < b .qest le quotient et rle reste de la division euclidienne de apar b.
On propose un algorithme ´ecrit en Python qui, `a partir de aet bentr´es par l’utilisateur, renvoie qet r.
def d i v i s i o n e u c l i d i e n n e ( a , b ) :
q=0
r=a
while r>=b :
q=q+1
r=r−b
r et un ( q , r )
1. Tester l’algorithme avec n= 17 et b= 4. Remplir le tableau ci-dessous :
Avant it´eration n◦n r
2
3
4
5
..
2. On note Pla propri´et´e a=bq +r, montrer que cette propri´et´e est un invariant de boucle
–Avant d’entrer dans la boucle
– Si Pest vraie avant d’entrer dans la boucle iavec des valeurs ri, qides variables, montrer que Pest
vraie avant d’entrer dans la boucle i+ 1 avec des valeurs ri+1, qi+1.
– Montrer que Pest vraie en sortie de boucle.
1

Ann´ee scolaire 2013/2014
PCSI Informatique: Cours5
3. Que choisir comme variant de boucle ? Montrer que la variable choisie est bien un variant de boucle
Exemple 2 Algorithme permettant de calculer apdans le cas o`u p∈N.
def p u i s s a n c e ( a , p ) :
r=1
n=p
x=a
while n ! =0 :
i f n\%2==1:
r=r ∗x
x=x∗x
n=x //2
return(r)
1. Tester l’algorithme pour le calcul de 59puis de 314. Remplir les tableaux ci-dessous :
Avant it´eration n◦r n x
1 1 9 5
3
4
5
..
Avant it´eration n◦r n x
1 1 14 3
3
4
5
..
2. On note Pla propri´et´e rxn=ap, montrer que cette propri´et´e est un invariant de boucle.
3. Que choisir comme variant de boucle ? Montrer que la variable choisie est bien un variant de boucle.
2

Ann´ee scolaire 2013/2014
PCSI Informatique: Cours5
0.2 Probl`eme 2 : la Complexit´e
1. Coˆut d’un algorithme
Pour traiter un mˆeme probl`eme, il existe souvent plusieurs algorithmes. Quand on doit choisir, l’un des
crit`eres est celui du temps d’ex´ecution, qu’on appelle parfois coˆut de l’algorithme.
Le temps d’ex´ecution d´epend du nombre d’op´erations ´el´ementaires mises en oeuvre dans l’algorithme.
2. De quoi tient-on compte pour d´eterminer le coˆut d’un algorithme ?
On se fonde sur le mod`ele de complexit´e suivant :
– Une affectation, une comparaison, l’´evaluation d’une op´eration arithm´etique ont un faible temps d’ex´ecution,
celui-ci est consid´er´e comme l’unit´e de mesure du coˆut d’un algorithme.
– Le coˆut d’ex´ecution de deux instructions successives est ´egal `a la somme des coˆuts d’ex´ecution de
chacune de ces instructions.
– Le coˆut du test if b: p else: q est inf´erieur ou ´egal au maximum des coˆuts des instructions pet q
plus le temps de l’´evaluation de l’expression b.
– Coˆut d’une boucle du type for i in ...: p(i) la somme des coˆuts des instructions p(i).
En g´en´eral, on ne donne pas pr´ecis´ement le nombre d’op´erations faites ni le nombre de comparaisons
faites, on se contente d’un ordre de grandeur pour ces nombres.
D´efinition 1 On dira qu’un algorithme a une complexit´e en O(f(n)) si son coˆut est, `a partir d’un certain
rang, inf´erieur `a K∗f(n)o`u Kest une constante.
Exemples Les algorithmes suivants calculent et affichent diff´erentes suites de nombres. Quelle est la com-
plexit´e de chacun d’eux ?
def t a b l e 1 ( n ) :
for iin ra nge ( 1 1 ) :
print( i ∗n )
def t a b l e 1 ( n ) :
for iin ra nge ( 1 1 ) :
print( i ∗n )
def t a b l e 2 ( n ) :
for iin ra nge ( 1 1 ) :
print( i ∗i )
def t a b l e 3 ( n ) :
for iin r an g e ( n ) :
for jin r an ge ( n ) :
print( i ∗j )
def t a b l e 4 ( n ) :
for iin r an g e ( n ) :
for jin ra nge ( i ) :
print( i ∗j )
3

Ann´ee scolaire 2013/2014
PCSI Informatique: Cours5
3. Evaluations
On a des complexit´es en O(1), O(log(n)), O(n), O(nlog(n), O(n2), O(nk) et O(2n).
4. Diff´erentes nuances de complexit´e
–La complexit´e au pire.
On cherche un majorant du temps d’ex´ecution, on retient le pire des cas
–La complexit´e dans le meilleur des cas
On cherche un minorant du temps d’ex´ecution, on se place dans le meilleur des cas
–La complexit´e en moyenne
On cherche le coˆut moyen de l’algorithme, On consid`ere qu’on travaille sur une situation au hasard, on
introduit la variable al´eatoire ’Coˆut’ dont on calcule la loi et l’esp´erance.
–La complexit´e en espace.
Si l’algorithme prend trop de place m´emoire, il peut avoir besoin de m´emoire que la capacit´e de m´emoire
vive allou´ee par le syst`eme d’exploitation. Une partie de cette m´emoire sera alors stock´ee sur un espace
de stockage d’acc`es moins rapide (le disque dur par exemple). Le temps que passera le syst`eme d’ex-
ploitation `a g´erer l’espace m´emoire d´egradera les performances de notre algorithme et le coˆut th´eorique
en temps ne sera plus pertinent.
Pour certains probl`emes la quantit´e des donn´ees est tr`es importante et ils important de minimiser le
temps d’acc`es `a l’information ainsi que le codage de celle-ci. Bien souvent, dans les programmes, le
gain en m´emoire se fait au d´etriment du temps d’ex´ecution et le gain en temps d’ex´ecution se fait au
d´etriment de l’espace m´emoire occup´e
Trouver un compromis
5. Complexit´e du tri `a bulles
On a une liste tde nentiers distincts, on veut trier cette liste dans l’ordre croissant
(a) Que fait la suite de commandes suivante :
for iin ra nge ( n −1):
i f t [ i ]>t [ i + 1 ]:
x=t [ i ]
t [ i ]= t [ i +1]
t [ i +1]=x
Eventuellement proposer une commande plus courte qui fait la mˆeme chose que les trois derni`eres
lignes
(b) Compl´eter le programme ci-dessous pour qu’il renvoie la liste tri´ee dans l’ordre croissant.
for . . in ran ge ( . . . . . . . . ) :
for . . in ran ge ( . . . . . . ) :
i f t[..] >t[...]:
x=t [ . . ]
t [ . . ] = t [ . . . ]
t [ . . . ] = x
(c) Combien le programme r´ealise-t-il de comparaisons quand il trie une liste tde nentiers distincts ?
(d) Combien d’´echanges pour trier la liste t=[1,2,3,4,......,n]
(e) Combien d’´echanges pour trier la liste t=[n,n-1, n-2,..........,1]
Le tri `a bulles est un tri en O(n2) les meilleurs algorithmes de tri sont en O(nlog(n)).
4