158 lines
3.9 KiB
Python
158 lines
3.9 KiB
Python
#!/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
|
|
from random import randint
|
|
|
|
NB_ELEMENTS = 10
|
|
elements = list()
|
|
taille = len(LEXIQUE)
|
|
for n in range(NB_ELEMENTS):
|
|
elements.append(LEXIQUE[randint(0, taille)])
|
|
|
|
#
|
|
|
|
def tricho(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 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"
|
|
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)
|
|
|
|
print(tricho(LEXIQUE_TRIE, 0, len(LEXIQUE_TRIE), 'banane')) |