Rendu Kayyissa

README.md

@@ -57,7 +57,7 @@ Mesurez combien de temps prend python à générer un tableau composés de :
 
 Sur un tableur, générez un tableau permettant de visualiser le temps d'éxécution en fonction de la taille de l'entrée.
 
-Comment vous semble évoluer la courbe ? Observez bien les différentes courbes du graphique ci-dessous. Quelle est la plus ressemblante à notre situation ? *Écrivez votre réponse ici*
+Comment vous semble évoluer la courbe ? Observez bien les différentes courbes du graphique ci-dessous. Quelle est la plus ressemblante à notre situation ? O(n) (Par ressemblance visuelle avec le graphique fourni, O(n) et O(n log n) sont acceptables. Il faut l'explication des complexités, ou un graphique exposant davantage la courbe de n log n  pour répondre à la question.)
 
 <img src="img/o.webp" width="400">
 
@@ -75,7 +75,8 @@ Observez attentivement l'animation de tri par sélection ci-dessous pour en comp
 
 <img src="img/selection.gif">
 
-Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? *Écrivez votre réponse ici*
+Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ?
+On explore un tableau à la recherche de la plus petite valeur, puis on la place au premier emplacement disponible. À la première itération, la plus petite valeur du tableau est donc placée à l'index 0. À la seconde, la valeur la plus petite trouvée entre l'index 1 et la fin du tableau est placée à l'index 1, etc.
 
 Puis implémentez l'algorithme en python dans la fonction `sort` du fichier `sort/selection.py`. Vérifiez son bon fonctionnement en éxécutant le fichier `python3 -m unittest`. Le test correspondant au tri par sélection doit passer.
 
@@ -88,15 +89,18 @@ Mesurez le temps d'éxécution pour un tableau de :
 
 Tracez le graphique correspondant.
 
-Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? *Écrivez votre réponse ici*
+<img src="img/selectionGraph.png">
+
+Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? O(n²). Cela semble logique car pour chaque entrée supplémentaire, à chaque itération (il y en a n * n-index soit presque n²) on explore une valeur de plus. Soit n² fois plus de valeurs.
 
 ### 2. Tri par insertion
 
 Observez attentivement l'animation de tri par insertion ci-dessous pour en comprendre le fonctionnement.
 
 <img src="img/insertion.gif">
 
-Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? *Écrivez votre réponse ici*
+Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ?
+On regarde pour chaque valeur si elle est plus petite que celle qui la précède. Si c'est le cas, elle est placée avant elle. Cela est répété jusqu'à ce que la valeur précédente soit plus petite que celle qu'on déplace.
 
 Puis implémentez l'algorithme en python dans la fonction `sort` du fichier `sort/insertion.py`. Utilisez les tests automatiques pour vérifier votre implémentation.
 
@@ -109,7 +113,9 @@ Mesurez le temps d'éxécution pour un tableau de :
 
 Tracez le graphique correspondant.
 
-Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? *Écrivez votre réponse ici*
+<img src="img/insertionGraph.png">
+
+Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? O(n²). En effet, pour chaque élément dans le tableau, dans le pire des cas on itère entre le début du tableau et l'index de ce nombre. Cela représente presque n² itérations pour explorer tous les éléments.
 
 ### 3. Tri par fusion
 
@@ -154,7 +160,8 @@ Observez bien le schéma suivant : il représente le concept du tri par fusion.
 
 Cet algorithme est de type "diviser pour régner".
 
-Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? *Écrivez votre réponse ici*
+Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ?
+On sépare un tableau en 2 jusqu'à ce que tous les élements soient isolés. Ensuite, on compare les élements deux à deux. Le plus petit est placé au début d'un nouveau tableau de 2 élémnts. On compare ensuite deux à deux les premières valeurs des tableaux de deux éléments. La plus petite valeur est placé au début d'un tableau de 4 éléments. On compare ensuite la première valeur du tableau de deux éléments avec la deuxième du tableau dont la première valeur a été prise. On place la plus petite de ces valeurs à la suite de la première. On itère jusqu'à avoir reconstituté un unique tableau.
 
 Complétez la fonction `sort` du fichier `sort/fusion.py` en suivant les instructions suivantes.
 
@@ -174,15 +181,18 @@ Mesurez le temps d'éxécution pour un tableau de :
 
 Tracez le graphique correspondant.
 
-Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? *Écrivez votre réponse ici*
+<img src="img/fusionGraph.png">
+
+Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? O(n log n). Cet algorithme utilise la récursivité plutôt que des boucles imbriquées. Pour chaque élement supplémentaire, on va réaliser une récursion de plus, mais pas explorer de nouveau tout le tableau. C'est donc une complexité logique.
 
-Question bonus : Y a-t-il des tailles de tableaux pour lesquelles le tri par fusion n'est pas aussi rapide que les précédents tris abordés ? *Écrivez votre réponse ici*
+Question bonus : Y a-t-il des tailles de tableaux pour lesquelles le tri par fusion n'est pas aussi rapide que les précédents tris abordés ? Des tailles je ne sais pas, mais si le tableau fourni est déjà trié, il est plus lent que les autres.
 
 ### 4. sort()
 
 Bien que tout cela soit fascinant, Python possède sa propre méthode de tri : `sort()`.
 
 Une dernière fois, analysez le temps d'exécution et découvrez si python fait mieux que nos implémentations rudimentaires ;)
+Il est effectivement beaucoup plus rapide !
 
 ## Pour rendre ce TP
 

__main__.py

@@ -1,5 +1,42 @@
+from sort.range import generate_array_of_number
+from sort.insertion import sort as insersion_sort
+from sort.selection import sort as selection_sort
+from sort.fusion import sort as fusion_sort
+
+import time
+
+
 def main():
-    print("Hello world")
+    array_list: list[list[int]] = []
+    array_size: int = 1000
+
+    for i in range(10):
+        array_list.append(generate_array_of_number(array_size))
+        array_size += 1000
+
+    for i in range(10):
+        start: float = time.time()
+        selection_sort(array_list[i])
+        end: float = time.time()
+        print(f"Time for {len(array_list[i])} (selection):", end - start)
+
+    for i in range(10):
+        start: float = time.time()
+        insersion_sort(array_list[i])
+        end: float = time.time()
+        print(f"Time for {len(array_list[i])} (insertion):", end - start)
+
+    for i in range(10):
+        start: float = time.time()
+        fusion_sort(array_list[i])
+        end: float = time.time()
+        print(f"Time for {len(array_list[i])} (fusion):", end - start)
+
+    for i in range(10):
+        start: float = time.time()
+        array_list[i].sort()
+        end: float = time.time()
+        print(f"Time for {len(array_list[i])} (python sort):", end - start)
 
 
 main()

sort/fusion.py

@@ -1,2 +1,33 @@
 def sort(array: list[int]) -> list[int]:
+    """sort using fusion:
+    split the given list until every element is separated,
+    then compare them to merge them into a sorted list"""
+
+    if len(array) > 1:
+        array = merge(sort(array[:len(array)//2]),
+                      sort(array[len(array)//2:]))
+
     return array
+
+
+def merge(array_a: list[int], array_b: list[int]) -> list[int]:
+    """sort and merge two ordered given lists"""
+
+    merged_array: list[int] = []
+
+    while len(array_a) != 0 or len(array_b) != 0:
+
+        if len(array_a) == 0:
+            merged_array.extend(array_b)
+            break
+
+        if len(array_b) == 0:
+            merged_array.extend(array_a)
+            break
+
+        if array_a[0] < array_b[0]:
+            merged_array.append(array_a.pop(0))
+        else:
+            merged_array.append(array_b.pop(0))
+
+    return merged_array

sort/insertion.py

@@ -1,2 +1,17 @@
 def sort(array: list[int]) -> list[int]:
+    """sort a given list by comparing values 2 per 2,
+    placing the lowest value to the left"""
+
+    for index, value in enumerate(array):
+
+        # Can't compare a value with nothing before
+        if index == 0:
+            continue
+
+        for i in range(1, len(array[:index])+1):
+            if value < array[index-i]:
+                array[index-i], array[index-i+1] = value, array[index-i]
+            else:
+                break
+
     return array

sort/range.py

@@ -1,2 +1,7 @@
+import random
+
+
 def generate_array_of_number(array_size: int) -> list[int]:
-    return []
+    """Return an array of numbers between 0 and 100 of the given size"""
+
+    return [random.randint(0, 100) for i in range(array_size)]

sort/recursion.py

@@ -1,2 +1,4 @@
 def get_factorial(number: int) -> int:
-    return number
+    """Get the factorial of a number using recursion"""
+
+    return number * get_factorial(number - 1) if number > 1 else 1

sort/selection.py

@@ -1,2 +1,20 @@
 def sort(array: list[int]) -> list[int]:
+    """sort a given list by searching the lowest value again and again"""
+
+    current_index: int = 0
+    lowest_value_index: int = 0
+
+    while current_index < len(array):
+        lowest_value_index = current_index
+
+        for index, value in enumerate(array[current_index:]):
+            if value < array[lowest_value_index]:
+                lowest_value_index = index + current_index
+
+        array[current_index], array[lowest_value_index] = \
+            array[lowest_value_index], array[current_index]
+
+        current_index += 1
+        lowest_value_index = current_index
+
     return array