Exercices corrigés en algorithmique : algorithmes de base

Exercices en  Algorithmique

Exercice 1: 

Ecrire un programme qui échange la valeur de deux variables. Exemple, si a = 2 et b = 5, le programme donnera a = 5 et b = 2.

Correction exercice 1 :

Début
a=2
b=5
t  <--  a
a  <-- b
b  <-- t
Fin

ou bien

Début
a=2
b=5
a  <--  a+b
b  <-- a-b
a  <-- a-b
Fin

Exercice 2

Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et affiche le carré de ce nombre.

Correction exercice 2 :

Variables nb, carr en Entier
Début
Ecrire ”Entrez un nombre :”
Lire nb
carr <--  nb * nb
Ecrire ”Son carré est : ”, carr
Fin

En fait, on pourrait tout aussi bien économiser la variable carr en remplaçant les deux avant-dernières lignes par :

Ecrire ”Son carré est : ”, nb*nb

C’est une question de style ; dans un cas, on privilégie la lisibilité de l’algorithme, dans l’autre, on privilégie l’économie d’une variable.


Exercice 3 :


Ecrire un programme qui lit le prix HT d’un article, le nombre d’articles et le taux de TVA, et qui fournit le prix total TTC correspondant. Faire en sorte que des libellés apparaissent clairement.

Correction exercice 3 :

Variables nb, pht, ttva, pttc en Numérique
Début
Ecrire ”Entrez le prix hors taxes :”
Lire pht
Ecrire ”Entrez le nombre d’articles :”
Lire nb
Ecrire ”Entrez le taux de TVA :”
Lire ttva
pttc  <-- nb * pht * (1 + ttva)
Ecrire ”Le prix toutes taxes est : ”, pttc
Fin

Là aussi, on pourrait squeezer une variable et une ligne en écrivant directement. :

Ecrire ”Le prix toutes taxes est : ”, nb * pht * (1 + ttva)

C’est plus rapide, plus léger en mémoire, mais un peu plus difficile à relire (et à écrire !)

Exercice 4 :

Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si leur produit est négatif ou positif (on laisse de côté le cas où le produit est nul). Attention toutefois : on ne doit pas calculer le produit des deux nombres.

Correction exercice 4 :

Variables m, n en Entier
Début
Ecrire ”Entrez deux nombres : ”
Lire m, n
Si (m > 0 ET n > 0) OU (m < 0 ET n < 0) Alors
Ecrire ”Leur produit est positif”
Sinon
Ecrire ”Leur produit est négatif”
Finsi
Fin

Exercice 5 :

Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur. Ensuite, il l’informe de sa catégorie :
”Poussin” de 6 à 7 ans
”Pupille” de 8 à 9 ans
”Minime” de 10 à 11 ans
”Cadet” après 12 ans

Peut-on concevoir plusieurs algorithmes équivalents menant à ce résultat ?

Correction exercice 5 :

Variable age en Entier
Début
Ecrire ”Entrez l’âge de l’enfant : ”
Lire age
Si age >= 12 Alors
Ecrire ”Catégorie Cadet”
SinonSi age >= 10 Alors
Ecrire ”Catégorie Minime”
SinonSi age >= 8 Alors
Ecrire ”Catégorie Pupille”
SinonSi age >= 6 Alors
Ecrire ”Catégorie Poussin”
Finsi
Fin

On peut évidemment écrire cet algorithme de différentes façons, ne serait-ce qu’en commençant par la catégorie la plus jeune.

Exercice 6 :


Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse convienne. En cas de réponse supérieure à 20, on fera apparaître un message : Plus petit ! , et inversement, Plus grand ! si le nombre est inférieur à 10.

Correction exercice 6 :

Variable N en Entier
Debut
N <--  0
Ecrire ”Entrez un nombre entre 10 et 20”
Lire N
TantQue N < 10 ou N > 20
Si N < 10 Alors
Ecrire ”Plus grand !”
SinonSi N > 20 Alors
Ecrire ”Plus petit !”
FinSi
FinTantQue
Fin

Exercice 7 :

Ecrire un algorithme qui demande un nombre de départ, et qui calcule la somme des entiers jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer : 1 + 2 + 3 + 4 + 5 = 15 NB : on souhaite afficher uniquement le résultat, pas la décomposition du calcul.

Correction exercice 7 :

Variables N, i, Som en Entier
Debut
Ecrire ”Entrez un nombre : ”
Lire N
Som <--  0
Pour i  <-- 1 à N
Som <--  Som + i
i Suivant
Ecrire ”La somme est : ”, Som
Fin

