Sous Programmes Usuels

En Algorithme En Pascal
Saisir un entier N tel que 5 ≤ N ≤ 500
0) DEF PROC Saisie (VAR N : Entier) Procedure Saisie (Var n : integer) ;
1) Répéter Begin
Ecrire ("Donner un entier "), Lire(N) Repeat
Jusqu’à (5 ≤ N) ET (N ≤ 500) Write (‘Donner un entier ’);
2) Fin Saisie Readln (n);
Until (5 <= N) AND (N <= 500) ;
End ;

Saisir une chaîne de caractère en majuscule

0) DEF PROC Saisie (VAR ch : Chaîne) Procedure Saisie (Var ch : String) ;
1) Répéter Var i : integer;
Ecrire ("Saisir une chaîne "), Lire(CH) Begin
i1 Repeat
Tant que (ch[i] dans ["A".."Z"]) et Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
(i ≤ long(ch)) Faire ii+1 i:=1;
Jusqu’à i > long(ch) While (ch[i] in ['A'..'Z']) and (i<=length(ch)) do
2) Fin Saisie i:=i+1;
Until i > length(ch);
End ;
Saisir une chaîne de caractères distincts
0) DEF PROC Saisie (VAR ch : Chaîne) Procedure Saisie (Var ch : String) ;
1) Répéter Var i : integer;
Ecrire ("Saisir une chaîne "), Lire (ch) verif : Boolean;
i0 Begin
Répéter Repeat
ii+1 Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
verif  pos (ch[i],ch) = i i := 0 ;
Jusqu’à (verif=faux) ou (i=long(ch)) Repeat
Jusqu’à verif i := i+1 ;
2) Fin Saisie Verif := pos(ch[i],ch) = i ;
Until (verif=false) or (i = length(ch)) ;
Until verif ;
End ;
Remplir un tableau T par N entiers impairs
0) DEF PROC Remplir (N : Entier ; VAR T : Tab) Procedure Remplir (N : integer ; Var T : Tab) ;
1) Pour i de 1 à n Faire Var i : integer;
Répéter Begin
Ecrire ("T[", i, "] = "), Lire (T[i]) For i:=1 To n Do
Jusqu’à (T[i] mod 2) ≠ 0 Repeat
Fin Pour Write (‘T[‘,i,’]= ’) ;
2) Fin Remplir Readln (T[i]) ;
Until (T[i] mod 2) <> 0 ;
End ;
Remplir un tableau par des entiers au hasard entre [a,b]
0) DEF PROC Remplir (VAR T : Tab ; N : Entier) Procedure Remplir (Var T : Tab ; N : integer) ;
1) Lire(a, b) Var a, b, i : integer;
2) Pour i de 1 à n Faire Begin
T[i] a + Aléa (b-a+1) Readln (a,b);
Fin Pour Randomize ;
3) Fin Remplir For i:=1 To n Do
T[i] := a + Random (b-a+1);
End ;

• Un réel au hasard entre [a,b[ • Un réel au hasard entre [a,b[

T[i] a+ (b-a) * Aléa T[i] := a+ (b-a) * Random
• Une lettre majuscule au hazard • Une lettre majuscule au hazard
T[i] chr (65 + Aléa(26)) T[i] := chr (65 + Random(26))
 Remplir un tableau T par N éléments en ordre croissant
0) DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : integer ; var t : tab) ;
1) Ecrire ("T[1] : "), Lire(T[1]) Var i : integer;
2) Pour i de 2 à n Faire Begin
Répéter Write ('T[1] : ') ; Readln (T[1]) ;
Ecrire ("T[", i, "] : "), Lire (T[i]) For i:=2 To n Do
Jusqu’à T[i] > T[i-1] Repeat
Fin Pour Write ('T[',i,'] : ') ;
3) Fin Saisie Readln (T[i]) ;
Until T[i] > T[i-1];
End ;

Remplir un tableau T par N éléments distincts

0) DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : Integer ; Var T: Tab);
1) Pour i de 1 à n Faire Var i, j : Integer;
Répéter Begin
Ecrire (''Saisir la case '', i), Lire (T[i]) For i:=1 To n Do
j 1 Repeat
Tant que T[i] ≠ T[j] Faire Writeln ('Saisir la case ', i); Readln (T[i]);
j j+1 j:=1;
Fin Tant que While T[i] <> T[j] Do j:=j+1 ;
Jusqu’à (j = i) Until (j = i) ;
Fin Pour End;
2) Fin Saisie
Remplir un tableau T par N entiers formés des chiffres non nuls
0) DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : Integer ; Var T : TAB) ;
1) Pour i de 1 à n Faire Var i : Integer ;
Répéter ch : String ;
Ecrire ("T[", i, "]= "), Lire (T[i]) Begin
Conch (T[i], ch) For i:=1 To n Do
Jusqu’à pos("0",ch)= 0 Repeat
Fin Pour Write (‘T[‘,i,’]= ’) ; Readln (T[i]) ;
2) Fin Saisie Str (T[i], ch);
Until pos('0',ch) = 0 ;
End;

