diff --git a/Readme.md b/Readme.md
index 9639650..6c4a439 100644
--- a/Readme.md
+++ b/Readme.md
@@ -71,35 +71,68 @@ O(\text{grades\_number} \cdot \text{students\_number}^3)
 
 #### **Exercice 3**
 
+Voici ma réponse reformulée comme si j'étais un étudiant :
+
+---
+
 ### **Algorithme proposé**
 
-Pour trier un tableau à \( N \)-dimensions avec \( M \) valeurs par dimension, voici l'algo. 
+1. **Tri des sous-dimensions** :  
+   - Si on est sur un tableau 1D (le plus bas niveau), on le trie avec un tri par insertion.
 
-#### Étapes de l’algorithme :
+2. **Calcul des sommes des sous-dimensions** :  
+   - Pour chaque sous-tableau, on calcule la somme des valeurs pour s’en servir comme critère de tri.
 
-1. Si on est au niveau d’un tableau 1D (dimension la plus basse), on le trie directement.
-2. Sinon :
-   - Trier chaque sous-dimension récursivement.
-   - Calculer la somme des valeurs de chaque sous-dimension.
-   - Trier les sous-dimensions en fonction de leurs sommes.
+3. **Tri des sous-dimensions par leurs sommes** :  
+   - On trie les sous-dimensions avec un tri par insertion basé sur les sommes calculées.
 
+4. **Répétition pour les autres dimensions** :  
+   - On applique ces étapes de façon récursive à chaque niveau du tableau.
 
-### **Implémentation en Python**
+---
 
-Voici l’algorithme en code :
+### **Implémentation**
+
+Voici l'algorithme en Python :
 
 ```python
+# Fonction pour trier un tableau 1D avec un tri par insertion
+def insertion_sort(arr):
+    for i in range(1, len(arr)):
+        key = arr[i]
+        j = i - 1
+        # Déplacement des éléments plus grands que key
+        while j >= 0 and arr[j] > key:
+            arr[j + 1] = arr[j]
+            j -= 1
+        arr[j + 1] = key
+
+# Fonction pour trier un tableau multidimensionnel récursivement
 def recursive_sort(T):
-    # Si c'est un tableau 1D, on le trie directement
+    # Si c'est un tableau 1D, on le trie
     if not isinstance(T[0], list):
-        return sorted(T)
+        insertion_sort(T)
+        return T
     
-    # Sinon, on trie chaque sous-dimension récursivement
+    # Trier chaque sous-dimension
     for i in range(len(T)):
         T[i] = recursive_sort(T[i])
     
-    # Puis on trie le tableau actuel selon la somme des sous-dimensions
-    T.sort(key=lambda x: sum(sum(val) if isinstance(val, list) else val for val in x))
+    # Calculer les sommes des sous-dimensions
+    sums = [sum(sum(val) if isinstance(val, list) else val for val in sublist) for sublist in T]
+    
+    # Trier les sous-dimensions en fonction de leurs sommes
+    for i in range(1, len(T)):
+        key_sum = sums[i]
+        key_sublist = T[i]
+        j = i - 1
+        while j >= 0 and sums[j] > key_sum:
+            sums[j + 1] = sums[j]
+            T[j + 1] = T[j]
+            j -= 1
+        sums[j + 1] = key_sum
+        T[j + 1] = key_sublist
+
     return T
 
 # Exemple avec un tableau 2D
@@ -108,55 +141,57 @@ resultat = recursive_sort(tableau)
 print(resultat)  # Résultat attendu : [[0, 2, 3], [1, 3, 4], [4, 5, 9]]
 ```
 
+---
 
 ### **Exemple d’exécution**
 
-Pour le tableau donné :  
+Prenons le tableau suivant :  
 \[ [ [0, 3, 2], [9, 4, 5], [4, 1, 3] ] \]
 
-1. **Trier chaque ligne individuellement** :  
+1. **Trier chaque ligne** :  
+   - Première ligne : \( [0, 3, 2] \rightarrow [0, 2, 3] \)  
+   - Deuxième ligne : \( [9, 4, 5] \rightarrow [4, 5, 9] \)  
+   - Troisième ligne : \( [4, 1, 3] \rightarrow [1, 3, 4] \)  
    \[
    [ [0, 2, 3], [4, 5, 9], [1, 3, 4] ]
    \]
 
-2. **Calculer la somme des valeurs pour chaque ligne** :  
-   - Première ligne : \( 0 + 2 + 3 = 5 \)  
-   - Deuxième ligne : \( 4 + 5 + 9 = 18 \)  
-   - Troisième ligne : \( 1 + 3 + 4 = 8 \)  
+2. **Calculer les sommes** :  
+   - \( [0, 2, 3] \rightarrow 5 \)  
+   - \( [4, 5, 9] \rightarrow 18 \)  
+   - \( [1, 3, 4] \rightarrow 8 \)  
 
-3. **Trier les lignes en fonction de leurs sommes** :  
+3. **Trier les lignes en fonction des sommes** :  
    \[
    [ [0, 2, 3], [1, 3, 4], [4, 5, 9] ]
    \]
 
+---
 
-### **Complexité de l’algorithme**
+### **Complexité**
 
 #### Analyse :
 
-1. **Pour la dimension la plus basse (1D)** :  
-   - Trier \( M \) éléments coûte \( O(M \log M) \).  
+1. **Tri des tableaux 1D** :  
+   - Pour \( M \) éléments, le tri par insertion a une complexité de \( O(M^2) \).
 
-2. **Pour les dimensions supérieures (\( N > 1 \))** :  
-   - Chaque dimension contient \( M^{N-1} \) sous-tableaux.
-   - Trier ces sous-tableaux coûte \( O(M^{N-1} \log M^{N-1}) \).
-   - Calculer les sommes pour ces sous-tableaux prend \( O(M^N) \).
+2. **Tri des sous-tableaux (dimensions \( N > 1 \))** :  
+   - Chaque sous-tableau contient \( M^{N-1} \) éléments. Trier ces sous-tableaux coûte \( O(M^{N-1} \cdot M^{N-1}) = O(M^{2(N-1)}) \).
 
-3. **Récursivité sur \( N \) dimensions** :  
-   - La complexité totale est donnée par la somme :  
+3. **Calcul des sommes** :  
+   - Calculer les sommes pour \( M^{N-1} \) sous-tableaux coûte \( O(M^N) \).
+
+4. **Complexité totale** :  
+   - L'algorithme s’applique de façon récursive sur \( N \) dimensions. La partie dominante vient du tri des sous-tableaux les plus grands :  
      \[
-     T(N, M) = O(M^N \log M + M^{N-1} \log M^{N-1} + \dots + M \log M)
-     \]
-   - La partie dominante est celle de la dimension principale :  
-     \[
-     T(N, M) = O(M^N \log M)
+     T(N, M) = O(M^{2N-2})
      \]
 
+---
 
 ### **Conclusion**
 
-- - La complexité globale est 
+La complexité globale est 
      \[
-     O(M^N \log M)
+     O(M^{2N-2})
      \]
-