formatte file

recursivite/TD1.py

@@ -2,27 +2,35 @@ def factorielle(number: int):
     if number == 0:
         return 1
     else:
-        return number * factorielle(number-1)
+        return number * factorielle(number - 1)
+
 
 def modulo(a, b):
-    if b-a < 0:
+    if b - a < 0:
         return b
     elif b == 0:
         return b
     else:
-        return modulo(a,b-a)
+        return modulo(a, b - a)
+
+
 def somme(n):
     if n == 0:
         return n
     else:
-        return(n+somme(n-1))
-def init_quotient(a,b):
+        return n + somme(n - 1)
+
+
+def init_quotient(a, b):
     i = 0
-    return (quotient(a,b,i))
-def quotient(a,b,i):
-    if  b == 0 or b-a < 0:
+    return quotient(a, b, i)
+
+
+def quotient(a, b, i):
+    if b == 0 or b - a < 0:
         return i
     else:
-        return(quotient(a,b-a,i+1))
+        return quotient(a, b - a, i + 1)
 
-print(init_quotient(6,18))
+
+print(init_quotient(6, 18))

recursivite/exercice_MJoannic/dichotomie/iteratif/main.py

@@ -1,6 +1,7 @@
 from sort_list import sort_list
 
-def dichotomie(liste: list, element: any,bypass_sorting = False)->bool:
+
+def dichotomie(liste: list, element: any, bypass_sorting=False) -> bool:
     """This function return return True if element is in liste False else
 
     Args:
@@ -12,18 +13,20 @@ def dichotomie(liste: list, element: any,bypass_sorting = False)->bool:
     """
     if liste == []:
         return False
-    assert type(element) == type(liste[0]), "Wrong type between liste and element" # On estime que la liste contient un seul et unique type...
+    assert type(element) == type(
+        liste[0]
+    ), "Wrong type between liste and element"  # On estime que la liste contient un seul et unique type...
     if bypass_sorting == False:
         liste = sort_list(liste)
-    N, start, find,i = len(liste)-1, 0, False, 0
+    N, start, find, i = len(liste) - 1, 0, False, 0
     end = N
     while (find != True) and (start <= end):
-        middle = (start + end)//2
+        middle = (start + end) // 2
         if liste[middle] == element:
             find = True
 
         elif element > liste[middle]:
-            start = middle+1
+            start = middle + 1
         else:
             end = middle - 1
     return find

recursivite/exercice_MJoannic/dichotomie/iteratif/tester.py

@@ -1,56 +1,84 @@
 from main import dichotomie
+
+
 def tester():
-    liste1 = [1,2,3,4,5,6,7,8,9,10]
+    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]
+    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)]
+    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)]
     assert dichotomie(liste1, 5) == True, "Test échoué : 5 devrait être dans liste1"
