Segmenter Matrice – Bac théorique – Section informatique – 2025
Sujet (Algo et programmation - Bac 2025)
En effet:
Dans la première ligne (ligne 0), e = 6 (M[0,0]). Les valeurs de cette ligne inférieures ou égales à e sont : 6, -4 et 3, tandis que les valeurs supérieures sont : 12 et 11. Ainsi les valeurs 6, -4 et 3 sont placées à gauche de l'élément e = 6 et les valeurs 12 et 11 sont placées à sa droite.
Dans la troisième ligne (ligne 2), e = 34 (M[2,0]). Les valeurs de cette ligne inférieures ou égales à e sont : 12, 11, 4, 29 et - 3. Aucune valeur ne lui est supérieure. Ainsi les valeurs 12, 11, 4, 29 et -3 sont placées à sa gauche et aucune valeur n'est placée à sa droite.
Travail demandé
1- Écrire un algorithme d'une procédure Segmenter(T, nc) qui permet de segmenter un tableau T à une dimension de nc entiers par rapport à sa première case (T[0]).
2- En faisant appel à la procédure Segmenter, écrire un algorithme d'une procédure Partitionner(M, nl, nc) qui permet de segmenter toutes les lignes de la matrice M par rapport à la première colonne (colonne 0),
NB :
T et M sont respectivement de type Tab et Mat
Le candidat n'est pas appelé à dresser le tableau de déclaration pour définir les types Tab et Mat
Solution Algorithmique
Dans cet algorithme, On va utiliser une fonction et quatre procédures :
- la fonction saisie()
- la procédure remplir()
- la procédure segmenter()
- la procédure partitionner()
- la procédure afficher_matrice()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Algorithme segmentation_matrice Debut Ecrire('*** Saisir le nombre des lignes et des colonnes ***') nl <- saisie(1, 30) # Saisie du nombre de lignes nc <- saisie(1, 30) # Saisie du nombre de colonnes Ecrire('*** Remplir la matrice M ***') remplir(m, nl, nc) Ecrire('*** La matrice M ***') afficher_matrice(m, nl, nc) # Segmentation de chaque ligne de la matrice partitionner(m, nl, nc) Ecrire('*** La matrice M segmentée ***') afficher_matrice(m, nl, nc) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| nl | entier |
| nc | entier |
| m | matrice |
La fonction saisie
Cette fonction permet de saisir et retourner un entier compris entre binf et bsup en contrôlant la validité de la saisie.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie(binf:entier,bsup:entier):entier # Demande à l'utilisateur de saisir un entier n dans l'intervalle [binf, bsup] Ecrire('donner un entier dans [',binf,' , ',bsup),'] : ') Lire(n) # Vérification de la validité de la saisie Tant que Non (binf <= n <= bsup) faire Ecrire('donner un entier dans [',binf,' , ',bsup,'] : ') Lire(n) Fin tant que # Retourne la valeur valide saisie par l'utilisateur retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir
Cette procédure permet de saisir et stocker les éléments d’une matrice m de dimensions nl × nc.
|
1 2 3 4 5 6 7 8 |
Procédure remplir(m:matrice, nl:entier, nc:entier) Pour i de 0 à nl-1 faire Pour j de 0 à nc-1 faire Ecrire('Donner un élément de la matrice M : ') Lire(m[i][j]) Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La procédure segmenter
La procédure segmenter(t, nc) réorganise le tableau t en plaçant au début tous les éléments inférieurs ou égaux au premier élément, ce qui constitue une opération de partitionnement.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Procédure segmenter(t:tableau, nc!entier) e <- t[0] # Élément de référence p <- 0 # Position d'insertion Pour i de 1 à nc-1 faire Si t[i] <= e faire temp <- t[i] # Décalage des éléments vers la droite Pour j de i à p-1 (pas=-1) faire t[j] <- t[j-1] Fin pour t[p] <- temp p <- p+1 Fin si Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| e | entier |
| p | entier |
| i | entier |
| j | entier |
| temp | entier |
La procédure partitionner
La procédure partitionner sert à réorganiser chaque ligne de la matrice en utilisant la procédure de segmentation, en plaçant en début de ligne les éléments inférieurs ou égaux au premier élément de la ligne.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Procédure partitionner(m:matrice, nl:entier, nc:entier) Pour i de 0 à nl-1 # Copier la ligne i de la matrice dans le tableau t Pour j de 0 à nc-1 faire t[j] <- m[i][j] Fin pour # Segmenter le tableau t segmenter(t, nc) # Copier le tableau segmenté dans la matrice Pour j de 0 à nc-1 faire m[i][j] <- t[j] Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| t | tableau |
La procédure afficher
La procédure afficher_matrice(m, nl, nc) sert à présenter clairement le contenu d’une matrice sous forme tabulaire.
|
1 2 3 4 5 6 7 8 |
Procédure afficher(m:matrice, nl:entier, nc:entier) Pour i de 0 à nl-1 faire Pour j de 0 à nc-1 faire Ecrire(m[i][j];end=' ') Fin pour Ecrire() Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
Solution en Python
|
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 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 50 # Nombre maximal de lignes colonnes = 50 # Nombre maximal de colonnes # -------------------------------------------------- # Création d'une matrice M de taille maximale lignes × colonnes # Elle servira à stocker les valeurs saisies par l'utilisateur # -------------------------------------------------- m = array([[int()] * colonnes] * lignes) # -------------------------------------------------- # Déclaration d’un tableau global t de taille 50 # Il sera utilisé comme tableau temporaire lors # du traitement (segmentation d’une ligne) # -------------------------------------------------- t = array([int()] * 50) # -------------------------------------------------- # Fonction saisie(binf, bsup) # Permet de saisir un entier compris entre binf et bsup # avec contrôle de validité # -------------------------------------------------- def saisie(binf, bsup): # Demande de saisie n = int(input('donner un entier dans [' + str(binf) + ' , ' + str(bsup) + '] : ')) # Tant que la valeur n'est pas valide, redemander la saisie while not (binf <= n <= bsup): n = int(input('donner un entier dans [' + str(binf) + ' , ' + str(bsup) + '] : ')) # Retourner la valeur valide return n # -------------------------------------------------- # Procédure remplir(m, nl, nc) # Permet de remplir la matrice m de dimensions nl × nc # -------------------------------------------------- def remplir(m, nl, nc): for i in range(nl): for j in range(nc): m[i][j] = int(input('Donner un élément de la matrice M : ')) # -------------------------------------------------- # Procédure segmenter(t, nc) # Réorganise les éléments du tableau t : # les éléments <= au premier élément sont placés au début # -------------------------------------------------- def segmenter(t, nc): e = t[0] # Élément de référence p = 0 # Position d'insertion for i in range(1, nc): if t[i] <= e: temp = t[i] # Décalage des éléments vers la droite for j in range(i, p, -1): t[j] = t[j - 1] t[p] = temp p = p + 1 # -------------------------------------------------- # Procédure partitionner(m, nl, nc) # Applique la segmentation à chaque ligne de la matrice # -------------------------------------------------- def partitionner(m, nl, nc): for i in range(nl): # Copier la ligne i de la matrice dans le tableau t for j in range(nc): t[j] = m[i][j] # Segmenter le tableau t segmenter(t, nc) # Copier le tableau segmenté dans la matrice for j in range(nc): m[i][j] = t[j] # -------------------------------------------------- # Procédure afficher_matrice(m, nl, nc) # Affiche la matrice m de dimensions nl × nc # -------------------------------------------------- def afficher_matrice(m, nl, nc): for i in range(nl): for j in range(nc): print(m[i][j], end=' ') print() # -------------------------------------------------- # Programme principal # -------------------------------------------------- print('*** Saisir le nombre des lignes et des colonnes ***') nl = saisie(1, 30) # Saisie du nombre de lignes nc = saisie(1, 30) # Saisie du nombre de colonnes print('*** Remplir la matrice M ***') remplir(m, nl, nc) print('*** La matrice M ***') afficher_matrice(m, nl, nc) # Segmentation de chaque ligne de la matrice partitionner(m, nl, nc) print('*** La matrice M segmentée ***') afficher_matrice(m, nl, nc) |
Exécution du programme
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
