Exercices pascal tous les chapitres

1
Exercice N°1
Soit la structure personne constituée par :
 Un nom (chaîne de 30 caractères maximum).
 Un numéro fiscal (entier).
 Un numéro de téléphone (chaîne de 10 caractères maximum).
 Un numéro de carte bancaire (entier non signé).
Ecrivez les analyses, les algorithmes des différents modules d’un programme nommée fiche,
qui permet la saisie et l’affiche de l’enregistrement d’une personne.
Traduisez ce programme en pascal et l’enregistrez sous le nom Eneg_1 sous le dossier
c:4infog2.
program fiche;
uses wincrt;
type personne=record
nom:string[30];
fisc:integer;
tel:string[10] ;
banc:word
end;
var p:personne;
procedure saisie (var individu:personne);
begin
with p do
begin
write ('entrer le nom de personne : ');
readln (nom);
write('entrer son code fiscal : ');
readln(fisc);
write('entrer son numéro de téléphone : ');
readln(tel);
write('entrer le numéro de sa carte bancaire : ');
readln(banc);
end;
end;
procedure affichage (individu:personne);
begin
with p do
begin
writeln('Nom:',nom);
writeln('code fiscal:',fisc);
writeln('Numéro de téléphone:',tel);
writeln('Numéro de la carte bancaire:',banc);
end; end;
begin
saisie(p);
writeln ;
affichage(p);
©
Prof.AbdelkaderBarraj

2
end.
Exercice N°2
Une société veut informatisez la gestion des ses employés. Elle détint pour chacun les
informations suivantes :
 Le nom et le prénom (chaîne de caractères).
 Le grade (G1, G2, G3, G4) ;
 Le code fiscal (un entier non signé).
 L’assurance maladie (O pour oui et N pour non).
Le nombre d’employés est N avec 4 ≤ N ≤ 120.
Question :
Ecrivez un programme modulaire nommé GESTION, qui permet la saisie de toutes les
fiches d’enregistrement puis d’afficher :
Toutes les fiches un par un.
Le nombre d’employés ayant un grade donné et leur pourcentage par
Rapport au nombre total des employés.
Traduisez ce programme en pascal.
program gesstion;
uses wincrt;
type
gr=string[2];
fiche=record
nom:string[40];
garde:gr;
c_fiscal:word;
assurrence:char;
end;
tab=array[1..120]of fiche;
var
n:integer;
t:tab;
nb_g:integer;
g:gr;
nb:integer;
procedure saisie_n(var n:integer);
begin
repeat
write('N= ');
readln(n);
until n in [1..120];
end;
procedure saisie_g(var g:gr);
begin
repeat
write ('garde= ');
readln(g);
until (g='g1')or(g='g2')or(g='g3')or(g='g4');
end;
©

3
procedure saisie(var t:tab;n:integer);
var i : integer;
begin
for i :=1 to n do
with t[i] do
begin
write ('Nom: '); readln (nom);
saisie_g(garde);
write ('code fiscal: '); readln(c_fiscal);
repeat
write('assurrence maladie: '); readln(assurrence);
until upcase (assurrence)in ['O','N'];
end;
end;
procedure affichage(n:integer;t:tab);
var i:integer;
begin
for i:=1 to n do
with t[i] do
begin
writeln('Nom & prénom :',nom);
writeln('garde :',garde);
writeln('code fiscal :',c_fiscal);
writeln('assurrance maladie: ',assurrence);
writeln('******************************');
end;
end;
function occurrence(n:integer;t:tab;g:gr):integer;
var i,nb:integer;
begin
nb:=0;
for i:= 1 to n do
if(t[i].garde=g) then nb:=nb+1;
occurrence:=nb;
end;
procedure resultat (n,nb_g:integer;g:gr);
var p:real;
begin
writeln('le nombre d''occurrence de ',g,' est= à: ',nb_g);
p:=(nb_g*100)/n;
writeln('le pourcentage de ',g, 'est = ',p:0:0,'%');
end;
begin
saisie_n(n);
saisie(t,n);
affichage(n,t);
saisie_g(g);
nb_g:=occurrence(n,t,g);
resultat(n,nb_g,g);
end.
©

4
Les Fichiers
uses wincrt;
type
mot = record
fr: string[10];
Ag: string[10];
end;
Dictionnaire = file of mot;
var
D: Dictionnaire;
choix : char;
Procedure Saisie(var D: dictionnaire);
var
M: mot;
Rep : char;
begin
Repeat
with m do
begin
write('Mot en français : '); readln(fr);
write('Mot en anglais : '); readln(Ag);
end;
Write(D,M);
Repeat
Write('Terminer O/N : '); readln(Rep);
until upcase(Rep) in ['O','N'];
until upcase(rep) = 'O';
end;
procedure test (var D: dictionnaire);
begin
{$I-}
Reset(D);
If IOResult <> 0 then Rewrite(D);
{$I+}
end;
Procedure affiche(var D: dictionnaire);
var
M: mot;
begin
test(D);
{$I-}
©

5
Read(D,M);
If IOResult <> 0 then writeln('Fichier vide')
else
with m do
begin
writeln('Mot en français : ',fr);
writeln('Mot en anglais : ',Ag);
end;
{$I+}
Close(D);
end;
Procedure Recherche(var D: dictionnaire);
var
M: mot;
F:string[10];
begin
test(D);
Write('Donner le mot en français:'); Readln(f);
While not(Eof(d)) and (M.Fr <> F) do Read(D,M);
if M.Fr = F then writeln('Mot en anglais : ',M.Ag)
else writeln('Mot introuvable');
Close(D);
end;
Procedure ajout(var D: dictionnaire);
var
M: mot;
P: integer;
begin
test(D);
P:= Filesize(D);
Seek(D,P);
with m do
begin
write('Mot en français : '); readln(fr);
write('Mot en anglais : '); readln(Ag);
end;
Write(D,M);
Close(D);
end;
Procedure Supprimer(var D: dictionnaire);
var
M: mot;
P,N: integer;
begin
test(D);
P:=filesize(D);
Repeat
©

6
Write('Donner le nombre d''enregistrements à supprimer entre [0..',P,']:');
readln(n);
until n in [0..P];
P:=P - n;
if P <= 0 then Erase(D)
else
Begin
Seek(D,P);
Truncate(D);
end;
Close(D);
end;
begin
Assign(D,'C:dictionnair.dat');
Repeat
Clrscr;
Writeln('O : Quiter ');
Writeln('1 : Saisie ');
Writeln('2 : Affichage du premier enregistrement');
Writeln('3 : Rechercher un enregistrement ');
Writeln('4 ; Ajout d''un enregistrement à la fin du fichier');
Writeln('5 ; Supprimer les n derniers enregistrements');
Writeln('*******************************************************************');
Write('Donner votre choix : '); readln(choix);
Case choix of
'0':halt;
'1':begin
Rewrite(D);
Saisie(D);
Close(D);
end;
'2': affiche(D);
'3': Recherche(D);
'4': ajout(D);
'5': Supprimer(D);
else writeln('Erreur');
end;
readln;
until choix = '0';
end.
Exercice N°2 Fichier texte
uses wincrt;
var
f:text;
choix:char;
procedure Association(var f:text);
var
nom_phy : string[30];
begin
write('Nom physique du fichier texte: '); readln(nom_phy);
Assign(f,nom_phy);
©

7
end;
Procedure Saisie(var f:text);
var
ch:string;
begin
Rewrite(f);
repeat
readln(ch);
writeln(f,ch);
until ch[length(ch)] = '.';
close(f);
end;
Procedure ajout(var f:text);
var
ch:string;
begin
{$I-}
append(f);
If IOResult <> 0 then Rewrite(f);
{$I+}
readln(ch);
writeln(f,ch);
close(f);
end;
procedure test (var F: text);
begin
{$I-}
Reset(F);
If IOResult <> 0 then Rewrite(F);
{$I+}
end;
Procedure affiche(var f:text);
var
ch:string;
begin
test(F);
while not(eof(f)) do
begin
readln(f,ch);
writeln(ch);
end;
close(f);
end;
Procedure recherche(var f:text);
var
ch:string;
mot:string[15];
begin
test(f);
©

8
write('Mot : ');readln(mot);
begin
readln(f,ch);
if pos(mot,ch)<> 0 then writeln(mot,' se trouve dans la ligne : ',ch);
end;
close(f);
end;
Procedure Nombre(var f:text);
var
c:char;
l:integer;
begin
test(f);
l:=0;
while not(seekeof(f)) do
begin
read(f,c);
if seekeoln(f) then l:=l+1;
end;
writeln('Le Nombre de ligne = ',l);
close(f);
end;
begin
Association(f);
Repeat
Clrscr;
Writeln('1 : Association d''un nom logique à un nom physique');
Writeln('3 : Ajout d''une ligne à la fin d''un fichier texte');
Writeln('4 : Affichage ');
Writeln('5 : Rechercher un mot dans un fichier texte ');
Writeln('6 : Nombre de ligne dans un fichier texte');
Writeln('*******************************************************************');
Case choix of
'0': halt;
'1': Association(f);
'2': Saisie(f);
'3': Ajout(f);
'4': Affiche(f);
'5': Recherche(f);
'6': Nombre(f);
end;
readln;
until choix = '0';
end.
©

9
Fichier Texte
uses wincrt;
var
f:text;
choix:char;
procedure Association(var f:text);
var
nom_phy : string[30];
begin
write('Nom physique du fichier texte: '); readln(nom_phy);
Assign(f,nom_phy);
end;
Procedure Saisie(var f:text);
var
ch:string;
begin
Rewrite(f);
repeat
readln(ch);
writeln(f,ch);
until ch[length(ch)] = '.';
close(f);
end;
Procedure ajout(var f:text);
var
ch:string;
begin
{$I-}
append(f);
If IOResult <> 0 then Rewrite(f);
{$I+}
readln(ch);
writeln(f,ch);
close(f);
end;
procedure test (var F: text);
begin
{$I-}
Reset(F);
If IOResult <> 0 then Rewrite(F);
{$I+}
end;
Procedure affiche(var f:text);
var
ch:string;
begin
test(F);
begin
readln(f,ch);
writeln(ch);
end;
close(f);
end;
©

10
Procedure recherche(var f:text);
var
ch:string;
mot:string[15];
begin
test(f);
write('Mot : ');readln(mot);
begin
readln(f,ch);
if pos(mot,ch)<> 0 then writeln(mot,' se trouve dans la ligne : ',ch);
end;
close(f);
end;
Procedure Nombre(var f:text);
var
c:char;
l:integer;
begin
test(f);
l:=0;
while not(seekeof(f)) do
begin
read(f,c);
if seekeoln(f) then l:=l+1;
end;
writeln('Le Nombre de ligne = ',l);
close(f);
end;
begin
Association(f);
Repeat
Clrscr;
Writeln('1 : Association d''un nom logique à un nom physique');
Writeln('3 : Ajout d''une ligne à la fin d''un fichier texte');
Writeln('4 : Affichage ');
Writeln('5 : Rechercher un mot dans un fichier texte ');
Writeln('6 : Nombre de ligne dans un fichier texte');
Writeln('*******************************************************************');
Case choix of
'0': halt;
'1': Association(f);
'2': Saisie(f);
'3': Ajout(f);
'4': Affiche(f);
'5': Recherche(f);
'6': Nombre(f);
end;
readln;
until choix = '0';
end.
©

11
La récursivité
{Exercice: Factorielle de (n);}
uses wincrt;
var
n:integer;
procedure saisie(var n:integer);
begin
repeat
write('donner n>0: ');
readln(n);
until n>=0;
end;
function factorielle(n:integer):longint;
begin
if n=0 then factorielle:=1
else factorielle:=n*factorielle(n-1);
end;
begin
saisie(n);
writeln(factorielle(n));
end.
{Exercice PGCD 1ére methode}
uses wincrt;
var
a,b:integer;
n:integer;
begin
repeat
readln(n);
until n>=0;
end;
function pgcd(a,b:integer):integer;
begin
if a mod b=0 then pgcd:=b
else pgcd:=pgcd(b,a mod b);
end;
begin
saisie(a);
saisie(b);
writeln('Le resultat est= ',pgcd(a,b));
end.
©

12
{Exercice PGCD 2éme methode}
uses wincrt;
var
a,b:integer;
n:integer;
begin
repeat
readln(n);
until n>=0;
end;
begin
if a>b then pgcd:=pgcd(a-b,b)
else if a<b then pgcd:=pgcd(a,b-a)
else pgcd:=a;
end;
begin
saisie(a);
saisie(b);
writeln('Le resultat est= ',pgcd(a,b));
end.
{Exercice PGCD 3éme methode}
uses wincrt;
var
n,a,b,i:integer;
procedure saisie (var n:integer);
begin
repeat
write('donner un entier>0: ');
readln(n);
until n>=0;
end;
begin
if a=0 then pgcd:=b
else if b=0 then pgcd:=a
else if not(odd(a)) and not(odd(b)) then pgcd:=2*Pgcd(a div 2,b div 2)
else if not(odd(a)) and (odd(b)) then pgcd:= pgcd(a div 2,b)
else if (odd(a)) and not(odd(b)) then pgcd:=pgcd(a,b div 2)
else if (odd(a)) and (odd(b)) then if a>b then pgcd:=pgcd(a-b,b)
else pgcd:=pgcd(a,b-a);
end;
begin
saisie(a);
saisie(b);
writeln('le resultat est= ',pgcd(a,b));
end.
©

