372 lines
9.6 KiB
Python
372 lines
9.6 KiB
Python
#!/usr/bin/python3
|
||
# -*- coding: utf-8 -*-
|
||
# pylint: disable=invalid-name, global-statement
|
||
|
||
"""
|
||
TP AP1
|
||
Licence SESI 1ère année
|
||
Univ. Lille 1
|
||
|
||
analyse_tris.py
|
||
|
||
TP4 - Evaluation empirique des tris
|
||
|
||
http://www.fil.univ-lille1.fr/~L1S2API/CoursTP/tp4_tri.html
|
||
|
||
"""
|
||
|
||
__author__ = 'PREUD\'HOMME Geoffrey & BEAUSSART Jean-loup'
|
||
__date_creation__ = 'Tue, 10 Mar 2015 10:26:41 +0100'
|
||
|
||
from random import randint
|
||
|
||
affichage = __name__ == '__main__'
|
||
# La variable affichage définit si on doit répondre aux questions du TP. De cette manière, ces
|
||
# dernières sont affichées et calculées uniquement si le programme principal est lancé, ce qui
|
||
# nous permet de réutiliser des fonctions de ce fichier dans `analyse_en_moyenne.py` sans avoir
|
||
# d'affichage et de calculs non-nécessaires à son fonctionnement. On aurait pu aussi séparer
|
||
# fonctions et questions, mais pour la facilité de la correction nous avons préféré qu'il en soit
|
||
# ainsi.
|
||
|
||
def partie(nom):
|
||
"""
|
||
str → ∅
|
||
Affiche le nom de la partie en cours
|
||
"""
|
||
assert type(nom) == str
|
||
|
||
if affichage:
|
||
print('\n', nom, '=' * len(nom), sep='\n')
|
||
|
||
|
||
def section(nom):
|
||
"""
|
||
str → ∅
|
||
Affiche le nom de la section en cours
|
||
"""
|
||
assert type(nom) == str
|
||
|
||
if affichage:
|
||
print('\n', nom, '-' * len(nom), sep='\n')
|
||
|
||
|
||
def question(numero):
|
||
"""
|
||
str → ∅
|
||
Affiche le numéro de la question en cours
|
||
"""
|
||
assert type(numero) == int
|
||
|
||
if affichage:
|
||
print('\n***', 'Question', numero, '***')
|
||
|
||
def reponse(texte):
|
||
"""
|
||
str → ∅
|
||
Affiche la réponse à la question.
|
||
"""
|
||
assert type(texte) == str
|
||
|
||
if affichage:
|
||
print(texte)
|
||
|
||
|
||
partie("Prérequis")
|
||
|
||
|
||
def comp(x, y):
|
||
"""
|
||
parametres
|
||
x , y de même type et comparables
|
||
valeur renvoyee : int
|
||
-1 si x<y
|
||
0 si x==y
|
||
1 si x>y
|
||
action : incrémente le compteur
|
||
CU : aucune
|
||
"""
|
||
|
||
global compteur
|
||
compteur = compteur + 1
|
||
if x < y:
|
||
return -1
|
||
elif x == y:
|
||
return 0
|
||
else:
|
||
return 1
|
||
|
||
|
||
def select_min(l, a, b):
|
||
"""
|
||
list, int, int → int
|
||
Renvoie l'indicde d'un élément minimal de la tranche l[a:b]
|
||
CU : l est une liste de longueur n, d'éléments homogènes ordonnables, et a et b deux indices
|
||
tels que 0 ≤ a < b < n
|
||
"""
|
||
assert 0 <= a < b <= len(l)
|
||
|
||
imin = a
|
||
for i in range(a + 1, b + 1):
|
||
if comp(l[i], l[imin]) == -1:
|
||
imin = i
|
||
return imin
|
||
|
||
|
||
def tri_selection(l):
|
||
"""
|
||
list → ∅
|
||
La liste l est trié (selon l'algorithme du tri par sélection du minimum)
|
||
CU : l est une liste de longueur n, homogène, d’éléments ordonnables
|
||
"""
|
||
assert type(l) == list
|
||
n = len(l)
|
||
for i in range(n - 1):
|
||
imin = select_min(l, i, n - 1)
|
||
l[i], l[imin] = l[imin], l[i]
|
||
|
||
|
||
def tri_insertion_base(l, n):
|
||
"""
|
||
list, int → ∅
|
||
n est un indice de l tel que l[0:n] soit une liste triée. La fonction déplace l'élément
|
||
de rang n de telle sorte que l[0:i+1] soit triée
|
||
CU: n est un entier < len(l) et l est une liste, dont les éléments sont comparables, triée
|
||
jusqu'à l'indice n-1.
|
||
"""
|
||
assert type(n) == int and type(l) == list and 0 <= n < len(l)
|
||
|
||
aux = l[n]
|
||
|
||
k = n
|
||
while k >= 1 and comp(l[k - 1], aux) == 1:
|
||
l[k] = l[k - 1]
|
||
k -= 1
|
||
|
||
l[k] = aux
|
||
|
||
|
||
def tri_insertion(l):
|
||
"""
|
||
list → ∅
|
||
La liste l est trié (selon l'algorithme du tri par insertion)
|
||
CU : l est une liste de longueur n, homogène, d’éléments ordonnables
|
||
"""
|
||
assert type(l) == list
|
||
for i in range(1, len(l)):
|
||
tri_insertion_base(l, i)
|
||
|
||
partie("Travail à réaliser")
|
||
|
||
section("Préliminaires")
|
||
|
||
question(1)
|
||
|
||
|
||
def liste_croissante(n):
|
||
"""
|
||
int → list(int)
|
||
Retourne la liste des entiers compris entre 0 et n-1, rangés dans l'ordre croissant
|
||
CU: n est un entier positif
|
||
"""
|
||
assert type(n) == int and n >= 0
|
||
|
||
return list(range(n))
|
||
|
||
|
||
question(2)
|
||
|
||
|
||
def liste_decroissante(n):
|
||
"""
|
||
int → list(int)
|
||
Retourne la liste des entiers compris entre 0 et n-1, rangés dans l'ordre décroissant
|
||
CU: n est un entier positif
|
||
"""
|
||
assert type(n) == int and n >= 0
|
||
|
||
return list(range(n - 1, -1, -1))
|
||
|
||
question(3)
|
||
|
||
|
||
def liste_alea(n, a, b):
|
||
"""
|
||
int, int, int → list
|
||
Renvoie une liste d’entiers, qui construit une liste de longueur n les entiers choisis au hasard
|
||
compris entre a et b.
|
||
CU : n entier positif, a et b entiers, a ≤ b
|
||
"""
|
||
assert type(n) == type(a) == type(b) == int and n >= 0 and a <= b
|
||
|
||
return [randint(a, b) for _ in range(n)]
|
||
|
||
section("Compter les comparaisons")
|
||
|
||
question(1)
|
||
|
||
compteur = 0
|
||
|
||
tri_selection(liste_alea(100, -5000, 5000))
|
||
|
||
reponse('{} comparaisons ont été faite pour cette liste.'.format(compteur))
|
||
|
||
question(2)
|
||
|
||
|
||
def tri_et_compte(trieur, l):
|
||
"""
|
||
Trie la liste l avec la fonction de triage trieur passée en paramètre, renvoie la liste triée
|
||
et le nombre de comparaisons effectuées
|
||
str, list → (list, int)
|
||
CU: trieur est une fonction, l est une liste
|
||
"""
|
||
assert callable(trieur) and type(l) == list
|
||
|
||
global compteur
|
||
compteur = 0
|
||
ltrie = trieur(l[:]) # On fait une copie l
|
||
|
||
return (ltrie, compteur)
|
||
|
||
partie("Analyse du tri par sélection")
|
||
|
||
|
||
def afficher_tableau(donnees):
|
||
"""
|
||
list[list] → ∅
|
||
Affiche donnees sous forme d'un tableau x / y
|
||
CU : donnees est une liste contenant des listes de même longueurs
|
||
"""
|
||
taillesColonnes = [max([len(str(donnees[y][x])) for y in range(
|
||
len(donnees))]) for x in range(len(donnees[0]))]
|
||
|
||
barres = ['─' * l for l in taillesColonnes]
|
||
print('┌' + '┬'.join(barres) + '┐')
|
||
for y in range(len(donnees)):
|
||
ligne = '│'
|
||
for x in range(len(donnees[0])):
|
||
ligne += ' ' * \
|
||
(taillesColonnes[x] - len(str(donnees[y][x]))) + \
|
||
str(donnees[y][x]) + '│'
|
||
print(ligne)
|
||
if y == 0:
|
||
print('├' + '┼'.join(barres) + '┤')
|
||
print('└' + '┴'.join(barres) + '┘')
|
||
|
||
question(1)
|
||
|
||
if affichage:
|
||
tableau = [['nb ', 'croissante ', 'aléatoire ', 'decroissante']]
|
||
for nb in range(1, 101):
|
||
tableau.append([nb,
|
||
tri_et_compte(tri_selection, liste_croissante(nb))[1],
|
||
tri_et_compte(tri_selection, liste_alea(nb, 0, 500))[1],
|
||
tri_et_compte(tri_selection, liste_decroissante(nb))[1]])
|
||
afficher_tableau(tableau)
|
||
|
||
question(2)
|
||
|
||
partie("Analyse du tri par insertion")
|
||
|
||
question(1)
|
||
|
||
if affichage:
|
||
tableau = [tableau[0]]
|
||
for nb in range(1, 101):
|
||
tableau.append([nb,
|
||
tri_et_compte(tri_insertion, liste_croissante(nb))[1],
|
||
tri_et_compte(tri_insertion, liste_alea(nb, 0, 500))[1],
|
||
tri_et_compte(tri_insertion, liste_decroissante(nb))[1]])
|
||
afficher_tableau(tableau)
|
||
|
||
section("Dans le meilleur des cas")
|
||
|
||
question(1)
|
||
|
||
reponse("Le meilleur des cas est lorsque la liste est déjà triée.")
|
||
|
||
question(2)
|
||
|
||
if affichage:
|
||
reponse("Résultat théorique établi : c_{tri-insert}(n)=n-1")
|
||
tableau = [['i', 'coût comtpé', 'coût théor.', 'fidèle']]
|
||
tousFideles = True
|
||
for nb in range(1, 101):
|
||
c_compte = tri_et_compte(tri_insertion, liste_croissante(nb))[1]
|
||
c_theor = nb - 1
|
||
fidele = c_compte == c_theor
|
||
if not fidele:
|
||
tousFideles = False
|
||
tableau.append([nb, c_compte, c_theor, fidele])
|
||
afficher_tableau(tableau)
|
||
reponse("Les résultats comptés {} tous fidèles aux résultats théoriques."
|
||
.format("sont" if tousFideles else "ne sont pas"))
|
||
|
||
section("Dans le pire des cas")
|
||
|
||
question(1)
|
||
|
||
reponse("Le pire des cas est lorsque la liste est triée dans l'ordre inverse.")
|
||
|
||
question(2)
|
||
|
||
if affichage:
|
||
reponse("Résultat théorique établi : c_{tri-insert}(n)=n(n-1)/2")
|
||
tableau = [tableau[0]]
|
||
tousFideles = True
|
||
for nb in range(1, 101):
|
||
c_compte = tri_et_compte(tri_insertion, liste_decroissante(nb))[1]
|
||
c_theor = nb * (nb - 1) // 2
|
||
fidele = c_compte == c_theor
|
||
if not fidele:
|
||
tousFideles = False
|
||
tableau.append([nb, c_compte, c_theor, fidele])
|
||
afficher_tableau(tableau)
|
||
reponse("Les résultats comptés {} tous fidèles aux résultats théoriques."
|
||
.format("sont" if tousFideles else "ne sont pas"))
|
||
|
||
section("En moyenne")
|
||
|
||
question(1)
|
||
|
||
if affichage:
|
||
t1 = tri_et_compte(tri_insertion, liste_alea(100, -5000, 5000))[1]
|
||
t2 = tri_et_compte(tri_insertion, liste_alea(100, -5000, 5000))[1]
|
||
|
||
reponse("Le nombre de comparaisons de la première liste est {t1}, celui de la deuxième liste \
|
||
est {t2}.\nLes nombres de comparaisons pour ces deux tris sont {res}.".format(t1=t1, t2=t2, \
|
||
res=("identiques (mais c'est un coup de chance)" if t1 == t2 else "différents")))
|
||
|
||
question(1)
|
||
|
||
def nbre_moyen_tri_insertion(m, n):
|
||
"""
|
||
int, int → float
|
||
Calcule la moyenne du nombre de comparaisons pour trier par insertion un échantillion de taille
|
||
m de listes choisies au hasard de longueur n.
|
||
CU : m et n sont des entiers positifs
|
||
"""
|
||
compTotal = 0
|
||
for _ in range(m):
|
||
compTotal += tri_et_compte(tri_insertion, liste_alea(n, -5000, 5000))[1]
|
||
return compTotal / m
|
||
|
||
question(2)
|
||
|
||
reponse("Voir le fichier `analyse_en_moyenne.py`.")
|
||
|
||
question(3)
|
||
|
||
question(4)
|
||
|
||
reponse("Je vous invite à éxecuter la commande `make tri_insertion_moyen.txt` pour obtenir ce \
|
||
fichier.")
|
||
|
||
section("Avec Gnuplot")
|
||
|
||
question(1)
|
||
|
||
reponse("Graphiquement, on trouve que cette fonction a pour expression 0,287x²-2x+1\n\
|
||
Cette fonction correspond à la commande : \n\
|
||
gnuplot> plot 'tri_insertion_moyen.txt', 0.287*x**2-2*x +1 with lines")
|