Bonjour visiteur!

Rechercher

Les dernières News

Derniers articles

Connexion à Eduroam avec l'iphone
Mindstorm: Reconnaissance des couleurs
Programmation fonctionnelle en OCaml
TDs de programmation élémentaire (2008)
Algorithmique
Algèbre 1
Installer Lejos 0.6 pour Mindstorm NXT (version obsolète)
Le langage C

Liens intéressants

UPVD
Polétudiant
Energie Citoyenne

Article de la catégorie Informatique

Historique pdf

Convertir en PDF

TDs de programmation élémentaire (2008)

Les partielles se rapprochant de plus en plus, je me décide à mettre mon travail sur ce merveilleux wiki.

ça vaut ce que ça vaut bien sûr. On ne peut pas dire que je me sois appliqué pour la présentation. Mais tous ces programmes marchent à la compilation donc je pense que ça mérite quand même le coup d'œil.

NDR: Pour pouvoir compiler ces TDs, veuillez utiliser le paquetage ES_simples. (Placez le paquetage compilé dans le même dossier où vous compilerez vos programmes.)

TD N°1:

Exercice 2

Utiliser ES Simples pour réaliser les traitements suivants.
1. Afficher sur une même ligne,
(a) tous les caractères ;
(b) tous les caractères définis dans le (sous-)type ISO 646 de la librairie Ada.Characters.Handling.

with Es_Simples, Ada.Characters.Handling;

use Es_Simples, Ada.Characters.Handling;



procedure Exo2_1 is



begin

   --(a)

   for I in Character'range loop

      afficher(I);

   end loop;

   

   Nouvelle_Ligne_D_Affichage;

   

   --(b)

   for I in Iso_646'range loop

      afficher(I);

   end loop;

   

end Exo2_1;

2. Lire au clavier deux valeurs booléennes puis afficher leur négation.

with Es_Simples;

use Es_Simples;



procedure Exo2_2 is

   T,F:Boolean;

   

begin

   Afficher("tapez true: ");Lire(T);

   Afficher("tapez false: ");Lire(F);

   

   Nouvelle_Ligne_D_Affichage;

   

   Afficher("negation de ");

   Afficher(T);

   Afficher(" = ");

   Afficher(not T);

   

   Nouvelle_Ligne_D_Affichage;

   

   Afficher("negation de ");

   Afficher(F);

   Afficher(" = ");

   Afficher(not F);

   

end Exo2_2;

3. (a) Lire 5 entiers et les afficher, d’abord sur la même ligne, puis sur 5 lignes successives.
(b) Afficher la somme Somme et le produit Produit de ces 5 entiers.
(c) Lire 3 flottants puis afficher la somme Somme et le produit Produit de ces 3 flottants.
Que se passe-t-il ? Que faut-il faire ?

with Es_Simples;

use Es_Simples;



procedure Exo2_3 is

   A,B,C,D,E,somme,produit:Integer;

   X,Y,Z,somme_f,produit_f:Float;

   

begin

   

   --(a)

   Afficher("A= ");Lire(A);

   Afficher("B= ");Lire(B);

   Afficher("C= ");Lire(C);

   Afficher("D= ");Lire(D);

   Afficher("E= ");Lire(E);

   

   Nouvelle_Ligne_D_Affichage;

   

   Afficher(A);

   Afficher(B);

   Afficher(C);

   Afficher(D);

   Afficher(E);

   

   Nouvelle_Ligne_D_Affichage;

   

   Afficher(A);Nouvelle_Ligne_D_Affichage;

   Afficher(B);Nouvelle_Ligne_D_Affichage;

   Afficher(C);Nouvelle_Ligne_D_Affichage;

   Afficher(D);Nouvelle_Ligne_D_Affichage;

   Afficher(E);

   

   Nouvelle_Ligne_D_Affichage;

   

   --(b)

   Somme:=A+B+C+D+E;

   Produit:=A*B*C*D*E;

   

   Afficher("somme =");

   Afficher(Somme);

   Nouvelle_Ligne_D_Affichage;

   Afficher("produit =");

   Afficher(Produit);

   Nouvelle_Ligne_D_Affichage;

   

   --(c)

   Afficher("X= ");Lire(X);

   Afficher("Y= ");Lire(Y);

   Afficher("Z= ");Lire(Z);

   

   Somme_F:=X+Y+Z;

   Produit_F:=X*Y*Z;

   

   Afficher("somme =");

   Afficher(Somme_f);

   Nouvelle_Ligne_D_Affichage;

   Afficher("produit =");

   Afficher(Produit_F);

   

end exo2_3;

Exercice 3

Écrire les procédures qui réalisent les traitements suivants.
1. Permuter deux valeurs booléennes dont les valeurs sont fixées dans les déclarations.
2. Permuter deux valeurs booléennes dont les valeurs sont entrées au clavier par l’utilisateur.

NDR: Je n'ai fais que le 2. par flemmardise. Si vous le comprenez, vous n'avez pas besoin d'explication supplémentaire pour le 1. .

with Es_Simples;

use Es_Simples;



procedure Exo3 is

   T,F,Temp:Boolean;

   

begin

   

   Afficher("ecrire true (t): ");Lire(T);

   Afficher("ecrire false (f): ");Lire(F);

   

   Temp:=T;

   T:=F;

   F:=Temp;

   

   Afficher("apres echange t = ");Afficher(T);

   nouvelle_ligne_d_affichage;

   Afficher("f = ");Afficher(F);

   

end exo3;

Exercice 4

Quels sont les attributs de valeurs de type Boolean ? Écrire la procédure qui réalise le
traitement suivant.
– Afficher le résultats de ces attributs avec, si besoin, deux constantes V et F valant respectivement
True et False.

