1 Liste Itérative → Python - Algo, la page

Algorithmique
Info-sup S1
td Algo 4 Déc. 2016
Epita
Lists
Liste Itérative → Python
1
Type abstrait : Liste itérative
λ
λ←
Python : type list
type(L) = list
: Liste
L = []
liste-vide
len(L)
λ
longueur ( )
L[k]
λ k)
ième ( ,
Exercice 1.1 (
Algo 7→ Python)
Traduire les deux algorithmes suivants en Python.
fonction compte(Element x, Liste λ) : entier
variables
1.
debut
entier
i, cpt
cpt ← 0
pour i ← 1 jusqu'a longueur (λ) faire
si x = ieme (λ, i) alors
cpt ← cpt + 1
n
n pour
retourne cpt
fonction est-present(Element x, Liste λ) : booleen
variables
2.
debut
entier
i
i ← 1
tant que (i <= longueur (λ)) et (x <> ieme (λ, i)) faire
i ← i + 1
n
n tant que
retourne (i <= longueur (λ))
3. Modier la fonction précédente : elle retourne la position du premier
x trouvé
et la liste en paramètre
est triée (en ordre croissant)
Exercice 1.2 (Type abstrait → Python P1 - 2016 )
Soit l'opération change dénie pour le type abstrait Liste itérative de la manière suivante :
opérations
axiomes
change : Liste
×
Élément
λ
1 ≤ i ≤ longueur(λ)
1 ≤ i ≤ longueur(λ)
×
Élément
→
Liste
λ
x = ième(λ, i) ⇒ ième(change(λ, x, y), i) = y
x 6= ième(λ, i) ⇒ ième(change(λ, x, y), i) = ième(λ, i)
longueur (change ( , x, y)) = longueur ( )
avec
&
&
λ : Liste
i : Entier
x, y : Élément
Implémenter cette opération à l'aide d'une fonction
Python. La fonction doit modier la liste en place
(la liste en paramètre est modiée, aucune autre liste ne doit être créée).
1
Algorithmique
Info-sup S1
td Algo 4 Déc. 2016
Epita
Exercice 1.3 (Construire une liste)
1
2
3
4
5
6
7
8
9
10
>>> help ( list . append )
Help on method_descriptor :
append (...)
L . append ( object ) -> None -- append object to end
>>> L = []
>>> L . append (1)
>>> L . append (2)
>>> L . append (3)
>>> L
[1 , 2 , 3]
Écrire une fonction qui retourne une nouvelle liste de
n
valeurs
val.
Exercice 1.4 (Type abstrait 7→ Python)
Implémenter les opérations suivantes en Python.
1. L'opération supprimer
opérations
préconditions
λ k
axiomes
supprimer : Liste
supprimer ( ,
)
×
Entier
→
Liste
est-déni-ssi 1 ≤ k ≤ longueur(λ)
λ 6= liste-vide & 1 ≤ k ≤ longueur(λ) ⇒ longueur(supprimer(λ, k)) = longueur(λ)−
1
λ 6= liste-vide & 1 ≤ k ≤ longueur(λ) & 1 ≤ i < k
⇒ ième(supprimer(λ, k), i) = ième(λ, i)
λ 6= liste-vide & 1 ≤ k ≤ longueur(λ) & k ≤ i ≤ longueur(λ) − 1
⇒ ième(supprimer(λ, k), i) = ième(λ, i + 1)
avec
λ : Liste
k, i : Entier
2. L'opération insérer
opérations
×
×
→
préconditions
λ
est-déni-ssi 1 ≤ k ≤ longueur(λ) + 1
axiomes
insérer : Liste
Entier
Élément
Liste
insérer( , k, e)
1≤k
1≤k
1≤k
1≤k
avec
≤ longueur(λ) + 1 ⇒ longueur(insérer(λ, k, e)) = longueur(λ) + 1
≤ longueur(λ) + 1 & 1 ≤ i < k ⇒ ième(insérer(λ, k, e), i) = ième(λ, i)
≤ longueur(λ) + 1 & k = i ⇒ ième(insérer(λ, k, e), i) = e
≤ longueur(λ) + 1 & k < i ≤ longueur(λ) + 1
⇒ ième(insérer(λ, k, e), i) = ième(λ, i − 1)
λ : Liste
k, i : Entier
e : Élément
Comment implémenter ces opérations "en place" ?
2
Algorithmique
Info-sup S1
td Algo 4 Déc. 2016
2
Epita
Une impression de déjà vu
Exercice 2.1 (Histogramme)
1. Écrire une fonction qui donne un histogramme des caractères présents dans une chaîne de caractères :
une liste de longueur 256 qui donne pour chaque caractère son nombre d'occurences dans la chaîne.
2. Écrire une fonction qui compte le nombre de caractères diérents dans une chaînes de caractères.
3. Écrire une fonction qui retourne le caractère le plus fréquent d'une chaîne, ainsi que son nombre
d'occurrences.
Exercice 2.2 (Ératosthène)
Écrire une fonction qui donne la liste de tous les nombres premiers jusqu'à une valeur
n
donnée.
Utiliser la méthode du crible d'Eratosthène (voir wikipedia).
3
Ordre et tris
Exercice 3.1 (
Algo → Python P1 - 2016 )
Soit la fonction
test,
qui utilise les opérations du type abstrait Liste itérative :
fonction test(Liste L) : booleen
variables
entier i
booleen b
debut
b ← vrai
i ← 1
tant que i < longueur(L) faire
si ieme(L, i) > ieme(L, i+1) alors
b ← faux
n si
i ← i + 1
n
n tant que
retourne b
test ?
Écrire une version Python de cette fonction, si possible plus optimale que la version Algo présentée
1. Que fait la fonction
2.
ci-dessus.
Exercice 3.2 (Tri par sélection (Select Sort))
1. Écrire la fonction
minimum
qui détermine la position de la valeur minimum dans une liste.
2. Utiliser la fonction précédente (en la modiant si nécessaire) pour écrire une fonction qui trie une
liste en ordre croissant.
Exercice 3.3 (Tri par insertion (Insertion Sort))
1. Écrire une fonction qui insère un élément
x
à sa place dans une liste
L
triée.
2. Utiliser la fonction précédente pour écrire une fonction qui trie une liste.
3
Algorithmique
Info-sup S1
td Algo 4 Déc. 2016
4
Epita
Diviser pour régner (Divide and Conquer)
Exercice 4.1 (Dichotomie (Binary Search))
1. Écrire une version plus optimale de la fonction qui recherche un élément
elle retourne la position de
x
s'il est présent dans
L,
x
dans une liste triée
L
:
la position où il devrait être sinon.
2. Avec cette nouvelle version de la recherche, l'insertion dans une liste triée est-elle plus optimale ?
Exercice 4.2 (Tri fusion (Merge sort) 1. Écrire la fonction
partition
P1 - 2016 )
qui sépare une liste en deux listes de longueurs quasi identiques (à 1
près) : une moitié dans chaque liste.
Exemples d'application :
>>> partition ([15 , 2 , 0 , 4 , 5 , 8, 2 , 3 , 12 , 25])
([15 , 2 , 0 , 4 , 5] , [8 , 2 , 3 , 12 , 25])
>>> partition ([5 ,3 ,2 ,8 ,7 ,1 ,5 ,4 ,0 ,6 ,1])
([5 , 3 , 2 , 8 , 7] , [1 , 5 , 4 , 0 , 6 , 1])
1
2
3
4
2. Écrire la fonction
merge
qui fusionne deux listes triées en ordre croissant en une seule liste triée.
Exemple d'application :
>>> merge ([1 ,5 ,8] , [2 ,3 ,4 ,8])
[1 , 2 , 3 , 4 , 5, 8 , 8]
1
2
3. Pour trier une liste
.
.
L,
on procède (récursivement) de la façon suivante :
Une liste de longueur < 2 est triée.
Une liste de longueur
≥2:
L en
on partitionne la liste
deux sous-listes
on trie récursivement les deux listes
enn, on fusionne les listes
L1
et
L2
L1
et
L1
et
L2
de longueurs quasi identiques (à 1 près) ;
L2 ;
en une liste triée.
Utiliser les deux fonctions précédentes (quelles soient écrites ou non) pour écrire la fonction
mergesort
qui trie en ordre croissant une liste (pas en place : la fonction construit une nouvelle liste qu'elle
retourne).
Exemple d'application :
1
2
>>> mergesort ([5 ,3 ,2 ,8 ,7 ,1 ,5 ,4 ,0 ,6 ,1])
[0 , 1 , 1 , 2 , 3, 4 , 5 , 5 , 6 , 7 , 8]
4