Vous êtes sur la page 1sur 9

Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

Code barre :

 On attachera une grande importance à la concision, à la précision de la rédaction qui doit se


faire obligatoirement en Python.
 Les parties du deuxième problème sont indépendantes.
 La question 21 est à traiter obligatoirement sur l’énoncé.
 Soit a et b deux entiers positifs, a//b donne le quotient de la division et a%b donne son reste.
 Soit L une liste, voici quelques fonctions et méthodes qui peuvent vous être utiles :
 len(L) donne la taille de L.
 L.append(x) permet d’ajouter x à la fin de la liste L.
 L.insert(i,x) permet d’insérer la valeur x à la position i.
 l.pop() dépile le dernier élément de L et retourne sa valeur.
 L.remove(x) permet de supprimer la première occurrence de x dans L.
 in et not in permet de vérifier l’appartenance ou non d’un élément à un ensemble d’éléments. La
complexité temporelle de x in L est d’ordre O(len(L))
 L’instruction for i in range(n, m, k) permet d’obtenir un itérateur
rateur de valeur initiale n, de pas k et de
valeur finale inférieure à m.
 Une matrice en Python peut être représentée comme une liste de listes
5 1 1
0 1 0 sera représentée par a=[[5, 1, 1], [0, 1, 0], [0, 0, 1]]
0 0 1
 m=[[0]*C for i in range(L)]; permet de créer une matrice vide (qui ne contient que des zéros) de L
lignes et C colonnes.
 Soit string=’mot1, mot2, mot3 mot3’ une chaîne de caractères,, voici quelques fonctions et méthodes qui
peuvent vous être utiles :
 string.find(sch) retourne la position (l’indice du début) de la première occurrence de la
sous-chaîne sch dans la chaîne chaine, en partant du début. Exemple : s.find(‘t2‘) 8
 La méthode split() () divise une chaîne en une liste. Vous pouvez spécifier le séparateur, le