13
{Exercice PPCM (a,b)}
uses wincrt;
var
n,a,b,max,min,i:integer;
begin
repeat
write('donner un entier>0: ');
readln(n);
until n>=0;
end;
function ppcm(max,min:integer):integer;
begin
if max mod min=0 then ppcm:=max
else begin max:=max+(a+b-min);ppcm:=ppcm(max,min) ;end;
end;
begin
saisie(a);
saisie(b);
if a>b then begin max:=a; min := b;end else begin max:=b;min := a;end;
writeln(ppcm(min,max));
end.
{Exercice Produit (x exposon n) de (n); }
uses wincrt;
var
n:integer;
x:real;
begin
repeat
readln(n);
until n>=0;
end;
function produit(n:integer):real;
begin
if n=0 then produit:=1
else produit:=produit(n-1)*x;
end;
begin
saisie(n);
write('x= '); readln(x);
writeln('Le resultat est= ',produit(n):0:0);
end.
©

14
{Exercice somme de (n) }
uses wincrt;
var
n:integer;
begin
repeat
readln(n);
until n>=0;
end;
function somme(n:integer):real;
var x:real;
begin
if n=0 then somme:=0
else begin
write('x= ');
readln(x);
somme:=x+somme(n-1);
end;
end;
begin
saisie(n);
writeln(somme(n):0:0);
end.
{Exercice Fabonacci F0=1 ;F1=1 ; Fn=Fn-1+Fn-2 }
uses wincrt;
var
n:integer;
begin
repeat
readln(n);
until n>=0;
end;
function fabonacci(n:integer):integer;
begin
if n=0 then fabonacci:=1
else if n=1 then fabonacci:=1
else fabonacci:=fabonacci(n-1)+fabonacci(n-2);
end;
begin
saisie(n);
writeln('Le resultat est= ',fabonacci(n));
end.
©

15
Exercice 6
program ex6;
uses wincrt ;
var
n,p:integer;
begin
repeat
write('donner n: ');
readln(n);
until n>=0;
end;
function com(n,p:integer):integer;
begin
if p>n then com:=0
else if p=0 then com:=1
else if p=n then com:=1
else if p=1 then com:=n
else com:=com(n-1,p-1)+com(n-1,p);
end;
begin
saisie(n);
saisie(p);
writeln('le resultat= ',com(n,p));
end.
Exercice 7
{Ecrire une fonction recursive palandrom permettant de vérifier si une chaine est palandrom}
program ex7;
uses wincrt ;
var
ch:string;
procedure saisie (var ch:string);
begin
write('donner une chaine: ');
readln(ch);
end;
function palindrome(ch:string):boolean;
begin
if length(ch)<2 then palindrome:=true
else if ch[1]=ch[length(ch)] then
palindrome:=palindrome(copy(ch,2,length(ch)-2))
else palindrome:=false;
end;
begin
saisie(ch);
writeln('le resultat= ',palindrome(ch));
end.
©

16
Exercice 8
{Ecrire un procédure inverse permettant d'inverser une chaine CH}
program ex8;
uses wincrt ;
procedure inverse;
var
c:char;
begin
read(c);
if ord(c)<>13 then inverse;
write(c);
end;
begin
inverse
end.
Exercice 9
{Ecrire une procédure récursive saisie_n permettant de saisir un entier dans l'intervalle [x..y]}
procedure saisie_n(var n:integer;x,y:integer);
begin
write('donner un entier dans[',x,'..',w,'] : '); readln(n);
if not (n in [x..y]) then saisie_n (n,x,y);
end;
Saisie_n (n,x,y) ;
Saisie_n (n,2,30) ;
Exercice 10
{Ecrire une procédure récursive saisie_vect permettant de saisie un tableau T de réels}
procedure saisie_vect(var t:tab;n:integer);
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
procedure saisie_vect(var t:tab;deb,fin:integer);
begin
if deb <= fin then
begin
write('T[',deb,'] = ');
readln(T[deb]);
saisie_vect(t,deb+1,fin);
end;
end;
©

17
Exercice 11
{Ecrire une procédure récursive Affichage permettant d’afficher les éléments d’un tableau T}
procedure affichage (t:tab;n:integer);
begin
if n<>0 then
begin
affichage (t,n-1);
writeln('t[',n,']=',t[n]);
end;
end;
procedure affichage(t:tab;deb,fin:integer);
begin
if deb <= fin then
begin
writeln('T[',deb,'] = ',T[deb]);
affichage(t,deb+1,fin);
end;
end;
program tableau;
uses wincrt;
type
tab = array[1..100] of real;
var
T:tab;
n:integer;
Procedure saisie_n(var n : integer; x,y : integer);
begin
write('Donner un entier dans [',x,'..',y,'] : ');
readln(n);
if not(n in [x..y]) then saisie_n(n,x,y);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
procedure affichage(t:tab;n:integer);
begin
if n <>0 then
begin
affichage(t,n-1);
writeln('T[',n,'] = ',T[n]);
end;
end;
begin
saisie_n(n,1,100);
saisie_vect(t,n);
affichage(t,n);
program tableau;
uses wincrt;
type
var
T:tab;
n:integer;
begin
readln(n);
end;
procedure saisie_vect(var t:tab;deb,fin:integer);
begin
if deb <= fin then
begin
write('T[',deb,'] = ');
readln(T[deb]);
saisie_vect(t,deb+1,fin);
end;
end;
procedure affichage(t:tab;deb,fin:integer);
begin
if deb <= fin then
begin
writeln('T[',deb,'] = ',T[deb]);
affichage(t,deb+1,fin);
end;
end;
begin
saisie_n(n,1,100);
saisie_vect(t,1,n);
affichage(t,1,n);
©

18
end. end.
Exercice 12
{Ecrire une fonction récursive recherche permettant
de vérifier l’existence d’un réel x dans un tableau T
de réel en utilisant la technique de la recherche
séquentielle.}
Méthode itérative:
function Recherche ( T : vect; n: integer ; X : real) :
boolean;
Var
i : integer;
begin
i:= 1;
while (T[i] <> X) and (i <=n) do
i:= i+1;
If T[i] = X then Recherche := True
Else Recherche := false ;
end;
function Recherche ( T : vect; n: integer ; X : real) :
boolean;
Var
i : integer;
begin
i:= 0;
Repeat
i:= i+1;
until (T[i] <> X)or (i <=n) ;
If T[i] = X then Recherche := True
Else Recherche := false ;
end;
Méthode récursive:
function recherche (t:tab;n:integer;x:real):boolean;
begin
if n = 0 then recherche := false
else
if x = t[n] then recherche := true
else recherche := recherche(t,n-1,x);
end;
program recherche_seq;
uses wincrt;
type
var
T:tab;
n:integer;
x:real;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
function recherche (t:tab;n:integer;x:real):boolean;
begin
if n = 0 then recherche := false
else
if x = t[n] then recherche := true
else recherche := recherche(t,n-1,x);
end;
begin
saisie_n(n,1,100);
saisie_vect(t,n);
write('donner un réel : '); readln(x);
if recherche(t,n,x) then writeln(x,' Exite dans le
tableau')
else writeln(x,' N''Existe pas dans le tableau ');
end.
©

19
Exercice 13
{Ecrire une fonction récursive recherche permettant
de vérifier l’existence d’un réel x dans un tableau T
de réel en utilisant la technique de la recherche
dichotomique}
Méthode itérative :
function recherche (t:tab;c:char;n:integer):boolean;
var i: integer;
begin
premier:=1;
dernier:=n;
repeat
i:=(premier + dernier) div 2;
if c< t[i] then dernier := i-1;
if c>t[i] then premier :=i+1;
until (c=t[i]) or (premier>dernier);
if t[i]=c then recherche:= true else recherche:= false;
end;
Méthode récursive :
function recherche
(t:tab;deb,fin:integer;x:real):boolean;
var
m:integer;
begin
M := (deb + fin) div 2;
if x = T[m] then recherche := true
else
if (x < T[m]) and (deb < m) then recherche :=
recherche(t,deb,m-1,x)
else
if (x > T[m]) and (fin > m) then recherche :=
recherche(t,m+1,fin,x)
else recherche := false;
end;
program recherche_seq;
uses wincrt;
type
var
T:tab;
n:integer;
x:real;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
function recherche (t:tab;deb,fin:integer;x:real):boolean;
var
m:integer;
begin
M := (deb + fin) div 2;
if x = T[m] then recherche := true
else
if (x < T[m]) and (deb < m) then recherche :=
recherche(t,deb,m-1,x)
else
if (x > T[m]) and (fin > m) then recherche :=
recherche(t,m+1,fin,x)
else recherche := false;
end;
begin
saisie_n(n,1,100);
saisie_vect(t,n);
write('donner un réel : '); readln(x);
if recherche(t,1,n,x) then writeln(x,' Exite dans le
tableau')
else writeln(x,' N''Existe pas dans le tableau ');
end.
©

20
Exercice 14
{Ecrire une fonction récursive maximum permettant
de déterminer le maximum d’un tableau de réel}
Méthode Itérative :
Fonction maximum (elément) :
function maximum( n:integer;t:tab):real;
begin
max:=t[1];
for i := 2 to n do
begin
if t[i]>max then
max := t[i];
end;
maximum := max;
end;
function maximum (t:tab;n:integer):real;
var
max:real;
begin
if n=1 then maximum := t[1]
else
begin
max:= maximum(t,n-1);
if max < t[n] then maximum := t[n]
else maximum :=max;
end;
end;
program tab_max_elem;
uses wincrt;
type
var
T:tab;
n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
function maximum (t:tab;n:integer):real;
var
max:real;
begin
if n=1 then maximum := t[1]
else
begin
if max < t[n] then maximum := t[n]
else maximum :=max;
end;
end;
begin
saisie_n(n,1,100);
saisie_vect(t,n);
writeln('Maximum = ',Maximum(t,n));
end.
©

21
Exercice 14
de déterminer le maximum d’un tableau de réel}
Fonction maximum (position):
function maximum( n:integer;t:tab):integer;
begin
max:=1;
for i := 2 to n do
begin
if t[i]>t[max] then
max := i;
end;
maximum := max;
end;
function maximum (t:tab;n:integer):integer;
var
max:integer;
begin
if n=1 then maximum := n
else
begin
if t[max] < t[n] then maximum := n
else maximum :=max;
end;
end;
program tab_max_indice;
uses wincrt;
type
var
T:tab;
n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
function maximum (t:tab;n:integer):integer;
var
max:integer;
begin
if n=1 then maximum := 1
else
begin
if t[max] < t[n] then maximum := n
else maximum :=max;
end;
end;
begin
saisie_n(n,1,100);
saisie_vect(t,n);
writeln('Maximum = ',t[Maximum(t,n)]);
end.
©

22
Exercice 15
de déterminer le maximum d’un tableau de réel entre
deux bornes [bi..bf]}
function maximum (t:tab;bi,bs:integer):integer;
var i,max:integer;
begin
max:=bi;
for i:= bi +1 to bs do
if t[i]>t[max] then max:=i;
maximum:=max;
end;
function maximum (t:tab;bi,bf:integer):integer;
var
max:integer;
begin
if bf = bi then maximum:=bi
else
begin
max:= maximum(t,bi,bf-1);
if t[max] < t[bf] then maximum := bf
else maximum :=max;
end;
end;
program tab_max_indice;
uses wincrt;
type
var
T:tab;
bi,bf,n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
var
max:integer;
begin
if bf = bi then maximum:=bi
else
begin
else maximum :=max;
end;
end;
begin
Saisie_n(n,1,100);
saisie_n(bi,1,n);
Saisie_n(bf,bi,n);
saisie_vect(t,n);
writeln('Maximum = ',t[Maximum(t,bi,bf)]);
end.
©

23
Exercice 14
{Ecrire une fonction récursive minimum permettant
de déterminer le minimum d’un tableau de réel}
Fonction minimum (position):
function minimum( n:integer;t:tab):integer;
begin
min:=1;
for i := 2 to n do
begin
if t[i]<t[min] then
min := i;
end;
minimum := min;
end;
function minimum (t:tab;n:integer):integer;
var
min:integer;
begin
if n=1 then minimum := n
else
begin
min:= minimum(t,n-1);
if t[min] >t[n] then minimum := n
else minimum :=min;
end;
end;
program tab_min_indice;
uses wincrt;
type
var
T:tab;
n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
function minimum (t:tab;n:integer):integer;
var
min:integer;
begin
if n=1 then minimum := 1
else
begin
if t[min] > t[n] then minimum := n
else minimum :=min;
end;
end;
begin
saisie_n(n,1,100);
saisie_vect(t,n);
writeln('Minimum = ',t[Minimum(t,n)]);
end.
©

24
Exercice 15
de déterminer le minimum d’un tableau de réel entre
deux bornes [bi..bf]}
function minimum (t:tab;bi,bs:integer):integer;
var i,min:integer;
begin
min:=bi;
for i:= bi +1 to bs do
if t[i]<t[min] then min:=i;
minimum:=min;
end;
function minimum (t:tab;bi,bf:integer):integer;
var
min:integer;
begin
if bf = bi then minimum:=bi
else
begin
min:= minimum(t,bi,bf-1);
if t[min] > t[bf] then minimum := bf
else minimum :=min;
end;
end;
program tab_min_indice;
uses wincrt;
type
var
T:tab;
bi,bf,n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
function minimum (t:tab;bi,bf:integer):integer;
var
min:integer;
begin
if bf = bi then minimum:=bi
else
begin
min:= minimum(t,bi,bf-1);
if t[min] > t[bf] then minimum := bf
else minimum:=min;
end;
end;
begin
Saisie_n(n,1,100);
saisie_n(bi,1,n);
Saisie_n(bf,bi,n);
saisie_vect(t,n);
writeln('Minimum = ',t[Minimum(t,bi,bf)]);
end.
©

25
Exercice 14
de déterminer le minimum d’un tableau de réel}
Fonction minimum (elément) :
function minimum( n:integer;t:tab):real;
begin
min:=t[1];
for i := 2 to n do
begin
if t[i]<min then
min:= t[i];
end;
minimum := min;
end;
function minimum (t:tab;n:integer):real;
var
min:real;
begin
if n=1 then minimum := t[1]
else
begin
if min >t[n] then minimum:= t[n]
else minimum :=min;
end;
end;
program tab_min_elem;
uses wincrt;
type
var
T:tab;
n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
function minimum (t:tab;n:integer):real;
var
min:real;
begin
if n=1 then minimum := t[1]
else
begin
if min > t[n] then minimum := t[n]
else minimum :=min;
end;
end;
begin
saisie_n(n,1,100);
saisie_vect(t,n);
writeln('Minimum = ',Minimum(t,n));
end.
©

