Feuille d`exercices 2

Algorithmique
Feuille d’exercices 2: correction et terminaison des boucles
Prenons quelques tˆaches simples, pour lesquelles on demande d’´ecrire un algorithme qui la remplit, de
d´emontrer sa correction et, si n´ecessaire, sa terminaison. Ce sont plus des exercices de r´edaction que de
r´eflexion. Les points `a ne pas n´egliger :
— ´enoncer clairement les invariants de boucle
— justifier leur invariance
— v´erifier qu’ils sont vrais avant la boucle pour en conclure qu’ils sont vrais apr`es celle-ci.
Si on montre la terminaison avec un variant de boucle :
— indiquer clairement ce dernier en tant que variant de boucle
— au moins mentionner le fait qu’il ne prend que des valeurs enti`eres, mˆeme si c’est ´evident
— justifier sa d´ecroissance stricte d’une it´eration `a la suivante
— justifier le fait qu’il ne peut pas d´ecroˆıtre ind´efiniment (qu’il doit rester positif, par exemple)
Les deux premiers exercices sont corrig´es pour donner un exemple du niveau de formalisme attendu.
1. pgcd de aet b: On choisit l’algorithme d’Euclide, avec une pr´ecaution au d´ebut pour s’assurer de la
positivit´e des arguments :
a=abs(a)
b=abs(b)
while b>0:
r=a%b
a=b
b=r
d=a
Correction : On note a0et b0les valeurs initiales de aet b. La positivit´e de aet b, le fait que pgcd(a,
b)=pgcd(a0,b0), sont des invariants de la boucle :
— si best positif avant une it´eration, aqui prend sa valeur au cours de cette it´eration sera positif apr`es
cela. La valeur de bapr`es une it´eration est le reste de la division euclidienne de deux naturels :
elle est donc positive.
— en notant aiet biles valeurs de aet bavant une it´eration, et afet bfleurs valeurs apr`es cette
it´eration, on a af=biet ai=q×bi+bfpour un certain entier q. Comme aiet bisont des
combinaisons enti`eres de afet bf, et r´eciproquement afet bfsont des combinaisons enti`eres de
aiet bi, on a pgcd(ai,bi)=pgcd(af,bf)
Ces invariants ´etant vrais avant l’entr´ee dans la boucle, ils le sont encore `a sa sortie. D’apr`es la
condition de sortie de boucle, on a b= 0 `a ce moment-l`a, ce qui permet de conclure que a, et donc d,
vaut pgcd(a0,b0).
Terminaison : best un variant de boucle : il est ´evidemment `a valeurs enti`eres, et `a chaque it´eration,
sa valeur finale bfest le reste dans une division euclidienne par sa valeur initiale, bi: on a donc
0≤bf< biet par cons´equent bd´ecroˆıt strictement `a chaque it´eration. Comme il doit rester positif
d’apr`es la condition de la boucle, ceci prouve la terminaison de cette boucle.
2. ´ Ecrire un algorithme qui prend une liste tet une valeur x, et d´etermine si xest un ´el´ement de t.
R´eponse :
1

def contient(L,x):
n=len(L)
present=False
for iin range(n):
if L[i]==x:
present=True
return present
Correction :
— Montrons que la formule I: “present ⇔ ∃j < i tel que x=L[j]” est un invariant de cette boucle.
— Si elle est vraie au d´ebut d’une it´eration, `a la fin de celle-ci on est dans l’un des deux cas suivants :
soit L[i]=x et present=True, soit L[i]6=x et present est inchang´e, c’est `a dire present ⇔ ∃j < i
tel que x=L[j]. Dans les deux cas, cela signifie que present ⇔ ∃j < (i+ 1) tel que x=L[j], et
donc qu’apr`es incr´ementation de i, l’invariant est toujours vrai au d´ebut de l’it´eration suivante.
— Comme Iest ´evidemment vrai au d´ebut de la boucle quand i=0 et present=False, on en d´eduit
qu’il est vrai `a la fin de la boucle en imaginant i=n.
— Il en d´ecoule que la valeur bool´eenne retourn´ee est ´equivalente `a “∃j < n tel que x=L[j]”,
autrement dit au fait que xsoit un ´el´ement de L.
3. Pareil avec un algorithme de calcul du minimum d’une liste. (Donn´e en exemple dans le chapitre
“Complexit´e”)
4. Pareil avec un algorithme calculant la somme des ´el´ements d’une liste.
5. D´ecomposition en base b≥2. On rappelle que l’´ecriture en base b c1c2. . . cnbrepr´esente l’entier
n
X
i=1
cibn−i. On consid`ere la fonction suivante, tir´ee d’un ´enonc´e de CCP 2015 :
def chiffres(n,b):
""" Donnees : deux entiers n>0 et b>1
Resultat : une liste de chiffres"""
t=[]
while n>0:
c=n%b
t.append(c)
n=n//b
return t
(a) Cette fonction calcule l’´ecriture en base b≥2 de l’entier n. Formaliser cette sp´ecification par une
pr´econdition et une postcondition.
(b) Justifier la terminaison de la boucle while (ce que l’´enonc´e de 2015 demandait). Quelle partie de
la pr´econdition est n´ecessaire pour cela ?
(c) D´emontrer `a l’aide d’un invariant de boucle que l’algorithme satisfait cette sp´ecification.
6. Donner un algorithme prenant deux listes de mˆeme longueur, et retournant leur produit scalaire.
Prouver sa correction.
7. Pareil avec un algorithme qui compte le nombre d’´el´ements nuls dans une liste Lre¸cue en argument.
Indice pour la question 5c : utiliser l’invariant “n∗blen(t) +
len(t)−1
X
i=0
bit[i] est ´egal au ninitial”.
8. ´ Ecrire en python un algorithme de recherche par dichotomie qui prend une liste ttri´ee dont on sait
qu’elle contient x, et d´etermine l’indice de xdans cette liste. Prouver sa correction et sa terminaison.
2