Suite arithmétique – Bac théorique – Section informatique – 2023
Sujet (Algo et programmation - Bac 2023)
Une agence de location de voitures se propose de gérer le budget de renouvellement de ses Nb voitures. Pour se faire, l’agence calcule pour chaque voiture le nombre d’années au bout duquel elle doit être renouvelée. Ce nombre dépend de la valeur du kilométrage initialement parcouru par la voiture (d), du nombre de kilomètres parcourus chaque année (r) et de la valeur maximale prévue des kilomètres à parcourir (m).
La valeur du kilométrage parcouru par une voiture est initialement égale à d et elle augmente chaque année d’une même valeur r, donc elle forme une suite arithmétique U de raison r :
U1 = d
Un = Un-1 + r pour n ≥ 2
Avec :
- d : un entier qui représente la valeur du kilométrage initialement parcouru.
- r : un entier qui représente le nombre de kilomètres parcourus chaque année.
Exemple : Pour d = 10000 km, r = 40000 km et m = 400000 km, le nombre d’années au bout duquel la voiture doit être renouvelée est égale à 10 ans.
Les informations des Nb voitures de l’agence de location sont stockées dans un fichier d’enregistrements "Depart.dat" déjà rempli. Chaque enregistrement du fichier contient les champs suivants :
- immat : une chaîne de caractères qui représente le numéro d’immatriculation de la voiture.
- d : un entier naturel qui représente la valeur du kilométrage initialement parcouru.
- r : un entier naturel qui représente le nombre de kilomètres parcourus chaque année.
- m : un entier naturel qui représente la valeur maximale prévue des kilomètres à parcourir.
On se propose d’écrire un algorithme d’une procédure nommée Renouv qui, à partir du fichier "Depart.dat", permet de générer un fichier texte "Resultat.txt" contenant dans chaque ligne le numéro d’immatriculation de la voiture suivi du nombre d’années pour atteindre la distance maximale prévue séparés par le caractère espace.
Travail demandé :
1) Ecrire un algorithme d’une fonction Annee(d, r, m) qui permet de retourner un entier qui représente le nombre d’années au bout du quel une voiture ayant parcourue une distance d atteindra une distance maximale prévue m (avec m strictement supérieur à d).
2) Ecrire les instructions d’ouverture des fichiers "Depart.dat" et "Resultat.txt", sachant qu’ils sont stockés sur la racine du disque D.
3) Ecrire un algorithme de la procédure Renouv, pour générer le fichier "Resultat.txt", en faisant appel à la fonction Annee.
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
