Correction du devoir surveillé 2 - Informatique

(1)

Correction du devoir surveillé 2 - Informatique

Exercice 1 — Boule de gomme 1. (a) L’instruction

fonction_mystere("la voiture") renvoie la chaine de caractères suivante :

"lu vietora"

(b) Décrivons le fonctionnement de fonction_mystere dans le cas général.

La fonction fonction_mystere prend en entrée une chaine de carac- tèreschaine puis renvoie la chaine de caractèreschaine dans laquelle les voyelles ont été modifiées de la manière suivante : leu deviento, le o devienti, le i devient e, le e devienta et enfin le a devientu.

Autrement dit, chaque voyelle (y exclue) est remplacée par la voyelle venant directement avant elle dans l’ordre alphabétique, avec la convention que la voyelle venant directement avant le a est la toute dernière voyelle de l’alpha- bet. On effectue donc une permutation circulaire sur l’ensemble des voyelles.

Pour le voir, détaillons les différentes étapes de la fonction.

Tout d’abord, on se donne la liste V des voyelles. Puis on crée la chaine de caractères resultat, initialement vide, qui sera renvoyée à la fin.

On parcourt alors un à un les caractères de la chaine de caractères chaine.

Pour chaque caractère c de chaine, on effectue les opérations suivantes.

• On détermine si le caractère c est une voyelle.

Pour cela, on crée une variable booléenne voy, initialement fausse, qui deviendra vraie si le caractère c est une voyelle. On parcourt ensuite la liste V pour comparer le caractère c à tous les éléments de la liste V des voyelles.

• Si le caractère c n’est pas une voyelle, la variable booléenne voy reste fausse. Le test suivant concatène alors à la chaine resultatle caractère c (inchangé).

• Si le caractère c est égal à l’un des éléments de la liste V, la boucle while s’arrête. La variable booléenne voydevient alors vraie et l’indice i est la position du caractère c (qui est donc une voyelle) dans la liste V : on a c=V[i].

Comme la variable voyest vraie, on concatène à la chaine resultat la voyelle V[i−1].

Lycée Pierre-Gilles de Gennes 1 Adriane Kaïchouh

(2)

Cette opération remplace donc le caractère c, égal àV[i], par la voyelle venant juste avant dans la listeV des voyelles. Notons que sii= 0, alors V[i−1] = V[−1], qui est le dernier élément de la liste V. On effectue donc bien la permutation circulaire de l’ensemble des voyelles décrite plus haut.

Enfin, après le parcours, la fonctionfonction_mystererenvoie la chaine de caractères resultat, qui est bien la chaine voulue.

2. Pour que la chaine de caractères soit réécrite à l’envers, il suffit de concaténer chaque caractère à gauche de la chaine resultat construite auparavant.

def fonction_mystere_envers(chaine):

V = ['a', 'e', 'i', 'o', 'u']

resultat = ""

for c in chaine:

voy = False i = -1

while (i < 4) and (not voy):

i = i + 1 if c == V[i]:

voy = True if voy:

resultat = V[i - 1] + resultat else:

resultat = c + resultat return resultat

3. Pour effectuer une permutation différente des voyelles, on crée la liste W des voyelles de V après transformation (dans le même ordre). Ainsi, si l’on rencontre la voyelle V[i], on la remplace par la voyelleW[i] dans la chaine finale.

def fonction_mystere_envers_permutation_differente(chaine):

V = ['a', 'e', 'i', 'o', 'u']

W = ['o', 'i', 'e', 'a', 'u'] # Voyelles transformées resultat = ""

for c in chaine:

voy = False i = -1

while (i < 4) and (not voy):

i = i + 1 if c == V[i]:

voy = True if voy:

resultat = W[i] + resultat else:

resultat = c + resultat return resultat

(3)

Exercice 2 — Barbara au photomaton^®

1. La fonction suivante prend en argument une image et renvoie l’image après un passage dans la cabine photographique.

import numpy as np def photomaton(T):

"""

Entrée : un tableau T, représentant une image.

Sortie : l'image à laquelle la transformation

de la cabine photographique a été appliquée.

"""

(n, p) = np.shape(T) # Dimensions du tableau T.

if n != p or n % 2 == 1 :

return ("L'image doit être carrée et de dimensions paires.") else:

moitie = n // 2

# Chaque petite image sera de taille moitie * moitie.

Resultat = np.zeros((n, p))

# Initialisation du tableau transformé.

for i in range(moitie):