Affichage d’un tableau T de N éléments

0) DEF PROC Affiche (N : Entier ; T : Tab) Procedure Affiche (n : Integer ; T : TAB) ;
1) Pour i de 1 à n Faire Var i : Integer ;
Ecrire (T[i], " ") Begin
Fin Pour FOR i :=1 TO n DO Write (T[i], ‘ ‘) ;
2) Fin Affiche End ;

Affichage d’un tableau, 10 valeurs par ligne

0) DEF PROC Affiche (T:tab ; n:entier) Procedure Affiche (T:tab ; n:integer);
1) Pour i de 1 à n Faire Var i : integer;
Ecrire (T[i], " ") Begin
Si (i mod 10) = 0 For i:=1 To n Do
Alors Retour_à_la_ligne begin
Fin Si write(T[i], " ");
Fin Pour If (i mod 10) = 0 then writeln ;
2) Fin Affiche end;
End ;

Permutation de deux variables réelles

0) DEF PROC Permut (VAR x, y : Réel) Procedure Permut (VAR x, y : Real) ;
1) AUX  Y Var aux : Real ;
2) YX Begin
3) X AUX Aux := Y ;
4) Fin Permut Y := X ;
X := Aux ;
End ;
 Transférer les éléments pairs d’un tableau T, dans T1 et les impairs dans T2
0) DEF PROC Transfert (T : tab ; n : entier ; var Procedure Transfert (T : tab ; n : integer ; var t1,t2 :
t1,t2 : tab ; var c1,c2 : entier) tab ; var c1,c2 : integer) ;
1) c1 0 ; c2  0 Var i :integer ;
Pour i de 1 à n Faire Begin
Si t[i] mod 2 = 0 c1 := 0 ;
Alors c1 c1 +1 c2 := 0 ;
T1[c1] T[i] For i :=1 To n Do
Sinon c2 c2 +1 If t[i] mod 2 = 0
T2[c2] T[i] Then begin
Fin Si c1 := c1 +1 ;
Fin Pour T1[c1] := T[i] ;
2) Fin Transfert end
Else begin
c2 := c2 +1 ;
T2[c2] := T[i] ;
end ;
End ;

Ranger les éléments négatifs d’un tableau T à gauche et les positifs à droite
0) DEF PROC Ranger (Var T : tab ; n : entier) Procedure Ranger (Var T : tab ; n : integer) ;
1) K 0 Var i, k, aux : integer ;
Pour i de 1 à n Faire Begin
Si t[i] < 0 k := 0 ;
Alors k k +1 For i :=1 To n Do
Aux t[i] If t[i] < 0
t[i]  t[k] Then begin
t[k]  aux k := k +1 ;
Aux := t[i] ;
Fin Si
Fin Pour t[i] := t[k] ;
2) Fin Transfert t[k] := aux ;
end ;
End ;

Insertion d’un élément X dans un tableau T à une position p

0) DEF PROC Insertion (Var T : tab ; n, x, p : Procedure Insertion ( Var T : tab ; n, x, p : integer) ;
entier) Var i :integer ;
1) Pour i de (n+1) à (p+1) Faire Begin
T[i]  T[i-1] {décalage des éléments vers droite} For i := (n+1) DownTo (p+1) Do T[i] := T[i-1] ;
Fin Pour T[p] := X ;
2) T[p]  X {insertion de X à la position p} End;
3) Fin Insertion

La somme de n réels dans un tableau

0) DEF FN Somme (T : tab ; n : entier) : réel Function Somme (T : tab ; n : integer) : real ;
1) S 0 Var i : integer ;
Pour i de 1 à n Faire s : real;
S S + T[i] Begin
Fin Pour s:=0 ;
2) Somme  S For i:=1 To n Do s:=s + T[i] ;
3) Fin Somme Somme := s ;
End ;

Factorielle de N ( n ! )
0) DEF FN Fact (n : entier) : entier long Function Fact (n : integer) : Longint ;
1) F 1 Var i : integer ;
2) Pour i de 2 à n Faire f : longint ;
FF*i Begin
Fin Pour f:=1 ;
3) Fact  F For i:=2 To n Do f := f * i ;
4) Fin Fact Fact := f ;
End ;
 Calcul de Xn (n ≥ 0)