séparateur par défaut étant n'importe quel espace.
string.split(‘,’) [‘mot1’, ‘ mot2’, ‘ mot3’]
Exemple : string.split(
 chaine.join(seq) : concatène les chaînes du conteneur seq en intercalant la chaîne sur laq laquelle
la méthode est appliquée
Exemple : ‘ :’.join([‘mot1’, mot3’]) ’mot1: mot2: mot3’
[‘mot1’, ‘ mot2’, ‘ mot3’]
 L’opérateur [ ] avec 2 ou 3 index séparés par le caractère : permet d’extraire des sous chaînes
(ou tranches) d’une chaîne :

1
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

I- Chaîne des caractères (5 points)


Dans un réseau informatique, chaque ordinateur se voit attribuer une adresse unique permettant
d’identifier cet ordinateur sur le réseau. Cette adresse est connue sous le nom d’adresse IP.
Une adresse IP version 6 est représentée par 8 blocs séparés par deux points, chaque bloc contient 4
caractères représentant les chiffres en hexadécimal (0, 1, 2 …, 9, a, b, c, d, e, f).
Exemple d’une adresse IP version 6 (IPv6) : fe80:0000:0000:0000:00ed:4eff:fe50:0020
Une adresse IPv6 est donc formé de :
 8 blocs ;
 4 caractères par bloc ;
 Chaque deux blocs sont séparé par deux points « : ».

1. Ecrivez la fonction EstValideIPv6(adIP) qui prend en paramètre une chaine de caractères contenant
une adresse IPv6 et qui permet de vérifier si cette adresse est valide (retourne True) ou non (retourne
False).
Pour réduire la taille d’une adresse, les zéros leaders (les zéros non significatifs) peuvent être omis. Les
règles visant à simplifier l’écriture d’une adresse IPV6 sont:
 Tout d’abord, on remplace les groupes :0000: par :0:
 Puis Pour compresser encore ces adresses on enlève les zéros qui commencent un groupe. Par
exemple le bloc :00ed: sera remplacé par :ed:
Exemple :
fe80:0000:0000:0000:00ed:04ef:fe50:0020
Après la simplification on a :
fe80:0:0:0:ed:4ef:fe50:20
2. Ecrivez la fonction SimplifierIPv6 (adIP) qui prend en paramètre une chaine de caractères contenant
une adresse IPv6 et qui permet de simplifier cette adresse.
Pour compresser encore ces adresses, on remplace la première suite de zéros consécutifs (deux ou plus)
de langueur maximale par ::
Exemple 1: Exemple 2: Exemple 3 :
fe80 :0:0:0:ed:0:0:0 0:0:0:0:0:0:0:1 fe80:0:0:3D:0:0:0:0
Après la compression sera : Après la compression sera: A près la compression sera :
fe80::ed:0:0:0 ::1 fe80:0:0:3d ::
3. Ecrivez la fonction suiteZeros(adIP) qui prend en paramètre une chaine de caractères contenant une
adresse IPv6 et qui retourne les indices du début et de la fin la première suite de zéros consécutifs de
langueur maximale (voir l’exemple ci-dessous).
Exemple : suiteZeros("fe80 :0:0:0:ed:0:0:0")  [5, 9], suiteZeros("0:0:0:0:0:0:0:1")  [0, 12].
4. Ecrivez la fonction CompresserIPv6(adIP) qui prend en paramètre une chaine de caractères contenant
une adresse IPv6 et qui permet de compresser cette adresse.
5. Ecrivez la fonction DecompresserIPv6(adIP) qui prend en paramètre une chaine de caractères
contenant une adresse IPv6 et qui permet de décompresser une adresse IPv6 compressée.

Exemple : fe80 ::34  fe80:0:0:0:0:0:0:34

2
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

II- Matrice binaire


Une matrice binaire de n lignes et p colonnes est une matrice dans laquelle chaque valeur est égale à 0 ou
égale à 1. Par la suite nous représentons une matrice binaire par une grille binaire dans laquelle chaque
case est de couleur blanche (valeur 0), ou bien de couleur noire (valeur 1).

i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 i a b
j ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ j ↓ ↓
0→ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1→ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
2→ 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 c→ 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0
3→ 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0
4→ 0 0 1 1 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 1 0 0 0 0
5→ 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0
6→ 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0
7→ 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0
8→ 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0
9→ 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0
10→ 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0
11→ 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0
12→ 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0
13→ 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0
14→ 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 d→0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0
15→ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
16→ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
17→ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Figure 1 Figure 2
Partie 1 : Centrage du contenu de la matrice (6 points)
Dans cette partie, nous nous intéressons à la détermination de la sous matrice de taille minimale contenant
l’ensemble des valeurs 1. Notons cette sous matrice par SMA (voir figure 2).
En commençant à partir de l’origine (0,0) :
 a: est l’indice de la première colonne contenant au moins une valeur 1.
 b: est l’indice de la dernière colonne contenant au moins une valeur 1.
 c: est l’indice de la première ligne contenant au moins une valeur 1.
 d: est l’indice de la dernière ligne contenant au moins une valeur 1.
6. Ecrivez la fonction indice_a(A) qui prend en paramètre une matrice binaire et retourne la valeur de a.
7. Ecrivez la fonction indice_b(A) qui prend en paramètre une matrice binaire et retourne la valeur de b.
8. Ecrivez la fonction indice_c(A) qui prend en paramètre une matrice binaire et retourne la valeur de c.
9. Ecrivez la fonction indice_d(A) qui prend en paramètre une matrice binaire et retourne la valeur de d.
10. Ecrivez la fonction indice_abcd(A) qui prend en paramètre une matrice binaire et retourne une liste
contenant les valeurs a, b, c et d. La fonction doit calculer les valeurs a, b, c et d en un seul parcours
de A.
Afin de centrer le contenu le la matrice (les valeurs non nulles), nous proposons de faire une translation de
la sous matrice SMA de telle sorte qu'elle soit au centre de la matrice mère A. (voir la figure 3 page 4).
Pour centrer le contenu de la matrice, nous proposons de procéder comme suit :
i) Calculer les valeurs des indices a, b, c et d,
ii) Calculer les coordonnées du centre de la sous matrice SMA,
iii) Calculer le décalage nécessaire (dx, dy) pour coïncider le centre de SMA avec le centre de la
matrice à centrer,
iv) Déplacer la sous matrice SMA au centre de la matrice à centrer (vous pouvez utiliser une matrice
auxiliaire) en décalant chaque valeur par dx, dy.

