On souhaite écrire le sous-programme GenereTabInt (). Celui-ci doit générer un tableau de N entiers aléatoires distincts dans [1..M] (M > N). Dans cet exercice, à chaque itération, on va générer un nombre aléatoire, que l’on va ranger ou non dans le tableau. L’algorithme de haut niveau est le suivant :
[Algo]
…
tant_que (Nb < N)
faire
GenererEntierAleatoire;
si (LEntierAleatoireNAppartientPasAuTableau)
StockerLEntierAleatoireDansTabInt;
fsi
ffaire
…
[/Algo]

Ecrire l’algorithme qui teste GenereTabInt ().

[Algo]
fonction SaisirEntierSupX (Invite : in string, MsgErr : in string, X : in entier_naturel) renvoie entier_naturel
debut
declarer N : entier_naturel;
boucle
afficher (Invite);
saisir(N);
si (N > X) sortie;
afficher (MsgErr);
ligne_suivante;
fboucle
renvoie N;
fin

fonction find (Val : in entier, TabInt : in tableau_de entier) renvoie entier_naturel
debut
allonger (TabInt, 1);
TabInt [taille (TabInt) – 1] <- Val;

declarer Pos : entier_naturel;
Pos <- 0;
tant_que (TabInt[Pos] ne_vaut_pas Val)
faire
Pos <- Pos + 1;
ffaire
renvoie Pos;
fin

procedure AfficheTabInt (TabInt : in tableau_de entier, Sep : in caractere, NbParLigne : in entier_naturel)
debut

//cpt designe le nombre d’affichage déjà effectué
declarer cpt :entier_naturel;
cpt <- 0;

pour (i variant_de 0 a taille(TabInt) – 1)
faire

afficher (TabInt [i]);
cpt <- cpt + 1;
si (modulo (cpt, NbParLigne) vaut 0)
ligne_suivante;
sinon
afficher (Sep);
fsi
ffaire
fin

procedure GenereTabInt (TabInt : in_out tableau_de entier, M : in entier)
debut
declarer Nb : entier_naturel;
Nb <- 0;
tant_que (Nb < taille (TabInt))
faire
declarer Alea : entier_naturel;
Alea <- Rand (1, M);
declarer Pos : entier_naturel;
Pos <- 0;
tant_que (Pos < Nb ET_ALORS TabInt[Pos] ne_vaut_pas Alea)
faire
Pos <- Pos + 1;
ffaire
si (Pos vaut Nb)
TabInt [Nb] <- Alea;
Nb <- Nb + 1;
fsi
ffaire
fin

algorithme TestDeGenereTabInt
debut
declarer N : entier_naturel;
afficher ("entrer la taille du tableau : ");
saisir (N);

declarer TabInts : tableau_de N entier;

declarer M : entier_naturel;
M <- SaisirEntierSupX ("entrer la valeur maximale du tableau : ", "Plus grand que la taille du tableau svp …", N);

GenereTabInt (TabInts, M);

AfficheTabInt (TabInts, ‘\t’, 10);
ligne_suivante;
fin[/Algo]

On souhaite écrire le sous-programme GenereTabInt (). Celui-ci doit générer un tableau de N entiers aléatoires distincts dans [1..M] (M vaut N).

Le but de cet exercice est d’afficher un tableau de N éléments. Pour cela :

1. écrire la procédure AfficheTabInt () qui affiche tous les éléments du tableau d’entiers qui lui est passé en paramètre. Tous les éléments sont affichés suivis d’un espace ;
2. écrire un algorithme qui :
   1. saisit le nombre d’éléments (N) du tableau ;
   2. déclare le tableau (N entiers) ;
   3. initialise le tableau avec des valeurs saisies au clavier ;
   4. affiche le tableau à l’aide de la procédure AfficheTabInt ().

[Algo]
procedure AfficheTabInt (TabInt : in tableau_de entier)
debut
pour (i variant_de 0 a taille(TabInt) – 1)
faire
afficher (TabInt [i], ” “);
ffaire
ligne_suivante;
fin

algorithme UtilisationDeAfficheTabInt
debut
declarer N : entier_naturel;
afficher (“entrer la taille du tableau : “);
saisir (N);

declarer TabInts : tableau_de N entier;

pour (i variant_de 0 a N – 1)
faire
afficher (“entrer la “, i, “eme valeur du tableau : “);
//saisir (TabInts [i]);
declarer Val : entier;
saisir (Val);
TabInts [i] <- Val;
ffaire

AfficheTabInt (TabInts);
fin
[/Algo]

Ecrire la procédure GenereTabInt () de profil
[Algo]procedure GenereTabInt (TabInt : out tableau_de entier, N : in entier_naturel);[/Algo]
Cette procédure doit :

1. redimensionner TabInt à N;
2. saisir, un par un, les N éléments de TabInt.

Réécrire l’algorithme de l’exercice 1 en utilisant cette procédure.

[Algo]
procedure GenereTabInt (TabInt : out tableau_de entier, N : in entier_naturel)
debut
redimensionner (TabInt, N);

pour (i variant_de 0 a N – 1)
faire
afficher (“entrer la “, i, “eme valeur du tableau : “);
saisir (TabInt [i]);
/*declarer Val : entier;
saisir (Val);
TabInt [i] <- Val;*/
ffaire
fin

procedure AfficheTabInt (TabInt : in tableau_de entier)
debut
pour (i variant_de 0 a taille(TabInt) – 1)
faire
afficher (TabInt [i], ” “);
ffaire
ligne_suivante;
fin

algorithme UtilisationDeAfficheTabIntEtDeGenereTabInt
debut
declarer N : entier_naturel;
afficher (“entrer la taille du tableau : “);
saisir (N);

declarer TabInts : tableau_de entier;

GenereTabInt (TabInts, N);

AfficheTabInt (TabInts);
fin
[/Algo]

Effectuer le même travail que dans l’exercice 2, en transformant la procédure GenereTabInt () en fonction, puis en réécrivant l’algorithme de l’exercice 1 pour qu’il utilise cette fonction.

[Algo]
fonction GenereTabInt (N : in entier_naturel) renvoie tableau_de entier
debut

declarer TabInt : tableau_de N entier;

pour (i variant_de 0 a N – 1)
faire
afficher (“entrer la “, i, “eme valeur du tableau : “);
//saisir (TabInt [i]);
declarer Val : entier;
saisir (Val);
TabInt [i] <- Val;
ffaire
renvoie TabInt;
fin

procedure AfficheTabInt (TabInt : in tableau_de entier)
debut
pour (i variant_de 0 a taille(TabInt) – 1)
faire
afficher (TabInt [i], ” “);
ffaire
ligne_suivante;
fin

algorithme UtilisationDeAfficheTabIntEtDeGenereTabInt
debut
declarer N : entier_naturel;
afficher (“entrer la taille du tableau : “);
saisir (N);

declarer TabInts : tableau_de entier;

TabInts <- GenereTabInt (N);

AfficheTabInt (TabInts);
fin
[/Algo]

Effectuer le même travail que dans l’exercice 3, en transformant la fonction GenereTabInt () en procédure ayant un unique paramètre donné-résultat (TabInt), puis en réécrivant l’algorithme de l’exercice 1 pour qu’il utilise cette procédure.