26
Algorithme de TRI
TRI à Bulle
Itérative
program tri_bull;
uses wincrt;
type
tab = array[1..100] of char;
var
T:tab;
n:integer;
begin
repeat
readln(n);
until n in [x..y];
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
begin
if n <>0 then
begin
affichage(t,n-1);
writeln('T[',n,'] = ',T[n]);
end;
end;
procedure permutation(var a,b:char);
var
c:char;
begin
c:=a;
a:=b;
b:=c;
end;
procedure tri(var t:tab; n:integer);
var
trouve : boolean;
i:integer;
begin
Repeat
trouve := false;
Recursive
program tri_bulle;
uses wincrt;
type
tab = array[1..100] of char;
var
T:tab;
n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
begin
if n <>0 then
begin
affichage(t,n-1);
writeln('T[',n,'] = ',T[n]);
end;
end;
procedure permutation(var a,b:char);
var
c:char;
begin
c:=a;
a:=b;
b:=c;
end;
procedure tri(var t:tab; deb,fin:integer);
var
trouve : boolean;
begin
trouve := false;
if deb < fin then
©

27
for i := 1 to n-1 do
if T[i] > T[i+1] then
begin
permutation(T[i],T[i+1]);
trouve := true;
end;
until not(trouve);
end;
begin
Saisie_n(n,1,100);
Saisie_vect(T,n);
tri(t,n);
affichage(t,n);
end.
begin
if T[deb] < T[deb + 1] then
begin
permutation(T[deb],T[deb+1]);
trouve := true;
end;
tri(T,deb+1,fin);
end;
if trouve then tri(T,deb,fin);
end;
begin
Saisie_n(n,1,100);
Saisie_vect(T,n);
tri(t,1,n);
affichage(t,n);
end.
©

28
TRI par Sélection
Iterative
program tri_selection;
uses wincrt;
type
var
T:tab;
n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
var
max:integer;
begin
if bf = bi then maximum := bi
else
begin
else maximum :=max;
end;
end;
begin
if n <>0 then
begin
affichage(t,n-1);
writeln('T[',n,'] = ',T[n]);
end;
end;
procedure permutation(var a,b:real);
var
c:real;
begin
Récursive
program tri_selection;
uses wincrt;
type
var
T:tab;
n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
var
max:integer;
begin
if bf = bi then maximum := bi
else
begin
else maximum :=max;
end;
end;
begin
if n <>0 then
begin
affichage(t,n-1);
writeln('T[',n,'] = ',T[n]);
end;
end;
procedure permutation(var a,b:real);
var
c:real;
begin
©

29
c:=a;
a:=b;
b:=c;
end;
procedure tri(var t:tab;n:integer);
var
M,i : integer;
begin
for i := 1 to n do
begin
M:=maximum(T,i,n);
if i<>M then permutation(t[i],T[m]);
end;
end;
begin
Saisie_n(n,1,100);
Saisie_vect(T,n);
tri(t,n);
affichage(t,n);
end.
c:=a;
a:=b;
b:=c;
end;
procedure tri(var t:tab;deb,fin:integer);
var
M : integer;
begin
M:=maximum(T,deb,fin);
if deb<>m then permutation(t[deb],T[m]);
if deb+1 <> fin then tri(T,deb+1,fin);
end;
begin
Saisie_n(n,1,100);
Saisie_vect(T,n);
tri(t,1,n);
affichage(t,n);
end.
©

30
TRI par Insertion
program tri_insertion;
uses wincrt;
type
Vect = array[1..100] of char;
var
T:Vect;
N: integer;
procedure saisie (Var x : integer;bi,bf:integer);
begin
repeat
write('Donner un entier dans [',bi,'..',bf,'] : ');
readln(n);
until n in [bi..bf];
end;
Procedure saisie_vect(Var T:Vect;n:integer);
var
i : integer;
begin
for i := 1 to n do
begin
write('T[',i,'] = ');
readln(T[i]);
end; end;
Procedure affichage(T:Vect;n:integer);
var
i : integer;
begin
for i := 1 to n do
writeln('T[',i,'] = ',T[i]);
end;
Procedure tri(var T:vect;n:integer);
var
i,j:integer;
value : char;
begin
for i:=2 to n do
begin
value := T[i];
j:=i;
while(T[j-1] < value) and (j > 1) do
begin
T[j]:=T[j-1];
j:=j-1;
end;
T[j]:=value;
end;end;
Begin
Saisie(n,2,100);
Saisie_vect(T,n);
tri(T,n);
writeln('*****************************');
affichage(T,n);
©