3
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

11. Ecrivez la fonction centre(a, b, c, d) qui prend en paramètre les indices a, b, c et d et retourne une liste
contenant les coordonnées du centre de la sous matrice SMA.
12. Ecrivez la fonction centrer(A) qui prend en paramètre une matrice binaire et qui permet de centrer son
contenu en utilisant l’algorithme décrit ci-dessus.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 11 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 11 1 0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Figure 3
Partie 2 : distance entre deux matrices binaires (8 points)
Les opérateurs étudiés dans cette partie prennent en compte l’information portée par les valeurs voisines
de la valeur traitée. Deux cases de la grille (autrement dit deux valeurs de la matrice) d’indices (i1, j1) et
(i2, j2) sont voisines si |i1-i2|≤1 et |j1-j2|≤1.
Une fonction adhérence sur une partie A de Z2 peut être définie de la façon suivante :
a(E)={xA, V(x) E ≠Ø}
avec V désigne l’ensemble formé de point x et de ses voisins. E désigne, dans notre cas, l’ensemble des
points dont la valeur égale à 1 (cases noires). Cette opération permet d’étendre la partie contenant les
valeurs 1 à sa frontière. Autrement dit :
a(E)=les cases noires + les cases blanches dont le voisinage contient au moins une case noire.
Exemple :
Matrice initiale Adhérence = Cases noires + cases Résultat de l’adhérence
de leurs frontières
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 1 1 1 1 1 0 0 0 0 0 0 0 0 0
0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 01 1 1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 01 1 1 1 1 1 1 0 0 1 1 1 1 1 0
0 0 1 1 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 1 1 0 0 0 1 1 1 1 0 0 01 1 1 1 1 1 1 0 1 1 1 1 1 1 0
0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 01 1 1 1 1 1 1 1 1 1 1 1 1 1 0
0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 01 1 1 1 1 1 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 00 1 1 1 1 1 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 1 1 11 1 0 0 0 0 0 0 0 0 0 0 0 1 1 11 1 0 0 0 0 00 0 0 0 1 1 1 1 11 1 1 1 0 0
0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 00 0 0 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 00 0 1 1 1 1 1 1 1 1 1 0 0 0 0
0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 00 0 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 00 0 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 00 0 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 00 0 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 1 1 1 1 1 1 1 1 0 0 0 0

Figure 4

4
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

13. Ecrivez la fonction inclusDansAdherence(A, i, j) qui retourne True si le voisinage de la case dont les
coordonnées qui sont passées en paramètre contient au moins une case noire, ou False sinon.
14. Ecrivez la fonction adherence(A) qui prend en paramètre une matrice binaire et qui permet de dilater
l’ensemble des formes contenant les valeurs 1.
On définit l’intérieur sur une partie A de Z2 par i(E)={xA, V(x) E}.
avec V désigne l’ensemble formé de point x et de ses voisins. E désigne, dans notre cas, l’ensemble des
points dont la valeur égale à 1 (cases noires). Cette opération permet d’éroder la partie contenant les
valeurs 1. Autrement dit, l’intérieur d’un sous ensemble E d’une partie A (dans notre cas, l’ensemble des
cases noires) est toutes les cases de E dont le voisinage inclus dans E. (voir la figure 5 page suivante)
Matrice initiale Les cases qui vont être érodées : Résultat de l’érosion= intérieur
Cases noires qui ne respectent pas le critère i(E)
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 00 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 1 0 0 00 0 1 1 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 00 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 00 0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 00 0 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 0 1 1 11 1 0 0 0 0 0 0 0 0 0 0 0 1 1 11 1 0 0 0 0 00 0 0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 00 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 00 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 00 0 0 0 0 1 1 0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 00 0 0 0 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 00 0 0 0 0 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Figure 5

