Import all

Formations/NSI/Bloc1/diubloc1-files-td3/diu-dico-english.py

@@ -0,0 +1,61 @@
+#! /usr/bin/env python3
+"""
+    python3 diu-dico-english.py 
+"""
+__author__ = "Laure Gonnord"
+__copyright__ = "Univ Lyon1, 2019"
+
+import time
+
+# Comparaison rapide liste/dictionnaires.
+# Nécessite le fichier dico.en2fr récupéré de http://www.june29.com/IDP/files/French.txt (on a enlevé les lignes du début)
+
+
+# Liste
+def update_list(mot, trad, mylist):
+    mylist.append((mot, trad))
+
+
+def load_list(nomFichier, dico):
+    """
+    charge les mots du fichier dans la liste
+    """
+    with open(nomFichier) as fichier:
+        for ligne in fichier:
+            (mot, trad) = ligne.strip().split("\t")
+            # print(mot, trad)
+            update_list(mot, trad, dico)
+
+
+def search_tuple(tups, elem):
+    for (mot, trad) in tups:
+        if (mot == elem):
+            return trad
+    raise Exception("search tuple: not found")
+
+
+# Dictionnaire
+# TODO : update, load.
+
+
+##################  Programme principal ######################
+
+
+fichier = 'dico.en2fr'
+NBTRIES = 10000
+
+# initialisation et chargement de la liste
+mylist = []
+startTime = time.time()
+load_list(fichier, mylist)
+endTime = time.time()
+print("La liste est chargée en (s)", (endTime - startTime))
+print("la traduction de dog est ", search_tuple(mylist, "dog"))
+
+startTime = time.time()
+for i in range(NBTRIES):
+    search_tuple(mylist, "house")
+endTime = time.time()
+print("mes recherches ont coûté ", (endTime - startTime))
+
+# TODO : faire la même chose avec un dictionnaire

Formations/NSI/Bloc1/diubloc1-files-td3/diu-dico-hash.py

