Matrice et Suite – Bac pratique – Section informatique – 2014
Sujet (Algo et programmation - Bac 2014)
Une suite est dite arithmétique si, pour tout n > 0, Un = Un-1 + r.
On se propose d'afficher toutes les suites arithmétiques à partir d'un ensemble d'entiers sauvegardés dans un fichier de données en procédant comme suit :
- remplir une matrice V de n lignes et m colonnes par des entiers (avec I Pour le fichier "Fnombres.dat" précédent, on affichera 2, 5, 8,1 1, 14,17 est une suite arithmétique de raison r = 3 14, 13, 12., I 1, 10 est une suite arithmétique de raison r = -1 Travail demandé Ecrire un programme en Python permettant de réaliser les traitements décrits précédemment.
Solution Algorithmique
Dans cet algorithme, On va utiliser trois fonctions et quatre procédures:
- la fonction saisie_ligne()
- la fonction saisie_colonne()
- la procédure remplir_matrice()
- la procédure afficher_matrice()
- la procédure remplir_fichier_fnombre()
- la fonction recherche_raison()
- la procédure recherche_suites()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Algorithme suite_matrice Debut 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) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| k | entier |
| n | entier |
| m | matrice |
| v | matrice |
| t | tableau |
La fonction saisie_ligne
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_ligne():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 saisie_colonne
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, n:entier, m: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
