logo Debian Debian Debian-France Debian-Facile Debian-fr.org Forum-Debian.fr Debian ? Communautés logo inclusivité

Debian-facile

Bienvenue sur Debian-Facile, site d'aide pour les nouveaux utilisateurs de Debian.

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 → ODT PDF Export

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

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 [06/12/2014 16:44]
Hypathie [Trier un tableau par remontée des bulles]
utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [06/12/2014 17:08] (Version actuelle)
Hypathie [Recherche dichotomique]
Ligne 452: Ligne 452:
     // taille_tableau_donné : c'​est ​ la taille choisie par l'​utilisateur de la table.     // 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 ​     // chiffre_donnés ​      : c'est pour arrêter la saisie d'un nouvel élément ​
-                          ​quand il y a autant que chiffres_donnés.+    //                          ​quand il y a autant que chiffres_donnés.
     // ind : c'est l'​indice de parcours de la table.     // 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.     // liste_désordonnée ​  : c'est la table de chiffre toute remplie qui a été saisie.
Ligne 459: Ligne 459:
                     entrée/​sortie ​ chiffresDesordo : table                     entrée/​sortie ​ chiffresDesordo : table
                     entrée/​sortie ​ chiffreOrdonnés : table)                     entrée/​sortie ​ chiffreOrdonnés : table)
-    // la procédure du tri des bulles permet de ranger une chaîne de chiffres  +    // La procédure du tri des bulles permet de ranger une chaîne de chiffres  
-    //​désordonnés en ordre croissant. +    //      désordonnés en ordre croissant. 
-    // chiffresDesordo : est la liste de chiffres désordonnés rentrée par  +    // 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. +    // ​                    l'​utilisateur ainsi que la liste de chiffres triés en sortie. 
-    // taille : est le nombre de chiffres rentrés par l'​utilisateur. +    // taille : C'est le nombre de chiffres rentrés par l'​utilisateur. 
-    // invert :  est vrai quand il y a eu inversion+    // invert :  ​C'est vrai quand il y a eu inversion.
  
 procédure Procédure affichage_tableau_ordonné ( entrée table_Rangée : table procédure Procédure affichage_tableau_ordonné ( entrée table_Rangée : table
Ligne 769: Ligne 769:
  
  fin  fin
 +</​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>​ </​code>​
utilisateurs/hypathie/tutos/algo-exo-constructions-d-algorithmes-de-procedure.1417880674.txt.gz · Dernière modification: 06/12/2014 16:44 par Hypathie

Pied de page des forums

Propulsé par FluxBB