31
end.
TRI Shell
uses wincrt;
type
tab=array[1..40]of char;
var t:tab;
n:integer;
procedure saisie_n (var n:integer);
begin
write('donner n= ');readln(n);
end;
begin
if n <>0 then
begin
saisie_vect(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;end;
procedure tri(var t:tab;n:integer);
var
h,i,j:integer;
value:char;
begin
h:=0;
repeat
h:=3*h+1;
until h>n;
repeat
begin
h:=h div 3;
for i := h+1 to n do
begin
value:=t[i];
j:=i;
while (t[j-h]<value) and (j>h) do
begin
t[j]:=t[j-h];
j:=j-h;
end;
t[j]:=value;
end;
end;
until h=1;
end;
begin
if n <>0 then
begin
affichage(t,n-1);
writeln('T[',n,'] = ',T[n]);
end;end;
begin
saisie_n(n);
saisie_vect(t,n);
tri(t,n);
affichage(t,n);
©

32
end.
Classement
Iterative
uses wincrt;
Const
N= 2;
type
ch = string[40];
Fiche = record
nom: ch;
DCP,DCT,DS,Moy:Real;
Rang:Byte;
end;
Eleve = array[1..N] of fiche;
var
tab_elev:Eleve;
Procedure saisie_note(mes :ch; var X: real);
begin
repeat
Write(Mes);
readln(x);
until (x >= 0) and (x <=20);
end;
Procedure Saisie(var tab_elev:Eleve);
var
i:integer;
begin
for i := 1 to n do
with tab_elev[i] do
begin
write('Nom : '); readln(Nom);
Saisie_note('Devoir de contrôle Pratique
: ',DCP);
Saisie_note('Devoir de contrôle
théorique : ',DCT);
Saisie_note('Devoir de synthése : ',DS);
Moy := (DCP + DCT + 2*DS)/4;
end;
end;
Procedure affichage(tab_elev:Eleve);
var
i:integer;
begin
for i := 1 to n do
with tab_elev[i] do
begin
writeln(Nom,' ', Moy:2:2,' ',Rang);
end;
Recursive
uses wincrt;
Const
N= 2;
type
ch = string[40];
Fiche = record
nom: ch;
DCP,DCT,DS,Moy:Real;
Rang:Byte;
end;
Eleve = array[1..N] of fiche;
var
tab_elev:Eleve;
Procedure saisie_note(mes :ch; var X: real);
begin
Write(Mes);
readln(x);
if not((x >= 0) and (x <=20)) then saisie_note(mes,
x);
end;
Procedure Saisie(var tab_elev:Eleve;n:integer);
begin
if n <>0 then
begin
saisie(tab_elev,n-1);
with tab_elev[n] do
begin
write('Nom : '); readln(Nom);
Saisie_note('Devoir de contrôle Pratique
: ',DCP);
Saisie_note('Devoir de contrôle
théorique : ',DCT);
Saisie_note('Devoir de synthése : ',DS);
Moy := (DCP + DCT + 2*DS)/4;
end;
end;
end;
Procedure affichage(tab_elev:Eleve;n:integer);
begin
if n <>0 then
begin
affichage(tab_elev,n-1);
with tab_elev[n] do
begin
writeln(Nom,' ', Moy:2:2,' ',Rang);
end;
©

33
end;
Procedure Calcul_Rang(var tab_elev:Eleve);
var
i,j:integer;
begin
for i := 1 to n do
begin
tab_elev[i].Rang := 1;
for j := 1 to n do
if tab_elev[i].Moy < tab_elev[j].Moy
then
tab_elev[i].Rang := tab_elev[i].Rang +
1;
end;
end;
begin
Saisie(Tab_elev);
Calcul_Rang(Tab_elev);
Affichage(tab_elev);
end.
end;
end;
Procedure Calcul_Rang(var
tab_elev:Eleve;x,y:integer);
begin
if x <> 0 then
begin
tab_elev[x].Rang := 1;
if y<>0 then
begin
Calcul_rang(tab_elev,x,y-1);
if tab_elev[x].Moy < tab_elev[y].Moy
then
tab_elev[x].Rang := tab_elev[x].Rang
+ 1;
end;
if y = 0 then Calcul_rang(tab_elev,x-1,n);
end;
end;
begin
Saisie(Tab_elev,n);
Calcul_Rang(Tab_elev,n,n);
Affichage(tab_elev,n);
end.
©

34
Itérative
Program tri_fusion;
uses wincrt;
type Tab = array[1..40] of string[10];
var A,B,Fus : tab;
N,M : integer;
procedure Remplir(var T: Tab; var x : integer);
var
i : integer;
begin
repeat
write('Donner un entier dans [3..20] : ');
readln(x);
until x in [3..20];
write('T[',1,']= '); readln(T[1]);
for i := 2 to x do
repeat
write('T[',i,']= '); readln(T[i]);
until T[i] <= T[i - 1];
end;
Procedure Fusion (Var Fus : Tab; A, B : Tab;N,M :
integer);
var IA, IB, Ifus,i: integer;
begin
IA := 1;
Ib := 1;
IFus:= 0;
Repeat
IFus := IFus + 1;
If A[IA] > B[IB] Then
begin
Fus[Ifus] := A[iA];
iA := iA + 1;
end
else
begin
Fus[Ifus] := B[IB];
IB := IB + 1;
end;
until (IA > N) or (IB > M);
If IA > N then
for i := IB to M do
begin
IFus:= IFus + 1;
Fus[IFus] := B[i];
end;
If IB > M then
for i := IA to N do
begin
IFus:= IFus + 1;
Fus[IFus] := A[i];
end;
Récursive
Program tri_fusion;
uses wincrt;
type tab = array[1..20] of string[10];
var A,B,Fus : tab;
N,M : integer;
begin
readln(n);
if not(n in [x..y]) then saisie_n(x,1,20);
end;
procedure Saisie(var T: Tab;deb,fin : integer);
begin
if (deb <= fin) then
begin
write('T[',deb,'] = '); readln(T[deb]);
if (deb <> 1 ) and (t[deb] >= T[deb-1]) then
Saisie(T,deb,fin)
else Saisie(T,deb+1,fin);
end;
end;
Procedure Fusion (Var Fus : Tab; A, B :
Tab;IA,IB,IFUS,N,M : integer);
begin
if (IA <= n) and (IB <= m) then
begin
If A[IA] > B[IB] Then
begin Fus[Ifus] := A[iA];
Fusion(Fus,A,B,IA+1,IB,IFUS+1,N,M); end
else
begin Fus[Ifus] := B[iB];
Fusion(Fus,A,B,IA,IB+1,IFUS+1,N,M); end;
end;
If IA > N then
if IB <= M then
begin Fus[IFus] := B[IB];
Fusion(Fus,A,B,IA,IB+1,IFUS+1,N,M); end;
If IB > M then
if IA <= N then
begin Fus[IFus] := A[IA];
Fusion(Fus,A,B,IA+1,IB,IFUS+1,N,M); end;
end;
Procedure affichage(T:Tab; deb,fin : integer);
var i : integer;
begin
if deb <= fin then
begin writeln('T[',deb,'] = ',T[deb]);
affichage(T,deb+1,fin); end;
end;
begin
Saisie_n(n,1,20); Saisie(A,1,n);
Saisie_n(m,1,20); Saisie(B,1,m);
©

35
end;
Procedure affichage(T:Tab; x : integer);
var i : integer;
begin
for i := 1 to x do
writeln('T[',i,'] = ',T[i]);
end;
begin
Remplir(A,n);
Remplir(B,M);
Fusion(Fus, A, B, N, M);
affichage(Fus, N+M);
end.
Fusion(Fus, A, B,1, 1, 1, n, m);
affichage(Fus,1,n+m);
end.
©

36
Les Algorithme Récurrents
Exercice N°1
Ecrire un programme qui met à zéro les éléments de la diagonale d’une matrice carrée A donnée.
uses wincrt;
type
mat=array[1..20,1..20]of integer;
var
n:integer;
a:mat;
begin
readln(n);
end;
procedure saisie (var a:mat;n:integer);
var
i,j:integer;
begin
for i:=1 to n do
for j:=1 to n do
begin
write('A[',i,',',j,']= ');
readln (A[i,j]);
end;
end;
procedure diagonale (var a:mat;n:integer);
var i:integer;
begin
for i:= 1 to n do
A[i,i]:=0;
end;
procedure affichage (a:mat;n:integer);
var
i,j:integer;
begin
for i:=1 to n do
for j:=1 to n do
writeln('A[',i,',',j,']= ',A[i,j]);
end;
begin
saisie_n(n,1,20);
saisie(a,n);
diagonale(a,n);
affichage (a,n);
end.
©

37
Exercice N°2
Ecrire un programme qui construit et affiche une matrice carrée unitaire U de dimension N.
Une matrice Unitaire est une matrice, telle que:
Uij= 1 si i=j
0 si i # j
uses wincrt;
type
mat=array[1..20,1..20]of 0..1;
var
n:integer;
u:mat;
begin
readln(n);
end;
procedure affichage (U:mat;n:integer);
var
i,j:integer;
begin
for i:=1 to n do
for j:=1 to n do
writeln('U[',i,',',j,']= ',U[i,j]);
end;
procedure remplir (var u:mat;n:integer);
var i,j:integer;
begin
for i:= 1 to n do
for j:=1 to n do
Begin
if i=j then U[i,j]:=1
else U[i,j]:=0
end;
end;
begin
saisie_n(n,1,20);
remplir(U,n);
affichage (u,n);
end.
©

38
Exercice N°3
uses wincrt;
type
mat=array[1..20,1..20]of char;
var
l,c:integer;
a,b:mat;
begin
readln(n);
end;
procedure saisie (var a:mat;l,c:integer);
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
write('A[',i,',',j,']= ');
readln (A[i,j]);
end;
end;
procedure affichage (a:mat;l,c:integer);
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
writeln('A[',i,',',j,']= ',A[i,j]);
end;
Procedure transposition (var A,B:mat;l,c:integer);
var i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
B[j,i]:=A[i,j];
end;
end;
begin
saisie_n(l,1,20);
saisie_n(c,1,20);
saisie(a,l,c);
transposition (a,b,l,c);
affichage (a,l,c);
end.
©

39
Exercice N°4
Ecrire un programme qui réalise la multiplication d’une matrice A par un réel X.
a) Le résultat de la multiplication sera mémorisé dans une deuxième matrice B qui sera ensuite affichée.
b) Les éléments de la matrice A seront multipliés par X.
uses wincrt;
type
mat=array[1..20,1..20]of real;
var
l,c:integer;
a,b:mat;
x:real;
begin
readln(n);
end;
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
write('A[',i,',',j,']= ');
readln (A[i,j]);
end;
end;
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
writeln('A[',i,',',j,']= ',A[i,j]:2:2);
end;
Procedure multiplication (var A,B:mat;l,c:integer);
var i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
a[i,j]:=A[i,j]*x;
end;end;
begin
saisie_n(l,1,20);
saisie_n(c,1,20);
saisie(a,l,c);
write('donner un réel: '); readln(x);
multiplication(a,b,l,c);
affichage (a,l,c);
end.
©

40
Exercice N°5
Ecrire un programme qui réalise l’addition de deux matrice A et B de mêmes dimensions N et M.
a) Le résultat de l’addition sera mémorisé dans une troisième matrice S qui sera ensuite affichée.
b) La matrice B est ajoutée à A.
uses wincrt;
type
var
l,c:integer;
a,b:mat;
x:real;
begin
readln(n);
end;
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
write('A[',i,',',j,']= ');
readln (A[i,j]);
end;
end;
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
gotoxy (4*j,i+2);
writeln('A[',i,',',j,']= ',A[i,j]:2:2);
end;
end;
Procedure somme (var A,B:mat;l,c:integer);
var i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
a[i,j]:=A[i,j]+b[i,j];
end;
end;
uses wincrt;
type
var
l,c:integer;
a,s,b:mat;
x:real;
begin
readln(n);
end;
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
write('A[',i,',',j,']= ');
readln (A[i,j]);
end;
end;
procedure affichage (s:mat;l,c:integer);
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
gotoxy (4*j,i+2);
writeln('S[',i,',',j,']= ',S[i,j]:2:2);
end;
end;
Procedure somme (var s,A,B:mat;l,c:integer);
var i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
s[i,j]:=A[i,j]+b[i,j];
end;
end;
©

41
begin
saisie_n(l,1,20);
saisie_n(c,1,20);
saisie(a,l,c);
saisie_n(l,1,20);
saisie_n(c,1,20);
saisie(b,l,c);
somme(a,b,l,c);
writeln('***********************');
clrscr;
affichage (a,l,c);
end.
begin
saisie_n(l,1,20);
saisie_n(c,1,20);
saisie(a,l,c);
saisie_n(l,1,20);
saisie_n(c,1,20);
saisie(b,l,c);
somme(s,a,b,l,c);
writeln('***********************');
clrscr;
affichage (s,l,c);
end.
©

42
Exercice N°6
uses wincrt;
type
var
a,c,b:mat;
x:real;
m,n,p:integer;
begin
readln(n);
end;
procedure saisie (var a:mat;n,m:integer);
var
i,j:integer;
begin
for i:=1 to n do
for j:=1 to m do
begin
write('A[',i,',',j,']= ');
readln (A[i,j]);
end;
end;
Procedure multiplication (var c:mat;
A,B:mat;n,m,p:integer);
var i,j,k:integer;
begin
for i:=1 to n do
for j:=1 to p do
begin
c[i,j]:=0;
for k:=1 to m do
c[i,j]:=c[i,j]+a[i,k]*b[k,j];
end;
end;
procedure affichage (a:mat;n,p:integer);
var
i,j:integer;
begin
for i:=1 to n do
for j:=1 to p do
writeln('A[',i,',',j,']= ',A[i,j]);
end;
begin
saisie_n(n,1,20);
saisie_n(m,1,20);
saisie(a,n,m);
saisie_n(m,1,20);
saisie_n(p,1,20);
saisie(b,m,p);
multiplication ( c,a,b,n,m,p);
writeln('******');
affichage(c,n,p);
end.
©

43
Exercice N°7
uses wincrt;
type
var
l,c,j,i:integer;
a,min,max:mat;
x:real;
m,n:integer;
begin
readln(n);
end;
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
write('A[',i,',',j,']= ');
readln (A[i,j]);
end;
end;
function maximum (a:mat;l,c:integer):integer;
var i:integer;
begin
m:=1;
for i :=2 to c do
if a[l,i]> a[l,m] then
m:=i ;
maximum:= m;
end;
function minimum(a:mat;l,c:integer):integer;
var i:integer;
begin
m:=1;
for i :=2 to l do
if a[i,c]< a[m,c] then
m:=i ;
minimum:= m;
end;
procedure mat_max (var max:mat;a:mat;l,c:integer);
var j,k:integer;
begin
for j:=1 to l do
begin
m:=maximum(a,j,c);
for k:=1 to c do
if m=k then max[j,k]:=1
else max[j,k]:=0;
end;
end;
procedure mat_min (var min:mat;a:mat;l,c:integer);
var j,k:integer;
begin
for j:=1 to c do
begin
m:=minimum(a,l,j);
for k:=1 to l do
if m=k then min[k,j]:=1
else min[k,j]:=0;
end;
end;
procedure affiche (a,min,max:mat;l,c:integer);
var
i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin
if (max[i,j]=1) and (min[i,j]=1) then
write('a[',i,';',j,']= ',a[i,j]);
end;
end;
begin
saisie_n(l,1,20);
saisie_n(c,1,20);
saisie(a,l,c);
mat_max(max,a,l,c);
mat_min(min,a,l,c);
writeln('******');
affiche(a,min,max,l,c);
end.
©

44
Exercice N°8 1ére méthode
uses wincrt;
type
mat=array[0..50,0..50]of byte;
var
t:mat;
n,l,c:integer;
begin
readln(n);
end;
procedure Remplir (Var t : Mat ; N : integer);
var l,c:integer;
begin
t [0,0]:= 1;
t [1,0]:= 1 ;
t [1,1]:=1 ;
for L := 2 to N do
begin
t [L, 0]:=1;
t [L, L]:=1;
for C := 1 to L-1 do
t [L, C]:= t [L-1, C] +t [L-1, C-1];
end;
end;
procedure affichage (t:mat;n:integer);
begin
for l:=0 to n do
begin
writeln;
for c:=0 to l do
write(t[l,c]:5);
end;
end;
begin
Saisie_n (n, 0, 50);
Remplir (t, n);
Affichage (t, n);
end.
Exercice N°8 2éme méthode
uses wincrt;
type
mat=array[0..50,0..50]of byte;
var
p:mat;
n,l,c:integer;
begin
readln(n);
end;
procedure Remplir (Var p : Mat ;l,c ,N : integer);
begin
p [0,0]:= 1; p [1,0]:= 1 ; p [1,1]:=1 ;
if l<=n then
begin
p[l,0]:=1; p[l,l]:=1;
if c<=l-1 then
begin
p[l,c]:=p[l-1,c]+p[l-1,c-1];
remplir(p,l,c+1,n);
end
else remplir (p,l+1,0,n);
end;
end;
procedure affichage (var p:mat;l,c,n:integer);
begin
if l<=n then
if c<=l then
begin
write(p[l,c]:5);
affichage(p,l,c+1,n);
end
else begin writeln;affichage(p,l+1,0,n); end;
end;
begin
Saisie_n (n, 0, 50);
Remplir (p,0,0, n);
Affichage (p,0,0, n);
end.
©

45
Exercice N°9
uses wincrt;
var
n:integer;
c:char;
begin
repeat
write('Donner un entier dans [',x,',',y,'] = ');
readln(n);
until n in [x..y];
end;
procedure saisie_c(var c:char;x,y:char);
begin
repeat
write('Donner un caractère dans [',x,',',y,'] = ');
readln(c);
until c in [x..y];
end;
Procedure thue_morse(c:char;n:integer);
var
i,j:integer;
ch:string;
begin
ch:=c;
writeln(ch);
for i :=1 to n do
begin
j:=1;
repeat
if ch[j]='1' then insert('0',ch,j+1)
else insert('1',ch,j+1);
j:=j+2;
until j > length(ch);
writeln(ch);
end;
end;
begin
saisie_n(n,2,50);
Saisie_c(c,'0','1');
Thue_Morse(c,n);
end.
Exercice N°9
uses wincrt;
var
n:integer;
c:char;
begin
repeat
write('Donner un entier dans [',x,',',y,'] = ');
readln(n);
until n in [x..y];
end;
procedure saisie_c(var c:char;x,y:char);
begin
repeat
write('Donner un caractère dans [',x,',',y,'] = ');
readln(c);
until c in [x..y];
end;
function inverse_ch(ch:string):string;
var
j:integer;
ch1:string;
begin
ch1:='';
for j := 1 to length(ch) do
if ch[j]='0' then ch1:=concat(ch1,'1')
else ch1:=concat(ch1,'0');
inverse_ch:=ch1;
end;
Procedure thue_morse(c:char;n:integer);
var
i,j:integer;
ch:string;
begin
ch:=c;
writeln(ch);
for i :=1 to n do
begin
ch:=concat(ch,inverse_ch(ch));
writeln(ch);
end;
end;
begin
saisie_n(n,2,50);
Saisie_c(c,'0','1');
Thue_Morse(c,n);
end.
©

46
Exercice N°10
uses wincrt;
type
fibo=array[1..100] of integer;
var f:fibo;
n:integer;
begin
readln(n);
end;
procedure fibonacci (var f:fibo;n:integer);
var i:integer;
begin
f[1]:=1;
f[2]:=1;
f[3]:=1;
for i:= 4 to n do
begin
f[i]:=f[i-3]+f[i-2]+f[i-1];
write(f[i]);
end;
end;
begin
saisie_n(n,4,100);
fibonacci(f,n);
end.
Exercice N°10
uses wincrt;
var
n:integer;
begin
readln(n);
end;
procedure fibonacci (n:integer);
var i,f1,f2,f3,f:integer;
begin
f1:=1;
f2:=1;
f3:=1;
for i:= 4 to n do
begin
f:=f3+f2+f1;
write(f);
f1:=f2;
f2:=f3;
f3:=f;
end;
end;
begin
saisie_n(n,4,100);
fibonacci(n);
end.
©

47
Exercice N°11
uses wincrt;
type
Tab_E = array[1..100] of integer;
Tab_R = array[1..100] of real;
var
e:real;
Procedure saisie_e(var e:real);
begin
repeat
Write('Donner un réel très proche de zéro :');
readln(e);
until (e >=0) and (e <= 1);
end;
Procedure nombre_or(e:real);
var
n :integer;
U:Tab_E;
V:Tab_R;
begin
U[1]:=1;
U[2]:=2;
n:=2;
Repeat
n:=n+1;
U[n]:=U[n-1]+U[n-2];
V[n]:=U[n] / U[n-1];
Until abs(V[n]-V[n-1]) < e;
Writeln('V[',n,'] = ',V[n]);
end;
begin
Saisie_e(e);
nombre_or(e);
end.
©

48
Exercice N°3 page 145
uses wincrt;
var
n:integer;
procedure saisie_n (var n:integer;x,y:integer);
begin
write ('donner un entier ');
readln (n);
if not (n in [x..y]) then saisie_n(n,x,y);
end;
procedure triangle (var n:integer);
var i,j,k:integer;
begin
for i := 1 to n do
begin
k:=2*i-1;
for j:= 1 to k do
begin
gotoxy (n*2-(k div 2)+j ,i+4);
write('*');
end;
end;
end;
begin
saisie_n(n,1,100);
triangle(n);
end.
uses wincrt;
var
n:integer;a,x0,x:real;
begin
readln (n);
end;
procedure suite ( n:integer;a:real);
var i:integer;
begin
x0:=a;
for i:= 1 to n do
begin
x:=4*x0*(1-x0);
writeln(x:0:0);
x0:=x;
end;
end;
begin
saisie_n(n,1,100);
write('donner a: '); readln(a);
suite(n,a);
end.
©

49
uses wincrt;
var
n:integer;a,u,u0,v,v0:real;
begin
readln (n);
end;
function suite ( n:integer):real;
var i:integer;
begin
u0:=1;
v0:=2;
for i:= 1 to n do
begin
u:=(u0+v0)/2;
writeln('u[',i,']= ',u);
v:=sqrt(u*v0);
writeln('v[',i,']= ',v);
u0:=u;
v0:=v;
end;
suite:=v;
end;
begin
saisie_n(n,1,100);
writeln('pi=',sqrt(27)/suite(n));
end.
program suites;
uses wincrt;
var N:Real;
procedure suite(var n : Real;x:Real);
var
U1,U2,U:Real;
begin
U1:=1; U2:=1; n:=2;
Repeat
n:=n+1;
U:=U1+U2;
U1:=U2;
U2:=U;
until U > x;
writeln('N= ',N-1:2:0,' Un= ',U1:10:0);
end;
Begin
Suite(n,32767);
Suite(n,2147483647);
End.
©

50
***Algorithmes Récurrents***
Saisie_Mat Itérative Saisie_Mat Itérative
Procedure lecture(Var T:Mat;n:integer);
var
i,j : integer;
begin
for i := 1 to n do
for j := 1 to n do
begin
write('T[',i,',',j,'] = ');
readln(T[i, j]);
end;
end;
begin
Saisie_n(n,1,20);
Lecture(T,n);
end.
Procedure lecture(Var T:Mat; l, c:integer);
var
i,j : integer;
begin
for i := 1 to l do
for j := 1 to c do
begin
write('T[',i,',',j,'] = ');
readln(T[i, j]);
end;
end;
begin
Saisie_n(l,1,20);
Saisie_n(c,1,20);
Lecture(T,l,c);
end.
Saisie_Mat Récursive Saisie_Mat Récursive
uses wincrt;
type
Mat = array[1..20,1..20] of char;
var
T:Mat;
n:integer;
Procedure saisie_n(Var n : integer; x,y : integer);
begin
Write('Donner un entier dans [', x ,',',y, '] : ');
readln(n);
If not(n in [x..y]) then Saisie_n(n, x, y);
end;
Procedure lecture(Var T:Mat;i,j,n:integer);
begin
if i <= n then
if j <= n then
begin
write('T[',i,',',j,'] = ');
readln(T[i, j]);
lecture(T,i,j+1,n);
end
else lecture(T,i+1,1,n);
end;
begin
Saisie_n(n,1,20);
Lecture(T,1,1,n);
end.
uses wincrt;
type
Mat = array[1..20,1..20] of real;
var
T:Mat;
l,c:integer;
begin
readln(n);
end;
Procedure lecture(Var T:Mat;i,j,l,c:integer);
begin
if i <= l then
if j <= c then
begin
write('T[',i,',',j,'] = ');
readln(T[i, j]);
lecture(T,i,j+1,l,c);
end
else lecture(T,i+1,1,l,c);
end;
begin
Saisie_n(l,1,20);
Saisie_n(c,1,20);
Lecture(T,1,1,l,c);
end.
©

51
Affichage Itérative Affichage Itérative
Procedure Affichage(T:Mat;n:integer);
var
i,j : integer;
begin
for i := 1 to n do
for j := 1 to n do
writeln('T[',i,',',j,'] = ', T[i, j]);
end;
begin
Saisie_n(n,1,20);
Affichage(T,n);
end.
Procedure affichage(T:Mat; l, c:integer);
var
i,j : integer;
begin
for i := 1 to l do
for j := 1 to c do
write('T[',i,',',j,'] = ', T[i, j]);
end;
begin
Saisie_n(l,1,20);
Saisie_n(c,1,20);
Affichage(T,l,c);
end.
Affichage Récursive Affichage Récursive
Procedure Affichage(T:Mat;i,j,n:integer);
begin
if i <= n then
if j <= n then
begin
write('T[',i,',',j,'] = ', T[i, j]);
Affichage(T,i,j+1,n);
end
else Affichage(T,i+1,1,n);
end;
begin
Saisie_n(n,1,20);
Affichage(T,1,1,n);
end.
Procedure Affichage(T:Mat;i,j,l,c:integer);
begin
if i <= l then
if j <= c then
begin
write('T[',i,',',j,'] = ', T[i, j]);
affichage(T,i,j+1,l,c);
end
else affichage(T,i+1,1,l,c);
end;
begin
Saisie_n(l,1,20);
Saisie_n(c,1,20);
Affichage(T,1,1,l,c);
end.
©

52
Maximum_Note Itérative
Function Maximum(n:integer):real;
var
M,note : real;
i:integer;
begin
Write('Note = '); readln(note);
M:=Note;
for i:=1 to n do
begin
if Note > M Then M:=note;
end;
Maximum := M;
end;
begin
saisie_n(n,1,50);
Writeln(Maximum(n));
end.
Maximum_Note Récursive Maximum_Note Récursive
uses wincrt;
var
n:integer;
begin
readln(n);
end;
Function Maximum(n:integer):real;
var
note,M : real;
begin
if n=1 then Maximum := Note
else
begin
M:=Maximum(n-1);
if Note > M then Maximum:=Note
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50);
Writeln(Maximum(n));
end.
uses wincrt;
var
n:integer;
begin
readln(n);
end;
Function Maximum(deb,fin:integer):real;
var
note,M : real;
begin
if deb=fin then Maximum := Note
else
begin
M:=Maximum(deb,fin-1);
if Note > M then Maximum:=Note
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50);
Writeln(Maximum(1,n));
end.
©

