diff --git a/Ex3_Trie_Tableau_Double.py b/Ex3_Trie_Tableau_Double.py
new file mode 100644
index 0000000..a36c42c
--- /dev/null
+++ b/Ex3_Trie_Tableau_Double.py
@@ -0,0 +1,64 @@
+
+def Trie_Tableau_Double(tab) : # complexitée O(n(m²+n))
+    sorted_dico = {}
+
+    print(tab[0])
+
+            # n^(m+m*((m(m+1))/2))+n((m(m+1))/2)
+
+    for sub_tab in tab :                                    # n
+        val = 0
+        sub_tab2 = []
+        for elt in sub_tab :                                # m
+            val += elt
+
+        for i in range(len(sub_tab)):                       # m
+            if i == 0 :
+                sub_tab2.append(sub_tab[i])
+            else : 
+                for j in range(len(sub_tab2)+1):            # (m(m+1))/2
+                    if j >= len(sub_tab2):
+                        sub_tab2.append(sub_tab[i])
+                    else : 
+                        if sub_tab[i] <= sub_tab2[j] :
+                            sub_tab2.insert(j,sub_tab[i])
+                            break
+        
+        sorted_dico[val] = sub_tab2
+    
+    tab = []
+    index_tab = []
+
+            # n*(m(m+1))/2
+
+    for clef,valeur in sorted_dico.items() :                # n
+        if index_tab == [] :
+            tab.append(valeur)
+            index_tab.append(clef)
+        else : 
+            for j in range(len(index_tab)+1):               # (m(m+1))/2
+                    if j >= len(index_tab):
+                        tab.append(valeur)
+                        index_tab.append(clef)
+                    else : 
+                        if clef <= index_tab[j] :
+                            tab.insert(j,valeur)
+                            index_tab.insert(j,clef)
+                            break
+
+    return tab
+
+
+def Trie_Tableau_Double_bySort(tab) : # complexitée O(n*m * log(m))
+
+    tab.sort()                  # n log(n)
+
+    for sub_tab in tab :        # n
+        sub_tab.sort()          # m log(m)
+    
+    return tab
+
+
+Tableau_test = [[0,3,2], [9,4,5], [4,1,3]]
+
+print(Trie_Tableau_Double(Tableau_test))
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..09ad61b
--- /dev/null
+++ b/README.md
@@ -0,0 +1,104 @@
+# TD4 - DEV5.1 Qualité algorithmique
+Complexité algorithmique
+
+## Ex 2 - Calculs de complexité de fonctions
+Calculez la complexité des fonctions suivantes :
+![alt text](image/function_1.png)
+
+Ici on prend un tableau 1 contenant **n** valeurs et un tableau 2 contenant **m** valeurs.
+
+On parcour entièrement les deux pour savoir si une valeur ce trouve dans l'autre tableau.
+
+On a donc : 
+> O ( n x m ) 
+
+
+
+![alt text](image/function_2.png)
+
+Ici on prend un une variable x de valeur **n**.
+
+Tant que x est positif, on le décrémente pour arriver a 0 
+
+On a donc : 
+> O ( n ) ou O ( x )
+
+
+
+![alt text](image/function_3.png)
+
+Cette fonction n'a pas de boucle donc elle ne ce répète pas.
+
+On a donc : 
+> O ( 1 )
+
+## Ex 3 - Algorithme de tri
+- Créer un algorithme pour trier un tableau à N dimensions de M valeurs
+- Chaque dimension doit être trié par ordre croissant de la somme des valeurs de la
+dimension inférieur
+- Exemple pour un tableau à 2 dimensions de 3 valeurs
+[ [0,3,2], [9,4,5], [4,1,3] ] → [ [0,2,3], [1,3,4], [4,5,9] ]
+- Calculer la complexité algorithmique de l’algorithme écrit
+ * la complecitée de ce programme est de O(n(m²+n))
+```python
+def Trie_Tableau_Double(tab) : # complexitée O(n(m²+n))
+    sorted_dico = {}
+
+    print(tab[0])
+
+            # n^(m+m*((m(m+1))/2))+n((m(m+1))/2)
+
+    for sub_tab in tab :                                    # n
+        val = 0
+        sub_tab2 = []
+        for elt in sub_tab :                                # m
+            val += elt
+
+        for i in range(len(sub_tab)):                       # m
+            if i == 0 :
+                sub_tab2.append(sub_tab[i])
+            else : 
+                for j in range(len(sub_tab2)+1):            # (m(m+1))/2
+                    if j >= len(sub_tab2):
+                        sub_tab2.append(sub_tab[i])
+                    else : 
+                        if sub_tab[i] <= sub_tab2[j] :
+                            sub_tab2.insert(j,sub_tab[i])
+                            break
+        
+        sorted_dico[val] = sub_tab2
+    
+    tab = []
+    index_tab = []
+
+            # n*(m(m+1))/2
+
+    for clef,valeur in sorted_dico.items() :                # n
+        if index_tab == [] :
+            tab.append(valeur)
+            index_tab.append(clef)
+        else : 
+            for j in range(len(index_tab)+1):               # (m(m+1))/2
+                    if j >= len(index_tab):
+                        tab.append(valeur)
+                        index_tab.append(clef)
+                    else : 
+                        if clef <= index_tab[j] :
+                            tab.insert(j,valeur)
+                            index_tab.insert(j,clef)
+                            break
+
+    return tab
+```
+
+ * la complecitée de ce programme est de O(n*m * log(m))
+ ```python
+ def Trie_Tableau_Double_bySort(tab) : # complexitée O(n*m * log(m))
+
+    tab.sort()                  # n log(n)
+
+    for sub_tab in tab :        # n
+        sub_tab.sort()          # m log(m)
+    
+    return tab
+ ```
\ No newline at end of file
diff --git a/image/function_1.png b/image/function_1.png
new file mode 100644
index 0000000..18f5f93
Binary files /dev/null and b/image/function_1.png differ
diff --git a/image/function_2.png b/image/function_2.png
new file mode 100644
index 0000000..86c8646
Binary files /dev/null and b/image/function_2.png differ
diff --git a/image/function_3.png b/image/function_3.png
new file mode 100644
index 0000000..0c6bfb7
Binary files /dev/null and b/image/function_3.png differ