énoncé

Sup 841 - Lycée du parc TP Python
Tableaux (2/2)
Les 12, 13 et 19 février 2014
http://www.mp933.fr/ - [email protected]
Buts du TP
– Faire de nouveaux exemples de parcours de tableaux.
– Découvrir les tableaux à deux dimensions... et leurs pièges.
– Découvrir un algorithme élémentaire permettant de trier un tableau.
Exercice 1 Créér (au bon endroit) un dossier associé à ce TP. Placer le fichier cadeau.py (récupéré
sur le réseau ou le web) dans ce dossier.
Lancer Spyder, sauvegarder immédiatement au bon endroit le fichier .py ; écrire une commande ab-
surde, de type print(5*3) dans l’éditeur, sauvegarder et exécuter.
Après 40 minutes, on passera impérativement à la deuxième partie du TP.
1 Encore des parcours de tableaux
Exercice 2 Écrire une fonction prenant en entrée un tableau tnon vide, et renvoyant le nombre de
couples (i, j)tels que i<j et ti> tj. Complexité ?
>>> inversions([5,1,2,4,3])
5
Exercice 3 Savez-vous encore 1écrire une fonction prenant en entrée un tableau (disons de réels) et
déterminant l’indice d’un élément maximal ?
Exercice 4 Chiche ! Programmez moi ça rapidement ! Complexité ?
>>> indice_maxi([0, 1, 2, 3, 42, 5, 6])
4
Exercice 5 Écrire une fonction prenant en entrée un tableau tnon vide, et renvoyant un couple (i, j)
tel que i>jet |ti−tj|est maximal. Complexité ?
Exercice 6 Écrire une fonction prenant en entrée un tableau tnon vide, et renvoyant True si le tableau
possède un élément répété au moins deux fois, et False sinon. Complexité ?
def doublon(t):
...
>>> doublon([10, 2, 5, 2, 42])
True
>>> doublon([10, 2, 5, 3, 42])
False
Exercice 7 Écrire une fonction prenant en entrée un tableau tnon vide, et renvoyant la liste (éven-
tuellement vide) des couples (i, j)tels que i<j et ti=tj. Complexité ?
1. ...
1

def doublons(t):
...
>>> doublons([10, 2, 5, 2, 42])
[(1, 3)]
>>> doublons([10, 2, 5, 3, 42])
[]
Exercice 8 Le polynôme P= 4−3X+X2+5X3peut être stocké dans un tableau de la forme [4,−3,1,5].
D’une manière générale, on stocke le polynôme p0+p1X+... +pnXndans un tableau de longueur n+ 1 :
[p0, p1, ..., pn]. Pour évaluer un polynôme en un réel (c’est-à-dire calculer P(t)=4−3t+t2+ 5t3dans
l’exemple précédent), on peut additionner les différents monômes :
Entrées :P, t
s←0# la somme provisoire
pour iallant de 0à|P|faire
s←s+Piti
Résultat :s
1. Programmer cet algorithme dans une fonction evaluation.
def evaluation(P, t):
...
>>> evaluation([4,-3,1,5], 2)
42
2. En imaginant que le calcul de tiréclame i−1multiplications, combien de multiplications demande
l’évaluation d’un polynôme de degré d?
On va améliorer un peu les choses, en calculant les ti« à la volée » : une variable pest chargée de
stocker les puissances successives de t: elle vaut 1au départ, et est multipliée par tà chaque étape.
Entrées :P, t
s←0# la somme provisoire
p←1# la puissance de ten cours. Ici, p=t0.
pour iallant de 0à|P|faire
s←s+Pi×p
p←p×t# calcul de la puissance suivante, c’est-à-dire t1puis t2, etc.
Résultat :s
3. Programmer une nouvelle fonction d’évaluation utilisant cette idée.
4. Avec ce nouvel algorithme, combien de multiplications demande l’évaluation d’un polynôme de degré
d?
On propose un nouvel algorithme, basé sur l’idée suivante :
4−3t+t2+ 5t3= 4 + t(−3 + t(1 + t×5
|{z}
s0
| {z }
s1
)
| {z }
s2
),
ce qui permet de calculer P(t)grâce aux opérations suivantes (on effectue le calcul de l’intérieur
vers l’extérieur, pour calculer s0puis s1...) :
s←5; s←1 + t×s;s← −3 + t×s;s←4 + t×s.
5. Écrire l’algorithme permettant de calculer P(t)suivant cette idée, puis un dernier programme d’éva-
luation suivant cet algorithme. Il s’agit de l’algorithme de Hörner.
6. Évaluer le nombre de multiplications nécessaires pour évaluer P(t)avec cet algorithme.
2

