Algorithmes et programmation

Algorithmes et programmation
4 janvier 2015
1 Introduction
1.1 Algorithme et programme
Un algorithme est une suite d’opérations élémentaires constituant un schéma de
calcul et de résolution en un temps fini (et acceptable) d’un problème donné.
— Les opérations élémentaires correspondent à une suite d’instructions visant à
tranformer les données pour obtenir le résultat.
— Un algorithme est indépendant de tout langage de programmation. Il est écrit en
pseudo-langage.
Un programme est l’implémentation (ou implantation) d’un algorithme dans un
langage de programmation donné.
Un algorithme n’est pas un programme. Par exemple, dans un algorithme, on ne
précise pas comment sont formatées les variables utilisées (polynôme, tableau...).
1.2 Portée des variables
— Une variable locale est une variable utilisée comme paramètre d’une procédure,
ou qui est affectée à l’intérieur d’une procédure.
Une fois la procédure exécutée, la variable locale a perdu la valeur qu’elle avait
au sein de la procédure.
— On dit que la portée d’une variable locale est limitée au corps de la procédure où
elle est utilisée.
— Une variable globale est une variable utilisée à l’intérieur d’une fonction sans y
être affectée ou qui est déclarée comme globale à l’intérieur d’une procédure.
— On dit que la portée d’une variable globale s’étend à l’ensemble du programme.
1

def f():
global a
a=a+1
c=2*a
return a+b+c
Dans ce programme, aet bsont globales mais cest locale.
x=1
def plusun ():
x+=1
return x
ERREUR car, x étant affecté à l’intérieur de la procédure, x est considérée comme
variable locale qui n’est donc pas initialisée donc ’x=x+1’ donne une erreur.
Par contre
x=1
def plusun ():
return 1+x
renvoie 2. xest considérée comme variable globale.
def f():
global x
x=2
def g():
x=3
Ici, on a deux variables x indépendantes : une globale dans f et une locale dans g.
Dans g , on ne peut plus accéder à la variable globale x car masquée par la variable
locale x.
x=1
f()
g()
print x
affiche 2.
On utilisera les variables globales pour les constantes du problème.
On évitera d’avoir à recourir à l’instruction global .
On évitera de donner des noms de variables identiques aux variables locales et aux
variables globales.
On donnera des noms de variables longs et explicites pour les variables globales, et
des noms courts pour les variables locales.
Pour écrire un algorithme, on doit procéder de la manière suivante :
1. définir la spécification (ie le contrat) formée de :
— La précondition,
— La postcondition,
2

2. écrire l’algorithme
3. Justifier sa correction composée de :
— la correction partielle (sous réserve de terminaison)
— La terminaison .
— Le couple précondition/postcondition représente un contrat : on garantie que
sous réserve que la précondition est vérifiée au début, la postcondition le sera à
la fin.
— Justifier la correction partielle du programme consiste à démontrer que l’algo-
rithme respecte le contrat pour toutes les valeurs pour lesquelles l’algorithme
termine.
Dans le cas d’une boucle ’for’ ou ’while’ :
— définir un invariant de boucle pour une boucle for ou while qui est une
propriété qui est vraie à l’entrée de la boucle et qui, si elle est vraie en début
de tour de boucle, est vraie à la fin du tour. Dans ce cas, à la sortie du dernier
tour de boucle, on obtient le résultat cherché.
— justifier cet invariant de boucle.
— Prouver la correction partielle du programme ie montrer que
(Precond + condition d’arrêt de la boucle ⇒Postcond ).
Pour une boucle ’while cond’, la condition d’arrêt est ’non cond’
Pour une boucle ’for i in range(n)’, la condition d’arrêt est ’i=n-1’.
La question de la terminaison ne se pose que pour une boucle «tant que condition
».
On la justifie en :
— définissant un variant de boucle qui est une valeur entière , positive et décrois-
sant strictement à chaque tour de boucle ;
— justifiant ce variant de boucle pour en déduire la terminaison (ie condition fausse)
2 Exemples classiques
2.1 Division euclidienne
Calculer quotient et reste d’une division euclidienne en utilisant pour seules opéra-
tions arithmétiques l’addition et la soustraction.
2.1.1 Spécifier le problème
Étant donné deux entiers n et d , avec d > 0 et n≥0 , on veut retourner l’unique
couple d’entiers (q, r)tel que n=dq +ret 0≤r < d.
3

2.1.2 Écrire un algorithme
Précondition:n∈Net d∈Z∗
Postcondition:q∈N,r∈[[0, d[[ et n=dq +r
1q←0;
2r←a;
3tant que r≥dfaire
4r←r−d;
5q←q+ 1
6fin
2.1.3 Correction partielle d’un algorithme
Ajout d’un invariant :
Précondition:n∈Net d∈Z\ { 0}
Postcondition:q∈N,r∈[[0, d[[ et n=dq +r
1q←0;
2r←n;
3tant que r≥dfaire
4invariant n=dq +r;
5r←r−d;
6q←q+ 1
7fin
Justification de l’invariant L’invariant de boucle «tant que» ligne 4 est vérifié car
1. Quand on arrive à la boucle, q= 0 et r=n, donc n=dq +r;
2. Si l’invariant est vérifié au début d’un tour de boucle alors il est encore vérifié à
la fin de ce même tour. En effet, si on note qk et rk les valeurs de q et r au début
d’un tour de boucle, on a rk+1 =rk−d et qk+1 =qk+ 1 donc dqk+1 +rk+1 =
dqk+d+rk−d=dqk+rk=nce qui justifie l’invariant.
Correction partielle du programme À la sortie de la boucle on a donc n=dq +r et
r < d.
(Il nous manque r≥0: il aurait suffit de l’ajouter dans l’invariant de boucle).
Conclusion Si la précondition est vérifiée au début de l’exécution de l’algorithme alors
la postcondition est vérifiée à la fin. . . sous réserve que cette exécution se termine !
L’algorithme est donc partiellement correct.
Remarquez que notre algorithme ne termine pas toujours : prendre d=−1 par
exemple !
4

2.1.4 Justifier la terminaison d’un algorithme (impératif)
Risque de non-terminaison : les boucles «tant que».
Renforçons la précondition : on prendra d∈N∗.
Précondition:n∈Net d∈N∗
Postcondition:q∈N,r∈[[0, d[[ et n=dq +r
1q←0;
2r←a;
3tant que r≥dfaire
4invariant n = dq+r;
5variant r-d;
6r←r−d;
7q←q+ 1
8fin
Sous la précondition n∈N,ret dont des valeurs entières.
De plus, la condition de boucle est r≥d donc dans le corps de la boucle, r−d est
toujours positif.
Enfin, rdiminue de dà chaque tour de boucle et d > 0(précondition d∈N∗).
Donc r−dest un entier positif diminuant strictement à chaque tour de boucle.
2.1.5 Programme
def diveuclide(n,d) :
" " " Retourne un couple (q , r ) avec
q naturel , 0 <= r < d et n == d*q + r
Pr é c on di tio n : n e n t i e r n at ur el , d n a tu re l non nul . " " "
q= 0
r=a
while r>= d:
#n == d*q + r
# v a r i a n t : r−d
r=r−d
q=q+ 1
return q,r
2.2 Recherche du minimum d’un tableau
2.2.1 Spécification
On veut rechercher l’indice du minimum d’un tableau.
Étant donné un tableau de nombres t non nécessairement trié contenant au moins
un élément, retourner un indice i∈[[0,len(t)[[ tel que
t[i] = min
j∈[[0,len(t)[[(t[j])
5