Algorithme de comptage des occurrences des voyelles dans une chaîne
Plan de tutoriel
1- Principe de l'algorithme de comptage des occurrences des voyelles
2- Algorithme de comptage des occurrences des voyelles
3- Programme Python
Principe de l'algorithme de comptage des occurrences des voyelles
Cet algorithme permet de déterminer le nombre d’occurrences de chaque voyelle dans une chaîne de caractères saisie par l’utilisateur. Les voyelles prises en compte sont A, E, I, O, U et Y, qu’elles soient écrites en majuscules ou en minuscules.
Au début de l’algorithme, six compteurs sont initialisés à 0. Chaque compteur correspond à une voyelle : ca pour A, ce pour E, ci pour I, co pour O, cu pour U et cy pour Y.
L’utilisateur saisit ensuite une chaîne de caractères à l’aide de la fonction saisie(). Cette chaîne peut contenir des lettres, des chiffres, des espaces ou des symboles. La fonction retourne la chaîne saisie afin qu’elle puisse être traitée par la fonction occurrence().
La fonction occurrence() parcourt un à un tous les caractères de la chaîne. Pour chaque caractère, la méthode Majus() le transforme en majuscule. Cette transformation permet de traiter de la même manière une voyelle majuscule et sa correspondante minuscule, par exemple A et a.
Pour chaque caractère, l’instruction Selon permet de vérifier s’il correspond à l’une des six voyelles. Lorsqu’une voyelle est trouvée, son compteur est augmenté de 1. Les autres caractères, comme les consonnes, les chiffres, les espaces et les symboles, ne sont pas comptabilisés.
À la fin du traitement, les six compteurs contiennent le nombre total d’occurrences de chaque voyelle dans la chaîne. Le programme principal affiche alors les résultats obtenus : le nombre de A, de E, de I, de O, de U et de Y.
Algorithme de comptage des occurrences des voyelles
Algorithme du programme Principal
’algorithme principal permet de gérer l’exécution du programme qui compte le nombre d’occurrences de chaque voyelle dans une chaîne de caractères.
Il commence par appeler la fonction saisie() afin de récupérer la chaîne de caractères saisie par l’utilisateur et de la mémoriser dans la variable ch.
Ensuite, il appelle la procédure occurrence(ch) qui parcourt la chaîne et détermine le nombre d’apparitions de chaque voyelle : A, E, I, O, U et Y. Les résultats sont mémorisés dans les compteurs ca, ce, ci, co, cu et cy.
Enfin, l’algorithme principal affiche les résultats en indiquant pour chaque voyelle le nombre de fois où elle apparaît dans la chaîne saisie.
|
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 |
Algorithme Occurrence_voyelles Debut # Appeler la fonction saisie() pour récupérer # la chaîne de caractères saisie par l'utilisateur. ch <-- saisie() # Appeler la fonction occurrence() pour parcourir la chaîne # et compter les occurrences de chaque voyelle. occurrence(ch) # Afficher le nombre d'occurrences de la lettre A. Ecrire("Le nombre de lettres A est ", ca) # Afficher le nombre d'occurrences de la lettre E. Ecrire("Le nombre de lettres E est ", ce) # Afficher le nombre d'occurrences de la lettre I. Ecrire("Le nombre de lettres I est ", ci) # Afficher le nombre d'occurrences de la lettre O. Ecrire("Le nombre de lettres O est ", co) # Afficher le nombre d'occurrences de la lettre U. Ecrire("Le nombre de lettres U est ", cu) # Afficher le nombre d'occurrences de la lettre Y. Ecrire("Le nombre de lettres Y est ", cy) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne des caractères |
| ca | entier |
| ce | entier |
| ci | entier |
| co | entier |
| cu | entier |
| cy | entier |
La fonction saisie
La fonction saisie() permet de demander à l’utilisateur de saisir une chaîne de caractères, puis de retourner cette chaîne au programme principal.
|
1 2 3 4 5 6 7 8 |
Fonction saisie():chaine # Demander à l'utilisateur de saisir une chaîne # de caractères. Ecrire('Donner une chaine des caractères : ') Lire(ch) # Retourner la chaîne saisie. retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne des caractères |
La procédure occurrence
La procédure occurrence(ch) permet de parcourir tous les caractères de la chaîne ch afin de compter le nombre d’apparitions de chaque voyelle : A, E, I, O, U et Y.
Pour chaque caractère de la chaîne, la procédure le convertit en majuscule afin de considérer de la même manière les lettres minuscules et majuscules. Par exemple, a et A sont comptées comme la même lettre.
Ensuite, grâce à l’instruction Selon, elle vérifie la nature du caractère. Lorsqu’il correspond à une voyelle, le compteur associé est augmenté de 1 : ca pour A, ce pour E, ci pour I, co pour O, cu pour U et cy pour Y.
Ainsi, à la fin de la procédure, les différents compteurs contiennent le nombre total d’occurrences de chaque voyelle dans la chaîne saisie.
|
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 |
Procédure occurrence(ch:chaine): # Parcourir tous les caractères de la chaîne ch. # range(len(ch)) produit les indices de 0 jusqu'à len(ch)-1. Pour i de 0 à long(ch)-1 faire # Convertir le caractère ch[i] en majuscule. # Ainsi, 'a' et 'A' seront considérés comme la même lettre. Selon Majus(ch[i]) faire # Si le caractère est égal à 'A', # augmenter le compteur de la lettre A. "A": ca <-- ca + 1 # Si le caractère est égal à 'E', # augmenter le compteur de la lettre E. "E": ce <-- ce + 1 # Si le caractère est égal à 'I', # augmenter le compteur de la lettre I. "I": ci <-- ci + 1 # Si le caractère est égal à 'O', # augmenter le compteur de la lettre O. "O": co <-- co + 1 # Si le caractère est égal à 'U', # augmenter le compteur de la lettre U. "U": cu <-- cu + 1 # Si le caractère est égal à 'Y', # augmenter le compteur de la lettre Y. "Y": cy <-- cy + 1 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| ca (variable globale) | entier |
| ce (variable globale) | entier |
| ci (variable globale) | entier |
| co (variable globale) | entier |
| cu (variable globale) | entier |
| cy (variable globale) | entier |
Programme 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 |
# ========================================================== # Initialisation des compteurs # ========================================================== # Ces variables permettent de compter le nombre d'occurrences # de chaque voyelle dans la chaîne de caractères. ca = 0 # Compteur de la lettre A ce = 0 # Compteur de la lettre E ci = 0 # Compteur de la lettre I co = 0 # Compteur de la lettre O cu = 0 # Compteur de la lettre U cy = 0 # Compteur de la lettre Y # ========================================================== # Fonction de saisie # ========================================================== def saisie(): # Demander à l'utilisateur de saisir une chaîne # de caractères. ch = input('Donner une chaine des caractères : ') # Retourner la chaîne saisie. return ch # ========================================================== # Procédure occurrence # ========================================================== def occurrence(ch): # Déclarer les compteurs comme variables globales. # Cela permet de modifier directement leur valeur # à l'intérieur de la fonction. global ca, ce, ci, co, cu, cy # Parcourir tous les caractères de la chaîne ch. # range(len(ch)) produit les indices de 0 jusqu'à len(ch)-1. for i in range(len(ch)): # Convertir le caractère ch[i] en majuscule. # Ainsi, 'a' et 'A' seront considérés comme la même lettre. match ch[i].upper(): # Si le caractère est égal à 'A', # augmenter le compteur de la lettre A. case c if c == "A": ca = ca + 1 # Si le caractère est égal à 'E', # augmenter le compteur de la lettre E. case c if c == "E": ce = ce + 1 # Si le caractère est égal à 'I', # augmenter le compteur de la lettre I. case c if c == "I": ci = ci + 1 # Si le caractère est égal à 'O', # augmenter le compteur de la lettre O. case c if c == "O": co = co + 1 # Si le caractère est égal à 'U', # augmenter le compteur de la lettre U. case c if c == "U": cu = cu + 1 # Si le caractère est égal à 'Y', # augmenter le compteur de la lettre Y. case c if c == "Y": cy = cy + 1 # ========================================================== # Programme principal # ========================================================== # Appeler la fonction saisie() pour récupérer # la chaîne de caractères saisie par l'utilisateur. ch = saisie() # Appeler la fonction occurrence() pour parcourir la chaîne # et compter les occurrences de chaque voyelle. occurrence(ch) # Afficher le nombre d'occurrences de la lettre A. print("Le nombre de lettres A est ", ca) # Afficher le nombre d'occurrences de la lettre E. print("Le nombre de lettres E est ", ce) # Afficher le nombre d'occurrences de la lettre I. print("Le nombre de lettres I est ", ci) # Afficher le nombre d'occurrences de la lettre O. print("Le nombre de lettres O est ", co) # Afficher le nombre d'occurrences de la lettre U. print("Le nombre de lettres U est ", cu) # Afficher le nombre d'occurrences de la lettre Y. print("Le nombre de lettres Y est ", cy) |
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
