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
Prochaine révision Les deux révisions suivantes
utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [06/12/2014 11:15]
Hypathie [Exo 3 : procédure rechercher un palindrome]
utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [06/12/2014 13:23]
Hypathie [Trier un tableau par remontée des bulles]
Ligne 390: Ligne 390:
 </​code>​ </​code>​
  
 +=====Trier un tableau par remontée des bulles =====
 +
 +
 +===1) Définition du problème===
 +
 +<​code>​
 +                                   ​| ​   |
 +  liste désordonnée de chiffre--->​ |    |----> liste ordonnés par ordre croissant
 +                                   ​| ​   |
 +</​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>​
 +CONSTANTES
 +constante MAX = 80
 +
 +TYPES
 +table =Tableau[MAX] de entiers
 +
 +VARIABLES
 +variable chiffresDesordo : table    //Table d'​entiers désordonné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
 +
 +</​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 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 saisie
 +procédure triBulle
 +procédure affichage
 +
 +
 +Début
 +  saisie(chiffresDesordo,​ nbrchiffre, taille) // appel de la procédure saisie
 +  triBulle(chiffresDesordo,​ taille) ​          // appelle de la procédure triBulle
 +  affichage(chiffreOrdonnés,​ taille) ​         // 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** est la liste de chiffres désordonnés rentrée par 
 +   ​l'​utilisateur ainsi que la liste de chiffres triés en sortie.
 +// **taille** est le nombre de chiffres rentrés par l'​utilisateur.
 +// **invert** est vrai quand il y a eu inversion
 +
 +</​code>​
 +===6) Algorithme de la procédure TrieBulle===
 +
 +<​code>​
 +variable
 +i       : entier ​  // indice de parcours du tableau. ​   ​
 +cible   : entier ​ // variable permettant l'​inversion de 2 entiers dans le tableau.
 +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 "1 " du tableau ​
 +                                                           //est supérieur à l'​entier "​2" ​
 +                                                           // suivant dans le tableau alors.
 +
 + cible = table[1]
 + table[1] = table[i + 1]                 
 + table[i+1] = cible
 + invert := VRAI
 +
 + Finsi
 +      i := i + 1  // incrémentation pour passer aux entiers suivants.
 +      Fintantque
 +    Jusquà ​ invert = faux
 +
 + Fin
 +</​code>​
 +
 +===6 bis) Interfaces et programmes des procédures utilisées par le programme principal=== ​
 +<​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_table : 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.
 +  //​listechiffre 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
 +</​code>​
  
 =====Recherche dichotomique ===== =====Recherche dichotomique =====
utilisateurs/hypathie/tutos/algo-exo-constructions-d-algorithmes-de-procedure.txt · Dernière modification: 06/12/2014 17:08 par Hypathie

Pied de page des forums

Propulsé par FluxBB