Les tableaux : Quoi et Pourquoi ?

Définition

Les tableaux sont des structures de données statiques.

Une structure de données est une manière d'organiser les données pour les traiter plus facilement (Wikipedia).

Statique désigne la taille fixe : un tableau est d'une taille (nombre de cellules) fixe.

Un tableau (array en anglais) est une structure de données qui consiste en un ensemble d'éléments ordonnés accessibles par leur indice (ou index) (Wikipedia).

Pourquoi utiliser un tableau ?

Un tableau est utilisé lorsque les données à manipuler satisfont les trois conditions suivantes :

1. Nous voulons sauvegarder toutes les données,
2. Nous avons des données de même types,
3. Nous allons appliquer le même traitement sur toutes les données.

Exemple 1 : Utilisation des tableaux recommandée

Supposons que nous voulons saisir les notes de tous les étudiants d'un groupe pour ensuite calculer la moyenne et connaître le min et le max.

Dans ce cas, les trois conditions sons satisfaites :

1. Nous voulons nous rappeler de toutes les notes,
2. Les notes sont toutes de même nature et de même types,
3. Le calcul de la moyenne et la recherche du min et de max nécessitent des traitement identiques sur chaque notes (addition et comparaison)

Exemple 2 : Utilisation des tableaux non recommandées

Supposons que nous avons les données suivantes : la taille (en m) d'une personne, son poids (en kg), son rythme cardiaque, sa tension et sa température au moment de la consultation médicale.

Ces données sont toutes des nombres (entiers ou réels). Nous voulons les sauvegarder dans le dossier médical du patient. Néanmoins, ces données ne peuvent pas subir des traitements identiques : la somme de la taille et du poids, la comparaison entre le poids et tension ou la multiplication de la tempértaure et du rythme cardiaque sont toutes des opérations qui n'ont aucun sens.

Ainsi, l'utilisation des tableaux n'est pas recommandée dans ce cas.

Déclaration et code : solution du premier exemple :

Program PremierExempleTableau;

Const
 N = 10;
 
