s1-tp/S2/TP4/tp4.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-

"""
TP AP1
Licence SESI 1ère année
Univ. Lille 1

tp4.py

TP 4

"""

__author__ = 'PREUD\'HOMME Geoffrey & BEAUSSART Jean-loup'
__date_creation__ = 'Tue, 24 Feb 2015 10:30:21 +0100'


def question(numero):
    print('\n***', 'Question', numero, '***')

def squestion(lettre):
    print('\n%s)' % lettre)


question(1) # Programmer recherches seq, seq triée, dicho

def seq(l, a, b, x): # Jean-loup
	"""
		Recherche séquentielle de l'élément x dans la liste l, entre les borne a et b, b étant exclu
		list(x), int, int, x → (bool, int)
		Renvoie True et l'emplacement de x dans l, si x a été trouvé, sinon (False, 0)
		CU: 0 <= a < b <= len(l)
	"""

	assert(a >=0 and b > a and b <= len(l))

	i=a

	while i < b and l[i] != x:
		i += 1
	if i < b:
		return (True, i)
	else:
		return (False, 0)

def seqTrie(l, a, b, x): # Jean-loup
	"""
		Recherche séquentielle de l'élément x dans la liste l triée, entre les bornes a et b, b étant exclu
		list(x), int, int, x → (bool, int)
		Renvoie True et l'emplacement de x dans l, si x a été trouvé, sinon (False, 0)
		CU: l est triée et 0 <= a < b <= len(l)
	"""

	assert(a >=0 and b > a and 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, 0)

def  dicho(l, a, b, x): # Geoffrey
	"""
	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 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"
	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 x == l[d] else -1)

question(2) # Utiliser LEXIQUE

from lexique import *

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

def creerListeRecherche(l, dans, hors):
	elements = list()
	taille = len(LEXIQUE)
	for n in range(dans):
		elements.append(LEXIQUE[randint(0, taille)])
	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)))