0) DEF FN Puissance (x, n : entier) : entier Function Puissance (x, n : integer) : integer ;
1) p 1 Var i , p : integer ;
Pour i de 1 à n Faire Begin
pp*x p:=1 ;
Fin Pour For i:=1 To n Do p := p * x ;
2) puissance  p puissance := p ;
3) Fin Puissance End ;
Vérifier si un nombre est premier (le nombre de ses diviseurs =2)
0) DEF FN Premier (n : entier) : booléen Function Premier (N:integer) : boolean ;
1) nbdiv 1 Var i ,nbdiv : integer;
2) Pour i de 1 à (n div 2) Faire Begin
Si (n mod i = 0) nbdiv:=1;
Alors nbdiv  nbdiv+1 For i:=1 To (n div 2) Do
Fin Si If (n mod i = 0)
Fin Pour Then nbdiv := nbdiv + 1 ;
3) premier  (nbdiv = 2) premier := nbdiv = 2 ;
4) Fin Premier End ;
Vérifier si une chaîne de caractères contient uniquement des lettres
0) DEF FN Verif (ch : chaîne) : booléen Function verif (ch : String) : Boolean;
1) i0 Var i : Integer;
2) Répéter Test : Boolean;
i  i+1 Begin
test  ch[i] dans ["a".."z", "A".."Z"] i := 0;
Jusqu’à (test=faux) ou (i=long(ch)) Repeat
3) Verif  test i := i+1;
4) Fin verif test := ch[i] in ['a'..'z','A'..'Z'] ;
Until (test=False) Or (i=Length(ch));
verif := test;
End;
PPCM (a,b)
0) DEF FN PPCM ( a, b : entier) : entier Function PPCM (a ,b :integer) : integer ;
1) i 1 Var i : integer;
2) Tant que ((a*i) mod b) ≠ 0 Faire Begin
i  i+1 i := 1 ;
Fin Tant que While (a*i) mod b <> 0 Do i:=i+1 ;
3) ppcm  a*i
4) Fin PPCM ppcm := a*i ;
End;
PGCD_Euclide (a,b)
0) DEF FN PGCD_Euclide ( a, b : entier) : entier Function PGCD_Euclide (a ,b :integer) : integer ;
1) Tant que b ≠ 0 Faire Var r : integer;
r  a mod b Begin
a b While b<>0 Do
br Begin
Fin Tant que r := a mod b;
2) Pgcd_euclide  a a := b;
3) Fin PGCD_Euclide b := r;
End;
PGCD_Euclide := a;
End;
La somme de chiffres d’un entier
0) DEF FN Som_chif (n : entier) : entier Function Som_Chif ( N : integer ) : integer ;
1) som 0 Var som, r : integer ;
2) Répéter Begin
R n mod 10 som:=0 ;
Som  som + r Repeat
N  n div 10 r := n mod 10 ;
Jusqu’à (n = 0) Som := som + r ;
3) som_chif  som N := n div 10 ;
4) Fin Som_chif Until n=0 ;
Som_chif := som ;
End;
 Vérifier si une chaîne est palindrome (ou symétrique)
0) DEF FN Palindrome (ch : chaîne) : Booléen Function palindrome (ch : string) : boolean;
1) i 0 Var i:integer;
2) Répéter verif:boolean;
i  i+1 Begin
verif  ch[i] = ch[long(ch) – i + 1] i:=0;
Jusqu’à (verif=faux) ou (i = long(ch) div 2) repeat
3) palindrome  verif i:=i+1;
4) Fin Palindrome verif := ch[i] = ch[length(ch)-i+1] ;
until (verif=false) or (i=length(ch) div 2) ;
Palindrome := verif;
End;

Recherche de la première valeur minimum dans un tableau de n réels

0) DEF FN Minimum (n : Entier ; T : Tab) : Réel Function Minimum (n : Integer ; T : Tab) : Real ;
1) min T[1] Var i : Integer ;
Pour i de 2 à n Faire Min : Real ;
Si (T[i] < min) Begin
Alors min  T[i] Min := T[1] ;
Fin Si For i :=2 To n Do
Fin Pour If (T[i] < min) Then min := T[i] ;
2) Minimum  min Minimum := min ;
3) Fin Minimum End ;

Recherche de la dernière position d’un élément X dans un tableau de n réels

0) DEF FN Recherche (X : réel ; n : Entier ; T : Function Recherche (X:Real ; N:Integer ; T:Tab) :
Tab) : Entier Integer ;
1) p 0 ; in+1 Var i, p : Integer ;
Répéter Begin
ii - 1 p := 0 ;
Si T[i]=X Alors p  i Fin Si i := n+1;
Jusqu’à (p≠0) OU (i=1) Repeat
2) Recherche  p i := i - 1;
3) Fin Recherche If T[i]=X Then p := i ;
Until (p<>0) OR (i=1) ;
Recherche := p ;
End ;

Fréquence d’un élément X dans un tableau de N entiers

