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.

Remarques importantes

  1. 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.

  2. Les solutions proposées ne sont que des propositions !
    Il existe d'autres codes valables pour répondre à chaque problème que ceux proposés ici : il ne faut pas hésiter à les soumettre à votre enseignant pour qu'il vous donne son avis sur les idées mises en oeuvre.

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 possible
 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 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
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 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
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))

Minimum et ses indices☘

Écrire une fonction indices_du_mini() qui prend en paramètre un tableau non vide tab de nombres entiers et qui renvoie un couple donnant le plus petit élément de ce tableau ainsi que le tableau des indices des apparitions de ce minimum dans le tableau.

Exemple

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

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

  1. Compléter la définition de la fonction indices_du_mini(), 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 indices_du_mini(tab):
    """
    tab - 
    Sortie: 
    >>> indices_du_mini([2, 1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
    (1, [1, 5])
    """
    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 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 indices_du_mini(tab):
    """
    tab - list, tableau non vide d'entiers
    Sortie: tuple - couple constitué du minimum de tab
            et du tableau des indices des apparition de ce minimum dans tab
    >>> indices_du_mini([2, 1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
    (1, [1, 5])
    """
    assert tab != [], "Tableau vide !"
    tab_des_indices = [0]
    mini = tab[0]
    for i in range(1, len(tab)):
        if tab[i] == mini:
            tab_des_indices.append(i)
        elif tab[i] < mini:
            mini = tab[i]
            tab_des_indices = [i]
    return mini, tab_des_indices


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

    print(indices_du_mini([1]) == (1, [0]))    
    print(indices_du_mini([8, 8, 8, 8]) == (8, [0, 1, 2, 3]))    
    print(indices_du_mini([5, 4, 3, 2]) == (2, [3]))

Minimum jusqu'à☘

Écrire une fonction mini_jusqu_a() qui prend en paramètres en paramètres un tableau non vide tab et un indice i d'un élément de ce tableau.

Cette fonction renvoie l'élément de plus petite valeur parmi les éléments tab[0], tab[1], ..., jusqu'à tab[i] inclus.

Exemple

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

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

>>> mini_jusqu_a([98, 23, 104, 131, 9, 12], 7)
AssertionError: tab index out of range

  1. Compléter la définition de la fonction mini_jusqu_a(), 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
    def mini_jusqu_a(tab, i):
    """
    tab - 
    i - 
    Sortie: 
    >>> mini_jusqu_a([98, 23, 104, 131, 9, 12], 3)
    23
    >>> mini_jusqu_a([98, 23, 104, 131, 9, 12], 4)
    9
    """
    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 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
def mini_jusqu_a(tab, i):
    """
    tab - list, tableau de n entiers
    i - int, entier compris entre 0 et n-1
    Sortie: int – valeur du minimum dans le sous-tableau tab[0..i]
    >>> mini_jusqu_a([98, 23, 104, 131, 9, 12], 3)
    23
    >>> mini_jusqu_a([98, 23, 104, 131, 9, 12], 4)
    9
    """
    assert 0 <= i < len(tab), "tab index out of range"
    mini = tab[0]
    for k in range(i+1):
        if tab[k] < mini:
            mini = tab[k]
    return mini


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

    print(mini_jusqu_a([1], 0) == 1)    
    print(mini_jusqu_a([8, 8, 8, 8], 2) == 8)  
    print(mini_jusqu_a([7, 3, 4, 1, 11], 2) == 3)
    print(mini_jusqu_a([7, 3, 4, 1, 11], 4) == 1)

Maximum à partir de☘

Écrire une fonction maxi_a_partir_de() qui prend en paramètres en paramètres un tableau non vide tab et un indice i d'un élément de ce tableau.

Cette fonction renvoie l'élément de plus grande valeur parmi les éléments tab[i], tab[i+1], ..., jusqu'au dernier élément de tab inclus.

Exemple

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

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

>>> maxi_a_partir_de([98, 23, 104, 131, 9, 12], 7)
AssertionError: tab index out of range

  1. Compléter la définition de la fonction maxi_a_partir_de(), 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
    def maxi_a_partir_de(tab, i):
    """
    tab - 
    i - 
    Sortie: 
    >>> maxi_a_partir_de([98, 23, 104, 131, 9, 12], 3)
    131
    >>> maxi_a_partir_de([98, 23, 104, 131, 9, 12], 4)
    12
    """
    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 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
