diff --git a/S2/TP4/tp4.py b/S2/TP4/tp4.py deleted file mode 100644 index e42df58..0000000 --- a/S2/TP4/tp4.py +++ /dev/null @@ -1,238 +0,0 @@ -#!/usr/bin/python3 -# -*- coding: utf-8 -*- - -""" -TP AP1 -Licence SESI 1ère année -Univ. Lille 1 - -tp4.py - -TP 4 - Algorithmes de recherche - -""" - -__author__ = 'PREUD\'HOMME Geoffrey & BEAUSSART Jean-loup' -__date_creation__ = 'Tue, 24 Feb 2015 10:30:21 +0100' - - -def question(numero): - """ - int → ∅ - Affiche la question en cours - """ - print('\n***', 'Question', numero, '***') - - -def squestion(lettre): - """ - int → ∅ - Affiche la sous-question en cours - """ - print('\n%s)' % lettre) - - -question(1) # Programmer recherches seq, seq triée, dicho - - -def seq(l, a, b, x): - """ - list, int, int, a → (bool, int) - Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l entre les - bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par méthode séquentielle. - CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l) - """ - assert(type(l) == list), "l doit être une liste" - assert(type(a) == type(b) == int), "a et b doivent être des ints" - assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)" - - i = a - - while i < b and l[i] != x: - i += 1 - if i < b: - return (True, i) - else: - return (False, -1) - - -def seqTrie(l, a, b, x): - """ - list, int, int, a → (bool, int) - Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l triée entre - les bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par méthode séquentielle. - CU : l une liste triée, a et b des ints tels que 0 ≤ a < b ≤ len(l) - """ - assert(type(l) == list), "l doit être une liste triée" - assert(type(a) == type(b) == int), "a et b doivent être des ints" - assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)" - - i = a - - while i < b and l[i] < x: - i += 1 - if i < b and l[i] == x: - return (True, i) - else: - return (False, -1) - - -def dicho(l, a, b, x): - """ - list, int, int, a → (bool, int) - Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l triée entre - les bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par dichotomie. - CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l) - """ - assert(type(l) == list), "l doit être une liste triée" - assert(type(a) == type(b) == int), "a et b doivent être des ints" - assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)" - - d = a - f = b - 1 - while d < f: - m = (d + f) // 2 - if l[m] < x: - d = m + 1 - else: - f = m - est_dedans = x == l[d] - return (est_dedans, d if est_dedans else -1) - - -def tricho(l, a, b, x): # TODO - """ - list, int, int, a → (bool, int) - Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l triée entre - les bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par trichotomie. - CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l) - """ - assert(type(l) == list), "l doit être une liste triée" - assert(type(a) == type(b) == int), "a et b doivent être des ints" - assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)" - - d = a - f = b - 1 - while d < f: - m1 = (d + f) // 3 - m2 = m1 * 2 - if l[m1] >= x: - f = m1 - elif l[m2] >= x: - d = m1 + 1 - f = m2 - else: - d = m2 + 1 - est_dedans = x == l[d] - return (est_dedans, d if x == l[d] else -1) - -question(2) # Utiliser LEXIQUE - -from lexique import LEXIQUE - -squestion('a') # Vérifier que LEXIQUE est triée - - -def est_trie(l): - """ - list → bool - Indique si la liste l est triée dans l'ordre croissant - """ - for i in range(len(l) - 1): - if not l[i] < l[i + 1]: - return False - return True - -print("Le test indiquant si LEXIQUE est trié retourne %s." % est_trie(LEXIQUE)) - -print("Le lexique est cependant bien trié, mais par ordre alphabétique, comprenant les accents dans\ -cet ordre, ce qui n'est pas l'ordre \"naturel\" de Python, qui se base sur le codage des \ -caractères") - -print( - "Création de LEXIQUE_TRIE, qui est une copie de LEXIQUE trié par l'ordre de Python") -LEXIQUE_TRIE = list(LEXIQUE) # Crée une copie -LEXIQUE_TRIE.sort() - -print("Le test indiquant si LEXIQUE_TRIE est trié retourne %s." % - est_trie(LEXIQUE_TRIE)) - -squestion('b') -# Effectuer de nombreuses recherches dans LEXIQUE -# et comparer les temps d'éxécution selon les -# algorithmes utilisés - -# Définition des éléments choisis pour la recherche -from random import randint, SystemRandom -from string import ascii_lowercase, ascii_uppercase - - -def motAleatoire(taille): - """ - int → str - Renvoie une mot aléatoire constitué de lettres (sans accent) minuscules et majuscules, et de - chiffres - """ - return ''.join(SystemRandom().choice(ascii_lowercase + ascii_uppercase) - for _ in range(taille)) - - -def creerListeRecherche(l, dans, hors): - """ - list, int, int → list - Crée une liste de termes dont `dans` sont contenus dans `l`, et `hors` sont des mots générés - aléatoirement. - """ - elements = list() - taille = len(l) - for _ in range(dans): - elements.append(l[randint(0, taille)]) - for _ in range(hors): - while True: - mot = motAleatoire(randint(2, 10)) - if mot not in l: - break - elements.append(mot) - return elements - -# Méthode de test des fonctions -from time import time -from sys import stdout - - -def mesure(methode, l, elements): - """ - function, list, list → ∅ - Mesure le temps mis pour rechercher les éléments elements dans l en utilisant methode et affiche - les résultats. - """ - t = len(l) - print("Test de la méthode %s..." % methode, end='') - stdout.flush() - debut = time() - for e in elements: - methode(l, 0, t, e) - fin = time() - print("\rLa méthode %s a pris %f secondes pour trouver %d éléments, soit %f secondes par \ -élément." % (methode, fin - debut, len(elements), (fin - debut) / len(elements))) - - -if __name__ == '__main__': - import sys - if len(sys.argv) == 1: - MESURE_DEFAUT = 500 - print("\nTest avec %d éléments pris exclusivement de LEXIQUE" % - MESURE_DEFAUT) - exclu = creerListeRecherche(LEXIQUE, MESURE_DEFAUT, 0) - mesure(seq, LEXIQUE, exclu) - mesure(seqTrie, LEXIQUE_TRIE, exclu) - mesure(dicho, LEXIQUE_TRIE, exclu) - - PART_DEHORS = 0.2 - print("\nTest avec %d éléments dont %d sont dans LEXIQUE" % - (MESURE_DEFAUT, (1 - PART_DEHORS) * MESURE_DEFAUT)) - exclu = creerListeRecherche(LEXIQUE, int( - (1 - PART_DEHORS) * MESURE_DEFAUT), int(PART_DEHORS * MESURE_DEFAUT)) - mesure(seq, LEXIQUE, exclu) - mesure(seqTrie, LEXIQUE_TRIE, exclu) - mesure(dicho, LEXIQUE_TRIE, exclu)