Merge pull request #39 from JulesFouchy/S2_TD5

S2 TD5

Author: dsmtE

content/TDs/S2/05_hashAndAssociativeTables.md

@@ -4,7 +4,7 @@ title: TD5 - Hachage et tableaux associatifs
 
 Dans ce TD nous allons mettre en pratique les notions vues en cours sur les tables de hachage et les tables associatives.
 
-## Exercice 1 (fonction de hachage)
+## Exercice 1 (Fonction de hachage)
 
 1. Écrire une fonction de hachage qui prend en paramètre une chaîne de caractères, fait la somme des valeurs ASCII des caractères et renvoie un entier compris entre 0 et un maximum donné nommé `max` (le type de retour du hash doit être `size_t`).
 > Nous utiliserons une simple somme des codes ASCII des caractères suivie d'un modulo pour obtenir un entier compris entre 0 et `max`.
@@ -13,14 +13,14 @@ size_t folding_string_hash(std::string const& s, size_t max);
 ```
 
 > $$
-> \text{hash}(s) = \sum_{i=0}^{n-1} (s[i] \mod m)
+> \text{hash}(s) = (\sum_{i=0}^{n-1} s[i]) \mod m
 > $$
 > Avec:
 > - $s$ la chaîne de caractères
 > - $n$ la taille de la chaîne de caractères
 > - $s[i]$ le code ASCII du caractère à l'index $i$ dans la chaîne de caractères
 
-Ce que nous venons de faire s'appel la technique dite de **folding** (pliage en français). Cela consiste à découper notre donnée en plusieurs parties, calculer une valeur(hash) pour chacune de ces parties, sommer ces valeurs et enfin appliquer un modulo pour obtenir un entier compris entre 0 et `max`.  Ici on traite une chaîne de caractère, on va donc faire la somme des valeurs de hachage de chaque caractère.
+Ce que nous venons de faire s'appelle la technique dite de **folding** (pliage en français). Cela consiste à découper notre donnée en plusieurs parties, calculer une valeur (hash) pour chacune de ces parties, sommer ces valeurs et enfin appliquer un modulo pour obtenir un entier compris entre 0 et `max`.  Ici on traite une chaîne de caractère, on va donc faire la somme des valeurs de hachage de chaque caractère.
 
 :::info
 On veux se ramener à un entier compris entre 0 et `max` car cette valeur hachée sert généralement d'index dans un tableau (table de hachage). Hors on souhaite un tableau de taille "raisonnable" en mémoire, donc on limite la taille de ce tableau à `max`.
@@ -34,7 +34,7 @@ size_t folding_string_ordered_hash(std::string const& s, size_t max);
 ```
 
 > $$
-> \text{hash}(s) = \sum_{i=0}^{n-1} ((s[i] * (i+1)) \mod m)
+> \text{hash}(s) = (\sum_{i=0}^{n-1} s[i] \times (i+1)) \mod m
 > $$
 >
 > Ici j'utilise `i+1` pour éviter que la position 0 (le 1er caractère)  ne soit pas prise en compte dans le calcul du hash car multipliée par 0.
@@ -43,21 +43,21 @@ size_t folding_string_ordered_hash(std::string const& s, size_t max);
 
 > Voila le prototype de la fonction à écrire:
 ```cpp
-size_t polynomial_rolling_hash(const std::string& s, size_t p, size_t m);
+size_t polynomial_rolling_hash(std::string const& s, size_t p, size_t m);
 ```
 
 > Nous allons utiliser la technique dite de **polynomial rolling hash**. Cette technique consiste à calculer le hash d'une chaîne de caractères en incorporant la position d'une manière plus complexe pour éviter les collisions. On va donc multiplier la valeur de chaque caractère par une puissance de `p` qui dépend de la position du caractère dans la chaîne de caractères.
 > Pour cela, nous allons utiliser la formule suivante:
 > $$
-> \text{hash}(s) = \sum_{i=0}^{n-1} ((s[i] \times p^i) \mod m)
+> \text{hash}(s) = (\sum_{i=0}^{n-1} s[i] \times p^i) \mod m
 > $$
 >
 > Avec:
 > - $p$ un nombre (généralement un nombre premier)
 > - $m$ un nombre (généralement une puissance de 2)
 
 :::warning