15. Ecrivez la fonction inclusDansErode(A, i, j) qui retourne True si le voisinage d’une case, dont les
coordonnées qui sont passées en paramètre, ne contient que des cases noires (autrement dit les valeurs
1), ou False sinon.
16. Ecrivez la fonction interieur(A) qui prend en paramètre une matrice binaire et qui permet d’éroder
l’ensemble des parties contenant les valeurs 1.
Nous définissons la pseudo-distance entre deux matrices binaires par :

d(A, B)=inf{k :Bak(A) et Aak(B)} si A et B sont non vide ;


d(A, B)= +∞ si A ou B est vide (une matrice est vide si elle ne contient que des zéros).

ak(.) désigne l’adhérence d’ordre k (a2(A)=a(a(A)) ).


AB si toutes les cases noires de A sont aussi noires dans B.
Autrement dit, la distance entre deux matrices binaires A et B, notée d(A, B), est le nombre minimal de
fois qu’il faut appliquer l’opération de l’adhérence sur B pour que toute case noire dans A soit aussi noire
dans ak(B) et que toute case noire dans B soit aussi noire dans ak(A).
17. Ecrivez la fonction inclus(A, B) qui retourne True si A inclus dans B, ou False sinon.
18. Ecrivez la fonction kMin(A, B) qui retourne la valeur minimale k tel que Aak(B)
19. Ecrivez la fonction distance(A, B) qui permet de calculer la distance entre les deux matrices A et B.

5
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

Partie 3 : Composantes connexes d’une matrice binaire (8,5 points)


(Algorithme de Rosenfeld & Pfaltz (1966))
Une composante connexe C d’une matrice A=(aij) est un ensemble des points similaires (dans notre cas
les points dont les valeurs sont égales à 1) pour lesquels il existe une relation de connexité. Deux points
(Pa, Pb) sont dits connexes s’il existe un chemin ζpa,pb ={ p1, p2, …, pn / piV(pi+1) et api= api+1} reliant
ces deux points.
Matrice initiale Résultat d’étiquetage
1 1 1 2 2 2
1 1 1 1 1 2 2 2 2 2
1 1 1 1 1 1 1 1 2 2 2 2 2 3 3 3
1 1 1 1 1 1 1 1 2 2 2 2 3 3 3 3
1 1 1 1 1 1 1 Composante 2 2 3 3 3 3 3
1 1 1 1 1 connexe étiquetée 3 3 3 3 3
1 1 1 1 1
par l’étiquette 2 3 3 3 3 3 Composante
1 1 1 1 1 3 3 3 3 3 connexe étiquetée
1 1 1 1 1 3 3 3 3 3
par l’étiquette 3
1 1 1 1 1 3 3 3 3 3
1 1 1 1 1 1 1 1 3 3 3 3 3 3 3 3
1 1 1 1 1 1 1 1 3 3 3 3 3 3 3 3
1 1 1 1 1 1 3 3 3 3 3 3

Figure 6
L’étiquetage en composantes connexes (ECC) est une opération qui consiste à identifier chaque
composante connexe de manière unique par une étiquette. Puisque les valeurs 0 et 1 sont déjà utilisées
dans la matrice, la première étiquette qu’on va utiliser est 2 et les composantes connexes seront
numérotées 2, 3 … (voir figure 6).
L’algorithme d’ECC parcourt la matrice à étiqueter ligne par ligne et valeur par valeur. À chaque valeur x
de la matrice, il évalue le voisinage à la recherche des étiquettes existantes (cases du voisinage qui sont
déjà étiquetées).
Selon le nombre N d’étiquettes présentes dans le voisinage, il agit différemment :
 Cas 1 : N = 0 la case courante reçoit une nouvelle étiquette.
 Cas 2 : N = 1 la case courante reçoit la valeur de cette étiquette (aucune action sur la table
d’équivalence).
 Cas 3 : N > 1 l’algorithme affecte la valeur de la plus petite étiquette, notons cette étiquette par et,