>>> P0 = [4, -3, 1, 5]
>>> evaluation(P0, 2)
42
>>> evaluation_meilleure(P0, 2)
42
>>> P0.reverse()
>>> P0
[5, 1, -3, 4]
>>> horner(P0, 2)
42
2 Manipulation de tableaux bidimensionnels
Exercice 9 Expliquer ce qui suit !
>>> t1 = [[0] * 3] * 2
>>> t2 = [[0] * 3 for _ in range(2)]
>>> t1,t2
([[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]])
>>> t1[1][1] = 42
>>> t2[1][1] = 42
>>> t1,t2
([[0, 42, 0], [0, 42, 0]], [[0, 0, 0], [0, 42, 0]])
Exercice 10 Les fonctions suivantes seront nécessaires à la suite du tp :
–matrice_nulle prend en entrée deux entiers (n, p)et retourne la matrice nulle de Mn,p(R).
–dimensions prend en entrée une matrice (un tableau à deux dimensions) et retourne le nombre de
lignes et le nombre de colonnes de cette matrice.
–copie réalise la copie d’une matrice.
1. Réfléchir à la façon d’écrire de telles fonctions. Éventuellement, les coder (sans regarder le cours !).
2. Récupérer de telles fonctions qui marchent 2dans le fichier cadeau.py généreusement fourni.
>>> m1 = matrice_nulle(3, 2)
>>> m1
[[0, 0], [0, 0], [0, 0]]
>>> dimensions(m1)
(3, 2)
>>> m2 = copie(m1)
>>> m3 = m1
>>> m1[1][1] = 3
>>> m1
[[0, 0], [0, 3], [0, 0]]
>>> m2
[[0, 0], [0, 0], [0, 0]]
>>> m3
[[0, 0], [0, 3], [0, 0]]
Exercice 11 Écrire une fonction réalisant l’addition de deux matrices (de mêmes dimensions).
Exercice 12 Écrire une fonction réalisant la multiplication d’une matrice par un scalaire.
Exercice 13 Écrire une fonction renvoyant la transposée d’une matrice donnée en paramètre.
2. Elles...
3

Exercice 14 Écrire une fonction réalisant la multiplication de deux matrices (de dimensions compa-
tibles, c’est-à-dire de la forme (n, p)et (p, q)).
Exercice 15 Écrire une fonction réalisant le calcul de Aq, avec A∈ Mn(R)et q∈Ndonnés. Combien
de multiplications matricielles sont réalisées pour calculer Aq?
Exercice 16 Combien d’additions et de multiplications de réels sont nécessaires pour effectuer les calculs
des 5 derniers exercices ?
Addition Multiplication scalaire Transposition Multiplication matrices Calcul de Aq
Additions n×p0 0
Multiplications 0 0
Exercice 17 Écrire une fonction testant le caractère symétrique d’une matrice (et renvoyant donc un
booléen).
>>> est_symetrique(m1)
False
>>> est_symetrique(m2)
True
3 Tri par sélection
L’objet de cette section est d’implémenter un algorithme de tri.
Informellement, il s’agit de trouver le plus grand élément d’un tableau, et le placer à la fin (et on
n’y touchera plus). On cherche ensuite le plus grand parmi ceux qui restent, et on le place à sa position
finale ; etc. Avec la notation Python des tableaux « slicés », et en notant nla taille du tableau :
– Calculer l’indice i0du plus grand élément de t[0:n] ; échanger t[i0] et t[n-1].
– Calculer l’indice i0du plus grand élément de t[0:n-1] ; échanger t[i0] et t[n-2].
– Calculer l’indice i0du plus grand élément de t[0:n-2] ; échanger t[i0] et t[n-3].
– ...
– Calculer l’indice i0du plus grand élément de t[0:2] ; échanger t[i0] et t[1].
On obtient ainsi l’algorithme assez naturel :
Entrées :T
pour jallant de nà2faire
Trouver un indice i0tel que T[i0] soit maximal dans T[0:j] # donc jusqu’à j−1inclus...
Échanger T[i0] et T[j-1]
Il est à noter qu’un tel algorithme est destructif : le tableau passé en paramètre sera modifié (et il
n’est donc pas nécessaire de retourner quoi que ce soit.
On pourrait faire le choix de préserver le tableau passé en paramètre. Il faudrait alors faire une copie
de celui-ci, travailler sur cette copie, et retourner finalement ce nouveau tableau sur lequel on a travaillé :
Entrées :T0
Copier T0dans un nouveau tableau T
pour jallant de nà2faire
Trouver un indice i0tel que T[i0] soit maximal dans T[0:j]
Échanger T[i0] et T[j-1]
Résultat :T
Exercice 18 Simuler l’exécution de cet algorithme sur le tableau [3, 42, 112, 50, 8, -5]
On va avoir besoin de deux programmes extérieurs :
– un programme qui trouve la position du plus grand élément du début d’un tableau ;
– un autre réalisant l’échange de deux éléments.
On pourrait encapsuler ces tâches dans le programme de tri, mais c’est toujours une bonne idée de
travailler de façon modulaire, en déléguant des tâches non élémentaires à d’autres programmes.
4

Exercice 19 Écrire une fonction prenant en entrée un tableau Tet un entier kmajoré par la longueur
de T, et renvoyant un indice i0tel que T[i0] est maximal parmi T[0:k] (donc parmi les kpremiers
éléments T[0], ... T[k−1]) :
>>> pos_maxi_j_premiers([3, 42, -5, 8, 50, 112], 4)
1
Exercice 20 Écrire une fonction réalisant en place (sans rien renvoyer) l’échange de deux éléments
d’un tableau :
def echange(t, i, j):
...
>>> t0 = [3, 42, -5, 8, 50, 112]
>>> echange(t0, 1, 3)
>>> t0
[3, 8, -5, 42, 50, 112]
Exercice 21 Écrire un programme réalisant le tri d’un tableau. Le tri se fera obligatoirement en place,
c’est-à-dire en modifiant le tableau donné en entrée, sans rien renvoyer.
def tri(t):
...
>>> t1 = [112, 3, 42, -5, 8, 50]
>>> tri(t1)
>>> t1
[-5, 3, 8, 42, 50, 112]
Exercice 22 Évaluer, en fonction du nombre nd’éléments du tableau, la complexité (en nombre de
comparaisons) de cet algorithme de tri.
5