Skip to content

Chaîne maximale☘

On compare les mots en utilisant l'ordre du dictionnaire (ou ordre alphabétique). Notre fonction de recherche du maximum semble bien fonctionner dans le code ci-dessous puisque l'on obtient "diable" comme attendu.

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


if __name__ == '__main__':

    L = ["abaque", "ancre", "barque", "cancre",  "diable", "animal", "caramel"]
    m = max_tableau(L)
    print(m)

Exercice 1☘

Remplacer "diable" par "Diable". Quel est maintenant le maximum? Avez-vous une explication?

Nouveau max

Avec le code:

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


if __name__ == '__main__':

    L = ["abaque", "ancre", "barque", "cancre",  "Diable", "animal", "caramel"]
    m = max_tableau(L)
    print(m)

On obtient caramel comme maximum.

Une explication

Le code suivant:

1
2
>>> 'Z' < 'a'
True

montre que 'Z' est avant 'a'. Faites quelques tests. On a en fait:

'A' < 'B' < ... < 'Z' < 'a' < 'b' < ... < 'z'

Les majuscules sont donc inférieures à toutes les minuscules. Ceci explique le nouveau maximum de la liste L.

Et 'Diable' est même maintenant le minimum: 

1
2
3
>>> L = ["abaque", "ancre", "barque", "cancre",  "Diable", "animal", "caramel"]
>>> min(L)
'Diable'

Exercice 2☘

Modifier le code précédent pour que l'on ait un classement des mots dans lequel chaque majuscule est considérée comme "égale" à la minuscule correspondante.

Vérifier que la liste L = ["abaque", "ancre", "barque", "cancre", "Diable", "animal", "caramel"] a bien alors 'Diable' pour valeur maximale.

Une solution

Il suffit de comparer les mots écrits uniquement en minuscules. Pour cela, on a ici écrit une fonction transformant un mot en ce même mot mais ne comportant que des minuscules.

 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
def passage_en_minuscules(mot):
    """
    mot est de type str, mot est constitué de lettres de 
    l'alphabet majuscules ou minuscules.
    La fonction renvoie le mot en minuscules.
    Remarque: on pourra compléter cette fonction en traitant les lettres
    accentuées...
    """
    dico = {}
    alphabet = "abcdefghijklmnopqrstuvwxyz"
    ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    for i in range(26):
        dico[ALPHABET[i]] =  alphabet[i]

    mot_minuscule = ''
    for lettre in mot:
        if lettre in ALPHABET:
            mot_minuscule += dico[lettre]
        else:
            mot_minuscule += lettre
    return mot_minuscule


def max_binaire(a,b):
    """
    a et b sont deux variables de type str.
    La fonction renvoie  la plus grande des deux, une majuscule
    étant considérée comme identique à sa minuscule.
    """
    a_minuscule = passage_en_minuscules(a)
    b_minuscule = passage_en_minuscules(b)
    if a_minuscule > b_minuscule:
        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


if __name__ == '__main__':

    L = ["abaque", "ancre", "barque", "cancre",  "Diable", "animal", "caramel"]
    m = max_tableau(L)
    print(m)

Note

La fonction renvoyant le mot correspondant en minuscules est en fait déjà prédéfinie en python. Consultez cette page de la documentation python. Et ce passage pour le passage en majuscules.

Mini projet☘

Ecrire une fonction renvoyant le maximum d'une liste de mots sachant que l'on doit avoir:

'A' < 'a' < 'B' < 'b' < 'C' < 'c' < ... < 'Z' < 'z'.