-On ne veux pas utiliser la fonction [`std::pow`](https://en.cppreference.com/w/c/numeric/math/pow) de la bibliothèque standard car elle est "lente" est fonctionne avec des **flottants** (ce qui nous ferait faire des conversions inutiles).
+On ne veux pas utiliser la fonction [`std::pow`](https://en.cppreference.com/w/c/numeric/math/pow) de la bibliothèque standard car elle est "lente" et fonctionne avec des **flottants** (ce qui nous ferait faire des conversions inutiles).
 
 De plus on ne veux pas recalculer la puissance de `p` à chaque itération car c'est des calculs inutiles. Admettons qu'il faille $n-1$ multiplications pour calculer $p^n$ ($p \times p \times p = p^3$) et que l'on recalculait à chaque fois la puissance. Pour une chaîne de taille $n$ on ferait donc $1 + 2 + \ldots + (n-2) + (n-1)$ multiplications. On peut simplifier cette somme en $n(n-1)/2$ ce qui est de l'ordre de $n^2$ multiplications. On veut éviter ça.
 
@@ -66,7 +66,7 @@ On va donc utiliser une variable `power` (initialisée à 1 au début) et multip
 :::
 
 :::tip choix de `p` et `m`
-Le choix de `p` et `m` va influencer la qualité (collision) et les performances de notre fonction de hachage. Sans rentrer dans les détails, on choisit généralement `p` un **nombre premier** et `m` un nombre suffisamment grand pour éviter les collisions tout en restant petit pour rester performant et éviter des erreur numériques. Par exemple, on peut choisir `p` = **31** et `m` = **10^9 + 9** (que l'on peut noter `1e9 + 9` en C++ ou tout simplement `1000000009`).
+Le choix de `p` et `m` va influencer la qualité (probabilité de collision) et les performances de notre fonction de hachage. Sans rentrer dans les détails, on choisit généralement `p` un **nombre premier** et `m` un nombre suffisamment grand pour éviter les collisions tout en restant petit pour rester performant et éviter des erreur numériques. Par exemple, on peut choisir `p` = **31** et `m` = **10^9 + 9** (que l'on peut noter `1e9 + 9` en C++ ou tout simplement `1000000009`).
 :::
 
 ## Exercice 2 (Analyse du nombre d'insectes)
@@ -95,7 +95,7 @@ enum class Insect {
 Je vous fournis également une liste des valeurs de l'énumération `Insect` sous forme de vecteur (pour pouvoir itérer sur les valeurs de l'énumération et éviter de faire des `static_cast` pour obtenir les valeurs de l'énumération à partir d'un entier (index) ou encore avoir le nombre d'éléments de l'énumération). Rappels sur les cast avec enum [ici](/Lessons/S1/Variables/#cast-et-enum).
 ```cpp
 #include <vector>
-const std::vector<Insect> insect_values {
+std::vector<Insect> const insect_values {
     Insect::ClassicBee,
     Insect::Ladybug,
     Insect::Butterfly,
@@ -118,7 +118,7 @@ Il n'existe pas de fonction dans la bibliothèque standard C++ pour obtenir le n
 #include <unordered_map>
 #include <string>
 
-const std::unordered_map<Insect, std::string> insect_to_string = {
+std::unordered_map<Insect, std::string> const insect_to_string = {
     {Insect::ClassicBee, "ClassicBee"},
     {Insect::Ladybug, "Ladybug"},
     {Insect::Butterfly, "Butterfly"},
@@ -138,7 +138,7 @@ Cette liste se présente sous forme d'un vecteur avec les nombres d'individus at
 
 ```cpp
 #include <vector>
-const std::vector<int> expected_insect_counts {
+std::vector<int> const expected_insect_counts {
     75, // ClassicBee
     50, // Ladybug
     100, // Butterfly
@@ -166,25 +166,25 @@ Voilà une fonction qui génère une liste d'observations aléatoires pour simul
 #include <iterator>
 
 std::vector<std::pair<Insect, int>> get_insect_observations(
-    const size_t number_of_observations,
+    size_t const number_of_observations,
     std::vector<float> const& insect_probabilities,
-    const unsigned int seed = std::random_device{}()) {
+    unsigned int const seed = std::random_device{}()
+) {
     // Create a random engine with a given seed
-    std::default_random_engine random_engine(seed);
+    std::default_random_engine random_engine{seed};
 
-    auto randInsectIndex { std::bind(std::discrete_distribution<size_t>{insect_probabilities.begin(), insect_probabilities.end()}, random_engine) };
+    auto rand_insect_index { std::bind(std::discrete_distribution<size_t>{insect_probabilities.begin(), insect_probabilities.end()}, random_engine) };
 
     std::vector<std::pair<Insect, int>> observations {};
     observations.reserve(number_of_observations);
 
     for(size_t i {0}; i < number_of_observations; ++i) {
-        size_t const random_insect_index { randInsectIndex() };
+        size_t const random_insect_index { rand_insect_index() };
         Insect const random_insect { insect_values[random_insect_index] };
         
-        //If we have already seen the same insect, increment the count on the last observation
-        auto& previous_observation { observations.back() };
-        if(previous_observation.first == random_insect) {
-            previous_observation.second++;
+        // If we have already seen the same insect, increment the count on the last observation
+        if(!observations.empty() && observations.back().first == random_insect) {
+            observations.back().second++;
             i -= 1;
         } else {
             observations.push_back({random_insect, 1});
@@ -202,7 +202,7 @@ On utilisera la valeur de l'énumération `Insect` comme **clé** dans la table
 :::
 
 :::info
-Le paramètre `seed` de la fonction `get_insect_observations` permet de fixer la graine du générateur de nombres aléatoires. Cela permet de reproduire les mêmes observations à chaque exécution du programme. Si vous ne spécifiez pas de graine, le générateur de nombres aléatoires utilisera une graine aléatoire à chaque exécution du programme sinon vous pouvez le fixer à une valeur de votre choix pour obtenir les mêmes observations à chaque exécution.
+Le paramètre `seed` de la fonction `get_insect_observations` permet de fixer la graine du générateur de nombres aléatoires. Cela permet de reproduire les mêmes observations à chaque exécution du programme. Si vous ne spécifiez pas de graine, le générateur de nombres aléatoires utilisera une graine aléatoire à chaque exécution du programme.
 :::
 
 3. Utiliser de nouveau la fonction `probabilities_from_count` pour obtenir les probabilités des insectes observés. Il faudra au préalable convertir le résultat de la table de hachage en un vecteur de comptage pour pouvoir utiliser la fonction `probabilities_from_count`.
@@ -228,7 +228,7 @@ Vous pouvez utiliser l'include `<iomanip>` pour formater l'affichage des nombres
 Ajouter `std::cout << std::fixed << std::setprecision(3);` avant d'afficher les nombres pour afficher les nombres avec 3 chiffres après la virgule.
 :::
 
-## Exercice 3 (hash sur une structure)
+## Exercice 3 (Hash sur une structure)
 
 Donnons nous les enums et structures suivantes:
 
@@ -264,7 +264,7 @@ struct Card {
 
 L'idée de cet exercice est de créer une fonction de hachage pour la structure `Card` pour que l'on puisse utiliser cette structure comme clé dans une table de hachage.
 
-la bibliothèque standard C++ fournit une fonction de hachage pour les types de base (entiers, flottants, etc.) et les chaînes de caractères. Mais elle ne fournit pas de fonction de hachage pour nos structures.
+La bibliothèque standard C++ fournit une fonction de hachage pour les types de base (entiers, flottants, etc.) et les chaînes de caractères. Mais elle ne fournit pas de fonction de hachage pour nos structures.
 
 De la même façon que l'on a surchargé les opérateurs pour nos structures, on va pouvoir surcharger la fonction de hachage de notre structure.
 
@@ -330,11 +330,11 @@ std::string card_name(Card const& card) {
     unsigned int card_value {(static_cast<unsigned int>(card.value)+2) % 14};
 
     if (card_value < 10) {
-        name += '0' + card_value;
+        name += '0' + std::to_string(card_value);
     }else if (card_value == 10) {
         name += "10";
     }else if (card_value == 11) {
-        name += 'V';
+        name += 'J';
     }else if (card_value == 12) {
         name += 'Q';
     }else if (card_value == 13) {