
Ecrire une fonction qui retourne la factorielle d'un nombre.
Solution : Voir le fichier Facto.pas
Facto.pas
Sélectionnez
program
facto;
uses
crt;
function
factorielle(n: integer
): longint
;
var
fac: longint
;
begin
fac := 1
;
while
(n > 1
) do
begin
fac := fac * n;
n := n - 1
;
end
;
factorielle := fac;
end
;
var
n: integer
;
begin
clrscr;
writeln('
Entrez
la
valeur
de
n
'
);
readln(n);
writeln('
n!
=
'
, factorielle(n));
readln;
end
.
Remarque :
- Le type de retour de la fonction est Longint (entier long) pour nous permettre de
calculer la factorielle de nombres supérieurs à 8. En effet, les entiers étant codés sur 16 bits, ils
sont compris entre -32768 et 32767, or 8! = 40320, il y'a donc débordement et nous obtenons une
valeur négative qui est réalité -32768 + (40320 - 32767) - 1 soit -25216 (en fait, 32767+1 = -32768
d'après l'arithmétique des entiers signés).
Déduire de la solution précédente, une fonction qui permet le calcul de la combinaison de p
dans q définie par : Comb(p, q)=q!/(p!*(q-p)!) ensuite construire le triangle de Pascal
en prenant en entrée le nombre de lignes à afficher.
Solution : Voir le fichier Tpascal.pas
Tpascal.pas
Sélectionnez
program
trianglepascal;
uses
crt;
function
factorielle(n: integer
): longint
;
var
fac: longint
;
begin
fac := 1
;
while
(n > 1
) do
begin
fac := fac * n;
n := n - 1
;
end
;
factorielle := fac;
end
;
function
combinaison(p: integer
; q: integer
): longint
;
begin
combinaison := factorielle(q) div
(factorielle(p) * factorielle(q - p));
end
;
var
n: integer
;
p, q: integer
;
begin
clrscr;
write
('
Entrez
le
nombre
de
ligne
du
triangle
de
Pascal
a
afficher
:
'
);
readln(n);
for
q := 0
to
n do
begin
p := 0
;
while
(p <= q) do
begin
write
(combinaison(p, q): 7
);
p := p + 1
;
end
;
writeln;
end
;
readln;
end
.
Ecrire une fonction qui retourne x^y (x à la puissance y).
Solution : Voir le fichier Power1.pas
Power1.pas
Sélectionnez
program
powerxy;
uses
crt;
function
power(x: integer
; y: integer
): longint
;
var
i: integer
;
p: longint
;
begin
p := 1
;
for
i := 1
to
y do
p := p * x;
power := p;
end
;
begin
end
.
Utiliser cette fonction pour effectuer la conversion de binaire à décimal.
Exemple : 10110 = 0*2^0 + 1*2^1 + 1*2^2 + 0*2^3 + 1*2^4 = 2+4+16 = 22
Solution : Voir le fichier Power2.pas
Power2.pas
Sélectionnez
program
powerxy;
uses
crt;
function
power(x: integer
; y: integer
): longint
;
var
i: integer
;
p: longint
;
begin
p := 1
;
for
i := 1
to
y do
p := p * x;
power := p;
end
;
var
nombre: integer
;
i: integer
;
r: integer
;
valeur: longint
;
begin
clrscr;
i := 0
;
valeur := 0
;
write
('
Entrez
le
nombre
codé
en
binaire
:
'
);
readln(nombre);
while
(nombre <> 0
) do
begin
r := nombre mod
10
;
if
(r = 1
) then
valeur := valeur + power(2
, i);
i := i + 1
;
nombre := nombre div
10
;
end
;
writeln('
Le
nombre
vaut
'
, valeur, '
en
decimal
'
);
readln;
end
.
Réutiliser la fonction Power et écrire une fonction Int2Bin(Value: Integer): string qui
convertit l'entier en paramètre en binaire. Le type de retour de la fonction est une chaîne de
caractère, c'est-à-dire un tableau de caractères et chacun de ses caractères contiendra le bit.
Préréquis : Consultez l'aide sur la fonction Ord.
Solution : Voir le fichier Numcode.pas
Numcode.pas
Sélectionnez
program
numcode;
uses
crt;
type
string8 = string
[8
];
function
byte2bin(value: byte
): string8;
var
s: string8;
i: integer
;
begin
s[0
] := #
8
;
for
i := 0
to
7
do
begin
s[8
- i] := Char
(((value shr
i) and
1
) + Ord('
0
'
));
end
;
byte2bin := s;
end
;
function
power2(i: integer
): integer
;
var
j: integer
;
pro: integer
;
begin
pro := 1
;
for
j := 1
to
i do
begin
pro := pro * 2
;
end
;
power2 := pro;
end
;
function
int2bin(value: integer
): string
;
var
i: integer
;
j: integer
;
begin
i := 0
;
while
(value div
power2(i)) <> 0
do
i := i + 1
; int2bin[0
] := Chr(i);
for
j := 0
to
i - 1
do
begin
int2bin[i - j] := Char
(((value shr
j) and
1
) + Ord('
0
'
));
end
;
end
;
var
i: integer
;
value: integer
;
begin
clrscr;
writeln(int2bin(256
));
readln;
end
.
Commentaire :
- La structure des chaînes de caractères est assez simple. Ce sont en fait des tableaux
indexés de 0 à n, n étant la taille réelle du tableau. Seulement, le premier
octet est reservé pour stocker le nombre de caractère de la chaîne, soit donc n-1 espaces
disponibles.