L'icône rouge permet de télécharger chaque page du wiki visitée au format PDF et la grise au format ODT →

Différences

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

--- utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure [30/11/2014 23:15]
Hypathie [recherche dichotomique]
+++ 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 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é}}
   * Commentaires : //Contexte d'utilisation du sujet du tuto. //
@@ Ligne 298: / Ligne 298: @@
 </code>
 ====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 ====
+<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====
+<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 désordonnée de chiffre---> |    |----> liste ordonnés par ordre croissant
+                                   |    |
+</code>
+===2) Jeu d'essai===
+<code>
+Entrée                       sortie
+------------------------------------
+rien                         rien
+                             0
+5293741                       123479
+</code>
+===3) Définition des données du programme TriBulle===
 <code>
 CONSTANTES
-taille =80 //nombre max de caractères  de la chaine
+constante MAX = 80
-carterm = '.' // caractère terminateur
 TYPES
-chaîne =tableau[taille] de caractère
+table =Tableau[MAX] de entiers
 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 nbrchiffre      : entier   // Nombres de chiffres
-j      :entier //indice de parcours de la phrase par la fin
+variable taille          : entiers  // Taille de la table de chiffres désordonnés en entrée
+                                    // et ordonnée en sortie
-  Début
-    écrire('Donnez une phrase."
-    lire(phrase)
-    j := 1
-    TantQue  phrase[j] <> carterm FAIRE
-          j := j + 1   //arrêt car on est sur terminateur
-    FinTantQue
-    //Parcours par les deux bouts
-    j := j - 1
-    i := 1
-    TantQue (i<j) ET (phrase[i] = phrase[j]) FAIRE
-        j := i + 1
-        i := j - 1
-    FinTantQue
-    //Affichage du résultat
-    SI i >= j ALORS // Fin du parcours
-       écrire("C'est un palindrome")
-    SINON
-       ecrire("Ce n'est pas un palindrome")
-    FinSI
-  Fin
 </code>
-Autre solution :
+===Programme de test de la procédure TriBulle===
 <code>
 CONSTANTES
-carterm ='.'
+constante MAX = 80
 TYPES
-phrase =tableau[i,j] de caractères
+table =Tableau[MAX] de entiers
 VARIABLES
-i : entier // indice de début du tableau
+variable chiffresDesordo : table    //Table d'entiers désordonnés
-j : entier //indice de fin
+variable nbrchiffre      : entier   // Nombres de chiffres
-resultat : booléen // VRAI si symétrie
+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.
-    //initialisation
+    i := 1
-    i := phrase[1]
+    invert := FAUX
-    j := phrase[carterm - 1]
+    Répéter
+      Tantque ( i < taille ) faire
-    SI (carterm) ALORS
+	 SI table[i] > table[ i + 1 ] ALORS // si l'entier "1 " du tableau
-        lire(phrase[i,j])
+                                                           //est supérieur à l'entier "2"
+                                                           // suivant dans le tableau alors.
-        SI (phrase[i] = phrase[j]) ALORS
+		cible = table[1]
-           resultat = VRAI
+		table[1] = table[i + 1]
+		table[i+1] = cible
-           i := i + 1  // Parcours dans les deux sens
+		invert := VRAI
-           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
-    FINSI
+	 Finsi
+      i := i + 1  // incrémentation pour passer aux entiers suivants.
- fin
+      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 =====

utilisateurs/hypathie/tutos/algo-exo-constructions-d-algorithmes-de-procedure.txt · Dernière modification: 06/12/2014 17:08 par Hypathie

Debian-facile

Différences

Pied de page des forums