à la case courante et met à jour la table d’équivalence associée aux étiquettes de voisinage (voir la
suite pour la mise à jour de la table d’équivalence).
Au fur et à mesure du parcours de la matrice, l’algorithme construit une table appelée table d’équivalence
qui représente les connexions existantes entre les différentes étiquettes temporaires. La mise à jour de la
table d’équivalence (appelée aussi fermeture transitive) se fait comme suit :
Si une nouvelle étiquette est créée (cas 1), alors elle sera ajoutée à la table d’équivalence,
Sinon si le nombre d’étiquettes dans le voisinage est supérieur à 1 (cas 3) alors
PPE  la valeur de la plus petite étiquette du voisinage
Pour toute étiquette et  voisinage,
Tant que T[et-2] ≠ et faire #propagation des étiquettes jusqu’à ce que T[et-2] =et.
aux T[et-2] ;
T[et-2] PPE ;
etaux
Fin Tant que
T[et-2]  PPE

6
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

20. Ecrivez la fonction etiquettesV(A, i, j) qui retourne la liste des étiquettes du voisinage. La fonction doit
retourner une liste vide si aucune des cases du voisinage n’est pas encore étiquetée (voir l’exemple).
Exemple

2 2 0 0 3
Si A= 0 0 0 0 3 alors etiquettesV(A, 3, 1)  [4,5].
4 0 5 0 3
0 1 0 1 0
2 2 0 0 3
0 0 0 0 3
Si A= alors etiquettesV (A, 2, 2) []
4 0 1 0 3
0 1 0 1 0

Exemple d’étiquetage: case noire =1, case blanche = 0, case grise = case déjà étiquetée.

Cas2 Cas1
Cas1 Cas 1 Cas 2

2 2 2 2 2 3 2 2 3 2 2 3
3 3
4

2 2 2 3 2 3 2 3 4
Cas1 Cas 2 Cas 3 Cas 3
2 2 3 2 2 3 2 2 3 2 2 3
3 3 3 3 Table d’équivalence
4 5 4 5 3 4 5 3 4 5 3
4 4 3

2 3 4 5 2 3 4 5 2 3 4 4 2 3 3 3

21. Ecrivez la procédure fermeture(T, et, PPE) qui prend en paramètre la table d’équivalence T et deux
étiquettes et et PPE et qui permet de mettre à jour l’étiquette et par l’étiquette PPE et de propager
l’étiquette PPE en utilisant le principe expliqué précédemment. Si et=PPE et PPE ne figure pas dans
la table T, alors elle sera ajoutée.
22. Ecrivez la fonction passage1(A) qui permet d’attribuer les étiquettes aux différentes cases de la
matrice A suivant l’algorithme décrit au-dessus. La fonction doit retourner la table d’équivalence.
Une fois la dernière case de la matrice est traité, il restera à effectuer un ré-étiquetage de la matrice afin
d’obtenir une matrice étiquetée. Cette étape consiste à affecter à chaque case l’étiquette équivalente.
Exemple
Matrice A= 2 2 3 Résultat d’étiquetage après le deuxième passage
3 2 2 3
4 5 3 3
4 3 3 3 3
3 3
Table d’équivalence T = 2 3 3 3

23. Ecrivez la fonction passage2(A, T) qui prend en paramètre la matrice binaire A et la table
d’équivalence T et qui permet de ré-étiqueter la matrice A.

7
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

Partie 4 : Compression d’une matrice binaire (7 points)


