Exercices Corrigés En Algorithme – Les tableaux
La meilleure façon d’apprendre quelque chose est de pratiquer des exercices. Nous avons préparer ces exercices corrigés pour les personnes (débutantes ou intermédiaires) qui sont familières avec les algorithmes. Nous espérons que ces exercices vous aideront à améliorer vos compétences sur les tableaux en algorithmique.
Vous pouvez lire notre tutoriel sur les algorithmes avant de résoudre les exercices suivants.
1. Écrire un algorithme permettant de saisir 10 nombres et de les stocker dans un tableau appelé myTab, puis de les afficher.
Exemple de sortie:
6 3 8 1 5 9 4 2 6 0 6 3 8 1 5 9 4 2 6 0
Algorithme AfficherTableau
Variable myTab[10]:reéls
i : entier
Début
Pour i de 1 jusqu❛à 10 faire
lire(myTab[i])
FinPour
Pour i de 1 jusqu'à 10 faire
Ecrire(myTab[i])
FinPour
Fin
L’algorithme ci-dessus invite l’utilisateur à saisir 10 entiers dans un tableau nommé myTab, puis affiche les éléments du tableau.
La première boucle POUR demande à l’utilisateur de saisir 10 éléments dans le tableau, et la boucle POUR s’exécute de 1 jusqu’à 10, invitant l’utilisateur à saisir chaque élément à l’aide de lire(), et stockant chaque entrée dans l’index correspondant du tableau myTab[i].
La deuxième boucle POUR affiche ensuite le contenu du tableau, qui parcourt les éléments de myTab et affiche chaque élément à l’aide de Ecrire().
2. Écrire un algorithme permettant d’entrer 10 notes et d’afficher la moyenne de ces notes.
Exemple de sortie:
6 3 8 1 5 9 4 2 6 0 La moyenne est: 4,4
Algorithme NoteMoyenne
Variables Notes[10], sum :réels
i :entier
Début
sum ← 0
Pour i de 1 jusqu'à 10 faire
Lire(Notes[i])
sum ← sum + Notes[i]
FinPour
Ecrire("La moyenne est:",sum/10)
Fin
L’algorithme demande à l’utilisateur de saisir 10 notes dans le tableau, et la boucle POUR s’exécute de 1 jusqu’à 10, invitant l’utilisateur à saisir chaque élément à l’aide de lire(), et stockant chaque entrée dans l’index correspondant du tableau Notes[i].
Ensuite, à chaque itération de la boucle, la somme de chaque élément saisi est calculée. Une fois la boucle POUR terminée, la moyenne est calculée et affichée à l’écran à l’aide de Ecrire().
3. Écrire un algorithme permettant la saisi de 10 nombres et l’affichage du maximum de ces nombres.
Exemple de sortie:
Entrer un nombre: 6 Entrer un nombre: 3 Entrer un nombre: 8 Entrer un nombre: 1 Entrer un nombre: 5 Entrer un nombre: 7 Entrer un nombre: 4 Entrer un nombre: 2 Entrer un nombre: 6 Entrer un nombre: 0 Le maximum est: 8
Algorithme myTabMax
Variables myTab[10],max,i:réels
Début
Ecrire("Entrer un nombre:")
Lire(myTab[0])
max ← myTab[0]
Pour i de 1 jusqu'à 10 faire
Ecrire("Entrer un nombre:")
Lire(myTab[i])
Si (myTab[i] > max) alors
max ← myTab[i]
FinSi
FinPour
Ecrire("Le maximum est:",max)
Fin
Dans cet algorithme nous avons créer une variable max et l’initier à myTab[0] pour stocker le maximum dans le tableau.
Itérer sur le tableau
- Comparer myTab[i] avec max.
- Si myTab[i] > max, mettre à jour max ← myTab[i].
Une fois l’itération terminée, renvoyer max comme réponse.
4. Ecrivez un algorithme qui permet d’entrer 10 nombres dans un tableau, et de calculer le nombre d’occurrences d’un élément E dans ce tableau. Où E est entré par l’utilisateur.
Exemple de sortie:
Entrer un nombre: 6 Entrer un nombre: 3 Entrer un nombre: 8 Entrer un nombre: 6 Entrer un nombre: 5 Entrer un nombre: 7 Entrer un nombre: 4 Entrer un nombre: 6 Entrer un nombre: 6 Entrer un nombre: 0 Entrer Le nombre recherché: 6 Nombre d'occurences de 6 est 4
Algorithme NbrOccurences
Variables nbrRech,myTab[10]:réels
nbrOcc,i:entiers
Début
nbrOcc ← 0
Pour i de 1 jusqu❛à 10 faire
Ecrire("Entrer un nombre:")
Lire(myTab[i])
FinPour
Ecrire("Entrer Le nombre recherché:")
Lire(nbrRech)
Pour i de 1 jusqu❛à 10 faire
Si(myTab[i] = nbrRech) alors
nbrOcc ← nbrOcc + 1
FinSi
FinPour
Ecrire("Nombre d'occurences de ",nbrRech," est ",nbrOcc)
Fin
Pour compter le nombre d’occurrences d’une valeur spécifique dans un tableau, nous pouvons utiliser une simple boucle POUR tout en recherchant notre valeur cible. Si la valeur cible est trouvée, nous incrémentons la variable nbrOcc. Nous procédons de cette façon jusqu’à ce que l’ensemble du tableau soit parcouru.
Approche:
- Initialiser la variable nbrOcc à zéro.
- On parcourt le tableau et on vérifie si l’élément courant(myTab[i]) correspond à la valeur cible(nbrRech).
- Si c’est le cas, nbrOcc est incrémenté de 1.
- Dans le cas contraire, passer à l’itération suivante.
- Répétez le processus jusqu’à ce que tous les éléments du tableau aient été vérifiés.
- Enfin, retourner nbrOcc.
5. Ecrivez un algorithme pour entrer 10 entiers dans un tableau et trier ce tableau dans un ordre croissant. Affichez ensuite ce tableau après l’avoir trié.
Exemple de sortie:
Entrer un nombre: 8 Entrer un nombre: 1 Entrer un nombre: 5 Entrer un nombre: 6 Entrer un nombre: 3 Entrer un nombre: 2 Entrer un nombre: 4 Entrer un nombre: 7 Entrer un nombre: 9 Entrer un nombre: 0 Tableau trié: 0 1 2 3 4 5 6 7 8 9
Algorithme TrierTab
Variables i,j,tmp,myTab[10]:entiers
Début
Pour i de 1 jusqu❛à 10 faire
Ecrire("Entrer un nombre:")
Lire(myTab[i])
FinPour
Pour i de 1 jusqu❛à 9 faire
Pour j de i+1 jusqu'à 10 faire
Si(myTab[j] < myTab[i]) alors
tmp ← myTab[i]
myTab[i] ← myTab[j]
myTab[j] ← tmp
FinSi
FinPour
FinPour
Pour i de 1 jusqu❛à 10 faire
Ecrire(myTab[i])
FinPour
Fin
L'algorithme ci-dessus invite l'utilisateur à saisir 10 nombres dans un tableau nommé myTab, puis affiche les éléments triés du tableau.
La première boucle POUR demande à l'utilisateur de saisir 10 éléments dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 10, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau myTab[i].
La deuxième boucle POUR parcourt le tableau myTab et permute les éléments du tableau(permute deux éléments aux positions i et j) en utilisant une variable temporaire pour contenir l'une des valeurs pendant la permutation. L'algorithme parcourt le tableau répétitivement, compare chaque paire d'éléments adjacents et les échange si nécessaire. Après le premier passage, l'élément le plus grand est placé à la fin du tableau.
- Dans l'algorithme de tri à bulle, nous comparons les deux premiers éléments d'un tableau et les permutons si nécessaire.
- Si nous voulons trier les éléments d'un tableau dans l'ordre croissant et si le premier élément est plus grand que le second, nous devons permuter les éléments.
- Si le premier élément est plus petit que le second, il n'est pas nécessaire de permuter les éléments. Ce processus se poursuit jusqu'à ce que le dernier et l'avant-dernier élément soient comparés et permutés.
La troisième boucle POUR affiche ensuite le tableau trié, qui parcourt les éléments de myTab et affiche chaque élément à l'aide de Écrire().
6. Ecrivez un algorithme qui demande d'entrer un tableau Tab de 10 nombres, et de placer les éléments pairs dans un tableau Tab1 et les éléments impairs dans un tableau Tab2. Affichez ensuite Tab1 et Tab2.
Exemple de sortie:
Tab : 1 5 2 4 9 3 3 6 8 7 Tab1: 2 4 6 8 Tab2: 1 5 9 3 3 7
Algorithme TabPairImpaire
Variables i,j,k:entiers
Tab[10],Tab1[10],Tab2[10]:tableaux d'entiers
Début
j ← 1
k ← 1
Ecrire("Tab:")
Pour i de 1 à 10 faire
Lire(Tab[i])
FinPour
Pour i de 1 à 10 faire
Si(Tab[i] mod 2 = 0) alors
Tab1[j] ← Tab[i]
j ← j + 1
SiNon
Tab2[k] ← Tab[i]
k ← k + 1
FinSi
FinPour
Ecrire("Tab1:")
Pour i de 1 à j faire
Ecrire(Tab1[i])
FinPour
Ecrire("Tab2:")
Pour i de 1 à k faire
Ecrire(Tab2[i])
FinPour
Fin
La première instruction Ecrire demande à l'utilisateur d'entrer N nombre d'éléments dans le tableau Tab à l'aide d'une boucle POUR, et stocke chaque entrée dans l'index correspondant du tableau Tab[i].
La boucle POUR suivante itère ensuite sur chaque élément de Tab et sépare les éléments pairs et impairs dans deux tableaux différents Tab1 et Tab2, respectivement, à l'aide d'instructions Si-SiNon. Les variables j et k sont utilisées pour suivre les indices des éléments pairs et impairs dans les deux tableaux.
Enfin, les deux dernières instructions Ecrire (Ligne 24 et 28) affichent les éléments pairs et impairs trouvés, respectivement, en utilisant une boucle POUR pour itérer sur chaque élément des deux tableaux.
7. Écrire un algorithme qui compte le nombre d'éléments dupliqués dans un tableau de nombres entiers saisi par l'utilisateur.
Exemple de sortie:
Entrer un nombre: 5 Entrer un nombre: 1 Entrer un nombre: 5 Entrer un nombre: 6 Entrer un nombre: 3 Entrer un nombre: 5 Entrer un nombre: 4 Entrer un nombre: 7 Entrer un nombre: 9 Entrer un nombre: 5 Nombre total d'éléments dupliqués est: 4
Algorithme ElémentsDupliqués
Variables myTab[10],compteur,i,j: entiers
Début
Pour i de 1 à 10 faire
Ecrire("Enter un entier:")
Lire(myTab[i])
FinPour
compteur ← 0
Pour i de 1 à 10 faire
Pour j de i+1 à 10 faire
Si(myTab[i] = myTab[j]) alors
compteur ← compteur + 1
FinSi
FinPour
FinPour
Ecrire("Nombre total d'éléments dupliqués est:",compteur)
Fin
L'algorithme ci-dessus invite l'utilisateur à saisir 10 nombres dans un tableau nommé myTab, puis affiche les éléments triés du tableau.
La première boucle POUR demande à l'utilisateur de saisir 10 éléments dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 10, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau myTab[i].
Initialiser la variable "compteur" avec 0 pour stocker le nombre de doublons.
Pour compter le nombre total d'éléments dupliqués dans un tableau donné, nous avons besoin de deux boucles. Exécutez une boucle extérieure de 0 à la taille(10). La structure de la boucle doit ressembler à Pour i de 1 à 10 faire. Cette boucle est utilisée pour sélectionner chaque élément du tableau et vérifier les éléments suivants pour les éléments en double en utilisant une autre boucle imbriquée.
Exécutez une autre boucle interne pour trouver le premier doublon de l'élément actuel du tableau. Exécutez une boucle interne de i + 1 à la taille(10), la structure de la boucle devrait ressembler à Pour j de i+1 à 10 faire. Pourquoi exécuter la boucle à partir de i + 1 ? Parce que nous devons rechercher les éléments en double dans les éléments suivants, à partir de l'élément actuel.
La boucle interne vérifie la présence d'un élément en double. Si c'est le cas, le compteur est incrémenté. C'est-à-dire Si(myTab[i] = myTab[j]) alors, compteur ← compteur + 1.
8. Ecrivez un algorithme qui permet de saisir 5 nombres dans un tableau. Comptez ensuite le nombre d'éléments pairs et impairs.
Exemple de sortie:
Entrer un nombre: 1 Entrer un nombre: 3 Entrer un nombre: 2 Entrer un nombre: 6 Entrer un nombre: 9 Total des éléments pairs: 2 Total des éléments impaires: 3
Algorithme NbrPaireImpaire
Variables myTab[10],i,pair,impair :entiers
Début
pair ← 0
impair ← 0
Pour i de 1 à 5 faire
Ecrire("Entrer un nombre:")
Lire(myTab[i])
FinPour
Pour i de 1 à 5 faire
Si(myTab[i] mod 2 = 0) alors
pair ← pair + 1
SiNon
impair ← impair + 1
FinSi
FinPour
Ecrire("Total des éléments pairs:",pair)
Ecrire("Total des éléments impaires:",impair)
Fin
L'algorithme ci-dessus invite l'utilisateur à saisir 5 nombres dans un tableau nommé myTab, puis affiche le total des éléments pairs et impaires.
Déclarez et initialisez deux variables avec zéro pour stocker les nombres pairs et impairs.
pair ← 0 et impair ← 0.
La première boucle POUR demande à l'utilisateur de saisir 5 éléments dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 5, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau myTab[i].
La deuxième boucle POUR parcourt le tableau myTab de 0 à 5. A l'intérieur de la boucle, incrémenter le nombre pair de 1 si l'élément courant du tableau est pair. Sinon, on incrémente le nombre impair.
Enfin, nous affichons le résultat à l'aide de Ecrire().
9. Ecrivez un algorithme qui teste l'égalité de deux tableaux de nombres entiers (tailles 5). Le programme affiche TRUE si les éléments des deux tableaux correspondent, sinon il affiche FALSE.
Exemple de sortie:
1 2 3 4 5 1 2 3 4 5 TRUE 10 20 30 40 50 20 30 40 50 60 FALSE
Algorithme Comparer2Tableaux
Variables Tab1[5],Tab2[5],i,not_equal: entiers
Début
not_equal ← 0
Pour i de 1 à 5 faire
Lire(Tab1[i])
FinPour
Pour i de 1 à 5 faire
Lire(Tab2[i])
FinPour
Pour i de 1 à 5 faire
Si(Tab1[i] ≠ Tab2[i]) alors
not_equal ← 1
FinSi
FinPour
Si(not_equal = 0) alors
Ecrire("TRUE")
SiNon
Ecrire ("FALSE")
FinSi
Fin
10. Écrire un algorithme qui permet la saisie de 5 nombres et qui calcule la différence entre la somme des nombres pairs et la somme des nombres impairs. En utilisant les tableaux.
Par exemple : 3 5 2 4 6 => (2+4+6) - (3+5) = 4
Exemple de sortie:
Entrer un nombre: 3 Entrer un nombre: 5 Entrer un nombre: 2 Entrer un nombre: 4 Entrer un nombre: 6 La différence égale à 4
Algorithme CalcDifférence
Variables myTab[5],i,sum: entiers
Début
sum ← 0
Pour i de 1 à 5 faire
Ecrire("Entrer un nombre:")
Lire(myTab[i])
Si(myTab[i] mod 2 = 0) alors
sum ← sum + myTab[i]
SiNon
sum ← sum - myTab[i]
FinSi
FinPour
Ecrire("La différence égale à ",sum)
Fin
11. Écrire un algorithme qui place les zéro vers la fin du tableau, en maintenant l'ordre des éléments.
Exemple de sortie:
Entrée: 8 0 6 0 1 6 0 0 2 3 Sortie: 8 6 1 6 2 3 0 0 0 0
Algorithme ZéroALaFin
Variables i,j,T[10],tmp: Entiers
Début
Pour i de 1 jusqu’à 10 faire
Lire(T[i])
FinPour
Pour i de 1 jusqu’à 10 faire
Ecrire(T[i])
FinPour
Pour i de 1 jusqu’à 9 faire
Si(T[i] = 0) alors
j ← i + 1;
TantQue(T[j]=0 et j<9) faire
j ← j + 1
FinTantQue
tmp ← T[i]
T[i]← T[j]
T[j]← tmp
FinSi
FinPour
Pour i de 1 jusqu’à 10 faire
Ecrire(T[i])
FinPour
Fin
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 1
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 2
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 3
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 4
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 5
- Exercices Corrigés En Algorithme – Les boucles
- Exercices Corrigés En Algorithme – Les tableaux
- Exercices Corrigés En Algorithme – Structure conditionnelle
- Exercices Corrigés En Algorithme – Fonctions et Procédures
merci beaucoup
Comment résoudre cet algorithme
Une entreprise offre les avantages suivant à ses clients : une remise de
– 1 % pour un client dont le montant total d’achat est supérieur ou égal à 1000 dollars ;
– 5 % pour un client dont le montant total d’achat compris entre 1000 à 5000 dollars ;
– 10 % pour un client dont le montant total d’achat est strictement supérieur à 5000 dollars,
Proposer un algorithme qui lit le montant total d’achat et qui lit affiche le montant net à payer sachant que la TVA vaut de 16 % du prix d’achat