Exercices de programmation en Python

Exercices de programmation en Python
1) Test d’appartenance
Ecrire une fonction mem qui étant donnés une liste aet un objet xrenvoie True ssi xest un élément de la liste.
Corrigé
Noter que la procédure s’interrompt dès qu’une occurrence de xest trouvée.
def mem(a,x) :
for k in range(0,len(a)) :
if a[k] == x : return True
return False
Remarque : Les puristes considèrent (non sans raison) que les interruptions de boucles for sont des pratiques barbares
de programmation. On pourrait ainsi proproser la variante suivante :
def mem(a,x) :
test = False ; n=len(a) ; k=0
while (not test) and k<n :
if a[k] == x : test = True
k += 1
return test
Par exemple, print(mem([2,0,1,4],3)) a¢ che False.
Remarque : En Python, le booléen (x in a) vaut True ssi xest un élément de la liste a:
2) Suite dé…nie par une relation de récurrence
Ecrire une fonction suite qui étant donnés deux arguments net arenvoie la valeur de un, où la suite (uk)k2Nest la suite
dé…nie par u0= 1 et 8k2N,uk+1 =1
2uk+a uk:
Corrigé
def suite(n,a) :
u = 1
for k in range(0,n) :
u = (u + a/u) / 2
return u
Remarque : Par exemple, print(suite(10,2)) renvoie 1.414213562373095 ; en fait, on peut montrer que la suite (uk)k2N
converge vers pa.
3) Maximum de deux entiers et maximum d’une liste (non vide)
a) Ecrire une fonction maximum qui étant donnés deux entiers renvoie leur valeur maximale.
b) Ecrire une fonction max qui étant donnée une liste non vide d’entiers renvoie leur valeur maximale.
Par exemple, print(max([1,3,5,1])) a¢ che 5.
Remarque : Cette fonction max est en fait déjà dé…nie en Python, avec la syntaxe max(iterable). Elle est aussi valable
pour tous les itérables (tuples, chaînes, dictionnaires, etc ...).
Corrigé
def maximum(x,y) :
if x>y : return(x)

else : return(y)
Remarque : Les mots-clés def,if,else doivent se trouver en première position, donc sur des lignes di¤érentes.
def max(a) :
n = len(a) ; m=a[0]
for j in range(1,n) :
if a[j]>m : m = a[j]
return m
4) Nombre maximum de zéros (consécutifs) dans une liste
On suppose que la fonction maximum dé…nie dans l’exercice précédent est connue.
a) Ecrire une fonction nombre qui étant donnée une liste renvoie le nombre de zéros dans la liste.
Par exemple, print(nombre([1,0,2,0,0,4])) renvoie 3.
b) Ecrire une fonction consec qui étant donnée une liste renvoie le nombre maximum de zéros consécutifs dans la liste.
Par exemple, print(nombre([1,0,2,0,0,4])) renvoie 2.
Corrigé
def nombre(a) :
n = len(a) ; c=0
for j in range(0,n) :
if a[j]==0 : c += 1
return c
Remarque : On utilise un compteur c. On rappelle que c += 1 équivaut à c = c+1.
def consec(a) :
n = len(a)
c=0 ; m=0
for j in range(0,n) :
if a[j]== 0 : c += c
else : c=0 ; m=max(m,c)
return max(m,c)
Commentaire : On utilise un compteur cdont la valeur correspond au nombre de zéros conséctifs dans la séquence en
cours de lecture. On utilise aussi une variable mqui mémorise la longueur maximale des séquences déjà lues. Lorsqu’on
lit une valeur non nulle, on met à jour m(en lui attirbuant max(m,c)), et on met le compteur à 0. Il faut faire attention
à la dernière étape où on doit renvoyer max(m,c).
5) Tri par sélection
a) Ecrire une fonction indMin on renvoie l’indice du minimum (en renvoyant le plus petit s’il en existe plusieurs). Par
exemple, indMin([5,2,3,4,2]) renvoie 1(les éléments sont indicés à partir de 0).
b) Ecrire une procédure echange qui étant donnés une liste aet deux entiers iet jpermute dans a les éléments d’indices
iet j. Par exemple : a = [1,2,3,4,5] ; echange(a,0,2) ; print(a) a¢ che [3,2,1,4,5].
c) Ecrire une procédure tri qui étant donnée une liste amodi…e cette liste de sorte à trier ses éléments (sans modi…er
l’ensemble de ses valeurs). On utilisera un tri par sélection (des minima) : Le principe de l’algorithme consiste à
déterminer la position du plus petit élément et à le mettre en première position (par un échange), puis d’itérer le procédé