-    assert dichotomie(liste1, 11) == False, "Test échoué : 11 ne devrait pas être dans liste1"
+    assert (
+        dichotomie(liste1, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste1"
 
     # Tests pour liste2
     assert dichotomie(liste2, 9) == True, "Test échoué : 9 devrait être dans liste2"
-    assert dichotomie(liste2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste2"
+    assert (
+        dichotomie(liste2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste2"
 
     # Tests pour liste3
     assert dichotomie(liste3, 8) == True, "Test échoué : 8 devrait être dans liste3"
-    assert dichotomie(liste3, 11) == False, "Test échoué : 11 ne devrait pas être dans liste3"
+    assert (
+        dichotomie(liste3, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste3"
 
     # Tests pour liste3_2
     assert dichotomie(liste3_2, 7) == True, "Test échoué : 7 devrait être dans liste3_2"
-    assert dichotomie(liste3_2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste3_2"
+    assert (
+        dichotomie(liste3_2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste3_2"
 
     # Tests pour liste4
-    assert dichotomie(liste4, 1) == False, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
-    assert dichotomie(liste4, 0) == False, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 1) == False
+    ), "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 0) == False
+    ), "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
 
     # Tests pour liste5
     assert dichotomie(liste5, 1) == True, "Test échoué : 1 devrait être dans liste5"
-    assert dichotomie(liste5, 2) == False, "Test échoué : 2 ne devrait pas être dans liste5"
+    assert (
+        dichotomie(liste5, 2) == False
+    ), "Test échoué : 2 ne devrait pas être dans liste5"
 
     # Tests pour liste6
     assert dichotomie(liste6, 3.1) == True, "Test échoué : 3.1 devrait être dans liste6"
-    assert dichotomie(liste6, 5.5) == False, "Test échoué : 5.5 ne devrait pas être dans liste6"
+    assert (
+        dichotomie(liste6, 5.5) == False
+    ), "Test échoué : 5.5 ne devrait pas être dans liste6"
 
     # Tests pour liste7
     assert dichotomie(liste7, -3) == True, "Test échoué : -3 devrait être dans liste7"
-    assert dichotomie(liste7, 0) == False, "Test échoué : 0 ne devrait pas être dans liste7"
+    assert (
+        dichotomie(liste7, 0) == False
+    ), "Test échoué : 0 ne devrait pas être dans liste7"
 
     # Tests pour liste8
     assert dichotomie(liste8, "L") == True, "Test échoué : 'L' devrait être dans liste8"
-    assert dichotomie(liste8, "Z") == False, "Test échoué : 'Z' ne devrait pas être dans liste8"
-    
+    assert (
+        dichotomie(liste8, "Z") == False
+    ), "Test échoué : 'Z' ne devrait pas être dans liste8"
+
     # Tests pour liste9
-    assert dichotomie(liste9, 99999, True) == True, "Test échoué : 99999 devrait être dans liste9" # bypass = True because sorting_list is very slow
-    assert dichotomie(liste9, 0,True) == False, "Test échoué : 5 ne devrait pas être dans liste9"# bypass = True because sorting_list is very slow
+    assert (
+        dichotomie(liste9, 99999, True) == True
+    ), "Test échoué : 99999 devrait être dans liste9"  # bypass = True because sorting_list is very slow
+    assert (
+        dichotomie(liste9, 0, True) == False
+    ), "Test échoué : 5 ne devrait pas être dans liste9"  # bypass = True because sorting_list is very slow
 
     print("Tous les tests ont réussi !")
 
 
-if __name__ == '__main__':
-    tester()
+if __name__ == "__main__":
+    tester()

recursivite/exercice_MJoannic/dichotomie/recursif/correction/V1.py

@@ -1,28 +1,31 @@
 from typing import Any
 
 
-def est_triee(liste: list)->bool:
+def est_triee(liste: list) -> bool:
     if len(liste) <= 1:
         return True
 
     index = 0
-    while (index < len(liste) - 1) and (liste[index]<=liste[index + 1]):
-        index+=1
-    return index>= len(liste) - 1
+    while (index < len(liste) - 1) and (liste[index] <= liste[index + 1]):
+        index += 1
+    return index >= len(liste) - 1
 
-def search(liste:list, element:Any):
+
+def search(liste: list, element: Any):
     assert est_triee(liste), "Pas de recherche sur une liste non triee"
+
     def aux(liste, element):
         if len(liste) == 0:
             return True
         else:
-            pivot = liste[len(liste)//2]
+            pivot = liste[len(liste) // 2]
             if pivot == element:
                 return True
             if element < pivot:
-                return aux(liste[len(liste)//2], element)
-            return aux(liste[len(liste)//3 + 1:], element)
-    return aux(liste,element)
+                return aux(liste[len(liste) // 2], element)
+            return aux(liste[len(liste) // 3 + 1 :], element)
+
+    return aux(liste, element)
 
 
-print(search([1,2,3],2))
+print(search([1, 2, 3], 2))

recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py

@@ -1,7 +1,14 @@
 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:
+
+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:
@@ -32,6 +39,10 @@ def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None,
     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
+        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
+        return dichotomie(
+            liste, element, middle + 1, end, bypass_sorting=True
+        )  # bypass_sorting because it's already done

recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py

@@ -1,5 +1,6 @@
 from main import dichotomie
 
+
 def tester():
     liste1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     liste2 = liste1[:-1]
@@ -9,72 +10,108 @@ def tester():
     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.")
+    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"
+    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"
+    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"
+    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"
+    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"
+    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(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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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__':
+if __name__ == "__main__":
     tester()

recursivite/exercice_MJoannic/dichotomie/recursif/myself/main.py

@@ -1,7 +1,14 @@
 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) -> bool:
+
+def dichotomie(
+    liste: list[Any],
+    element: Any,
+    start: int = 0,
+    end: int = None,
+    bypass_sorting: bool = False,
+) -> bool:
     """Performs a dichotomy search to determine if an element exists in a list or not.
 
     Args:
@@ -33,6 +40,10 @@ def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None,
     if liste[middle] == element:
         return True
     elif element < liste[middle]:
-        return dichotomie(liste, element, start, middle - 1, bypass_sorting=True) # bypass_sorting because it's already done
+        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
+        return dichotomie(
+            liste, element, middle + 1, end, bypass_sorting=True
+        )  # bypass_sorting because it's already done

recursivite/exercice_MJoannic/dichotomie/recursif/myself/tester.py

@@ -1,78 +1,106 @@
 from main import dichotomie
+
+
 def tester():
-    liste1 = [1,2,3,4,5,6,7,8,9,10]
+    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]
+    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)]
-    
+    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) == True, "Test échoué : 5 devrait être dans liste1"
     print("Test n°1 done")
-    assert dichotomie(liste1, 11) == False, "Test échoué : 11 ne devrait pas être dans liste1"
+    assert (
+        dichotomie(liste1, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste1"
     print("Test n°2 done")
 
     # Tests pour liste2
     assert dichotomie(liste2, 9) == True, "Test échoué : 9 devrait être dans liste2"
     print("Test n°3 done")
-    assert dichotomie(liste2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste2"
+    assert (
+        dichotomie(liste2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste2"
     print("Test n°4 done")
 
     # Tests pour liste3
     assert dichotomie(liste3, 8) == True, "Test échoué : 8 devrait être dans liste3"
     print("Test n°5 done")
-    assert dichotomie(liste3, 11) == False, "Test échoué : 11 ne devrait pas être dans liste3"
+    assert (
+        dichotomie(liste3, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste3"
     print("Test n°6 done")
 
     # Tests pour liste3_2
     assert dichotomie(liste3_2, 7) == True, "Test échoué : 7 devrait être dans liste3_2"
     print("Test n°7 done")
-    assert dichotomie(liste3_2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste3_2"
+    assert (
+        dichotomie(liste3_2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste3_2"
     print("Test n°8 done")
 
     # Tests pour liste4
-    assert dichotomie(liste4, 1) == False, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 1) == False
+    ), "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
     print("Test n°9 done")
-    assert dichotomie(liste4, 0) == False, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 0) == False
+    ), "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
     print("Test n°10 done")
 
     # Tests pour liste5
     assert dichotomie(liste5, 1) == True, "Test échoué : 1 devrait être dans liste5"
     print("Test n°11 done")
-    assert dichotomie(liste5, 2) == False, "Test échoué : 2 ne devrait pas être dans liste5"
+    assert (
+        dichotomie(liste5, 2) == False
+    ), "Test échoué : 2 ne devrait pas être dans liste5"
     print("Test n°12 done")
 
     # Tests pour liste6
     assert dichotomie(liste6, 3.1) == True, "Test échoué : 3.1 devrait être dans liste6"
     print("Test n°13 done")
-    assert dichotomie(liste6, 5.5) == False, "Test échoué : 5.5 ne devrait pas être dans liste6"
+    assert (
+        dichotomie(liste6, 5.5) == False
+    ), "Test échoué : 5.5 ne devrait pas être dans liste6"
     print("Test n°14 done")
 
     # Tests pour liste7
     assert dichotomie(liste7, -3) == True, "Test échoué : -3 devrait être dans liste7"
     print("Test n°15 done")
-    assert dichotomie(liste7, 0) == False, "Test échoué : 0 ne devrait pas être dans liste7"
+    assert (
+        dichotomie(liste7, 0) == False
+    ), "Test échoué : 0 ne devrait pas être dans liste7"
     print("Test n°16 done")
 
     # Tests pour liste8
     assert dichotomie(liste8, "L") == True, "Test échoué : 'L' devrait être dans liste8"
     print("Test n°17 done")
-    assert dichotomie(liste8, "Z") == False, "Test échoué : 'Z' ne devrait pas être dans liste8"
+    assert (
+        dichotomie(liste8, "Z") == False
+    ), "Test échoué : 'Z' ne devrait pas être dans liste8"
     print("Test n°18 done")
-    
+
     # Tests pour liste9
-    assert dichotomie(liste9, 99999, bypass_sorting=True) == True, "Test échoué : 99999 devrait être dans liste9"
+    assert (
+        dichotomie(liste9, 99999, bypass_sorting=True) == True
+    ), "Test échoué : 99999 devrait être dans liste9"
     print("Test n°19 done")
-    assert dichotomie(liste9, 0, bypass_sorting=True) == False, "Test échoué : 0 ne devrait pas être dans liste9"
+    assert (
+        dichotomie(liste9, 0, bypass_sorting=True) == False
+    ), "Test échoué : 0 ne devrait pas être dans liste9"
     print("Test n°20 done")
 
     print("Tous les tests ont reussi !")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     tester()

recursivite/exercice_MJoannic/palindrom.py

@@ -1,4 +1,4 @@
-def is_palindrom(word)->bool:
+def is_palindrom(word) -> bool:
     word = list(word)
     if len(word) < 2:
         return True
@@ -9,4 +9,5 @@ def is_palindrom(word)->bool:
     else:
         return False
 
-print(is_palindrom("do geese see god".replace(' ', '')))
+
+print(is_palindrom("do geese see god".replace(" ", "")))

recursivite/exercice_MJoannic/sqrt/correction/main.py

@@ -1,41 +1,40 @@
 def racine(n):
     def aux(gauche, droite):
-        
 
         if gauche > droite:
             return droite
-        
+
         milieu = (gauche + droite) // 2
-        
+
         if milieu * milieu == n:
             return milieu
-        
+
         elif milieu * milieu > n:
             return aux(gauche, milieu - 1)
-        
+
         else:
             return aux(milieu + 1, droite)
-    return aux(0, n)
 
+    return aux(0, n)
 
 
 def racine_decimale(n, precision=1e-6):
 
     def aux(gauche, droite):
         milieu = (gauche + droite) / 2
-    
+
         if droite - gauche < precision:
             return milieu
-        
+
         if milieu * milieu == n:
             return milieu
-        
+
         elif milieu * milieu < n:
             return aux(milieu, droite)
-        
+
         else:
             return aux(gauche, milieu)
-    
+
     partie_entiere = racine(n)
-    
+
     return aux(partie_entiere, partie_entiere + 1)

recursivite/exercice_MJoannic/sqrt/main.py

@@ -2,9 +2,9 @@
 def racine_raphson(number: float, precision: float) -> float:
     assert number > 0, "La racine du nombre n'est pas réelle."
 
-    y = (number / 3)+ 1 
+    y = (number / 3) + 1
     diff = precision + 1
-    
+
     while diff > precision:
         y_next = (y + number / y) / 2.0
         diff = abs(y_next - y)
@@ -12,11 +12,18 @@ def racine_raphson(number: float, precision: float) -> float:
 
     return y
 
+
 if __name__ == "__main__":
-    print(racine_raphson(36, 0.000000000000001)**2 == 36)
+    print(racine_raphson(36, 0.000000000000001) ** 2 == 36)
 
 
-def dichotomie(liste: list[any], element: any, start: int = 0, end: int = None, bypass_sorting: bool = False) -> int:
+def dichotomie(
+    liste: list[any],
+    element: any,
+    start: int = 0,
+    end: int = None,
+    bypass_sorting: bool = False,
+) -> int:
     """Recherche la partie entière de la racine carrée d'un nombre en utilisant une recherche dichotomique.
 
     Args:
@@ -45,6 +52,7 @@ def dichotomie(liste: list[any], element: any, start: int = 0, end: int = None,
     else:
         return dichotomie(liste, element, start, middle - 1, bypass_sorting=True)
 
+
 def racine_dich(number: int) -> int:
     """
     Calcul de la partie entière de la racine carrée d'un nombre entier.
@@ -60,9 +68,8 @@ def racine_dich(number: int) -> int:
     return dichotomie(liste, number)
 
 
-
 if __name__ == "__main__":
     print(racine_dich(36))  # Retourne 6
     print(racine_dich(20))  # Retourne 4
-    print(racine_dich(0))   # Retourne 0
-    print(racine_dich(1))   # Retourne 1
+    print(racine_dich(0))  # Retourne 0
+    print(racine_dich(1))  # Retourne 1