@@ -0,0 +1,182 @@
+#! /usr/bin/env python3
+"""
+    python3 diu-dico-hash
+"""
+__author__ = "Nicolas Pronost and Laure Gonnord"
+__copyright__ = "Univ Lyon1, 2019"
+
+from libdiulistechainee import *  # une librairie maison de listes triées.
+import matplotlib.pyplot as plt
+import time
+import sys
+
+sys.setrecursionlimit(10000)
+
+##################  Constantes ######################
+
+TAILLE_TABLE = 308
+
+##################  Fonction de hachage ######################
+
+
+def asciss(mot):
+    h = 0
+    for c in mot:
+        h += ord(c) - 96
+    return h
+
+
+def hash(mot):
+    return asciss(mot) % TAILLE_TABLE
+
+
+##################  Construction de la table ######################
+
+
+def init_ht(ht):
+    """
+    Construit une liste de TAILLE_TABLE listes chainees (triées)
+    une nouvelle liste chainee sera obtenue en appelant ListeChainee()
+    """
+    ht = [ListeChainee() for i in range(TAILLE_TABLE)]
+    return ht
+
+
+def update_ht(mot, ht):
+    """
+    Ajoute le mot dans la liste chainee triee à la case d'index hash(mot).
+    Utiliser ajouterDansListeTriee.
+    """
+    ht[hash(mot)].ajouterEnTete(mot)
+
+
+def load_ht(nomFichier, ht):
+    """
+    Ajoute les mots du fichier dans la table de hachage
+    """
+    with open(nomFichier) as fichier:
+        for ligne in fichier:
+            update_ht(ligne[:-1], ht)
+
+
+##################  Fonctionnalités de la table ######################
+
+
+def afficheCollisions(ht):
+    """
+    Imprime la taille de chaque liste contenue dans les cases de ht 
+    Utiliser la méthode nbElements()
+    """
+    for lc in ht:
+        print(lc.nbElements())
+
+
+def nombresCollisions(ht):
+    """
+    Calcule et retourne la taille des listeschainées 
+    pour chaque case de la table
+    selon une forme utile pour les graphiques, ie :
+    - la premiere liste contient les indices des cases
+    - la deuxième la taille de la liste contenue.
+    Utiliser la méthode nbElements()
+    """
+    res = ([], [])
+    for k,v in enumerate(ht):
+        res[0].append(k)
+        res[1].append(v.nbElements())
+    return res
+
+
+def max_hash(nomFichier):
+    """
+    Retourne le couple (mot_max,hmax) du plus "grand" mot (au sens de asciss)
+    et sa valeur de hachage
+    """
+    mot_max = ""
+    hmax = 0
+    with open(nomFichier) as fichier:
+        for ligne in fichier:
+            mot = ligne[:-1]
+            ha = hash(mot)
+            if ha > hmax:
+                hmax = ha
+                mot_max = mot
+    return (mot_max, hmax)
+
+
+####### Quelques fonctions de stats/dessin de figures qui font varier la taille de ht
+
+
+def stats_load(fichier):
+    global TAILLE_TABLE
+    ht = []
+    # affichage temps exec en fct de la taille de la table
+    plt.figure()
+    toplot = []
+    tailles_table = [10, 50, 100, 200, 400]
+    for TAILLE_TABLE in tailles_table:
+        ht.clear()
+        startTime = time.time()
+        init_ht(ht)
+        load_ht(fichier, ht)
+        toplot.append(time.time() - startTime)
+    plt.plot(tailles_table, toplot, "-k")
+    plt.title("Temps d'exécution vs. taille table")
+    plt.grid(True)
+    plt.show()
+
+
+# Affichage graphe du nombre de collisions pour plusieurs tailles.
+def stats_collisions(fichier):
+    global TAILLE_TABLE
+    ht = []
+    plt.figure()
+    tailles_table = [10, 50, 100, 200, 400]
+    colors_plot = ["r", "b", "k", "g", "m"]
+    for i in range(len(tailles_table)):
+        TAILLE_TABLE = tailles_table[i]
+        init_ht(ht)
+        load_ht(fichier, ht)
+        (axisX, axisY) = nombresCollisions(ht)
+        plt.plot(axisX, axisY, colors_plot[i], label="taille " + str(TAILLE_TABLE))
+    plt.grid(True)
+    plt.legend(loc="upper right")
+    # plt.title('Nb de collisions vs. taille table')
+    plt.show()
+
+
+##################  Programme principal ######################
+
+
+ht = []  # Ma table de hachage est une liste de listes chainées
+fichier = "dico.english"
+
+# initialisation et chargement de la table
+ht = init_ht(ht)
+load_ht(fichier, ht)
+
+# Affichage console du nombre de collisions
+#afficheCollisions(ht)
+
+# A décommenter (il faut numpy et mathplotlib)
+
+# # Affichage graphe du nombre de collisions
+# (axisX, axisY) = nombresCollisions(ht)
+# plt.figure()
+# plt.plot(axisX, axisY, '-k')
+# plt.title('Nombre de collisions vs. indice table')
+# plt.grid(True)
+# plt.savefig("collisions.pdf")
+# 
+# # Mot de valeur de hachage max
+(mot_max, hmax) = max_hash(fichier)
+print('valeur de hachage max: '+str(hmax)+' pour le mot: '+mot_max)
+TAILLE_TABLE = hmax+1
+init_ht(ht)
+load_ht(fichier, ht)
+print('Le mot '+mot_max+' doit être dans la liste : ', end='')
+ht[hmax].afficher()
+# 
+# # Maintenant comparons wrt les tailles de ht.
+# stats_load(fichier)
+# stats_collisions(fichier)

Formations/NSI/Bloc1/diubloc1-files-td3/libdiulistechainee.py

