Vous n'êtes pas identifié(e).
L'icône rouge permet de télécharger chaque page du wiki visitée au format PDF et la grise au format ODT →
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente | ||
utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [30/11/2014 08:23] Hypathie [Exo 3 : procédure rechercher un palindrome] |
utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [06/12/2014 17:08] (Version actuelle) Hypathie [Recherche dichotomique] |
||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
- | ======Algo: exo constructions d'algorithmes de procédure====== | + | ======algo-exo-constructions-d-algorithmes-de-procedure====== |
- | * Objet : S'exercer à la construction d'algorithmes de procédure | + | * Objet : Comment élaborer l'algorithme une procédure ? |
* Niveau requis : {{tag>débutant avisé}} | * Niveau requis : {{tag>débutant avisé}} | ||
* Commentaires : //Contexte d'utilisation du sujet du tuto. // | * Commentaires : //Contexte d'utilisation du sujet du tuto. // | ||
Ligne 298: | Ligne 298: | ||
</code> | </code> | ||
- | ====4)Interface (notice) de la procédure ==== | + | ====4)Interface (notice) de la procédure ==== |
+ | <code> | ||
+ | procédure cherchePalinPoint(entrée texte : chaine, | ||
+ | entrée sortie ind1 : entier, ind2 : entier) | ||
+ | // Cette procédure permet de dire si une chaine de caractère terminée par un point est un palindrome. | ||
+ | // ind1 : c'est l'indice de parcours du texte par le début | ||
+ | // ind2 : c'est l'indice de parcours du texte par la fin | ||
+ | </code> | ||
====5)Programme de test ==== | ====5)Programme de test ==== | ||
+ | <code> | ||
+ | CONSTANTES | ||
+ | constante MAX =80 //nombre max de caractères de la chaîne (Pour pouvoir créer le type chaine, car un tableau est toujours de taille fixe. | ||
+ | constante FIN ='.' // caractère terminaleur de la chaîne (Un tableau peut ne pas être tout rempli) | ||
+ | |||
+ | TYPES | ||
+ | Type chaine =tableau[MAX] de caractères // type crée pour contenir une liste | ||
+ | |||
+ | VARIABLES | ||
+ | variable possPalin : chaine // phrase où une symétrie est recherchée | ||
+ | variable indiceDeb : entier // | ||
+ | variable indiceFin : entier // indice de parcours de la phrase depuis la fin. | ||
+ | |||
+ | PROCEDURES | ||
+ | procédure cherchePalinPoint(entrée texte : chaine, | ||
+ | entrée sortie ind1 : entier, ind2 : entier | ||
+ | sortie result : booléen) | ||
+ | // Cette procédure permet de dire si une chaine de caractère terminée par un point est un palindrome. | ||
+ | // ind1 : c'est l'indice de parcours du texte par le début | ||
+ | // ind2 : c'est l'indice de parcours du texte par la fin | ||
+ | |||
+ | Début | ||
+ | // Saisie de la phrase : | ||
+ | ECRIRE ('Entrez votre phrase et n'oubliez pas de la terminer par un point.' | ||
+ | LIRE(phrase) | ||
+ | indiceDeb := possPalin[1] | ||
+ | indiceFin := possPalin[MAX-1] | ||
+ | result := booléen | ||
+ | |||
+ | // Recherche d'un palindrome fini par un point : | ||
+ | cherchePalinPoint(entrée possPalin:chaine , entrée/sortie ind1:entier, entrée/sortie ind2:entier, sortie result:bool) | ||
+ | SI result = VRAI | ||
+ | ECRIRE('La phrase', possPalin 'est un palindrome.') | ||
+ | SINON | ||
+ | ECRIRE('La phrase', possPalin 'n'est pas un palindrome.') | ||
+ | FINSI | ||
+ | Fin | ||
+ | |||
+ | </code> | ||
+ | |||
====6)Algorithme de la procédure Palindrome terminé par un point==== | ====6)Algorithme de la procédure Palindrome terminé par un point==== | ||
+ | |||
+ | <code> | ||
+ | procédure cherchePalinPoint(entrée texte : chaine, | ||
+ | entrée sortie ind1 : entier, ind2 : entier | ||
+ | sortie result: booléen) | ||
+ | // Cette procédure permet de dire si une chaine de caractère terminée par un point est un palindrome. | ||
+ | // ind1 : c'est l'indice de parcours du texte par le début | ||
+ | // ind2 : c'est l'indice de parcours du texte par la fin | ||
+ | |||
+ | CONSTANTE | ||
+ | MAX : 80 | ||
+ | |||
+ | TYPE chaine = tableau[MAX] de caractères | ||
+ | |||
+ | VARIABLES | ||
+ | |||
+ | i : entier | ||
+ | j : entier | ||
+ | palindrome : booléen | ||
+ | |||
+ | TERM : '.' : caractère | ||
+ | |||
+ | |||
+ | début | ||
+ | i := chaine[1] | ||
+ | j := chaine[TERM - 1] | ||
+ | |||
+ | |||
+ | SI chaine[i] < chaine[j] ALORS | ||
+ | palindrome := VRAI | ||
+ | TQ (i < j) ET (chaine[i] = chaine[j]) | ||
+ | i := i + 1 | ||
+ | j := j - 1 | ||
+ | FinTQ | ||
+ | SINON | ||
+ | palindrome := FAUX | ||
+ | FINSI | ||
+ | |||
+ | fin | ||
+ | </code> | ||
+ | |||
+ | =====Trier un tableau par remontée des bulles ===== | ||
+ | |||
+ | |||
+ | ===1) Définition du problème=== | ||
+ | |||
+ | <code> | ||
+ | | | | ||
+ | liste chiffre---> | |----> liste de chiffre | ||
+ | (désordonnée) | | (ordonnée) | ||
+ | </code> | ||
+ | |||
+ | |||
+ | ===2) Jeu d'essai=== | ||
+ | <code> | ||
+ | Entrée sortie | ||
+ | ------------------------------------ | ||
+ | rien rien | ||
+ | 5 0 | ||
+ | 5293741 123479 | ||
+ | </code> | ||
+ | |||
+ | ===3) Définition des données du programme TriBulle=== | ||
<code> | <code> | ||
CONSTANTES | CONSTANTES | ||
- | taille =80 //nombre max de caractères de la chaine | + | constante MAX = 80 |
- | carterm = '.' // caractère terminateur | + | |
TYPES | TYPES | ||
- | chaîne =tableau[taille] de caractère | + | table =Tableau[MAX] de entiers |
VARIABLES | VARIABLES | ||
- | phrase :chaîne //phrase dont on va déterminer la symétrie | + | variable chiffresDesordo : table //Table d'entiers désordonnés |
- | i :entier //indice de parcours de la phrase par le début | + | variable chiffresOrdonnés: table // Table d'entiers ordonnés |
- | j :entier //indice de parcours de la phrase par la fin | + | variable nbrchiffre : entier // Nombres de chiffres |
+ | variable taille : entiers // Taille de la table de chiffres désordonnés en entrée | ||
+ | // et ordonnée en sortie | ||
+ | </code> | ||
+ | |||
+ | ===Programme de test de la procédure TriBulle=== | ||
+ | <code> | ||
+ | CONSTANTES | ||
+ | constante MAX = 80 | ||
+ | |||
+ | TYPES | ||
+ | table =Tableau[MAX] de entiers | ||
+ | |||
+ | VARIABLES | ||
+ | variable chiffresDesordo : table //Table d'entiers désordonnés | ||
+ | variable chiffresOrdonnés: table // Tables d'entiers ordonnés | ||
+ | variable nbrchiffre : entier // Nombres de chiffres | ||
+ | variable taille : entiers // Taille de la table de chiffres désordonnés en entrée | ||
+ | // et ordonnée en sortie | ||
+ | PROCEDURES | ||
+ | procédure remplir ( entrée taille_tableau_donné : entier | ||
+ | entrée/sortie ind : entier | ||
+ | entrée/sortie chiffre_donnés : entier | ||
+ | sortie liste_désordonnée : table | ||
+ | // La procédure remplir permet de récupérer les données saisies par l'utilisateur. | ||
+ | // chiffres_donnés : compteur de chiffres entrés | ||
+ | // taille_tableau_donné : c'est la taille choisie par l'utilisateur de la table. | ||
+ | // chiffre_donnés : c'est pour arrêter la saisie d'un nouvel élément | ||
+ | // quand il y a autant que chiffres_donnés. | ||
+ | // ind : c'est l'indice de parcours de la table. | ||
+ | // liste_désordonnée : c'est la table de chiffre toute remplie qui a été saisie. | ||
+ | |||
+ | procédure procédure tribulle( entrée taille : entier | ||
+ | entrée/sortie chiffresDesordo : table | ||
+ | entrée/sortie chiffreOrdonnés : table) | ||
+ | // La procédure du tri des bulles permet de ranger une chaîne de chiffres | ||
+ | // désordonnés en ordre croissant. | ||
+ | // chiffresDesordo : C'est la liste de chiffres désordonnés rentrée par | ||
+ | // l'utilisateur ainsi que la liste de chiffres triés en sortie. | ||
+ | // taille : C'est le nombre de chiffres rentrés par l'utilisateur. | ||
+ | // invert : C'est vrai quand il y a eu inversion. | ||
+ | |||
+ | procédure Procédure affichage_tableau_ordonné ( entrée table_Rangée : table | ||
+ | entrée taille_table : entier) | ||
+ | // La procédure permet l'affichage du tableau trié | ||
+ | // table_Rangée est la table de chiffres ordonnés. | ||
+ | // table est le type crée (un tableau) | ||
+ | // taille_table définie la taille de la table. | ||
+ | |||
+ | |||
+ | Début | ||
+ | saisie(chiffresDesordo, nbrchiffre, taille) // appel de la procédure saisie | ||
+ | triBulle(taille, chiffresDesordo) // appelle de la procédure triBulle | ||
+ | affichage(taille, chiffreOrdonnés) // appelle de la procédure affichage | ||
+ | |||
+ | Fin | ||
+ | </code> | ||
+ | |||
+ | ===5) Interface de la procédure TrieBulle=== | ||
+ | <code> | ||
+ | Procédure tribulle ( entrée taille : entier | ||
+ | entrée/sortie chiffresDesordo : table | ||
+ | entrée/sortie chiffreOrdonnés : table) | ||
+ | |||
+ | // La procédure du tri des bulles permet de ranger une chaîne de chiffres | ||
+ | //désordonnés en ordre croissant. | ||
+ | // chiffresDesordo : C'est la liste de chiffres désordonnés rentrée par | ||
+ | l'utilisateur ainsi que la liste de chiffres triés en sortie. | ||
+ | // taille : C'est le nombre de chiffres rentrés par l'utilisateur. | ||
+ | </code> | ||
+ | ===6) Algorithme de la procédure TrieBulle=== | ||
+ | |||
+ | <code> | ||
+ | procédure tribulle( entrée taille : entier | ||
+ | entrée/sortie chiffresDesordo : table | ||
+ | entrée/sortie chiffreOrdonnés : table) | ||
+ | // La procédure du tri des bulles permet de ranger une chaîne de chiffres | ||
+ | //désordonnés en ordre croissant. | ||
+ | // chiffresDesordo : C'est la liste de chiffres désordonnés rentrée par | ||
+ | l'utilisateur ainsi que la liste de chiffres triés en sortie. | ||
+ | // taille : C'est le nombre de chiffres rentrés par l'utilisateur. | ||
+ | |||
+ | VARIABLES | ||
+ | variable i : entier // indice de parcours du tableau. | ||
+ | variable cible : entier // variable permettant l'inversion de 2 entiers dans le tableau. | ||
+ | variable comptinversion : entier // Comptage des inversions | ||
+ | variable invert : booléen // Permet de déterminé s'il y a ou non inversion | ||
+ | |||
+ | Début | ||
+ | // parcours jusqu'à qu'il n'y est plus aucune inversion. | ||
+ | i := 1 | ||
+ | invert := FAUX | ||
+ | Répéter | ||
+ | Tantque ( i < taille ) faire | ||
+ | SI table[i] > table[ i + 1 ] ALORS // si l'entier de la case n°1 du tableau supérieur à | ||
+ | // celui de la case n°2 du même tableau alors | ||
+ | |||
+ | |||
+ | cible = table[1] // | ||
+ | table[1] = table[i + 1] // inversion | ||
+ | table[i+1] = cible // | ||
+ | invert := VRAI | ||
+ | |||
+ | Finsi | ||
+ | i := i + 1 // incrémentation pour passer aux entiers suivants. | ||
+ | Fintantque | ||
+ | Jusquà NON invert | ||
+ | |||
+ | Fin | ||
+ | </code> | ||
+ | |||
+ | ====6 bis) Interfaces et programmes des procédures utilisées par le programme principal==== | ||
+ | |||
+ | ===I] Procédure "remplir et afficher tableau désordonné"=== | ||
+ | <code> | ||
+ | //exo: tri par remontée des bulles | ||
+ | CONSTANTES | ||
+ | constante MAX = 80 // Taille maximal de la table de chiffres | ||
+ | |||
+ | Procédure remplir ( entrée taille_tableau_donné : entier | ||
+ | entrée/sortie ind : entier | ||
+ | entrée/sortie chiffre_donnés : entier | ||
+ | sortie liste_désordonnée : table | ||
+ | // La procédure remplir permet de récupérer les données saisies par l'utilisateur. | ||
+ | // chiffres_donnés : compteur de chiffres entrés | ||
+ | // taille_tableau_donné : c'est la taille choisie par l'utilisateur de la table. | ||
+ | // chiffre_donnés : c'est pour arrêter la saisie d'un nouvel élément | ||
+ | quand il y a autant que chiffres_donnés. | ||
+ | // ind : c'est l'indice de parcours de la table. | ||
+ | // liste_désordonnée : c'est la table de chiffre toute remplie qui a été saisie. | ||
+ | |||
+ | |||
+ | Type table = tableau[MAX] d'entiers | ||
+ | |||
+ | Variables | ||
+ | taille_finale : entier // nombre de tous les chiffres rentrés par l'utilisateur. | ||
+ | chiffre_donnés : entier // les chiffres rentrés par l'utilisateur pour mettre | ||
+ | //quelque chose dans le tableau | ||
+ | //(l'utilisateur ne rentre pas forcément 80 chiffres) | ||
+ | ind : entier // indice de parcours de table | ||
+ | liste_désordonnée : table | ||
+ | |||
+ | Début | ||
+ | |||
+ | // l'utilisateur rentre la taille de la table d'entier et ses valeurs. | ||
+ | |||
+ | Répéter | ||
+ | Ecrire ( 'Quel sera le nombre de nombres à trier?' ) // taille du tableau à trier | ||
+ | //( sup à 0 , | ||
+ | // non égal à 1, | ||
+ | // stric inf à 80) | ||
+ | Lire ( taille_finale ) | ||
+ | Jusquà ( taille_finale >= 0 ) et ( taille_finale < = MAX ) | ||
+ | |||
+ | Ecrire ('Saisissez le chiffre n°)', ind ) | ||
+ | |||
+ | // remplir le tableau | ||
+ | |||
+ | chiffre_donnés := 0 // initialisation l'utilisateur n'a pas encore donné ses chiffres à trier | ||
+ | ind =1 // initialisation de l'indice de parcours | ||
+ | |||
+ | Tantque (chiffre_donnés <= taille_finale) Faire | ||
+ | Ecrire ('Veuillez donner un entier') // on demande ensuite les entiers à l'utilisateur | ||
+ | // pour chaque case du tableau. | ||
+ | | ||
+ | Lire (liste_désordonnée[ind]) | ||
+ | chiffre_donnés := chiffre_donnés + 1 // Incrémentation pour mettre les autres | ||
+ | //entiers dans le tableau. | ||
+ | ind := ind + 1 | ||
+ | Fintantque | ||
+ | ecrire('Voici la liste des chiffres que vous avez entré',(liste_désordonnée[i]) | ||
+ | |||
+ | Fin | ||
+ | </code> | ||
+ | |||
+ | ===II] procédure "afficher tableau ordonné"=== | ||
+ | |||
+ | <code> | ||
+ | Procédure affichage_tableau_ordonné ( entrée table_Rangée : table | ||
+ | entrée taille_table : entier) | ||
+ | | ||
+ | |||
+ | // La procédure permet l'affichage du tableau trié | ||
+ | // table_Rangée est la table de chiffres ordonnés. | ||
+ | // table est le type crée (un tableau) | ||
+ | // taille_table définie la taille de la table. | ||
+ | |||
+ | Type listeChiffre | ||
+ | |||
+ | Variable taille_table : entier // compte le nombre de chiffres rentré par l'utilisateur. | ||
+ | |||
+ | |||
Début | Début | ||
+ | Ecrire ( "le tableau rangé est ",table_Rangée[taille_table]) | ||
+ | Fin | ||
+ | </code> | ||
+ | |||
+ | =====Recherche dichotomique ===== | ||
+ | VOIR les tris :[[http://axiomcafe.fr/tri-dans-un-tableau]] | ||
+ | <code> | ||
+ | |||
+ | // recherche dichotomique | ||
+ | |||
+ | GENERALITE | ||
+ | |||
+ | méthode de recherche par dichotomie : exemple | ||
+ | |||
+ | i | a | b | c | d | e | ...| j | ||
+ | |||
+ | i = début | ||
+ | j = fin | ||
+ | milieu = tab(i[1] + i[n]) / 2 | ||
| | ||
- | écrire('Donnez une phrase." | + | si cible > milieu alors |
- | lire(phrase) | + | cible est à chercher sur tab[milieu][j] |
- | + | ||
- | j := 1 | + | si cible < milieu alors |
- | + | cible est à chercher sur tab[i][j] | |
- | TantQue phrase[j] <> carterm FAIRE //arrêt sur terminateur | + | |
- | + | ///////////////////////// | |
- | j := j + 1 | + | |
- | + | 1) Analyse du problème : | |
- | FinTantQue | + | |
- | + | deux programmes : 1) crée la table de prénom | |
- | //Parcours par les deux bouts | + | 2) chercher un prenom dans la table |
- | j := j - 1 | + | |
- | i := 1 | + | |
- | + | ||
- | TantQue (i<j) ET (phrase[i] = phrase[j]) FAIRE | + | |
+ | entrée Faire_table sortie prénom cherché | ||
+ | --------------------------------------------------------------------------------------------------------- | ||
+ | | enregistre | | | ||
+ | les prénoms | et numérote |-> une table | résultat : prénom dans la table | ||
+ | | les prénoms | de prenoms numérotés | ou | ||
+ | | entrés | (max 10) | pas dans la table | ||
+ | ---------------------------------------------------------------------------------------------------------- | ||
+ | |||
+ | //////////////////////////////////////////////////////////////////// | ||
+ | PROGRAMME crée la table de prénom et enregister le prenom recherché | ||
+ | ///////////////////////////////////////////////////////////////////// | ||
+ | On sait que la taille de la table de prénom est égale au nombre de prénoms entrés | ||
+ | |||
+ | CONSTANTES | ||
+ | |||
+ | nombre_de_prenom = 10 // taille max de la table | ||
+ | taille_prenom = 15 // taille max d'un prenom | ||
+ | |||
+ | TYPE | ||
+ | |||
+ | prenom =tableau[nombre_de_prenom] de caractère | ||
+ | table =tableau[nombre_de_prenom] de prenom | ||
+ | |||
+ | VARIABLES | ||
+ | |||
+ | i : entier // compteur de prénoms entrée | ||
+ | nombre_de_prenom : entier // Nombre de prenoms entrés par l'utilisateur | ||
+ | table_prenom : table de prenom | ||
+ | |||
+ | prenom : prenom // prénom cherché | ||
+ | resultat : entier | ||
+ | |||
+ | |||
+ | début | ||
+ | |||
+ | i := 0 // Pas encore de prénom entrés | ||
+ | |||
+ | écrire("combien de prenom ?") | ||
+ | lire(nombre_de_prenom) | ||
+ | |||
+ | TANTQUE ( i < nombre_de_prenom ) FAIRE | ||
+ | |||
+ | i := i + 1 | ||
+ | écrire(Entrez un prénom, svp.) | ||
+ | lire( table_prenom[i] ) | ||
+ | |||
+ | FINTANTQUE | ||
+ | |||
+ | // enregistrer le prénom à chercher | ||
+ | |||
+ | ecrire(Pour quel nom voulez-vous l'indice ?) | ||
+ | lire(prenom) | ||
+ | |||
+ | //appel procédure cherche_prenom | ||
+ | chercher_prenom(table , nombre_de_prenom, prenom , resultat) | ||
+ | |||
+ | SI resultat = 0 ALORS | ||
+ | écrire ("Le prénom n'est pas dans la liste") | ||
+ | SINON | ||
+ | écrire ("Le prénom est dans la table au n° ", resultat) | ||
+ | fin | ||
+ | |||
+ | ////////////////////////////////////////////////////////////////////// | ||
+ | Programme chercher le prénom | ||
+ | ///////////////////////////////////////////////////////////////////// | ||
+ | |||
+ | |||
+ | VARIABLES | ||
+ | |||
+ | indice_début : entier // Début de table de prénom | ||
+ | indice_fin : entier // fin de la table de prénom | ||
+ | indice_moyen : entier // milieu de la table de prénom | ||
+ | |||
+ | |||
+ | TYPE | ||
+ | |||
+ | prenom =tableau[nombre_de_prenom] de caractère | ||
+ | table =tableau[nombre_de_prenom] de prenom | ||
+ | |||
+ | |||
+ | procédure chercher_prenom(entrée tableEnregistrée :table | ||
+ | entrée taille :entier | ||
+ | entrée prenom_cherché :prenom | ||
+ | sortie indice : entier) | ||
+ | // taille c'est place du prénom par rapport à la taille totale de la table de prénom | ||
+ | // cible c'est le n° du prenom dans la table de prénom | ||
+ | |||
+ | début | ||
+ | indice_début := 1 | ||
+ | indice_fin := taille | ||
+ | cible := (indice_début + indice_fin) DIV 2 | ||
+ | |||
+ | |||
+ | TANTQUE (indice_début < indice_fin) ET (table [cible] <> prenom_cherché) FAIRE | ||
+ | |||
+ | SI tableEnregistrée[cible] > prenom_cherché ALORS | ||
| | ||
- | j := i + 1 | + | indice_fin = cible - 1 //du milieu à la fin de la table de prénom |
- | i := j - 1 | + | |
- | FinTantQue | + | SINON |
- | + | indice_début := cible + 1 //du début jusqu'au milieu de la table de prénom | |
- | //Affichage du résultat | + | |
- | + | FINSI | |
- | SI i >= j ALORS // Fin du parcours | + | |
- | écrire("C'est un palindrome") | + | cible := (indice_début + indice_fin) DIV 2 |
- | SINON | + | |
- | ecrire("Ce n'est pas un palindrome") | + | FINTANTQUE |
- | FinSI | + | |
- | + | ||
- | Fin | + | SI (indice_début > indice_fin ) OU ( table [cible] <> prenom_cherché) ALORS |
+ | |||
+ | cible := 0 | ||
+ | |||
+ | FINSI | ||
+ | |||
+ | fin | ||
</code> | </code> | ||
+ | =====Rechercher un mot dans une phrase===== | ||
+ | |||
+ | ====1) schéma du problème==== | ||
+ | <code> | ||
+ | SCHEMA : | ||
+ | phrase -----------------------------> | | | ||
+ | | | | ||
+ | mot à chercher----------------------> | | ---> mot dans phrase oui ou non | ||
+ | | | | ||
+ | Longueur du mot à chercher----------> | | | ||
+ | |||
+ | </code> | ||
+ | |||
+ | ====Jeu d'essai ==== | ||
+ | <code> | ||
+ | phrase Mot_cherché longueur_Mot_Cherché Trouvé | ||
+ | . coucou 6 VRAI | ||
+ | . ' ' 0 VRAI | ||
+ | coucou le chat le 2 VRAI | ||
+ | |||
+ | coucou le chat couii 5 FAUX | ||
+ | |||
+ | le chat 4 FAUX | ||
+ | |||
+ | </code> | ||
+ | |||
+ | ====PROCEDURE TROUVER UN MOT==== | ||
+ | ===1) Algorithme de principe === | ||
+ | <code> | ||
+ | DEBUT | ||
+ | Avoir une phrase | ||
+ | Avoir un mot à chercher | ||
+ | Avoir la longueur de ce mot cherché | ||
+ | REPETER | ||
+ | PRENDRE un mot dans la phrase | ||
+ | SI mot de la phrase = mot cherché ALORS | ||
+ | comparer les deux mots | ||
+ | FinSi | ||
+ | JUSQU'A avoir trouvé le mot cherché OU avoir parcouru toute la phrase | ||
+ | FIN | ||
+ | </code> | ||
+ | |||
+ | ===2)PROGRAMME DE TEST=== | ||
+ | |||
+ | <code> | ||
+ | CONSTANTES | ||
+ | |||
+ | TERM = '.' | ||
+ | ESPACE = ' ' | ||
+ | |||
+ | MaxPhrase = 80 | ||
+ | MaxMot = 15 | ||
+ | |||
+ | |||
+ | TYPES | ||
+ | |||
+ | phrase_tableau =Tableau [MaxPhrase] de caractères | ||
+ | mot_tableau =Tableau [MaxMot] de caractères | ||
+ | |||
+ | VARIABLES | ||
+ | |||
+ | phraseSaisie : phrase_tableau | ||
+ | motSaisi : mot_tableau | ||
+ | lgMotCherché : entier | ||
+ | MotTrouvé : booléen | ||
+ | |||
+ | |||
+ | PROCEDURES | ||
+ | |||
+ | TrouverMot(entrée phrase : phrase_tableau | ||
+ | entrée mot : mot_tableau | ||
+ | entrée lgMotCherché : entier | ||
+ | sortie Trouvé : booléen | ||
+ | |||
+ | Début | ||
+ | |||
+ | ECRIRE ('Donnez une phrase de moins de', MaxPhrase, 'caractères et un mot | ||
+ | de', MaxMot, 'n'oubliez pas le point.') | ||
+ | LIRE(phraseSaisie) | ||
+ | ECRIRE('Donnez un mot à cherché de moins de', MaxMot) | ||
+ | LIRE(motSaisi ) | ||
+ | ECRIRE('Donner la longueur du mot à cherché.') | ||
+ | LIRE(lgMotCherché) | ||
+ | |||
+ | SI MotTrouvé := TrouverMot(phraseSaisie, MotSaisi, lgMotCherché, trouvé) | ||
+ | ALORS | ||
+ | ECRIRE('Le mot, motSaisi 'est dans dans la phrase.') | ||
+ | SINON | ||
+ | ECRIRE('Le mot, motSaisi 'n'est pas dans dans la phrase.') | ||
+ | FINSI | ||
+ | Fin | ||
+ | </code> | ||
+ | |||
+ | === 3)PROCEDURES TROUVER UN MOT=== | ||
+ | <code> | ||
+ | rouverMot( entrée phrase : phrase_tableau | ||
+ | entrée mot : mot_tableau | ||
+ | entrée longueur : entier | ||
+ | sortie trouvé : booléen ) | ||
+ | |||
+ | VARIABLES : | ||
+ | position : entier // Indice de parcours de la phrase | ||
+ | longueur : entier // Longueur du mot analysé dans la phrase | ||
+ | trouvé1 : booléen // Vrai si la mot est trouvé | ||
+ | |||
+ | PROCEDURES | ||
+ | prendreMot( Entrée phrase : phrase_tableau | ||
+ | Entrée mot : mot_tableau | ||
+ | Entrée/Sortie indice : entier | ||
+ | Sortie longueurMot : entier | ||
+ | Sortie trouvé1 : booléen ) | ||
+ | // Cette procédure regarde s'il y a un mot suivant à partir de la position de l'indice i placé | ||
+ | // après le dernier mot analysé dans la phrase où l'on cherche un mot. | ||
+ | // Phrase : c'est la phrase dans laquelle on cherche un mot | ||
+ | // mot : c'est le mot qu'on cherche à trouver dans la phrase | ||
+ | // indice : c'est l'indice de parcours de la phrase à partir duquel on commence la recherche | ||
+ | // longueurMot : c'est la longueur du mot trouvé est que l'indice qui le traverse va permettre d'en | ||
+ | // la taille. | ||
+ | //// Le programme est page suivante. | ||
+ | |||
+ | comparerMot( Entrée phrase : phrase_tableau | ||
+ | Entrée position : entier | ||
+ | Entrée longueurMot : entier | ||
+ | Entrée mot : mot_tableau | ||
+ | Sortie trouvé2 : booléen ) | ||
+ | // Cette procédure vérifie que le mot trouvé dans la phrase est de taille égale au mot cherché. | ||
+ | // Phrase : c'est la phrase dans laquelle on cherche un mot. | ||
+ | // longueurMot : c'est la longueur unique pour les deux mots. | ||
+ | // mot : c'est le mot cherché | ||
+ | // trouvé2 : c'est le résultat de la comparaison entre les deux mots. | ||
+ | //// Le programme est page suivante. | ||
+ | |||
+ | Début | ||
+ | position := 0 | ||
+ | longueur:= 0 | ||
+ | trouvéA : = prendreMot(phrase, position, longueur) | ||
+ | TantQ trouvéA:= VRAI | ||
+ | SI longueur = longueurMot ALORS | ||
+ | trouvéB:= comparerMot( phrase, position, longueurMot, mot) | ||
+ | FINSI | ||
+ | FIN | ||
+ | </code> | ||
+ | |||
+ | ===PROCEDURES prendreMot=== | ||
+ | |||
+ | <code> | ||
+ | prendreMot( Entrée phrase : phrase_tableau | ||
+ | Entrée mot : mot_tableau | ||
+ | Entrée/Sortie indice : entier | ||
+ | Sortie longueurMot : entier | ||
+ | Sortie trouvé1 : booléen ) | ||
+ | // Cette procédure regarde s'il y a un mot suivant à partir de la position de l'indice i placé | ||
+ | // après le dernier mot analysé dans la phrase où l'on cherche un mot. | ||
+ | // Phrase : c'est la phrase dans laquelle on cherche un mot | ||
+ | // mot : c'est le mot qu'on cherche à trouver dans la phrase | ||
+ | // indice : c'est l'indice de parcours de la phrase à partir duquel on commence la recherche | ||
+ | // longueurMot : c'est la longueur du mot trouvé est que l'indice qui le traverse va permettre d'en | ||
+ | // la taille. | ||
+ | |||
+ | PROGRAMME prendreMot | ||
+ | |||
+ | Début | ||
+ | TQ texte[indice] = espace FAIRE | ||
+ | indice := indice + 1 | ||
+ | FinTQ | ||
+ | lg := 0 | ||
+ | Si (texte[indice] <> espace) ET (texte[indice] <> TERM) ALORS | ||
+ | indice := indice + 1 | ||
+ | lg := lg + 1 | ||
+ | trouvé2:= VRAI | ||
+ | Sinon | ||
+ | trouvé2:= FAUX | ||
+ | FinTQ | ||
+ | Fin | ||
+ | </code> | ||
+ | |||
+ | === comparerMot=== | ||
+ | <code> | ||
+ | comparerMot( Entrée phrase : phrase_tableau | ||
+ | Entrée position : entier | ||
+ | Entrée longueurMot : entier | ||
+ | Entrée mot : mot_tableau | ||
+ | Sortie trouvé2 : booléen ) | ||
+ | // Cette procédure vérifie que le mot trouvé dans la phrase est de taille égale au mot cherché. | ||
+ | // Phrase : c'est la phrase dans laquelle on cherche un mot. | ||
+ | // longueurMot : c'est la longueur unique pour les deux mots. | ||
+ | // mot : c'est le mot cherché | ||
+ | // trouvé2 : c'est le résultat de la comparaison entre les deux mots. | ||
+ | //// Le programme est page suivante. | ||
+ | VARIABLES | ||
+ | |||
+ | |||
+ | k : entier // début du mot repéré | ||
+ | i : entier // début du mot cherché | ||
+ | reponse : booléen // Vrai si tout le mot cherché est identique | ||
+ | |||
+ | |||
+ | Début | ||
+ | |||
+ | TQ ( k <= long ) ET (phrase[i] = mot[k] FAIRE | ||
+ | k := k + 1 | ||
+ | i := i + 1 | ||
+ | FinTQ | ||
+ | |||
+ | SI ( k > long ) ALORS // cette condition peut s'écrire | ||
+ | reponse := VRAI // reponse := (k>long) | ||
+ | reponse := FAUX | ||
+ | FinSi | ||
+ | |||
+ | |||
+ | Fin | ||
+ | </code> |