Sem 1. TD 3.1 Corrigés PDF

CFPA Mixte Younes Lekhel Bejaia
Section : T.S Informatique, option bases de données Date : 25/12/2018

Matière : Algorithmique, série de travaux dirigés n° 3.1 PSFEP: Mr Boudries
Exercice 1:
Que produisent les algorithmes suivants?
Algorithme Algo1;
Var i: entier;
Nb: tableau[1..5] de entier;
Début
Pour i allant de 1 à 5 faire
Nb[i]i*i ;
Fpour;
Écrire(Nb[i]);
Fpour;
Fin.
Algo1:
Déclare un tableau de 5 entiers, le remplit avec les carrés de 1 à 5 (1, 4, 9, 16, 25), puis affiche tous les éléments de ce tableau,
un par un.
Algo2:
Déclare un tableau de 7 entiers, initialise le premier élément à 1, remplit le reste du tableau avec l'élément précédent
additionné de 2 (1, 3, 5, 7, 9, 11, 13), puis affiche tous les éléments de ce tableau.
Algo3:
Déclare un tableau de 10 entiers, fait saisir tous les éléments du tableau par l'utilisateur, ensuite écrase chaque valeur saisie par
l'utilisateurs, par son double.
Exercice 2:
Écrire un algorithme qui déclare et remplisse un tableau contenant les six voyelles de l’alphabet latin (A,E,I,O,U,Y)
Algorithme Exo2;
Var T: tableau[1..6] de char;
Début
T[1]'A';
T[2]'E';
T[3]'I';
T[4]'O';
T[5]'U';
T[6]'Y';
Fin.
Exercice 3:
Écrire un algorithme qui déclare et remplisse un tableau de 7 valeurs numériques en les mettant toutes à zéro
Algorithme Exo3;
Var i: entier;
T: tableau[1..7] de réel;
Début
T[i]0;
Finpour;
Fin.
1

