From a7b30e8e79f2aed9836a1d444693664e3ad3998d Mon Sep 17 00:00:00 2001
From: genique <florian.genique@etu.u-pec.fr>
Date: Tue, 26 Nov 2024 11:31:30 +0100
Subject: [PATCH] readme
---
README.md | 66 +++++++++++++++++++++++++++++++++++++++----------------
tri.py | 12 +++++-----
2 files changed, 54 insertions(+), 24 deletions(-)
diff --git a/README.md b/README.md
index 8cf3f3e..4a8fa88 100644
--- a/README.md
+++ b/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²)
\ No newline at end of file
+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²).
\ No newline at end of file
diff --git a/tri.py b/tri.py
index 232cea3..283ce8b 100644
--- a/tri.py
+++ b/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)