Aller au contenu

Extremum

Chaque exercice est fourni avec un fichier Python à compléter et un énoncé « papier » distribué à l'élève et reproduit ci-dessous.

Remarque importante

Les exercices de cette page ne sont pas classés par ordre de « difficulté », cette notion de difficulté étant subjective et dépendante de chaque élève.

Maximum☘

Écrire une fonction maximum() qui prend en paramètre un tableau non vide d'entiers tab et qui renvoie le plus grand élément de ce tableau.

Exemple

>>> maximum([98, 12, 104, 23, 131, 9])
131

>>> maximum([-27, 24, -3, 15])
24

>>> maximum([])
AssertionError: Tableau vide !

  1. Compléter la définition de la fonction maximum(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
    def maximum(tab):
    """
    tab - 
    Sortie: 
    >>> maximum([98, 12, 104, 23, 131, 9])
    131
    >>> maximum([-27, 24, -3, 15])
    24
    """
    pass



if __name__ == '__main__':
    import doctest
    doctest.testmod()

  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def maximum(tab):
    """
    tab - list, tableau non vide d'entiers
    Sortie: int - Plus grand élément de tab
    >>> maximum([98, 12, 104, 23, 131, 9])
    131
    >>> maximum([-27, 24, -3, 15])
    24
    """
    assert tab != [], "Tableau vide !"
    maxi = tab[0]
    for elt in tab:
        if elt > maxi:
            maxi = elt
    return maxi


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(maximum([1]) == 1)    
    print(maximum([8, 8, 8, 8]) == 8)

Indice du minimum☘

Écrire le code d’une fonction indice_du_min() qui prend en paramètre un tableau d’entiers non vide et non trié tab, et qui renvoie l'indice de la première occurrence du minimum de ce tableau.

Exemple

>>> indice_du_min([5])
0

>>> indice_du_min([2, 4, 1])
2

>>> indice_du_min([5, 3, 1, 1, 4])
2

>>> indice_du_min([])
AssertionError: tableau vide !

  1. Compléter la définition de la fonction indice_du_min(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    def indice_du_min(tab):
    """
    tab - 
    Sortie: 
    >> indice_du_min([5])
    0
    >>> indice_du_min([2, 4, 1])
    2
    >>> indice_du_min([5, 3, 1, 1, 4])
    2
    """
    pass



if __name__ == '__main__':
    import doctest
    doctest.testmod()

  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution
 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
def indice_du_min(tab):
    """
    tab - list, tableau non vide d'entiers
    Sortie: int, indice de la première occurrence du minimum dans tab
    >> indice_du_min([5])
    0
    >>> indice_du_min([2, 4, 1])
    2
    >>> indice_du_min([5, 3, 1, 1, 4])
    2
    """
    assert tab != [], "Tableau vide !"
    indice_du_min = 0
    for i in range(len(tab)):
        if tab[i] < tab[indice_du_min]:
            indice_du_min = i
    return indice_du_min


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(indice_du_min([1]) == 0)    
    print(indice_du_min([8, 8, 8, 8]) == 0)

Maximum et son indice☘

Écrire une fonction maxi() qui prend en paramètre un tableau tab de nombres entiers et qui renvoie un couple donnant le plus grand élément de ce tableau ainsi que l’indice de la première apparition de ce maximum dans le tableau.

Exemple

>>> maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
(9, 3)

>>> maxi([])
AssertionError: Tableau vide !

  1. Compléter la définition de la fonction maxi(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    def maxi(tab):
    """
    tab - 
    Sortie: 
    >>> maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
    (9, 3)
    """
    pass



if __name__ == '__main__':
    import doctest
    doctest.testmod()

  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def maxi(tab):
    """
    tab - list, tableau d'entiers
    Sortie: tuple - couple constitué du maximum de tab
            et indice de la première apparition de ce maximum dans tab
    >>> maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
    (9, 3)
    """
    assert tab != [], "Tableau vide !"
    pge = tab[0]
    i_pge = 0
    for i in range(1, len(tab)):
        if tab[i] > pge:
            pge = tab[i]
            i_pge = i
    return (pge, i_pge)


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(maxi([1]) == (1, 0))    
    print(maxi([8, 8, 8, 8]) == (8, 0))

Correspondance avec un autre tableau☘

La fonction temp_mini() doit prendre en paramètres :

  • un tableau releve de valeurs moyennes annuelles des températures dans une ville ;
  • un tableau date des années de relevé des valeurs moyennes annuelles précédentes.

Cette fonction renvoie un couple constitué de la plus petite température relevée au cours de la période et l’année correspondante. En cas d'apparition multiple de cette température, c'est l'année la plus récente qui est renvoyée.

Exemple

On a relevé les valeurs moyennes annuelles des températures à Paris pour la période allant de 2013 à 2019. Les résultats ont été récupérés sous la forme de deux tableaux : l’un pour les températures, l’autre pour les années : 

>>> t_moy = [14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7]
>>> annees = [2013, 2014, 2015, 2016, 2017, 2018, 2019]

>>> temp_mini(t_moy, annees)
(12.5, 2016)

>>> t_moy = [14.9, 13.3]
>>> annees = [2013]

>>> temp_mini(t_moy, annees)
AssertionError: Les deux tableaux n'ont pas le même nombre d'élément

  1. Compléter la définition de la fonction temp_mini(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.
    On admet qu'aucun des tableaux passé en paramètre n'est vide - inutile de faire une assertion pour ce cas.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    def temp_mini(releve, date):
    """
    releve - 
    date - 
    Sortie: 
    >>> t_moy = [14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7]
    >>> annees = [2013, 2014, 2015, 2016, 2017, 2018, 2019]
    >>> temp_mini(t_moy, annees)
    (12.5, 2016)
    """
    pass



if __name__ == '__main__':
    import doctest
    doctest.testmod()

  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution
 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
def temp_mini(releve, date):
    """
    releve - list, tableau de flottants représentant des températures
             moyennes annuelles
    date - list, tableaux d'entiers représentant les dates des relevés
           précédents, de même longueur que releve
    Sortie: tuple, couple constitué du plus petit élément de releve
            et de la valeur de même indice dans le tableau date.
            L'année la plus récente possible est renvoyée
    >>> t_moy = [14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7]
    >>> annees = [2013, 2014, 2015, 2016, 2017, 2018, 2019]
    >>> temp_mini(t_moy, annees)
    (12.5, 2016)
    """
    assert len(releve) == len(date), "Les deux tableaux n'ont pas le même nombre d'élément"
    temp_mini = releve[0]
    date_mini = date[0]
    for i in range(len(releve)):
        if releve[i] <= temp_mini:
            temp_mini = releve[i]
            date_mini = date[i]
    return temp_mini, date_mini


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    t_moy = [14.2, 17.4, 9.5, 12.1, 6.6, 8.7, 17.5, 19.6]
    annees = [2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009]

    print(temp_mini(t_moy, annees) == (6.6, 2006))

    t_moy = [11.9, 5.5, 15.2, 6.0, 7.3, 5.5]
    annees = [2008, 2009, 2010, 2011, 2012, 2013]

    print(temp_mini(t_moy, annees) == (5.5, 2013))

Correspondances avec un autre tableau☘

La fonction meilleures_notes() doit prendre en paramètres :

  • un tableau noms_eleves de noms d'élèves dans une classe ;
  • un tableau notes_eleves des notes obtenues par les élèves précédents à une évaluation.

Cette fonction renvoie un triplet constitué de la plus grande note obtenue, du nombre d'élèves ayant obtenu cette note et d'un tableau des noms des élèves ayant eu cette meilleure note.

Exemple

Avec une évaluation sur 100, on peut avoir : 

>>> noms_eleves = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
>>> notes_eleves = [1, 40, 80, 60, 58, 80, 75, 80, 60, 24]

>>> meilleures_notes(noms_eleves, notes_eleves) 
(80, 3, ['c', 'f', 'h'])

>>> noms_eleves = ['a', 'b', 'c']
>>> notes_eleves = [1, 40]

>>> meilleures_notes(noms_eleves, notes_eleves) 
AssertionError: Les deux tableaux n'ont pas le même nombre d'élément

  1. Compléter la définition de la fonction meilleures_notes(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.
    On admet qu'aucun des tableaux passé en paramètre n'est vide - inutile de faire une assertion pour ce cas.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    def meilleures_notes(noms, notes):
    """
    noms - 
    notes - 
    Sortie: 
    >>> noms_eleves = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
    >>> notes_eleves = [1, 40, 80, 60, 58, 80, 75, 80, 60, 24]
    >>> meilleures_notes(noms_eleves, notes_eleves) 
    (80, 3, ['c', 'f', 'h'])
    """
    pass



if __name__ == '__main__':
    import doctest
    doctest.testmod()

  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution
 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 meilleures_notes(noms, notes):
    """
    noms - list, tableau de chaînes de caractères représentant des noms d'élèves
    notes - list, tableaux d'entiers représentant les notes de ces élèves à une évaluation
    Sortie: tuple, triplet constitué de la plus grande note obtenue,
            du nombre d'élèves ayant obtenu cette note et d'un tableau des noms
            des élèves ayant eu cette meilleure note.
    >>> noms_eleves = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
    >>> notes_eleves = [1, 40, 80, 60, 58, 80, 75, 80, 60, 24]
    >>> meilleures_notes(noms_eleves, notes_eleves) 
    (80, 3, ['c', 'f', 'h'])
    """
    assert len(noms) == len(notes), "Les deux tableaux n'ont pas le même nombre d'élément"
    note_maxi = 0
    nb_eleves_note_maxi = 0
    eleves_maxi =  []

    for compteur in range(len(noms)):
        if notes[compteur] == note_maxi:
            nb_eleves_note_maxi = nb_eleves_note_maxi + 1
            eleves_maxi.append(noms[compteur])

        if notes[compteur] > note_maxi:
            note_maxi = notes[compteur]
            nb_eleves_note_maxi = 1
            eleves_maxi = [noms[compteur]]

    return (note_maxi, nb_eleves_note_maxi, eleves_maxi)


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    noms_eleves = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
    notes_eleves = [25, 27, 98, 21, 50, 85, 56, 98, 60, 75]
    print(meilleures_notes(noms_eleves, notes_eleves) == (98, 2, ['c', 'h']) )

    from random import randint
    notes_eleves = [randint(1, 20) for _ in range(10)]
    print(notes_eleves)
    print(meilleures_notes(noms_eleves, notes_eleves))