Exercice 8 :

Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle.

NB : la factorielle de 8, notée 8 !, vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 Variables N, i, F en Entier

Correction exercice 8 :

Debut
Ecrire ”Entrez un nombre : ”
Lire N
F <--  1
Pour i <--  2 à N
F <--  F * i
i Suivant
Ecrire ”La factorielle est : ”, F
Fin

Exercice 9 :

Que produit l’algorithme suivant ?

Tableau Nb(5) en Entier
Variable i en Entier
Début
Pour i <--  0 à 5
Nb(i) <--  i * i
i suivant
Pour i <--  0 à 5
Ecrire Nb(i)
i suivant
Fin

Peut-on simplifier cet algorithme avec le même résultat ?

Correction exercice 9 :

Cet algorithme remplit un tableau avec six valeurs : 0, 1, 4, 9, 16, 25.

Il les écrit ensuite à l’écran. Simplification :

Tableau Nb(5) en Numérique
Variable i en Numérique
Début
Pour i  <-- 0 à 5
Nb(i)  <-- i * i
Ecrire Nb(i)
i Suivant
Fin


Exercice 10 :

écrivez un algorithme permettant, à l’utilisateur de saisir les notes d’une classe. Le programme, une fois la saisie terminée, renvoie le nombre de ces notes supérieures à la moyenne de la classe.

Correction exercice 10 :

Variables Nb, i, Som, Moy, Nbsup en Numérique
Tableau T() en Numérique
Debut
Ecrire “Entrez le nombre de notes à saisir : “
Lire Nb
Pour i <--  1 à Nb
Ecrire “Entrez le nombre numero”, i
Lire T(i)
i Suivant
Som   0
Pour i  <-- 1à Nb
Som <--  Som + T(i)
i Suivant
Moy <--  Som / Nb
NbSup <--  0
Pour i  <-- 1 à Nb
Si T(i) > Moy Alors
NbSup  <-- NbSup + 1
FinSi
i Suivant
Ecrire NbSup, “ élèves dépassent la moyenne de la classe”
Fin

Exercices corrigés en algorithmique : Instructions conditionnelles et répétitives

 Exercice 1 : Tarifs

Écrire l’algorithme décrivant un programme permettant à une hôtesse de calculer le prix d’une place en fonction de l’âge du passager. Les enfants de moins de deux ans ne paient pas, ceux qui ont moins de 10 ans paient moitié prix, et les personnes de moins de 27 ans et celles de plus de 70 ans ont une réduction de 10%. L’utilisateur doit saisir le prix de base du billet et l’âge du passager. Le programme affiche le résultat.

Correction exercice 1 :

PROGRAMME Tarifs

VAR      prix,age : entier

DEBUT

AFFICHER « Entrez le prix de la place, puis votre age : »

SAISIR prix,age

Si age<2

Alors AFFICHER« Vous ne payez pas »

Sinon

     Si age<10

Alors AFFICHER« Vous devez payer : »,prix/2

Sinon

Si age<27 OUage>70

Alors AFFICHER« Vous devez payer : »,prix-(prix*10)/100

Sinon AFFICHER« Vous devez payer : »,prix

FinSi

     FinSi

FinSi

FIN

Exercice 2 : Indice de masse corporelle

Écrire le pseudo-code d’un programme demandant à une personne de saisir au clavier son sexe (H/F), sa taille (en cm) et son poids (en kg) et affichant les messages :

• « vous devriez surveiller votre alimentation » si l’indice de masse corporelle (poids/(taille*taille)) est supérieur ou égal à 25 pour un homme ou 23 pour une femme.
• « vous devriez prendre des forces » s’il est inférieur ou égal à 19 pour un homme ou 18 pour une femme.
• « vous êtes à votre poids de forme » sinon.

NB : Les données fournies dans cet exercice n’ont aucune valeur scientifique.

Correction exercice 2 :

PROGRAMME MasseCorpo

VAR      taille,poids,indice     : entier

         sexe               : charactère

         phrase_finale      : chaine

DEBUT

AFFICHER « Quel est votre sexe ? (H/F) »

SAISIR sexe

AFFICHER « Entrez votre taille (en cm) puis votre poids (en kg) »

SAISIR taille,poids

indice <- (poids/(taille*taille))

Si sexe = ‘H’

Alors

Si indice >= 25

Alors phrase_finale<-« vous devriez surveiller votre alim. »

Sinon

Si indice <= 19

Alors phrase_finale<-« vous devriez prendre des forces. »

