Aller au contenu

Sujet n°34

Sujet original

Pour télécharger l'énoncé original, cliquer ici.

Exercice n°1

Écrire une fonction occurrence_max prenant en paramètres une chaîne de caractères chaine et qui renvoie le caractère le plus fréquent de la chaîne. La chaine ne contient que des lettres en minuscules sans accent.

On pourra s’aider du tableau

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
et du tableau occurrence de 26 éléments où l’on mettra dans occurrence[i] le nombre d’apparitions de alphabet[i] dans la chaine. Puis on calculera l’indice k d’un maximum du tableau occurrence et on affichera alphabet[k].

Erreur dans l'énoncé initial

Il y avait une virgule en trop dans la chaîne de caractère 'o' :

alphabet=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o,','p','q','r','s','t','u','v','w','x','y','z']

Exemples

>>> ch="""je suis en terminale et je passe le bac et je souhaite
poursuivre des etudes pour devenir expert en informatique"""
>>> occurrence_max(ch)
'e'
Une solution

Une solution avec un dictionnaire :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def occurrence_max(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: str - le caractère le plus fréquent de la chaîne
    """
    alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
                'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

    occurrence = {alphabet[i]:0 for i in range(26)}
    for carac in chaine:
        if carac in alphabet :
            occurrence[carac] += 1
    maxi = 0
    for clef in occurrence.keys():
        if occurrence[clef] > maxi:
            maxi = occurrence[clef]
            lettre_maxi = clef
    return lettre_maxi

if __name__ == '__main__':
    ch = 'je suis en terminale et je passe le bac et je souhaite poursuivre des etudes pour devenir expert en informatique'

    print(occurrence_max(ch) == 'e')

Une autre solution

Une solution avec une fonction supplémentaire

 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 indice(carac, alphabet):
    """
    carac - str, un caractère
    alphabet - list, tableau des 26 lettres de l'alphabet
    Sortie: int - indice de carac dans alphabet
    """
    for i in range(26):
        if alphabet[i] == carac:
            return i
    return -1

def occurrence_max(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: str - le caractère le plus fréquent de la chaîne
    """
    alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
                'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

    occurrence = [0]*26
    for carac in chaine:
        i = indice(carac, alphabet)
        if i != -1:
            occurrence[i] += 1
    maxi = occurrence[0]
    indice_maxi = 0
    for i in range(1, 26):
        if occurrence[i] > maxi:
            maxi = occurrence[i]
            indice_maxi = i
    return alphabet[indice_maxi]

if __name__ == '__main__':
    ch = 'je suis en terminale et je passe le bac et je souhaite poursuivre des etudes pour devenir expert en informatique'

    print(occurrence_max(ch) == 'e')

Encore une solution

Une solution avec les fonctions chr() et ord() sachant que ord('a') vaut 97.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
def occurrence_max(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: str - le caractère le plus fréquent de la chaîne
    """
    occurrence = [0]*26
    for carac in chaine:
        if 'a' <= carac <= 'z':
            occurrence[ord(carac)-97] += 1
    maxi = occurrence[0]
    indice_maxi = 0
    for i in range(1, 26):
        if occurrence[i] > maxi:
            maxi = occurrence[i]
            indice_maxi = i
    return chr(indice_maxi+97)

if __name__ == '__main__':
    ch = 'je suis en terminale et je passe le bac et je souhaite poursuivre des etudes pour devenir expert en informatique'

    print(occurrence_max(ch) == 'e')

Exercice n°2

On considère une image en 256 niveaux de gris que l’on représente par une grille de nombres, c’est-à-dire une liste composée de sous-listes toutes de longueurs identiques.

La largeur de l’image est donc la longueur d’une sous-liste et la hauteur de l’image est le nombre de sous-listes.

Chaque sous-liste représente une ligne de l’image et chaque élément des sous-listes est un entier compris entre 0 et 255, représentant l’intensité lumineuse du pixel.

Commentaires

Dans cet énoncé, le mot « liste » est à comprendre dans le sens « liste Python » (c'est-à-dire tableau) plutôt que dans le sens du type abstrait de données liste étudié en Terminale.

Compléter le programme ci-dessous :

 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
def nbLig(image):
    '''renvoie le nombre de lignes de l'image'''
    return ...

def nbCol(image):
    '''renvoie la largeur de l'image'''
    return ...

def negatif(image):
    '''renvoie le négatif de l'image sous la forme 
       d'une liste de listes'''
    # on créé une image de 0 aux mêmes dimensions que le paramètre image 
    L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))] 
    for i in range(nbLig(image)):
        for j in range(...):
            L[i][j] = ...
    return L

def binaire(image, seuil):
    '''renvoie une image binarisée de l'image sous la forme 
       d'une liste de listes contenant des 0 si la valeur 
       du pixel est strictement inférieure au seuil 
       et 1 sinon'''
     # on crée une image de 0 aux mêmes dimensions que le paramètre image 
    L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))]
    for i in range(nbLig(image)):
        for j in range(...):
            if image[i][j] < ... :
                L[i][j] = ...
            else:
                L[i][j] = ...
    return L
Commentaires sur le code original
  1. Pour télécharger l'original du fichier à compléter, cliquer ici.

  2. En lignes 14 et 28, le code original donnait l'instruction renvoyée par la fonction nbLig(), ce qui rend inutile cette fonction... pourtant utilisée dans les définitions par compréhension des lignes 13 et 25.

Exemple

>>> img=[[20, 34, 254, 145, 6], [23, 124, 287, 225, 69], [197,
174, 207, 25, 87], [255, 0, 24, 197, 189]]
>>> nbLig(img)
4
>>> nbCol(img)
5
>>> negatif(img)
[[235, 221, 1, 110, 249], [232, 131, -32, 30, 186], [58, 81, 48,
230, 168], [0, 255, 231, 58, 66]]
>>> binaire(img, 120)
[[0, 0, 1, 1, 0], [0, 1, 1, 1, 0], [1, 1, 1, 0, 0], [1, 0, 0, 1, 1]]
Exemples originaux avec erreurs
>>> img=[[20, 34, 254, 145, 6], [23, 124, 287, 225, 69], [197,
174, 207, 25, 87], [255, 0, 24, 197, 189]]
>>> nbLig(img)
4
>>> nbCol(img)
5
>>> negatif(img)
[[235, 221, 1, 110, 249], [232, 131, -32, 30, 186], [58, 81, 48,
230, 168], [0, 255, 231, 58, 66]]
>>> binaire(img, 120)
[[1, 1, 0, 0, 1], [1, 1, 0, 0, 1], [0, 0, 0, 1, 1], [0, 1, 1, 0,
0]]
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
def nbLig(image):
    '''renvoie le nombre de lignes de l'image'''
    return len(image)

def nbCol(image):
    '''renvoie la largeur de l'image'''
    return len(image[0])

def negatif(image):
    '''renvoie le négatif de l'image sous la forme 
       d'une liste de listes'''
    L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))] # on créé une image de 0 aux mêmes dimensions que le paramètre image 
    for i in range(nbLig(image)):
        for j in range(nbCol(image)):
            L[i][j] = 255-image[i][j]
    return L

def binaire(image, seuil):
    '''renvoie une image binarisée de l'image sous la forme 
       d'une liste de listes contenant des 0 si la valeur 
       du pixel est strictement inférieure au seuil 
       et 1 sinon'''
    L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))] # on crée une image de 0 aux mêmes dimensions que le paramètre image 
    for i in range(nbLig(image)):
        for j in range(nbCol(image)):
            if image[i][j] < seuil :
                L[i][j] = 0
            else:
                L[i][j] = 1
    return L

if __name__ == '__main__':
    img=[[20, 34, 254, 145, 6], [23, 124, 87, 225, 69], [197, 174, 207, 25, 87], [255, 0, 24, 197, 189]]
    print(nbLig(img) == 4)
    print(nbCol(img) == 5)

    print(negatif(img) == [[235, 221, 1, 110, 249], [232, 131, 168, 30, 186],
[58, 81, 48, 230, 168], [0, 255, 231, 58, 66]])

    print(binaire(img, 120) == [[0, 0, 1, 1, 0], [0, 1, 0, 1, 0], [1, 1, 1, 0, 0],
[1, 0, 0, 1, 1]])