for j in range(moitie):

Resultat[i, j] = T[2*i][2*j]

# Image réduite en haut à gauche.

Resultat[i + moitie , j] = T[2*i + 1][2*j]

# Image réduite en bas à gauche.

Resultat[i, j + moitie] = T[2*i][2*j + 1]

# Image réduite en haut à droite.

Resultat[i + moitie , j + moitie] = T[2*i + 1][2*j + 1]

# Image réduite en bas à droite.

return Resultat

2. (a) La fonction suivante détermine si deux tableaux sont égaux.

Notons tout d’abord que si T etS sont deux tableaux numpy, l’instruction T == S

renvoie un tableau de booléens et non un booléen.

Pour déterminer si les deux tableaux sont égaux, on commence alors par comparer leurs tailles.

Si leurs tailles sont égales, on parcourt alors toutes les positions dans les deux tableaux :

• si on rencontre une case à laquelle les tableaux diffèrent, on renvoie False, ce qui arrête la fonction ;

• si à la fin du parcours, on n’a rencontré aucune case où les tableaux diffèrent, c’est que les tableaux sont égaux et on renvoie True.

(4)

def egalite(T, S):

"""

Entrées : deux tableaux T et S.

Sortie : True si les tableaux T et S sont égaux , False sinon.

"""

(n, p) = np.shape(T) (m, q) = np.shape(S) if n != m or p != q:

return False else:

for i in range(n):

for j in range(p):

if T[i][j] != S[i][j]:

return False return True

(b) La fonction suivante prend en argument une image, lui applique la transformation de la cabine photographique jusqu’à ce que l’image obtenue soit égale à l’image initiale et renvoie le nombre de transformations effectuées.

def amanite(T):

"""

Entrée : un tableau T, représentant une image.

Sortie : le nombre de transformations de la cabine photographique au bout duquel l'image T revient à son état inital.

"""

Transformee = photomaton(T) compteur = 1

# Nombre de passages dans la cabine photographique.

while not egalite(T, Transformee):

Transformee = photomaton(Transformee)

# On applique la transformation

# de la cabine photographique.

compteur += 1 return compteur

En appliquant cette fonction à Barbara, on obtient qu’à son neuvième passage dans la cabine photographique, Barbara revient à sa taille initiale.

Exercice 3 — Et vice et versa

1. Tout d’abord, on implémente la fonctionf: x7−→x+e^x à tracer.

import numpy as np def fonction(x):

return x + np.exp(x)

(5)

Puis on trace sa courbe représentative sur [−3; 3] avec mille points.

import matplotlib.pyplot as plt def trace():

x = np.linspace(-3, 3, 1000) y = fonction(x)

plt.plot(x, y)

2. Comme la courbe de la fonction réciproque de f_[−3;3] est symétrique de celle de f_[−3;3] par rapport à la première bissectrice, il suffit pour la tracer d’échanger les rôles des abscisses et des ordonnées dans la fonction précédente, c’est-à-dire de tracer x en fonction de f(x).

def trace_reciproque():

x = np.linspace(-3, 3, 1000) y = fonction(x)

plt.plot(y, x)

(6)

(7)

Exercice 4 — Libérés, délivrés

1. On modélise une porte ouverte par le booléen True et une porte fermée par le booléen False. Chaque cellule est donc modélisée par un booléen : l’état de sa porte.

La prison est alors modélisée par une liste de cellules (une liste de portes, c’est-à- dire de booléens), de longueur n+ 1: les portes des cellules sont alors numérotées de0 àn, la cellule0 n’étant pas à prendre en compte (on respecte ainsi la numé- rotation des cellules de la prison de Sikinia).

2. La fonction suivante prend en entrée la liste des cellules et un numéro de porte, et change l’état de la porte dans la liste (c’est-à-dire tourne le bouton de la porte d’un demi-tour). Pour cela, il suffit de remplacer l’état de la porte par sa négation.

Remarquons que la liste, qui est un objet mutable, est modifiée directement. Il n’est nul besoin de renvoyer la liste ainsi modifiée.

def demi_tour(Prison , porte):

"""

Entrées : la liste Prison de tous les états des portes , un numéro porte de cellule de prison.

Tourne d'un demi -tour le bouton de la porte porte.

"""

Prison[porte] = not(Prison[porte])

3. Pour suivre les directives de la présidente de la république de Sikinia, on utilise une boucle fordont l’indice k va prendre successivement toutes les valeurs entre 1 etn.