Sinon phrase_finale<-« Vous êtes à votre poids de forme »

FinSi

FinSi

Sinon

Si indice >= 23

Alors phrase_finale<-« vous devriez surveiller votre alim. »

Sinon

Si indice <= 18

Alors phrase_finale<-« vous devriez prendre des forces. »

Sinon phrase_finale<-« Vous êtes à votre poids de forme »

FinSi

FinSi

FinSi

AFFICHER phrase_finale

FIN

Exercice 3 : Triangles

Écrire en pseudo-code un programme qui demande à l’utilisateur de saisir les valeurs des trois côtés d’un triangle et affiche si le triangle est rectangle, isocèle, isocèle rectangle, ou équilatéral.

Correction exercice 3 :

PROGRAMME Triangles

VAR      a,b,c    : entier

         estRectangle,estIsocele,estEquilateral : booléen

DEBUT

AFFICHER « veuillez entrer l’hypoténuse : »

SAISIR a

AFFICHER « veuillez entrer les 2 autres cotés : »

SAISIR b,c

estRectangle <- a*a=b*b+c*c

estIsocele <- a=b OU a=c OU b=c

estEquilateral <- a=b ET a=c

Si estEquilateral

Alors

AFFICHER « le triangle est equilatéral ! »

Sinon

Si estIsocele ETestRectangle

Alors AFFICHER « le triangle est isocèle rectangle ! »

Sinon

Si estIsocele

Alors

AFFICHER « le triangle est isocèle ! »

Sinon

SI estRectangle

Alors AFFICHER « le triangle est rectangle ! »

Sinon AFFICHER « le triangle n’a pas de propriétés… »

FinSi

FinSi

FinSi

FinSi

FIN

Exercice 4 : Minimum

Écrire l’algorithme affichant le minimum d’une suite de 10 réels saisis au clavier.

Correction exercice 4 :

PROGRAMME Minimum

VAR      boucle   : entier

         min,val  : reel

DEBUT

AFFICHER « Entrez un réel : »

SAISIR min

Pour boucle de 1 à 9 pas de 1, faire

AFFICHER « Entrez un autre réel : »

SAISIR val

Si val<min

Alors min=val

FinSi

FinPour

AFFICHER « le minimum est : », min

FIN

Exercice 5 : Saisie correcte

Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse convienne. En cas de réponse supérieure à 20, on fera apparaître un message : « Plus petit ! », et inversement, « Plus grand ! » si le nombre est inférieur à 10.

Correction exercice 5 :

PROGRAMME SaisieCorrecte

VAR      valeur   : entier

DEBUT

Répéter

AFFICHER « Entrez un nombre entier : »

SAISIR valeur

Si valeur >20

Alors AFFICHER« Plus petit ! »

FinSi

Si valeur <10

Alors AFFICHER« Plus grand ! »

FinSi

Jusqu’à valeur <20 ETvaleur >10

FIN

Exercice 6 : Table de multiplication

Ecrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la table de multiplication de ce nombre, présentée comme suit (cas où l'utilisateur entre le nombre 7) :

Table de 7 :
7 x 1 = 7
7 x 2 = 14
…
7 x 11 = 77
…
7 x 20 = 140

Correction exercice 6 :

PROGRAMME Multiplication

VAR      table,boucle  : entier

DEBUT

AFFICHER « Entrez la table de multiplication : »

SAISIR table

Pour boucle de 1 à 20 pas de 1, faire

AFFICHER table,‘x’, boucle,’=’,table*boucle

FinPour

FIN

Exercices corrigés en algorithmique : Instructions répétitives - les boucles

Exercice 1 :

Ecrire un algorithme permettant de lire une suite de nombres réels sur le clavier. Le dernier élément à lire est un zéro.
L’algorithme doit afficher le plus petit élément de la suite ainsi que la somme des éléments lus.


Correction exercice 1 :

Algorithme  lire_une_suite;
Var
            a,s : réels ;
Debut
              Repeter
                        Ecrire(‘entrer un  nombre: ‘) ;
                        Lire(a) ;
                        S<-- s+a ;
              Jusqu'à (a=0)
              Ecrire(‘la somme des nombres est :  ‘,s) ;
fin


Exercice 2 :

Ecrire un algorithme qui lit les noms des athlètes désirant participer à un marathon et s’arrête lorsqu’il rencontre deux noms consécutifs identiques.
L’algorithme doit afficher , à la fin , le nombre de participants.


Correction exercice 2 :

Algorithme  lire_une_suite;
Var
            Nom1,nom2 : chaine de 30 caractères ;
            Compteur  i  :entier ;
Debut
                Ecrire(‘entrer un nom d’athlète   : ‘) ;
                Lire(nom1) ;
                Ecrire(‘entrer un nom d’athlète   : ‘) ;
                Lire (nom2) ;
                i <--  2 ;
              Tantque(nom1 <> nom2)
                        Nom1 <--  nom2 ;
                        Ecrire(‘entrer un  nom d’athlète  : ‘) ;
                        Lire(nom2) ;
                        i<-- i+1;
              Fintantque
              Ecrire(‘le nombre des participants est :  ‘,i) ;
fin


Exercice 3 :

Dans un cinéma , on désire calculer la moyenne  d’âges de personnes s’intéressant à voir un film particulier.
Pour finir, l’utilisateur doit répondre par ‘N’ à la question posée par l’algorithme :
‘’ Encore une autre personne (O/N) ? ’’
Et on doit afficher la moyenne d’âges des personnes à l’ecran.


Correction exercice 3 :

Algorithme  moyenne_age;
Var
            i ,age,som :entier ;
Debut
                i <--  0 ;
                age <--  0 ;
                Repeter
                        Ecrire(‘ entrer l’age du personne ’) ;
                        Lire(‘age’ ) ;
                          i<--  i+1 ;
                        Som <--  som+ age ;
                          Ecrire(‘Encore une autre personne (O/N) ?’)
                          Lire(rep) ;
                Jusqu'à (rep=’N’)
              Ecrire(‘la moyenne d’âges des personnes  est :  ‘,som/i) ;
fin


Exercice 4 :

Ecrire un algorithme permettant de calculer la factorielle d’un nombre entier positif N.
N ! = 1*2*3*……..*N


Correction exercice 4 :

Algorithme  factorielle;
Var
              i ,N,fact:entier ;
Debut
                fact<--  1 ;
                pour i=1 à N faire
                             fact<-- fact*i ;
                Finpour  i
              Ecrire(‘ la factorielle de  ’ ,N,’  est   : ‘,fact  ) ;
fin


Exercice 5 :

Pour avoir une idée sur le niveau des éleves d’une classe, on a décidé de calculer la moyenne  de la classe à partir des moyennes générales de tous les élèves qui sont au nombre de 30.
         Moy =
Ecrire un algorithme de résolution.


Correction exercice 5 :

Algorithme  moyenne_classe;
Var
              i   :entier ;
                NT ,som: réels
const
                nb=30 ;
Debut
                Som <--  0 ;
                pour i=1 à N faire
                            Ecrire(‘ entrer la note N°’,i,’ :’) ;
                            Lire(NT) ;
                            Som<-- som+NT ;
                Finpour  i
              Ecrire(‘ la moyenne de la classe est : ‘,som/nb ) ;
fin


Exercice 6 :

Ecrire un algorithme qui permet de retrouver le maximum, le minimum ainsi que la somme d’une liste de nombres positifs saisis par l’utilisateur. La fin de la liste est indiquée par un nombre négatif. La longueur  de la liste n’est pas limitée.
Exemple :              si la liste des éléments est : 7   3   20     15    2      6    5   -1
                                Le maximum est 20  , le minimum est 2 .


Correction exercice 6 :

Algorithme  moyenne_age;
Var
            i ,n,som :entier ;
Debut
                Ecrire(‘ entrer un nombre ’) ;
              Lire(‘n’ ) ;
                max<--  n ;
                min <--  n ;
                som <--  n ;
                Tantque n>0  faire
                        Ecrire(‘ entrer  un nombre’) ;
                        Lire(‘n’ ) ;
                         Si min>n  alors
                                Min <--  n ;
                         Finsi
             Si max<n  alors
                                 Max <--  n ;
                          Finsi
                fintantque
              Ecrire(‘Le maximum est  ‘,max ,’ le minimum est ‘,min) ;
fin

Exercices corrigés en algorithmique : Les tableaux

Exercice 1 :

Ecrire un algorithme permettant  d’entrer cinq valeurs réelles au clavier,les stocker dans un tableau, calculer leur somme et les afficher avec leur somme à l’ecran.

Correction exercice 1 :

Algorithme  tableau_somme;
Var
              V   : tableau [1..5] de réels ;
              S   :  réel ;
i  :entier;
Debut
                (*lecture  des élements  du tableau*)
                Pour i <--  1 à 5 faire
                               Ecrire(‘entrer l’element  N° ’,i);
                               Lire(V[i]) ;
                Finpour i
                (*calcul de la somme des élements du tableau *)
                S <--  0 ;
Pour i <--  1 à 5 faire
                               S <--  S + V[i] ;
                Finpour i
(*afficher des éléments du tableau *)
                Pour i <--  1 à 5 faire
                               Ecrire(‘l’’element  N° ’,i,’est : ‘,V[i]);
                Finpour i
                Ecrire(‘la somme des éléments du tableau est :‘,S) ;
fin


Exercice 2 :

Ecrire un algorithme permettant  de saisir et d’afficher N éléments d’un tableau.


Correction exercice 2 :

Algorithme  saisie_affichage;
Var
              T   : tableau [1..100] de réels ;
              N,i   :  réel ;
Debut
                Ecrire(‘entrer le nombre d’éléments du tableau :’) ;
                Lire(N) ;
                (*lecture  des élements  du tableau*)
                Pour i <--  1 à N faire
                               Ecrire(‘entrer l’element  N° ’,i);
                               Lire(T[i]) ;
                Finpour i
(*afficher des éléments du tableau *)
                Pour i <--  1 à N faire
                               Ecrire(‘l’’element  T[’,i,’] est : ‘,T[i]);
                Finpour i
Fin


Exercice 3 :

Ecrire un algorithme permettant  de calculer la somme,produit et moyenne des  éléments d’un tableau.


Correction exercice 3 :

Algorithme  somme_produit_moyenne;
Var
              T   : tableau [1..100] de réels ;
              N,i   :  entiers ;
                S,P,M :  réels ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                         S <--  0 ;
                         P <--  1 ;
                         Pour i <--  1 à N faire
                               S <--  S+T[i] ;
                               P <--  P * T[i] ;
                           Finpour i
                           M <--  S/N ;
                            Ecrire(‘la somme des éléments du tableau est : ‘,S);
                Ecrire(‘le produit des éléments du tableau est : ‘,P);
                Ecrire(‘la  moyenne des éléments du tableau est : ‘,M);
Finsi
Fin


Exercice 4 :

Ecrire un algorithme permettant  de consulter un  élément d’un tableau.

Correction exercice 4 :

Algorithme  consultation;
Var
              T   : tableau [1..100] de réels ;
              N,P   :  entiers ;
Debut
                Si N=0 alors
                        Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer l’’indice de l’’élément à consulter :’) ;
                        Lire(P) ;
                        Si (P<1) ou (P>N) alors
                                Ecrire(‘Position hors limites du tableau ‘)
                        Sinon
                                Ecrire(‘l’’élément à consulter est :’,T[P]) ;
                         Finsi
                Finsi