def maxi_a_partir_de(tab, i):
    """
    tab - list, tableau de n entiers
    i - int, entier compris entre 0 et n-1
    Sortie: int – valeur du maximum dans le sous-tableau tab[i..]
    >>> maxi_a_partir_de([98, 23, 104, 131, 9, 12], 3)
    131
    >>> maxi_a_partir_de([98, 23, 104, 131, 9, 12], 4)
    12
    """
    assert 0 <= i < len(tab), "tab index out of range"
    maxi = tab[i]
    for k in range(i+1, len(tab)):
        if tab[k] > maxi:
            maxi = tab[k]
    return maxi


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

    print(maxi_a_partir_de([1], 0) == 1)    
    print(maxi_a_partir_de([8, 8, 8, 8], 2) == 8)  
    print(maxi_a_partir_de([11, 3, 4, 1, 7], 2) == 7)
    print(maxi_a_partir_de([11, 3, 4, 1, 7], 0) == 11)

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 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
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 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 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))

Plus longue suite de caractères☘

Écrire le code d'une fonction compter_suite() qui prend en paramètres une chaîne de caractères nommée chaine ainsi qu'un unique caractère nommé lettre. Cette fonction renvoie le plus grand nombre d'occurrences consécutives de lettre dans chaine.

Exemple

>>> compter_suite('DDDDDDGGGGDDDGDDDDGGGGGGGGDDDDDDDDDDGGD', 'D')
10

>>> compter_suite('33391119099030111140700411111671689431110092', '1')
5

>>> compter_suite('33391119099030111140700411111671689431110092', '11')
AssertionError: Le second argument doit être un unique caractère.

  1. Compléter la définition de la fonction compter_suite(), 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
    def compter_suite(chaine, lettre):
    """
    chaine – 
    lettre - 
    Sortie: 

    >>> compter_suite('DDDDDDGGGGDDDGDDDDGGGGGGGGDDDDDDDDDDGGD', 'D')
    10
    >>> compter_suite('33391119099030111140700411111671689431110092', '1')
    5
    """
    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 possible avec une boucle while
 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
def compter_suite(chaine, lettre):
    """
    chaine – str, une chaîne de caractères
    lettre - str, un seul caractère
    Sortie: int – plus grand nombre d'occurrences consécutives de lettre dans chaine

    >>> compter_suite('DDDDDDGGGGDDDGDDDDGGGGGGGGDDDDDDDDDDGGD', 'D')
    10
    >>> compter_suite('33391119099030111140700411111671689431110092', '1')
    5
    """
    assert len(lettre) == 1, "Le second argument doit être un unique caractère."
    nb_max = 0
    indice = 0
    while indice < len(chaine):
        nb_temp = 0
        while indice < len(chaine) and chaine[indice] == lettre:
            nb_temp += 1
            indice += 1
        if nb_temp > nb_max:
            nb_max = nb_temp
        indice += 1
    return nb_max


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

    print(compter_suite('33391119099030111140700411111671689431110092', '2') == 1)
    print(compter_suite('33391119099030111140700411111671689431110092', '3') == 3)
    print(compter_suite('33391119099030111140700411111671689431110092', '5') == 0)
    print(compter_suite('33391119099030111140700411111671689431110092', '9') == 2)
Une solution possible avec une boucle for
 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
def compter_suite(chaine, lettre):
    """
    chaine – str, une chaîne de caractères
    lettre - str, un seul caractère
    Sortie: int – plus grand nombre d'occurrences consécutives de lettre dans chaine

    >>> compter_suite('DDDDDDGGGGDDDGDDDDGGGGGGGGDDDDDDDDDDGGD', 'D')
    10
    >>> compter_suite('33391119099030111140700411111671689431110092', '1')
    5
    """
    assert len(lettre) == 1, "Le second argument doit être un unique caractère."
    nb_lettre = 0
    nb_temp = 0
    for i in range(1, len(chaine)):
        if chaine[i-1] == lettre:
            nb_temp += 1
            if chaine[i] != lettre:
                if nb_temp > nb_lettre:
                    nb_lettre = nb_temp
                nb_temp = 0
    if chaine[len(chaine)-1] == lettre:
        nb_temp += 1
        if nb_temp > nb_lettre:
            nb_lettre = nb_temp
    return nb_lettre


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

    print(compter_suite('33391119099030111140700411111671689431110092', '2') == 1)
    print(compter_suite('33391119099030111140700411111671689431110092', '3') == 3)
    print(compter_suite('33391119099030111140700411111671689431110092', '5') == 0)
    print(compter_suite('33391119099030111140700411111671689431110092', '9') == 2)