Exercice 1

1. function_1(tableau1, tableau2) :
   Dans cette fonction, il y a deux boucles imbriquées : la première parcourt tous les éléments de tableau1 (de taille n), et pour chaque élément, la deuxième boucle parcourt tableau2 (de taille m).
   Dans le pire des cas, si aucun élément ne correspond (ou si le break n'est jamais atteint), chaque élément de tableau1 sera comparé à tous les éléments de tableau2.
   Donc, la complexité de cette fonction est O(n \cdot m).

2. function_2(x) :
   Ici, on a une boucle while qui s’exécute x fois. À chaque itération, on effectue une addition et une décrémentation, qui prennent toutes les deux un temps constant.
   Du coup, la complexité est proportionnelle à x, donc O(x).

3. function_3(x) :
   Cette fonction contient uniquement des blocs if indépendants, qui s’exécutent chacun au maximum une seule fois. Il n’y a pas de boucle, donc chaque opération est constante.
   La complexité est donc O(1), car c’est constant peu importe la valeur de x.

---

Exercice 2

Pour analyser la complexité de la fonction sort_students, on décompose chaque étape :

1. Boucle externe sur les grades :
   La boucle externe parcourt tous les grades des étudiants, soit \text{grades\_number} itérations.

2. Allocation dynamique des notes :
   L’allocation du tableau grades est faite avec malloc, qui est supposée avoir une complexité O(1). Cela n’affecte donc pas significativement la complexité globale.

3. Copie des notes des étudiants :
   Dans la boucle interne :

   for(j = 0; j < students_number; j++) {
       grades[j] = students_array[j][i];
   }
   

   on copie les notes des \text{students\_number} étudiants, ce qui prend O(\text{students\_number}) par itération de la boucle externe.

4. Tri des notes avec bubblesort :
   La fonction bubblesort trie un tableau de taille \text{students\_number}, avec une complexité O(\text{students\_number}^2).

5. Trouver le rang de chaque étudiant :
   Ensuite, dans cette boucle interne :

   for(j = 0; j < students_number; j++) {
       students_rank[j][i] = find_rank_student(students_array[j][i], grades, students_number);
   }
   

   on appelle find_rank_student pour chaque étudiant. Cette fonction effectue :

   • Un tri par bulles O(\text{students\_number}^2),
   • Une recherche pour trouver le rang, qui prend O(\text{students\_number}).

   Donc, chaque appel à find_rank_student a une complexité totale de O(\text{students\_number}^2), et cette fonction est appelée \text{students\_number} fois par itération de la boucle externe. Cela donne une complexité O(\text{students\_number}^3) par itération de la boucle externe.

6. Libération de mémoire :
   Enfin, la mémoire allouée pour grades est libérée avec free, ce qui est une opération O(1).

Complexité totale :

La boucle externe s’exécute \text{grades\_number} fois, et la partie la plus coûteuse de la boucle interne est O(\text{students\_number}^3). La complexité globale de la fonction est donc :

O(\text{grades\_number} \cdot \text{students\_number}^3)

Conclusion :

La fonction sort_students a une complexité algorithmique de ( O(\text{grades_number} \cdot \text{students_number}^3) ).

---

Exercice 3

Algorithme proposé

Pour trier un tableau à ( N )-dimensions avec M valeurs par dimension, voici l'algo.

Étapes de l’algorithme :

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.

Implémentation en Python

Voici l’algorithme en code :

def recursive_sort(T):
    # Si c'est un tableau 1D, on le trie directement
    if not isinstance(T[0], list):
        return sorted(T)
    
    # Sinon, on trie chaque sous-dimension récursivement
    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))
    return T

# Exemple avec un tableau 2D
tableau = [[0, 3, 2], [9, 4, 5], [4, 1, 3]]
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é :

 [ [0, 3, 2], [9, 4, 5], [4, 1, 3] ] 

1. Trier chaque ligne individuellement :

   
   [ [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

3. Trier les lignes en fonction de leurs sommes :

   
   [ [0, 2, 3], [1, 3, 4], [4, 5, 9] ]
   

Complexité de l’algorithme

Analyse :

1. Pour la dimension la plus basse (1D) :

   • Trier M éléments coûte O(M \log M).

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).

3. Récursivité sur N dimensions :

   • La complexité totale est donnée par la somme :

     
     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)
     

Conclusion

• • La complexité globale est [ O(M^N \log M) ]