Vous êtes sur la page 1sur 2

PCSI2 2010/2011

Boucles et tests

P100
Soit à calculer la somme s = k=1 k. Une façon de procéder est d’affecter la valeur 0 à la variable s,
puis d’effectuer la suite d’opérations s:=s+1, s:=s+2, . . ., s:=s+100. Après cette dernière opération, s a
bien la valeur voulue. Bien sûr, il y a beaucoup trop d’opérations à effectuer pour les écrire toutes. On
demande alors à Maple d’effectuer une boucle :
> s:=0:
for i from 1 to 100 do
s:=s+i
od:
s;
Cette suite d’instructions signifie exactement : pour i variant de 1 jusqu’à 100, effectuer l’instruction
suivante (ou la suite d’instructions) : ajouter i à la variable s. L’instruction od indique la fin de la
succession d’actions à effectuer (ici, une seule).
Noter l’intérêt de l’utilisation de : au lieu de ; : dans le cas contraire, tous les résultats intermédiaires
seraient affichés. Comme aucun ne l’est, il faut demander l’affichage de s à la fin de la boucle.
À la fin de la boucle, la variable i est affectée à la première valeur qui n’a pas été utilisée :
> i;
101
La syntaxe la plus générale pour une boucle est la suivante (les mots en italique ne désignent pas des
commandes Maple ; il faut les remplacer par les expressions adéquates) :
> for variable from début by pas to fin while condition do
instructions
od;
ou bien
> for variable in expression while condition do
instructions
od;

Commentaires
– for variable : n’est nécessaire que si l’on a besoin d’utiliser la variable que l’on va incrémenter. Dans
l’exemple précédent, on aurait pu se contenter d’écrire : from 1 to 100 do s:=s+1 od;.
– from début : est optionnel (par défaut, est égal à 1). Ainsi, l’instruction précédente aurait même pu
être écrite de la façon suivante : to 100 do s:=s+1 od;.
– by pas : spécifie de combien doit être incrémentée la variable à chaque passage. C’est également
optionnel (par défaut, c’est égal à 1). Cela permet par exemple de faire varier i de 1 à 100 en ne
conservant que les nombres impairs, ou bien de faire décroître la variable (en prenant pas < 0).
– to fin : indique jusqu’à quelle valeur la variable peut aller. Elle n’est pas nécessairement atteinte : par
exemple, si l’on commence avec i=1 et que le pas est égal à 2, on n’obtiendra jamais la valeur 100. La
dernière instruction effectuée sera celle correspondant à la dernière valeur inférieure ou égale à fin (ici,
99) ; la valeur de i sera encore incrémentée une fois, puis comparée à fin . Comme elle l’aura dépassée
strictement, on sortira de la boucle (c’est ce qui explique la valeur de variable en sortie de boucle).
L’instruction to fin est elle aussi optionnelle, mais il vaut alors mieux imposer une condition d’arrêt
de la boucle grâce à while. Par exemple, la boucle réduite à sa plus simple expression do od; est une
boucle infinie qui ne fait rien.
– while : permet d’imposer des conditions supplémentaires pour un arrêt de la boucle. En sortie, la
variable est encore égale à la première valeur non utilisée. Optionnel. Exemple : la boucle
> s:=0;
for k while s<5 do s:=s+1/k od:
k;

1
X
n
1
donne la plus petite valeur de n telle que > 5.
k
k=1

Exercices
1. Calculer 10! grâce à une boucle.
2. Déterminer le plus petit diviseur de 57469 (indication : grâce à une boucle, tester le reste de la
division par l’entier i tant que ce reste est non nul. Le reste de la division de a par b est a mod b,
ou irem(a,b) (le quotient est iquo(a,b)).

Instructions conditionnelles
La syntaxe est :
> if condition then instruction elif condition1 then instruction1
elif condition2 then instruction2
.
.
.
elif condition n then instruction n
else instruction finale
fi;
Si condition est vérifiée, alors Maple exécute instruction puis sort de la structure conditionnelle
(après le fi). Sinon, il teste si condition1 est vérifiée ; si oui, il exécute instruction1 puis sort, sinon
il teste condition2 ... Si aucun des conditions n’est vérifiée, il exécute instruction finale puis sort.
Les champs elif et else sont optionnels.

Exemple : on note P1 l’ensemble des nombres premiers inférieurs ou égaux à 100. Calculer les sommes
suivantes : X
S1 = p et S2 = 02 + 13 + 22 + · · · + 993 + 1002
p∈P1

Indication : utiliser une boucle et l’instruction isprime.

Exercices
1. Écrire un programme calculant la plus grande puissance d’un entier x inférieure ou égale à un autre
entier y.
2. Écrire un programme déterminant la somme des diviseurs propres (i.e. différents de lui-même) d’un
entier N quelconque. On pourra commencer par le faire pour N = 200 par exemple avant d’écrire
le programme général. On remarquera que l’on peut s’arrêter de tester bien avant N − 1...
Indication : créer un compteur S, initialisé à 0, dont on augmente la valeur à chaque fois que l’on
a trouvé un diviseur de N . Pour chercher ces diviseurs, faire une boucle et un test (k divise N si,
et seulement si, son reste dans la division par k est nul...)
3. Un entier N est dit parfait si, et seulement si, il est égal à la somme de tous ses diviseurs propres
(exemple : 6 = 1 + 2 + 3 est parfait). Écrire un programme déterminant si un entier N est parfait.
Le résultat sera le booléen true ou false. On utilisera le programme précédent.
4. Écrire un programme, utilisant la commande isprime, déterminant la séquence des nombres pre-
miers inférieurs à N .
5. Écrire un programme déterminant la séquence des nombres parfaits inférieurs à N .

Vous aimerez peut-être aussi