From 14803e0cbddc4b0aa8d3e0a09c9dc0bcd6ba84d5 Mon Sep 17 00:00:00 2001 From: Hugo DIMITRIJEVIC Date: Tue, 26 Nov 2024 11:30:37 +0100 Subject: [PATCH] Actualiser Readme.md --- Readme.md | 111 +++++++++++++++++++++++++++++++++++------------------- 1 file changed, 73 insertions(+), 38 deletions(-) diff --git a/Readme.md b/Readme.md index 9639650..6c4a439 100644 --- a/Readme.md +++ b/Readme.md @@ -71,35 +71,68 @@ O(\text{grades\_number} \cdot \text{students\_number}^3) #### **Exercice 3** +Voici ma réponse reformulée comme si j'étais un étudiant : + +--- + ### **Algorithme proposé** -Pour trier un tableau à \( N \)-dimensions avec \( M \) valeurs par dimension, voici l'algo. +1. **Tri des sous-dimensions** : + - Si on est sur un tableau 1D (le plus bas niveau), on le trie avec un tri par insertion. -#### Étapes de l’algorithme : +2. **Calcul des sommes des sous-dimensions** : + - Pour chaque sous-tableau, on calcule la somme des valeurs pour s’en servir comme critère de tri. -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. +3. **Tri des sous-dimensions par leurs sommes** : + - On trie les sous-dimensions avec un tri par insertion basé sur les sommes calculées. +4. **Répétition pour les autres dimensions** : + - On applique ces étapes de façon récursive à chaque niveau du tableau. -### **Implémentation en Python** +--- -Voici l’algorithme en code : +### **Implémentation** + +Voici l'algorithme en Python : ```python +# Fonction pour trier un tableau 1D avec un tri par insertion +def insertion_sort(arr): + for i in range(1, len(arr)): + key = arr[i] + j = i - 1 + # Déplacement des éléments plus grands que key + while j >= 0 and arr[j] > key: + arr[j + 1] = arr[j] + j -= 1 + arr[j + 1] = key + +# Fonction pour trier un tableau multidimensionnel récursivement def recursive_sort(T): - # Si c'est un tableau 1D, on le trie directement + # Si c'est un tableau 1D, on le trie if not isinstance(T[0], list): - return sorted(T) + insertion_sort(T) + return T - # Sinon, on trie chaque sous-dimension récursivement + # Trier chaque sous-dimension 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)) + # Calculer les sommes des sous-dimensions + sums = [sum(sum(val) if isinstance(val, list) else val for val in sublist) for sublist in T] + + # Trier les sous-dimensions en fonction de leurs sommes + for i in range(1, len(T)): + key_sum = sums[i] + key_sublist = T[i] + j = i - 1 + while j >= 0 and sums[j] > key_sum: + sums[j + 1] = sums[j] + T[j + 1] = T[j] + j -= 1 + sums[j + 1] = key_sum + T[j + 1] = key_sublist + return T # Exemple avec un tableau 2D @@ -108,55 +141,57 @@ 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é : +Prenons le tableau suivant : \[ [ [0, 3, 2], [9, 4, 5], [4, 1, 3] ] \] -1. **Trier chaque ligne individuellement** : +1. **Trier chaque ligne** : + - Première ligne : \( [0, 3, 2] \rightarrow [0, 2, 3] \) + - Deuxième ligne : \( [9, 4, 5] \rightarrow [4, 5, 9] \) + - Troisième ligne : \( [4, 1, 3] \rightarrow [1, 3, 4] \) \[ [ [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 \) +2. **Calculer les sommes** : + - \( [0, 2, 3] \rightarrow 5 \) + - \( [4, 5, 9] \rightarrow 18 \) + - \( [1, 3, 4] \rightarrow 8 \) -3. **Trier les lignes en fonction de leurs sommes** : +3. **Trier les lignes en fonction des sommes** : \[ [ [0, 2, 3], [1, 3, 4], [4, 5, 9] ] \] +--- -### **Complexité de l’algorithme** +### **Complexité** #### Analyse : -1. **Pour la dimension la plus basse (1D)** : - - Trier \( M \) éléments coûte \( O(M \log M) \). +1. **Tri des tableaux 1D** : + - Pour \( M \) éléments, le tri par insertion a une complexité de \( O(M^2) \). -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) \). +2. **Tri des sous-tableaux (dimensions \( N > 1 \))** : + - Chaque sous-tableau contient \( M^{N-1} \) éléments. Trier ces sous-tableaux coûte \( O(M^{N-1} \cdot M^{N-1}) = O(M^{2(N-1)}) \). -3. **Récursivité sur \( N \) dimensions** : - - La complexité totale est donnée par la somme : +3. **Calcul des sommes** : + - Calculer les sommes pour \( M^{N-1} \) sous-tableaux coûte \( O(M^N) \). + +4. **Complexité totale** : + - L'algorithme s’applique de façon récursive sur \( N \) dimensions. La partie dominante vient du tri des sous-tableaux les plus grands : \[ - 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) + T(N, M) = O(M^{2N-2}) \] +--- ### **Conclusion** -- - La complexité globale est +La complexité globale est \[ - O(M^N \log M) + O(M^{2N-2}) \] -