Stage IREM : Initiation à l’algorithmique

TP 1 : Listes en Python

Julien Cervelle, Antoine Meyer

3 mars 2015

1 Piste verte : découverte de Python

1.1 Échauffement : maximum d’une liste
On a vu lors du premier jour du stage une fonction Python qui calcule le
maximum d’une liste non vide (et non supposée triée) :

def maxi(lst):
res = lst[0]
for elem in lst[1:len(lst)]:
if elem > res:
res = elem
return res

Dans cet exemple, on remarque :

– une définition de fonction (mot-clé def) appelée max, possédant un pa-
ramètre lst ;
– une affectation de la valeur lst[0] (l’élément d’indice 0 de lst, soit son
premier élément) à la variable res. On voit ici que lst doit être une liste
et qu’elle doit posséder au moins un élément, pour que cela fonctionne ;
– une boucle (mots-clés for et in) affectant successivement à la variable
elem la valeur de chacun des éléments de la liste entre les indices 1 (inclus)
et len(lst) (exclu) ;
– une structure conditionnelle (mot-clé if) ;
– la production d’un résultat (mot-clé return).
Pour vous familiariser avec la syntaxe de Python et le fonctionnement de son
interpréteur, voici quelques exercices d’échauffement.

x Exercice 1 :
1. Télécharger le fichier listes.py sur la page web du groupe IREM (ici).
2. Ouvrir et lire ce fichier dans l’environnement de développement IDLE
(fourni avec Python 3).
3. Expliquer la fonction liste_aleatoire(taille, seuil) recopiée ci-
dessous :
def liste_aleatoire(taille, seuil):
res = []

1
 for i in range(taille):
res.append(randint(1, seuil))
return res
Indices : randint(a, b) renvoie un entier pseudo-aléatoire compris entre
a et b (au sens large), et lst.append(e) ajoute l’élément e à la fin de la
liste lst.
4. Exécuter le programme grâce à la commande “Run Module” d’IDLE
(menu Run → Run module, ou touche F5).

1.2 Petites modifications

En modifiant très légèrement le code de la fonction maxi ci-dessus, il est
possible d’obtenir de nombreuses fonctions sur les listes qui exploitent la même
structure de base.

x Exercice 2 :
1. En recopiant la fonction maxi, créer une fonction mini qui calcule le plus
petit élément d’une liste non vide.
2. Créer une fonction min_max qui calcule le plus petit et le plus grand
élément d’une liste non vide.
3. Créer une fonction maxi_pair qui calcule le plus grand élément de la liste
qui soit un nombre pair.
4. Créer une fonction tous_pair qui renvoie la valeur spéciale True (vrai ) si
tous les éléments de la liste sont des nombres pairs, et False (faux ) sinon.
5. Créer une fonction somme qui calcule la somme des éléments de la liste.
6. Créer une fonction moyenne qui calcule la moyenne des éléments de la
liste.
Cet exercice peut être prolongé à l’envi...

1.3 Évaluation de polynôme

x Exercice 3 : On modélise un polynôme de degré au plus n par la liste de

ses n + 1 coefficients, par degrés croissants. Autrement Pndit, on utilisera la liste
[a0 ,a1 , · · · ,an ] pour représenter le polynôme P (X) = k=0 ak X k .
1. Écrire une fonction eval(P, a) où P est la liste représentant le polynôme
P et a est un nombre, qui calcule la valeur P (a).
2. Combien d’additions et de multiplications en tout cette fonction effectue-
t-elle?
Pn
3. Pour P (X) = k=0 ak X k , on constate que l’on a P (X) = a0 + XP1 (X),
Pn−1
où P1 (X) = k=0 ak+1 X k . En exploitant cette égalité, écrire une fonc-
tion horner(P,a) qui calcule P(a) plus efficacement que la fonction
précédente, et calculez le nombre d’opérations effectuées.

2 Piste bleue : mélanges

On souhaite écrire une fonction qui mélange une liste de telle sorte que la
permutation à appliquer à la liste soit tirée de manière uniforme. On commence

2
par la fonction suivante:
from random import randint

def melange_faux(lst):
for i in range(0, len(lst)):
n = randint(0, len(lst) - 1)
lst[i], lst[n] = lst[n], lst[i]

x Exercice 4 :
1. Programmer et tester cette fonction sur quelques exemples.
2. Démontrer que cette fonction ne respecte pas le critère d’uniformité. Pour
cela, on pourra montrer que la probabilité qu’apparaisse une permutation
donnée en sortie de cette fonction est de la forme nan où a est un entier et
n la longeur de la liste.
3. Modifier la fonction pour qu’elle respecte le critère d’uniformité.
4. Tester la fonction modifiée sur quelques exemples. Comment faudrait-il
faire pour établir expérimentalement l’uniformité du tirage?
La fin de la piste change de couleur : pour aller plus loin, rendez-vous à la
section 4.

3 Piste rouge : calcul de la médiane

Le but de cette section est d’écrire un programme qui trouve la médiane des
éléments d’une liste. On commencera par une méthode naı̈ve pour aller vers une
méthode linéaire, optimale.

