Non mais vraiment cette fois

S2/TP4/tp4.py

@@ -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)