L’objectif de la compression d’une matrice est de représenter une matrice par une séquence d’entiers plus
courte en réduisant la redondance des données.
On suppose que la valeur de départ est 0. L’opération de compression consiste alors à indiquer le nombre
de valeurs 1 ou de valeurs 0 successives.
La matrice binaire sera compressée comme suit :
1ère valeur indique le nombre de colonnes, la 2ème valeur indique le nombre de valeurs 0 au début de la
matrice (le nombre vaut 0 si la matrice ne commence pas par des valeurs 0) ;
La 3ème valeur indique le nombre de valeurs 1 qui suivent, la 4ème valeur indique le nombre de valeurs 0
qui suivent, et ainsi de suite jusqu’à la fin de la matrice qui sera marquée par -1.

Exemple :

Matrice binaire Résultat de la compression


0 1 1 0 0 1 [6, 1, 2, 2, 1, 5, 5, 1, 2, 1, 1, 2, -1]
0 0 0 0 0 1
1 1 1 1 0 1
1 0 1 0 1 1

24. Donnez la matrice binaire correspondant à la séquence d’entiers :


[4, 2, 2, 1, 2, 1, 2, 2, -1]
25. Définissez les constantes globales suivantes : NL (nombre de lignes de la matrice), NC (Nombre de
colonnes de la matrice) et TMAX (taille maximale du tableau d’entiers contenant la séquence).
26. Pourquoi TMAX doit être égal à NL*NC+2 ?
27. Ecrivez la fonction compresseMatrice(A) qui forme la séquence d’entiers compressée à partir de la
matrice binaire passée en paramètre. La séquence ainsi formée doit être retournée.
28. Ecrivez la fonction decompresseSeq(Seq) qui prend en paramètre une séquence d’entiers compressée
et retourne la matrice binaire correspondant.
III- Arbre binaire de recherche (6,5 points)
Un arbre binaire de recherche est un arbre binaire possédant récursivement la propriété suivante :
 L'ensemble des étiquettes est totalement ordonné.
 Une étiquette est dénommée clef.
 Les clefs de tous les nœuds du sous-arbre gauche d'un nœud X, sont inférieures ou égales à la clef de
X.
 Les clefs de tous les nœuds du sous-arbre droit d'un nœud X, sont supérieures à la clef de X.
 Les éléments égaux pouvant être arbitrairement placés à gauche ou à droite (choix à faire pour un
algorithme d’insertion).

8
Agrégation Informatique Juillet 2019 Informatique fondamentale et programmation

Exemple

Figure 7
29. Quelle est la caractéristique de la valeur minimale contenant dans l’arbre binaire de recherche en
termes de sa position dans l’arbre ?
30. Quelle est la caractéristique de la valeur maximale contenant dans l’arbre binaire de recherche en
termes de sa position dans l’arbre ?
31. Donnez les résultats (valeurs des clés) des parcours préfixe, infixe et postfixe de l’arbre de la figure 7?
Parcours préfixe :
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..

Parcours infixe :
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..

Parcours postfixe :
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..
……………………………………………………………
………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………..
……………………………………………………………
…………………………………………………………………………………
……………………………………………………………………………………………………..

32. Que remarquez-vous au niveau du parcours infixe?


On suppose qu’un arbre binaire de recherche est représenté par une référence (pointeur) sur la classe
Noeud définie comme suit :
class Noeud:
def __init__(self,cle):
self.fd = None
self.fg = None
self.info =cle

33. Écrivez la fonction itérative maximumABR(A) qui prend en paramètre un arbre binaire de recherche et
qui retourne la plus grande valeur entière s’il existe, la valeur nil sinon.
34. Donnez et justifier les complexités (pire des cas et meilleur des cas) de votre fonction
maximumABR(A) en fonction du nombre de nœuds n ou de la hauteur h de l’arbre A.
35. Ecrivez la fonction insererABR(A, cle) qui permet d’insérer la valeur cle dans l’arbre A. La fonction
doit retourner le nouveau ainsi obtenu.
****