Nom Triangulaire – Bac théorique – Section informatique – 2024
Sujet (Algo et programmation - Bac 2024)
Dans le but d’attribuer des cadeaux à des invités présents dans une soirée, on se propose de choisir les personnes dont le nom est triangulaire et ayant le score le plus élevé. Ces personnes seront déclarées gagnantes.
Un nom est dit triangulaire, si son score est un nombre triangulaire.
Le score d’un nom est la somme des rangs dans l’alphabet de toutes les lettres qui le constituent. Un nombre S est triangulaire s’il existe un entier 𝑛 tel que :
Sachant que les noms des invités sont enregistrés dans le fichier texte "Invites.txt", on procède comme suit pour sélectionner les personnes gagnantes :
- Transférer, à partir du fichier "txt" les noms triangulaires vers un nouveau fichier d’enregistrements nommé "Triangulaires.dat" où chaque enregistrement est constitué de deux champs :
Nom : le nom de la
Score : le score du nom de la
- Afficher les noms des personnes gagnantes (ayant le score le plus élevé).
Travail demandé :
1- Ecrire un algorithme du programme principal en respectant le procédé décrit précédemment et en le décomposant en modules.
2- Ecrire un algorithme pour chaque module envisagé.
Solution Algorithmique
Dans cet algorithme, On va utiliser trois fonctions et quatre procédures
- la fonction saisie()
- la procédure remplir_fichier_Invites()
- la fonction test_triangulaire()
- la fonction calcul_score()
- la procédure remplir_fichier_triangulaire()
- la procédure recherche_maxscore_gangnants()
- la procédure afficher_gagnants()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 |
Algorithme nom_triangulaire Debut n <- saisie() remplir_fichier_Invites(n) remplir_fichier_triangulaire() max_score <- recherche_maxscore_gangnants() afficher_gagnants(max_score) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| max_score | entier |
La fonction saisie
Cette fonction permet de saisir et retourner un entier > 0 en contrôlant la validité de la saisie.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie():entier # Demande à l'utilisateur de saisir un entier n > 0 Ecrire('donner un entier n > 0') Lire(n) # Vérification de la validité de la saisie Tant que Non (n > 0) faire Ecrire('donner un entier n > 0 : ') 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_fichier_Invites
Cette procédure sert à enregistrer dans le fichier Invites.txt une liste de n invités saisis par l’utilisateur, à raison d’un nom par ligne.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Procedure remplir_fichier_Invites(n:entier) Ecrire('*** Remplir fichier Invites.txt ***') # Ouverture du fichier en mode écriture texte Ouvri(f , "Invites.txt", "w") # Saisie des noms et écriture dans le fichier Pour i de 0 à n-1 faire Ecrire('donner un nom ') Lire(nom) Ecrire(f, nom + '\n') Fin pour # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| i | entier |
| nom | chaîne |
La fonction test_triangulaire
Cette fonction teste si le score donné est un nombre triangulaire et renvoie vrai si c’est le cas, faux sinon.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction test_triangulaire(score:entier):booleen n <- 1 # On cherche un n tel que n(n+1)/2 atteigne ou dépasse le score Tant que (n*(n+1)/2)<score faire n<-n+1 Fin tant que # Retourne Vrai si le score est triangulaire, sinon Faux retourner score = n*(n+1)/2 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction calcul_score
Cette fonction qui calcule le score d'un nom qui est la somme des positions alphabétiques des lettres du nom (A=1, B=2, ..., Z=26).
|
1 2 3 4 5 6 7 |
Fonction calcul_score(nom:entier):entier score <- 0 Pour i de 0 à long(nom)-1 faire score <- score+(ord(Majus(nom[i]))-64 Fin pour retourner score Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| score | entier |
| i | entier |
La procédure remplir_fichier_triangulaire
Cette Procédure crée le fichier binaire "Triangulaires.dat" contenant les invités dont le score est triangulaire.
|
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 remplir_fichier_triangulaire() Ecrire('*** Contenu du fichier Triangulaires.dat ***') # Ouverture du fichier des invités en lecture Ouvrir(f_invite , "Invites.txt", "r") # Ouverture du fichier binaire en écriture Ouvrir(f_triangle , "Triangulaires.dat", "wb") # Lecture de tous les noms noms <- Lire_lignes(f_invite) # Traitement de chaque nom Pour nom dans noms faire nom <- nom.strip('\n') # Suppression du retour à la ligne score <- calcul_score(nom) # Vérification si le score est triangulaire Si test_triangulaire(score) alors invite['nom'] <- nom invite['score'] <- score # Affichage à l’écran Ecrire("nom=" + nom + ', score=' + Convch(score)) # Sauvegarde dans le fichier binaire Ecrire(f_triangle , invite) Fin pour # Fermeture des fichiers Fermer(f_invite) Fermer(f_triangle) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_invite | fichier |
| f_triangle | fichier |
| noms | chaîne |
| nom | chaîne |
| score | entier |
| invite | enregistrement |
La fonction recherche_maxscore_gangnants
Cette fonction recherche le score maximum parmi les invités triangulaires
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Fonction recherche_maxscore_gangnants():entier Ouvrir(f_triangle , "Triangulaires.dat", "rb") max_score <- 0 # Lecture du fichier jusqu'à la fin Tant que Vrai faire Essayer: invite = Lire(f_triangle) # Lecture d’un dictionnaire Si invite["score"] > max_score alors max_score <- invite["score"] En cas de fin du fichier: # Fin du fichier Sortir Fin tant que Fermer(f_triangle) retourner max_score Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_triangle | fichier |
| max_score | entier |
| invite | enregistrement |
La procédure afficher_gagnants
Cette procédure affiche les gagnants (invités ayant le score maximum).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Procédure afficher_gagnants(max_score:entier) Ecrire('*** Les gagnants sont : ***') Ouvrir(f_triangle , "Triangulaires.dat", "rb") # Parcours du fichier binaire Tant que Vrai faire Essayer: invite <- Lire(f_triangle) Si invite["score"] = max_score alors print(invite["nom"]) Fin si En cas de fin de fichier: # Fin du fichier Sortir Fin tant que Fermer(f_triangle) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_triangle | fichier |
| invite | enregistrement |
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 |
from pickle import load, dump # -------------------------------------------------- # Enregistrement représentant un invité # - nom : nom de l'invité # - score : score associé au nom # -------------------------------------------------- invite = dict( nom=str(), score=int() ) # -------------------------------------------------- # Fonction de saisie d’un entier strictement positif # -------------------------------------------------- def saisie(): # Saisie initiale n = int(input('donner un nombre >0: ')) # Vérification de la validité de la saisie # Tant que n n'est pas strictement positif, on redemande while not (n > 0): n = int(input('donner un nombre >=0: ')) # Retourner la valeur valide return n # -------------------------------------------------- # Procédure qui remplit le fichier texte "Invites.txt" # avec n noms saisis par l'utilisateur # -------------------------------------------------- def remplir_fichier_Invites(n): print('*** Remplir fichier Invites.txt ***') # Ouverture du fichier en mode écriture texte f = open("Invites.txt", "w") # Saisie des noms et écriture dans le fichier for i in range(n): nom = input('donner un nom ') f.write(nom + '\n') # Fermeture du fichier f.close() # -------------------------------------------------- # Fonction qui teste si un score est un nombre triangulaire # Un nombre triangulaire est de la forme n(n+1)/2 # -------------------------------------------------- def test_triangulaire(score): n = 1 # On cherche un n tel que n(n+1)/2 atteigne ou dépasse le score while (n * (n + 1) / 2) < score: n = n + 1 # Retourne True si le score est triangulaire, sinon False return score == n * (n + 1) / 2 # -------------------------------------------------- # Fonction qui calcule le score d'un nom # Le score est la somme des positions alphabétiques # des lettres du nom (A=1, B=2, ..., Z=26) # -------------------------------------------------- def calcul_score(nom): score = 0 for i in range(len(nom)): score = score + (ord(nom[i].upper())) - 64 return score # -------------------------------------------------- # Procédure qui crée le fichier binaire "Triangulaires.dat" # contenant les invités dont le score est triangulaire # -------------------------------------------------- def remplir_fichier_triangulaire(): print('*** Contenu du fichier Triangulaires.dat ***') # Ouverture du fichier des invités en lecture f_invite = open("Invites.txt", "r") # Ouverture du fichier binaire en écriture f_triangle = open("Triangulaires.dat", "wb") # Lecture de tous les noms noms = f_invite.readlines() # Traitement de chaque nom for nom in noms: nom = nom.strip('\n') # Suppression du retour à la ligne score = calcul_score(nom) # Vérification si le score est triangulaire if test_triangulaire(score): invite['nom'] = nom invite['score'] = score # Affichage à l’écran print("nom=" + nom + ', score=' + str(score)) # Sauvegarde dans le fichier binaire dump(invite, f_triangle) # Fermeture des fichiers f_invite.close() f_triangle.close() # -------------------------------------------------- # Fonction qui recherche le score maximum # parmi les invités triangulaires # -------------------------------------------------- def recherche_maxscore_gangnants(): f_triangle = open("Triangulaires.dat", "rb") max_score = 0 # Lecture du fichier jusqu'à la fin while True: try: invite = load(f_triangle) # Lecture d’un dictionnaire if invite["score"] > max_score: max_score = invite["score"] except EOFError: # Fin du fichier break f_triangle.close() return max_score # -------------------------------------------------- # Procédure qui affiche les gagnants # (invités ayant le score maximum) # -------------------------------------------------- def afficher_gagnants(max_score): print('*** Les gagnants sont : ***') f_triangle = open("Triangulaires.dat", "rb") # Parcours du fichier binaire while True: try: invite = load(f_triangle) if invite["score"] == max_score: print(invite["nom"]) except EOFError: # Fin du fichier break f_triangle.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie() remplir_fichier_Invites(n) remplir_fichier_triangulaire() max_score = recherche_maxscore_gangnants() afficher_gagnants(max_score) |
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