53
Maximum Elément Itérative Maximum Position Itérative
Procedure saisie(Var T:Tab; n: integer);
var i:integer;
begin
for i:=1 to n do
begin write('T[',i,'] : '); readln(T[i]); end;
end;
Function Maximum(T: Tab;n:integer):real;
var M:real;
i:integer;
begin
M:=T[1];
for i:=2 to n do
If T[i] > M Then M:=T[i];
Maximum := M;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(Maximum(T,n));
end.
var i:integer;
begin
for i:=1 to n do
end;
Function Maximum(T: Tab;n:integer):integer;
var i,M:integer;
begin
M:=1;
for i:=2 to n do
If T[i] > t[M] Then M:=i;
Maximum := M;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(T[Maximum(T,n)]);
end.
Maximum Elément entre deux bornes Itérative Maximum Position entre deux bornes Itérative
var i:integer;
begin
for i:=1 to n do
end;
Function Maximum(T: Tab;bi,bf:integer):real;
var M:real;
i:integer;
begin
M:=T[bi];
for i:=bi+1 to bf do
if T[i] > M Then M:=T[i];
Maximum := M;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Saisie_n(bf,1,n);
Saisie_n(bi,1,bf);
Writeln(Maximum(T,bi,bf));
end.
var i:integer;
begin
for i:=1 to n do
end;
Function Maximum(T: Tab;bi,bf:integer):integer;
var i,M:integer;
begin
M:=bi;
for i:=bi+1 to bf do
if T[i] > T[M] Then M:=i;
Maximum := M;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Saisie_n(bf,1,n);
Saisie_n(bi,1,bf);
Writeln(T[Maximum(T,bi,bf)]);
end.
©

54
Maximum Elément Récursive (n) Maximum Position Récursive (n)
begin
if n <>0 then
begin
saisie(t,n-1);
write('T[',n,'] = '); readln(T[n]);
end;
end;
Function Maximum(T:Tab;n:integer):real;
var M : real;
begin
if n=1 then Maximum := T[1]
else begin
M:=Maximum(T,n-1);
if T[n] > M then Maximum:=T[n]
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(Maximum(T,n));
end.
begin
if n <>0 then
begin
saisie(t,n-1);
write('T[',n,'] = '); readln(T[n]);
end;
end;
Function Maximum(T:Tab;n:integer):integer;
var M : integer;
begin
if n=1 then Maximum := 1
else begin
M:=Maximum(T,n-1);
if T[n] > T [M] then Maximum:=n
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(T[Maximum(T,n)]);
end.
Maximum Elément Récursive (deb/fin) Maximum Position Récursive (deb/fin)
procedure saisie(var t:tab; deb, fin:integer);
begin
if deb <= fin then
begin
saisie(t,deb+1, fin);
end;
end;
Function Maximum(T:Tab;deb,fin:integer):real;
var M : real;
begin
if deb=fin then Maximum := T[deb]
else begin
M:=Maximum(T,deb,fin-1);
if T[fin] > M then Maximum:=T [fin]
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50);
Saisie(T,1,n);
Writeln(Maximum(T,1,n));
end.
begin
if deb <= fin then
begin
end;
end;
Function Maximum(T:Tab;deb,fin:integer):integer;
var M : integer;
begin
if deb=fin then Maximum := deb
else begin
if T[fin] > T[M] then Maximum:=fin
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50);
Saisie(T,1,n);
Writeln(T[Maximum(T,1,n)]);
end.
©

55
Maximum Elément entre deux bornes Récursive Maximum Position entre deux bornes Itérative
uses wincrt;
type
Tab = array[1..50] of real;
var
T:Tab;
bi,bf,n:integer;
begin
readln(n);
end;
begin
if deb <= fin then
begin
end;
end;
Function Maximum(T:Tab;deb,fin:integer):real;
var M : real;
begin
if deb=fin then Maximum := T[deb]
else begin
if T[fin] > M then Maximum:=T[fin]
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50); Saisie(T,1,n);
Saisie_n(bf,1,n); Saisie_n(bi,1,bf);
Writeln(Maximum(T,bi,bf));
end.
uses wincrt;
type
var
T:Tab;
bi,bf,n:integer;
begin
readln(n);
end;
begin
if deb <= fin then
begin
end;
end;
Function Maximum(T:Tab;deb,fin:integer):integer;
var M : integer;
begin
if deb=fin then Maximum := deb
else begin
if T[fin] > T[M] then Maximum:=fin
else Maximum := M;
end;
end;
begin
saisie_n(n,1,50); Saisie(T,1,n);
Saisie_n(bf,1,n); Saisie_n(bi,1,bf);
Writeln(T[Maximum(T,bi,bf)]);
end.
©

