fin TD4

README.md

@@ -0,0 +1,52 @@
+# Ex2 - Calculs de complexité de fonctions
+
+Complexité algorithmique : 
+- fonction_1 : O(n*m)<br>
+Cette fonction contient des boucles imbriquées. Dans le pire des cas, il faudra parcourir n x m.
+- fonction_2 : O(n) <br>
+La boucle while s'exécute au maximum n fois.
+- fonction_3 : O(1)<br>
+Cette fonction ne contient pas de boucle. Chaque condition est évaluée une seule fois, indépendamment de la taille des données d'entrée.
+
+# Ex3 - student_rank.c
+
+
+```
+void sort_students(int** students_rank, int** students_array, int students_number, int grades_number)
+{
+    int i = 0, j = 0;
+    for(i = 0; i < grades_number; i++)
+    {
+        int * grades = (int*) malloc(students_number*sizeof(int));
+	for(j = 0; j < students_number; j++)
+	{
+	    grades[j] = students_array[j][i];
+	}
+        bubblesort(grades,students_number);
+	for(j = 0; j < students_number; j++)
+	{
+            students_rank[j][i] = find_rank_student(students_array[j][i],grades,students_number);
+	}
+	free(grades);
+    }
+}
+```
+
+1. La boucle externe s'exécute m fois, où m représente grades_number La complexité est donc O(m).
+2. La copie des notes prend O(n),où n est le nombre d'étudiants.
+3. Le tri bublesort a une complexité de O(n²) 
+4. find_rank_student la complexité de cette étape est dominée par le tri des étudiants bubblesort donc O(n²).
+
+À chaque itération (pour chaque groupe de notes m), les opérations dominantes sont le tri des n étudiants avec une complexité de O(n²) ainsi la complexité totale est O(m*n²).
+
+## Ex4 - Algorithme de tri
+
+### 1. Tri des sous-listes :
+Si une sous-liste a une taille de m, la complexité du tri de cette sous-liste est O(m²) car l'algorithme de tri parcourt la sous-liste m et, à chaque fois, il effectue m-1 comparaisons.
+il y a n sous-listes au total. Donc, la complexité totale du tri des sous-listes est O(n*m²).
+
+### 2. Tri liste principale
+À chaque itération, nous comparons les sommes des sous-listes. Calculer la somme des éléments d'une sous-liste prend O(m) temps (car la somme des m éléments de la sous-liste doit être calculée).
+Donc, pour chaque comparaison, la complexité est O(m) (pour calculer la somme), et il y a O(n²) comparaisons au total dans le tri à bulle de la liste principale. La complexité du tri de la liste principale est donc O(n²*m)
+
+Donc, la complexité totale est O( n*m² + n²\*m )

sorting.py

@@ -0,0 +1,19 @@
+def sorting(array):
+    for sublist in array:
+        for i in range(len(sublist)):
+            for j in range(len(sublist) - i - 1):
+                if sublist[j] > sublist[j + 1]:
+                    sublist[j], sublist[j + 1] = sublist[j + 1], sublist[j]
+
+    for i in range(len(array)):
+        for j in range(len(array) - i - 1):
+            sum_i = sum(array[j])
+            sum_j = sum(array[j + 1])
+            if sum_i > sum_j:
+                array[j], array[j + 1] = array[j + 1], array[j]
+                
+    return array
+
+array = [[0, 3, 2], [9, 4, 5], [4, 1, 3]]
+sorted_array = sorting(array)
+print(sorted_array)