Exercices sur les listes en Python 3

Recherche d'élément dans une liste

Écrire une fonction find_in_list_1st_index_of (alist, element) qui retourne l'index de la première occurence de l'élément element dans la liste alist. La fonction retourne None si l'élément n'est pas trouvé.

def find_in_list_1st_index_of (alist, element):
    pass

assert find_in_list_1st_index_of (["a", "b", "c", "d", "c", "e"], "c") == 2
assert find_in_list_1st_index_of (["a", "b", "c", "d", "c", "e"], "x") == None

Écrire une fonction find_in_list_nth_index_of (alist, element, n) qui retourne l'index de la n-ième occurence de element dans la liste alist. La fonction retourne None si l'élément a moins de n occurrences.

def find_in_list_nth_index_of (alist, element, n):
    pass

assert find_in_list_nth_index_of (["a", "b", "c", "d", "c", "e"], "c", 1) == 2
assert find_in_list_nth_index_of (["a", "b", "c", "d", "c", "e"], "c", 2) == 4
assert find_in_list_nth_index_of (["a", "b", "c", "d", "c", "e"], "c", 3) == None

Écrire une fonction find_in_list_all_indexes_of (alist, element) qui retourne la liste de tous les indexes de element dans la liste alist. La fonction retourne une liste vide [] si l'élément n'est pas présent.

def find_in_list_all_indexes_of (alist, element):
    pass

assert find_in_list_all_indexes_of (["a", "b", "c", "d", "c", "e"], "c") == [2, 4]
assert find_in_list_all_indexes_of (["a", "b", "c", "d", "c", "e"], "x") == []

Écrire une fonction find_in_list_index_of_max (alist) qui retourne l'index de l'élément maximal dans la liste alist. La fonction retourne None si la liste est vide.

def find_in_list_index_of_max (alist):
    pass

assert find_in_list_index_of_max (["a", "b", "c", "e", "c", "d"]) == 3
assert find_in_list_index_of_max ( [] ) == None

Tri d'une liste par insertion

Écrire une fonction list_is_sorted (alist) testant si la liste alist est triée. La fonction retourne un Booléen (True ou False). La liste vide est réputée triée.
```
def list_is_sorted (alist):
    pass

assert list_is_sorted ([])
assert list_is_sorted (["a", "b", "c"])
assert not list_is_sorted (["a", "b", "d", "c"])
```

Écrire une fonction find_in_list_insertion_index_of (alist, element) qui retourne l'index du premier élément strictement plus grand que element dans la liste alist. La fonction retourne la longueur de la liste, si aucun élément n'est plus grand que element.

def find_in_list_insertion_index_of (alist, element):
    pass

assert find_in_list_insertion_index_of ([], "x") == 0
assert find_in_list_insertion_index_of (["a", "b", "d", "e"], "c") == 2
assert find_in_list_insertion_index_of (["a", "b", "d", "e"], "x") == 4

En supposant que la liste est triée, la fonction précédente find_in_list_insertion_index_of (alist, element) indique à quel index insérer element pour maintenir la liste triée. En déduire une fonction list_sorted_with_insertion (alist) qui retourne une version triée de la liste alist. Le résultat est construit en créant une liste vide, que l'on augmente petit à petit en parcourant les éléments element de alist et en insérant element à l'endroit indiqué par find_in_list_insertion_index_of (alist, element).
```
def list_sorted_with_insertion (alist):
    pass

assert list_sorted_with_insertion (["c", "b", "d", "a"]) == ["a", "b", "c", "d"]
assert list_sorted_with_insertion (["a"]) == ["a"]
assert list_sorted_with_insertion ([]) == []
```

Tri d'une liste par fusion

Écrire une fonction list_merged_with (sorted1, sorted2) qui prend en arguments deux listes triées sorted1 et sorted2, et qui retourne leur fusion triée.
```
def list_merged_with (sorted1, sorted2):
    pass

assert list_merged_with ([3,6,8], [1,2,5]) == [1,2,3,5,6,8]
```
Écrire une fonction each_in_list_merged_with_next (list_of_list) qui prend en argument une liste de listes triées et qui retourne une liste de liste triées. Chaque liste du résultat est obtenue par la fusion triée de deux listes voisines.
```
def each_in_list_merged_with_next (list_of_list):
    pass

assert each_in_list_merged_with_next ([[1,3],[2,4],[5,8],[6,7],[9]]) == [[1,2,3,4],[5,6,7,8],[9]]
```
Écrire une fonction each_in_list_nested (alist) qui retourne une liste de singletons, chacune contenant un élément de alist.
```
def each_in_list_nested (alist):
    pass

assert each_in_list_nested ([1,3,2]) == [[1],[3],[2]] 
```
Utiliser les deux fonctions précédentes pour écrire la fonction list_sorted_with_merge (alist) qui retourne alist triée par fusion.
```
def list_sorted_with_merge (alist):
    pass

assert list_sorted_with_merge ([5,3,1,6,2,8,9]) == [1,2,3,5,6,8,9]
```