56
Maximum Matrice Itérative Maximum Matrice Récursive
uses wincrt;
type
var
T:mat;
l,c:integer;
Procedure saisie_n(Var n : integer; x, y: integer);
begin
Repeat
Write('Donner un entier dans [',x, ',',y, '] : ');
readln(n);
until n in [x..y];
end;
Procedure lecture(Var T:Mat; l,c: integer);
var i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
begin write('T[',i,',',j,'] : '); readln(T[i, j]); end;
end;
Function Maximum(T: Mat; l,c:integer):real;
var M:real;
i,j:integer;
begin
M:=T[1,1];
for i:=1 to l do
for j:=1 to c do
if T[i,j] > M Then M:=T[i,j];
Maximum := M;
end;
begin
saisie_n(l,1,50);
saisie_n(c,1,50);
lecture(T,l,c);
Writeln(Maximum(T,l,c));
end.
uses wincrt;
type Mat = array[1..5,1..5] of real;
var T:Mat; l,c:integer;
begin
readln(n);
end;
begin
if i <= l then
if j <= c then
begin
write('T[',i,',',j,'] = '); readln(T[i, j]);
end
end;
Function Maximum(T: Mat; l,c,n:integer):real;
Var M: Real;
begin
if l = 1 then Maximum := T[1,1]
else if c <> 0 Then begin
M:=Maximum(T,l,c-1,n);
if T[l,c] > M then Maximum:=
T[l,c];
else Maximum := M;
end
else M:=Maximum(T,l-1,n,n);
end;
begin
Saisie_n(l,1,5); Saisie_n(c,1,5);
Lecture(T,1,1,l,c); Writeln(Maximum(T,l,c,c));
end.
©

57
Moyenne Note : Itérative
Function Moyenne(n:integer):real;
var
S,note : real;
i:integer;
begin
S:=0;
for i:=1 to n do
begin
Write('Note = ');
readln(note);
S:=S+note
end;
Moyenne := S/N;
end;
begin
saisie_n(n,1,50);
Writeln(Moyenne(n));
end.
Moyenne Note : Récursive Moyenne Note : Récursive
uses wincrt;
var
n:integer;
begin
readln(n);
end;
Function Moyenne(n:integer):real;
var
note : real;
begin
if n <> 0 then
begin
Write('Note = ');
readln(note);
Moyenne:=Moyenne(n-1)+note/N;
end;
end;
begin
saisie_n(n,1,50);
Writeln(Moyenne(n));
end.
uses wincrt;
var
n:integer;
begin
readln(n);
end;
Function Moyenne(deb, fin:integer):real;
var
note : real;
begin
if deb <= fin then
begin
Write('Note = ');
readln(note);
Moyenne:=Moyenne(deb+1,fin)+note/N;
end;
end;
begin
saisie_n(n,1,50);
Writeln(Moyenne(1,n));
end.
©

