mise en place TP

docs/TP2023-2024/README.md

@@ -23,6 +23,7 @@
 * [tp18](http://vps-ff29e1ab.vps.ovh.net:8080/) : Tableaux dynamiques
   à la scala en `OCaml`
 * [tp19](TP19_parcours_arbre/tp_parcours_arbres.md) : Parcours d'arbres
+* [tp20](TP20_hachage/tp_hachage.md) : Hachage
 
 # Trop rapide ?
 Allez chercher du travail sur

docs/TP2023-2024/TP20_hachage/code/hachage.h

@@ -0,0 +1,41 @@
+#ifndef _HACHAGE_H
+#define _HACHAGE_H
+
+#include "liste.h"
+
+struct hachage {
+  int lg; // nombre d'alvéoles
+  struct maillon **alveoles; // tableau de listes d'alveoles
+  int (*hacher)(int, int); // fonction de hachage (prend deux entiers en argument et renvoie un entier)
+};
+
+typedef struct hachage hachage;
+
+/** n : entier strictement positif
+ * hacher : une fonction qui prend un entier en argument et renvoie un entier compris entre 0 et n-1
+ * sortie: table de hachage avec n alvéoles
+ */
+hachage init(int n, int (*hacher)(int, int));
+
+/** h : table de hachage existante
+ * val : valeur à ajouter
+ * sortie : la valeur val est ajoutée à l'alvéole hacher(val) si elle n'appartenait pas à l'ensemble
+ */
+void ajout(hachage h, int val);
+
+/** sortie : vrai si et seulement si val apparaît dans h
+ */
+bool element(hachage h, int val);
+
+/** h : table de hachage existante
+ * valeur à supprimer
+ * sortie : la valeur val a été supprimée de h si elle appartenait à h
+ */
+void suppression(hachage h, int val);
+
+/** affiche le contenu de h */
+void contenu(hachage h);
+
+/** vider le contenu de la table de hachage */
+void vider(hachage h);
+#endif

docs/TP2023-2024/TP20_hachage/code/liste.h

@@ -0,0 +1,35 @@
+#ifndef _LISTE_H
+#define _LISTE_H
+
+#include <stdbool.h>
+
+struct maillon {
+  int val;
+  struct maillon *suivant;
+};
+
+typedef struct maillon *liste;
+
+/** sortie : vrai si et seulement si val apparaît dans lst
+ */
+bool element_liste(int val, liste lst);
+
+/** val : entier à ajouter
+ * lst : liste d'entier
+ * sortie : val a été ajouté en tête s'il n'appartenait pas déjà à lst, sinon lst est renvoyé
+ */
+liste ajout_liste(int val, liste lst);
+
+
+/** val : entier à supprimer
+ * lst : liste d'entier
+ * sortie : val a été supprimé s'il appartenait à lst, sinon lst est renvoyé
+ */
+liste suppression_liste(int val, liste lst);
+
+/** affiche le contenu de lst */
+void contenu_liste(liste lst);
+
+/** libere la mémoire de la liste */
+void vider_liste(liste lst);
+#endif

docs/TP2023-2024/TP20_hachage/code/temps.c

@@ -0,0 +1,21 @@
+#include <time.h>
+#include <stdio.h>
+#include <math.h>
+#include "temps.h"
+
+clock_t debut, fin;
+
+void debut_mesure_temps(){
+  debut = clock();
+}
+
+void fin_mesure_temps(){
+  fin = clock();
+}
+
+void affiche_mesure_temps(){
+  printf("%f", (fin - debut + .0)/CLOCKS_PER_SEC);
+}
+void affiche_mesure_log_temps(){
+  printf("%f", log((fin - debut + .0)/CLOCKS_PER_SEC));
+}

docs/TP2023-2024/TP20_hachage/code/temps.h

@@ -0,0 +1,15 @@
+#ifndef _TEMPS_H
+#define _TEMPS_H
+
+#include <time.h>
+
+/** commence à mesurer le temps d'exécution */
+void debut_mesure_temps();
+/** arrête de mesurer le temps d'exécution */
+void fin_mesure_temps();
+/** affiche en seconde le dernier temps d'exécution mesuré */
+void affiche_mesure_temps();
+/** affiche le log dernier temps d'exécution mesuré */
+void affiche_mesure_log_temps();
+
+#endif

docs/TP2023-2024/TP20_hachage/tp_hachage.md

@@ -0,0 +1,87 @@
+TP20 : Tables de hachage
+==
+
+Il s'agit dans ce TP de constater expérimentalement l'efficacité des
+tables de hachage pour stocker des ensembles (d'entiers pour
+simplifier).
+
+# Gestion des collisions par chaînage
+
+Nous nous intéressons à la gestion des collisions par chaînage et nous
+voulons déterminer expérimentalement la bonne taille de table de
+hachage en fonction du nombre de données à stocker.
+
+Les fichiers d'en-tête qui spécifient les types et les fonctions à
+implémenter: [hachage.h](code/hachage.h) / [liste.h](code/liste.h).
+
+## Exercice 1 : implémenter les fonctions liées aux listes chaînées
+
+Tout est dans le titre... la liste des fonctions se trouvent dans le
+fichier d'en-tête.
+
+## Exercice 2 : implémenter la table de hachage
+
+Le champ `hacher` un peu bizarre qu'on voit dans le fichier d'en-tête
+et le paramètre assez similaire de la fonction `init`
+permettent de manipuler des fonctions comme des valeurs (comme dans le
+cas des tableaux, le nom d'une fonction est converti implicitement en
+son adresse). Il s'agit ici de conserver l'adresse de la fonction de
+hachage dans la table de hachage.
+
+Par exemple on pourrait écrire:
+
+```C
+int zero(int n, int p){  // les paramètres sont là pour le type de la fonction
+    return 0;
+} // très peu intéressant comme fonction de hachage
+
+int main(void){
+    hachage h;
+
+    h.hacher = zero;
+}
+```
+
+(Les types comme celui du champ `hacher` sont hors programme et je ne
+vous demande pas de savoir les manipuler, mais là il s'agit juste
+d'utiliser une fonction comme paramètre d'une autre.)
+
+Varier les fonctions de hachage:
+* identité modulo la taille de la table,
+* produit par un entier premier avec la taille de la table, puis
+  modulo la taille de la table,
+* première valeur renvoyée par `random` quand on fait un `srandom` sur
+  la valeur à stocker,
+* choix d'un double non entier `a` et partie entière inférieure de
+  `n*(k*a % 1)` où `n` est la taille de la table et `k` la clef considérée.
+
+## Exercice 3 : statistiques
+Je vous fournis les fichiers [temps.h](code/temps.h) / [temps.c](code/temps.c)
+qui permettent de mesurer le temps d'exécution d'une partie d'un
+programme.
+
+Il s'agit de faire des statistiques sur les temps d'insertion, de
+consultation et de suppression d'élément dans votre table de hachage.
+
+Pour les tracés, on utilisera `gnuplot` (essayez de le lancer en ligne
+de commande dans un terminal, si ce n'est pas installé, appelez-moi).
+
+Un tutoriel pour utiliser gnuplot avec des données dans un fichier:
+[https://sodocumentation.net/gnuplot/topic/3591/basic-plotting-of-data-files](https://sodocumentation.net/gnuplot/topic/3591/basic-plotting-of-data-files).
+
+On suppose qu'on a une table de hachage de `N` alvéoles. On veut
+ connaître le temps mis pour `M` insertions prises au hasard, le temps
+ de consultation pour `M/2` consultations au hasard et le temps de
+ suppression pour `M/2` suppressions au hasard.
+ 
+ Faites des graphiques où `N` est fixé et `M` varie, et des graphiques
+ où `N/M` est fixé et `N` et `M` varient.
+
+# Gestion des collisions par sondage
+ 
+ Faites les mêmes expériences en gérant les collisions par sondage.
+
+# Pour ceux qui ont fini
+Je vous propose d'essayer de commencer un [sujet de TP
+d'ENS](https://informatique.ens-lyon.fr/concours-info/2019/sujet-ancetre_commun.pdf),
+en `C` ou en `OCaml`, au choix.