Recherche dans un tableau des caractères – Bac pratique 2010 [ Algorithme + Python ]
Travail demandé
Ecrire un programme qui permet de :
- remplir un tableau T de n lettres alphabétique minuscules (5<=n<=9) - saisir une chaîne MOT non vide formée de lettres alphabétiques minuscules de longueur inférieure ou égale à 7 - vérifier si on peut former cette chaîne à partir des caractères du tableau. Dans le cas où on peut la former, le programme affichera les indices repectifs des caractères dans le tableau T qui composent la chaîne MOT. Exemple1 : pour MOT= »admis » et pour le tableau T suivant :
| s | r | d | a | i | e | P | D | m |
Le programme affichera : 4 3 9 5 1
Exemple 2 : pour MOT= « bac » et pour le tableau T suivant :
| f | c | k | A | e | H |
Le programme affichera : on ne peut pas former la chaîne à partir des caractères du tableau.
Solution Algorithmique
Voici le principe de l'algorithme pour résoudre ce problème :
1. Remplir le tableau T de n lettres alphabétiques minuscules :
- Créer un tableau T de longueur n (avec 5 <= n <= 9).
- Remplir le tableau avec des lettres alphabétiques minuscules manuellement.
2. Saisir la chaîne MOT :
Demander à l'utilisateur de saisir une chaîne MOT formée de lettres alphabétiques minuscules. La longueur de MOT doit être inférieure ou égale à 7.
3. Vérifier si la chaîne MOT peut être formée à partir des caractères du tableau T :
- Pour chaque lettre c dans MOT, rechercher cette lettre dans le tableau T.
- Si la lettre c est trouvée dans T, enregistrer l'indice correspondant, et marquer cette lettre comme utilisée (pour éviter de l'utiliser à nouveau).
- Répéter cette étape pour chaque lettre de MOT.
4. Affichage des indices :
- Si toutes les lettres de MOT ont été trouvées dans T, afficher les indices respectifs des caractères dans le tableau T.
- Sinon, indiquer que MOT ne peut pas être formé à partir de T.
Dans cet algorithme, On va utiliser 3 fonctions et 2 procédures :
|
1 2 3 4 5 6 7 8 |
Algorithme eliminer_tableau Debut n<-saisie() Ecrire('remplissage du tableau t') remplir(t,n) mot<-saisie_mot() recherche (t,n,mot) Fin |
Déclaration des objets
Objet | Type / Nature |
n | entier |
t | tableau de 30 entiers |
La fonction saisie
Cette fonction retourne un entier n entre 4 et 10 saisi par l'utilisateur.
|
1 2 3 4 5 6 7 8 9 10 |
foncttion saisie() Début Ecrire('donner un entier entre 5 et 9') lire (n) Tant que n<5 ou n>9 faire Ecrire('donner un entier entre 5 et 9') lire (n) Fin tant que retourner n Fin |
Déclaration des objets
Objet | Type / Nature |
n | entier |
La procédure remplir
Cette procédure remplit le tableau t de n entiers.
|
1 2 3 4 5 6 7 8 9 10 11 |
Procédure remplir(@t:Tab,n:entier) Début Pour i de 0 à n-1 faire Ecrire(donner une lettre miniscule pour elt N°",i,": ") lire(t[i]) Tant que ('a'>t[i]) ou (t[i]>'z') faire Ecrire(donner une lettre miniscule pour elt N°",i,": ") lire(t[i]) Fin tant que Fin pour Fin |
Déclaration des objets
Objet | Type / Nature |
i | entier |
La fonction verif_mot
Cette fonction vérifie si un mot est de longueur entre 1 et 7 et composé uniquement des lettres minuscules.
|
1 2 3 4 5 6 7 8 9 10 11 |
Fonction verif_mot(ch:chaine) Début Si 1<=len(ch)<=7 alors i<-0 Tant que 'a'<=ch[i]<='z' et i<long(ch)-1 faire i<-i+1 Fin tant que retourner 'a'<=ch[i]<='z' Si non retourner Faux Finin |
Déclaration des objets
Objet | Type / Nature |
i | entier |
La fonction saisie_mot
Cette fonction saisit un mot de longueur entre 1 et 7 et composé uniquement des lettres minuscules.
|
1 2 3 4 5 6 7 8 |
Fonction saisie_mot(@ch:chaine) Début lire(ch) Ecrire("donner un mot non vide formé par des lettres minuscules et sa longeur <=7: ") Tant que (verif_mot(ch)=Faux) faire ch=input("donner un mot non vide formé par des lettres minuscules et sa longeur <=7: ") retourner ch Fin |
La procédure recherche
Cette procédure recherche si les caractères d'un mot se trouvent tous dans le tableau des caractères.
|
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 |
Procédure recherche(t:Tab,n:entier,mot:chaîne) Début indice<-'' i<--1 j<-0 exist<-Vrai Tant que (exist) et (i<long(mot)-1) faire i<-i+1 exist<-Faux j<-0 Tant que ((mot[i]!=t[j]) et (j<n-1)) faire j<-j+1 Fin tant que Fin tant que Si (mot[i]=t[j]) alors exist<-Vrai ch<-Conch(j)+' ' indice<-indice+ch Fin si Si (mot[i]=t[j]) alors Ecrire('les indices des lettres du mot= ',indice) Sinon Ecrire('On ne peut pas former la chaîne à partir des caractères du tableau ') Fin si Fin |
Déclaration des objets
Objet | Type / Nature |
i | entier |
j | entier |
indice | chaîne des carcatères |
exist | booléen |
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 |
from numpy import array t=array([str()]*30) # déclaraction des objets def saisie_taille() : n=int(input("donner un entier entre 5 et 9 ")) while(5>n) or (n>9) : n=int(input("donner un entier entre 5 et 9 ")) return n def remplir(t,n): for i in range (n) : t[i]=input("donner une lettre miniscule pour elt N°"+str(i)+": ") while('a'>t[i]) or (t[i]>'z') : t[i]=input("donner une lettre miniscule pour elt N°"+str(i)+": ") def verif_mot(ch): if 1<=len(ch)<=7 : i=0 while 'a'<=ch[i]<='z' and i<len(ch)-1: i=i+1 return 'a'<=ch[i]<='z' else: return False def saisie_mot(): ch=input("donner un mot non vide formé par des lettres minicules et sa longeur <=7: ") while(verif_mot(ch)==False) : ch=input("donner un mot non vide formé par des lettres minicules et sa longeur <=7: ") return ch def recherche (t,n,mot): indice='' i=-1 j=0 exist=True while (exist) and (i<len(mot)-1): i=i+1 exist=False j=0 while ((mot[i]!=t[j]) and (j<n-1)): j=j+1 if (mot[i]==t[j]): exist=True ch=str(j)+' ' indice=indice+ch if(mot[i]==t[j]): print('les indices des lettres du mot= '+str(indice)) else: print('On ne peut pas former la chaîne à partir des caractères du tableau ') # programme principal n=saisie_taille() print('remplissage du tableau t') remplir(t,n) mot=saisie_mot() recherche (t,n,mot) |
Exécution du programme
Solution en Python et Designer QT
Pour remplir un tableau des caractères à 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 des caractères.
2- Ajouter chaque caractère au tableau.
Pour créer une application en Python pour vérifier si les caractères d'un mot se trouvent tous dans le tableau des caractères.
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 des caractères pour le tableau t.
QLineEdit nommé 'mot' pour entrer une chaîne à rechercher dans le tableau .
QPushButton nommé 'remplir_bt' pour exécuter le module createTab afin de remplir le tableau à partir de la chaine 'ch'.
QPushButton nommé 'recherche_bt' pour exécuter le module chercher_mot.
QLabel nommé 'msg' pour afficher un message d'erreur si ch est vide ou ne contient pas des lettres minuscules.
QLabel nommé 'resultat_recherche' pour afficher le résultat de la recherche du mot dans le tableau des caractères.
QLabel nommé 'tablabel' pour afficher les éléments du tableau.
Enregistrez le fichier avec l'extension .ui, par exemple tabtab-2.ui.
2- Créer le script Python pour l'application
Voici un exemple de script Python qui utilise l'interface graphique générée par Qt Designer.
|
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 |
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(): windows.tab_label.clear() ch = windows.ch.text() global n # pour la taille du 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]<='z') or (ch[i]==' '))): if ('a'<=ch[i]<='z') : t[j]=ch[i] j=j+1 i=i+1 if (i<len(ch)) : # si la chaine contient des valeurs non numeriques windows.msg.setText("la chaîne doit contenir des lettres minsicules ") else : if (5<=j<=9) : n=j tab='' for k in range (j) : tab=tab+ 't['+str(k)+']= '+ str(t[k])+ '\n' #afficher les elements du tableau windows.tab_label.setText(tab) else: windows.msg.setText("la taille du tableau n'est pas entre 5 et 9") def verif_mot(ch): if 1<=len(ch)<=7 : i=0 while 'a'<=ch[i]<='z' and i<len(ch)-1: i=i+1 return 'a'<=ch[i]<='z' else: return False def chercher_mot(): mot = windows.mot.text() if verif_mot(mot): indice='' i=-1 j=0 exist=True while (exist) and (i<len(mot)-1): i=i+1 exist=False j=0 while ((mot[i]!=t[j]) and (j<n-1)): j=j+1 if (mot[i]==t[j]): exist=True ch=str(j)+' ' indice=indice+ch if(mot[i]==t[j]): windows.resultat_recherche.setText('les indices des lettres du mot= '+str(indice)) else: windows.resultat_recherche.setText('On ne peut pas former la chaîne à partir des caractères du tableau') windows.remplir_bt.clicked.connect ( createTab ) windows.recherche_bt.clicked.connect ( chercher_mot ) 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