Exercice 4:
Écrire un algorithme qui permet de remplir un tableau de 10 éléments, et d’afficher son contenu
Algorithme Exo4;
Var i: entier;
Début
Écrire ('Veuillez saisir l'élément n°:', i);
Lire(T[i]);
Fpour;
Écrire(T[i]);
Fpour;
Fin.
Exercice 5:
Écrire un algorithme qui permet de remplir un tableau de N éléments (N compris entre 1 et 50) et d’afficher son contenu
Algorithme Exo5;
Var i, N: entier;
T: tableau[1..50] de entier;
Début
//Demander à l'utilisateur le nombre d'éléments du tableau
Répeter
Écrire ('Saisissez un nombre d'éléments du tableau, compris entre 1 et 50' );
Lire(N);
Jusqu'à (N≥1) et (N≤50);
//Saisie des éléments, en fonction du nombre d'éléments N saisi précédemment

Pour i allant de 1 à N faire
Lire(T[i]);
Fpour;
//Affichage de chaque élément du tableau

Écrire(T[i]);
Fpour;
Fin.
Exercice 6:
Écrivez un algorithme calculant la somme des valeurs d’un tableau (on suppose que le tableau a été préalablement saisi).
Algorithme Exo6;
Var i, som: entier;
T: tableau[1..100] de entier; //On suppose une taille de tableau, quand ce n'est pas spécifié
Début
som0;
//Parcourir tous le tableau, et additionner chaque élément à som
somsom+ T[i];
Fpour;
Écrire(' La somme des éléments du tableau est: ', som);
Fin.
2

Exercice 7:
Écrire un algorithme qui déclare un tableau de 9 notes, dont on fait ensuite saisir les valeurs par l’utilisateur, ensuite calcule la
moyenne des notes et l'affiche à l’écran.
Algorithme Exo7;
Var i: entier;
som, moy: réel;
Début
Lire(T[i]);
Fpour;
som0;
Pour i allant de 1 à 9 faire //Calcul de la somme d'abord
somsom+ T[i];
Fpour;
moysom / 9; //Calcul de la moyenne ensuite
Écrire(' La moyenne des notes est: ', moy);
Fin.
Exercice 8:
Écrire un algorithme qui calcule la somme des entiers positifs, ainsi que la somme des entiers négatifs dans un tableau.
Algorithme Exo8;
Var i, neg, pos: entier;
Début
Pour i allant de 1 à 50 faire //Remplissage du tableau par l'utilisateur d'abord
Écrire ('Veuillez saisir l'élément n° :', i); Lire(T[i]);
Fpour;
neg0; pos0;
Pour i allant de 1 à 50 faire //Parcours du tableau
Si T[i]>0 alors //Additionner chaque élément positif trouvé à la variable pos
pospos+ T[i];
Sinon //Additionner chaque élément négatif trouvé à la variable neg
negneg+ T[i];
Fsi;
Fpour;
Écrire(' La somme des valeurs positives est: ', pos);
Écrire(' La somme des valeurs négatives est: ', neg);
Fin.
Exercice 9:
Écrivez un algorithme qui demande à l'utilisateur de saisir 16 entiers qui seront répartis dans deux tableaux de taille 8 chacun.
L'algorithme calculera ensuite la somme des deux tableaux, comme suit:
3

Algorithme Exo9;
Var i: entier;
T1, T2, T3: tableau[1..8] de entier;
Début
Pour i allant de 1 à 8 faire //Remplissage du tableau T1 par l'utilisateur
Écrire (' Veuillez saisir l'élément n° : ', i);
Lire(T1[i]);
Fpour;
Pour i allant de 1 à 8 faire //Remplissage du tableau T2 par l'utilisateur
Écrire (' Veuillez saisir l'élément n° : ', i+8);
Lire(T2[i]);
Fpour;
Pour i allant de 1 à 8 faire //Calcul de la somme, comme indiquée
T3[i]T1[i] + T2[i];
Fpour;
Fin.
Exercice 10:
Écrire un algorithme qui permet de rechercher un élément donné X dans un tableau, en renvoyant son indice (si l'élément X est
trouvé dans le tableau bien sûr).
Algorithme Exo10;
Var i, X, pos: entier;
trouve: booléen;
Début
//Remplissage du tableau par l'utilisateur
Écrire (' Veuillez saisir l'élément n° : ', i);
Lire(T[i]);
Fpour;
Écrire (' Veuillez saisir l'élément à rechercher : '); Lire(X); //Saisie de la valeur à rechercher par l'utilisateur
//Initialisation de i, utilisé comme indice de parcours

//Initialisation de trouve, utilisé pour arrêter la boucle quand X est trouvé
i1; trouvefaux;
//La boucle Tant que est plus adaptée que la boucle Pour, afin d'arrêter la recherche dès que X est trouvé
// Parcours du tableau, qui s'arrête quand on trouve X ou on atteint la fin du tableau
Tant que (trouve=faux) et (i≤30) faire
Si T[i]=X alors //Si on trouve X, on récupère sa position, et on met trouve à vrai, pour arrêter le parcours du tableau
posi;
trouvevrai;
Fsi;
ii+1 ; //Incrémentation de l'indice i, utilisé pour le parcours
FTQ;
Si trouve= faux alors //Élément non trouvé

Écrire(' L'élément ', X, 'n'a pas été trouvé. ');
Sinon //Élément trouvé
Écrire(' L'élément ', X, 'a été trouvé à la position: ', pos);
Fsi;
Fin.
4

Exercice 11:
Écrire un algorithme qui permet de rechercher le minimum et le maximum dans un tableau de N réels.
Algorithme Exo11;
Var i, N: entier;
T: tableau[1..50] de réels;
max, min: réels;
Début
//Demander à l'utilisateur le nombre d'éléments du tableau
Répeter
Écrire ('Saisissez un nombre d'éléments du tableau, compris entre 1 et 50' ); Lire(N);
//Saisie des éléments, en fonction du nombre d'éléments N saisi précédemment
Écrire ('Veuillez saisir l'élément n°:', i); Lire(T[i]);
Fpour;
minT[1]; maxT[1]; //On suppose la valeur du min et du max, comme étant le 1er élément du tableau
Pour i allant de 2 à N faire //Parcours de tout le tableau

Si T[i]<min alors //A chaque fois qu'on trouve un élément inferieur à min, cet élément devient le nouveau min
minT[i];
Fsi;
Si T[i]>max alors //A chaque fois qu'on trouve un élément supérieur à max, cet élément devient le nouveau max
maxT[i];
Fsi;
Fpour;
Écrire (' Le minimum est : ', min); Écrire (' Le maximum est : ', max); //Affichage du résultat
Fin.
Exercice 12:
É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
Algorithme Exo12;
Var i, N, som, compt: entier;
T: tableau[1..50] de réels; //On majore la classe à 50 élèves
moy: réel;
Début
//Demander à l'utilisateur la taille de la classe
Répeter
Écrire ('Saisissez le nombre d'élèves de la classe, compris entre 1 et 50' ); Lire(N);
//Saisie des notes, en fonction du nombre d''eleves N saisi précédemment
Écrire ('Veuillez saisir la note de l'élève n°:', i); Lire(T[i]);
Fpour;
//Calcul de la moyenne de la classe d'abord

som0;
somsom+ T[i];
Fpour;
moysom / N;
5

//Parcours de tout le tableau à la recherche de notes supérieures aux moyennes de la classe

compt0;
Si T[i]>moy alors //A chaque fois qu'on trouve une note supérieure à moy, on incrémente le compteur
comptcompt+1;
Fsi;
Fpour;
Écrire (' Il y a ', compt, ' notes supérieurs à la moyenne '); //Affichage du résultat
Fin.
Exercice 13:
Écrire un algorithme qui calcule le nombre d’occurrences (apparitions) d’un élément donné X dans un tableau, et qui affiche
l'indice de la dernière occurrence de cet élément.
Algorithme Exo13;
Var i, X, pos, compt: entier;
Début
Écrire (' Veuillez saisir l'élément n° : ', i); Lire(T[i]);
Fpour;
// Parcours du tableau, à la recherche d'occurrences de X

compt0;
Si T[i]=X alors //Si on trouve X, on récupère sa dernière position, et on incrémente le compteur
posi;
comptcompt+1;
Fsi;
Fpour;
Si compt= 0 alors //Élément non trouvé

Écrire(' L'élément ', X, 'a été trouvé', compt, 'fois ');
Écrire(' Sa dernière position est ', pos);
Fsi;
Fin.
Exercice 14:
Écrire un algorithme qui calcule le nombre d’occurrences d’un élément donné X dans un tableau, et qui affiche l'indice de la
première occurrence de cet élément.
Algorithme Exo14;
Var i, X, pos, compt: entier;
Début
Fpour;
6

// Parcours du tableau, à la recherche d'occurrences de X

compt0;
Si T[i]=X alors //Si on trouve X, on incrémente le compteur
comptcompt+1;
Fsi;
Si (compt=1) et (T[i]=X) alors //Récupérer la position d'uniquement de la première occurrence trouvée
posi;
Fsi;
Fpour;
Si compt=0 alors //Élément non trouvé

Écrire(' L'élément ', X, 'a été trouvé', compt, 'fois ');
Écrire(' Sa première position est ', pos);
Fsi;
Fin.
Exercice 15:
Écrivez un algorithme qui teste si les éléments d'un tableau sont triés par ordre croissant (-4, 0, 5, 6, 20, 32…)
Algorithme Exo15;
Var i: entier;
trie: booléen;
Début
Fpour;
// On suppose que le tableau est trié, on arrête le parcours des qu'on trouves deux valeurs successives non triées
trievrai; i1;
Tant que (trie=vrai) et (i≤49) faire
Si T[i]> T[i+1]> alors //Si on trouve deux éléments non triés, alors le tableau n'est pas trié
triefaux;
Fsi;
FTQ;
Si trie=vrai alors //Tableau trié

Écrire(' Le tableau est trié par ordre croissant. ');
Sinon //Tableau non trié
Écrire(' Le tableau n'est pas trié par ordre croissant. ');
Fsi;
Fin.
Exercice 16:
Écrivez un algorithme qui teste si les éléments d'un tableau sont triés. Si c'est le cas, il affichera à l'utilisateur le type du tri
(croissant, décroissant).
7

Algorithme Exo16;
Var i, j: entier;
Début
Fpour;
// On suppose que le tableau est trié par ordre croissant: si c'est le cas, i sortira avec une valeur i=50
i1;
Tant que (i≤49) et (T[i] ≤ T[i+1]) faire
FTQ;
// On suppose que le tableau est trié par ordre décroissant: si c'est le cas, j sortira avec une valeur j=50
j1;
Tant que (j≤49) et (T[j] ≥ T[j+1]) faire
jj+1 ; //Incrémentation de l'indice j, utilisé pour le parcours
FTQ;
Si i=50 alors //i=50,donc tableau trié par ordre croissant

Écrire(' Le tableau est trié par ordre croissant. ');
Sinon
Si j=50 alors //j=50,donc tableau trié par ordre décroissant
Écrire(' Le tableau est trié par ordre décroissant. ');
Sinon // i≠50 et j≠50, donc tableau non trié
Écrire(' Le tableau n'est pas trié. ');
Fsi;
Fsi;
Fin.
Exercice 17:
Soit un tableau T rempli uniquement de 0 et de1.
Écrire un algorithme qui retourne la position i dans le tableau telle que T[i] est le début de la plus longue suite consécutive de
zéros.
Algorithme Exo17;
Var i, pos, long, max: entier;
Début
//On suppose le tableau est déjà rempli, on le parcourt du premier au dernier élément
long0; pos0; max0;
Si T[i]=0 alors //si on rencontre un 0, on incrémente le compteur long (la longueur de la suite de 0)
longlong+1;
Fsi;
Si long>max alors //si la nouvelle suite de 0 est plus longue que la précédente
maxlong; // on affecte à max la nouvelle plus grande longueur
posi-max+1; // on récupère la position du premier élément de cette suite de 0
Fsi;
Si T[i]=1 alors //Si on rencontre un 1, ça veut dire que la suite précédente de 0 est finie, on commence une nouvelle
long0;
Fsi;
Fpour;
8

Si max=0 alors //Aucun 0 dans le tableau

Écrire(' Il n'y a aucun 0 dans le tableau ');
Sinon //il y'a des 0 dans le tableau
Écrire('La plus grande suite de 0 commence à l''indice: ',pos); Écrire ('Sa longueur est: ',max);
Fsi;
Fin.
Exercice 18:
Écrire un algorithme qui permet d'échanger les valeurs de deux tableaux de taille N.
Algorithme Exo18;
Var i, inter: entier;
T1, T2: tableau[1..50] de entier;
Début
//On suppose les tableaux est déjà remplis, et on les parcourt
interT1[i]; //On récupère la valeur d'un élément de T1 dans une variable intermédiaire inter
T1[i] T2[i]; //On affecte la valeur d'un élément de T2 à un élément de T1, du même indice
T2[i] inter; //On affecte la valeur de la variable intermédiaire stockée précédemment à un élément de T2
Fpour;
Fin.
Exercice 19:
Écrire un algorithme qui permet de tester si un tableau est symétrique. Par exemple, les tableaux suivants sont symétriques :
Tableau 1: 3, 2, 1, 2 ,3 Tableau 2: 4, 2, 2, 4
Algorithme Exo19;
Var i, N, fin: entier;
symetr: booléen;
Début
Répeter //Demander à l'utilisateur le nombre d'éléments du tableau
Écrire ('Saisissez un nombre d'éléments du tableau, compris entre 1 et 50' ); Lire(N);
Pour i allant de 1 à N faire //Saisie des éléments, en fonction du nombre d'éléments N saisi précédemment
Écrire ('Veuillez saisir l'élément n° :', i); Lire(T[i]);
Fpour;
//On parcourt le tableau jusqu'à sa moitié (N div 2)

//On suppose que le tableau est symétrique, on arrête le parcours des que ce n'est plus le cas
symetr vrai; i1; finN div 2;
Tant que (symetr =vrai) et (i≤ fin) faire
Si T[i]≠ T[N-i+1] alors //Si on trouve deux éléments symétriques de valeurs différentes
symetr faux;
Fsi;
FTQ;
Si symetr=vrai alors //Tableau symétrique

Écrire(' Le tableau est symétrique. ');
Sinon //Tableau non symétrique
Écrire(' Le tableau n'est pas symétrique. ');
Fsi;
Fin.
9

Exercice 20:
Écrire un algorithme qui calcule le schtroumpf de deux tableaux (qui ne sont pas forcement de même taille).
Pour calculer le schtroumpf, il faut multiplier chaque élément du tableau 1 par chaque élément du tableau 2, et additionner le
tout. Par exemple si l'on a :
Tableau 1 : 4, 8 ,7, 12
Tableau 2 : 3, 6
Le Schtroumpf sera : 3 ∗ 4 + 3 ∗ 8 + 3 ∗ 7 + 3 ∗ 12 + 6 ∗ 4 + 6 ∗ 8 + 6 ∗ 7 + 6 ∗ 12 = 279
Algorithme Exo20;
Var i, j, N1,N2, schtr: entier;
T1, T2: tableau[1..50] de entier;
Début
//Demander à l'utilisateur le nombre d'éléments du tableau T1
Répeter
Écrire ('Saisissez un nombre d'éléments du tableau 1, compris entre 1 et 50' ); Lire(N1);
Jusqu'à (N1≥1) et (N1≤50);
//Saisie des éléments de T1, en fonction du nombre d'éléments N1 saisi précédemment

Pour i allant de 1 à N1 faire
Écrire ('Veuillez saisir l'élément n°:' i, ' du tableau 1'); Lire(T1[i]);
Fpour;
//Demander à l'utilisateur le nombre d'éléments du tableau T2

Répeter
Écrire ('Saisissez un nombre d'éléments du tableau 2, compris entre 1 et 50' ); Lire(N2);
Jusqu'à (N1≥2) et (N2≤50);
//Saisie des éléments de T2, en fonction du nombre d'éléments N2 saisi précédemment

Écrire ('Veuillez saisir l'élément n°:' i, ' du tableau 2'); Lire(T2[i]);
Fpour;
//On parcourt le tableau T1 élément par élément

//On multiplie l'élément en cours de T1 avec chaque élément de T2, et on additionne dans schtr
schtr 0;
Pour j allant de 1 à N2 faire
schtr schtr+ T1[i]*T2[j];
Fpour;
Fpour;
//Affichage du résultat
Écrire('Le schtroumpf des deux tableaux est: ', schtr);
Fin.
10

Sem 1. TD 3.1 Corrigés PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Sem 1. TD 3.1 Corrigés PDF

Transféré par

Droits d'auteur :

Formats disponibles

CFPA Mixte Younes Lekhel Bejaia

Section : T.S Informatique, option bases de données Date : 25/12/2018

Section : T.S Informatique, option bases de données Date : 25/12/2018

//Saisie des éléments, en fonction du nombre d'éléments N saisi précédemment

//Affichage de chaque élément du tableau

Section : T.S Informatique, option bases de données Date : 25/12/2018

Section : T.S Informatique, option bases de données Date : 25/12/2018

//Initialisation de i, utilisé comme indice de parcours

Si trouve= faux alors //Élément non trouvé

Section : T.S Informatique, option bases de données Date : 25/12/2018

Pour i allant de 2 à N faire //Parcours de tout le tableau

//Calcul de la moyenne de la classe d'abord

Section : T.S Informatique, option bases de données Date : 25/12/2018

//Parcours de tout le tableau à la recherche de notes supérieures aux moyennes de la classe

// Parcours du tableau, à la recherche d'occurrences de X

Si compt= 0 alors //Élément non trouvé

Section : T.S Informatique, option bases de données Date : 25/12/2018

// Parcours du tableau, à la recherche d'occurrences de X

Si compt=0 alors //Élément non trouvé

Si trie=vrai alors //Tableau trié

Section : T.S Informatique, option bases de données Date : 25/12/2018

Si i=50 alors //i=50,donc tableau trié par ordre croissant

Section : T.S Informatique, option bases de données Date : 25/12/2018

Si max=0 alors //Aucun 0 dans le tableau

//On parcourt le tableau jusqu'à sa moitié (N div 2)

Si symetr=vrai alors //Tableau symétrique

Section : T.S Informatique, option bases de données Date : 25/12/2018

//Saisie des éléments de T1, en fonction du nombre d'éléments N1 saisi précédemment

//Demander à l'utilisateur le nombre d'éléments du tableau T2

//Saisie des éléments de T2, en fonction du nombre d'éléments N2 saisi précédemment

//On parcourt le tableau T1 élément par élément

Vous aimerez peut-être aussi