"yes"

TP/TP18/hash.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "hash.h"
+
+
+int hash(val,length){
+
+
+    for (int i = 0; i < strlen(c); ++i) {
+    val = (43 * val + c[i]) % length;
+                }
+    return (val % length);
+}
+
+hm_t* hm_create(int capacity){
+
+    hm_t* hash_map = (hm_t*)malloc(sizeof(hm_t));
+
+    hash_map->length = capacity;
+
+    return hash_map;
+}
+
+void hm_destroy(hm_t* hm){
+
+
+    for (int i= 0;i< hm->length;i++){
+
+        hm_t* current_entry = hm->entries[i]; 
+
+        while(current_entry != NULL){
+
+            current_entry = hm->entries[i];
+            free(current_entry);
+        }
+    }
+
+    free(hm->entries);
+
+    free(hm);
+
+}
+
+void hm_set(hm_t* hm, char* key, char* value){
+
+    
+}
+
+
+char* hm_get(hm_t* hm, char* key){
+
+    int index = hash(key,hm->length);
+
+    for (int i ?=)
+    hm_t* current_entry = hm->entries[i]; 
+    
+}
+
+
+
+
+
+
+
+int main (){
+
+    int capacity = 100; // Capacité de la table de hachage
+    
+    // Création d'une nouvelle table de hachage
+    hm_t* hash_map = hm_create(capacity);
+
+    // Utilisation de la table de hachage...
+
+    // Libération de la mémoire allouée pour la table de hachage lorsque vous avez terminé
+    free(hash_map);
+
+    return 0;
+
+}
\ No newline at end of file

TP/TP18/hash.h

+
+typedef struct {
+    struct entry_t **entries;
+    int length;
+} hm_t;
+
+typedef struct entry_t {
+    char *key;
+    char *value;
+    struct entry_t *next;
+}entry_t;
+
+// création d'un pointeur vers une hm
+hm_t* hm_create(int capacity);
+// destruction de la hm et libération de la mémoire
+void hm_destroy(hm_t* hm);
+// insère la paire key-value dans la hm. si key est déjà présente
+// écraser value dans la hm. La clé et la valeur sont stockées
+// dans de nouveau espaces mémoires alloués par la fonction
+
+void hm_set(hm_t* hm, char* key, char* value);
+// retourne la valeur associé à la clé, key
+// dans un espace mémoire alloué à strcet effet
+char* hm_get_alloc(hm_t* hm, char* key);
+// retourne la valeur associé à la clé, key
+// retourne le pointeur dans la structure hm_t
+char* hm_get(hm_t* hm, char* key);
+// retire une clé de la hm
+void hm_rm(hm_t* hm, char* key);
+// teste si une clé se trouve dans la hm
+bool hm_is_present(hm_t* hm, char* key);
+// affiche le contenu de la hm
+void hm_print(hm_t* hm);
+// sauvegarde les pairs clé-valeur contenues de la table de hachage dans un fichier texte
+// au format <key>;<value>
+void hm_save(hm_t *hm, char *filename);
+// charge les pairs clé-valeur dans une table de hachage depuis les
+// lignes d'un fichier texte dont le format est <key>;<value>
+hm_t *hm_load(char *filename);
\ No newline at end of file