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.
Sommaire→Structuration de programmes
