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 [06/12/2014 07:03]
Hypathie [Algo_méthodologie : élaboration d'une procédure]
+++ 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 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>
-CONSTANTES
+procédure cherchePalinPoint(entrée         texte : chaine,
-taille =80 //nombre max de caractères  de la chaine
+                            entrée sortie  ind1  : entier, ind2 : entier
-carterm = '.' // caractère terminateur
+                            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
-chaîne =tableau[taille] de caractère
+MAX : 80
+TYPE chaine = tableau[MAX] de caractères
 VARIABLES
-phrase :chaîne //phrase dont on va déterminer la symétrie
-i      :entier //indice de parcours de la phrase par le début
-j      :entier //indice de parcours de la phrase par la fin
-  Début
+i    : entier
+j    : entier
-    écrire('Donnez une phrase."
+palindrome : booléen
-    lire(phrase)
+TERM : '.' : caractère
-    j := 1
-    TantQue  phrase[j] <> carterm FAIRE
+ début
+  i := chaine[1]
-          j := j + 1   //arrêt car on est sur terminateur
+  j := chaine[TERM - 1]
-    FinTantQue
+    SI chaine[i] < chaine[j] ALORS
-    //Parcours par les deux bouts
+    palindrome := VRAI
-    j := j - 1
+      TQ (i < j) ET (chaine[i] = chaine[j])
-    i := 1
+	 i := i + 1
+	 j := j - 1
-    TantQue (i<j) ET (phrase[i] = phrase[j]) FAIRE
+      FinTQ
+    SINON
-        j := i + 1
+         palindrome := FAUX
-        i := j - 1
+    FINSI
-    FinTantQue
+ fin
-    //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 :
+=====Trier un tableau par remontée des bulles =====
 <code>
-CONSTANTES
+//exo: tri par remontée des bulles
-carterm ='.'
-TYPES
+I] Procédure "remplir"
-phrase =tableau[i,j] de caractères
-VARIABLES
+Procédure remplir ( sortie tab_désordonné : les_chiffres_donnés,
-i : entier // indice de début du tableau
+                    sortie tableau_donné : entier )
-j : entier //indice de fin
-resultat : booléen // VRAI si symétrie
+// 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
-    //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
-    FINSI
+     // parcours jusqu'à qu'il n'y est plus aucune inversion.
+    i := 1
+    invert := FAUX
- fin
+    Répéter
-</code>
+	  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]]

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