TD 2 corrigé sur les boucles en Scilab

Exercice 1

Exercice

Affichage des N premiers entiers impairs (ordre décroissant)

Niveau : Débutant Durée : 10 min

Écrire un programme qui permet d'afficher les N premiers entiers impairs dans l'ordre décroissant.

Par exemple, si N = 5, les 5 premiers entiers impairs sont : 1, 3, 5, 7, 9. Dans l'ordre décroissant, cela donne : 9, 7, 5, 3, 1.

Exemple

Entrée

N = 5

Sortie

Explication : Les 5 premiers entiers impairs sont 1,3,5,7,9. L'affichage se fait en ordre décroissant : 9,7,5,3,1.

Besoin d'un indice ?

Le N-ème nombre impair est donné par la formule : 2×N - 1
Pour un affichage décroissant, il faut partir du plus grand et descendre jusqu'à 1
Le pas de la boucle doit être négatif pour décroître

Solution Scilab

Principe : On utilise une boucle for avec un pas négatif pour parcourir les nombres impairs du plus grand au plus petit.

Code :

N = input("Saisir N : ")
for nb = (2*N-1):-2:1
    disp(nb)
end

Explication :
- 2*N-1 donne le N-ème nombre impair (le plus grand)
- :-2: indique un pas de -2 pour passer d'un nombre impair au précédent
- La boucle s'arrête quand nb devient inférieur à 1

Exercice 2

Exercice

Somme et moyenne de N entiers

Niveau : Débutant Durée : 15 min

