Bases de programmation - TD 2 : Itérations et tableaux

Bases de programmation - TD 2 : Itérations et tableaux
IUT Aix-Marseille / DUT R&T 1ière année
J. Seinturier (http://www.seinturier.fr)
1. Itérations
Exercice 1.1 : Ecrire un algorithme qui demande à l’utilisateur un nombre compris entre 1 et 3 jusqu’à ce que la
réponse convienne.
algorithme triplette
données
n : entier
début
ecrire("Entrez un nombre entre 1 et 3")
n ← lire()
tantque n < 1 ou n > 3 faire
ecrire("Saisie erronée. Recommencez”)
n ← lire()
fintq
fin
Exercice 1.2 : 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.
algorithme justeprix
données
n : entier
début
n ← 0
ecrire("Entrez un nombre entre 10 et 20")
tantque n < 10 ou n > 20 faire
n ← lire()
si n < 10 alors
ecrire("Plus grand !")
sinon
si n > 20 alors
ecrire("Plus petit !")
finsi
finsi
fintq
fin
Exercice 1.3 : Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche les dix nombres
suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres de 18 à 27.
algorithme dix_suivants
données
n :entier
cpt : entier
début
ecrire("Entrez un nombre : ")
n ← lire()
cpt ← 1
ecrire("Les 10 nombres suivants sont : ")
tantque cpt ≤ 10 faire
ecrire(n + cpt)
cpt ← cpt + 1
fintq
fin
Exercice 1.4 : 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) l’algorithme doit afficher :
Table de 7 : On pourra pour cela utiliser la fonction ecrire()
7 x 1 = 7 en lui passant plusieurs paramètres, par exemple :
7 x 2 = 14
7 x 3 = 21 ecrire(‘’7 x 1 = ‘’, 7)
algorithme multiplication
données
n : entier
i : entier
début
ecrire("Entrez un nombre : ")
n ← lire()
i ← 1
ecrire("La table de multiplication de ce nombre est : ")
tanque i ≤ 10 faire
ecrire(n, " x ", i, " = ", n x i)
i ← i + 1
fintq
fin

Exercice 1.5 : 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
algorithme somme
données
n, i, som : entier
début
ecrire("Entrez un nombre : ")
n ← lire()
som ← 0
i ← 1
tanque i ≤ n faire
som ← som + i
i ← i + 1
fintq
ecrire("La somme est: ")
ecrire(som)
fin
Exercice 1.6 : Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle. Par exemple,
la factorielle de 8, notée 8!, vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8
algorithme factorielle
données
n : entier
fact : entier
début
ecrire(‘’Entrer un nombre entier : ’’)
n ← lire()
fact ← 1
tantque n > 1 faire
fact ← fact x n
n ← n - 1
fintq
ecrire(n, ‘’ ! = ’’, fact)
fin
Exercice 1.7 : Ecrire un algorithme qui demande successivement 20 nombres à l’utilisateur, et qui lui dise ensuite
quel était le plus grand parmi ces 20 nombres :
algorithme max
données
val, max, cpt : entier
début
cpt ← 0
max ← 0
tantque cpt < 20 faire
val ← lire()
si val > max alors
max ← val
finsi
cpt ← cpt + 1
fintq
ecrire(max)
fin
Modifiez ensuite l’algorithme pour que le programme affiche de surcroît en quelle position avait été saisie ce
nombre.
algorithme max
données
val, max, cpt, index : entier
début
cpt ← 0
max ← 0
tantque cpt < 20 faire
val ← lire()
si val > max alors
max ← val
index ← cpt
finsi
cpt ← cpt + 1
fintq
ecrire(max)
ecrire(index)
fin
Exercice 1.8 : Lire la suite des prix (en euros entiers et terminée par zéro) des achats d’un client. Calculer la somme
qu’il doit, demander la somme qu’il paye, et simuler la remise de la monnaie en affichant les textes "10 Euros", "5
Euros" et "1 Euro" autant de fois qu’il y a de coupures de chaque sorte à rendre.
algorithme caisse
données E, somdue, M, Reste, Nb10E, Nb5E : entier
début
E ← 1
somdue ← 0
tantque E ≠ 0 faire
ecrire("Entrez le montant : ")
E ← lire()
somdue ← somdue + e
fintq
ecrire("Vous devez :", somdue, " euros")
ecrire("Montant versé :")
M ← lire()
Reste ← M - somdue
Nb10E ← 0
tantque Reste ≥ 10 faire
Nb10E ← Nb10E + 1
Reste ← Reste – 10
fintq
Nb5E ← 0
si Reste ≥ 5 alors
Nb5E ← 1
Reste ← Reste – 5
finsi
ecrire("Rendu de la monnaie :")
ecrire("Billets de 10 E : ", Nb10E)
ecrire("Billets de 5 E : ", Nb5E)
ecrire("Pièces de 1 E : ", reste)
fin

2. Tableaux
Exercice 2.1 : Ecrire un algorithme qui déclare et remplisse un tableau de 7 valeurs numériques en les mettant
toutes à zéro.
algorithme tab7
données
tab : entier[]
i : entier
début
tab ← entier[7]
i ←0
tantque i < taille(tab) faire
tab[i] ← 0
i ← i + 1
fintq
fin
Exercice 2.2 : Ecrire un algorithme qui déclare et remplisse un tableau contenant les six voyelles de l’alphabet
latin.
algorithme tabLatin
données
tab : caractère[]
début
tab ← caractère[6]
tab[0] ← ‘a’
tab[1] ← ‘e’
tab[2] ← ‘i’
tab[3] ← ‘o’
tab[4] ← ‘u’
tab[5] ← ‘y’
fin
Exercice 2.3 : Ecrire un algorithme qui déclare un tableau de 9 notes, dont on fait ensuite saisir les valeurs par
l’utilisateur.
algorithme saisie
données
notes : réel[]
i : entier
début
notes ← réel[9]
i ← 0
tantque i < taille(notes) faire
ecrire(‘’Entrer la valeur ‘’, i, ‘’ : ‘’)
tab[i] ← lire()
i ← i + 1
fintq
fin
Exercice 2.4 : Ecrire un algorithme permettant à l’utilisateur de saisir un nombre quelconque de valeurs, qui seront
stockées dans un tableau. L’utilisateur doit donc commencer par entrer le nombre de valeurs qu’il compte saisir.
Il effectuera ensuite cette saisie. Enfin, une fois la saisie terminée, le programme affichera le nombre de valeurs
négatives et le nombre de valeurs positives.
algorithme saisieMultiple
données
tab : entier[]
positive : entier
negative : entier
cpt : entier
début
ecrire(‘’taille du tableau : ‘’)
cpt ← lire()
tab ← entier[cpt]
positive ← 0
negative ← 0
cpt ← 0
tantque cpt < taille(tab) faire
tab[cpt] ← lire()
si tab[cpt] ≥ 0 alors
positive ← positive + 1
sinon
negative ← negative + 1
finsi
cpt ← cpt + 1
fintq
ecrire(positive)
ecrire(negative)
fin
Exercice 2.5 : Ecrire un algorithme calculant la somme des valeurs d’un tableau donné en entrée. Penser à
retrouver la taille du tableau.
algorithme sommeEntree
entrées
tab : réel[]
données
i : entier
somme : réel
début
i ← 0
somme ← 0
tantque i < taille(tab) faire
somme ← somme + tab[i]
i ← i + 1
fintq
fin

Exercice 2.7 : Ecrire un algorithme constituant un tableau, à partir de deux tableaux de même longueur donnés
en entrée. Le nouveau tableau sera la somme des éléments des deux tableaux de départ.
algorithme concat
entrées
tab1 : entier[]
tab2 : entier[]
données
result : entier[]
cpt, index: entier
début
result ← entier[taille(tab1) + taille(tab2)]
cpt ← 0
index ← 0
tantque cpt < taille(tab1) faire
result[index] ← tab1[cpt]
cpt ← cpt + 1
index ← index + 1
fintq
cpt ← 0
tantque cpt < taille(tab2) faire
result[index] ← tab2[cpt]
cpt ← cpt + 1
index ← index + 1
fintq
fin
Exercice 2.8 : Ecrire un algorithme qui permette la saisie d’un nombre quelconque de valeurs. Toutes les valeurs
doivent être ensuite augmentées de 1, et le nouveau tableau doit être affiché à l’écran.
algorithme pluUn
données
nombres : entier[]
cpt : entier
début
ecrire(‘’Nombre de valeurs : ‘’)
cpt ← lire()
nombres ← entier[cpt]
cpt ← 0
tantque cpt < taille(nombres) faire
nombres[cpt] ← lire() + 1
cpt ← cpt + 1
fintq
cpt ← 0
tantque cpt < taille(nombres) faire
ecrire(nombres[cpt])
cpt ← cpt + 1
fintq
fin
Exercice 2.9 : Ecrire un algorithme permettant, à l’utilisateur de saisir les notes d'une classe. Et qui renvoie le
nombre de ces notes supérieures à la moyenne de la classe.
algorithme supMoyenne
données
notes : réels[]
moyenne : réel
sup : entier
cpt : entier
début
ecrire(‘’Nombre d’élèves : ‘’)
cpt ← lire()
notes ← réels[cpt]
moyenne ← 0
sup ← 0
cpt ← 0
tantque cpt < taille(notes) faire
notes[cpt] ← lire()
moyenne ← moyenne + notes[cpt]
cpt ← cpt + 1
fintq
moyenne ← moyenne / taille(notes)
cpt ← 0
tantque cpt < taille(notes) faire
si notes[cpt] ≥ moyenne alors
sup ← sup + 1
finsi
cpt ← cpt + 1
fintq
ecrire(‘’Nombre de notes au dessus de la moyenne :’’)
ecrire(sup)
fin