readme

README.md

@@ -1,35 +1,63 @@
-# RAPPORT 
+# RAPPORT
 
 ## EXO2
 
-- function_1(tableau1, tableau2) : complexité alogithmique est égale à : O(n*m) dans le pire cas ou n est la taille du tableau 1 et m la taille du tableau 2.
-- function_2(x) : compléxité algorithmique est égale a : O(x) car la boucle while fait x itération et car x est décrémenter de 1 jusqu'a 0.
-- function_3(x) : cette fois ci la compléxité algorithmique est égale a : O(1) car en fonction de la valeur de x uniquement une des trois conditions qui effectue une opération simple.
+- **function_1(tableau1, tableau2)** :  
+  - **Complexité algorithmique** : O(n * m)  
+    - Dans le pire cas, où `n` est la taille du tableau 1 et `m` la taille du tableau 2.
 
-## EXO3 
+- **function_2(x)** :  
+  - **Complexité algorithmique** : O(x)  
+    - La boucle `while` fait `x` itérations, et `x` est décrémentée de 1 jusqu'à 0.
 
-Pour cette fonction on a : 
+- **function_3(x)** :  
+  - **Complexité algorithmique** : O(1)  
+    - En fonction de la valeur de `x`, une des trois conditions exécute une opération simple.
 
-- la premiere boucle for : O(g)
-- ensuite malloc : O(1)
-- deuxieme boucle for : O(g*n)
-- bubblesort : O(g*n²)
-- free : O(1)
-- find_rank_student : O(g*n²) de bubblesort + O(g*n) : O(g*n^3)
+---
 
+## EXO3
 
-simplification :
+Pour cette fonction, on a :
 
-- on peut enlever les O(1) et on garde la complexité la plus élévé donc O(g*n^3) 
+- **La première boucle for** : O(g)
+- **Malloc** : O(1)
+- **Deuxième boucle for** : O(g * n)
+- **Bubblesort** : O(g * n²)
+- **Free** : O(1)
+- **find_rank_student** : O(g * n²) pour Bubblesort + O(g * n) : O(g * n^3)
 
-Cela fait pour la compléxité algorithmique de sort_student : O(g*n^3)
+**Simplification :**
+- On peut enlever les O(1) et conserver la complexité la plus élevée, donc O(g * n^3).
 
+**Complexité algorithmique pour sort_student :** O(g * n^3)
+
+---
 
 ## EXO4
 
-compléxité algorithmique de ma fonction tri() :
-- pour m éléments dans chaque sous-liste n, alors la compléxité algorithmique de sort() est O(m log m) pour n sous liste on a O(n * m log m)
+Voici le code :
 
-- pour le tri la complexité algorithmique est O(n²)
+```python
+def tri(t):
+    for tab in t:
+        for i in range(len(tab)):
+            for j in range(len(tab) - 1):
+                if tab[j] > tab[j + 1]:
+                    tab[j], tab[j + 1] = tab[j + 1], tab[j]
+    
+    for i in range(len(t)):
+        for j in range(len(t) - 1):
+            if t[j][0] > t[j + 1][0]:
+                t[j], t[j + 1] = t[j + 1], t[j]
+    
+    print(t)
 
-on prend la plus elevé et donc on pour ma fonction O(n²)
+tri([[3, 9, 6], [9, 3, 8], [10, 67, 55]])
+
+Complexité algorithmique de ma fonction tri() :
+
+   - Pour m éléments, la complexité algorithmique de chaque sous-liste est O(m²), multipliée par le nombre de sous-listes, cela fait : O(n * m²).
+   - Pour le tri final, la complexité algorithmique est O(n²).
+
+On garde la plus élevée, donc pour ma fonction : O(n * m²) + O(n²).

tri.py

@@ -1,12 +1,14 @@
 def tri(t):
-    # Trier chaque sous-liste individuellement
     for tab in t:
-        tab.sort()
+        for i in range(len(tab)):
+            for j in range(len(tab) - 1):
+                if tab[j] > tab[j + 1]:
+                    tab[j], tab[j + 1] = tab[j + 1], tab[j]
     
     for i in range(len(t)):
-        for j in range(i + 1, len(t)):
-            if t[i][0] > t[j][0]:
-                t[i], t[j] = t[j], t[i]
+        for j in range(len(t) - 1):
+            if t[j][0] > t[j + 1][0]:
+                t[j], t[j + 1] = t[j + 1], t[j]
     
     print(t)