Skip to content

Le maximum suivant un critère donné☘

Exercice 1☘

On dispose de listes de uplets d'entiers.

Par exemple:

1
L = [ (12, 13, 16), (7, 8, 5, 3, 13), (17,15, 19), (2, 20, 14, 19)]

Ces listes correspondent aux notes d'élèves (dans l'exemple, L[0] est constitué des 3 notes d'un élève, L[1] des 5 notes d'un autre élève...).

Question 1☘

Ecrire une fonction python prenant en entrée deux uplets d'entiers et renvoyant le uplet correspondant à la plus forte moyenne.

Info

Le mot uplet de traduit en anglais par tuple. On parle de p-uplet pour un uplet ayant p composantes. Par exemple, (1,3,5) est un 3-uplet (ou triplet). (4,8) est un 2-uplet (ou couple). Un 4-uplet est aussi appelé quadruplet...

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
def moyenne(a):
    """
    a est un  uplet de nombres.
    La fonction renvoie le flottant moyenne des composantes du  uplet.
    """
    somme = 0
    for x in a:
        somme += x
    return somme/len(a)



def plus_grande_moyenne(a,b):
    if moyenne(a) > moyenne(b):
        return a
    else:
        return b

# exemple d'utilisation
if __name__ == '__main__':

    albert = (12,13,14)
    barnabe = (8, 19, 17)
    print(f"Moyenne de Albert: {moyenne(albert)}.")
    print(f"Moyenne de Barnabé: {moyenne(barnabe)}.")

    print(f"Meilleur résultat en moyenne: {plus_grande_moyenne(albert, barnabe)}.")

Affichage obtenu:

1
2
3
Moyenne de Albert: 13.0.
Moyenne de Barnabé: 14.666666666666666.
Meilleur résultat en moyenne: (8, 19, 17).

Question 2☘

En utilisant le code de la fonction extreme_tableau (vu dans cette page et rappelé ci-dessous), écrire une fonction prenant en paramètre une liste de notes (comme définie plus haut) et renvoyant le tuple de notes correspondant à la moyenne la plus forte.

Rappel du code de extreme_tableau

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

1
2
3
4
5
6
7
8
9
def extreme_tableau(tab, extreme_binaire):
    """
    tab est une liste d'éléments "comparables".
    La fonction renvoie un élément extremum.
    """
    m = tab[0]
    for x in tab:
        m = extreme_binaire(m,x)
    return m
Une solution

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
34
35
36
37
38
39
40
41
42
def moyenne(a):
    """
    a est un p-uplet de nombres.
    La fonction renvoie le flottant moyenne des composantes du p-uplet.
    """
    somme = 0
    for x in a:
        somme += x
    return somme/len(a)



def plus_grande_moyenne(a,b):
    if moyenne(a) > moyenne(b):
        return a
    else:
        return b


def extreme_tableau(tab, extreme_binaire):
    """
    tab est une liste d'éléments "comparables".
    La fonction renvoie un élément extremum.
    """
    m = tab[0]
    for x in tab:
        m = extreme_binaire(m,x)
    return m



def plus_forte_moyenne_tableau(resultats):
    return  extreme_tableau(resultats, plus_grande_moyenne)   

# exemple d'utilisation    
if __name__ == '__main__':

    L = [ (12, 13, 16), (7, 8, 5, 3, 13), (17,15, 19), (2, 20, 14, 19)]
    print(f"tuple de notes à plus forte moyenne: {plus_forte_moyenne_tableau(L)}." )

    for resultat in L:
        print(f"Moyenne pour {resultat}: {moyenne(resultat)}")

L'affichage obtenu:

1
2
3
4
5
tuple de notes à plus forte moyenne: (17, 15, 19).
Moyenne pour (12, 13, 16): 13.666666666666666
Moyenne pour (7, 8, 5, 3, 13): 7.2
Moyenne pour (17, 15, 19): 17.0
Moyenne pour (2, 20, 14, 19): 13.75

Exercice 2☘

On dispose comme dans l'exercice précédent de listes de uplets de notes d'élèves.

Ecrire une fonction qui renvoie le tuple de plus grande amplitude où l'amplitude d'un tuple est l'écart entre sa plus grande valeur et sa plus petite valeur.

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def plus_grand_binaire(a,b):
    if a > b: 
        return a
    else: 
        return b

def plus_petit_binaire(a,b):
    if a < b: 
        return a
    else: 
        return b



def extreme_tableau(tab, extreme_binaire):
    """
    tab est une liste d'éléments "comparables".
    La fonction renvoie l'élément le plus "extrême".
    """
    m = tab[0]
    for x in tab:
        m = extreme_binaire(m,x)
    return m



def max_tuple(resultat_eleve):
    return extreme_tableau(resultat_eleve, plus_grand_binaire)

def min_tuple(resultat_eleve):
    return extreme_tableau(resultat_eleve, plus_petit_binaire)  

def amplitude(resultat_eleve):
    return max_tuple(resultat_eleve) - min_tuple(resultat_eleve)


def plus_grande_amplitude_binaire(r1, r2):
    if amplitude(r1) > amplitude(r2):
        return r1
    else:
        return r2


def plus_forte_amplitude_tableau(resultats):
    return  extreme_tableau(resultats, plus_grande_amplitude_binaire)   

# exemple d'utilisation    
if __name__ == '__main__':

    L = [ (12, 13, 16), (7, 8, 5, 3, 13), (17,15, 19), (2, 20, 14, 19)]
    print(f"tuple de notes à plus forte amplitude: {plus_forte_amplitude_tableau(L)}." )

    for resultat in L:
        print(f"Amplitude pour {resultat}: {amplitude(resultat)}")

Affichage obtenu:

1
2
3
4
5
tuple de notes à plus forte amplitude: (2, 20, 14, 19).
Amplitude pour (12, 13, 16): 4
Amplitude pour (7, 8, 5, 3, 13): 10
Amplitude pour (17, 15, 19): 4
Amplitude pour (2, 20, 14, 19): 18