def liste_divisibles(n, m):
    """int*int -> list[int]
    Hypothèse n >= 0
    Hypothèse m > 0
    
    Retourne la liste des entiers positifs inférieurs ou égaux à n qui sont divisibles par m."""
    
    # L : list[int]
    L = [] # la liste calculéée
    
    # i : int
    for i in range(0, n+1):
        if i % m == 0:
            L.append(i)
            
    return L

liste_divisibles(18, 6)

liste_divisibles(0, 6)

liste_divisibles(18, 3)

liste_divisibles(20, 3)

L = [0,1,2]
print (len(L))
print (L[0])
print (L[1])
print (L[2])

def valeurs_positives_positions(L):
    """list[Number]-> list[(Number, int)]
    
    Retourne la liste de couples contenant les valeurs positives et leurs position dans X."""
    
    # N : list[Number]
    N = [] # liste fabriquée
    
    # n : int 
    n = len(L)
    
    # i : int # position
    for i in range(0, n):
        if L[i] >= 0:
            N.append((L[i], i))
        
    return N

valeurs_positives_positions([3, -2, 4.5, 0, -1, 1.8])

valeurs_positives_positions([])

def derniers(L):
    """list[str] -> list[str]
    
    Retourne la liste des derniers caractères de chacune des chaînes de L."""
    
    # S : list[str]
    S = [] # liste créée
    
    # x : int (nombre de chaînes de caractères)
    x = len(L) 
    
    # i : int (position dans L)
    for i in range(0, x):
        if L[i] == "":
            S.append(L[i])
        else: 
            C = L[i] # C : str (liste de caractères dans L)
            S.append(C[-1])
        
    return S

derniers(["abc", "de", "fghi", "j"])

derniers(["abc", "", "fghi"])

derniers([])

def valeurs_contraintes(L):
    """list[Number] -> list[Number]
    
    Retourne la liste des valeurs de L qui sont précédées d'exactement deux valeurs strictement positives
    et qui sont suivies d'exactement deux valeurs strictement positives."""
    
    # res : list[Number] (liste recherchée)
    res = []
    
    # i : int
    for i in range(2, (len(L) - 3)):
        if (L[i - 2] > 0) and (L[i - 1] > 0) and (L[i + 1] > 0) and (L[i + 2] > 0):
            res.append(L[i]) 
            
    return res

valeurs_contraintes([])

valeurs_contraintes([1])

valeurs_contraintes([-3, 1, 2, 6, 4, 5, -4, 1, -3, 1, 2, -2, 1, 4, 0])

valeurs_contraintes([1,2,3,4,5])

def positonN(L, x, n):
    """list[Number] * Number * int -> int
    hypothèse n > 0
    
    Retourne l'entier i tel qu'il y a n occurrences de x entre 0 et i incluses de L."""
    
    # x : Number
    for x in L:
        # n : int
        n = 1
        n = n + 1
        
        # x : Number
        for i range(0, len(L[-1]):
                    if x = L[i]:
                    L[i + 1] = 
         
 
            
    return i

positionN([1.6, 2.5, 3.2, 1.6, 4.6, 1.6, 1.6, 5.8], 1.6, 1)