with Es_Simples;

use Es_Simples;



procedure Exo4 is

   V:Boolean:=True;

   F:Boolean:=False;

   

begin

   Afficher("premier ");Afficher(Boolean'First);Nouvelle_Ligne_D_Affichage;

   Afficher("dernier ");Afficher(Boolean'Last);Nouvelle_Ligne_D_Affichage;

   Afficher("bits occupes "); Afficher(Boolean'Size);Nouvelle_Ligne_D_Affichage;

   Afficher("longueur max "); Afficher(Boolean'Width);Nouvelle_Ligne_D_Affichage;

   Afficher("suivant de " &

      Boolean'Image(F) &

         " = "); Afficher(Boolean'Succ(F));Nouvelle_Ligne_D_Affichage;

   Afficher ("precedant de " &

      Boolean'Image(V) &

         " = "); Afficher(Boolean'Pred(V));Nouvelle_Ligne_D_Affichage;

      

   Nouvelle_Ligne_D_Affichage;

   

   for B in Boolean'range loop

      Afficher("pour" &

         Boolean'Image(B) &

         " : ");nouvelle_ligne_d_affichage;

      Afficher("position ");Afficher(Boolean'Pos(B));Nouvelle_Ligne_D_Affichage;

      Afficher("bits occupes "); Afficher(B'Size);Nouvelle_Ligne_D_Affichage;

   end loop;

   

   for I in 0..1 loop

      Afficher("si la position du booleen est" &

         Integer'Image(I) &

         " alors c'est ");

      Afficher(Boolean'Val(I));

      nouvelle_ligne_d_affichage;

   end loop;

end Exo4;

Exercice 5

Écrire la procédure qui réalise le traitement suivant.
– Afficher les tables de vérité de tous les opérateurs booléens.

with Es_Simples;

use Es_Simples;



procedure Exo5 is

   

begin

   

   Afficher("A       B      nonA    nonB    AouB    AetB    AxouB");

   nouvelle_ligne_d_affichage;

   for A in reverse Boolean'range loop

      for B in reverse Boolean'range loop

         Afficher(boolean'pos(A),0);

         Afficher(boolean'pos(B),8);

         Afficher(Boolean'Pos(not A),8);

         Afficher(boolean'pos(not B),8);

         afficher(boolean'pos(A or B),8);

         Afficher(boolean'pos(A and B),8);

         Afficher(boolean'pos(A xor B),8);Nouvelle_Ligne_D_Affichage;

      end loop;

   end loop;

end Exo5;

TD N°2:

Exercice 1

1. Permuter deux valeurs entières.
2. Permuter les valeurs de deux variables entières arbitrairement choisies par l’utilisateur.

NDR: voir la précédente

with Es_Simples;

use Es_Simples;



--permuter deux valeurs entières

procedure Exo1 is

   M,N,Temp:Integer;

   -- m et n sont les deux variables qu'on veut échanger

   -- on prend temp comme variable vide

   

begin

   

   Afficher("avant l'echange, on a: ");

   Nouvelle_Ligne_D_Affichage; -- on saute une ligne dans le programme

   Afficher("M= ");Lire(M); -- On rentre M au clavier

   Afficher("N= ");Lire(N); -- On rentre N au clavier

   

   -- debut de l'echange

   

   Temp:=M; -- On met la valeur de M dans la variable vide

   M:=N; -- la valeur de N dans M qui est vide

   N:=Temp; -- la valeur de Temp dans N qui est vide

      

   -- M et N sont echanges

   

   Afficher("apres l'echange on a: ");

   Nouvelle_Ligne_D_Affichage;

   Afficher("M= " & integer'image(M));

   Nouvelle_Ligne_D_Affichage;

   Afficher("N= " & integer'image(N));

   

end Exo1;

Exercice 2

Calculer la table de multiplication (de 1 à 10) d’un entier arbitrairement choisi par l’utilisateur.

with Es_Simples;

use Es_Simples;



--table de multiplication d'un entier

procedure Exo2 is

   X,Y:Integer;

   

begin

   Afficher("Rentrez un nombre entier: ");Lire(X);

   

   for I in 0..10 loop -- pour i variant de 0 a 10

      Y:=I*X;

      Afficher(Integer'Image(I) & 

         " * " & 

         Integer'Image(X) & 

         " = " & 

         Integer'Image(Y));

         

      Nouvelle_Ligne_D_Affichage;

      

   end loop;

   

end exo2;

Exercice 3

1. Calculer la division euclidienne de deux variables entières arbitrairement choisies par l’utilisateur.

with Es_Simples;

use Es_Simples;



procedure Exo3_3 is

   I,J,N,f1,f2,f3:Integer;

   

begin

   Afficher("rentrez trois valeurs entieres:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("I= ");Lire(I);

   Afficher("J= ");Lire(J);

   Afficher("N= ");Lire(N);

   

   F1:=(I/J)*J+I rem J;

   Afficher("(" & 

      Integer'Image(I) & 

      " /" & 

      Integer'Image(J) & 

      " ) *" & 

      Integer'Image(J) & 

      " +" & 

      Integer'Image(I) & 

      " rem" & 

      Integer'Image(J) & 

      " =" & 

      Integer'Image(F1));

   

   Nouvelle_Ligne_D_Affichage;

   

   if F1=I then

      Afficher("(I/J)*J+I rem J est egal a I");

   else Afficher("(I/J)*J+I rem J(I/J)*J+I rem J est different de I");

   end if;

   

   Nouvelle_Ligne_D_Affichage(2);

   

   F2:=(I+J) mod N;

   F3:=(I mod N + J mod N) mod N;

   

   Afficher("(" & 

      Integer'Image(I) & 

      " +" & 

      Integer'Image(J) & 

      " ) mod" & 

      Integer'Image(N) & 

      " =" & 

      Integer'Image(F2));

      

   Nouvelle_Ligne_D_Affichage;

   

   Afficher("(" & 

      Integer'Image(I) & 

      " mod" & 

      Integer'Image(N) & 

      " +" & Integer'Image(J) & 

      " mod" & 

      Integer'Image(N) & 

      " ) mod" & 

      Integer'Image(N) & 

      " =" & 

      Integer'Image(F3));

   

   Nouvelle_Ligne_D_Affichage;

   

   if F2=F3 then

      Afficher("(I+J) mod N est egal a (I mod N + J mod N) mod N");

   else Afficher("(I+J) mod N est different de (I mod N + J mod N) mod N");

   end if;

   

end exo3_3;

2. Calculer les résultats des opérateurs entiers rem et mod sur deux valeurs arbitrairement choisies
par l’utilisateur. On comparera en particulier les résultats obtenus pour des variables de signe
différent.

with Es_Simples;

use Es_Simples;



procedure Exo3_2 is

   Modulo,Reste,X,Y:Integer;

   

begin

   Afficher("Donner x= ");Lire(X);

   Afficher("donner y= ");Lire(Y);

   

   Modulo:=X mod Y;

   Reste:=X rem Y;

   

   Afficher("le modulo de x et y est " & Integer'Image(Modulo));

   nouvelle_ligne_d_affichage;

   Afficher("le reste de x et y est " & Integer'Image(Reste));

end Exo3_2;

3. Vérifier que les deux formules suivantes sont satisfaites pour I,J et N trois valeurs entières.
(a) (I/J)*J + I rem J = I
(b) (I+J) mod N = (I mod N + J mod N) mod N

with Es_Simples;

use Es_Simples;



procedure Exo3 is

   X,Y,Q,R:Integer;

   --x divise y, q est le quotient, r est le reste

   

begin

   Afficher("x divise y, rentrez x= ");Lire(X);

   Afficher("rentrez y= ");Lire(Y);

   

   Q:=X/Y;

   R:=X-Q*Y;

   

   Afficher("le quotient est " & Integer'Image(Q));

   Afficher("le reste est " & Integer'Image(R));

end Exo3;

Exercice 4

Permuter les valeurs de deux variables flottantes arbitrairement choisies par l’utilisateur.

NDR: voir la précédente

with Es_Simples;

use Es_Simples;



procedure Exo4 is

   M,N,Temp:float;

   

begin

   

   Afficher("avant l'echange, on a: ");

   Nouvelle_Ligne_D_Affichage; 

   Afficher("flottant M= ");Lire(M); 

   Afficher("flottant N= ");Lire(N); 

   

   -- debut de l'echange

   

   Temp:=M; 

   M:=N; 

   N:=Temp; 

      

   -- M et N sont echanges

   

   Afficher("apres l'echange on a: ");

   Nouvelle_Ligne_D_Affichage;

   Afficher("M= " & float'image(M));

   Nouvelle_Ligne_D_Affichage;

   Afficher("N= " & Float'Image(N));

   

end exo4;

Exercice 5

1. Calculer la longueur de l’hypoténuse d’un triangle rectangle pour des longueurs des deux cˆot´es
de l’angle droit arbitrairement choisies par l’utilisateur.

with Es_Simples, ada.Numerics.Elementary_Functions;

use Es_Simples, ada.Numerics.Elementary_Functions;



procedure Exo5 is

   Hyp,L1,L2:Float;

   

begin

   afficher("donnez l1 et l2 les deux longueurs d'un triangle rectangle adjacentes a l'angle droit");

   nouvelle_ligne_d_affichage;

   Afficher("l1= "); Lire(L1);

   Afficher("l2= "); Lire(L2);

   

   Hyp:= Sqrt(L1 ** 2.0 + L2 ** 2.0);

   

   Afficher("L'hypothenuse du triangle rectangle est: " & Float'Image(Hyp));

end Exo5;

2. Calculer le périmètre du cercle et l’aire du disque pour un rayon R arbitrairement choisi par
l’utilisateur.

with Es_Simples, ada.Numerics, ada.Numerics.Elementary_Functions;

use Es_Simples, ada.Numerics, ada.Numerics.Elementary_Functions;



procedure Exo5_2 is

   R,Per,Air:Float;

   

begin

   Afficher("Donnez le rayon du cercle: ");

   Lire(R);

   

   Per:= 2.0 * Pi * R;

   Air:= Pi * R ** 2.0;

   

   Afficher("Son perimetre est " & Float'Image(Per));

   Nouvelle_Ligne_D_Affichage;

   Afficher("Son aire est " & Float'Image(Air));

end Exo5_2;

3. Faire de même qu’à la question 2 pour un rectangle et pour un triangle rectangle.

with Es_Simples, Ada.Numerics.Elementary_Functions;

use Es_Simples, Ada.Numerics.Elementary_Functions;



procedure Exo5_3 is

   M,N,Hyp,Per,Air:Float;

   

begin

   Afficher("Les deux côtés d'un rectangle ou un triangle rectangle");

   Nouvelle_Ligne_D_Affichage;

   Afficher("m= ");Lire(M);

   Afficher("n= ");Lire(N);

   

   Nouvelle_Ligne_D_Affichage;

   

   Per:=2.0*(M+N);

   Air:=M*N;

   

   Afficher("si on a un rectangle alors");

   Nouvelle_Ligne_D_Affichage;

   Afficher("Le perimetre est egal a " & Float'Image(Per));

   Nouvelle_Ligne_D_Affichage;

   Afficher("l'aire est egale a" & Float'Image(Air));

   Nouvelle_Ligne_D_Affichage(2);



   Hyp:= Sqrt(M ** 2.0 + N ** 2.0);

   Per:= Hyp + M + N;

   Air:= (M*N)/2.0;

   

   Afficher("si on a un triangle rectangle alors");

   Nouvelle_Ligne_D_Affichage;

   Afficher("Le perimetre est egal a " & Float'Image(Per));

   Nouvelle_Ligne_D_Affichage;

   Afficher("l'aire est egale a" & Float'Image(Air));

   Nouvelle_Ligne_D_Affichage(2);

   

end exo5_3;

Exercice 6

Lire 3 valeurs entières et 1 valeur flottante X arbitraires. Calculer la somme Somme et le
produit Produit des 3 entiers. Calculer le flottant X*Somme/Produit.

with Es_Simples;

use Es_Simples;



procedure Exo6 is

   M,N,P,somme,produit:Integer;

   X,quotient:Float;

   

begin

   Afficher("Donnez trois valeurs entieres:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("M= ");Lire(M);

   Afficher("N= ");Lire(N);

   Afficher("P= ");Lire(P);

   Afficher("Donnez une valeur floattante:");

   Nouvelle_Ligne_D_Affichage;

   afficher("X= ");Lire(X);

   

   Nouvelle_Ligne_D_Affichage;

   

   Somme:=M+N+P;

   Produit:=M*N*P;

   Quotient:=X*Float(Somme)/Float(Produit);

   

   Afficher(Integer'Image(M) & 

      "+" & 

      Integer'Image(N) & 

      "+" & 

      Integer'Image(P) & 

      "=" & 

      Integer'Image(Somme));

      

   Nouvelle_Ligne_D_Affichage;

   

   Afficher(Integer'Image(M) & 

      "*" & 

      Integer'Image(N) & 

      "*" & 

      Integer'Image(P) & 

      "=" & 

      Integer'Image(Produit));

      

   Nouvelle_Ligne_D_Affichage;

   

   Afficher(Float'Image(X) & 

      "*" & 

      Integer'Image(Somme) & 

      "/" & 

      Integer'Image(Produit) & 

      "=" & 

      Float'Image(Quotient));

      

end Exo6;

TD N°3

Exercice 1

Reprendre les exercices suivants en utilisant des objets tableaux pour rassembler les
données ou/et les résultats.
1. Feuille de TD No1 : Exercice 2, question 3.c.

with Es_Simples;

use Es_Simples;



procedure Exo1_1 is

   T : array (1 .. 5) of Float;



begin

   

   T(4):=0.0;

   T(5):=1.0;

   

   for I in 1..3 loop

      Afficher("Entrez la valeur flottante numero ");

      Afficher(I,0);

      Afficher(" : ");

      Lire(T(I));

      T(4):=T(4)+T(I);

      T(5):=T(5)*T(I);

   end loop;

   

   Afficher("la somme= ");Afficher(T(4));

   Nouvelle_Ligne_D_Affichage;

   Afficher("le produit= ");Afficher(T(5));

   

end exo1_1;

2. Feuille de TD No1 : Exercice 5.

with Es_Simples;

use Es_Simples;



procedure Exo1_2 is

   T : array (1 .. 5) of Boolean;

   -- T(1) et T(2) sont les paramètres de la table

   -- T(3)= and, T(4)=or, T(5) = xor

begin

   

   Afficher("A          B        A et B     A ou B     A xor B");

   Nouvelle_Ligne_D_Affichage;



   for A in Boolean'range loop

      for B in Boolean'range loop

         T(1):=A;

         T(2):=B;

         T(3):=A and B;

         T(4):=A or B;

         T(5):=A xor B;



         Afficher(Boolean'Pos(T(1)),0);

         Afficher(Boolean'Pos(T(2)));

         Afficher(Boolean'Pos(T(3)));

         Afficher(Boolean'Pos(T(4)));

         Afficher(Boolean'Pos(T(5)));

         

         Nouvelle_Ligne_D_Affichage;

      end loop;

   end loop;

   

end exo1_2;

3. Feuille de TD No2 : Exercice 2.

with Es_Simples;

use Es_Simples;



procedure Exo1_3 is

   T:array (0..10) of Integer;

   

begin

   Afficher("Entrer un nombre entier: ");

   Lire(T(0));

   

   Nouvelle_Ligne_D_Affichage;

   

   Afficher("Voici les mutiples de ");

   Afficher(T(0),0);

   Afficher(" allant de 1 a 10:");

   

   Nouvelle_Ligne_D_Affichage(2);

   

   for I in 1..10 loop

      Afficher(I,5);

   end loop;

   

   Nouvelle_Ligne_D_Affichage;

   

   for I in 1..10 loop

      T(I):=I*T(0);

      Afficher(T(I),5);

   end loop;

   

end exo1_3;

4. Feuille de TD No2 : Exercice 4.

with Es_Simples;

use Es_Simples;



procedure Exo1_4 is

   T : array (1 .. 3) of Float;



begin



   Afficher("T(1)= ");

   Lire(T(1));

   Afficher("T(2)= ");

   Lire(T(2));



   T(3):=T(1);

   T(1):=T(2);

   T(2):=T(3);



   Afficher("Apres permutation on a: ");

   Nouvelle_Ligne_D_Affichage;

   Afficher("T(1)= ");

   Afficher(T(1));

   Nouvelle_Ligne_D_Affichage;

   Afficher("T(2)= ");

   Afficher(T(2));

   

end exo1_4;

5. Feuille de TD No2 : Exercice 6.

with Es_Simples;

use Es_Simples;



procedure Exo1_5 is

   E:array (1..5) of Integer;

   F:array (1..2) of Float;

   

begin

   E(4):=0;

   E(5):=1;

   

   for I in 1..3 loop

      Afficher("rentrer l'entier numero ");

      Afficher(I,0);

      Afficher(" : ");

      Lire(E(I));

      E(4):=E(4)+E(I);

      E(5):=E(5)*E(I);

      Nouvelle_Ligne_D_Affichage;

   end loop;

   Afficher("rentrer un flottant x: ");

   Lire(F(1));

   F(2):=F(1)*Float(E(4))/Float(E(5));

   

   Afficher("la somme des entiers = ");Afficher(E(4),0);Nouvelle_Ligne_D_Affichage;

   Afficher("le produit des entiers = ");Afficher(E(5),0);Nouvelle_Ligne_D_Affichage;

   Afficher("x*somme/produit =");Afficher(F(2));

   

end exo1_5;

Exercice 2

Écrire une procédure qui déclare et initialise le plus élégamment possible un tableau
indicé par le numéro de mois et qui contient le nombre de jours correspondant (on choisira une
année non bissextile).

with Es_Simples;

use Es_Simples;



procedure Exo2 is

   Mois: array (1..12) of Integer:= (1|3|5|7|8|10|12 => 31, 2 => 28, others => 30);

   

begin

   for I in Mois'range loop

      Afficher("Le nombre de jours dans le mois numero ");

      Afficher(I,0);

      Afficher(" est ");

      Afficher(Mois(I),0);

      nouvelle_ligne_d_affichage;

   end loop;

end Exo2;

Exercice 3

La suite de Fibonnacci est définie par u₀ = 0, u₁ = 1, et u_n = u_n−1 + u_n−2 pour n >= 2. On
s’intéresse à la valeur du n-ième terme de cette suite pour une valeur de n arbitrairement choisie par
l’utilisateur et inférieure à 100.
1. Écrire une procédure qui demande à l’utilisateur une valeur pour n, puis affiche les valeurs
k et u_k pour k variant de n à 0, c’est-à-dire qui affiche les n premières valeurs de la suite de
Fibonnacci en ordre inverse de celui du calcul.

with Es_Simples;

use Es_Simples;



procedure Exo3 is

   N:constant :=10;

   U:array (0..N) of Integer;

   

begin

   U(0):=0;

   U(1):=1;

   Afficher("Soit U(n)=U(n-1)+U(n-2) la suite de fibonacci avec U(0)=0, U(1)=1 et N=");

   Afficher(N);

   Nouvelle_Ligne_D_Affichage;

   

   for K in 2..N loop

      U(K):=U(K-1)+U(K-2);

   end loop;

   

   for K in reverse 0..N loop

      Afficher("Pour K=");

      Afficher(K,0);

      Afficher(" Alors U(K)=");

      Afficher(U(K),0);

      Nouvelle_Ligne_D_Affichage;

   end loop;

   

end exo3;

Exercice 4

Cet exercice utilise la suite u_i des puissances de 2, u_i = 2ⁱ = 2 × 2 × · · · × 2 = 2 × u_i−1.

1. Écrire une procédure qui stocke dans un tableau les 32 premières puissances de 2 (de 20 à 231)
en utilisant la relation u_i = 2ⁱ.

2. Écrire une procédure qui stocke dans un tableau les 32 premières puissances de 2 (de 20 à 231)
en utilisant la relation u_i = 2 × u_i−1.

NDR: parties 1 et 2 dans le même programme

with Es_Simples;

use Es_Simples;



procedure Exo4_1 is

   U:array (-1..31) of float;

   

begin

   U(-1):=0.5;

   

   for I in 0..31 loop

      

      U(I):=2.0**I;

      

      Afficher("Pour i=");

      Afficher(I,0);

      afficher("  2 puissance i= ");

      Afficher(U(I));

      

      Afficher("    2*u(i-1)= ");

      U(I):=2.0*U(I-1);

      Afficher(U(I));

      Nouvelle_Ligne_D_Affichage;

   end loop;

   end exo4_1;

3. Écrire une fonction qui calcule la valeur p de la plus grande puissance de 2 inférieure ou égale
à un entier n > 0 donné, soit 2^p <= n < 2^p+1.

4. Écrire une fonction qui calcule le “reste” r = n − 2^p où p est la valeur donnée par la fonction
précédente.

5. Écrire une procédure qui calcule (et affiche) les valeurs p et r pour une valeur n arbitrairement
choisie (au clavier) par l’utilisateur.

NDR: parties 3,4 et 5 dans le même programme

with Es_Simples;

use Es_Simples;



procedure Exo4_3 is

   

   N,P,R:Integer;

   



   function Puissance(N:Integer) return Integer is

      P:Integer:=0;

      

   begin

      

      while 2**(P+1)<=N loop

         P:=P+1;

      end loop;

      return P;

      

   end Puissance;

   

   function Reste(N,P:Integer) return Integer is

      R:Integer;

      

   begin

      

      R:=N-2**P;

      return R;

      

   end Reste;

   

begin

   			

   Afficher("entrez un nombre entier N: ");

   Lire(N);

   

   P:=Puissance(N);		

   R:=Reste(N,P);

   

   Afficher("Soit 2 puissance p la plus grande puissance de 2 inferieure ou egale a N, p= ");

   Afficher(P,0);

   Nouvelle_Ligne_D_Affichage;

   Afficher("Le reste N-(2 puissance p) est egal a: ");

   Afficher(R,0);

   

end exo4_3;

Exercice 5

Écrire une procédure qui calcule les indices I et J du plus grand composant du tableau
A : array (1..N,1..M) of Float ;

with Es_Simples;

use Es_Simples;



procedure Exo5 is

   Max :          Float;

   L,

   C   :          Integer;

   N   : constant                                 := 3;

   M   : constant                                 := 4;

   A   :          array (1 .. N, 1 .. M) of Float;



begin

   

   for I in 1..N loop

      for J in 1..M loop

         Afficher("A(" &

            Integer'Image(I) &

            " ," &

            Integer'Image(J) &

            " )= ");

         Lire(A(I,J));

      end loop;

   end loop;

   



   Max:=A(1,1);



   for I in 1..N loop

      for J in 1..M loop

         if A(I,J)>max then

            Max:=A(I,J);

            L:=I;

            C:=J;

         end if;

      end loop;

   end loop;



   Afficher("la plus grande valeur du tableau A de ");

   Afficher(N,0);

   Afficher(" lignes et ");

   Afficher(M,0);

   Afficher(" colonnes se trouve à la ligne ");

   Afficher(L,0);

   Afficher(" et a la colonne ");

   afficher(c,0);



end Exo5;

TD N°4

Exercice 1

Reprendre les exercices suivants en encapsulant les traitements demandés dans des fonctions
ou des procédures puis en les appelant depuis une procédure principale.

1. Feuille de TD No1 : Exercice 3, question 2.
2. Feuille de TD No2 : Exercice 4.
3. Feuille de TD No2 : Exercice 5, questions 1 et 2.

with Es_Simples, Ada.Numerics.Elementary_Functions, Ada.Numerics;

use Es_Simples, Ada.Numerics.Elementary_Functions, Ada.Numerics;



procedure Exo1 is

   A,

   B   : Boolean;

   X,

   Y   : Float;

   Hyp,

   Lo,

   La,

   R,

   Air,

   Per : Float;



   procedure Echange_Bool (

         M,

         N : in out Boolean) is

      Temp : Boolean;



   begin

      Temp:=M;

      M:=N;

      N:=Temp;

   end Echange_Bool;



   procedure Echange_Float (

         M,

         N : in out Float) is

      Temp : Float;



   begin

      Temp:=M;

      M:=N;

      N:=Temp;

   end Echange_Float;



   function Hypo (

         M,

         N : Float)

     return Float is

      Hyp : Float;



   begin

      Hyp:=Sqrt(M**2+N**2);

      return Hyp;

   end Hypo;



   function Aire (

         R : Float)

     return Float is

      Air : Float;



   begin

      Air:=Pi*R**2.0;

      return Air;

   end Aire;



   function Perimetre (

         R : Float)

     return Float is

      Per : Float;



   begin

      Per:=2.0*Pi*R;

      return Per;

   end Perimetre;



begin



   Afficher("entrer deux booleens:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("A =");

   Lire(A);

   Afficher("B= ");

   Lire(B);

   Nouvelle_Ligne_D_Affichage;



   Afficher("entrer deux flottants:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("X= ");

   Lire(X);

   Afficher("Y= ");

   Lire(Y);

   Nouvelle_Ligne_D_Affichage;



   Afficher("entrer les longueurs des cotes de l'angle droit d'un triangle rectangle:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("longueur= ");

   Lire(Lo);

   Afficher("largeur= ");

   Lire(La);

   Nouvelle_Ligne_D_Affichage;



   Afficher("entrer le rayon d'un cercle:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("R= ");

   Lire(R);

   Nouvelle_Ligne_D_Affichage(2);







   Echange_Bool(A,B);

   Echange_Float(X,Y);

   Hyp:=Hypo(Lo,La);

   Per:=Perimetre(R);

   Air:=Aire(R);







   Afficher("Apres l'echange des booleens on a:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("A= ");

   Afficher(A);

   Nouvelle_Ligne_D_Affichage;

   Afficher("B= ");

   Afficher(B);

   Nouvelle_Ligne_D_Affichage(2);



   Afficher("Apres l'echange des flottants on a:");

   Nouvelle_Ligne_D_Affichage;

   Afficher("X= ");

   Afficher(X);

   Nouvelle_Ligne_D_Affichage;

   Afficher("Y= ");

   Afficher(Y);

   Nouvelle_Ligne_D_Affichage(2);



   Afficher("L'hypotenuse du triangle rectangle est: ");

   Afficher(Hyp);

   Nouvelle_Ligne_D_Affichage(2);



   Afficher("Pour un cercle de rayon R");

   Nouvelle_Ligne_D_Affichage;

   Afficher("aire = ");

   Afficher(Air);

   Nouvelle_Ligne_D_Affichage;

   Afficher("perimetre = ");

   Afficher(Per);



end Exo1;

Exercice 2

Écrire les sous-programmes qui réalisent les traitements suivants et les utiliser dans un programme principal.

1. Calculer −px, l’opposé de la racine carrée d’un nombre flottant positif x arbitrairement choisi par l’utilisateur.

2. Pour un nombre entier positif n arbitrairement choisi par l’utilisateur, calcule le nombre de ses racines carrées successives qui sont strictement supérieures à 1. Il s’agit de calculer k tel que

with Es_Simples, Ada.Numerics.Elementary_Functions;

use Es_Simples, Ada.Numerics.Elementary_Functions;



procedure Exo2 is

   X,

   Rac_Op : Float;

   N,

   K      : Integer;



   function Racine_Oposee (

         X : Float)

     return Float is

      Rac_Op : Float;



   begin

      Rac_Op:=-Sqrt(X);

      return Rac_Op;

   end Racine_Oposee;







   function Nombre_Racine (

         N : Integer)

     return Integer is

      K   : Integer;

      Rac : Float;



   begin

      Rac:=Sqrt(Float(N));

      K:=0;

      while Rac > 1.0 loop

         Rac:=Sqrt(Rac);

         K:=K+1;

      end loop;

      return K;

   end Nombre_Racine;





begin



   Afficher("Donner un flottant X= ");

   Lire(X);

   Afficher("Donner un entier N= ");

   Lire(N);

   Nouvelle_Ligne_D_Affichage;



   Rac_Op:=Racine_Oposee(X);

   K:=Nombre_Racine(N);



   Afficher("l'oppose de la racine de X= ");

   Afficher(Rac_Op);

   Nouvelle_Ligne_D_Affichage;

   Afficher("le nombre de racines successives superieures a 1 pour N= ");

   Afficher(K);



end Exo2;

Exercice 3

Écrire les sous-programmes qui réalisent les traitements suivants. Les utiliser dans une procédure principale qui regroupe les entrées-sorties et ces appels.

1. Calcule la valeur de n! = n×(n−1)×(n−2)×· · · 3×2×1, où n est un entier positif arbitrairement choisi par l’utilisateur.

with Es_Simples;

use Es_Simples;



procedure Exo3 is

   N,

   Fact : Integer;



   function Factoriel (

         N : Integer)

     return Integer is

      Fact : Integer;



   begin

      Fact:=1;

      if N > 0 then

         for I in 1..N loop

            Fact:=I*Fact;

         end loop;

      end if;

      return Fact;

   end Factoriel;



begin



   Afficher("Entrer N un entier positif: ");

   Lire(N);

   Nouvelle_Ligne_D_Affichage;



   Fact:=Factoriel(N);



   Afficher("!n= ");

   Afficher(Fact,0);



end Exo3;

TD N°5

Exercice 1

Continuons à découvrir et utiliser les paquetages prédéfinis. Il est souvent utile de pouvoir générer des ensembles de valeurs aléatoires. On utilisera pour cela les paquetages Numerics.Discrete Random, Numerics.Float Random.

En s’inspirant de l’exemple d’utilisation proposé dans tirage aleatoire.adb, écrire une procédure qui génère 50 valeurs aléatoires
1. de type booléen,

with Es_Simples, Ada.Numerics.Discrete_Random;

use Es_Simples;



procedure Exo1_1 is

   package Bool_Random is new Ada.Numerics.Discrete_Random(Boolean);

   use Bool_Random;

   B    : Boolean;

   Bool : Bool_Random.Generator;



begin

   for I in 1..50 loop

      B:=Random(Bool);

      Afficher(B);

      Nouvelle_Ligne_D_Affichage;

   end loop;



end Exo1_1;

2. du (sous-)type ISO 646 de la librairie Ada.Characters.Handling,

with Es_Simples, Ada.Characters.Handling, Ada.Numerics.Discrete_Random;

use Es_Simples, Ada.Characters.Handling;



procedure Exo1_2 is

   package Iso_Random is new Ada.Numerics.Discrete_Random(Iso_646);

   use Iso_Random;

   C    : Iso_646;

   Char : Iso_Random.Generator;



begin

   for I in 1..50 loop

      C:=Random(Char);

      Afficher(C);

      Nouvelle_Ligne_D_Affichage;

   end loop;

end Exo1_2;

3. flottantes et uniformément distribuées entre 0 et 1,

with Es_Simples, Ada.Numerics.Float_Random;

use Es_Simples, Ada.Numerics.Float_Random;



procedure Exo1_3 is

   subtype Petit_Float is Float range 0.0..1.0;

   F   : Petit_Float;

   P_F : Ada.Numerics.Float_Random.Generator;



begin

   for I in 1..50 loop

      F:=Random(P_F);

      Afficher(F);

      Nouvelle_Ligne_D_Affichage;

   end loop;

end Exo1_3;

4. flottantes et uniformément distribuées entre -2 et 2.

with Es_Simples, Ada.Numerics.Float_Random;

use Es_Simples, Ada.Numerics.Float_Random;



procedure Exo1_4 is

   subtype Petit_Float_2 is Float range -2.0..2.0;

   F   : Petit_Float_2;

   P_F : Ada.Numerics.Float_Random.Generator;



begin

   for I in 1..50 loop

      F:=Random(P_F);

      Afficher(F);

      Nouvelle_Ligne_D_Affichage;

   end loop;

end Exo1_4;

Exercice 2

Cet exercice considère les réponses fournies par un utilisateur à une question où la réponse attendue est une valeur booléenne : l’utilisateur répond ’O’ ou ’o’ pour True et ’N’ ou ’n’ pour False.

1. Il s’agit d’interpréter correctement la réponse fournie. Proposer une procédure qui lit la réponse au clavier, met à jour une variable Réponse selon la valeur lue et repose la question si la valeur lue ne permet pas de conclure.

with Es_Simples;

use Es_Simples;



procedure Exo2_1 is

   Reponse_Char : Character := '.';

   Reponse_Bool : Boolean;



begin

   

   Afficher("Aimez-vous repondre a des questions ?");

   Nouvelle_Ligne_D_Affichage;

   afficher("(O ou o pour oui et N ou n pour non): ");



   while Reponse_char/='o' and then Reponse_char/='O' and then Reponse_char/='n' and then Reponse_char/='N' loop

      Lire(Reponse_Char);

      

      case Reponse_char is

         when 'o'|'O' =>

            Reponse_Bool:=True;

         when 'n'|'N' =>

            Reponse_Bool:=False;

         when others =>

            Afficher("Ce n'est pas une reponse, essaie encore: ");

      end case;



   end loop;

   

   Nouvelle_Ligne_D_Affichage;

   

   if Reponse_Bool then

      Afficher("Chouette");

   else

      Afficher("Pas chouette");

   end if;



end Exo2_1;

2. Il s’agit d’analyser les valeurs des réponses fournies. Proposer une procédure qui après avoir lu le nombres de réponses attendues, dénombre les deux types de réponses et conclut sur la réponse majoritaire.

with Es_Simples;

use Es_Simples;



procedure Exo2_2 is

   Reponse_Char : Character;

   Oui          : Integer   := 0;

   Non          : Integer   := 0;

   N            : Integer   := 10;



begin



   while Oui=Non loop

      Reponse_Char:='.';



      Afficher("Etes-vous de bonne humeur ?");

      Nouvelle_Ligne_D_Affichage;

      Afficher("(O ou o pour oui et N ou n pour non): ");



      while Reponse_Char/='o' and then Reponse_Char/='O' and then Reponse_Char/='n' and then Reponse_Char/='N' loop

         Lire(Reponse_Char);



         case Reponse_Char is

            when 'o'|'O' =>

               Oui:=Oui+1;

            when 'n'|'N' =>

               Non:=Non+1;

            when others =>

               Afficher("Ce n'est pas une reponse, essaie encore: ");

         end case;



      end loop;



      Nouvelle_Ligne_D_Affichage;



      for I in 1..N-1 loop

         Reponse_Char:='.';

         Afficher("Et maintenant ?");

         Nouvelle_Ligne_D_Affichage;

         Afficher("(O ou o pour oui et N ou n pour non): ");



         while Reponse_Char/='o' and then Reponse_Char/='O' and then Reponse_Char/='n' and then Reponse_Char/='N' loop

            Lire(Reponse_Char);



            case Reponse_Char is

               when 'o'|'O' =>

                  Oui:=Oui+1;

               when 'n'|'N' =>

                  Non:=Non+1;

               when others =>

                  Afficher("Ce n'est pas une reponse, essaie encore: ");

            end case;



         end loop;

         Nouvelle_Ligne_D_Affichage;

      end loop;



      Afficher("Je tiens a te feliciter d'avoir repondu ");

      Afficher(N,0);

      Afficher(" fois a la meme question !");

      Nouvelle_Ligne_D_Affichage;

      Afficher("J'ai pu constater que tu as repondu ");

      Afficher(Oui,0);

      Afficher(" fois oui et ");

      Afficher(Non,0);

      Afficher(" fois non...");

      Nouvelle_Ligne_D_Affichage(2);

      Afficher("Conclusion...:");

      Nouvelle_Ligne_D_Affichage;

      if Oui>Non then

         Afficher("TU ES DE BONNE HUMEUR !!!!");

      elsif Non>Oui then

         Afficher("TU N'ES PAS VRAIMENT DE TRES BONNE HUMEUR !!!!");

      else

         Afficher("Tu hesites ? Alors tu vas recommencer mon questionnaire !");

      end if;

      Nouvelle_Ligne_D_Affichage(2);

   end loop;





end Exo2_2;

3. Effectuer le traitement de la question 2 pour un nombre arbitraire de valeurs booléennes générées de façon aléatoire.

with Es_Simples, Ada.Numerics.Discrete_Random;

use Es_Simples;



procedure Exo2_3 is

   package Char_Random is new Ada.Numerics.Discrete_Random(Boolean);

   use Char_Random;

   Rep    : Boolean;

   Rep_Al : Char_Random.Generator;

   N      : Integer;

   Oui    : Integer               := 0;

   Non    : Integer               := 0;



begin

   Afficher("On va jouer a un petit jeu");

   Nouvelle_Ligne_D_Affichage;

   Afficher("C'est moi qui vais repondre au hasard, le nombre de fois");

   Nouvelle_Ligne_D_Affichage;

   Afficher("que le voudrez a une meme question. Si vous obtenez un");

   Nouvelle_Ligne_D_Affichage;

   Afficher("nombre supérieur de reponse affirmative que positives vous");

   Nouvelle_Ligne_D_Affichage;

   Afficher("gagnerez, s'il est inferieur, vous perdez. Sinon on recommence");

   Nouvelle_Ligne_D_Affichage;

   Afficher("la partie.__________Donnez le nombre de questions souhaite: ");

   Lire(N);

   Nouvelle_Ligne_D_Affichage;



   while Oui=Non loop

      for I in 1..N loop

         Rep:=Random(Rep_Al);

         Afficher("Avez vous eu de la chance ce tour-ci ? ");



         if Rep then

            Afficher("oui");

            Oui:=Oui+1;

         else

            Afficher("non");

            Non:=Non+1;

         end if;



         Nouvelle_Ligne_D_Affichage;

      end loop;

      Nouvelle_Ligne_D_Affichage;

      if Oui>Non then

         Afficher("Bravo, vous avez gagne");

      elsif Non>Oui then

         Afficher("Dommage, vous avez perdu");

      else

         Afficher("Ni perdu, ni gagne, on recommence pour determiner votre sort");

      end if;

      Nouvelle_Ligne_D_Affichage(2);

   end loop;



end Exo2_3;

Exercice 3

On souhaite calculer le maximum, le minimum, la moyenne arithmétique et l’écart type de N valeurs flottantes générées aléatoirement, N étant un nombre arbitrairement choisi par l’utilisateur.

Écrire les procédures qui réalise ce traitement en procédant comme suit.
1. Utiliser un objet tableau et une seule procédure principale.

Prochainement.

2. Utiliser un objet tableau et réaliser les calculs demandés avec des sous-programmes.

Prochainement.

3. Utiliser le type tableau pour réaliser les calculs demandés avec des sous-programmes.

Prochainement.

Pour me contacter, si vous avez des questions.

Mon adresse hotmail.fr : jeremy_safont
(Je ne mets pas mon adresse en entier pour ne pas recevoir des spams).