Écrire un programme qui saisit N entiers (N est donné par l'utilisateur) et affiche leur somme et leur moyenne.

Le programme doit d'abord demander combien de nombres l'utilisateur souhaite saisir, puis demander chaque nombre un par un, et enfin afficher la somme et la moyenne.

Exemple

Entrée

N = 4
nombre 1 : 5
nombre 2 : 10
nombre 3 : 15
nombre 4 : 20

Sortie

la somme est : 50
la moyenne est : 12.5

Explication : 5 + 10 + 15 + 20 = 50, et 50/4 = 12.5

Besoin d'un indice ?

Utilisez une variable s pour accumuler la somme
La boucle doit s'exécuter N fois pour demander chaque nombre
La moyenne = somme / N
Attention : N ne doit pas être nul pour la division

Solution Scilab

Principe : On accumule les valeurs dans une variable somme, puis on calcule la moyenne après la boucle.

Code :

N = input("Saisir N : ")
s = 0

for i = 1:N
    val = input("saisir un nombre : ")
    s = s + val
end

moyenne = s / N
disp("la somme est : ", s)
disp(moyenne, "la moyenne est : ")

Explication :
- On initialise la somme s à 0 avant la boucle
- À chaque itération, on ajoute la valeur saisie à la somme
- Après la boucle, on calcule la moyenne en divisant la somme par N

Exercice 3

Exercice

Validation d'un nombre entre 10 et 20

Niveau : Débutant Durée : 15 min

Écrire un programme qui demande un nombre compris entre 10 et 20, jusqu'à ce que la réponse convienne.

Si le nombre est supérieur à 20, afficher le message : "Plus petit !"
Si le nombre est inférieur à 10, afficher le message : "Plus grand !"
Quand un nombre valide est saisi, afficher "Bravo !"

Exemple

Entrée

saisir un nombre : 5
saisir un nombre : 25
saisir un nombre : 15

Sortie

plus grand
plus petit
bravo !

Explication : 5 est trop petit → "plus grand", 25 est trop grand → "plus petit", 15 est valide → "bravo !"

Besoin d'un indice ?

Utilisez une boucle while qui continue tant que le nombre n'est pas valide
Le nombre est valide si : n ≥ 10 ET n ≤ 20
Les messages doivent être affichés à l'intérieur de la boucle

Solution Scilab

Principe : On utilise une boucle while qui continue tant que le nombre est en dehors de l'intervalle [10,20].

Code :

n = input("saisir un nombre : ")

while (n < 10 | n > 20)
    if (n < 10) then
        disp("plus grand")
    end
    if (n > 20) then
        disp("plus petit")
    end
    n = input("saisir un nombre : ")
end

disp("bravo !")

Explication :
- On commence par demander un premier nombre
- La condition n < 10 | n > 20 vérifie si le nombre est invalide
- À l'intérieur de la boucle, on affiche le message approprié
- On redemande un nouveau nombre à chaque itération
- Quand on sort de la boucle, le nombre est valide

Exercice 4

Exercice

Nombre parfait

Niveau : Intermédiaire Durée : 20 min

Écrire un programme qui détermine si un entier N est parfait ou non.

Un entier est dit parfait s'il est égal à la somme de ses diviseurs (autres que lui-même).

Exemple : 6 est parfait car 6 = 3 + 2 + 1 (ses diviseurs sont 1, 2 et 3).

Exemple 1

Entrée

N = 6

Sortie

le nombre est parfait

Exemple 2

Entrée

N = 12

Sortie

le nombre n'est pas parfait

Explication : Les diviseurs de 12 sont 1,2,3,4,6. Leur somme est 1+2+3+4+6 = 16 ≠ 12

Besoin d'un indice ?

On cherche tous les diviseurs de N (sauf N lui-même)
Un diviseur est un nombre i tel que N % i == 0 (modulo nul)
Il suffit de chercher jusqu'à N/2 car un diviseur ne peut pas dépasser la moitié de N
Additionnez tous les diviseurs trouvés

Solution Scilab

Principe : On calcule la somme des diviseurs de N (excluant N), puis on compare avec N.

Code :

N = input("Saisir N : ")
s = 0

for i = 1:(N/2)
    if modulo(N, i) == 0 then
        s = s + i
    end
end

if s == N then
    disp("le nombre est parfait")
else
    disp("le nombre n'est pas parfait")
end

Explication :
- On parcourt tous les entiers de 1 à N/2
- modulo(N,i)==0 vérifie si i divise N
- Si c'est le cas, on ajoute i à la somme
- Après la boucle, on compare la somme à N

Exercice 5

Exercice

Moyenne de notes avec saisie illimitée

Niveau : Intermédiaire Durée : 20 min

Écrire un programme qui permet de calculer la moyenne de notes fournies au clavier.

Contraintes :

Le nombre de notes n'est pas connu a priori - l'utilisateur peut en fournir autant qu'il le désire
Pour signaler qu'il a terminé, on convient qu'il fournira une note fictive négative
Cette note négative ne doit pas être prise en compte dans le calcul de la moyenne
Si aucune note valide n'est saisie, afficher un message approprié

Exemple

Entrée

saisir une note : 12
saisir une note : 15
saisir une note : 10
saisir une note : -1

Sortie

moyenne de ces 3 notes : 12.333333

Explication : (12 + 15 + 10) / 3 = 37/3 ≈ 12.333. La note -1 est le signal d'arrêt et n'est pas comptée.

Besoin d'un indice ?

La condition d'arrêt est une note négative
Il faut compter le nombre de notes valides (positives ou nulles)
Utilisez une boucle while qui continue tant que la note est ≥ 0
Pensez au cas où la première note est déjà négative

Solution Scilab

Principe : On utilise une boucle while avec une condition d'arrêt sur note négative. On accumule la somme et le nombre de notes.

Code :

note = input("saisir une note : ")
s = 0
n = 0

while note >= 0
    s = s + note
    n = n + 1
    note = input("saisir une note : ")
end

if n > 0 then
    moyenne = s / n
    disp("moyenne de ces " + string(n) + " notes : ", moyenne)
else
    disp("saisir au moins une note")
end

Explication :
- On demande une première note avant la boucle
- La boucle continue tant que la note est ≥ 0
- À l'intérieur, on accumule la note et on incrémente le compteur
- On redemande une nouvelle note à la fin de la boucle
- Après la boucle, on vérifie qu'au moins une note a été saisie

Exercice 6

Exercice

Épargne et intérêts composés

Niveau : Intermédiaire Durée : 25 min

Soit un montant m donné déposé dans une caisse d'épargne à un taux d'intérêt annuel t donné (par exemple, t=0.05 pour 5%).

Objectifs : Élaborer un programme qui calcule :

Le montant épargné après 10 ans (intérêts composés)
Le nombre d'années nécessaires pour que ce montant atteigne 1 000 000 DH

Rappel : Les intérêts composés signifient que chaque année, les intérêts s'ajoutent au capital pour produire de nouveaux intérêts.

Exemple

Entrée

montant initial = 100000
taux d'intérêt = 0.05 (5%)

Sortie

le montant épargné après 10 ans est : 162889.46
nombre d'années nécessaires pour atteindre 1000000 DH est : 48

Explication : Avec un taux de 5%, le capital est multiplié par 1.05 chaque année. Après 10 ans : 100000 × 1.05¹⁰ ≈ 162889.46. Pour atteindre 1 million, il faut 48 ans.

Besoin d'un indice ?

Pour les intérêts composés : capital = capital + capital × taux
Pour la première question, une boucle de 10 itérations suffit
Pour la deuxième question, utilisez une boucle while jusqu'à atteindre l'objectif
Attention : le taux doit être en décimal (ex: 5% = 0.05)

Solution Scilab

Principe : Application des intérêts composés par itérations annuelles.

Question 1 - Après 10 ans :

m = input("saisir le montant : ")
t = input("saisir le taux d'intérêt (ex: 0.05 pour 5%) : ")
montant = m

for i = 1:10
    montant = montant + montant * t
end

disp("le montant épargné après 10 ans est : ", montant)

Question 2 - Années pour atteindre 1 000 000 :

m = input("saisir le montant : ")
t = input("saisir le taux d'intérêt (ex: 0.05 pour 5%) : ")
montant = m
annee = 0

while montant < 1000000
    montant = montant + montant * t
    annee = annee + 1
end

disp("nombre d'années nécessaires pour atteindre 1000000 DH est : ", annee)

Explication :
- À chaque année, le capital augmente de montant * t
- Pour la première question, on arrête après exactement 10 itérations
- Pour la deuxième, on continue tant que l'objectif n'est pas atteint
- Le compteur annee s'incrémente à chaque année

Sortie

// La sortie apparaîtra ici…

Prêt · Ctrl+Entrée pour exécuter

Précédent TD 1 structures conditionnelles corrigé Scilab

Suivant TD 3 corrigé sur les suites en Scilab

Exercice 1

Affichage des N premiers entiers impairs (ordre décroissant)

Exercice 2

Somme et moyenne de N entiers

Exercice 3

Validation d'un nombre entre 10 et 20

Exercice 4

Nombre parfait

Exercice 5

Moyenne de notes avec saisie illimitée

Exercice 6

Épargne et intérêts composés

Discussion (0)

Laisser un commentaire

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

TD 2 corrigé sur les boucles en Scilab

Exercice 1

Affichage des N premiers entiers impairs (ordre décroissant)

Exercice 2

Somme et moyenne de N entiers

Exercice 3

Validation d'un nombre entre 10 et 20

Exercice 4

Nombre parfait

Exercice 5

Moyenne de notes avec saisie illimitée

Exercice 6

Épargne et intérêts composés

Discussion (0)

Laisser un commentaire