58
Moyenne Tab : Itérative
var i:integer;
begin
for i:=1 to n do
end;
Function Moyenne(T: Tab;n:integer):real;
var S:real;
i:integer;
begin
S:=0;
for i:=1 to n do S:=S+T[i];
Moyenne := S/N;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(Moyenne(T,n));
end.
Moyenne Tab : Récursive (n) Moyenne Tab Récursive : (deb/fin)
uses wincrt;
Type
Var T:tab; n:integer;
begin
readln(n);
end;
begin
if n <>0 then
begin
saisie(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
Function Moyenne(T: Tab; n, x:integer):real;
begin
if n <> 0 then Moyenne:= Moyenne(T,n-
1,x)+T[n]/x;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(Moyenne(T,n,n));
end.
uses wincrt;
type
Var T:Tab; n:integer;
begin
readln(n);
end;
begin
if deb <= fin then
begin
write('T[',deb,'] = ');
readln(T[deb]);
end;
end;
Function Moyenne(T:Tab; deb, fin:integer):real;
begin
if deb <= fin then
Moyenne:=Moyenne(T,deb+1,fin)+T[deb]/N;
end;
begin
saisie_n(n,1,50);
Saisie(T,1,n);
Writeln(Moyenne(T,1,n));
end.
©

59
Moyenne entre deux bornes : Itérative Moyenne entre deux bornes : Récursive
uses wincrt;
type
var
T:Tab;
bi,bf,n:integer;
begin
Repeat
readln(n);
until n in [x..y];
end;
var i:integer;
begin
for i:=1 to n do
end;
Function Moyenne(T: Tab;bi,bf:integer):real;
var S:real;
i:integer;
begin
S:=0;
for i:=bi to bf do S:=S+T[i];
Moyenne := S/(bf-bi+1);
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Saisie_n(bf,1,n);
Saisie_n(bi,1,bf);
Writeln(Moyenne(T,bi,bf));
end.
uses wincrt;
type
var
T:Tab;
bi,bf,n:integer;
begin
readln(n);
end;
begin
if deb <= fin then
begin
write('T[',deb,'] = ');
readln(T[deb]);
end;
end;
Function Moyenne(T:Tab; deb, fin,x:integer):real;
begin
if deb <= fin then
Moyenne:=Moyenne(T,deb+1,fin,x)+T[deb]/x
end;
begin
saisie_n(n,1,50);
Saisie(T,1,n);
Saisie_n(bf,1,n);
Saisie_n(bi,1,bf);
Writeln(Moyenne(T,bi,bf,bf-bi+1));
end.
©

60
Moyenne Matrice : Itérative Moyenne Matrice : Récursive
uses wincrt;
type
var
T:mat;
l,c:integer;
begin
Repeat
readln(n);
until n in [x..y];
end;
var i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
end;
Function Moyenne(T: Mat; l,c:integer):real;
var S:real;
i,j:integer;
begin
S:=0;
for i:=1 to l do
for j:=1 to c do S:=S+T[i,j];
Moyenne := S/(l*c);
end;
begin
saisie_n(l,1,50);
saisie_n(c,1,50);
lecture(T,l,c);
Writeln(Moyenne(T,l,c));
end.
uses wincrt;
type
var
T:Mat;
l,c:integer;
begin
readln(n);
end;
begin
if i <= l then
if j <= c then
begin
write('T[',i,',',j,'] = ');
readln(T[i, j]);
end
end;
Function Moyenne(T: Mat; l,c,n,x:integer):real;
begin
if l<> 0 then
begin
if c <> 0 then Moyenne := T[l,c]/x +
Moyenne(T,l,c-1,n,x)
else Moyenne:= Moyenne(T,l-1,n,n,x);
end;
end;
begin
Saisie_n(l,1,5);
Saisie_n(c,1,5);
Lecture(T,1,1,l,c);
Writeln(Moyenne(T,l,c,c,l*c));
end.
©

61
Somme Note : Itérative
uses wincrt;
var n:integer;
Function Somme(n:integer):real;
var
S,note : real;
i:integer;
begin
S:=0;
for i:=1 to n do
begin
Write('Note = ');
readln(note);
S:=S+note
end;
Somme := S; end;
begin
saisie_n(n,1,50);
Writeln(Somme(n));
end.
Somme Note : Récursive (n) Somme Note : Récursive (deb/fin)
uses wincrt;
var
n:integer;
begin
readln(n);
end;
Function Somme(n:integer):real;
var
note : real;
begin
if n <> 0 then
begin
Write('Note = ');
readln(note);
Somme:=Somme(n-1)+note
end;
end;
begin
saisie_n(n,1,50);
Writeln(Somme(n));
end.
uses wincrt;
var
n:integer;
begin
readln(n);
end;
Function Somme(deb, fin:integer):real;
var
note : real;
begin
if deb <= fin then
begin
Write('Note = ');
readln(note);
Somme:=Somme(deb+1,fin)+note
end;
end;
begin
saisie_n(n,1,50);
Writeln(Somme(1,n));
end.
©

62
Somme tab : Itérative
var i:integer;
begin
for i:=1 to n do
end;
Function Somme(T: Tab;n:integer):real;
var S:real;
i:integer;
begin
S:=0;
for i:=1 to n do S:=S+T[i];
Somme := S;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(Somme(T,n));
end.
Somme tab : Récursive (n) Somme tab : Récursive (deb/fin)
uses wincrt;
Type
Var T:tab;
n:integer;
begin
if n <>0 then
begin
saisie(t,n-1);
write('T[',n,'] = ');
readln(T[n]);
end;
end;
Function Somme(T: Tab; n:integer):real;
begin
if n <> 0 then Somme:=Somme(T,n-1)+T[n];
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Writeln(Somme(T,n));
end.
uses wincrt;
type
Var T:Tab;
n:integer;
begin
if deb <= fin then
begin
write('T[',deb,'] = ');
readln(T[deb]);
end;
end;
Function Somme(T:Tab; deb, fin:integer):real;
begin
if deb <= fin then
Somme:=Somme(T,deb+1,fin)+T[deb];
end;
begin
saisie_n(n,1,50);
Saisie(T,1,n);
Writeln(Somme(T,1,n));
end.
©

63
Somme tab entre deux bornes : Itérative Somme tab entre deux bornes : Récursive
uses wincrt;
type
var
T:Tab;
bi,bf,n:integer;
begin
Repeat
readln(n);
until n in [x..y];
end;
var i:integer;
begin
for i:=1 to n do
end;
Function Somme(T: Tab;bi,bf:integer):real;
var S:real;
i:integer;
begin
S:=0;
for i:=bi to bf do S:=S+T[i];
Somme := S;
end;
begin
saisie_n(n,1,50);
Saisie(T,n);
Saisie_n(bf,1,n);
Saisie_n(bi,1,bf);
Writeln(Somme(T,bi,bf));
end.
uses wincrt;
type
var
T:Tab;
bi,bf,n:integer;
begin
readln(n);
end;
begin
if deb <= fin then
begin
write('T[',deb,'] = ');
readln(T[deb]);
end;
end;
Function Somme(T:Tab; deb, fin:integer):real;
begin
if deb <= fin then
Somme:=Somme(T,deb+1,fin)+T[deb]
end;
begin
saisie_n(n,1,50);
Saisie(T,1,n);
Saisie_n(bf,1,n);
Saisie_n(bi,1,bf);
Writeln(Somme(T,bi,bf));
end.
©

64
Somme Matrice : Itérative Somme Matrice : Récursive
uses wincrt;
type
var
T:mat;
l,c:integer;
begin
Repeat
readln(n);
until n in [x..y];
end;
var i,j:integer;
begin
for i:=1 to l do
for j:=1 to c do
end;
Function Somme(T: Mat; l,c:integer):real;
var S:real;
i,j:integer;
begin
S:=0;
for i:=1 to l do
for j:=1 to c do S:=S+T[i,j];
Somme := S;
end;
begin
saisie_n(l,1,50);
saisie_n(c,1,50);
lecture(T,l,c);
Writeln(Somme(T,l,c));
end.
uses wincrt;
type
var
T:Mat;
l,c:integer;
begin
readln(n);
end;
begin
if i <= l then
if j <= c then
begin
write('T[',i,',',j,'] = ');
readln(T[i, j]);
end
end;
Function Somme(T: Mat; l,c,n:integer):real;
begin
if l<> 0 then
begin
if c <> 0 then Somme := T[l,c] +
Somme(T,l,c-1,n)
else Somme:= Somme(T,l-1,n,n);
end;
end;
begin
Saisie_n(l,1,5);
Saisie_n(c,1,5);
Lecture(T,1,1,l,c);
Writeln(Somme(T,l,c,c));
end.
©

65
Les Algorithme Arithmétique
PGCD 1ére Méthode
Méthode Itérative
program PGCD_difference;
uses wincrt;
var A, B: integer;
Procedure saisie_n(Var n : integer);
begin
Repeat
Write('Donner un entier >= 0 : '); readln(n);
until n >=0;
end;
function pgcd (a, b: integer): integer;
begin
Repeat
if a > b then a := a - b;
if b > a then b := b - a;
until a = b;
pgcd := a;
end;
begin
Saisie_n(A); Saisie_n(B);
writeln('Leur pgcd est ', pgcd(A, B));
end.
PGCD 1éme Méthode
Méthode récursive
program PGCD_Difference;
uses wincrt;
var A, B: integer;
begin
If not(n >=0) then Saisie_n(n);
end;
begin
if a > b then pgcd := pgcd(a - b, b)
else
if b > a then pgcd := pgcd(b - a, a)
else pgcd := a;
end;
begin
Saisie_n(A);
Saisie_n(B);
end.
PGCD 3ére Méthode
Méthode Itérative
program PGCD_Euclide;
uses wincrt;
var A, B: integer;
begin
Repeat
until n >=0;
end;
Var x : integer;
begin
Repeat
X:= A mod B;
A:= B;
B:= X;
until B = 0;
PGCD := A;
end;
begin
end.
PGCD 3éme Méthode
Méthode récursive
program PGCD_Euclide;
uses wincrt;
var A, B: integer;
begin
end;
begin
if a mod b = 0 then pgcd := b
else pgcd := pgcd(b, a mod b)
end;
begin
Saisie_n(A);
Saisie_n(B);
end.
©

66
PGCD 2ére Méthode
Méthode Itérative
program PGCD1;
uses wincrt;
var A, B: integer;
begin
Repeat
until n >=0;
end;
Var x : integer;
begin
x:=1;
while a*b <> 0 do
case (a mod 2) + (b mod 2) of
0: begin
x:=x*2;
a:=a div 2;
b:=b div 2;
end;
1: if a mod 2 = 0 then a:=a div 2
else b:=b div 2;
2: if a > b then a:= a-b
else b:= b-a;
end;
if a = 0 then PGCD := b*x
else PGCD := a*x;
end;
begin
end.
©

67
PGCD 2éme Méthode
Méthode récursive
program PGCD1;
uses wincrt;
var A, B: integer;
begin
end;
begin
if a=0 then PGCD:=b
else
if b=0 then PGCD:=a
else
if (a mod 2 = 0) and (b mod 2 = 0) then PGCD := PGCD(a div 2, b div 2) * 2
else
if(a mod 2 = 0) and (b mod 2 <> 0) then PGCD := PGCD(a div 2 , b)
else
if (a mod 2 <> 0) and ( b mod 2 = 0) then PGCD := PGCD(a, b div 2)
else
if (a mod 2 <> 0) and ( b mod 2 <> 0) then
if a > b then PGCD := PGCD(a - b, b)
else PGCD := PGCD(a, b - a);
end;
begin
Saisie_n(A);
Saisie_n(B);
end.
©

68
PPCM
Méthode Itérative
program Calcul_PPCM;
uses wincrt;
var
A, B, max, min: integer;
begin
Repeat
until n >=0;
end;
function ppcm (A,B: integer): integer;
var
Max,Min:integer;
begin
if A > B then begin max:=A; min:=B;end
else begin max:=B; min:=A; end;
while max mod min <> 0 do max := max + (A+B-min);
PPCM := max;
end;
begin
saisie_n(a);
Saisie_n(b);
writeln('Leur ppcm est ', ppcm(A,B));
end.
PPCM
Méthode Récursive
program Calcul_PPCM;
uses wincrt;
var
A, B, max, min: integer;
begin
end;
function ppcm (max,min: integer): integer;
begin
if max mod min = 0 then ppcm := max
else begin max:=max+(A+B-min);
ppcm:=ppcm(max,min); end;
end;
begin
saisie_n(a);
Saisie_n(b);
if A > B then begin max:=A; min:=B;end
else begin max:=B; min:=A; end;
writeln('Leur ppcm est ', ppcm(max,min));
end.
Produit
Méthode Itérative
uses wincrt;
var
n:integer; x: real;
function Produit(n : integer; x:real):real;
var
i:integer;
p:real;
begin
p:=1;
for i := 1 to abs(n) do P:=p*x;
if n >= 0 then produit:=p
else produit:=1/p;
end;
begin
write('N = ');readln(n);
write('X = ');readln(x);
writeln(produit(n,x):4:2);
end.
Produit
Méthode Récursive
uses wincrt;
var
n:integer;
x:real;
function Produit(n : integer;x : real):real;
begin
if n = 0 then Produit:=1
else Produit:=Produit(n-1,x) * x;
end;
begin
write('N = ');readln(n);
write('X = '); readln(x);
if n >= 0 then writeln(Produit(abs(n),x):4:2)
else writeln(1/Produit(abs(n),x):4:2);
end.
©

69
Parfait
Méthode Itérative
uses wincrt;
Var n :integer;
begin
Repeat
Write('Donner un entier >= 0 : ');
readln(n);
until n >=0;
end;
function Parfait(n:integer): integer;
var
i,S:integer;
begin
S:=0;
for i := 1 to n div 2 do
if n mod i = 0 then S:=S+i;
Parfait:=S;
end;
begin
Saisie_n(n);
if n=Parfait(n) then writeln(n,' est un nombre
parfait')
else writeln(n,' n''est pas un nombre parfait');
end.
Parfait
Méthode Récursive
uses wincrt;
Var n :integer;
begin
end;
function Parfait(n,m:integer): integer;
begin
if n = 0 then parfait :=0
else
if n <= m div 2 then
if m mod n = 0 then Parfait:=Parfait(n-1,m)+n
else Parfait := Parfait(n-1,m);
end;
begin
Saisie_n(n);
if n=Parfait(n div 2, n) then writeln(n,' est un
nombre parfait')
else writeln(n,' n''est pas un nombre parfait');
end.
Premier
Méthode Itérative
uses wincrt;
var n:integer;
procedure saisie_n(var n : integer);
begin
repeat Write('Donner un entier > 1 : ');readln(n) until n > 1;
end;
function premier(n : integer):boolean;
var i: integer;
begin
i:=2;
While (n mod i <> 0) and (i <= (n div 2)) do
i := i + 1;
if (n mod i = 0) and (n<>i) then premier := false
else premier := true;
end;
begin
saisie_n(n);
if premier(n) then writeln(n, ' est un nombre premier')
else writeln(n,' n''est pas un nombre premier');
end.
©

70
Premier
Méthode Récursive
uses wincrt;
var n:integer;
begin
Write('Donner un entier > 1 : '); readln(n);
If not(n > 1) then Saisie_n(n);
end;
function premier (n,m: integer): boolean;
begin
if m = 1 then premier := true
else
if (n mod m = 0) and (n<>m) then premier := false
else premier := premier(n,m-1);
end;
begin
saisie_n(n);
if premier(n, n div 2) then writeln(n, ' est un nombre premier')
else writeln(n,' n''est pas un nombre premier');
end.
Premier entre deux bornes
Méthode Itérative
uses wincrt;
var bi,bf:integer;
begin
Repeat
readln(n);
until n in [x..y]; end;
function premier(n : integer):boolean;
var i: integer;
begin
i:=2;
While (n mod i <> 0) and (i <= (n div 2)) do
i := i + 1;
if (n mod i = 0) and (n<>i) then premier := false
else premier := true;
end;
Procedure affichage(bi,bf:integer);
var
n:integer;
begin
for n:= bi to bf do
if premier(n) then writeln(n);end;
begin
saisie_n(bf,2,1000);
Saisie_n(bi,2,bf);
Affichage(bi,bf);
end.
©

71
Premier entre deux bornes
Méthode Récursive
uses wincrt;
var bi,bf:integer;
begin
Write('Donner un entier dans [', x ,',',y, '] : '); readln(n);
If not(n in [x..y]) then Saisie_n(n, x, y); end;
function premier (n,m: integer): boolean;
begin
if m = 1 then premier := true
else
if (n mod m = 0) and (n<>m) then premier := false
else premier := premier(n,m-1); end;
Procedure affichage(bi,bf:integer);
var
n:integer;
begin
if bi <= bf then
begin
if premier(bi, bi div 2) then writeln(bi);
affichage(bi+1,bf);
end;
end;
begin
saisie_n(bf,2,1000);
Saisie_n(bi,2,bf);
Affichage(bi,bf);
end.
Factorielle
Méthode Itérative
program factoriel;
uses wincrt;
var n:integer;
begin
readln(n);
if not(n in [x..y]) then saisie_n(n,x,y); end;
function fact(n:integer):longint;
var i:integer;
f:longint;
begin
f:=1;
for i:=1 to n do
f:=f*i;
fact:=f; end;
begin
saisie_n(n,1,10);
write(n,'!= ',fact(n));
end.
Factorielle
Méthode Récursive
program factoriellee;
uses wincrt;
var
n:integer;
begin
end;
function factorielle(n : integer):longint;
begin
if n = 0 then factorielle:= 1
else factorielle:=factorielle(n-1) * n;
end;
begin
saisie_n(n);
writeln(factorielle(n));
end.
©

72
uses wincrt;
var a,b:real; n:integer;
Procedure saisie_n(Var n : integer;x:integer);
begin
Write('Donner un entier >',x,' : '); readln(n);
If not(n >x) then Saisie_n(n,x);
end;
function C (n, p: integer): integer;
begin
if p > n then C := 0
else
if (p = 0) or (p = n) then C := 1
else
if p = 1 then c:=n
else C := C(n - 1, p - 1) + C(n - 1, p)
end;
function Produit(n : integer;x : real):real;
begin
if n = 0 then Produit:=1
else Produit:=Produit(n-1,x) * x;
end;
function polynome(a,b: real; n: integer):real;
var i:integer; S:real;
begin
s:=0;
for i := 0 to n do
S:= S +C(n,i)*produit(n-i,a)*produit(i,b);
polynome := S;
end;
begin
write('Donner a: ');readln(a);
write('Donner b: ');readln(b);
Saisie_n(n,0);
writeln(a:2:3,' + ',b:2:3,' à la puissance ',n,' =
',Polynome(a,b,n):2:3);
end.
uses wincrt;
var
n:integer;
Procedure saisie_n(Var n : integer;x:integer);
begin
Write('Donner un entier >',x,' : '); readln(n);
If not(n >x) then Saisie_n(n,x);
end;
function C (n, p: integer): integer;
begin
if p > n then C := 0
else
if (p = 0) or (p = n) then C := 1
else
if p = 1 then c:=n
else C := C(n - 1, p - 1) + C(n - 1, p)
end;
function polynome(n: integer):integer;
var
i,S:integer;
begin
s:=0;
for i := 0 to n do
if i mod 2 = 0 then S:= S + C(n,i)
else S:= S - C(n,i);
polynome := S;
end;
begin
Saisie_n(n,0);
writeln(Polynome(n));
end.
Exercice N° 7 page 183
uses wincrt;
var n,m,u:longint;
ch:string;
Function Somme(ch:string):integer;
var
i,S,nbr,e:integer;
begin
S:=0;
for i:=1 to length(ch) do
begin
Val(ch[i],nbr,e);
S:=S+nbr;
end;
Somme:=S;end;
Function divisible(n,m:integer):boolean;
begin
if n mod m = 0 then divisible := true
else divisible:=false;
end;
begin
for m:=1 to 9 do
for u:=1 to 9 do
begin
n:=m*1000+970+u;
str(n,ch);
if (Somme(ch) mod 9 = 0) and
(divisible(n*2,10)) then writeln(n);
end;
end.
©

73
Exercice divisible par 2 :
uses wincrt;
var n:longint;
begin
write('Donne un entier : ');readln(n);
if ((abs(n) mod 10) mod 2 = 0) then writeln(n,' est divisible par 2')
else writeln(n,' n''est pas divisible par 2');
end.
Exercice divisible par 3 :
uses wincrt;
var
n:longint;
function somme_div(n:longint):integer;
var
i,x,e,s:integer;
ch:string;
begin
str(n,ch);
S:=0;
for i :=1 to length(ch) do
begin
val(ch[i],x,e);
S:=S+x;
end;
Somme_div:=s;
end;
begin
write('n = ');readln(n);
if Somme_div(abs(n)) mod 3 = 0 then writeln(n,' est divisible par 3 ')
end.
Exercice divisible par 4:
uses wincrt;
var n:longint;
begin
end;
begin
write('n= ');readln(n);
if divisible(n mod 100, 4) then writeln(n,' est divisible par 4')
end.
©

74
uses wincrt;
var n:longint;
begin
end;
begin
write('n= ');readln(n);
if divisible(n*2,10) then writeln(n,' est divisible par 5')
end.
uses wincrt;
var
n:longint;
var
i,x,e,s:integer;
ch:string;
begin
str(n,ch);
S:=0;
begin
val(ch[i],x,e);
S:=S+x;
end;
Somme_div:=s;
end;
begin
if (Somme_div(abs(n)) mod 3 = 0) and ((n mod 10) mod 2 = 0) then
writeln(n,' est divisible par 6 ')
end.
©

75
uses wincrt;
var n:longint;
function Divisible(n:longint):boolean;
var ch:string; m,p,e:integer;
begin
while n div 100 <> 0 do
begin
str(n,ch);
val(ch[length(ch)],m,e);
delete(ch,length(ch),1);
val(ch,p,e);
n:= p-2*m;
end;
if n mod 7 = 0 then divisible:=true
end;
begin
if divisible(abs(n)) then writeln(n,' est divisible par 7')
end.
uses wincrt;
var
n:longint;
var
i,x,e,s:integer;
ch:string;
begin
str(n,ch);
S:=0;
begin
val(ch[i],x,e);
S:=S+x;
end;
Somme_div:=s;
end;
begin
if Somme_div(abs(n)) mod 9 = 0 then writeln(n,' est divisible par 9 ')
end.
©

76
uses wincrt;
var n:longint;
function Divisible(n:longint):boolean;
var ch:string; m,e,s1,s2,i:integer;
begin
str(n,ch); S1:=0; S2:=0;
for i:=1 to length(ch) do
begin
val(ch[i],m,e);
if i mod 2 = 0 then S1:=S1+m
else S2:=S2+m;
end;
if (S1-S2) mod 11 = 0 then divisible:=true
end;
begin
if divisible(abs(n)) then writeln(n,' est divisible par 11')
end.
Exercice divisible par 2,10,4,5,25
uses wincrt;
var
n:longint;
begin
write('n = '); readln(n);
if (n mod 10) mod 2 = 0 then writeln(n,' est divisible par 2')
if (n mod 10) = 0 then writeln(n,' est divisible par 10')
if (2*n mod 10) = 0 then writeln(n,' est divisible par 5')
end.
©

77
Exercice Facteurs premiers Itérative :
program facteurs_premiers;
uses wincrt;
type Tab = array[1..50] of byte;
var Fact:Tab; n,f:integer;
Procedure saisie_n(Var n : integer; x:integer);
begin
Write('Donner un entier dans > ', x ,' : ');
readln(n);
If not(n > x) then Saisie_n(n, x);
end;
Procedure remplir(var Fact:Tab;var f :
integer;n:integer);
var i:integer;
begin
i:=2; f:=0;
repeat
if n mod i = 0 then
begin
f:=f+1;
fact[f]:=i;
n:= n div i;
end
else i := i + 1;
until n = 1;
end;
Procedure affichage(T:Tab;n: integer);
var i:integer;
begin
for i :=1 to n do
write(T[i]:4);
end;
begin
Saisie_n(n,1);
remplir(Fact,f,n);
affichage(Fact,f);
end.
Exercice Facteurs premiers Récursive :
uses wincrt;
type Tab = array[1..50] of byte;
var Fact:Tab; n,f:integer;
procedure saisie_n(var n : integer;x:integer);
begin
repeat
write('donner un entier dans > ',x,' : ');
readln(n);
until n > x;
end;
Procedure remplir(var Fact:Tab;var f :
integer;i,n:integer);
begin
if n <>1 then
if n mod i = 0 then
begin
f:=f+1;
fact[f]:=i;
remplir(Fact,f,i, n div i);
end
else remplir(Fact,f,i+1,n);
end;
procedure affichage (t:tab; deb, fin:integer);
begin
if deb <= fin then
begin write(T[deb]:4); affichage(t,deb+1, fin);
end;
end;
begin
Saisie_n(n,1); f:=0; remplir(Fact,f,2,n);
affichage(Fact,1,f);
end.
©

78
Exercice Facteurs premiers Itérative sans tableau:
uses wincrt;
var n:integer;
begin
readln(n);
end;
procedure remplir (n:integer);
var i:integer;
begin
i:=2;
repeat
if n mod i=0 then
begin
write(i:4);
n:=n div i;
end
else i:=i+1;
until n=1;
end;
begin
saisie_n (n,1);
remplir(n);
end.
Exercice Facteurs premiers Récursive sans table:
uses wincrt;
var n:integer;
begin
readln(n);
end;
procedure remplir (i,n:integer);
begin
if n<>1 then
if n mod i=0 then
begin
write(i:4);
remplir(i,n div i);
end
else remplir(i+1,n);
end;
begin
saisie_n (n,1);
remplir(2,n);
end.
©

79
Exercice base 10 vers base 2, 8, 16
uses wincrt;
type
tab = array[1..50]of byte;
var
Rest:tab;
n,b,c:word;
procedure saisie_n(var n : word;x:word);
begin
repeat
write('donner un entier dans > ',x,' : '); readln(n);
until n > x;
end;
procedure saisie_b(var b : word);
begin
repeat
write('donner une base dans [2,8,16] : '); readln(b);
until b in [2,8,16];
end;
Procedure remplir(var Rest : tab;var c:word;N,B:word);
begin
c:=0;
Repeat
c:=c+1;
©

80
Rest[c]:=n mod b;
n:= n div b;
until n = 0;
end;
Procedure affichage(T:tab;n:word);
var
i:integer;
begin
for i := c downto 1 do
if rest[i] in [0..9] then write(Rest[i]:4)
else write(chr(ord('A')+ Rest[i] - 10):4);
end;
begin
Saisie_n(n,0);
Saisie_b(b);
remplir(Rest,c,n,b);
Affichage(Rest,c);
end.
Base 10 à l’autre base Récursive :
program base10_base;
uses wincrt;
var
n:integer;
b:byte;
procedure saisie_base(var b : byte);
begin
repeat
write('donner une base dans [2..36] : '); readln(b);
until b in [2..36];
end;
procedure saisie_n(var n : integer;x:integer);
begin
repeat
write('donner un entier dans > ',x,' : '); readln(n);
until n > x;
end;
Procedure affichage(x:byte);
begin
if x in [0..9] then write(x)
else write(chr(ord('A')+ x - 10));
©

81
end;
procedure remplir (n:integer;b:byte);
begin
if n<>0 then
begin
remplir(n div b,b);
affichage(n mod b);
end;
end;
begin
saisie_n(n,0);
saisie_base(b);
remplir(n,b);
end.
Autre base à la base 10 :
program base_base10;
uses wincrt;
type
ch=string[46];
var n:string;
b:byte;
p,s:integer;
procedure saisie_base(var b : byte);
begin
repeat
write('donner une base dans [2..36] : '); readln(b);
until b in [2..36];
end;
procedure base (var ch1:ch;b:byte);
var k:integer;
x:string[1];
begin
if b<=10 then
begin
ch1:='';
for k:=0 to b-1 do
begin str(k,x); ch1:=concat(ch1,x);end;
end
else
©

82
begin
ch1:='0123456789';
for k:=10 to b-1 do
ch1:=concat(ch1,chr(ord('A')+k-10));
end;
writeln(ch1);
end;
function recherche (n:string;ch1:ch):boolean;
var
i:integer;
begin
i:=0;
repeat
i:=i+1;
until (pos(upcase(n[i]),ch1)=0) or(i>length(n));
if i>length(n) then recherche:=true
else recherche:=false;
end;
procedure saisie_ch(var n:string);
var ch1:ch;
begin
base (ch1,b);
repeat
write('donner un nombre dans la base: ');
readln(n);
until recherche (n,ch1);
end;
function puis (b,r:integer):integer;
var i:integer;
begin
p:=1;
for i:= 1 to r do
p:=p*b;
puis:=p;
end;
function conver(b:byte; n:string):integer;
var
i,e:integer;
y:integer;
x:string[1];
begin
s:=0;
for i:=1 to length(n) do
begin
if n[i] in ['0'..'9'] then val(n[i],y,e)
else y:= (ord(upcase(n[i]))-ord('A') + 10);
s:=s+y*puis(b,length(n)-i);
end;
conver:=s;
©

83
end;
begin
saisie_base(b);
saisie_ch(n);
writeln(conver(b,n));
end.
Base 2 vers base 8, 16 :
program test;
uses wincrt;
const
ch1='01';
type
ch=string[46];
chv=string[4];
ch2=string[1];
bits=3..4;
var
n,ph:string;
b:byte;
bit:bits;
k:integer;
v:chv;
procedure saisie_base(var B : byte);
begin
repeat
write('donner une base dans [8,16] : ');
readln(B);
until B in [8,16];
end;
function recherche(n:string):boolean;
var
©

84
i:integer;
begin
i:=0;
repeat
i:=i+1;
until (pos(upcase(n[i]),ch1)=0) or (i > length(n));
if i > length(n) then recherche:=true
end;
procedure saisie_ch(var n : string);
begin
repeat
write('donner un nombre dans la base :');
readln(n);
until Recherche(n);
end;
function puissance (b,r:integer):integer;
begin
if r=0
then puissance:=1
else
puissance:=puissance(b,r-1)*b;
end;
function convert (v:chv):ch2;
var
s,e,x,i:integer;
u:string;
begin
s:=0;
for i:=1 to length (v) do
begin
val(v[i],x,e);
s:=s+x*puissance(2,length(v)-i);
end;
if s in[0..9] then str(s,u)
else u:=chr(ord('a')+s-10);
convert:=u;
end;
{function converssion (n:string;b:byte):string;
begin
if b=8 then bit:=3
else bit:=4;
while length(n) mod bit <>0 do
n:=concat('0',n);
k:=length(n);
ph:='';
repeat
v:=copy(n,k-bit+1,bit);
ph:=concat(convert(v),ph);
k:=k-bit;
©

85
until k=0;
converssion:=ph;
end;}
function converssion (n:string;b:byte):string;
begin
if b=8 then bit:=3
else bit:=4;
while length(n) mod bit <>0 do
n:=concat('0',n);
k:=0;
ph:='';
repeat
v:=copy(n,k+1,bit);
ph:=concat(ph,convert(v));
k:=k+bit;
until k=length(n);
converssion:=ph;
end;
begin
Saisie_ch(n);
saisie_base(b);
write(converssion(n,b));
end.
Base 8, 16 vers base2 :
program test;
uses wincrt;
type
ch=string[46];
ch0=string[4];
var
n,v:string;
b:byte;
ph:string;
u:string;
r:integer;
procedure saisie_base(var B : byte);
begin
repeat
write('donner une base dans [8,16] : ');
readln(B);
until B in [8,16];
end;
procedure base(var ch1:ch;B:byte);
var
k:integer;
x:string[1];
begin
if b <= 10 then
©

86
begin
ch1:='';
for k:=0 to b-1 do begin str(k,x);ch1:=concat(ch1,x); end;
end
else
begin
ch1:='0123456789';
for k:= 10 to b-1 do ch1:=concat(ch1,chr(ord('A')+k-10));
end;
end;
function recherche(n:string;ch1:ch):boolean;
var
i:integer;
begin
i:=0;
repeat
i:=i+1;
until (pos(upcase(n[i]),ch1)=0) or (i > length(n));
if i > length(n) then recherche:=true
end;
procedure saisie_ch(var n : string);
var
ch1:ch;
begin
Base(ch1,B);
repeat
write('donner un nombre dans la base :');
readln(n);
until Recherche(n,ch1);
end;
function convert(c:char;b:byte):ch0;
var j,x,e,r:integer;
v:string[1];
begin
if c in ['0'..'9'] then val(c,x,e)
else x:=ord(upcase(c))-ord('A')+10;
if b=8 then begin
u:='000';
j:=3;
end
else
begin
u:='0000';
j:=4;
end;
repeat
r:=x mod 2;
str(r,v);
u[j]:=v[1];
j:=j-1;
x:=x div 2;
until x=0;
©

87
convert:=u;
end;
function conversion (n:string):string;
var i:integer;
begin
ph:='';
for i:=1 to length(n) do
ph:=concat(ph,convert(n[i],b));
conversion:=ph;
end;
begin
saisie_base(b);
Saisie_ch(n);
write(conversion(n));
end.
©

88
Les Algorithme d’approximation
Calcul de valeurs approchées de constantes connues
Exercice -1-
La racine carrée approchée d’un nombre réel R par la méthode de Newton, définit de la façon
suivante : U0 = R Un+1 = (Un+ R / Un) / 2
Cette suite converge vers R le calcul est arrêté lorsque  R - Un
2
 < e, où e est un réel positif
saisi au clavier.
uses wincrt;
var
e:real;
R:real;
Procedure saisie_r(var R :real);
begin
repeat
Write('Donner un real > 0 :');
readln(R);
until R > 0;
end;
Procedure saisie_e(var e : real);
begin
repeat
Write('Donner e dans[0..0,1] :');
readln(e);
until (e>0) and (e <=0.1);
end;
function racine:real;
var
U0,U:real;
begin
U0:=R;
Repeat
U:=(U0 + R/U0)/2;
U0:=U;
until abs(R-sqr(U)) < e;
racine:=U;
end;
begin
Saisie_r(r);
saisie_e(e);
writeln(racine);
end.
©

89
Exercice -2-
Calculer la racine cubique d’un nombre réel R en utilisant la suite convergente définie par : U0 = 1









)(
21
2
3
1
U
UU
n
R
nn
Cette suite converge vers 3
R le calcul s’arrête lorsque enR U  )( 1
3
, où e est un réel positif
saisi au clavier.
uses wincrt;
var
e:real;
R:real;
Procedure saisie_r(var R :real);
begin
repeat
Write('Donner un real > 0 :');
readln(R);
until R > 0;
end;
Procedure saisie_e(var e : real);
begin
repeat
Write('Donner e dans[0..0,1] :');
readln(e);
until (e>0) and (e <=0.1);
end;
function racine:real;
var
U0,U:real;
begin
U0:=R;
Repeat
U:=(2*U0 + R/sqr(U0))/3;
U0:=U;
until abs(R-sqr(U)*u)< e;
racine:=U;
end;
begin
Saisie_r(r);
saisie_e(e);
writeln(racine);
end.
©

90
1) Algorithme
0) Début Fonction Pi (E : Réel) : Réel
1) I …
2) S2 …
3) Répéter
S1 S 2
S2 ……..
I I + 1
Jusqu’à …
4) Pi …
5) Fin
Exercice -3-
Soit l’expression mathématique suivante :
...*
12
2
*
12
2
*.......*
9
8*
7
8*
7
6*
5
6*
5
4*
3
4*
3
2*
1
2
2 

