Algorithmique et Applications en CPES2

Instruction Répétitive 1
PSL CPES 1re année
Informatique 2016-2017
Exercices sur les instructions répétitives
Exercices préparées par V. Gabrel, E. Lazard, M. Manouvrier et C. Murat 1
Les instructions répétitives (boucles) permettent de répéter un bloc d’instructions. La syn-
taxe d’une instruction répétitive est :
while expression_booleenne :
BlocInstruction
Exercice 1
Soit le programme Python suivant :
i=int(input("debut : "))
j=int(input("fin : "))
while (i!=j):
if (i%7==0):
print(i, " est multiple de 7")
i+=1
1. Que fait ce programme dans le cas général ?
2. Que se passe-t-il si on entre une valeur de istrictement plus grande que j? Comment
pourrait-on améliorer ce programme ?
Correction
1. Le programme fait saisir deux variables entières iet j. Puis affiche tous les multiples de
7 entre iet j(jexclus et si iest inférieur à j).
2. Si iest supérieur à jle programme va tourner indéfiniment (la boucle tant que s’exécu-
tera tant que iest supérieur à j, ce qui sera toujours le cas). Pour améliorer le programme,
il faut changer la condition et mettre tant que i<j.
Exercice 2
Étant donnée f(x) = x3−3x2+ 1, une fonction continue et strictement croissante sur l’in-
tervalle [2; 3], l’algorithme ci-dessous permet de déterminer la valeur approchée de xtelle que
f(x) = 0 par une méthode dichotomique avec une précision .
1. Cours également dispensé en 1ère année de licence Mathématique-Informatique-Économie (MIE) à l’Uni-
versité Paris-Dauphine

2Instruction répétitive
VARIABLES
precision EST_DU_TYPE NOMBRE
a,b,m EST_DU_TYPE NOMBRE
f_m,f_b EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
LIRE precision
a <- 2
b <- 3
TANT_QUE (b-a > precision) FAIRE
DEBUT_TANT_QUE
m <- (a+b)/2
f_m <- (m**3) - 3*(m**2) + 1
f_b <- (b**3) - 3*(b**2) + 1
SI (f_m*f_b > 0) ALORS
DEBUT_ALORS
b <- m
FIN_ALORS
SINON
DEBUT_SINON
a <- m
FIN_SINON
FIN_TANT_QUE
ECRIRE a
ECRIRE " <= solution <= "
ECRIRE b
FIN_ALGORITHME
Programmer en Python cet algorithme.
precision=float(input())
a=2
b=3
while (b-a > precision):
m=(a+b)/2
f_m=(m**3) - 3*(m**2) + 1
f_b = (b**3) - 3*(b**2) + 1
if (f_m*f_b > 0):
b=m
else:
a=m
print(a, ’<= solution <=’, b)
>>> (executing lines 1 to 12 of "<tmp 1>")
0.00001
2.8793792724609375 <= solution <= 2.8793869018554688

Instruction Répétitive 3
Exercice 3
Écrire un programme en Python qui saisit un réel x≥0et un entier n≥0, et affiche la valeur
de xn(sans utiliser l’opérateur puissance). Tester votre programme pour les valeurs suivantes :
x= 4 n= 3, x = 5 n= 0, x = 0 n= 0.
Correction
x=int(input(’entrez x’))
n=int(input(’entrez n’))
resul=1
while n>0:
resul=resul*x
n-=1
print(resul)
Exercice 4
Soit pour tout n∈N∗,Sn=
n
X
k=1
1
k, écrire un programme déterminant la plus petite valeur de
npour laquelle Sn> A,Aétant un réel entré par l’utilisateur. N’essayez pas votre programme
avec des valeurs de Asupérieures à 20.
A=float(input("A = "))
n=1
un=1
while un <= A :
n+=1
un = un + 1/n
print(n,un)
Quand A= 10,n= 12367 et S12367 = 10.000043008275778
Exercice 5
Soit la suite définie par u0= 0, et pour tout n∈N,un+1 =√3un+ 4.
1. Écrire un programme demandant à l’utilisateur un entier net affichant tous les termes
de la suite jusqu’à un.
2. Modifier votre programme pour qu’il affiche le plus petit entier npour lequel un>4−,
où  > 0. Que trouve-t-on pour = 10−8= 1.e −8?
Exercice 6
Écrire un algorithme en pseudo-langage puis en Python, qui saisit un entier (supposé strictement
positif), affiche la somme de tous ses diviseurs stricts et précise si ce nombre est premier. Par
exemple, si l’on saisit 8, il affiche 7 (car somme de ses diviseurs stricts qui sont 1, 2 et 4).

4Instruction répétitive
Correction
VARIABLES
n EST_DU_TYPE NOMBRE // entier saisi par l’utilisateur
d EST_DU_TYPE NOMBRE // diviseur
somme EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
LIRE n
d <- 1
somme <- 0
TANT_QUE (d<n) FAIRE
DEBUT_TANT_QUE
SI ((n%d)==0) ALORS
DEBUT_ALORS
somme <- somme+d
FIN_ALORS
d <- d+1
FIN_TANT_QUE
SI ((somme==1) ET (n!=1)) ALORS
DEBUT_ALORS
ECRIRE "Ce nombre est premier."
FIN_ALORS
SINON
DEBUT_SINON
ECRIRE "La somme des diviseurs est :"
ECRIRE somme
FIN_SINON
FIN_ALGORITHME
Exemples d’exécution :
Exemple d’exécution avec n=5
d <- 2
somme = 1
(d<n): n%d ==1
d<-3
(d<n): n%d ==2
d<-4
(d<n): n%d ==1
d<-5
(d==n) on sort du tant que
somme==1 on affiche "Ce nombre est premier"
Exemples d’exécution avec n=8
d=2
somme = 1
(d<n): n%d ==0
somme=1+2

Instruction Répétitive 5
d=3
(d<n): n%d ==2
d=4
(d<n): n%d ==0
somme=3+4
d=5
(d<n): n%d ==3
d=6
(d<n): n%d ==2
d=7
(d<n): n%d ==1
d=8
(d==n) on sort du tant que
somme!=1 on affiche "La somme des diviseurs est 7
Autre solution :
VARIABLES
k EST_DU_TYPE NOMBRE // compteur
s EST_DU_TYPE NOMBRE // somme des diviseurs
n EST_DU_TYPE NOMBRE // entier saisi par l’utilisateur
DEBUT_ALGORITHME
LIRE n
k <- 1
s <- 0
TANT_QUE (k<n) FAIRE
DEBUT_TANT_QUE
SI ((n/k)==PARTIE_ENTIERE(n/k)) ALORS
DEBUT_ALORS // Si k est un diviseur de n
s <- s+k
FIN_ALORS
k <- k+1
FIN_TANT_QUE
ECRIRE s
SI ((s==1) et (n!=1)) ALORS
DEBUT_ALORS
ECRIRE n
ECRIRE " est premier."
FIN_ALORS
SINON
DEBUT_SINON
ECRIRE "La somme des diviseurs est "
ECRIRE s
FIN_SINON
FIN_ALGORITHME
NB (pour nous uniquement) : dans le logiciel d’AlgoBox, l’instruction PARTIE_ENTIERE
est : floor(x).