Var 
 notes : Array [1..N] of Real; {toutes les données sont de même type, 
          la taille est fixe}
 i : Integer; {L'indice pour pouvoir accéder aux différentes valeurs}
 
 somme, max, min : Real;

Begin
 
 For i:= 1 to N Do
 Begin
  WriteLn('Donnez la ', i, 'ème valeur :');
  ReadLn(notes[i]);
 End;
 
 somme := notes[1];
 min := notes[1];
 max := notes[1];
 
 For i:= 2 to N Do
 Begin
  somme := somme + notes[i];
  
  If (notes[i] < min) Then
   min := notes[i];
   
  If (notes[i] > max) Then
   max := notes[i];
 End;
 
 WriteLn('Les notes saisies sont : ');
 For i:= 1 to N Do
 Begin
  Writeln('notes[', i, '] = ', notes[i]:2:2);
 End;
 
 WriteLn('La somme de ces notes est ', somme:2:2);
 WriteLn('La moyenne de ces notes est ', (somme / N):2:2);
 WriteLn('La plus grande note est ', max:2:2);
 WriteLn('La plus petite note est ', min:2:2);
 
End.

Effet de bord (variables) Démo

L'effet de bord (effet secondaire) pour les variables surgit lorsque la variable prend une valeur illogique. Cet effet peut figurer aussi avec les fonctions. (Pour un peu de détail : ici)

Pour les variables, la cause principale est la limite imposée par la taille de la variable.

Cet article vise à donner un exemple sur cet effet.

Démo

Pour démontrer cet effet, nous allons essayer de calculer le factoriel (n!) de quelques nombres. Cette fonction donne, rapidement, des valeurs très grandes.

En Pascal :

Program EffetDeBord;

Var
 i, factoriel : Integer;

Begin
 
 factoriel := 1;
 
 For i := 1 to 10 Do
 Begin
  factoriel := factoriel * i;
  WriteLn(i, '! = ', factoriel);
 End;
 
End.

L'exécution de ce code :

Nous pouvons voir que le calcul commence à donner des valeurs érronées et illogiques des (8!). En effet, le type Integer ne peut pas contenir des valeurs en dehors de l'intervalle : -32768 .. 32767.

Ce phénomène peut être réduit si on utilise des variables "plus grandes" comme le Longint (Long Integer) :

Program EffetDeBord;

Var
 i, factoriel : LongInt;

Begin
 
 factoriel := 1;
 
 For i := 1 to 10 Do
 Begin
  factoriel := factoriel * i;
  WriteLn(i, '! = ', factoriel);
 End;
 
End.

Ce code donne des valeurs plus correctes :

Un entier de type LongInt peut stocker des données de l'intervalle : -2147483648 .. 2147483647.

Pour plus d'information sur la taille des types de données, il faut consulter la documentation officielle du compilateur que vous utilisez. Par exemple :

Turbo Pascal : (ici) 
Free Pascal : (ici)

Un peu de pratique avec les boucles : calcul du cosinus

Enoncé
Ecrire le programme qui calcule la valeur du sinus grâce au développement limité suivant :

(source)
Solution
Dans cet exemple, j'ai présenté un problème très simiaire. On suit le même mode de raisonnement et on utilise l'écriture sous forme de série comme suit :

Le code Pascal sera ainsi :

Program CalculCosinus;

Var
 i, n, signe, factoriel : Integer;
 x, cosinus, puissancex : Real;

Begin
 
 WriteLn('Donnez le x pour cacluler cos(x) :');
 ReadLn(x);
 WriteLn('Donnez n qui désigne ma précision du calcul :');
 ReadLn(n);
 
 signe := 1;
 factoriel := 1;
 puissancex := 1;
 cosinus := 0;
 
 For i:= 1 to n Do
 Begin
  cosinus := cosinus + (signe * puissancex) / factoriel;
  WriteLn(signe, ' ', puissancex, ' ', factoriel, ' ', cosinus);
  signe := signe * -1;
  puissancex := puissancex * x * x;
  factoriel := factoriel * (2 * i - 1) * (2 * i);
  
 End;
 
 WriteLn('Valeur calculée par cet algorithme : ', cosinus:1:2);
 WriteLn('Valeur calculée par l''API de pascal : ', cos(x):1:2);
 
End.

Dans ce code comme le précédent, l'effet de bord est présent.

Un peu de pratique avec les boucles : calcul du sinus

Enoncé
Ecrire le programme qui calcule le sinus en utilisant le développement limité suivant :

(source)
Solution
Un autre exercice classique pour pratiquer avec les boucles.

L'astuce est simple : il ne faut pas penser à chaque élément d'une manière indépendant; il faut le baser sur l'élément précédent. En d'autres termes, pensez à utiliser l'écriture série de cette formule :

Ainsi, l'objectif est de calculer les éléments (les termes) de la sommes l'un après l'autre en se basant sur l'élément précédent.

Le code en Pascal sera :

Program CalculSinus;

Var
 i, n, signe, factoriel : Integer;
 x, sinus, puissancex : Real;

Begin
 
 WriteLn('Donnez le x pour cacluler sin(x) :');
 ReadLn(x);
 WriteLn('Donnez n qui désigne la précision du calcul :');
 ReadLn(n);
 
 signe := 1;
 factoriel := 1;
 puissancex := x;
 sinus := 0;
 
 For i:= 1 to n Do
 Begin
  sinus := sinus + (signe * puissancex) / factoriel;
  signe := signe * -1;
  puissancex := puissancex * x * x;
  factoriel := factoriel * (2 * i) * (2 * i + 1);
 End;
 WriteLn('Valeur calculée par cet algorithme : ', sinus:1:2);
 WriteLn('Valeur calculée par l''API de pascal : ', sin(x):1:2);
 
End.

Pour les deux exemples, j'ai donné 4 comme précision. Cela m'évite un effet de bord à cause de valeur 11! (11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1) si je donne 5 comme précision. Evidemment, toute valeur supérieure à 5 provoquera le même problème.