Fin


Exercice 5 :

Ecrire un algorithme permettant  de chercher toutes les occurrences d’un  élément  dans un tableau.


Correction exercice 5 :

Algorithme  recherche_toutes_occurences ;
Var
              T   : tableau [1..100] de réels ;
              N,i   :  entiers ;
                X : réel ;
                Existe : booléen ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        Existe <--  Faux ;
                        Pour i <--  1  à N  Faire
                                Si T[i] = X alors
                                               Existe <--  Vrai ;
                                               Ecrire(‘l’’élément à chercher apparait à la position : ‘,i) ;
                                Finsi
                         Finpour i
                         Si Existe = Faux alors
                                   Ecrire(‘l’’élément n’’apparait pas dans ce tableau ‘) ;
                           Finsi
                 Finsi
Fin


Exercice 6 :

Ecrire un algorithme permettant  de chercher  la première occurrence d’un élément dans un tableau.


Correction exercice 6 :

Algorithme  recherche_première_occurence ;
Var
T   : tableau [1..100] de réels ;
             P, N,i   :  entiers ;
                X : réel ;
                Existe : booléen ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        Existe <--  Faux ;
                        i <--  1 ;
                        tantque  (i<=N) et (Existe=Faux) Faire
                                Si T[i] = X alors
                                               Existe <--  Vrai ;
                                               P<--  i ;
                                Sinon
                                               i ßi+1 ;
                                Finsi
                       Fintantque
                       Si Existe = vrai alors
                                Ecrire(‘la première occurrence de l’élément dans ce tableau est :’,P) ;
                       Sinon
                                Ecrire(‘l’’élément n’’apparait pas dans ce tableau ‘) ;
                      Finsi
                Finsi
Fin


Exercice 7 :

Ecrire un algorithme permettant  de chercher  la dernière occurrence d’un élément dans un tableau.


Correction exercice 7 :

