Matrice – Bac pratique – Section informatique – 2014
Sujet (Algo et programmation - Bac 2014)
On se propose de remplir une matrice carrée M d'ordre N par des nombres premiers de l'intervalle [2, 99] et de rechercher les lignes et les colonnes de cette matrice dont les éléments sont ordonnés dans l'ordre croissant ou décroissant.
Exemple
Pour la matrice carrée M d'ordre N=5 ci-dessus, les lignes et les colonnes dont les éléments sont ordonnés dans l'ordre croissant ou décroissant sont :
- La ligne 2 formée par les éléments 5 - 29 - 37 - 61 - 67
- La ligne 5 formée par les éléments 31 - 29 - 23 - 19 - 17
- La colonne 1 formée par les éléments 2 - 5 - 23 - 29 - 31
Travail demandé
Ecrire un programme en Python permettant de :
- remplir aléatoirement une matrice M d'ordre N donné (avec 4 < N < 20) par des nombres premiers de l'intervalle [2, 99].
- stocker dans chacune des lignes du fichier texte "Result.txt", la lettre "L" suivie par le numéro de la ligne de la matrice ou la lettre "C" suivie par le numéro de la colonne de la matrice M vérifiant la propriété citée ci-dessus, suivi d'un astérisque "*", suivi des éléments de cette ligne ou de cette colonne séparés par des tirets "-", comme le montre le formatage suivant :
Exemple pour la matrice M de l'exemple ci-dessus, le contenu du fichier "Result.txt" sera :
L2*5-29-37-61-67
L5*31-29-23-19-17
C1*2-5-23-29-31
Solution Algorithmique
Dans cet algorithme, On va utiliser sept fonctions et trois procédures:
- la fonction saisie()
- la fonction test_premier()
- la fonction saisie_element()
- la procédure remplir_matrice()
- la procédure afficher_matrice()
- la fonction test_ordonne_ligne()
- la fonction test_ordonne_colonne()
- la fonction elements_ligne()
- la fonction elements_colonne()
- la procédure remplir_fichier_result()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 |
Algorithme eltpremier_matrice Debut Ecrire('*** Saisie du nombre des lignes et des colonnes ***') # Saisie de la dimension de la matrice n = saisie(3, 21) # Appel des différentes procédures remplir_matrice(m, n) afficher_matrice(m, n) remplir_fichier_result(m, n) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| m | matrice |
La fonction saisie
La fonction saisie(inf, sup) permet de demander à l’utilisateur de saisir un entier strictement compris entre deux bornes inf et sup.
Plus précisément :
- La fonction affiche un message demandant un entier n tel que inf < n < sup. - Si la valeur saisie n’est pas dans l’intervalle ouvert ]inf, sup[, la saisie est redemandée. - La saisie est répétée tant que la condition n’est pas respectée. - Lorsque l’utilisateur entre enfin une valeur correcte, la fonction retourne cet entier.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction saisie():entier # Demande à l'utilisateur de saisir un entier n Ecrire('donner n tel que ' + inf + '< n < ' + sup + ': ') Lire(n) # Tant que n n'appartient pas à l'intervalle ]inf , sup[ # on redemande la saisie Tant que (n <= inf) ou (n >= sup) faire Ecrire('donner n tel que ' + inf + '< n < ' + sup + ': ') Lire(n) Fin tant que # Retourne la valeur correcte saisie retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction test_premier
Cette fonction sert à saisir et valider le nombre de colonnes d’une matrice en respectant trois contraintes :
La fonction saisie_colonne(inf, sup) :
1- Demande à l’utilisateur de saisir un entier n
2- Vérifie que n est : strictement supérieur à inf, strictement inférieur à sup et pair (divisible par 2)
3-Redemande la saisie tant que ces conditions ne sont pas respectées
4- Retourne la valeur valide de n
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction saisie_colonne():entier # Demande à l'utilisateur de saisir un entier n Ecrire('donner n pair tel que ' + inf + '< n < ' + sup + ': ') Lire(n) # Tant que n n'appartient pas à l'intervalle ]inf , sup[ # on redemande la saisie Tant que (n <= inf) ou (n >= sup) ou (m div 2 !=0) faire Ecrire('donner n pair tel que ' + inf + '< n < ' + sup + ': ') Lire(n) Fin tant que # Retourne la valeur correcte saisie retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_matrice
Cette procédure permet de remplir une matrice V de dimensions n × m par des entiers saisis au clavier.
La procédure remplir_matrice(v, n, m) :
- affiche un message indiquant le début du remplissage de la matrice
- parcourt la matrice ligne par ligne
- Pour chaque position V[i][j] : demande à l’utilisateur de saisir un entier et stocke cet entier dans la matrice
|
1 2 3 4 5 6 7 8 9 |
Procedure remplir_matrice(v:matrice, n:entier, m:entier) Ecrire('*** Remplir la matrice V ***') Pour i de 0 à n-1 faire Pour j de 0 à m-1 faire Ecrire('donner un entier: ') Lire(v[i][j]) Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La procédure afficher_matrice
Cette procédure afficher_matrice(m, l, c) a pour rôle d’afficher le contenu de la matrice M de dimensions l × c.
Détail du fonctionnement :
Elle affiche un message indiquant l’affichage de la matrice.
Elle parcourt la matrice ligne par ligne à l’aide de la boucle sur i.
Pour chaque ligne, elle parcourt les colonnes avec la boucle sur j.
Chaque élément m[i][j] est affiché sur la même ligne, séparé par un espace.
Après l’affichage de chaque ligne, un retour à la ligne est effectué avec Ecrire().
|
1 2 3 4 5 6 7 8 9 |
Procedure afficher_matrice(v:matrice, l:entier, c:entier) Ecrire(''*** Contenu de la matrice V ***'') Pour i de 0 à n-1 faire Pour j de 0 à m-1 faire Ecrire(v[i][j],' ') Fin pour Ecrire() Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La procédure remplir_fichier_fnombre
Cette procédure permet de générer le fichier Fnombres.dat à partir de la matrice V, en calculant des valeurs spécifiques, puis en les stockant à la fois dans un fichier et dans un tableau.
La procédure remplir_fichier_fnombre(v, n, m, t) :
1- parcourt chaque ligne de la matrice V
2- pour chaque élément V[i][j], calcule la valeur absolue de la différence entre V[i][j] et son élément symétrique sur la même ligne V[i][m - j - 1]
3- stocke le résultat dans le tableau T et dans le fichier Fnombres.dat
4- affiche chaque valeur calculée
5- utilise la variable globale k pour compter le nombre total de valeurs produites
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Procédure remplir_fichier_fnombre(v:matrice , n:entier, m:entier, t:entier) Ecrire('*** Contenu du fichier Fnombres.dat ***') # Ouverture du fichier en mode écriture Ouvrir( f, "Fnombres.dat.txt", "w") Pour i de 0 à n-1 faire Pour j de à (m//2)-1 faire # Calcul de la valeur absolue de la différence t[k] <- abs(v[i][j] - v[i][m - j - 1]) # Affichage de la valeur Ecrire(t[k]) # Écriture de la valeur dans le fichier Ecrire(f , Convch(t[k]) + '\n') # Incrémentation du compteur global k <- k + 1 Fin pour Fin pour # Fermeture du fichier f.close() Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| k | entier (variable globale) |
| f | fichier |
La fonction recherche_raison
Cette fonction sert à vérifier si une raison r a déjà été trouvée et enregistrée dans le tableau raison.
La fonction recherche_raison(raison, n, r) :
1- parcourt le tableau raison depuis l’indice 0 jusqu’à n-1
2- compare chaque valeur avec la raison r
3- s’arrête dès que : la raison est trouvée, ou la fin de la zone utile du tableau est atteinte
4- retourne Vrai si la raison r n’existe pas encore et Faux si la raison r existe déjà
|
1 2 3 4 5 6 7 |
Fonction recherche_raison(raison:tableau, n:entier, r:entier):booleen i <- 0 Tant que (i < n - 1) et (raison[i] != r) faire i <- i + 1 Fin tant que retourner (raison[i] != r) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La procédure recherche_suites
Cette procédure remplir_fichier_long_seq(t, longueur_tableau, max_sequence) a pour rôle de créer et remplir le fichier texte Long_Seq.txt avec les informations relatives aux plus longues séquences d’éléments juxtaposés dont la somme est égale à zéro.
Détail du fonctionnement :
Elle ouvre (ou crée) le fichier Long_Seq.txt en mode écriture.
Elle écrit dans la première ligne du fichier le nombre d’éléments de la plus longue séquence trouvée.
Elle parcourt ensuite le tableau T, qui contient toutes les séquences détectées.
Pour chaque séquence, elle calcule sa longueur à partir des indices de début (icd) et de fin (icf).
Si la longueur de la séquence correspond à la longueur maximale (max_sequence), ses informations sont :
affichées à l’écran,
enregistrées dans le fichier sous la forme : NL#ICD#ICF.
Enfin, le fichier est fermé correctement.
|
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 |
Procédure recherche_suites(t:tableau, k:entier): Ecrire('*****************') index <- 0 # Nombre de raisons trouvées i <- 0 Tant que i < k - 2 faire # Calcul de la raison entre deux éléments successifs r <- t[i + 1] - t[i] j <- i + 1 # Vérification de la continuité de la suite Tant que (j < k - 1) and (t[j + 1] - t[j] == r) et recherche_raison(raison, index, r) faire j = j + 1 # Si la longueur du bloc est suffisante Fin tant que Si j - i >= 2 alors # Affichage des termes de la suite Pour l de i à j faire Ecrire(t[l], ' ') Fin pour Ecrire(" est une suite arithmétique de raison r = ", r) # Mémorisation de la raison raison[index] <- r index <- index + 1 Fin si i = i + 1 Fin tant que Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| index | entier |
| i | entier |
| j | entier |
| k | entier |
| l | entier |
| r | entier |
| raison | tableau |
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 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 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 50 colonnes = 50 # Création de la matrice V de taille 50x50 # Elle est initialisée avec des zéros v = array([[int()] * colonnes] * lignes) # Création du tableau T qui va contenir # les valeurs écrites dans le fichier Fnombres.dat t = array([int()] * 100) # Tableau qui mémorise les raisons déjà affichées # pour éviter l’affichage de suites ayant la même raison raison = array([int()] * 100) # -------------------------------------------------- # Fonction qui permet de saisir un nombre de lignes # strictement compris entre inf et sup # -------------------------------------------------- def saisie_ligne(inf, sup): # Première saisie du nombre de lignes n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Tant que n n’appartient pas à l’intervalle ]inf , sup[ # on redemande la saisie while (n <= inf) or (n >= sup): n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Retourne une valeur valide return n # -------------------------------------------------- # Fonction qui permet de saisir un nombre de colonnes # pair et strictement compris entre inf et sup # -------------------------------------------------- def saisie_colonne(inf, sup): # Première saisie du nombre de colonnes n = int(input('donner n paire tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Tant que n n’est pas valide (hors intervalle ou impair) # on redemande la saisie while (n <= inf) or (n >= sup) or n % 2 != 0: n = int(input('donner n paire tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Retourne une valeur valide return n # -------------------------------------------------- # Procédure qui permet de remplir la matrice V # -------------------------------------------------- def remplir_matrice(v, n, m): print('*** Remplir la matrice V ***') for i in range(n): for j in range(m): # Saisie des éléments de la matrice v[i][j] = int(input('donner un entier: ')) # -------------------------------------------------- # Procédure qui affiche le contenu de la matrice V # -------------------------------------------------- def afficher_matrice(v, n, m): print('*** Contenu de la matrice V ***') for i in range(n): for j in range(m): print(v[i][j], end=' ') print() # -------------------------------------------------- # Procédure qui : # - calcule la valeur absolue de la différence # entre chaque élément et son symétrique # - remplit le fichier Fnombres.dat # - stocke les valeurs dans le tableau T # -------------------------------------------------- def remplir_fichier_fnombre(v, n, m, t): global k print('*** Contenu du fichier Fnombres.dat ***') # Ouverture du fichier en mode écriture f = open("Fnombres.dat.txt", "w") for i in range(n): for j in range(m // 2): # Calcul de la valeur absolue de la différence t[k] = abs(v[i][j] - v[i][m - j - 1]) # Affichage de la valeur print(t[k]) # Écriture de la valeur dans le fichier f.write(str(t[k]) + '\n') # Incrémentation du compteur global k = k + 1 # Fermeture du fichier f.close() # -------------------------------------------------- # Fonction qui vérifie si une raison r # existe déjà dans le tableau des raisons # -------------------------------------------------- def recherche_raison(raison, n, r): i = 0 while (i < n - 1) and (raison[i] != r): i = i + 1 return (raison[i] != r) # -------------------------------------------------- # Procédure qui recherche et affiche toutes les # suites arithmétiques contenues dans le tableau T # -------------------------------------------------- def recherche_suites(t, k): print('*****************') index = 0 # Nombre de raisons trouvées i = 0 while i < k - 2: # Calcul de la raison entre deux éléments successifs r = t[i + 1] - t[i] j = i + 1 # Vérification de la continuité de la suite while (j < k - 1) and (t[j + 1] - t[j] == r) and recherche_raison(raison, index, r): j = j + 1 # Si la longueur du bloc est suffisante if j - i >= 2: # Affichage des termes de la suite for l in range(i, j + 1): print(t[l], end=' ') print(" est une suite arithmétique de raison r = ", r) # Mémorisation de la raison raison[index] = r index = index + 1 i = i + 1 # -------------------------------------------------- # Programme principal # -------------------------------------------------- print('*** Saisie de nombre des lignes et de colonnes ***') k = 0 # Compteur global des valeurs du tableau T # Saisie des dimensions n = saisie_ligne(0, 11) m = saisie_colonne(2, 11) # Traitements remplir_matrice(v, n, m) afficher_matrice(v, n, m) remplir_fichier_fnombre(v, n, m, t) recherche_suites(t, k) |
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