sur le sous-tableau restant. Il faut (n1) comparaisons pour déterminer la position du plus petit élément, donc il faut
(n1) + (n2) + ::: =1
2n(n1) comparaisons pour trier une liste selon ce procédé.
Corrigé
a) On utilise une variable mémorisant l’indice du plus petit élément déjà lu :
def indMin(a) :
n = len(a)
k=0
for j in range(1,n) :
if a[j] <a[k] : k = j
return k
b) Il y a plusieurs méthodes, puisque Python autorise les a¤ectations de couples (plus généralement de tuples) :
def echange(a,i,j) :
stock = a[i] ; a[i] = a[j] ; a[j] = stock
def echange(a,i,j) :
a[i],a[j] = a[j],a[i]
c) On utilise deux boucles imbriquées : dans la i-ième boucle, on détermine (à l’aide de la boucle en j) la position kdu
plus petit élément dans le sous-tableau [ai; ai+1; :::; an1], puis d’échanger aiet ak.
def tri(a) :
n = len(a)
for i in range(n) :
k=i
for j in range(i+1,n) : if a[j] <a[k] : k = j
echange(a,i,k)
Remarque : Ainsi, a=[1,3,2,2] ; tri(a) ; print(a) a¢ che [1;2;2;3]:
6) Tests de permutation
Il s’agit de déterminer si une liste de longueur ncorrespond à une permutation de f0;1; :::; n 1g, c’est-à-dire si tout
entier compris entre 0et (n1) apparaît une et une seule fois dans la liste. Il s’agit d’écrire une fonction à valeurs
booléennes qui étant donnée une liste ade longueur nrenvoie True ssi aest une permutation de f0;1; :::; n 1g. On
propose deux méthodes, la seconde étant plus e¢ cace que la première (le nombre d’opérations est moindre).
a) Ecrire une première fonction test1 qui pour tout entier i2 f0;1; :::; n 1g, véri…e qu’il existe un unique élément de
la liste avalant j, et interrompt la procédure dès que ce test est faux.
La complexité dans le pire des cas est en O(n2).
b) Ecrire une première fonction test2 qui pour tout entier i2 f0;1; :::; n 1gconstruit en temps linéaire O(n)le tableau
bdes occurrences, c’est-à-dire que b[j]vaut le nombre de termes de avalant j. On véri…e ensuite (en temps linéaire O(n))
que le tableau des occurrences ne contient que des 1. La complexité est O(n).
Corrigé
Noter au passage qu’une instruction comportant un return permet d’interromre une boucle for.
def test1(a) :
n=len(a)

for i in range(n) :
s=0
for j in a :
if i==j : s+=1
if s != 1 : return False
return True
def test2(a) :
n=len(a)
b = [0]*n # l’instruction [0]*n crée la liste de longueur nne contenant que des 0
for i in range(n) : occu[a[i]] += 1
return (occu == [1]*n)
Remarque : En Python, on peut tester directement l’égalité de listes (et plus généralement de tout objet). En revanche,
il faut avoir en tête que la complexité est proportionnelle à la longuer de la liste.
7) Recherche par dichotomie
En Python, le quotient de la division euclidienne d’un entier par un autre s’obtient à l’aide de //. Ainsi, si mest un
entier, (m//2) est égal à la partie entière E(m=2):
On suppose donnés un nombre xet une liste a= (a0; a1; :::; an1)de nombres classés par ordre croissant.
On propose de déterminer si xest un élément de la liste par une méthode par dichotomie : Supposons connus deux entiers
iet jtels que ji > 1et ai<x<aj. On considère l’élément d’indice k=E(1
2(i+j)) : Il est situé (au mieux) au
milieu du tableau composé des éléments dont les indices sont compris entre iet j. On compare xet ak. Si x<ak, alors
ai< x < ak, et on peut itérer le procédé (si ki > 1). Si ak< x, alors ak< x < aj. Si ak=x, alors on renvoie True.
Il est très important de comprendre qu’on renvoie False soit au début si x<a0ou x>an1soit lorsqu’on aboutit à
deux indices iet jtels que ji1:
Ecrire une fonction dicho, qui étant donnés une liste triée aet un nombre xrenvoie True ssi xapparaît dans a.
Corrigé
def dicho(a,x) :
i=0 ; j=len(a)-1
if (x-a[i])*(x-a[j])== 0 : return True
if (x-a[i])*(x-a[j])>0 : return False
while j-i >1 :
k = (i+j)//2
if a[k] == x : return True
if a[k] >x: j=k
else : i = k
return False