Skip to content

L'indice du maximum☘

Exercice 1☘

Modifier le code (rappelé ci-dessous) permettant de déterminer la valeur maximale d'une liste de façon à renvoyer l'indice d'une occurrence du maximum plutôt que la valeur.

Rappel du code déterminant la valeur maximum

Le code que l'on a défini est le suivant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
def max_binaire(a,b):
    """
    a et b sont deux variables de valeurs comparables.
    La fonction renvoie  la plus grande des deux.
    """
    if a > b:
        return a
    else:
        return b

def max_tableau(tab):
    """
    tab est une liste d'éléments comparables.
    La fonction renvoie l'élément le plus grand.
    """
    m = tab[0]
    for x in tab:
        m = max_binaire(m,x)
    return m
Un code possible pour l'indice du max
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def indice_du_max_bin(t, i, j):
    """
    t est une liste, non vide, d'éléments comparables.
    i et j sont deux indices de t.
    La fonction renvoie i si t[i] > t[j] et renvoie j sinon.
    """
    if t[i] > t[j]:
        return i
    else:
        return j

def indice_du_max_tableau(tab):
    """
    tab est une liste, non vide, d'éléments comparables.
    La fonction renvoie l'indice d'une occurrence de la valeur maximale.
    """
    k = 0
    for j in range(1, len(tab)):
        k = indice_du_max_bin(tab, j, k)
    return k

# test
if __name__ == '__main__':
    from random import randint

    L = [ randint(1,10) for _ in range(randint(1,20))]
    print(L)
    k = indice_du_max_tableau(L)
    print(f"L[{k}] = {L[k]}")

Exercice 2☘

Le code proposé en solution pour l'exercice précédent renvoie toujours le plus petit indice correspondant à une valeur maximale de la liste.

Proposez une modification de ce code pour renvoyer le plus grand indice correspondant à une valeur maximale de la liste.

Un code possible

On peut simplement remplacer ">" par ">=" dans la fonction indice_du_max_bin.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def indice_du_max_bin(t, i, j):
    """
    t est une liste, non vide, d'éléments comparables.
    i et j sont deux indices de t.
    La fonction renvoie i si t[i] >= t[j] et renvoie j sinon.
    """
    if t[i] >= t[j]:
        return i
    else:
        return j

def indice_du_max_tableau(tab):
    """
    tab est une liste, non vide, d'éléments comparables.
    La fonction renvoie l'indice d'une occurrence de la valeur maximale.
    """
    k = 0
    for j in range(1, len(tab)):
        k = indice_du_max_bin(tab, j, k)
    return k

# test 
if __name__ == '__main__':
    from random import randint

    L = [ randint(1,10) for _ in range(randint(1,20))]
    print(L)
    k = indice_du_max_tableau(L)
    print(f"L[{k}] = {L[k]}")

Ou, ce qui revient au même, échanger j et k à l'appel de indice_du_max_bin dans la boucle de la fonction indice_du_max_tableau:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def indice_du_max_bin(t, i, j):
    """
    t est une liste, non vide, d'éléments comparables.
    i et j sont deux indices de t.
    La fonction renvoie i si t[i] > t[j] et renvoie j sinon.
    """
    if t[i] > t[j]:
        return i
    else:
        return j

def indice_du_max_tableau(tab):
    """
    tab est une liste, non vide, d'éléments comparables.
    La fonction renvoie l'indice d'une occurrence de la valeur maximale.
    """
    k = 0
    for j in range(1, len(tab)):
        k = indice_du_max_bin(tab, k, j)
    return k


if __name__ == '__main__':
    from random import randint

    L = [ randint(1,10) for _ in range(randint(1,20))]
    print(L)
    k = indice_du_max_tableau(L)
    print(f"L[{k}] = {L[k]}")

Exercice 3☘

En vous inspirant de l'exercice précédent, écrire une fonction qui renvoie l'indice d'une occurrence du maximum dans la liste donnée en paramètre. Contrairement aux versions précédentes qui renvoyaient toujours soit la première occurrence, soit la dernière, lorsque le maximum est présent plusieurs fois, l'occurrence renvoyée pourra être ici quelconque (pour une même liste, deux exécutions de la fonction ne donneront pas nécessairement la même occurrence).

Note

Pour simuler le hasard, on rappelle l'existence du module random.

Un code possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from random import randint

def indice_du_max_bin(t, i, j):
    """
    t est une liste, non vide, d'éléments comparables.
    i et j sont deux indices de t.
    La fonction renvoie i si t[i] > t[j] et renvoie j sinon.
    """
    if t[i] > t[j]:
        return i
    else:
        return j

def indice_du_max_tableau(tab):
    """
    tab est une liste, non vide, d'éléments comparables.
    La fonction renvoie l'indice d'une occurrence de la valeur maximale.
    """
    k = 0
    for j in range(1, len(tab)):
        if randint(0,1) == 0:
            k = indice_du_max_bin(tab, k, j)
        else:
            k = indice_du_max_bin(tab, j, k)
    return k


if __name__ == '__main__':

    L = [ 3, 4, 3, 4, 4, 3, 4, 3, 4 ]
    print(L)
    k = indice_du_max_tableau(L)
    print(f"L[{k}] = {L[k]}")

Autre version:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from random import randint

def indice_du_max_bin(t, i, j):
    """
    t est une liste, non vide, d'éléments comparables.
    i et j sont deux indices de t.
    La fonction renvoie i si t[i] >= t[j] et renvoie j sinon.
    """
    if randint(0,1) == 0:
        if t[i] >= t[j]:
            return i
        else:
            return j
    else:
        if t[i] > t[j]:
            return i
        else:
            return j

def indice_du_max_tableau(tab):
    """
    tab est une liste, non vide, d'éléments comparables.
    La fonction renvoie l'indice d'une occurrence de la valeur maximale.
    """
    k = 0
    for j in range(1, len(tab)):
        k = indice_du_max_bin(tab, j, k)
    return k

# test 
if __name__ == '__main__':
    L = [ 3, 4, 3, 4, 4, 3, 4, 3, 4 ]
    print(L)
    k = indice_du_max_tableau(L)
    print(f"L[{k}] = {L[k]}")