Matrice – Bac pratique – Section informatique – 2026
Sujet (Python et Qt Designer - Bac 2026)
Dans un lycée, des observations précédentes ont montré que certaines zones de la cour pendant la recréation présentent une forte concentration d’élèves pouvant provoquer des tensions.
Pour améliorer la surveillance, un relevé du nombre d’élèves présent est modélisé sous forme d’une grille rectangulaire, où chaque case contient le nombre d’élèves présent à un emplacement donné, constituant ainsi une matrice d’entiers.
En analysant cette matrice, on cherche à repérer automatiquement certaines positions particulières pour mieux organiser la circulation des élèves et éviter les tensions et les problèmes. Ces positions sont appelées points croissants.
Un point croissant d’une matrice M de L lignes et C colonnes est tout élément M[i,j], qui vérifie la relation suivante :
M[i,j] = M[i,j-1] + M[i-1,j] + M[i+1,j]
Avec :
- 1 ≤ i ≤ L-2 (on exclue la première et la dernière ligne : ligne 0 et ligne L-1)
- 1 ≤ j ≤ C-1 (on exclue la première colonne : colonne 0)
Exemple :
Soit la matrice M suivante :
Les points croissants existant dans la matrice M sont :
13 car 13 = 4 + 5 + 4
18 car 8 = 2 + 7+ 9
16 car 16 = 8 + 2 + 6
On souhaite développer une application Python munie de deux interfaces graphiques permettant :
- de saisir les dimensions L et C et de remplir la matrice M,
- de rechercher et d’afficher les points croissants contenus dans la matrice M ainsi que leur nombre,
- de rechercher et d’afficher les zones sous-occupées dans la matrice M ainsi que leur nombre, sachant qu’une zone sous-occupée est une case de la matrice M dont la valeur est inférieure ou égale à un seuil S.
Travail demandé :
1- En se basant sur la figure Fig.1 de l’annexe, compléter l'interface graphique "InterfRempl.ui" par les éléments manquants (un label et un objet TextEdit).
2- Apporter les modifications nécessaires au fichier "RempliM.py" afin de réaliser les actions suivantes :
a. Développer le module Valide(L, C) qui permet de vérifier la validité de L et C, sachant que 2 ≤ L ≤ 100 et 2 ≤ C ≤ 100.
b. Développer le module Remplissage qui s’exécute suite au clic sur le bouton "Enregistrement de la matrice" et qui permet :
- de vérifier la validité des dimensions L et C en faisant appel au module Valide. Un message d’erreur doit être affiché via une boite de dialogue QMessageBox si l’une des contraintes sur L ou sur C n’est pas respectée (voir figure Fig.2).
- de vérifier la conformité du contenu saisi dans la zone TextEdit :
Le contenu saisi doit contenir exactement L lignes.
Chaque ligne doit contenir exactement C entiers naturels, tels que chaque deux entiers consécutifs sont séparés par un seul espace.
Afficher un message d’erreur via une boite de dialogue QMessageBox si l’une des conditions précédentes n’est pas respectée (voir figure Fig.3),
- d'enregistrer les données dans un fichier texte nommé "cour.txt", si toutes les conditions sont validées, selon le format suivant :
La première ligne du fichier contient les valeurs de L et de C, séparées par un espace.
Les lignes suivantes contiennent le contenu saisi dans la zone TextEdit, sachant que chaque ligne de cette zone correspond à une ligne du fichier.
c. Compléter la partie exploitation de l’interface graphique "InterfRempl.ui" par les noms adéquats afin :
- de charger l’interface graphique depuis le fichier "InterfRempl.ui",
- d’appeler le module nommé Remplissage suite au clic sur le bouton intitulé "Enregistrement de la matrice".
3- En se basant sur la figure Fig.4 de l’annexe, compléter l'interface graphique "InterfRech.ui" par les éléments manquants (un objet LineEdit et un bouton).
4- Apporter les modifications nécessaires au fichier "Recherche.py" afin de réaliser les actions suivantes :
a. Développer le module RechAffPC qui s'exécute suite au clic sur le bouton "Recherche et affichage des points croissants" et qui permet :
- de remplir la matrice M de L lignes et C colonnes à partir du fichier texte "cour.txt". On rappelle que la première ligne du fichier texte contient les valeurs de L et de C, séparées par un espace, et que les lignes suivantes contiennent le contenu de la matrice,
- de déterminer et d’afficher, dans la zone TextEdit, les valeurs et les indices des points croissants de la matrice M ainsi que leur nombre total. Chaque valeur d’un point croissant est affichée sur une ligne suivie de son indice de ligne, puis son indice de colonne, séparés par un espace (voir figure Fig.5),
- d’enregistrer les valeurs et les indices des points croissants dans un fichier texte nommé "PointsCroissant.txt". Chaque ligne du fichier doit contenir la valeur du point croissant, suivie de son indice de ligne dans la matrice, puis de son indice de colonne,
séparés par un espace.
b. Développer le module RechAffZones qui s'exécute suite au clic sur le bouton "Recherche et affichage des zones sous occupées" et qui permet :
- de récupérer la valeur du seuil S à partir de la zone LineEdit. Le seuil S doit être un entier positif inférieur ou égal à 5. En cas de non-respect de cette contrainte, afficher un message d’erreur via une boite de dialogue QMessageBox (voir figure Fig.6),
- de déterminer et d’afficher, dans la zone TextEdit, les valeurs et les indices des zones sous-occupées de la matrice M, ainsi que leur nombre total (voir figure Fig.7).
N.B : On rappelle qu’une zone sous-occupée est une case de M dont la valeur est inférieure ou égale au seuil S.
c. Développer le module Effacer qui s'exécute suite au clic sur le bouton "Effacer" et qui permet d’effacer le contenu de la zone TextEdit.
d. Compléter la partie exploitation de l’interface graphique "InterfRech.ui " par les noms adéquats afin :
- de charger l’interface graphique depuis le fichier "InterfRech.ui ",
- d’appeler le module nommé RechAffPC qui s'exécute suite au clic sur le bouton intitulé " Recherche et affichage des points croissants",
- d’appeler le module nommé RechAffZones qui s'exécute suite au clic sur le bouton intitulé " Recherche et affichage des zones sous occupées",
- d’appeler le module nommé Effacer qui s'exécute suite au clic sur le bouton intitulé "Effacer".
Annexe :
L'interface graphique "InterfRempl.ui"
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets :
- QLineEdit : nommé "L" pour saisir le nombre des lignes de la matrice.
- QLineEdit : nommé "C" pour saisir le nombre des colonnes de la matrice.
- QTextEdit : nommé "contenu" pour entrer les élements de la matrice.
- QPushButton : nommé "btEnreg" pour enregistrer les données dans un fichier texte.
Contenu du fichier RempliM.py
|
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 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 |
# ========================================================== # IMPORTATION DES BIBLIOTHÈQUES # ========================================================== from PyQt5.uic import loadUi # Chargement de l'interface graphique (.ui) from PyQt5.QtWidgets import * # Importation des composants graphiques PyQt5 from numpy import array # Création et manipulation des matrices # ========================================================== # DÉCLARATION DES CONSTANTES ET DE LA MATRICE # ========================================================== lignes = 100 # Nombre maximal de lignes colonnes = 100 # Nombre maximal de colonnes # Création d'une matrice 100 × 100 initialisée à 0 m = array([[int()] * colonnes] * lignes) # ========================================================== # FONCTION : valide() # Rôle : Vérifier que les dimensions de la matrice # respectent les contraintes (entre 2 et 100). # ========================================================== def valide(l, c): if 2 <= l <= 100 and 2 <= c <= 100: return True else: return False # ========================================================== # FONCTION : verif_lignes() # Rôle : Vérifier que le nombre de lignes saisies # correspond au nombre attendu. # ========================================================== def verif_lignes(matrice, l): i = 0 cp_lignes = 1 # Comptage des retours à la ligne while (i < len(matrice) - 1): if matrice[i] == '\n': cp_lignes = cp_lignes + 1 i = i + 1 return cp_lignes == l # ========================================================== # FONCTION : verif_nombre() # Rôle : Vérifier qu'une chaîne contient uniquement # des chiffres et des espaces. # ========================================================== def verif_nombre(ch): i = 0 while i < len(ch) - 1 and (('0' <= ch[i] <= '9') or ch[i] == ' '): i = i + 1 return '0' <= ch[i] <= '9' # ========================================================== # FONCTION : nbr_colonnes() # Rôle : Déterminer le nombre de colonnes d'une ligne # en comptant les espaces. # ========================================================== def nbr_colonnes(ch): cp_colonnes = 1 for i in range(len(ch)): if ch[i] == ' ': cp_colonnes = cp_colonnes + 1 return cp_colonnes # ========================================================== # FONCTION : supprimer_espaces() # Rôle : Supprimer les espaces inutiles : # - au début, # - à la fin, # - les espaces multiples. # ========================================================== def supprimer_espaces(ch): # Suppression des espaces au début while (ch[0] == ' '): ch = ch[1:len(ch)] # Suppression des espaces à la fin while (ch[len(ch) - 1] == ' '): ch = ch[0:len(ch) - 1] # Remplacement des doubles espaces par un seul while (ch.find(' ') > 0): ch = ch.replace(" ", " ") return ch # ========================================================== # FONCTION : verif_colonnes() # Rôle : Vérifier que chaque ligne possède exactement # le nombre de colonnes demandé et que les # données sont numériques. # ========================================================== def verif_colonnes(matrice, c): j = 0 elt = '' test_valide = True while (j <= len(matrice) - 1) and (test_valide == True): if matrice[j] != '\n': elt = elt + matrice[j] else: # Nettoyage de la ligne elt = supprimer_espaces(elt) # Vérification du contenu if verif_nombre(elt) and (nbr_colonnes(elt) == c): elt = '' else: test_valide = False j = j + 1 # Vérification de la dernière ligne elt = supprimer_espaces(elt) if verif_nombre(elt) and (nbr_colonnes(elt) == c): elt = '' else: test_valide = False return test_valide == True # ========================================================== # Procédure : remplir_fichier() # Rôle : Enregistrer les dimensions et le contenu # de la matrice dans le fichier "cour.txt". # ========================================================== def remplir_fichier(matrice, l, c): # Ouverture du fichier en écriture f = open("cour.txt", "w") # Enregistrement des dimensions f.write(str(l) + " " + str(c) + "\n") contenu = '' # Reconstruction du texte de la matrice for i in range(len(matrice)): contenu = contenu + matrice[i] # Écriture de la matrice f.write(contenu) # Fermeture du fichier f.close() # ========================================================== # Procédure : remplissage() # Rôle : Vérifier les données saisies puis enregistrer # la matrice dans le fichier si tout est correct. # ========================================================== def remplissage(): # Vérification de la saisie des dimensions if (w.L.text() != '') and (w.C.text() != ''): l = int(w.L.text()) c = int(w.C.text()) # Vérification des contraintes sur les dimensions if valide(l, c): # Récupération du contenu de la matrice matrice = w.contenu_matrice.toPlainText() if matrice != '': # Vérification du nombre de lignes if verif_lignes(matrice, l): # Vérification du nombre de colonnes if verif_colonnes(matrice, c): # Enregistrement dans le fichier remplir_fichier(matrice, l, c) QMessageBox.critical( w, 'Confirmation', "La matrice est enregistrée dans le fichier" ) else: QMessageBox.critical( w, 'Erreur', "Le contenu saisi n'est pas conforme aux contraintes" ) else: QMessageBox.critical( w, 'Erreur', "Le contenu saisi n'est pas conforme aux contraintes" ) else: QMessageBox.critical( w, 'Erreur', "Veuillez saisir les éléments de la matrice" ) else: QMessageBox.critical( w, 'Erreur', "Les dimensions ne sont pas conformes aux contraintes" ) else: QMessageBox.critical( w, 'Erreur', "Veuillez saisir les dimensions de la matrice" ) # ========================================================== # PROGRAMME PRINCIPAL # Chargement et exécution de l'interface graphique. # ========================================================== # Création de l'application PyQt5 app = QApplication([]) # Chargement de l'interface graphique w = loadUi("InterfRempl.ui") # Affichage de la fenêtre w.show() # Association du bouton "Enregistrer" à la fonction remplissage() w.btEnreg.clicked.connect(remplissage) # Démarrage de la boucle principale de l'application app.exec_() |
L'interface graphique "InterfRech.ui"
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets :
- QPushButton : nommé "btPC" pour chercher et afficher les points croissants.
- QPushButton : nommé "btZSO" pour chercher et afficher les zones sous occupés.
- QLineEdit : nommé "seuil" pour saisir le seuil.
- QTextEdit : nommé "teAffich" pour afficher les zones sous occupées.
- QPushButton : nommé "effacer" pour effacer le contenu du QLineEdit seuil et QTextEdit teAffich.
Contenu du fichier Recherche.py
|
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 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 |
# ========================================================== # Importation des bibliothèques nécessaires # ========================================================== from PyQt5.uic import loadUi # Chargement de l'interface graphique from PyQt5.QtWidgets import * # Widgets PyQt5 from pickle import load, dump # Gestion des fichiers binaires (non utilisée ici) from numpy import array # Création des matrices # ========================================================== # Déclaration des dimensions maximales de la matrice # ========================================================== lignes = 100 # Nombre maximal de lignes colonnes = 100 # Nombre maximal de colonnes # ========================================================== # Création de la matrice principale # Elle contiendra les valeurs lues à partir du fichier # ========================================================== m = array([[int()] * colonnes] * lignes) # Variables globales contenant le nombre réel de lignes et colonnes l = 0 c = 0 # ========================================================== # Procédure : remplir_matrice() # Rôle : lire les données du fichier "cour.txt" et remplir # la matrice m avec les valeurs correspondantes. # ========================================================== def remplir_matrice(): global l, c # Ouverture du fichier en mode lecture f = open("cour.txt", "r") # Lecture de la première ligne contenant # le nombre de lignes et de colonnes ligne = f.readline() ligne = ligne.strip('\n') # Extraction du nombre de lignes et de colonnes l = int(ligne[0:ligne.find(' ')]) c = int(ligne[ligne.find(' ') + 1:len(ligne)]) # Affichage des dimensions dans la console print(l, ' ', c) # Lecture de la première ligne de données ligne = f.readline() ligne = ligne.strip('\n') i = 0 j = 0 nbr = '' # Parcours de toutes les lignes du fichier while (ligne != ''): # Extraction des nombres séparés par des espaces while (ligne.find(' ') != -1): m[i][j] = int(ligne[0:ligne.find(' ')]) ligne = ligne[ligne.find(' ') + 1:len(ligne)] j = j + 1 # Lecture du dernier nombre de la ligne m[i][j] = int(ligne) # Passage à la ligne suivante j = 0 i = i + 1 ligne = f.readline() ligne = ligne.strip('\n') # Fermeture du fichier f.close() # ========================================================== # Procédure : RechAffPC() # Rôle : rechercher les points croissants de la matrice, # les afficher et les enregistrer dans un fichier. # # Un point est considéré croissant si : # valeur = gauche + haut + bas # ========================================================== def RechAffPC(): global l, c # Chargement de la matrice remplir_matrice() cp = 0 resultat = '' # Parcours des cases internes de la matrice for i in range(1, l): for j in range(1, c): # Vérification de la condition de point croissant if m[i][j] == m[i][j-1] + m[i-1][j] + m[i+1][j]: # Ajout de la valeur et de sa position resultat = resultat + str(m[i][j]) + ' ' + str(i) + ' ' + str(j) + '\n' cp = cp + 1 # Ajout du nombre total de points croissants resultat = resultat + 'Le nombre de points croissantes est : ' + str(cp) # Sauvegarde du résultat dans un fichier texte f = open("PointsCroissant.txt", "w") f.write(resultat) f.close() # Affichage dans la zone de texte w.teAffich.setText(resultat) # ========================================================== # Procédure : RechAffZones() # Rôle : rechercher toutes les cellules dont la valeur est # inférieure ou égale au seuil saisi par l'utilisateur. # ========================================================== def RechAffZones(): global l, c # Chargement de la matrice remplir_matrice() cp = 0 affichage = '' # Vérification de la validité du seuil if (w.seuil.text() != '') and (0 <= int(w.seuil.text()) <= 5): # Parcours de toute la matrice for i in range(l): for j in range(c): # Test de la condition if m[i][j] <= int(w.seuil.text()): # Ajout de la valeur et de sa position affichage = affichage + str(m[i][j]) + ' ' + str(i) + ' ' + str(j) + '\n' cp = cp + 1 # Affichage du nombre total des zones trouvées affichage = affichage + 'Le nombre des zones occupées est : ' + str(cp) # Affichage dans l'interface graphique w.teAffich.setText(affichage) else: # Message d'erreur si le seuil est incorrect QMessageBox.critical(w, 'Erreur', "Valeur du seuil incorrecte !") # ========================================================== # Procédure : effacer() # Rôle : vider la zone d'affichage et le champ du seuil. # ========================================================== def effacer(): w.teAffich.clear() w.seuil.clear() # ========================================================== # Programme principal # Chargement de l'interface graphique et connexion # des boutons aux différentes fonctions. # ========================================================== # Création de l'application PyQt5 app = QApplication([]) # Chargement de l'interface graphique w = loadUi("InterfRech.ui") # Affichage de la fenêtre w.show() # Association des boutons aux fonctions w.btPC.clicked.connect(RechAffPC) w.btZSO.clicked.connect(RechAffZones) w.bteffacer.clicked.connect(effacer) # Lancement de la boucle principale de l'application app.exec_() |
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