0) DEF FN Frequence (x,n :entier ;T:Tab) : entier Function Frequence (x, n :integer ; T:Tab):integer;
1) f0 Var i, f : Integer ;
2) Pour i de 1 à n Faire Begin
Si (T[i] = X) f := 0 ;
Alors f  f + 1 For i :=1 To n Do
Fin Si If (T[i] = X) Then f := f+1 ;
Fin Pour Frequence := f ;
3) frequence  f End ;
4) Fin Frequence

Miroir (symétrique) d’un entier long

0) DEF FN Miroir (x : entier long) : entier long Function miroir (x : longint) : longint ;
1) Sym  0 Var sym : longint ;
2) Répéter u : 0..9 ;
U  X mod 10 Begin
Sym  sym * 10 + u sym := 0 ;
X  x div 10 Repeat
Jusqu’à x=0 U := X mod 10;
3) miroir  sym Sym := sym * 10 + u;
4) Fin miroir X := x div 10 ;
Until x=0 ;
miroir := sym ;
End ;
Problème :
On se propose d’écrire un programme qui permet de :
• saisir un entier N (avec 10 ≤ N ≤ 50)
• remplir un tableau T par N chaînes alphanumériques
• ranger les chaînes formées uniquement des consonnes de T dans un tableau TC
• afficher les éléments de TC
Travail demandé :
1. Analyser le problème principal en le décomposant en modules.
2. Ecrire les algorithmes et les tableaux de déclaration relatifs aux modules envisagés.

ANALYSE DU P.P. :
Nom : Rangement
Résultat = PROC AFFICHE (K, TC)
(K, TC) = PROC RANGER (N, T, K, TC)
(N, T) = PROC SAISIES (N, T)
FIN Rangement
Tableau de Déclaration des Nouveaux Types
Type
Tab = Tableau de 50 chaînes

Tableau de Déclaration des Objets globaux

Objets Type/Nature Rôle
T Tab Tableau contenant n chaînes alphanumériques
TC Tab Tableau contenant k chaînes consonnes
N Entier Taille du tableau T
K Entier Taille du tableau TC
Saisies Procédure Permet de saisir un entier N et de remplir un tableau T
Ranger Procédure Permet de ranger les chaînes consonnes de T dans TC
Affiche Procédure Permet d’afficher les k éléments du tableau TC

Algorithme de la procedure saisies :

0) DEF PROC SAISIES (Var n : Entier ; Var T : tab)
1) Répéter
Ecrire ("N = "), Lire (N)
Jusqu’à n dans [10..50]
2) Pour i de 1 à n Faire
Répéter
Lire (T[i])
Jusqu’à FN Alpha (T[i]) { FN Alpha(T[i]) = Vrai }
Fin Pour
3) Fin Saisies
Tableau de Déclaration des Objets locaux
Objets Type/Nature Rôle
i Entier Compteur
Alpha Fonction Permet de vérifier si une chaîne est alphanumérique ou non
Algorithme de la fonction alpha :

0) DEF FN ALPHA (ch : chaîne) : Booléen

1) j  0
2) Répéter
j  j+1
test  majus(ch[j]) dans ["A".."Z","0".."9"]
Jusqu’à (test=faux) ou (j=long(ch))
3) Alpha  test
4) Fin Alpha

Tableau de Déclaration des Objets locaux

Objets Type/Nature Rôle
j Entier Compteur
test Booléen Variable intermédiaire

Algorithme de la procedure ranger :

0) DEF PROC RANGER (n :Entier ; T :Tab ; Var k : Entier ; Var Tc :Tab)

1) k0
2) Pour i de 1 à n Faire
Si FN Verif (T[i]) { Si FN Verif(T[i]) = Vrai }
Alors kk+1
Tc [k] T[i]
Fin si
Fin Pour
3) Fin Ranger

Tableau de Déclaration des Objets locaux

Objets Type/Nature Rôle
i Entier Compteur
Verif Fonction Permet de vérifier si une chaîne contient uniquement des consonnes

Algorithme de la fonction verif :

0) DEF FN Verif (ch : chaîne) : Booléen

1) j  0
2) Répéter
j  j+1
test  majus(ch[j]) dans (["A".."Z"]-["A","E","I","O","U","Y"])
Jusqu’à (test=faux) ou (j=long(ch))
3) Verif  test
4) Fin Verif

Tableau de Déclaration des Objets locaux

Objets Type/Nature Rôle
j Entier Compteur
test Booléen Variable intermédiaire
Algorithme de la procedure affiche :

0) DEF PROC Affiche (k : Entier ; Tc : tab)

1) Pour i de 1 à k Faire
Ecrire (Tc[i])
Fin Pour
2) Fin Affiche

Tableau de Déclaration des Objets locaux

Objets Type/Nature Rôle
i Entier Compteur