add recursiv function and move it into recursive dir

recurivite/exercice_MJoannic/dichotomie/iteratif/main.py

@@ -1,21 +1,4 @@
-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
-
+from sort_list import sort_list
 
 def dichotomie(liste: list, element: any,bypass_sorting = False)->bool:
     """This function return return True if element is in liste False else
@@ -23,7 +6,7 @@ def dichotomie(liste: list, element: any,bypass_sorting = False)->bool:
     Args:
         liste (list): the array to examinate
         element (any): the element to find into liste
-
+        bypass_sorting (bool, optional):If True, skips sorting the list. Defaults to False.
     Returns:
         bool: True if present False else
     """

recurivite/exercice_MJoannic/dichotomie/iteratif/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

recurivite/exercice_MJoannic/dichotomie/recursif/main.py

@@ -0,0 +1,38 @@
+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:
+    """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:
+        bool: True if the element is found, False otherwise.
+    """
+    if not liste:
+        return False
+
+    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 False
+
+    middle = (start + end) // 2
+
+    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
+    else:
+        return dichotomie(liste, element, middle + 1, end, bypass_sorting=True) # bypass_sorting because it's already done

recurivite/exercice_MJoannic/dichotomie/recursif/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

recurivite/exercice_MJoannic/dichotomie/recursif/tester.py

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