i
i
i
i
Calculer Pi en utilisant la formule ci-dessus.
Le calcul s’arrête quand la différence entre deux termes consécutifs devient inférieure ou égale à e, où e est un
réel positif saisi au clavier.
La dernière somme calculée est une valeur approchée de Pi.
uses wincrt ;
vare:real ;
procedure saisie (var e:real );
begin
repeat
write ('donner e dans [0..0,1] :') ;
readln(e);
until
(e>0) and (e <=0.1) ;
end;
function pi(e :real):real ;
var
s1,s2 :real ;
i:longint ;
begin
i:=1;
s2:=1;
repeat
s1:=s2;
if i mod 2=0 then s2:=s2*(i/(i+1))
else s2:=s2*((i+1)/i);
i:=i+1;
until abs(2*s2-2*s1)<=e;
writeln(i);
pi:=2*s2; end;
begin
saisie(e);
writeln(pi(0.1));writeln(pi(0.01));writeln(pi(0.00
1)); writeln(pi(0.0001));
end.
©

Exercices pascal tous les chapitres

Exercices pascal tous les chapitres

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (17)

Similaire à Exercices pascal tous les chapitres

Similaire à Exercices pascal tous les chapitres (19)

Dernier

Dernier (20)

Exercices pascal tous les chapitres