À l’étape k, on tourne le bouton de la porte k, puis d’une porte sur k jusqu’à ce qu’on arrive au bout des cellules (condition de fin de la boucle while).

À l’issue de cette boucle for, on parcourt une ultime fois la liste des cellules et on stocke le numéro de celles qui sont ouvertes dans une liste que l’on renvoie.

def amnistie(n):

"""

Entrée : un entier n (nombre de cellules de prison).

Pour tout k entre 1 et n : tourne d'un demi -tour une cellule sur k à partir de la cellule numéro k.

Sortie : liste des cellules dont la porte est ouverte à la fin.

"""

Prison = (n + 1)*[False]

# Au départ , toutes les portes sont fermées.

for k in range(1,n + 1):

porte = k

# On tourne les boutons d'une porte sur k.

while (porte < n + 1):

demi_tour(Prison , porte) porte = porte + k

(8)

Ouvertes = [] # Liste des numéros des cellules ouvertes.

for porte in range(n):

if Prison[porte]: # si la porte porte est ouverte Ouvertes.append(porte)

return Ouvertes

Testons notre fonction amnistie sur une prison de cent cellules. L’instruction amnistie(100)

renvoie la liste suivante :

[1, 4, 9, 16, 25, 36, 49, 64, 81]

On remarque que les cellules ouvertes sont celles dont le numéro est un carré ! C’est un joli petit exercice d’arithmétique de généraliser ce résultat à un nombre quelconque de cellules.

Problème — Sans parti pris nous avons pris la partie

1. La fonction suivante prend en argument la première représentationRd’une partie finie A de N et renvoie le cardinal de la partie A.

Pour ce faire, on initialise à 0 la variablecard, qui représentera le nombre d’élé- ments de A rencontrés.

On parcourt alors la première représentation R de la partieA :

• si l’élément rencontré vaut 1, l’entier correspondant (c’est-à-dire l’indice de l’élément) appartient à la partie A, donc on ajoute1 au cardinal ;

• si l’élément rencontré vaut 0, l’entier correspondant n’appartient pas à la partie A, donc on ne change pas le cardinal, c’est-à-dire qu’on lui ajoute0. Ainsi, dans tous les cas, on ajoute au cardinal la valeur de l’élément de R ren- contré. À la fin du parcours, la variable card contient le nombre d’éléments deA (puisqu’on lui a ajouté autant de fois 1que la partie contient d’éléments).

def cardinal(R):

"""

Entrée : la première représentation R d'une partie finie A de N.

Sortie : le cardinal de la partie A.

"""

card = 0

for element in R:

card += element return card

2. (a) La fonction suivante prend en arguments les premières représentations R et S de deux parties finies A et B de N et renvoie la première représentation de l’intersectionA∩B.

(9)

• Pour ce faire, on commence par accéder aux longueurs n etm des pre- mières représentations des ensembles A et B : l’entiern−1 est donc le plus grand élément de A et l’entierm−1 le plus grand élément de B. Remarquons que le plus grand élément de l’intersection de A etB doit être à la fois plus petit que le plus grand élément de A et que celui de B, c’est-à-dire doit être strictement inférieur au minimumN denetm. La première représentation de A∩B sera donc au plus de longueur N.

• Pour représenter l’intersectionA∩B, on crée alors une listeIntersection de longueur N, dont pour tout k ∈J0;N−1K, l’élément d’indice k vaut le produit R[k]S[k].

Soit k ∈J0;N −1K.

? Si l’entierk appartient àA∩B, c’est-à-dire si k appartient à la fois à A et à B, alors les éléments R[k] et S[k] valent tous les deux 1, donc leur produit vaut1.

? Si l’entier k n’appartient pas àA∩B, alors l’un des éléments R[k]

ouS[k]est nul, donc leur produit est nul.

Finalement, l’élément d’indice k de la liste Intersectionvaut bien R[k]S[k] =