3.1 Méthode A
La première méthode de calcul va consister à rechercher successivement le
plus grand élément de la liste, puis le second plus grand, et ainsi de suite jusqu’à
avoir trouvé la médiane.

x Exercice 5 :
1. Écrire une fonction indice_min(lst, debut) qui renvoie un indice de la
première occurrence du minimum de lst à partir de l’indice debut.
2. Écrire une fonction mediane_A(lst) qui renvoie la médiane de la liste
lst. Pour cela, après avoir dupliqué la liste, il faut déplacer le plus petit
élément de lst au début, le second plus petit à la deuxième position et
continuer ainsi jusqu’à avoir trouvé la médiane (voir l’exemple ci-dessous).
6,1,3,2,5
(échange de 1 et 6)
1,6,3,2,5
(échange de 2 et 6)
1,2,3,6,5
(pas d’échange)
médiane = 3
3. Calculer la complexité de la fonction mediane_A(lst).

3
3.2 Méthode B
La seconde méthode s’inspire de l’algorithme de tri par pivot afin d’améliorer
la recherche de médiane.

x Exercice 6 :
1. Écrire une fonction filtre_pivot(lst, pivot) qui renvoie le triplet
(a, b, c) où a est la liste des élements de lst strictement plus petits
que pivot, b la liste des éléments de lst égaux à pivot et c est la liste
des élements de lst strictement plus grands que pivot.
2. Écrire une fonction nieme(lst,n) qui calcule le nième plus petit élément
de la liste lst. Cette fonction sera récursive. Elle commencera par appeler
filtre_pivot(lst, lst[0]) puis, en fonction des tailles des listes ren-
voyées, soit renverra directement la valeur du nième plus petit élément,
soit effectuera un appel récursif à nieme.
3. Calculer la complexité dans le pire cas et dans le meilleur cas de la fonction
nieme.
4. Terminer l’exercice en écrivant une fonction mediane_B qui calcule la
médiane à l’aide de la fonction nieme.

3.3 Méthode C
Dans la méthode B, le pivot choisi était le premier élément de la liste. L’effi-
cacité dans le pire cas de cette méthode dépend très fortement de ce choix. Pour
cette partie, nous allons modifier le choix du pivot afin d’être assuré d’obtenir
une complexité linéaire.

x Exercice 7 :
1. Écrire une fonction paquets(lst) qui découpe la liste lst en listes de 5
éléments (sauf éventuellement le dernier) et renvoie cette liste de listes.
2. Écrire une fonction medianes(lst_de_liste) qui retourne la liste des
médianes des listes présentes dans lst_de_liste. On utilisera la méthode
A pour le calcul de la médiane.
3. Recopier le code de la fonction nieme dans une fonction nieme_C. On
modifiera cette copie en choisissant, à la place de lst[0], la médiane
de la liste renvoyée par medianes(paquets(lst)). Cette médiane sera
calculé par un appel récursif à nieme_C.
4. Démontrer que la fonction précédente est linéaire dans le pire cas.

4 Piste noire : pour aller plus loin

Pour étudier la distribution des permutations selon l’algorithme de mélange
faux, nous allons avoir besoin de compter le nombre de fois où chaque permu-
tation est produite. Pour ceci, nous allons stocker l’information concernant la
permutation p (représenté par un n-uplet d’éléments entre 0 et n − 1) dans la
case i d’une liste, où i est l’entier correspondant à p vu comme une écriture en
vase n.

4
x Exercice 8 :
1. Écrire une fonction indice(p) qui calule l’indice i correspondant à p soit
n−1
X
nn−j−1 pj .
j=0

On évitera les calculs de puissance en utilisant la fonction horner de l’exer-

cice 3.
2. Pour pouvoir effectuer une opération pour toutes les valeurs possibles re-
tournées par le générateur de nombre aléatoire, transformer la fonction
melange_faux en une fonction récursive appelée melange_faux_rec.
3. Modifier la fonction précédente pour qu’une fois le mélange effectué, le
tableau soit affiché.
4. Modifier à nouveau la fonction pour qu’à la place de tirer un entier n au
hasard, on effectue le traitement pour toutes les valeurs possibles de n.
Il faudra annuler l’effet de lst[i],lst[n]=lst[n],lst[i] en l’appelant
une nouvelle fois après l’appel récursif.
5. Pour stocker le nombre de fois que chaque permutation apparaı̂t, on uti-
lisera une liste de longueur nn :
pr=[0 for x in n**n]
Faire en sorte qu’au lieu d’afficher chaque liste mélangée l, on effectue
pr[indice(lst)]=pr[indice(lst)]+1
6. Pour afficher les résultats, il faut encore énumérer toutes les permutations.
Pour cela, on peut utiliser l’idée que les permutations à n éléments sont
obtenues à partir d’une permutation à n-1 éléments en ajoutant n à la fin
puis en permutant cet élément avec tout élément.
Par exemple, en partant de [0,1,2] on énumère:
[0,1,2,3]
[0,1,3,2]
[0,3,1,2]
[3,0,1,2]