Problème Matrice – Bac théorique – Section informatique – 2023
Sujet (Algo et programmation - Bac 2023)
Soit M une matrice de NL x NC entiers (avec 3 ≤ NL ≤ 15 et 3 ≤ NC ≤ 15) dont les éléments d’une même colonne sont distincts.
On se propose de déterminer la valeur minimale des maximums des colonnes de la matrice M appelée MiniMax. Pour ce faire on détermine le maximum de chaque colonne puis on détermine la valeur minimale des maximums obtenus.
Travail demandé :
1- Ecrire un algorithme d’une fonction Max_Colonne(NL, j, M) qui, pour une colonne j de la matrice M, permet de retourner le numéro de la ligne de son maximum.
2- Ecrire un algorithme d’une procédure nommée Recherche_Minimax qui permet de déterminer et d’afficher les positions de MiniMax dans la matrice M en utilisant le module Max_Colonne et en appliquant le procédé suivant :
- Remplir un tableau d’enregistrements T par les positions des maximums des colonnes de la matrice M. Chaque enregistrement du tableau T correspond au maximum d’une colonne et il est formé des deux champs suivants :
C : Le numéro de la colonne de la matrice M où se trouve la valeur maximale
L : Le numéro de la ligne de la matrice M où se trouve la valeur maximale
- Chercher et afficher la valeur du MiniMax.
- Afficher à partir du tableau T, la(les) position(s) du MiniMax. Exemple :
Pour NL = 5 , NC = 6 et la matrice M suivante :
La procédure Recherche_Minimax affiche :
MiniMax = 300
Les positions sont : (2,0) (3,4)
En effet, MiniMax est égale à 300 et se trouve dans la colonne numéro 2, la ligne numéro 0 et la colonne numéro 3, la ligne numéro 4 dans la matrice M.
Solution Algorithmique
Dans cet algorithme, On va utiliser deux fonctions et deux procédures :
- la fonction saisie()
- la procédure remplir_fichier_depart()
- la fonction calcul_nbr_annees()
- la procédure remplir_fichier_resultat()
Algorithme du programme Principal
|
1 2 3 4 5 6 |
Algorithme agence_suite Debut n <- saisie() # Saisie du nombre de voitures remplir_fichier_depart(n) # Remplissage du fichier binaire remplir_fichier_resultat() # Calcul et écriture des résultats Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie
Cette fonction assure une saisie sécurisée d’un entier n tel que n ≥ 1, en redemandant la saisie tant que la condition n’est pas respectée.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie():entier # Saisie initiale Ecrire('donner un nombre >=1: ') Lire(n) # Vérification de la validité de la saisie Tant que Non (n<1) faire Ecrire('donner un nombre >=1: ') Lire(n) Fin tant que # Retourner la valeur valide retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_fichier_depart
Cette procédure permet de saisir les informations de n voitures et de les enregistrer dans le fichier binaire Depart.dat.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Procedure remplir_fichier_depart(n:entier) Ecrire("*** Remplir le fichier Depart.dat ***") # Ouverture du fichier en écriture binaire Ouvrir(f_depart , "Depart.dat", "wb") Pour i de 0 à n-1 faire # Saisie des informations pour chaque voiture Ecrire ('donner immatriculation de la voiture: ') Lire(voiture['imma']) Ecrire('donner la valeur de kilometrage initiale: ') Lire(voiture['d']) Ecrire('donner la valeur de kilometrage parcourue: ') Lire(voiture['r']) Ecrire('donner la valeur de kilometrage initiale maximale: ') Lire(voiture['m']) # Écriture de l'enregistrement dans le fichier binaire Ecrire(f_depart,voiture) Fin pour # Fermeture du fichier Fermer(f_depart) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_depart | fichier |
| i | entier |
| voiture | enregistrement |
La fonction calcul_nbr_annees
Cette fonction calcule le nombre d’années nécessaires pour qu’une voiture atteigne ou dépasse son kilométrage maximal autorisé.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction calcul_nbr_annees(voiture:entier):entier r <- voiture['r'] # Kilométrage parcouru chaque année d_max <- voiture['m'] # Kilométrage maximal autorisé nbr_annee <- 0 # Compteur d'années u1 <- voiture['d'] # Kilométrage actuel # Boucle jusqu'à atteindre ou dépasser le kilométrage maximal Tant que u1 < d_max faire u2 <- u1 + r # Calcul du nouveau kilométrage u1 <- u2 nbr_annee <- nbr_annee + 1 Fin tant que retourner nbr_annee Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| r | entier |
| d_max | entier |
| nbr_annee | entier |
| u1 | entier |
| u2 | entier |
La procédure remplir_fichier_resultat
Cette procédure lit le fichier binaire Depart.dat, calcule pour chaque voiture le nombre d’années nécessaires pour atteindre son kilométrage maximal, puis écrit et affiche ces résultats dans le fichier texte Resultat.txt.
|
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 |
Procedure remplir_fichier_resultat() Ecrire("*** Contenu du fichier Resultat.txt ***") # Ouverture des fichiers Ouvrir(f_depart , "Depart.dat", "rb") Ouvrir(f_resultat , "Resultat.txt", "w") # Lecture des enregistrements du fichier binaire Tant que Vrai: Essayer: voiture = Lire(f_depart) # Lire un dictionnaire nbr_annee <- calcul_nbr_annees(voiture) # Calculer le nombre d'années # Écriture dans le fichier texte Ecrire(f_resultat, voiture['imma'] + ' ' + Conch(nbr_annee) + '\n') # Affichage à l'écran Ecrire(voiture['imma'] + ' ' + Convch(nbr_annee)) En cas de fin de fichier: # Fin du fichier atteinte break # Fermeture des fichiers Fermer(f_depart) Fermer(f_resultat) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_depart | fichier |
| f_resultat | fichier |
| voiture | Enregistrement |
| nbr_annee | 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 111 112 113 114 |
import pickle from pickle import load, dump # -------------------------------------------------- # Dictionnaire représentant une voiture # avec les champs suivants : # - imma : immatriculation de la voiture (chaîne) # - d : kilométrage initial (entier) # - r : kilométrage parcouru chaque année (entier) # - m : kilométrage maximal autorisé (entier) # -------------------------------------------------- voiture = dict( imma=str(), d=int(), r=int(), m=int ) # -------------------------------------------------- # Fonction de saisie sécurisée # Permet de saisir un entier n >= 1 # -------------------------------------------------- def saisie(): n = int(input('donner un nombre >=1: ')) # Tant que la saisie n'est pas valide, redemander while not (n >= 1): n = int(input('donner un nombre >=1: ')) return n # -------------------------------------------------- # Procédure qui remplit le fichier binaire "Depart.dat" # avec les informations des voitures # -------------------------------------------------- def remplir_fichier_depart(n): print("*** Remplir le fichier Depart.dat ***") # Ouverture du fichier en écriture binaire f_depart = open("Depart.dat", "wb") for i in range(n): # Saisie des informations pour chaque voiture voiture['imma'] = input('donner immatriculation de la voiture: ') voiture['d'] = int(input('donner la valeur de kilometrage initiale: ')) voiture['r'] = int(input('donner la valeur de kilometrage parcourue: ')) voiture['m'] = int(input('donner la valeur de kilometrage initiale maximale: ')) # Écriture de l'enregistrement dans le fichier binaire dump(voiture, f_depart) # Fermeture du fichier f_depart.close() # -------------------------------------------------- # Fonction qui calcule le nombre d'années nécessaires # pour qu'une voiture atteigne son kilométrage maximal # -------------------------------------------------- def calcul_nbr_annees(voiture): r = voiture['r'] # Kilométrage parcouru chaque année d_max = voiture['m'] # Kilométrage maximal autorisé nbr_annee = 0 # Compteur d'années u1 = voiture['d'] # Kilométrage actuel # Boucle jusqu'à atteindre ou dépasser le kilométrage maximal while u1 < d_max: u2 = u1 + r # Calcul du nouveau kilométrage u1 = u2 nbr_annee = nbr_annee + 1 return nbr_annee # -------------------------------------------------- # Procédure qui lit le fichier "Depart.dat", # calcule le nombre d'années pour chaque voiture # et écrit le résultat dans le fichier texte "Resultat.txt" # -------------------------------------------------- def remplir_fichier_resultat(): print("*** Contenu du fichier Resultat.txt ***") # Ouverture des fichiers f_depart = open("Depart.dat", "rb") f_resultat = open("Resultat.txt", "w") # Lecture des enregistrements du fichier binaire while True: try: voiture = load(f_depart) # Lire un dictionnaire nbr_annee = calcul_nbr_annees(voiture) # Calculer le nombre d'années # Écriture dans le fichier texte f_resultat.write(voiture['imma'] + ' ' + str(nbr_annee) + '\n') # Affichage à l'écran print(voiture['imma'] + ' ' + str(nbr_annee)) except EOFError: # Fin du fichier atteinte break # Fermeture des fichiers f_depart.close() f_resultat.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie() # Saisie du nombre de voitures remplir_fichier_depart(n) # Remplissage du fichier binaire remplir_fichier_resultat() # Calcul et écriture des résultats |
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