Algorithme  recherche_derniere_occurence ;
Var
T   : tableau [1..100] de réels ;
             P, N,i   :  entiers ;
                X : réel ;
                Existe : booléen ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        Existe <--  Faux ;
                        i <--  N ;
                        tantque  (i>=1) et (Existe=Faux) Faire
                                Si T[i] = X alors
                                               Existe <--  Vrai ;
                                               P<--  i ;
                                Sinon
                                               i <-- i-1 ;
                                Finsi
                       Fintantque
                       Si Existe = vrai alors
                                Ecrire(‘la dernière occurrence de l’élément dans ce tableau est :’,P) ;
                       Sinon
                                Ecrire(‘l’’élément n’’apparait pas dans ce tableau ‘) ;
                      Finsi
                Finsi
Fin


Exercice 8 :

Ecrire un algorithme permettant  de calculer le nombre de fois pour lesquelles un  élément  apparait dans un tableau.


Correction exercice 8 :

Algorithme  frequence;
Var
              T   : tableau [1..100] de réels ;
              N,i,F   :  entiers ;
                X : réel ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        F <--  0 ;
                        Pour i <--  1  à N  Faire
                                Si T[i] = X alors
                                               F <--  F+1 ;
                                Finsi
                         Finpour i
                                   Ecrire(‘l’’élément  apparait : ‘, F,’fois dans ce tableau ‘) ;
                 Finsi
Fin


Exercice 9 :

Ecrire un algorithme permettant  d’ajouter un élément a la fin d’un tableau.


Correction exercice 9 :

Algorithme  Ajout;
Var
              T   : tableau [1..100] de réels ;
              N :  entiers ;
                X : réel ;
                Rep : caractère ;
Debut
                Ecrire(‘entrer la valeur de l’’élément à ajouter   :’) ;
                Lire(X) ;
                 Ecrire(‘Confirmer l’ajout (O/N) :’) ;
                 Lire(Rep) ;
                Si Rep =’O’ alors  (*la valeur ‘o’ pour ‘oui’ ! et ‘N’ pour ‘Non’ *)                    
                               N<--  N+1 ;(* il y aura un élément en plus *)
                                T[N] <--  X ;
                 Finsi
Fin


Exercice 10 :

Ecrire un algorithme permettant  de modifier  un élément  dans un tableau.


Correction exercice 10 :

Algorithme Modification;
Var
              T   : tableau [1..100] de réels ;
              N ,P:  entiers ;
                X : réel ;
                Rep : caractère ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                Ecrire(‘entrer l’indice de l’’élément à  modifier :’) ;
                Lire(P) ;
                      Si (P<1) ou (P>N) alors
                                Ecrire(‘Position hors limites du tableau ‘)
                       Sinon
                                Ecrire(‘L’ancienne valeur dans cette position est :’,T[p]) ;
                                Ecrire(‘Entrer la nouvelle valeur :’) ;
                                Lire(X) ;
                                Ecrire(‘Confirmer  la modification (O/N) ‘) ;
                                Lire(Rep) ;
                                Si Rep=’O’ Alors
                                          T[P]<--  X ;
                                Finsi
                       Finsi
                Finsi
Fin


Exercice 11 :

Ecrire un algorithme permettant  d’insérer  un élément  dans un tableau  (au début , au milieu ou  à la fin).


Correction exercice 11 :

Algorithme  insertion;
Var
              T   : tableau [1..100] de réels ;
              N ,P,i:  entiers ;
                X : réel ;
                Rep : caractère ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                Ecrire(‘entrer la valeur de l’’élément à insérer  :’) ;
                Lire(X) ;
                 Ecrire(‘ Entrer la position d’insertion :’) ;
                 Lire(P) ;
                      Si (P<1) ou (P>N) alors
                                Ecrire(‘Position hors limites du tableau ‘)
                       Sinon
                                Ecrire(‘Confirmer l’insertion (O/N) ‘) ;
                                Lire(Rep) ;
                                Si Rep=’O’ Alors
                                               N <--  N+1 ;
                                               Pour i <--  N à P+1 Faire
                                                               T[i] <--  T[i-1] ;
                                               Finpour i
                                               T[P]<--  X ;
                                Finsi
                       Finsi
                Finsi
Fin


Exercice 12 :

Ecrire un algorithme permettant  de supprimer  un élément  dans un tableau.


Correction exercice 12 :

