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 Prochaine révision Les deux révisions suivantes | ||
utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [30/11/2014 17:16] Hypathie [Exo 3 : procédure rechercher un palindrome] |
utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [06/12/2014 12:12] Hypathie [Trier un tableau par remontée des bulles] |
||
---|---|---|---|
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 ==== | ||
- | |||
- | ====6)Algorithme de la procédure Palindrome terminé par un point==== | ||
- | |||
<code> | <code> | ||
- | CONSTANTES | + | CONSTANTES |
- | taille =80 //nombre max de caractères de la chaine | + | 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. |
- | carterm = '.' // caractère terminateur | + | constante FIN ='.' // caractère terminaleur de la chaîne (Un tableau peut ne pas être tout rempli) |
- | TYPES | + | TYPES |
- | chaîne =tableau[taille] de caractère | + | Type chaine =tableau[MAX] de caractères // type crée pour contenir une liste |
- | VARIABLES | + | VARIABLES |
- | phrase :chaîne //phrase dont on va déterminer la symétrie | + | variable possPalin : chaine // phrase où une symétrie est recherchée |
- | i :entier //indice de parcours de la phrase par le début | + | variable indiceDeb : entier // |
- | j :entier //indice de parcours de la phrase par la fin | + | variable indiceFin : entier // indice de parcours de la phrase depuis la fin. |
- | Début | + | PROCEDURES |
- | + | procédure cherchePalinPoint(entrée texte : chaine, | |
- | écrire('Donnez une phrase." | + | entrée sortie ind1 : entier, ind2 : entier |
- | lire(phrase) | + | sortie result : booléen) |
- | + | // Cette procédure permet de dire si une chaine de caractère terminée par un point est un palindrome. | |
- | j := 1 | + | // 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 | |
- | TantQue phrase[j] <> carterm FAIRE | + | |
- | + | Début | |
- | j := j + 1 //arrêt car on est sur terminateur | + | // Saisie de la phrase : |
- | + | ECRIRE ('Entrez votre phrase et n'oubliez pas de la terminer par un point.' | |
- | FinTantQue | + | LIRE(phrase) |
- | + | indiceDeb := possPalin[1] | |
- | //Parcours par les deux bouts | + | indiceFin := possPalin[MAX-1] |
- | j := j - 1 | + | result := booléen |
- | i := 1 | + | |
- | + | // Recherche d'un palindrome fini par un point : | |
- | TantQue (i<j) ET (phrase[i] = phrase[j]) FAIRE | + | cherchePalinPoint(entrée possPalin:chaine , entrée/sortie ind1:entier, entrée/sortie ind2:entier, sortie result:bool) |
- | + | SI result = VRAI | |
- | j := i + 1 | + | ECRIRE('La phrase', possPalin 'est un palindrome.') |
- | i := j - 1 | + | |
- | FinTantQue | + | |
- | + | ||
- | //Affichage du résultat | + | |
- | + | ||
- | SI i >= j ALORS // Fin du parcours | + | |
- | écrire("C'est un palindrome") | + | |
SINON | SINON | ||
- | ecrire("Ce n'est pas un palindrome") | + | ECRIRE('La phrase', possPalin 'n'est pas un palindrome.') |
- | FinSI | + | FINSI |
- | + | Fin | |
- | Fin | + | |
</code> | </code> | ||
- | Autre solution : | + | |
+ | ====6)Algorithme de la procédure Palindrome terminé par un point==== | ||
<code> | <code> | ||
- | CONSTANTES | + | procédure cherchePalinPoint(entrée texte : chaine, |
- | carterm ='.' | + | 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 | ||
- | TYPES | + | CONSTANTE |
- | phrase =tableau[i,j] de caractères | + | MAX : 80 |
+ | |||
+ | TYPE chaine = tableau[MAX] de caractères | ||
VARIABLES | VARIABLES | ||
- | i : entier // indice de début du tableau | ||
- | j : entier //indice de fin | ||
- | resultat : booléen // VRAI si symétrie | ||
+ | i : entier | ||
+ | j : entier | ||
+ | palindrome : booléen | ||
+ | |||
+ | TERM : '.' : caractère | ||
+ | |||
+ | |||
+ | début | ||
+ | i := chaine[1] | ||
+ | j := chaine[TERM - 1] | ||
- | Début | ||
- | | ||
- | //initialisation | ||
- | i := phrase[1] | ||
- | j := phrase[carterm - 1] | ||
- | | ||
- | SI (carterm) ALORS | ||
- | lire(phrase[i,j]) | ||
- | | ||
- | SI (phrase[i] = phrase[j]) ALORS | ||
- | | ||
- | resultat = VRAI | ||
- | |||
- | i := i + 1 // Parcours dans les deux sens | ||
- | j := j - 1 | ||
- | | ||
- | TQ (i < j) ET (resultat = VRAI) FAIRE | ||
- | écrire("C'est un palindrome") | ||
- | FINTQ | ||
- | |||
- | SINON | ||
- | resultat = FAUX | ||
- | écrire("Ce n'est pas un palindrome") | ||
- | FINSI | ||
+ | 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 | FINSI | ||
- | | + | |
fin | fin | ||
</code> | </code> | ||
+ | =====Trier un tableau par remontée des bulles ===== | ||
- | =====recherche dichotomique ===== | + | <code> |
+ | //exo: tri par remontée des bulles | ||
+ | I] Procédure "remplir" | ||
+ | |||
+ | Procédure remplir ( sortie tab_désordonné : les_chiffres_donnés, | ||
+ | sortie tableau_donné : entier ) | ||
+ | |||
+ | // La procédure remplir permet de récupérer les données saisies par l'utilisateur. | ||
+ | // les_chiffres_donnés : c'est la table de chiffres rentrés par l'utilisateur. | ||
+ | // taille_tableau_donné : c'est la taille de la table. | ||
+ | |||
+ | |||
+ | 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 la tableau | ||
+ | //(l'utilisateur ne rentre pas forcément 80 chiffres) | ||
+ | |||
+ | 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 ( "Vous allez entrer", taille_finale, "chiffres" ) | ||
+ | |||
+ | // remplir le tableau | ||
+ | |||
+ | chiffre_donnés := 1 // initialisation l'utilisateur n'a pas encore donné ses chiffres à trier | ||
+ | |||
+ | Tantque ( chiffre_donnés <= taille_finale ) Faire | ||
+ | Ecrire ( 'Veuillez donner un autre entier" ) // on demande ensuite les entiers à l'utilisateur | ||
+ | // pour chaque case du tableau. | ||
+ | Lire ( taille_finale [ chiffre_donnés ] ) | ||
+ | chiffre_donnés := chiffre_donnés + 1 // Incrémentation pour mettre les autres | ||
+ | //entiers dans le tableau. | ||
+ | Fintantque | ||
+ | |||
+ | Fin | ||
+ | |||
+ | /////////////////////////////////////////////////////////////////////// | ||
+ | |||
+ | II] procédure "afficher" | ||
+ | |||
+ | Procédure affichage ( entrée table_utilisateur : listechiffre, entrée taille_tableaffichage : entier ) | ||
+ | |||
+ | // La procédure permet l'affichage du tableau de chiffre de l'utilisateur et le tableau trié | ||
+ | // table_utilisateur est la table de chiffre rentré par l'utilisateur. | ||
+ | //liste_chiffre est le type crée (un tableau) | ||
+ | // taille_table définie la taille de la table. | ||
+ | |||
+ | |||
+ | |||
+ | Variables | ||
+ | nombre_chiffre_affichage : entier // compte le nombre de chiffres rentré par l'utilisateur. | ||
+ | |||
+ | |||
+ | Début | ||
+ | nombre_chiffre_affichage := 1 | ||
+ | |||
+ | Tantque ( nombre_chiffre_affichage <= taille_tableaffichage ) Faire | ||
+ | Ecrire ( ",liste_chiffre, [",nombre_chiffre_affichage," ] = ",taille_table [nombre_chiffre_affichage] ) | ||
+ | nombre_chiffre_affichage := nombre_chiffre_affichage + 1 | ||
+ | Fintantque | ||
+ | |||
+ | Fin | ||
+ | |||
+ | // III] procédure tribulle | ||
+ | |||
+ | Procédure tribulle ( entrée/sortie tablechiffre :liste_chiffres, | ||
+ | entrée tailletablebulle : entier ) | ||
+ | // **la procédure du tri des bulles** permet de ranger une chaîne de chiffres | ||
+ | //désordonnés en ordre croissant. | ||
+ | // **tablechiffre** est la liste de chiffres désordonnés rentrée par | ||
+ | l'utilisateur ainsi que la liste de chiffres triés en sortie. | ||
+ | // **tailletable** est le nombre de chiffres rentrés par l'utilisateur. | ||
+ | |||
+ | Variables | ||
+ | |||
+ | i : entier // indice de parcours du tableau. | ||
+ | cible : entier // variable permettant l'inversion de 2 entiers dans le tableau. | ||
+ | invert : booléen | ||
+ | Début | ||
+ | |||
+ | // parcours jusqu'à qu'il n'y est plus aucune inversion. | ||
+ | |||
+ | |||
+ | i := 1 | ||
+ | invert := FAUX | ||
+ | | ||
+ | Répéter | ||
+ | |||
+ | Tantque ( i < tailletablebulle ) faire | ||
+ | |||
+ | Si tablechiffre [i] > tablechiffre [ i + 1 ] alors // si l'entier "1 " du tableau | ||
+ | //est supérieur à l'entier "2" | ||
+ | // suivant dans le tableau alors. | ||
+ | |||
+ | cible = tablechiffre[1] | ||
+ | tablechiffre[1] = tablechiffre[i + 1] | ||
+ | tablechiffre[i+1] = cible | ||
+ | invert := VRAI | ||
+ | |||
+ | Finsi | ||
+ | |||
+ | i := i + 1 // incrémentation pour passer aux entiers suivants. | ||
+ | Fintantque | ||
+ | |||
+ | Jusquà invert = faux | ||
+ | |||
+ | Fin | ||
+ | </code> | ||
+ | =====Recherche dichotomique ===== | ||
+ | VOIR les tris :[[http://axiomcafe.fr/tri-dans-un-tableau]] | ||
<code> | <code> | ||