(1 si k ∈A∩B 0 sinon.

• Enfin, pour obtenir à partir de la liste Intersectionla première repré- sentation deA∩B, on retire de la liste tous les zéros de la fin de la liste (à partir du dernier 1), de sorte que le dernier élément de la représentation soit celui dont l’indice est le plus grand élément de A∩B.

def intersection(R, S):

"""

Entrées : les premières représentations R et S de deux parties finies A et B de N.

Sortie : la première représentation de l'intersection de A et B.

"""

n = len(R) m = len(S) N = min(n, m)

Intersection = [R[k] * S[k] for k in range(N)]

# On enlève alors les zéros de la fin de la représentation.

k = N - 1

while k >= 0 and Intersection[k] == 0:

Intersection.pop()

# Supprime le dernier élément de la liste.

k = k - 1

return Intersection

(10)

(b) La fonction suivante prend en arguments les premières représentations R et S de deux parties finies A et B de N et renvoie la première représentation de l’union A∩B.

• Tout d’abord, remarquons que le plus grand élément de l’union A∪B est le maximum du plus grand élément de A et du plus grand élément deB. Ainsi, la première représentation de l’unionA∩B a pour longueur le maximum M des longueurs de celles de A et de B.

• Pour créer la première représentation de A∪B, on initialise alors une liste Union à la liste vide.

Pour tout entier k ∈J0;M −1K :

? si l’entier k appartient à A, c’est-à-dire si R[k] existe et vaut 1, ou s’il appartient à B, c’est-à-dire siS[k]existe et vaut 1, alors l’entier k appartient àA∪B, donc on ajoute1à la fin de la listeUnion, de sorte que Union[k] vaille 1;

? sinon, l’entierk n’appartient pas àA∪B, donc on ajoute 0à la fin de la liste Union.

La listeUnioncréée est alors la première représentation de l’unionA∪B. def union(R, S):

"""

Sortie : la première représentation de l'union de A et B.

"""

n = len(R) m = len(S) M = max(n, m) Union = []

for k in range(M):

if ((k < len(R)) and (R[k] == 1)) or ((k < len(S)) and (S[k] == 1)):

# Si l'entier k appartient à A ou à B : Union.append(1)

else:

Union.append(0) return Union

Une autre manière de procéder consiste à compléter la plus courte des deux représentations par des zéros pour que les deux représentations aient la même longueur M.

La première représentation de l’union A∪B est alors une liste de longueur M dont pour tout k ∈ J0;M −1K, l’élément d’indice k vaut le maximum entre R[k] et S[k] (qui vaut bien 1 si l’un des deux nombres R[k] ou S[k]

vaut1, et 0 sinon).

(11)

def union_bis(R, S):

"""

Sortie : la première représentation de l'union de A et B.

"""

n = len(R) m = len(S) M = max(n, m)

# On complète la plus courte des

# représentations par des zéros.

if n < m:

for j in range(m - n):

R.append(0) else:

for j in range(n - m):

S.append(0)

Union = [max(R[k], S[k]) for k in range(M)]

return Union

3. (a) La fonction suivante prend en argument la première représentationR d’une partie finie A deN et renvoie la seconde représentation deA.

def conversion1vers2(R):

"""

Entrée : la première représentation R d'une partie finie A de N.

Sortie : la seconde représentation de A.

"""

S = [] # Seconde représentation.

for k in range(len(R)):

if R[k] == 1: # Si l'entier k appartient à A : S.append(k)

return S

Pour cela, on initialise une liste S, qui sera la seconde représentation de la partie A, à la liste vide.

On parcourt ensuite tous les indices de la listeR, c’est-à-dire tous les entiers naturels jusqu’au plus grand élément de A(puisque le dernier élément de R a pour indice le plus grand élément deA). Pour chaque entier k, siR[k]vaut 1, c’est-à-dire si l’entier k appartient à A, on ajoute l’entierk à la liste S. À la fin de la boucle, la liste S contiendra donc tous les éléments de A, dans l’ordre croissant (l’ordre du parcours des indices), donc S sera bien la seconde représentation de la partie A.

(b) La fonction suivante prend en argument la seconde représentation S d’une partie finie A deN et renvoie la première représentation de A.

(12)

def conversion2vers1(S):

"""

Entrée : la seconde représentation S d'une partie finie A de N.

Sortie : la première représentation de A.

"""

m = S[-1] # Plus grand élément de A.

R = (m + 1) * [0] # Première représentation.

for k in S:

R[k] = 1 return R

Pour cela, on stocke dans une variablem la valeur du plus grand élément de A, c’est-à-dire du dernier élément de la seconde représentation de A.

On crée alors une listeR, qui sera la première représentation de la partieA, constituée initialement dem+ 1zéros (de sorte que le dernier élément de la liste R ait pour indice m).

On parcourt ensuite la liste S : pour chaque élément k de S, c’est-à-dire pour chaque élémentk de la partie A, on remplace l’élément d’indicek de la listeR par1, de sorte qu’à la fin de la boucle, la listeR soit bien la première représentation de la partieA.

4. (a) La fonction suivante prend en arguments les secondes représentations de deux parties finiesAetB deN, les convertit en les premières représentations deAet B afin d’obtenir la première représentation de A∩B, puis convertit cette première représentation en la seconde représentation de l’intersection A∩B.

def intersection_seconde(R, S):

"""

Entrées : les secondes représentations R et S de deux parties finies A et B de N.

Sortie : la seconde représentation de l'intersection de A et B.

"""

RR = conversion2vers1(R) # Première représentation de A.

SS = conversion2vers1(S) # Première représentation de B.

I = intersection(RR, SS)

# Première représentation de l'intersection.

return conversion1vers2(I)

# Seconde représentation de l'intersection.

(b) De la même manière, la fonction suivante prend en arguments les secondes représentations de deux parties finies A et B de N, et renvoie la seconde représentation de l’union A∪B.

(13)

def union_seconde(R, S):

"""

Sortie : la seconde représentation de l'union de A et B.

"""

RR = conversion2vers1(R) # Première représentation de A.

SS = conversion2vers1(S) # Première représentation de B.

U = union(RR, SS)

# Première représentation de l'union.

return conversion1vers2(U)

# Seconde représentation de l'union.

5. (a) La fonction suivante, qui est une fonction de cours, prend en arguments une listeL, un indice iet un élémentx, et insère l’élémentx à la positionidans la liste L.

def insertion(L, i, x):

"""

Entrées : une liste L, un indice i, un élément x.

Insère l'élément x à la position i dans la liste L.

Sortie : aucune , la liste L est directement modifiée.

"""

n = len(L)

L.append(x) # On ajoute x à la fin de la liste.

# Initialement , l'élément x est donc en position n.

for k in range(n, i, -1): # k va de n à i + 1, par pas de -1.

# Échange des éléments L[k] et L[k - 1],

# c'est-à-dire échange de x avec l'élément

# le précédant dans la liste.

aux = L[k]

L[k] = L[k - 1]

L[k - 1] = L[k]

# Après l'étape où k = i + 1,

# l'élément x se retrouve en position i.

(b) Écrivons alors des fonctions qui, à partir des secondes représentations R et S de deux parties finies A et B de N, renvoient la seconde représentation de l’intersection et de l’union de A et B, sans passer par leur première représentation.

• Intersection

Pour créer directement la seconde représentation de l’intersectionA∩B, on commence par initialiser la représentation I à la liste vide.

(14)

On parcourt ensuite la seconde représentationRdeA, c’est-à-dire qu’on parcourt les éléments de A dans l’ordre croissant.

? Pour chaque élément de A, on cherche si l’élément appartient aussi àB. Si c’est le cas, on l’ajoute alors à la liste I représentant l’intersection.

? Pour rechercher l’élément dans la seconde représentationS deB, on initialise un indicej à0, puis on incrémentejde1jusqu’à rencontrer dans la liste S un élément plus grand ou égal à l’élément recherché (ou jusqu’à sortir de la liste S). En effet, comme la listeS est triée dans l’ordre croissant, si l’on rencontre un élément strictement plus grand que l’élément recherché, l’élément recherché n’appartient pas à la liste S (donc n’appartient pas à B).

? Comme la listeRest également triée par ordre croissant, le prochain élément recherché est nécessairement supérieur au précédent, donc il suffit de reprendre la recherche dansS à l’indicej auquel on avait arrêté la recherche de l’élément précédent (deR). Il est donc inutile de réinitialiser j à 0à chaque tour de boucle for.

def intersection_seconde_bis(R, S):

"""

Sortie : la seconde représentation de l'intersection de A et B.

"""

I = [] # Intersection de A et B.

j = 0

for element in R: # Parcours des éléments de A.

# Recherche de l'élément element dans la liste S.

while (j < len(S)) and (S[j] < element):

j = j + 1

if S[j] == element:

# Si l'élément appartient aussi à B,

# on l'ajoute à l'intersection.

I.append(element) return I

• Union

Pour créer directement la seconde représentation de l’union A∪B, on commence par créer parslicing une copie de la listeS. On initialise alors la représentation U de l’union à cette copie de S. Ainsi, la représenta- tion U contient au départ tous les éléments de B.

On parcourt ensuite les éléments de la liste R (c’est-à-dire les éléments de A), afin de les insérer dans la liste U à la bonne place.

(15)

? Pour chercher la position à laquelle insérer l’élément deAconsidéré, on initialise un indicej à0, puis on incrémentej de1jusqu’à sortir de la liste U ou rencontrer un élément de U supérieur ou égal à l’élément considéré.

? Si la boucle while s’arrête parce que l’on a dépassé le plus grand élément de U, on ajoute l’élément de A considéré à la fin de la liste U.

? Sinon, la bouclewhiles’arrête parce que l’élémentU[j]est supérieur ou égal à l’élément considéré.

SiU[j]est égal à l’élément considéré, alors l’élément est déjà présent dans l’union et on ne l’y ajoute pas une seconde fois.

Sinon, U[j] est le premier élément de l’union strictement supérieur à l’élément considéré, donc on insère l’élément considéré à l’indicej, de sorte qu’il apparaisse juste avant dans la liste U (l’élément U[j] sera alors décalé à l’indice j+ 1).

De même que pour l’intersection, comme les éléments de R sont classés dans l’ordre croissant, on peut, d’un tour de boucle for sur l’autre, reprendre le parcours de U à l’indice où l’on avait arrêté le parcours au tour précédent.

def union_seconde_bis(R, S):

"""

Sortie : la seconde représentation de l'union de A et B.

"""

U = S[ : ] # Copie de S.

j = 0

for element in R:

while (j < len(U)) and (U[j] < element):

j = j + 1

if (j == len(U)) or (U[j] != element):

insertion(U, j, element) return U

6. (a) Commençons par écrire une fonction qui prend en entrée une liste L de nombres et qui renvoie son plus grand élément.

def maximum(L):

"""

Entrée : une liste L de nombres.

Sortie : le plus grand élément de L.

"""

maxi = L[0]

(16)

for element in L:

if element > maxi:

maxi = element return maxi

La fonction suivante prend alors en argument une liste L d’entiers naturels (non nécessairement triée et pouvant contenir des doublons) et renvoie la première représentation de l’ensemble des éléments de la liste L.

Pour cela, on procède comme à la question 3.b) : on commence par trouver le plus grand élément m de la liste L à l’aide de la fonction maximum.

