Écrire une fonction plus_unqui renvoie une liste où chaque valeur de la liste passée en paramètre est augmentée de 1.

Exemple : plus_un([6, 12, 18, 5]) renvoie : [7, 13, 19, 6]

# Code à copier dans votre éditeur et à compléter
def plus_un(lst):
    
# Jeu d'essai
print("plus_un / validation tests")
print("==========================")
print("Pass test1 --> ",plus_un([6, 12, 18, 5])==[7, 13, 19, 6])
print("Pass test1 --> ",plus_un([78])==[79])
print("Pass test2 --> ",plus_un([])==[])

Écrire une fonction somme_lst qui renvoie la somme des éléments de la liste passée en paramètre.

# Code à copier dans votre éditeur et à compléter
def somme_lst(lst):
   
    
# Jeu d'essai
print("somme_lst / validation tests")
print("============================")
print("Pass test1 --> ",somme_lst([6, 12, 18, 5])==41)
print("Pass test1 --> ",somme_lst([45])==45)
print("Pass test2 --> ",somme_lst([])==0)			

Écrire une fonction nb3 qui renvoie le nombre de multiples de 3 présents dans la liste passée en paramètre.

# Code à copier dans votre éditeur et à compléter
def nb3(lst):    
    
# Jeu d'essai
print("nb3  / validation tests")
print("=======================")
print("Pass test1 --> ",nb3([])==0)
print("Pass test2 --> ",nb3([1])==0)
print("Pass test3 --> ",nb3([6])==1)
print("Pass test4 --> ",nb3([1,5,7])==0)
print("Pass test5 --> ",nb3([1,3,5,7,9,12,17,21])==4)

Écrire une fonction minmax_lst(lst) qui renvoie un couple de valeur correspondant à la valeur minimun et à la valeur maximum de la liste passée en paramètre.

On rappelle qu'un couple de valeurs correspond à un tuple.

# Code à copier dans votre éditeur et à compléter
def minmax_lst(lst):
       
    
# Jeu d'essai
print("minmax_lst / validation tests")
print("=============================")
print("Pass test1 --> ",minmax_lst([])== None)
print("Pass test2 --> ",minmax_lst([8,8])==(8,8))
print("Pass test3 --> ",minmax_lst([1,3,5,7,9,12,17,21])==(1,21))
print("Pass test4 --> ",minmax_lst([12,56,3,25,102,56,876,90,7])==(3,876))

Écrire une fonction prod5070(lst) qui renvoie le produit de toutes les valeurs de la liste comprise dans l’intervalle [50, 70]

# Code à copier dans votre éditeur et à compléter
def prod5070(lst):
       
    
# Jeu d'essai
print("prod5070 / validation tests")
print("===========================")
print("Pass test1 --> ",prod5070([])== 0)
print("Pass test2 --> ",prod5070([8])== 0)
print("Pass test3 --> ",prod5070([58])== 58)
print("Pass test4 --> ",prod5070([50,12,70])== 3500)
print("Pass test5 --> ",prod5070([12,45,78,36,59,65,14,3,78,62])== 237770)

Écrire une fonction recherche(lst,val) qui renvoie l'index de la valeur recherchée dans la liste lst.

La liste n'est pas triée.

Si la valeur n'existe pas dans la liste la fonction doit retourner None.

# Code à copier dans votre éditeur et à compléter
def recherche(lst,val)

        
# Jeu d'essai
print("recherche / validation tests")
print("============================")
print("Pass test1 --> ",recherche([12,45,78,36,59,65,14,3,78,62],80)== None)
print("Pass test2 --> ",recherche([12,45,78,36,59,65,14,3,78,62],12)== 0)
print("Pass test2 --> ",recherche([12,45,78,36,59,65,14,3,78,62],62)== 9)
print("Pass test2 --> ",recherche([12,45,78,36,59,65,14,3,78,62],78)== 2)

Écrire une fonction reverso qui étant donnée une liste lst renvoie une liste où les termes sont inversés.

Le premier terme se retrouve donc en dernière position, etc.

# Code à copier dans votre éditeur et à compléter
def reverso(lst)
        
    
# Jeu d'essai
print("reverso / validation tests")
print("==========================")
print("Pass test1 --> ",reverso([])==[])
print("Pass test2 --> ",reverso([1,2,3,4])==[4,3,2,1])
print("Pass test3 --> ",reverso(["chat","chien","cheval"])==["cheval","chien","chat"])
print("Pass test4 --> ",reverso(["aa"])==["aa"])

# Code à copier dans votre éditeur et à compléter
def enum(lst)

    
# Jeu d'essai
print("enum / validation tests")
print("=======================")
print("Pass test1 --> ",enum([1,1,1])==[(0,1),(1,1),(2,1)])
print("Pass test2 --> ",enum(["chat","chien","cheval"])==[(0,"chat"),(1,"chien"),(2,"cheval")])
print("Pass test3 --> ",enum([1])==[(0,1)])
print("Pass test4 --> ",enum([])==[])

Ecrire une fonction map_listf, qui étant donnés une fonction f et une liste lst,

renvoie la liste des f(x), où x décrit les éléments de la liste lst.

En particulier, la liste renvoyée est de même longueur que la liste entrée en argument.

Exemple : map(lambda x: 2*x, [1,2,3,4]) renvoie [2,4,6,8].

(Rappel : lambda x: 2*x définit la fonction anonyme qui pour x donné, retourne 2x)

# Code à copier dans votre éditeur et à compléter
def  map_list(f,lst)
        
    
# Jeu d'essai
print("map_list / validation tests")
print("===========================")
print("Pass test1 --> ",map_list(lambda x: 2*x, [1,2,3,4])== [2,4,6,8])
print("Pass test2 --> ",map_list(lambda x: None, [1,2,3,4])== [None,None,None,None])
print("Pass test3 --> ",map_list(lambda x: x+5, [1,2,3,4])== [6,7,8,9])
print("Pass test4 --> ",map_list(lambda x: x+5, [])== [])

Ecrire une fonction fusion_list qui étant données deux listes lst1 et lst2 de nombres classés par ordre croissant renvoie la liste obtenue en fusionnant les deux listes entrées en arguments.

La liste obtenue ne doit pas comporter de doublons.

# Code à copier dans votre éditeur et à compléter
def  fusion_list(lst1,lst2)
        
    
# Jeu d'essai
print("fusion_list / validation tests")
print("==============================")
print("Pass test1 --> ",fusion_list([1,5,7],[2,6,9,14])== [1,2,5,6,7,9,14])
print("Pass test2 --> ",fusion_list([1,5,7,20],[2,5,9,14])== [1,2,5,7,9,14,20])
print("Pass test3 --> ",fusion_list([1,2,3,4],[])== [1,2,3,4])
print("Pass test4 --> ",fusion_list([],[1,2,3,4])== [1,2,3,4])
print("Pass test5 --> ",fusion_list([1,2,3,4],[1,2,3,4])== [1,2,3,4])