Algorithmes - TSI Ljf.html

Informatique TD/TP 0.5 Algorithmes
Lycée Jules Ferry Cannes Page 1 sur 3 TSI2
Traitements de listes
Résolutions numériques
(intégration et résolution d'équations)
def chercher (L,x)
:
# Entrées : élément x et liste L
# Sortie : s=True si x dans L et False sinon
n = len (L)
s = False # s : Faux par défaut
c = 0 # initialisation de l'index
while (c<n and s==False):
if L[c]==x :
s = True
c = c+1
return s
def
maximum (L)
:
# Entrée : liste L non vide
# Sortie : s : valeur maximum de L
n = len(L)
s = L[0] # s=0 incorrect si valeurs toutes négatives
for i in range(n):
if L[i]>s:
s=L[i]
return s
def moyenne (L)
:
# Entrée : liste L de nombres non vide
# Sortie : moyenne des éléments de L
n = len(L)
som = 0
for i in range(n):
som = som + L[i]
return som/n
def variance (L)
:
# Entrée : liste L de nombres non vide
# Sortie : variance des éléments de L
n = len(L)
som = 0
for i in range(n):
som = som + L[i]**2
return som/n - moyenne(L)**2
def dichotomie (L,x)
:
# Entrées : élément x et liste L
# Sortie : s=True si x dans L et False sinon
n=len(L)
g=0 # premier indice de L : 0
d=n # dernier indice de L : n-1
m=(g+d)//2 # dichotomie
while g<d:
if L[m]==x: # x est au milieu
return True
else:
if L[m]<x: # x est à droite du milieu
g=m+1
else: # x est à gauche du milieu
d=m
m=(g+d)//2
return False
def
rectangleg(f,a,b,N)
:
# Entrée : fonction f, intervalle [a,b] et N partitions
# Sortie : intégrale à gauche de f entre a et b
h=(b-a)/N # pas des partitions
s=0 # somme des aires
for k in range(N):
s=s + h*f(a+k*h)
return s
def Dichotomie(f,a,b,E)
:
# Entrée : fonction f, intervalle [a,b]
# précision E< b-a
# Sortie : solution m de f(m)=0 avec précision E
g=a
d=b
while d-g>E :
m=(d+g)/2
if f(g)*f(m)>0:
g=m
else:
d=m
return m
def
Newton(f,x0,E)
:
# Entrée : fonction f, valeur intiale x0, précision E
# Sortie : solution s de f(s)=0 avec précision E
x=x0+2*E
s=x0
while abs(s-x)>E and derivee(f,x)!=0:
x=s
s = x - f(x) / derivee(f,x)
return s

Informatique TD/TP 0.5 Algorithmes
Lycée Jules Ferry Cannes Page 2 sur 3 TSI2
Les principales capacités développées dans cette partie de la formation sont :
• comprendre un algorithme et expliquer ce qu’il fait,
• modifier un algorithme existant pour obtenir un résultat différent,
• concevoir un algorithme répondant à un problème précisément posé,
• expliquer le fonctionnement d’un algorithme,
• écrire des instructions conditionnelles avec alternatives, éventuellement imbriquées,
• justifier qu’une itération (ou boucle) produit l’effet attendu au moyen d’un invariant,
• démontrer qu’une boucle se termine effectivement,
• s’interroger sur l’efficacité algorithmique temporelle d’un algorithme.
1) Expliquer comment fonctionne l'algorithme maximum ?
2) Ecrire une fonction maximumW à l'aide d'une boucle conditionnelle while. Quel est le danger d'une
boucle while en général et l'intérêt d'une boucle while dans ce cas particulier ?
3) Ecrire une fonction chercherF à partir d'une boucle inconditionnelle for. Quel est l'intérêt de la boucle
while dans ce cas particulier ? Quel est l'algorithme le plus efficace temporellement ?
4) Illustrer la différence de comportement en traçant les tables d'évolution des variables de la boucle
dans le cas où l'on recherche 2 dans la liste [3, 2, 5, 6].
5) Ecrire l'instruction qui permet de lancer la recherche précédente avec la fonction chercher.
Rappel [1]
Pour effectuer la preuve partielle d’une boucle, il faut tout d’abord trouver un invariant de boucle c’est-à-
dire une affirmation ou assertion vraie à chaque fois que l’exécution du programme atteint le début de
chaque itération de la boucle et qui permet de déduire le résultat voulu, si l’exécution de la boucle while se
termine.
Une formule I(c) est un invariant si :
- I(0) est vrai au début de l’exécution de la boucle while au moment où l’exécution du programme
atteint cet endroit.
- Ayant I(c) vrai et la condition de continuation du while également vraie (et donc que le corps du
while est évalué une fois de plus), il faut pouvoir vérifier qu’après l’exécution d’une itération du
corps la boucle while, l’invariant I(c+1) est à nouveau vrai.
- Enfin pour effectuer la preuve partielle, cet invariant, composé avec le fait que la condition de
continuation du while devienne fausse, doit permettre de vérifier que la boucle while a effectivement
‘’calculé’’ le résultat R qui lui était demandé.
Preuve totale :
- il faut montrer qu'il existe un variant de boucle dont la valeur décroissante mettra fin aux itérations
lorsqu'il atteindra 0.
Remarque : la difficulté de la preuve réside généralement dans la recherche de l'invariant de boucle.
6) Pour la fonction chercher montrer que la formule I(c)="x n'est pas présent dans la liste L[0:c] ou s
est vrai" est un invariant de boucle et que n-c est le variant de boucle.
7) Dans quelle fonction trouve-t-on des instructions conditionnelles imbriquées.
8) Indiquer la modification à apporter à la fonction dichotomie pour qu'elle soit compatible avec les
erreurs d'arrondi des flottants (on remplace la comparaison par une inégalité faisant apparaitre une
erreur E affectée dans le corps du programme).
9) Modifier la fonction dichotomie afin qu'elle renvoie la position du premier indice rencontré pour la
position d'un flottant x dans la liste L. La fonction devra renvoyer None dans le cas où x n'est pas
présent.
10) De quel type est la complexité temporelle de dichotomie et celle de recherche ? Quel est l'algorithme
le plus efficace temporellement ?

Informatique TD/TP 0.5 Algorithmes
Lycée Jules Ferry Cannes Page 3 sur 3 TSI2
Implémentation
Par ordre d'importance et de facilité d'apprentissage, on apprendra successivement les algorithmes
suivants :
moyenne, maximum, chercher, rectangleg, Dichotomie, Newton, dichotomie, variance.
11) Vous devez être capable d'implémenter les algorithmes précédents (à priori sans les avoir sous les
yeux) et de vérifier qu'ils fonctionnent correctement pour différentes valeurs (les tests resteront
cantonnés aux entrées autorisées ; quitte à compléter les commentaires de début de fonction
concernant les valeurs acceptables des paramètres).
Bibliographie :
[1] « 10. Logique, invariant et vérification d’algorithme — Syllabus INFO-F-101 - Programmation 3.4.0
(2015) documentation ». [En ligne]. Disponible sur:
http://www.ulb.ac.be/di/verif/tmassart/Prog/html/chapitre11.html. [Consulté le: 15-mars-2016].