Algorithme  suppression;
Var
              T   : tableau [1..100] de réels ;
              N ,P,i:  entiers ;
                Rep : caractère ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                                Ecrire(‘entrer l’indice  de l’’élément à supprimer  :’) ;
                                Lire(P) ;
                               Si (P<1) ou (P>N) alors
                                        Ecrire(‘Position hors limites du tableau ‘)
                              Sinon
                                         Ecrire(‘la valeur dans cette position est :‘,T[P]) ;
                                         Ecrire(‘Confirmer la suppression  (O/N) ‘) ;
                                         Lire(Rep) ;
                                         Si Rep=’O’ Alors
                                                 N <--  N+1 ;
                                                 Pour i <--  P à N-1 Faire
                                                               T[i] <--  T[i+1] ;
                                                 Finpour i
                                                  N <--  N-1; (*il y aura un élément en moins*)
                                           Finsi
                            Finsi
                Finsi
Fin


Exercice 13 :

Ecrire un algorithme permettant  de trier  par ordre croissant les éléments  d’un tableau.


Correction exercice 13 :

Algorithme  tri_Croissant;
Var
              T   : tableau [1..100] de réels ;
              N ,i,j:  entiers ;
                Aux: réel ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                          Pour i <--  1 à N-1 Faire
                                               Pour j <--  i+1 à N  Faire
                                                           Si T[i] > T[j]  alors
                                                                    Aux <--  T[i] ;
                                                                    T[i] <--  T[j] ;
                                                                    T[j] <--  Aux ;
                                                               Finsi
                                             Finpour j
                           Finpour i
                Finsi
Fin


Exercice 14 :

Ecrire un algorithme permettant  de trier  par ordre décroissant les éléments  d’un tableau.


Correction exercice 14 :

Algorithme  tri_Décroissant;
Var
              T   : tableau [1..100] de réels ;
              N ,i,j:  entiers ;
                Aux: réel ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                          Pour i <--  1 à N-1 Faire
                                               Pour j <--  i+1 à N  Faire
                                                           Si T[i] < T[j]  alors
                                                                    Aux <--  T[i] ;
                                                                    T[i] <--  T[j] ;
                                                                    T[j] <--  Aux ;
                                                               Finsi
                                             Finpour j
                           Finpour i
                Finsi
Fin


Exercice 15 :

Ecrire un algorithme permettant  de fusionner les éléments  de deux tableaux T1 et T2 dans un autre tableau T.
N.B :
 N : nombre des éléments  du tableau T1
M : nombre des éléments du tableau T2


Correction exercice 15 :

Algorithme  fusion_deux_tableaux;
Var
              T1,T2   : tableau [1..100] de réels ;
                T   : tableau [1..200] de réels ;
              N ,M,i:  entiers ;
Debut
                Si  (N=0)  et (M=0) alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                          Pour i <--  1 à N Faire
                                T[i] <--  T1[i] ;
                           Finpour i
                           Pour i <--  1 à M Faire
                                T[N+i] <--  T2[i] ;
                           Finpour i

                Finsi
Fin


Exercice 16 :

Ecrire un algorithme permettant  de saisir les données d’un tableau à deux dimensions (10,4), de faire leur somme, produit et moyenne et de les afficher avec les résultats de calcul à l’écran.


Correction exercice 16 :

Algorithme  tableau_deux_dimension;
Var
              T : tableau [1..10,1..4] de réels ;
              I,j:  entiers ;
                S,P,M : réels ;
