Download algorithme exercice for begibnner and more Exercises Information Systems in PDF only on Docsity!
Sommaire
- Série 1 : Type Tableau (Vecteurs et Matrices).....................................................................................................
- Exercice 1 : Lecture et Affichage d'un vecteur...............................................................................................
- Exercice 2 : Somme et Moyenne des éléments d'un vecteur..........................................................................
- Exercice 3 : L'inverse des éléments d'un vecteur............................................................................................
- Exercice 4 : Min et le Max d'un vecteur et leurs positions...........................................................................
- Exercice 5 : La recherche d'une valeur dans un vecteur...............................................................................
- Exercice 6 : Lecture et affichage d'une matrice............................................................................................
- Exercice 7 : Somme, Moyenne et Produit des éléments d'une matrice.........................................................
- Exercice 8 : Min et le Max dans une matrice et leurs positions....................................................................
- Exercice 9 : Transposée d'une matrice. Somme de deux matrices................................................................
- Exercice 10 : Produit de deux matrices.........................................................................................................
Série 1 : Type Tableau (Vecteurs et Matrices)
Exercice 1 : Lecture et Affichage d'un vecteur
Écrire un algorithme/programme PASCAL qui permet de lire et afficher un vecteur V de N
composantes réelles.
Solution
L'algorithme
Le programme PASCAL
Explication
Ce programme montre comment réaliser la lecture et l'écriture d'un vecteur (une séquence de cases mémoire contigüe de même type). Pour les deux opérations (lecture et écriture) on aura besoin toujours d'une boucle Pour. Lors de la déclaration, on réserve 100 cases réelles (le taille maximale du vecteur), et on utilise la variable n pour déterminer la taille qu'on veut utiliser (par exemple 5 cases). L'accès à une composante d'indice i se fait comment suit : V[i]. Ainsi, pour réaliser la lecture de la case 2, on écrira Lire(V[2]), et Écrire(T[4]) pour afficher la valeur de la 4ème^ case.
Program exercie_1; Uses wincrt ; var V : array [1..100] of Real; i, n : integer ; Begin {Les entrées} Write('Donner la taille du vecteur : '); Read(n); Writeln('Donner les composantes du vecteur : '); For i:=1 to n do Read( V[i] );
{Les sorties} Writeln('Affichage du Vecteur : '); For i:=1 to n do Write( V[i]:10:3 ); {Afficher sur 10 caractères et} {2 chiffres après la virgule} End.
Algorithme exercie_ Variables V : Tableau [1..100] de Réel i,n : entier Début Lire(n)
Pour i← 1 à n faire
Lire( V[i] ) Fin-Pour
Pour i← 1 à n faire
Écrire( V[i] ) Fin-Pour Fin
Traitement (vide)
V (i=1..N)
V (i=1..N)
n
Exercice 2 : Somme et Moyenne des éléments d'un vecteur
Écrire un algorithme/un programme PASCAL qui permet Calculer la somme et la moyenne des éléments
d'un vecteur V réel de taille N.
Solution
L'algorithme
Le programme PASCAL Program exercie_2; Uses wincrt ; var V : array [1..100] of Real; i, n : integer ; Som, Moy : real; Begin {Les entrées} Write('Donner la taille du vecteur : '); Read(n); Writeln('Donner les composantes du vecteur : '); For i:=1 to n do Read( V[i] );
{Les traitements} Som:=0; {Som = V[1] + V[2] + V[3] + … + V[n]} For i:=1 to n do Som:= Som + V[i];
Moy:=Som/n; {La moyenne égale à la somme sur le nombre d'éléments}
{Les sorties} Writeln('La somme est : ', Som:8:3); Writeln('La moyenne est : ', Moy:8:3); End.
Algorithme exercie_ Variables V : Tableau [1..100] de Réel i,n : entier Som, Moy : Réel Début Lire(n)
Pour i← 1 à n faire
Lire( V[i] ) Fin-Pour
Som ← 0
Pour i← 1 à n faire
Som ← Som + V[i]
Fin-Pour
Moy ← Som / n
Ecrire(Som, Moy) Fin
Traitement
V (i=1..N)
Som
n
Moy
Explication
Soit V un vecteur de n éléments réels, le calcul de la somme de ces éléments se fait par la
formule mathématique : V[1]+V[2]+...+V[n]. Si on met l'identificateur Som pour la variable qui
représente la somme de ces cases, donc on aura :
Som = V[1]+V[2]+...+V[n] = (^) ∑ i = 1
n V [ i ]
On a vu, auparavant, que le symbole de la somme sera remplacer par un boucle Pour, avec le
terme répétitif, pour cette somme, égale à V[i], ce qui donne :
Pour i ← 1 à n faire
Som ←Som + V[i] Remarquer que les bornes de la sommes (i=1 à n) sont les mêmes bornes de la boucle Pour (i ← 1
à n). Et pour la moyenne, on sait que : Moyenne = Somme / le nombre d'éléments sommés.
Organigramme
Lire(n)
Fin.
Lire(V[i])
Oui
Non
i <= n
Début
i ←
i ←i+
Écrire(Som, Moy)
Oui (^) i <= n Non
Som ← 0 i← 1
Som ← Som + V[i]
i ←i+
Moy ← Som / n
V[1] ← T[n]; V[2] ← T[n1] ; V[3] ← T[n2] ; …….. ; V[n] ← T[1];
La correspondance entre les indices de V et ceux de T sont commet suit : 1 ←→ n – 0 2 ←→ n – 1 3 ←→ n – 2 4 ←→n – 3 ...
Si on généralise par rapport à l'indice i, on aura : i ←→ n – (i1), donc aura l'affectation
suivante : Pour toute valeur i entre 1 et n, V[i] ← T[ni+1]
Organigramme
Lire(n)
Lire(T[i])
Oui
Non
i <= n
Début
i ←
i ←i+1 Oui^ i <= n Non
i ← 1
V[i] ← T[n – i + 1]
i ←i+
Fin.
Écrire(V[i])
Oui Non i <= n
i ←i+
i ←
2 Inverser les éléments du vecteur T dans lui même (sans utiliser un autre vecteur)
L'algorithme
Le programme PASCAL
Explication
La solution qui vient immédiatement à l'esprit est une suite d'affectations : T[i] ←T[ni+1]. Le problème ici est que la valeur de T[i] sera écrasée par T[ni+1]. Donc ce cas, il faut penser à
réaliser une permutation entre les deux cases : i et ni+1. Et ce ci avec les trois affectations :
Z ← T[i]; T[i] ← T[ni+1] ; T[ni+1] ←Z ; (comme la permutation entre x et y). Il faut faire attention, il faut réaliser cette permutation entre un case de la première moitié du vecteur avec la
Program exo3_2; Uses wincrt ; var T : array [1..100] of Real; i, n : integer ; Z:real; Begin {Les entrées} Write('Donner la taille du vecteur T : '); Read(n); Writeln('Donner les composantes du vecteur T : '); For i:=1 to n do Read( T[i] );
{Les traitements} For i:=1 to (n div 2) do {Inverser par permutation de cases} Begin {La case i est permutée avec la case n-i+1} Z := T[i]; {Conserver T[i] dans Z} T[i] := T[n-i+1]; {On peut écraser T[i] par T[n-i+1]} T[n-i+1] := Z; {Maintenant on met Z dans T[n-i+1]} end;
{Les sorties} Writeln('L''affichage du vecteur T : '); For i:=1 to n do Write( T[i] :10:2);
End.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 30
Algorithme exo3_ Variables T : Tableau [1..100] de Réel i,n : entier Z:Réel Début Lire(n) Pour i←1 à n faire Lire( T[i] ) Fin-Pour Pour i←1 à (n div 2) faire Z ← T[i] T[i] ← T[n-i+1] T[n-i+1] ← Z Fin-Pour
Pour i←1 à n faire Écrire( T[i] ) Fin-Pour Fin
Traitement
n T (i=1..N)
T (i=1..N)
Exercice 4 : Min et le Max d'un vecteur et leurs positions
1 Écrire un algorithme/programme PASCAL qui permet de rechercher le plus petit élément dans un
vecteur réel V ainsi que sa position.
2 Écrire un programme PASCAL qui permet de rechercher le plus grand élément dans un vecteur réel V
ainsi que sa position.
Solution
1 Recherche du min et sa position dans vecteur
L'algorithme
Le programme PASCAL Program exo4_1_Min; Uses wincrt ; var T, V : array [1..100] of Real; i, n, Pos : integer ; Min:Real; Begin {Les entrées} Write('Donner la taille du vecteur V : '); Read(n); Writeln('Donner les composantes du vecteur V : '); For i:=1 to n do Read( V[i] );
{Les traitements} Min:=V[1]; Pos:=1; {On suppose que le Min est la valeur de la première case} For i:=2 to n do {On parcours toutes les autres cases} If V[i] < Min then {Pour chaque case qui est inférieur au Min} begin Min := V[i]; {On actualise le Min (corriger le Min) } Pos := i; {On actualise sa position} end ;
{Les sorties} Write('Le Min du V est : ',Min:2:2,' et sa position est : ', Pos); End.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Algorithme exo4_1_Min Variables V : Tableau [1..100] de Réel i,n, Pos : entier Min:Réel Début Lire(n) Pour i←1 à n faire Lire( V[i] ) Fin-Pour Min ← V[1] Pos ← 1 Pour i←1 à n faire Si T[i] < Min alors Min ← V[i] Pos ← i Fin-Si Fin-Pour
Écrire( Min, Pos) Fin
Traitement
n V (i=1..N)
min pos
Explication
La solution de la recherche du min dans un vecteur ainsi que sa position commence par la
supposition que le premier élément du vecteur est le minimum (la ligne 15 du programme
précédent : Min:=V[1] ; Pos:=1;). Par la suite, on parcours toutes les autres cases de l'indice 2 jusqu'à l'indice n pour vérifier s'il y parmi ces cases celles qui vérifiassent la condition V[i]<Min,
pour chaque élément V[i] qui vérifie la condition précédente, on met à jour le Min par V[i] et la
valeur de Pos par i.
Organigramme
Lire(n)
Lire(V[i])
Oui
Non
i <= n
Début
i ←
i ←i+
Oui Non i <= n
Min ← V[1] Pos ← 1
i ← 2
Min ← V[i] Pos ← i
i ←i+
Fin.
Écrire(Min, Pos)
V[i] < Min
Oui
1 Recherche du max et sa position dans vecteur
L'algorithme
Le programme PASCAL
Explication
Le Même principe que la recherche du Min. Juste la condition qui est modifiée (V[i] > Max)
Program exo4_2_Max; Uses wincrt ; var T, V : array [1..100] of Real; i, n, Pos : integer ; Max:Real; Begin {Les entrées} Write('Donner la taille du vecteur V : '); Read(n); Writeln('Donner les composantes du vecteur V : '); For i:=1 to n do Read( V[i] );
{Les traitements} Max:=V[1]; Pos:=1; {On suppose que le Max est la valeur de la première case} For i:=2 to n do {On parcours toutes les autres cases} If V[i] > Max then {Pour chaque case qui est supérieur au Max} begin Max := V[i]; {On actualise le Max (corriger le Max) } Pos := i; {On actualise sa position} end ;
{Les sorties} Write('Le Max du V est : ',Max:2:2,' et sa position est : ', Pos); End.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Algorithme exo4_2_Max Variables V : Tableau [1..100] de Réel i,n, Pos : entier Max:Réel Début Lire(n) Pour i←1 à n faire Lire( V[i] ) Fin-Pour Max ← V[1] Pos ← 1 Pour i←2 à n faire Si T[i] > Max alors Max ← V[i] Pos ← i Fin-Si Fin-Pour
Écrire( Max, Pos) Fin
Traitement
n V (i=1..N)
max pos
Organigramme
Lire(n)
Lire(V[i])
Oui
Non
i <= n
Début
i ←
i ←i+
Oui (^) i <= n Non
Max ← V[1] Pos ← 1
i ← 2
Max ← V[i] Pos ← i
i ←i+
Fin.
Écrire(Max, Pos)
V[i] > Max
Oui
Exercice 5 : La recherche d'une valeur dans un vecteur
Soit V un vecteur de type réel de taille N. Écrire un algorithme/programme PASCAL qui
permet de rechercher si une valeur réelle x existe ou non dans le vecteur V. Dans le cas ou x existe dans V,
on affiche aussi sa position.
Solution Solution 01 : utiliser un booléen Trouve
L'algorithme
Le programme PASCAL Program exo5_a; Uses wincrt ; var T, V : array [1..100] of Real; i, n, Pos : integer ; x:Real; Trouve:boolean; Begin {Les entrées} Write('Donner la taille du vecteur V : '); Read(n); Writeln('Donner les composantes du vecteur V : '); For i:=1 to n do Read( V[i] ); Write('Donner la valeur de x : '); Read(x);
{Les traitements} Trouve:= false ; i:=1; {Initialiser Trouve à false} While (i<=n) AND (Trouve = false ) do begin If V[i]=x then {Si une case égale à x} begin Trouve:= true ; Pos:=i; End ; i := i+1; end;
{Les sorties} If Trouve= true Then Write('x existe dans le vecteur et sa positon est : ', Pos) Else Write('x n''existe pas dans le vecteur'); End.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Algorithme exo5_a Variables V : Tableau [1..100] de Réel i,n, Pos : entier x:Réel Trouve : booléen Début Lire(n) Pour i←1 à n faire Lire( V[i] ) Fin-Pour Lire(x) Trouve ← False i ← 1 Tantque (i<=n) ET (Trouve = False) Faire Si T[i] = x alors Trouve ← True Pos ← i Fin-Si i ← i+ Fin-Tantque Si Trouve = True Alors Écrire('X existe dans la position : ', Pos) Sinon Écrire('X n''existe pas dans V') Fin-Si Fin
Traitement
n V (i=1..N)
X n'existe pas dans V
x
X existe dans la case n° ...
Selon un Condition
Explication
Les entrées du programme sont le vecteur V et la valeur de x à rechercher. Il y a une boucle de
recherche qui permet de parcourir toutes les case de 1 jusqu'à n et elle s'arrête dans deux cas : Soit
V[i]=x (donc on trouve la valeur x et on continue pas la recherche), soit i>n (on a parcouru toutes les case sans trouver aucun valeur). La variable booléenne Trouve représente l'existence de x dans
V ou non : Si Trouve = True, donc on a trouvé x sinon on l'a pas trouve (ou on a pas encore trouvé
x). La boucle de recherche Tantque (i<=n) ET (Trouve = False) Faire signifie : Tantque on a pas terminé le tableau (i<=n) et toujours on pas encore trouve x (Trouve = False) donc on entre à
la boucle, une teste permet de vérifie la case actuelle si est égale à x (Si V[i]=x Alors), donc ce cas
on sauvegarde la position (qui est i : pos ← i) et on indique qu'on a trouvé la valeur x (Trouve ←true), ensuite, on se met à la case suivante: i ←i+1, et ainsi de suite.
Organigramme
Lire(n)
Lire(V[i])
Oui (^) Non i <= n
Début
i ←
i ←i+ Oui i <= n Et Non Trouve = false
Trouve ← False i ← 1
Trouve ← True Pos ← i
i ←i+
Fin.
Écrire('X non trouvé')
V[i] = x
Oui
Lire(x)
Trouve = true Oui Non
Écrire('X existe dans la positoin ', pos)
1 D éroulement du programme (ou l'algorithme) pour n=6 et V= [5, 12, 1, 2, 8, 10]. et x=
Instructions
Variables du Programme n i V x Trouve Pos Réponse (résultat)
Entrées (N° de ligne : 0813) 6 / [5, 12, 1, 2, 8, 10] 5 / /
Trouve := false ; i:=1 ; ''^1 ''^ False^ ''
While (i<=n)AND(Trouve=false) ( 1 <=6)And(false=false) → True (on entre à While) If (V[ 1 ] = x) (5=55) →False (On n'entre pas à If) i:= i+1 ; (i=2)
''
2
'' '' ''
While (i<=n)AND(Trouve=false) ( 2 <=6)And(false=false) → True (on entre à While) If (V[ 2 ] = x) (12=55) →False (On n'entre pas à If) i:= i+1 ; (i=3)
''
3
'' '' '' ''
While (i<=n)AND(Trouve=false) ( 3 <=6)And(false=false) → True (on entre à While) If (V[ 3 ] = x) (1=55) →False (On n'entre pas à If) i:= i+1 ; (i=4)
''
4
'' '' '' ''
While (i<=n)AND(Trouve=false) ( 4 <=6)And(false=false) → True (on entre à While) If (V[ 4 ] = x) (2=55) →False (On n'entre pas à If) i:= i+1 ; (i=5)
''
5
'' '' '' '''
While (i<=n)AND(Trouve=false) ( 5 <=6)And(false=false) → True (on entre à While) If (V[ 5 ] = x) (8=55) →False (On n'entre pas à If) i:= i+1 ; (i=6)
''
6
'' '' '' ''
While (i<=n)AND(Trouve=false) ( 6 <=6)And(false=false) → True (on entre à While) If (V[ 5 ] = x) (10=55) →False (On n'entre pas à If) i:= i+1 ; (i=7) 7
'' '' '' ''
While (i<=n)AND(Trouve=false) ( 7 <=6)And(false=false) False And True →False (on n'entre pas à While)
'' '' '' '' ''
If Trouve = true →Fase (on n'entre pas à If →On entre à Else) Write('x n''existe pas dans ')
'' '' '' X n'existe pas dans le vecteur
Donc le programme affichera le résultat : X n'existe pas dans le vecteur.
Solution 02 : utiliser l'indice i (selon la valeur de i)
L'algorithme
Le programme PASCAL
Explication
Dans cette solution, la boucle recherche s'arrête lorsque la condition (i<=n) AND (V[i]<>x)
est fausse, c àd, elle devient (i>n) OR (V[i]=x) (Soit i>n ou bien V[i]=x). Lorsque la boucle
est terminée, on aura deux cas par rapport à la valeur de i : Soit i>n ou bien i<=n. Dans le cas où i>n, çà veut dire qu'on a parcouru toutes cases du vecteur sans trouver aucun élément qui égale à x,
sinon (i<n), ça veut dire que la boucle a été arrêtée à la case i où on trouvé la valeur x, c'est à dire
V[i]=x.
Program exo5_b; Uses wincrt ; var T, V : array [1..100] of Real; i, n : integer ; x:Real; Begin {Les entrées} Write('Donner la taille du vecteur V : '); Read(n); Writeln('Donner les composantes du vecteur V : '); For i:=1 to n do Read( V[i] ); Write('Donner la valeur de x : '); Read(x);
{Les traitements} i:=1; {Initialiser Trouve à false} While (i<=n) AND (V[i] <> x) do i := i+1;
{Les sorties} If i <= n Then Write('x existe dans le vecteur et sa positon est : ', i) Else Write('x n''existe pas dans le vecteur'); End.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Algorithme exo5_b Variables V : Tableau [1..100] de Réel i,n: entier x:Réel Début Lire(n) Pour i←1 à n faire Lire( V[i] ) Fin-Pour Lire(x) i ← 1 Tantque (i <= n) ET (T[i] <> x) Faire i ← i+ Fin-Tantque Si i<=n Alors Écrire('X existe dans la position : ', i) Sinon Écrire('X n''existe pas dans V') Fin-Si Fin
Traitement
n V (i=1..N)
X n'existe pas dans V
x
X existe dans la case n° ...
Selon un Condition
