Ajout de l'exercice 4

rapport.md

@@ -26,4 +26,23 @@ Nous retrouvons une dernière boucle qui va itérer sur `students_number`, donc
 Cette fonction appelle la fonction `bubble_sort` avec le tableau `grades_array` et `students_number` comme arguments. `bubble_sort` qui est une fonction de tri, où dans le pire des cas, la complexité est de `O(m^2)`. Ensuite, nous avons une boucle qui va itérer sur `students_number`, donc la complexité de cette boucle est de `O(m)`. Donc la complexité globale de la fonction `find_rank_student` est de `O(m^2 + m) = O(m^2)`.
 
 ### Fonction `sort_students` :
-La complexité de la fonction `find_rank_student` est de `O(m^2)`, et nous l'appelons `m` fois, donc la complexité globale de la fonction `sort_students` est de `O(n * m^2 + m * m^2) = O(n * m^2 + m^3) = O(n*m^3)`.
+La complexité de la fonction `find_rank_student` est de `O(m^2)`, et nous l'appelons `m` fois, donc la complexité globale de la fonction `sort_students` est de `O(n * m^2 + m * m^2) = O(n * m^2 + m^3) = O(n*m^3)`.
+
+# Exercice 4)
+Code python : [sortarray.py](sortarray.py) 
+
+### Tri interne :
+Pour chaque sous-liste de `M` valeurs dans le tableau, nous utilisons le tri par sélection :
+<br>
+Le tri par sélection parcourt la liste pour trouver le minimum et l'échange avec le premier élément. Ensuite, il répète cela pour les éléments restants.
+<br>
+Si nous avons `N` sous-listes de `M` valeurs, la complexité de l'algorithme est de `O(N*M^2)`.
+
+### Tri externe :
+Pour trier les `N` sous-listes en fonction de leurs sommes, nous utilisons un algorithme similaire au tri par sélection sur les sous-listes. Nous avons donc une complexité de `O(N^2)`.
+
+### Calcul des sommes :
+Avant de comparer les sous-listes dans le tri externe, il faut calculer la somme de chaque sous-liste. Chaque somme nécessite `M` opérations, et il y a `N` sous-listes. Donc, le coût total pour calculer les sommes est de `O(N*M)`.
+
+### Complexité totale :
+La complexité totale dépend de la relation entre `N` et `M`. Si `N` est beaucoup plus grand que `M`, la complexité de l'algorithme est dominée par le tri externe, donc la complexité totale est de `O(N^2)`. Si `M` est beaucoup plus grand que `N`, la complexité de l'algorithme est dominée par le tri interne, donc la complexité totale est de `O(N*M^2)`. Si `N` et `M` sont de même ordre de grandeur, la complexité totale est de `O(N*M^2 + N^2 + N*M)`.

sortarray.py

@@ -0,0 +1,31 @@
+def sort_array(array):
+    def selection_sort(lst):
+        n = len(lst)
+        for i in range(n):
+            min_idx = i
+            for j in range(i+1, n):
+                if lst[j] < lst[min_idx]:
+                    min_idx = j
+            lst[i], lst[min_idx] = lst[min_idx], lst[i]
+        return lst
+
+    for i in range(len(array)):
+        array[i] = selection_sort(array[i])
+
+    n = len(array)
+    for i in range(n):
+        for j in range(i+1, n):
+            if sum(array[i]) > sum(array[j]):
+                array[i], array[j] = array[j], array[i]
+
+    return array
+
+# Test
+array = [
+    [0, 3, 2],
+    [9, 4, 5],
+    [4, 1, 3]
+]
+
+sorted_array = sort_array(array)
+print("Tableau trié :", sorted_array)