Cours d informatique du 17/11/2009 A. Rappels sur les boucles 1) Rappel sur les invariants de boucle : L invariant de boucle est un outil pour concevoir cette boucle. Il peut exister plusieurs invariants de boucle pour un même problème. Tout dépend de la manière dont on résout le problème. Cet invariant fixe la signification des variables du problème. Reprenons le problème du tri étudié au cours du 10/11. 0 Zone non triée n Zone triée N-1 Dans ce cas, on dit qu à partir de n, le tableau est trié. Autrement dit, n marque le début de la section triée. Pour trier complètement le tableau, il faut tout d abord prendre n = N. Ensuite il faut diminuer n en ne violant pas l invariant de la boucle. Ici, l invariant de boucle est : P : {j n j < N} : {i 0 i j} : B[i] B[j] A chaque itération, il faut restituer l invariant de boucle P. Reprenons l exemple du programme «Bubble sort» import numpy as np def bubble(b, upto): imaxchanged = 0 for i in range(1, upto): if B[i-1] > B[i]: # la condition de tri n est pas respectée # pour B[i-1] et B[i] B[i], B[i-1] = B[i-1], B[i] # la condition du tri est restaurée imaxchanged = i # Le tableau au dela de i est trié return imaxchanged S 0 N = 10 B = np.random.randint(0, 10, N) print B n = N while n > 0: n = bubble(b, n) print B
On remarque que le rôle de la séquence d instructions S 0 est de rétablir cet invariant de boucle. Avec ce code, on vérifié l invariant à chaque itération.! Chaque boucle a son invariant de boucle, même pour les boucles imbriquées! 2) Fin d une boucle : Lorsque l on crée une boucle, il faut vérifier qu elle se termine réellement à un moment. Pour vérifier cela, il faut vérifier que chaque instruction élémentaire et chaque boucle se termine réellement. Lorsqu on utilise l itérateur «for in», il n y a aucun problème. A chaque itération, l indice augmente. Tant que le problème qu il faut traiter contient un nombre fini d éléments, la boucle se termine toujours. En Python, il est donc plus sûr et plus simple d utiliser un itérateur tel que «for in» plutôt que l instruction «while». Il est en effet plus clair de voir que la boucle s arrêtera avec un itérateur. Reprenons comme exemple le problème du «bubble sort» écrit plus haut : Il y a deux boucles dans cet algorithme. La première boucle avec l itérateur «for in» se termine forcément puisque l indice i augmente d une unité à chaque itération. L indice «upto» étant fini, l indice i fini par atteindre la valeur «upto 1». La boucle se termine alors. Il est plus difficile de prouver que la deuxième boucle se termine. Pour le prouver, il suffit de montrer que «imaxchanged» est toujours plus petit que «upto». Si le tableau est trié, imaxchanged = 0, et donc n = 0, ce qui implique que la boucle s arrête. Tant que le tableau n est pas totalement trié, on a 1 i < upto, et donc toute nouvelle valeur de i est inférieure à n-1. La valeur de n diminue donc à chaque itération et fini par être nulle, ce qui arrête la boucle puisque le gardien est falsifié.! Quand on travaille avec une boucle, il est toujours plus simple de d abord réfléchir à partir d un dessin!
B. Problème des chaînes avec parenthèses Commençons à étudier ce problème par quelques exemples : a(b[{c}d])[e] est correct a(b[{c}d)[e] est faux puisque le premier crochet n est pas fermé a(b[{c}d)[e]] est faux. Cette fois, toutes les parenthèses ouvertes sont fermées mais elles ne le sont pas dans le bon ordre. Seul le premier exemple a une forme correcte. Quel pourrait être l algorithme qui vérifierait si l ordre d ouverture et de fermeture est correct? Une première approche est de dire qu on doit avoir des blocs imbriqués et enchaînés pour que l expression soit correcte. Cela peut se représenter avec un dessin. Voici une idée d algorithme : On pourrait tout d abord créer une liste. Ensuite, en parcourant la chaîne de caractère, chaque fois que l on rencontre une parenthèse ouverte, on l ajoute à la liste. Et lorsque l on trouve une parenthèse fermée, on la compare au dernier élément de la liste. S il s agit de l élément correspondant ouvert ( ( si on a ), { si on a } et [ si on a ] ), on supprime cet élément de la liste. S il s agit d un autre élément, il y a une erreur dans l ordre d ouverture et de fermeture. Reprenons le premier exemple correct. Voici, étape par étape, l évolution de la liste : 1 : ( 5 : ( 2 : ( [ 6 : / 3 : ( [ { 7 : [ 4 : ( [ 8 : / On observe donc qu on retrouve une liste vide après avoir parcouru tout le tableau. Essayons avec le deuxième exemple : 1 : ( 2 : ( [ 3 : ( [ { 4 : ( [ 5 : Il y a un problème : on trouve maintenant une parenthèse fermée. Or le crochet précédent n a pas été fermé.
Attention, on pourrait avoir une autre idée : à chaque fois que l on rencontre une parenthèse ouvert, on incrémente un compteur d une unité. Si on a une parenthèse fermée, on le décrémenterait. Cet algorithme déterminerait s il y a autant de parenthèses ouvertes que fermées, mais ne saurait pas dire qi les parenthèses ont été fermées dans le bon ordre. Revenons donc à la première idée. Cet algorithme peut s apparenter à une pile de livre. Il est facile de prendre ou d ajouter un livre sur le haut de cette pile. Il est par contre plus difficile d en insérer au milieu de cette pile. De même dans ce programme, on ne travaille qu à la fin de la liste. Cette structure de donnée s appelle donc structure de pile. Cette structure a trois opérations : - push(elem) ajoute un élément à la liste - elem = pop() regarde, supprime le dernier élément de la liste et rend celui qu on regarde - elem = top() consulte le dernier élément de la liste sans le supprimer Avec ces trois opérations, nous pouvons écrire en deux parties l algorithme qui déterminera si la chaîne est correctement parenthèsée. stack.py # Stack def newstack(): return [] def push(stack, elem): stack.append(elem) # ajoute l élément à la liste def pop(stack): # supprime le dernier élément return stack.pop() # pop existe déjà dans Python et supprime le dernier élément de la liste def top(stack): # doit regarder sans supprimer return stack[-1] # regarde le dernier élément
parentheses.py import sys import stack # faut un dictionnaire des caractères parens = {'(':')', '[':']', '{':'}'} # crée une pile leftparens = stack.newstack() # appelle la fonction newstack qu'on a importé string = sys.argv[1] for char in string: if char in parens: # si c'est une parenthèse gauche stack.push(leftparens, char) elif char in parens.values(): # si c'est une parenthèse droite # Faut vérifier si pile n'est pas vide if len(leftparens) == 0: print "no left parenthesis corresponding to", char break elif parens[stack.top(leftparens)] == char: # compare au correspondant grace à dico stack.pop(leftparens) else: print stack.pop(leftparens), "does not match", char break # si ce n'est ni parenthèse gauche ni droite, ne fait rien else: # s'exécute si on ne termine pas de boucle prématurément par break p. ex.. Ce else permet donc d éviter deux messages d erreur. if len(leftparens): # donne une valeur booléenne, mais on peut écrire if len(leftparens) > 0: print "No right parenthese for : ", leftparens En exécutant le code parentheses.py, on sait si la chaîne est correctement parenthésée ou non.