Debut
                 (*saisie des éléments du tableau *)
                 Pour i <--  1 à 10 Faire
                                 Pour j<--  1 à 4 Faire
                                              Ecrire(‘entrer l’’element T[‘,i,’,’,j,’] :’;
                                                Lire(T[i,j]) ;
                                Finpour j;
                Finpour i
 (*calcul de la somme ,produit et moyenne *)
S <-- 0 ;
P <--  1 ;
                Pour i <--  1 à 10 Faire
                                Pour j<--  1 à 4 Faire
                                             S <--  S+T[i,j] ;
                                             P <--  P + T[i,j] ;
                                Finpour j;
                Finpour i
                M <--  S/40 ; (*40 : nombre d’élément du tableau = 10x4 *)
                (* Affichage des éléments du tableau et des résultats *)
                Pour i <--  1 à 10 Faire
                                Pour j<--  1 à 4 Faire
                                             Ecrire(‘l’’élément T[‘,i,’,’,j,’] = ‘, T[i,j]);
                                Finpour j;
                Finpour i
                Ecrire(‘la somme des éléments du tableau est :’,S) ;
                Ecrire(‘le produit des éléments du tableau est :’,P) ;
                Ecrire(‘la moyenne  des éléments du tableau est :’,M) ;
Fin


Exercice 17 :

Ecrire un algorithme qui calcule la somme des éléments de la diagonale d’une matrice carrée M(n,n) donnée.


Correction exercice 17:

Algorithme  diagonale_de_matrice;
Const
                N=8 ;
Var
              M : tableau [1..8,1..8] d’entiers;
              i,j:  entiers ;
                Sdiag: entiers;
Debut
                 (*saisie des éléments de la matrice*)
                 Pour i <--  1 à n  Faire
                                 Pour j<--  1 à n Faire
                                              Ecrire(‘entrer l’’element M[‘,i,’,’,j,’] :’;
                                                Lire(M[i,j]) ;
                                Finpour j;
                Finpour i
 (*calcul de la somme  des éléments de la diagonale  *)
Sdiag <--  0 ;
                Pour i <--  1 à n Faire
                                Sdiag <--  Sdiag +M[i,j] ;
                Finpour i
                Ecrire(‘la somme des éléments  de la diagonale est :’,Sdiag) ;
Fin


Exercice 18 :

Ecrire un algorithme permettant d’effectuer le produit  des matrices A(n,m) et B(m,p) .
n ,m et p données (par exemple n=4,m=5,p=3 ).
N.B :
            Pour pouvoir faire le produit de deux matrices, il faut absolument que le nombre de colonnes
            de la première soit égal au nombre de lignes de la deuxième.


Correction exercice 18 :

Algorithme  produit_matrices;
Const
            n=4;
m=5;
p=3;
Var
              A : tableau [1..n,1..p] de réels;
              B : tableau [1..p,1..m] de réels;
              C : tableau [1..n,1..m] de réels;
  i,j:  entiers ;
Debut
                 (*lecture  des éléments des deux matrices*)
                 Pour i <--  1 à n  Faire
                                 Pour j<-- 1 à p Faire
                                              Ecrire(‘entrer l’’element A[‘,i,’,’,j,’] :’);
                                                Lire(A[i,j]) ;
                                Finpour j;
                Finpour i
                 Pour i <--  1 à p  Faire
                                 Pour j<--  1 à m Faire
                                              Ecrire(‘entrer l’’element B[‘,i,’,’,j,’] :’);
                                                Lire(B[i,j]) ;
                                Finpour j;
                Finpour i
 (*calcul de produit des deux matrices*)
                Pour i <--  1 à n  Faire
                                 Pour j<--  1 à m Faire
                                              C[i,j] <--  0 ;
                                               Pour k <--  1 à p faire
                                                               C[i,j] <--   C[i,j] + A[i,k] *B[k,j] ;
                                                Finpour k
                                Finpour j;
                Finpour i
                (*Affichage de la matrice produit*)
                 Pour i <--  1 à n  Faire
                                 Pour j<--  1 à m Faire
                                              Ecrire(‘l’’element C[‘,i,’,’,j,’] =’,C[i,j]);
                                Finpour j;
                Finpour i
Fin


Exercice 19 :

Ecrire un algorithme permettant  de construire dans une matrice carrée P et d’afficher le triangle de PASCAL  de degré N.
N.B :
            On poura utiliser cette relation pour les éléments de triangle de PASCAL :
                                                       Pi,j = Pi-1,j-1 + Pi-1,j
             Exemple : triangle de pascal de degré 5 :
N=0              -        1
N=1              -        1     1
N=2              -        1     2       1
N=3              -        1     3       3       1
N=4              -        1     4       6       4       1
N=5              -        1     5      10     10    15    1


Correction exercice 19 :

Algorithme  triangle_pascal;
Var
               P: tableau [1..100,1..100] de réels;
  i,j,n:  entiers ;
Debut
                Ecrire(‘entrer l’ordre du  triangle de pascal que vous voulez :’) ;
                Lire(n) ;
                (*remplissage du triangle de Pascal*)
                P[1,1] <--  1 ;
                 Pour i <-- 2 à n+1  Faire
                               P[i,1] <--  1 ;
                                 Pour j<-- 2 à i-1 Faire
                                           P[i,j]  <-- P[i-1,j-1] + P[i-1,j]
                                Finpour j;
                                P[i,j] <-- 1 ;
                Finpour i
                (* affichagedu triangle de Pascal*)
                 Pour i <--  1 à n+1  Faire
                                 Pour j<--  1 à i Faire
                                              Ecrire(P[i,j] ,’           ‘);
                                Finpour j;
                                 (*retour a la ligne *)
                Finpour i
Fin