Mot mono-vocalisme – Bac Pratique 2016 [ Algorithme + Python ]
Travail demandé
Un mot est dit mono-vocalisme en une voyelle donnée s’il inclut une seule voyelle, qui est celle donnée, avec une ou plusieurs occurrences, sans distinction entre majuscule et minuscules.
Exemples :
« Cas » est un mono-vocalisme en « a » car il inclut une seule occurrence de la voyelle « a »
« Cesse » est un mono-vocalisme en « e » car il inclut deux occurrence de la voyelle « e »
« Case » n’est pas un mono-vocalisme en « a » car il inclut une autre voyelle différente de « a »
On se propose d’écrire un programme Python permettant d’afficher les mots mono-vocalismes en une voyelle donnée, dans un tableau T de n chaines formées uniquement par des lettres (1≤n≤10)
Solution Algorithmique
Pour écrire un algorithme permettant d'afficher les mots qui sont des mono-vocalismes en une voyelle donnée, dans un tableau T de n chaînes formées uniquement par des lettres, voici les étapes à suivre :
1- Initialiser les variables :
Un tableau T de n chaînes.
Une voyelle v donnée.
2- Définir une fonction pour vérifier si un mot est un mono-vocalisme :
Pour chaque mot dans T, vérifier si toutes les lettres qui sont des voyelles sont identiques à v.
3- Parcourir le tableau T :
Pour chaque chaîne, appliquer la fonction de vérification du mono-vocalisme.
Si le mot est un mono-vocalisme en la voyelle v, l'afficher.
Dans cet algorithme, On va utiliser 4 fonctions et 2 procédures :
|
1 2 3 4 5 6 7 8 9 |
Algorithme mots_monovocalismes Debut ch<-saisie_ch() n<-saisie_taille() Ecrire('remplissage du tableau t') remplir(t,n,ch) v=saisie_voyelle() afficher_mots_monovocalismes(t,n,v) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| ch | chaîne des caractères |
| t | tableau des 30 chaînes des caractères |
| v | caractère |
La fonction saisie_taille
Cette fonction retourne un entier n entre 1 et 10 saisi par l'utilisateur.
|
1 2 3 4 5 6 7 8 9 10 |
foncttion saisie_taille():entier Début Ecrire('donner un entier entre 1 et 10') lire (n) Tant que n<1 ou n>10 faire Ecrire('donner un entier entre 1 et 10') lire (n) Fin tant que retourner n Fin |
Déclaration des objets
Objet | Type / Nature |
n | entier |
La fonction verif_lettres
Cette fonction vérifie si une chaine est composé uniquement des lettres.
|
1 2 3 4 5 6 7 8 9 10 11 |
foncttion verif_majus(ch:chaine):booleen Début i<-0 Tant que ('A'<=Majus(ch[i])<='Z') et (i<long(ch)-1) faire i<-i+1 Fin tant que Si ('A'<=Majus(ch[i])<='Z') alors retourner Vrai Sinon retuurner Faux Fin |
Déclaration des objets
Objet | Type / Nature |
i | entier |
La fonction saisie_voyelle
Cette fonction retourne une voyelle saisie par l'utilisateur.
|
1 2 3 4 5 6 7 8 9 10 |
foncttion saisie_voyelle():chaine Début Ecrire('donner une voyelle:') lire (v) Tant que (v n est pas dans {'A','I','O','Y','U','E'}) faire Ecrire('donner une voyelle:') lire (v) Fin tant que retourner v Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| v | caractère |
La procédure remplir
Cette procédure remplit le tableau t des mots composé uniquement des lettres
|
1 2 3 4 5 6 7 8 9 10 11 |
Procédure remplir(@t:Tab,n:entier,ch:chaine) Début Pour i de 0 à n-1 faire Ecrire(""donner elt N° "+i+" compose des lettres:") lire(t[i]) Tant que (verif_lettres(t[i])=Faux) faire Ecrire(""donner elt N° "+i+"compose des lettres:") lire(t[i]) Fin tant que Fin pour Fin |
Déclaration des objets
Objet | Type / Nature |
i | entier |
La fonction mono_vocalisme
Cette fonction vérifie si un mot est un mono-vocalisme.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Fonction mono_vocalisme(ch:chaine,v:caractere):booleen Début v<-Miniscule(v) #convertir la voyelle en miniscule Si Pos(ch, v) >=0 alors Tant que (Pos(ch, v)>=0) faire #effacer la voyelle ch=ch.replace(v, "") Fin tant que Tant que (Pos(ch, Majus(v))>=0) faire #effacer la voyelle en majuscule ch=ch.replace(v.upper(), "") fin tant que i<-0 # recherche d'autres voyelles Tant que (Majus(ch[i] n est pas dans {'A','I','O','Y','U','E'}) et i<long(ch)-1 faire i=i+1 Fin tant que retourner (Majus(ch[i] n est pas dans {'A','I','O','Y','U','E'} Sinon retourner Faux Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La procédure afficher_mots_monovocalismes
Cette procédure parcourt le tableau T :
1- Pour chaque chaîne, appliquer la fonction de vérification du mono-vocalisme.
2- Si le mot est un mono-vocalisme en la voyelle v, l'afficher.
|
1 2 3 4 5 6 7 8 9 |
Procédure afficher_mots_monovocalismes(t:Tab,n:entier,v:voyelle) Début Ecrire('Les mots mono-vocalismes en '+v+ ' sont' ) Pour i de 0 à n-1 faire Si mono_vocalisme(t[i],v) alors Ecrire(t[i]) Fin si Fin pour Fin |
Déclaration des objets
Objet | Type / Nature |
i | 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 |
from numpy import array t=array([str]*30) #declaration du tableau des chaines def verif_lettres(ch): i=0 while ('A'<=ch[i].upper()<='Z') and (i<len(ch)-1): i=i+1 if ('A'<=ch[i].upper()<='Z'): return True else: return False def saisie_taille() : n=int(input("donner un entier entre 1 et 10: ")) while(n<1) or (n>10) : n=int(input("donner un entier entre 1 et 10: ")) return n def saisie_voyelle() : c=input("donner une voyelle: ") while(c.upper() not in {'A','I','O','Y','U','E'}) : c=input("donner une voyelle: ") return c def remplir(t,n): for i in range (n) : t[i]=input("donner elt N° "+str(i)+" compose des lettres: ") while (len(t[i])==0) or (verif_lettres(t[i])==False) : t[i]=input("donner elt N° "+str(i)+" compose des lettres: ") def mono_vocalisme(ch,v): v=v.lower() if ch.find(v)>=0 : while (ch.find(v)>=0): ch=ch.replace(v, "") while (ch.find(v.upper())>=0): ch=ch.replace(v.upper(), "") i=0 while (ch[i].upper() not in {'A','I','O','Y','U','E'}) and i<len(ch)-1 : i=i+1 return ch[i].upper() not in {'A','I','O','Y','U','E'} else: return False def afficher_mots_monovocalismes(t,n,v): print('Les mots mono-vocalismes en '+v+ ' sont' ) for i in range (n) : if mono_vocalisme(t[i],v): print(t[i]) #programme principal n=saisie_taille() print('remplissage du tableau t') remplir(t,n) v=saisie_voyelle() afficher_mots_monovocalismes(t,n,v) |
Exécution du programme
Solution en Python et Designer QT
Pour remplir un tableau des chaînes à partir d'une chaîne de caractères en Python, vous pouvez suivre les étapes suivantes :
1- Découper la chaîne de caractères en sous-chaînes contenant les mots.
3- Ajouter chaque sous-chaîne au tableau.
Pour créer une application en Python pour rechercher l'existence des mots monovocalismes dans le tableau T.
1- Créer l'interface graphique avec Qt Designer
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets:
QLineEdit nommé 'ch' pour entrer une chaîne formées de plusieurs mot.
QLineEdit nommé 'c' pour entrer la voyelle.
QPushButton nommé 'remplir_bt' pour exécuter le module createTab afin de remplir le tableau à partir de la chaine 'ch'.
QPushButton nommé 'bt_recherche' pour exécuter le module afficher_mots_monovocalismes.
QLabel nommé 'msg' pour afficher les messages d'erreur
QLabel nommé 'tab_label' pour afficher les éléments du tableau T.
QLabel nommé 'resultat' pour afficher les mots monovocalismes.
Enregistrez le fichier avec l'extension .ui, par exemple tabtab-2.ui.
2- Créer le script Python pour l'application
|
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 |
from PyQt5.uic import loadUi from PyQt5 import QtCore, QtGui from PyQt5.QtWidgets import * from PyQt5 import QtCore, QtGui, QtWidgets from numpy import array t=array([str]*30) app = QApplication([]) windows = loadUi ("tabtab-2.ui") # Fonction qui supprime des espaces de la chaine des carcatères def supprimer_espaces (ch) : while(ch[0]==' '): # elimnier tous les espaces au début de la chaine ch=ch[1:len(ch)] while(ch[len(ch)-1]==' '): # elimnier tous les espaces a la fin de la chaine ch=ch[0:len(ch)-1] while (ch.find(' ')>0): ch=ch.replace(" ", " ") # remplacer les doubles espaces apar un seul espace return ch # Procedure qui remplit un tableau par des entiers a partir d'une chaine des caractère def createTab(): ch = windows.ch.text() global n # pour la taille di tableau if ch=="": windows.msg.setText("Veuillez remplir la chaîne") else: windows.msg.clear() # effacer le message d erreur ch= supprimer_espaces(ch) i=0 j=0 ch1='' # parcourir les caracteres de la chaine while((i<len(ch)) and (('A'<=ch[i].upper()<='Z') or (ch[i]==' '))): if ('A'<=ch[i].upper()<='Z'): ch1=ch1+ch[i] if ((ch[i]==' ') or (i==len(ch)-1)) : t[j]=ch1 ch1='' j=j+1 i=i+1 if (i<len(ch)) : windows.msg.setText("La chaine doit contenir des mots forùe des lettres") else : if 1<=j<=10: # test du taille du tableau n=j tab='' for k in range (j) : tab=tab+ 't['+str(k)+']= '+ t[k]+ '\n' #afficher les elements du tableau windows.tab_label.setText(tab) else: windows.msg.setText("Le nbr des elements doit etre entre 1 et 10") def mono_vocalisme(ch,c): c=c.lower() if ch.find(c)>=0 : while (ch.find(c)>=0): ch=ch.replace(c, "") while (ch.find(c.upper())>=0): ch=ch.replace(c.upper(), "") i=0 while (ch[i].upper() not in {'A','I','O','Y','U','E'}) and i<len(ch)-1 : i=i+1 return ch[i].upper() not in {'A','I','O','Y','U','E'} def afficher_mots_monovocalismes(): c = windows.c.text() if c.upper() in {'A','I','O','Y','U','E'} : liste='' for i in range (n) : if mono_vocalisme(t[i],c): print(t[i]) liste=liste+t[i]+'\n' windows.resultat.setText(liste) else: windows.msg.setText("Le caractere c doit etre une voyelle") windows.remplir_bt.clicked.connect ( createTab ) windows.bt_recherche.clicked.connect ( afficher_mots_monovocalismes ) windows.show() app.exec_() |
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