On crée alors une listeR, qui sera la première représentation cherchée, consti- tuée initialement dem+ 1 zéros.

Puis on parcourt les éléments de la listeL : pour chaque élément k deL, on remplace l’élément R[k]par 1. Si la liste L contient des doublons, l’élément R[k] sera simplement affecté plusieurs fois à 1.

def premiere_representation(L):

"""

Entrée : une liste L d'entiers.

Sortie : la première représentation

de l'ensemble des éléments de la liste L.

"""

m = maximum(L) R = (m + 1)*[0]

for k in L:

R[k] = 1 return R

(b) Pour donner la seconde représentation d’une liste L d’entiers naturels (non nécessairement triée et pouvant contenir des doublons) sans passer par la première représentation, on procède de la manière suivante.

• On commence par trier la liste Ldans l’ordre croissant. Ici, nous allons la trier avec le tri à bulles.

• Puis on supprime les doublons de la liste obtenue.

Pour cela, comme la liste est triée, il suffit de parcourir la liste et de supprimer un élément s’il est identique au précédent.

def tri_a_bulles(L):

"""

Entrée : une liste L de nombres.

Trie la liste dans l'ordre croissant.

Sortie : aucune , la liste L est triée en place.

"""

n = len(L)

(17)

for etape in range(1, n):

# Les étapes sont numérotées de 1 à n - 1.

for k in range(0, n - etape):

# On compare les paires L[k], L[k + 1] de la paire

# L[0], L[1] à la paire L[n - etape - 1], L[n - etape].

if L[k] > L[k + 1]:

# Échange des éléments d'indices k et k + 1.

aux = L[k]

L[k] = L[k + 1]

L[k + 1] = L[k]

def seconde_representation(L):

"""

Entrée : une liste L d'entiers naturels.

Sortie : la seconde représentation

de l'ensemble des éléments de la liste L.

"""

tri_a_bulles(L) # On trie L dans l'ordre croissant.

# On supprime les doublons de la liste L ainsi triée.

k = 1

while k < len(L):

# On compare l'élément d'indice k au précédent.

if L[k] == L[k - 1]:

del(L[k])

# Comme l'élément d'indice k a été supprimé ,

# le prochain élément à considérer

# est maintenant d'indice k.

else:

k = k + 1 return L

# L est maintenant la seconde représentation voulue.