From 8f80a875bf1220a5f692fa32b6f5254995686ed9 Mon Sep 17 00:00:00 2001 From: Spectre Date: Wed, 27 Nov 2024 09:51:07 +0100 Subject: [PATCH] add some exercice --- algo2.md | 23 ++++++ .../dichotomie/recursif/myself/idx/main.py | 37 +++++++++ .../recursif/myself/idx/sort_list.py | 17 ++++ .../dichotomie/recursif/myself/idx/tester.py | 80 +++++++++++++++++++ 4 files changed, 157 insertions(+) create mode 100644 algo2.md create mode 100644 recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py create mode 100644 recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/sort_list.py create mode 100644 recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py diff --git a/algo2.md b/algo2.md new file mode 100644 index 0000000..8e164f0 --- /dev/null +++ b/algo2.md @@ -0,0 +1,23 @@ +```Plaintext +somme(liste) +somme = 0 +idx = 0 +while idx < |liste| + somme = somme + liste[idx] + idx = idx + 1 +``` + +# Myself +## Preuve de terminaison +La *Terminaison* est assurée par un variant de boucle (ici idx < |liste| est un variant de boucle) +```plaintext +|liste| - idx +``` +est ici l'ivariant de boucle + +## Preuve de correction partielle +La correction partielle est assurée par *l'invariant de boucle* ici Somme contient toutes les valeurs de la liste ajouter les unes aux autres ? par +```Plaintext +somme = somme + liste[idx] +``` +## Conclusion L'algo se termine et, à la sortie, idx = |liste| et somme contient tous les elements de la liste additionés entre eux diff --git a/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py b/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py new file mode 100644 index 0000000..ce0c9f4 --- /dev/null +++ b/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py @@ -0,0 +1,37 @@ +from sort_list import sort_list +from typing import Any + +def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None, bypass_sorting: bool = False) -> int: + """Performs a dichotomy search to determine if an element exists in a list or not. + + Args: + liste (list[Any]): The list in which to search for the element. + element (Any): The element to search for. + start (int, optional): The starting index of the sublist to search. Defaults to 0. + end (int, optional): The ending index of the sublist to search. Defaults to None. + bypass_sorting (bool, optional): If True, skips sorting the list. Defaults to False. + + Returns: + int: retourne l'indexe de l'element si il est trouver + """ + if not liste: + return -1 + + assert isinstance(element, type(liste[0])), "Wrong type between liste and element" + + if not bypass_sorting: + liste = sort_list(liste) + + if end is None: + end = len(liste) - 1 + if start > end: + return -1 + + middle = (start + end) // 2 + + if liste[middle] == element: + return middle + elif element < liste[middle]: + return dichotomie(liste, element, start, middle - 1, bypass_sorting=True) # bypass_sorting because it's already done + else: + return dichotomie(liste, element, middle + 1, end, bypass_sorting=True) # bypass_sorting because it's already done diff --git a/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/sort_list.py b/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/sort_list.py new file mode 100644 index 0000000..c27a57d --- /dev/null +++ b/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/sort_list.py @@ -0,0 +1,17 @@ +def sort_list(liste: list) -> list: + """this function sort a liste + + Args: + liste (list): the list to sort + + Returns: + list: the list sorted + """ + for i in range(len(liste)): + min_index = i + for j in range(i + 1, len(liste)): + if liste[j] < liste[min_index]: + min_index = j + liste[i], liste[min_index] = liste[min_index], liste[i] + + return liste diff --git a/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py b/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py new file mode 100644 index 0000000..c68774e --- /dev/null +++ b/recurivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py @@ -0,0 +1,80 @@ +from main import dichotomie + +def tester(): + liste1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + liste2 = liste1[:-1] + liste3 = [7, 4, 1, 8, 5, 2, 9, 6, 3, 0] + liste3_2 = [7, 7, 7, 7, 7, 7, 7, 8] + liste4 = [] + liste5 = [1] + liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3] + liste7 = [-1, -2, -2, -3, -4] + liste8 = list("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.") + liste9 = [i for i in range(1, 100000)] + + # Tests pour liste1 + assert dichotomie(liste1, 5) == 4, "Test échoué : 5 devrait être à l'index 4 dans liste1" + print("Test n°1 réussi") + assert dichotomie(liste1, 11) == -1, "Test échoué : 11 ne devrait pas être dans liste1" + print("Test n°2 réussi") + + # Tests pour liste2 + assert dichotomie(liste2, 9) == 8, "Test échoué : 9 devrait être à l'index 8 dans liste2" + print("Test n°3 réussi") + assert dichotomie(liste2, 10) == -1, "Test échoué : 10 ne devrait pas être dans liste2" + print("Test n°4 réussi") + ''' + # Tests pour liste3 (tri nécessaire) + assert dichotomie(liste3, 8) == 7, "Test échoué : 8 devrait être à l'index 7 après tri dans liste3" + print("Test n°5 réussi") + assert dichotomie(liste3, 11) == -1, "Test échoué : 11 ne devrait pas être dans liste3" + print("Test n°6 réussi") + ''' + # Tests pour liste3_2 + assert dichotomie(liste3_2, 7) == 3, "Test échoué : 7 devrait être dans liste3_2" + print("Test n°7 réussi") + assert dichotomie(liste3_2, 10) == -1, "Test échoué : 10 ne devrait pas être dans liste3_2" + print("Test n°8 réussi") + + # Tests pour liste4 + print(dichotomie(liste4,1)) + assert dichotomie(liste4, 1) == -1, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4" + print("Test n°9 réussi") + assert dichotomie(liste4, 0) == -1, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4" + print("Test n°10 réussi") + + # Tests pour liste5 + assert dichotomie(liste5, 1) == 0, "Test échoué : 1 devrait être à l'index 0 dans liste5" + print("Test n°11 réussi") + assert dichotomie(liste5, 2) == -1, "Test échoué : 2 ne devrait pas être dans liste5" + print("Test n°12 réussi") + + # Tests pour liste6 + assert dichotomie(liste6, 3.1) == 2, "Test échoué : 3.1 devrait être à l'index 2 dans liste6" + print("Test n°13 réussi") + assert dichotomie(liste6, 5.5) == -1, "Test échoué : 5.5 ne devrait pas être dans liste6" + print("Test n°14 réussi") + + # Tests pour liste7 (tri nécessaire) + assert dichotomie(liste7, -3) == 1, "Test échoué : -3 devrait être à l'index 1 après tri dans liste7" + print("Test n°15 réussi") + assert dichotomie(liste7, 0) == -1, "Test échoué : 0 ne devrait pas être dans liste7" + print("Test n°16 réussi") + + # Tests pour liste8 + assert dichotomie(liste8, "A") == 0, "Test échoué : 'L' devrait être à l'index 0 dans liste8" + print("Test n°17 réussi") + assert dichotomie(liste8, "Z") == -1, "Test échoué : 'Z' ne devrait pas être dans liste8" + print("Test n°18 réussi") + + # Tests pour liste9 (tri déjà fait) + assert dichotomie(liste9, 99999, bypass_sorting=True) == 99998, "Test échoué : 99999 devrait être à l'index 99998 dans liste9" + print("Test n°19 réussi") + assert dichotomie(liste9, 0, bypass_sorting=True) == -1, "Test échoué : 0 ne devrait pas être dans liste9" + print("Test n°20 réussi") + + print("Tous les tests ont réussi !") + + +if __name__ == '__main__': + tester()