@@ -0,0 +1,124 @@
+# =======================    Cellule   ===========================================
+class Cellule:
+    def __init__(self, val, suiv):
+        self.val = val
+        self.suiv = suiv
+
+# ======================    ListeChainee   ========================================
+class ListeChainee:
+    """ Liste simplement chaînée non circulaire"""
+
+    def __init__(self):
+        self.premier = None
+
+    def estVide(self):
+        return self.premier == None
+
+    def nbElements(self):
+        nb = 0
+        elt = self.premier
+        while elt:
+            nb += 1
+            elt = elt.suiv
+        return nb
+
+    def iemeElement(self, indice):
+        elt = self.premier
+        for i in range(indice):
+            elt = elt.suiv
+            if elt == None:
+                print("Erreur iemeElement : indice trop grand")
+        return elt.val
+
+    def modifierIemeElement(self, indice, valElement):
+        elt = self.premier
+        for i in range(indice):
+            elt = elt.suiv
+            if elt == None:
+                print("Erreur modifierIemeElement : indice trop grand")
+        elt.val = valElement
+
+    def afficher(self):
+        elt = self.premier
+        while elt:
+            print(elt.val, end=' ')
+            elt = elt.suiv
+        print()
+
+    def ajouterEnTete(self, valElement):
+        elt = Cellule(valElement, self.premier)
+        self.premier = elt
+
+    def insererDansListeTriee(self,cellule,valElement):
+        celluleSuivante = cellule.suiv
+        if celluleSuivante == None or celluleSuivante.val > valElement:
+            elt = Cellule(valElement, celluleSuivante)
+            cellule.suiv = elt
+        else:
+            self.insererDansListeTriee(celluleSuivante,valElement)
+
+    def ajouterDansListeTriee(self, valElement):
+        if self.estVide():
+            self.ajouterEnTete(valElement)
+        else:
+            if self.premier.val > valElement:
+                self.ajouterEnTete(valElement)
+            else:
+                self.insererDansListeTriee(self.premier,valElement)
+
+    def supprimerTete(self):
+        elt = self.premier
+        self.premier = elt.suiv
+
+    def rechercheElement(self, valElement):
+        elt = self.premier
+        trouve = False
+        pos = 0
+        while elt and not trouve:
+            if valElement == elt.val:
+                trouve = True
+            else:
+                elt = elt.suiv
+                pos += 1
+        if trouve:
+            return pos
+        else:
+            return -1
+
+    def chargerDepuisFichier(self,nomFichier):
+        with open(nomFichier) as fichier:
+            for ligne in fichier:
+                self.insererDansListeTriee(ligne)
+
+
+# ========================== programme de test =====================================
+
+# lc = ListeChainee()
+# print("Ajout en tete de 5 '2' 4 : ", end='')
+# lc.ajouterEnTete(5)
+# lc.ajouterEnTete("2")
+# lc.ajouterEnTete(4)
+# lc.afficher()
+#
+# print("Valeur de l'element a l'indice 1 : ", lc.iemeElement(1))
+#
+# print("Modification de l'element a l'indice 1 (1.6) : ", end='')
+# lc.modifierIemeElement(1, 1.6)
+# lc.afficher()
+#
+# print("Nombre d'elements : ", lc.nbElements())
+#
+# print("Suppression de l'element de tete : ", end='')
+# lc.supprimerTete()
+# lc.afficher()
+#
+# print("Recherche de la valeur 5 : ", lc.rechercheElement(5))
+# print("Recherche de la valeur 'coucou' : ", lc.rechercheElement("coucou"))
+#
+# lcmots = ListeChainee()
+# print("Ajout dans liste triee de 'abc' 'edf' 'b' 'a' : ", end='')
+# lcmots.ajouterDansListeTriee("abc")
+# lcmots.ajouterDansListeTriee("edf")
+# lcmots.ajouterDansListeTriee("b")
+# lcmots.ajouterDansListeTriee("a")
+# lcmots.afficher()