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 // Parcourt les 10 positions du tableau
lire(myTab[i]) // Lit une valeur et la stocke dans le tableau
FinPour
// Parcourt à nouveau les 10 positions du tableau
Pour i de 1 jusqu'à 10 faire
Ecrire(myTab[i]) // Affiche la valeur située à la position 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().
Organigramme:
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 // Initialise la somme des notes à 0
Pour i de 1 jusqu'à 10 faire // Parcourt les 10 notes à saisir
Lire(Notes[i]) // Lit une note et la stocke dans le tableau
sum ← sum + Notes[i] // Ajoute la note à la somme totale
FinPour
// Calcule et affiche la moyenne des 10 notes
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().
- Notes[10] : réels : déclare un tableau pouvant contenir 10 notes de type réel.
- sum ← 0 : initialise la somme des notes à zéro avant de commencer les calculs.
- Pour i de 1 jusqu’à 10 faire : permet de parcourir les 10 positions du tableau.
- Lire(Notes[i]) : lit une note saisie par l’utilisateur et la stocke dans le tableau à la position i.
- sum ← sum + Notes[i] : ajoute chaque note à la somme totale.
- sum / 10 : divise la somme des 10 notes par 10 afin d’obtenir la moyenne.
- Ecrire(…) : affiche la moyenne calculée.
Organigramme:
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]) // Lit le 1er nombre et le stocke dans le tableau
max ← myTab[0] // Initialise max avec la 1er valeur du tableau
// Parcourt les autres positions du tableau
Pour i de 1 jusqu'à 10 faire
Ecrire("Entrer un nombre:")
Lire(myTab[i]) // Lit un nombre et le stocke dans le tableau
// Vérifie si la valeur actuelle est supérieure au max
Si (myTab[i] > max) alors
max ← myTab[i] // Met à jour max avec la nouvelle valeur
FinSi
FinPour
// Affiche la plus grande valeur du tableau
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.
- Lire(myTab[0]) : lit le premier nombre et le stocke dans la première position du tableau.
- max ← myTab[0] : initialise max avec la première valeur. Elle sert de référence pour les comparaisons suivantes.
- Pour i de 1 jusqu’à 9 faire : parcourt les 9 positions restantes du tableau.
- Lire(myTab[i]) : lit chaque nouveau nombre et le stocke dans le tableau.
- Si (myTab[i] > max) : vérifie si le nombre actuel est plus grand que le maximum trouvé jusqu’à présent.
- max ← myTab[i] : met à jour le maximum lorsque la valeur actuelle est plus grande.
- Ecrire(…) : affiche finalement la plus grande valeur trouvée.
Organigramme:
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 // Initialise le compteur d'occurrences à 0
Pour i de 1 jusqu❛à 10 faire // Parcourt les 10 positions du tableau
Ecrire("Entrer un nombre:")
Lire(myTab[i]) // Lit un nombre et le stocke dans le tableau
FinPour
Ecrire("Entrer Le nombre recherché:")
Lire(nbrRech) // Lit le nombre dont on veut compter les occurrences
// Parcourt à nouveau toutes les valeurs du tableau
Pour i de 1 jusqu❛à 10 faire
// Vérifie si la valeur actuelle correspond au nbr recherché
Si(myTab[i] = nbrRech) alors
// Incrémente le compteur lorsqu'une occurrence est trouvé
nbrOcc ← nbrOcc + 1
FinSi
FinPour
// Affiche le nombre total d'occurrences
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:
- nbrOcc ← 0 : initialise le compteur d’occurrences à 0, car aucune valeur n’a encore été trouvée.
- Lire(myTab[i]) : permet de remplir le tableau avec les 10 nombres saisis par l’utilisateur.
- Lire(nbrRech) : lit le nombre que l’utilisateur souhaite rechercher dans le tableau.
- Si (myTab[i] = nbrRech) : compare chaque élément du tableau avec le nombre recherché.
- nbrOcc ← nbrOcc + 1 : augmente le compteur de 1 chaque fois qu’une correspondance est trouvée.
- Ecrire(…) : affiche le nombre total de fois où le nombre recherché apparaît dans le tableau.
Organigramme:
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 // Parcourt les 10 positions du tableau
Ecrire("Entrer un nombre:")
Lire(myTab[i]) // Lit un nombre et le stocke dans le tableau
FinPour
// Parcourt le tableau jusqu❛à l❛avant-dernier élément
Pour i de 1 jusqu❛à 9 faire
// Compare l❛élément actuel avec les suivants
Pour j de i+1 jusqu❛à 10 faire
// Vérifie si un élément plus petit a été trouvé
Si(myTab[j] < myTab[i]) alors
// Sauvegarde temporairement la valeur de myTab[i]
tmp ← myTab[i]
// Place la plus petite valeur à la position i
myTab[i] ← myTab[j]
// Place l❛ancienne valeur de myTab[i] à la position j
myTab[j] ← tmp
FinSi
FinPour
FinPour
Pour i de 1 jusqu❛à 10 faire // Parcourt le tableau trié
Ecrire(myTab[i]) // Affiche les éléments dans l'ordre croissant
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 Ecrire().
- Lire(myTab[i]) : remplit le tableau avec les 10 nombres saisis par l'utilisateur.
- Pour i de 1 jusqu'à 9 : sélectionne chaque position du tableau, sauf la dernière.
- Pour j de i + 1 jusqu'à 10 : compare l'élément myTab[i] avec tous les éléments qui se trouvent après lui.
- Si (myTab[j] < myTab[i]) : vérifie si un élément plus petit que myTab[i] a été trouvé.
- tmp ← myTab[i] : sauvegarde temporairement la valeur de myTab[i] avant de l'échanger.
- myTab[i] ← myTab[j] : place la plus petite valeur à la position i.
- myTab[j] ← tmp : termine la permutation en plaçant l'ancienne valeur de myTab[i] à la position j.
- Ecrire(myTab[i]) : affiche le tableau après son tri.
Organigramme:
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
// Initialisent les indices de Tab1 (pairs) et Tab2 (impairs)
j ← 1
k ← 1
Ecrire("Tab:")
Pour i de 1 à 10 faire
Lire(Tab[i]) // Saisit les 10 éléments du tableau Tab
FinPour
Pour i de 1 à 10 faire // Parcourt tous les éléments de Tab
Si(Tab[i] mod 2 = 0) alors
Tab1[j] ← Tab[i] // Copie le nombre pair dans Tab1
j ← j + 1 // Passe à la case suivante de Tab1
SiNon
Tab2[k] ← Tab[i] // Copie le nombre impair dans Tab2
k ← k + 1 // Passe à la case suivante de Tab2
FinSi
FinPour
Ecrire("Tab1:")
Pour i de 1 à j faire // Affiche que les éléments stockés dans Tab1
Ecrire(Tab1[i])
FinPour
Ecrire("Tab2:")
Pour i de 1 à k faire // Affiche que les éléments stockés dans Tab2
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.
Organigramme:
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]) // Saisit les 10 éléments du tableau
FinPour
compteur ← 0 // Initialise le compteur des doublons
// Parcourt chaque élément du tableau
Pour i de 1 à 10 faire
// Compare l'élément courant avec les éléments suivants
Pour j de i+1 à 10 faire
Si(myTab[i] = myTab[j]) alors
// Incrémente le compteur lorsqu'un doublon est trouvé
compteur ← compteur + 1
FinSi
FinPour
FinPour
// Affiche le nombre de doublons trouvés
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.
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.
Organigramme:
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
// Initialise les compteurs des nombres pairs et impairs
pair ← 0
impair ← 0
Pour i de 1 à 5 faire
Ecrire("Entrer un nombre:")
Lire(myTab[i]) // Saisit et stocke les 5 nombres dans le tableau
FinPour
Pour i de 1 à 5 faire // Parcourt les éléments du tableau
Si(myTab[i] mod 2 = 0) alors
pair ← pair + 1 // Incrémente le compteur des nombres pairs
SiNon
impair ← impair + 1 // Incrémente le compteur des nbr impairs
FinSi
FinPour
// Affiche le nombre d'éléments pairs et impairs
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().
Organigramme:
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 // Suppose au départ que les 2 tableaux sont identiques
Pour i de 1 à 5 faire
Lire(Tab1[i]) // Saisit les 5 éléments du premier tableau
FinPour
Pour i de 1 à 5 faire
Lire(Tab2[i]) // Saisit les 5 éléments du deuxième tableau
FinPour
// Compare les éléments des deux tableaux position par position
Pour i de 1 à 5 faire
Si(Tab1[i] ≠ Tab2[i]) alors
not_equal ← 1 // Signale qu'au moins un élément est différent
FinSi
FinPour
// Vérifie si aucune différence n'a été trouvée
Si(not_equal = 0) alors
Ecrire("TRUE") // Les deux tableaux sont identiques
SiNon
Ecrire ("FALSE") // Les deux tableaux sont différents
FinSi
Fin
- not_equal ← 0 : initialise un indicateur à 0, ce qui signifie qu'aucune différence n'a encore été trouvée.
- Lire(Tab1[i]) : remplit le premier tableau avec 5 entiers.
- Lire(Tab2[i]) : remplit le deuxième tableau avec 5 entiers.
- Si (Tab1[i] ≠ Tab2[i]) : compare les éléments situés à la même position dans les deux tableaux.
- not_equal ← 1 : indique qu'au moins une différence a été détectée.
- Si (not_equal = 0) : si aucune différence n'a été trouvée, les deux tableaux sont identiques.
- Ecrire("TRUE") : indique que les deux tableaux sont identiques.
- Ecrire("FALSE") : indique qu'ils sont différents.
Organigramme:
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 // Initialise la variable qui stockera le résultat final
Pour i de 1 à 5 faire // Répète l'opération pour les 5 nombres
Ecrire("Entrer un nombre:")
Lire(myTab[i]) // Lit et stocke le nombre dans le tableau
Si(myTab[i] mod 2 = 0) alors
sum ← sum + myTab[i] // Ajoute le nombre pair à la somme
SiNon
sum ← sum - myTab[i] // Soustrait le nombre impair de la somme
FinSi
FinPour
Ecrire("La différence égale à ",sum) // Affiche le résultat final
Fin
- sum ← 0 : initialise le résultat à zéro.
- Pour i de 1 à 5 : permet de traiter les 5 nombres saisis.
- Lire(myTab[i]) : lit un nombre et le stocke dans le tableau.
- myTab[i] mod 2 = 0 : vérifie si le nombre est pair.
- sum ← sum + myTab[i] : ajoute les nombres pairs au résultat.
- sum ← sum - myTab[i] : soustrait les nombres impairs du résultat.
- Ecrire(...) : affiche la différence finale.
Organigramme:
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]) // Lit les 10 éléments du tableau
FinPour
Pour i de 1 jusqu’à 10 faire
Ecrire(T[i]) // Affiche le tableau avant la modification
FinPour
// Parcourt le tableau pour rechercher les zéros
Pour i de 1 jusqu’à 9 faire
// Vérifie si l'élément actuel est égal à 0
Si(T[i] = 0) alors
// Commence la recherche d'un élément non nul après le zéro
j ← i + 1;
// Cherche le prochain élément différent de 0
TantQue(T[j]=0 et j<9) faire
j ← j + 1 // Passe à la position suivante
FinTantQue
tmp ← T[i] // Sauvegarde temporairement le zéro
T[i]← T[j] // Place l'élément non nul à la position du zéro
T[j]← tmp // Place le zéro à la position de l'élément déplacé
FinSi
FinPour
// Parcourt le tableau après les déplacements
Pour i de 1 jusqu’à 10 faire
// Affiche le tableau avec les zéros déplacés à la fin
Ecrire(T[i])
FinPour
Fin
- Lire(T[i]) : remplit le tableau avec les 10 valeurs saisies par l'utilisateur.
- Si (T[i] = 0) : vérifie si l'élément actuel est égal à zéro.
- j ← i + 1 : commence la recherche juste après la position contenant le zéro.
- TantQue (T[j] = 0 et j < 9) : cherche un élément différent de zéro parmi les positions suivantes.
- j ← j + 1 : avance dans le tableau jusqu'à trouver un élément non nul.
- tmp ← T[i] : sauvegarde temporairement la valeur de T[i].
- T[i] ← T[j] : remplace le zéro par l'élément non nul trouvé.
- T[j] ← tmp : déplace le zéro vers la position j.
- La dernière boucle Pour : affiche le tableau après avoir déplacé les zéros vers la fin.
Organigramme:
- 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