ECE2 2020-2021

Méthodes itératives : Annales 2015 à 2020

I. Suites de type un+1 = f (un )

ECRICOME − 2015
• On considère la fonction F définie par :
(
0 si x < 0
F (x) =
1 − e−x si x > 0

(fonction de répartition de d’une v.a.r. X telle que X ,→ E (1))

et on définit la suite (un )n∈N∗ définie par :
(
u1 = 1
∀n ∈ N∗ , un+1 = F (un )

a) Recopier et compléter le programme Scilab suivant qui permet de représenter les cent premiers
termes de la suite (un )n∈N∗ :

1 U = zeros(1,100)
2 U(1) = 1
3 for n = 1 : 99
4 U(n+1) = ––––––
5 end
6 plot(U,"+")

Démonstration.

1 U = zeros(1,100)
2 U(1) = 1
3 for n = 1 : 99
4 U(n+1) = 1 - exp( U(n) )
5 end
6 plot(U,"+")

b) Le programme complété permet d’obtenir la représentation graphique suivante.

Quelle conjecture pouvez-vous émettre sur la monotonie et la limite de la suite (un )n∈N∗ ?

Démonstration.
D’après la représentation graphique, la suite (un ) semble être convergente, de limite nulle.

1
ECE2 2020-2021

c) On modifie le programme écrit en question a) en remplaçant la dernière ligne par :

1 X = 1:100
2 S = cumsum(U)
3 Y = log(X)
4 plot2d(X, S, -1)
5 plot2d(X, Y)

Le programme ci-dessus permet d’obtenir la représentation graphique suivante :

Que représente le vecteur-ligne S ?

Quelle conjecture pouvez-vous émettre sur la nature de la série de terme général un ?

Démonstration.
• Le vecteur U contient les 100 premiers éléments de la suite (un ). L’opérateur cumsum permet de
somme cumulée de ce vecteur. Ainsi, S contient les 100 premières sommes partielles
calculer la P
de la série un .
P
• D’après le tracé obtenu, on peut émettre l’hypothèse que la série un est divergente. Plus
précisément, que Sn −→ +∞.
n→+∞

2
ECE2 2020-2021

ECRICOME − 2018
   
2 1 −2 1 −1 −1
• On considère les matrices : A = 0 3 0  et B = −3 3 −3.
1 −1 5 −1 1 1
   
3 3 1 1
On pose X0 =  0 , X1 =  0 , et pour tout n ∈ N : Xn+2 = A Xn+1 + B Xn .
−1 −2 6 6

a) Compléter la fonction ci-dessous qui prend en argument un entier n supérieur ou égal à 2 et qui
renvoie la matrice Xn :

1 function res = X(n)

2 Xold = [3; 0; -1]
3 Xnew = [3; 0; -2]
4 A = [2,1,-2; 0,3,0; 1,-1,5]
5 B = [1,-1,-1; -3,3,-3; -1,1,1]
6 for i = 2:n
7 Aux = ..........
8 Xold = .........
9 Xnew = .........
10 end
11 res = .........
12 endfunction

Démonstration.
Détaillons les différents éléments présents dans cette fonction.
− En ligne 2 et 3, on définit les variables Xold et Xnew.
Ces deux variables sont initialement affectées aux valeurs X0 et X1 .
− En ligne 4 et 5, on stocke les matrices A et B dans les variables A et B.
− De la ligne 6 à la ligne 10, on met à jour les variables Xold et Xnew de sorte à ce qu’elles
contiennent les valeurs successives de la suite matricielle (Xn ).

6 for i = 2:n
7 Aux = Xold
8 Xold = Xnew
9 Xnew = 1/6 ? A ? Xold + 1/6 ? B ? Aux
10 end
Pour ce faire, on a introduit une variable auxiliaire Aux.
Détaillons le principe de cette boucle :
× avant le 1
er tour de boucle :

Xold contient X0 et Xnew contient X1

lors du 1er tour de boucle (i contient 2) :
Aux contient X0 ,
 
Aux = Xold
dernière valeur de Xold
Xold contient X1 ,
 
Xold = Xnew
dernière valeur de Xnew
Xnew contient X2 , valeur obtenue par
 
Xnew = 1/6 ? A ? Xold + 1/6 ? B ? Aux
la définition X2 = 61 AX1 + 16 BX0

3
ECE2 2020-2021

× avant le 2ème tour de boucle, d’après ce qui précède :

Xold contient X0 , Xold contient X1 et Xnew contient X2

lors du 2ème tour de boucle (i contient 3) :

Aux contient X1 ,
 
Aux = Xold
dernière valeur de Xold
Xold contient X2 ,
 
Xold = Xnew
dernière valeur de Xnew
Xnew contient X3 , valeur obtenue par
 
Xnew = 1/6 ? A ? Xold + 1/6 ? B ? Aux
la définition X3 = 61 AX2 + 16 BX1
× ...
× avant le (n − 1)ème tour de boucle :

Xold contient Xn−3 , Xold contient Xn−2 et Xnew contient Xn−1

lors du (n − 1)ème tour de boucle (i contient n) :

Aux contient Xn−2 ,

 
Aux = Xold
dernière valeur de Xold
Xold contient Xn−1 ,
 
Xold = Xnew
dernière valeur de Xnew
Xnew contient Xn , valeur obtenue par la
 
Xnew = 1/6 ? A ? Xold + 1/6 ? B ? Aux
définition Xn = 61 AXn−1 + 61 BXn−2

− Enfin, il n’y a plus qu’à affecter à res la valeur Xn .

11 res = Xnew

Commentaire
• Afin de permettre une bonne compréhension des mécanismes en jeu, on a détaillé la réponse
à cette question. Cependant, écrire correctement la fonction Scilab démontre la bonne com-
préhension et permet certainement d’obtenir tous les points alloués.
• On a démontré dans cette question que si, avant le ième tour de boucle :

Aux contient Xi−2 , Xold contient Xi−1 et Xnew contient Xi

alors, à l’issue de ce tour de boucle :

Aux contient Xi−1 , Xold contient Xi et Xnew contient Xi+1

Cette propriété est ce qu’on appelle un invariant de boucle. Elle permet d’assurer la cor-
rection de la fonction implémentée et notamment le fait qu’à l’issue du dernier tour de boucle
la variable Xnew contient Xn .
• Il est à noter que si on teste la fonction avec une valeur de n strictement inférieure à 2, alors
on n’entre pas dans la boucle (l’instruction 2:n crée une matrice ligne vide). Dans ce cas, la
variable Xnew n’est pas mise à jour et la variable res contient à la fin du programme X1 , soit
la valeur initialement affectée à Xnew. Ainsi, la fonction renvoie la bonne valeur aussi lorsque
la variable n prend la valeur 1.

4
ECE2 2020-2021

 
αn
• Dans l’exercice, il était noté Xn =  βn  et on démontrait, pour tout n ∈ N :
γn
 n  n−1  n
11 2 1 1 3 1
αn = + − + − −
6 3 2 2 2 3
 n−1  n  n  n
1 2 1 4 11 2 1 3 1
βn = − − − et γn = − − − + −
2 3 2 3 6 3 2 2 3
b) La fonction précédente a été utilisée dans un script permettant d’obtenir graphiquement (voir
figure 1) les valeurs de αn , βn et γn en fonction de n.
Associer chacune des trois représentations graphiques à chacune des suites (αn )n∈N , (βn )n∈N ,
(γn )n∈N en justifiant votre réponse.

Démonstration.
Soit n ∈ N.
• D’après la question 5 :
 n−1  n
1 2 1 4 4
βn = − − − −→ − ' −1, 33
2 3 2 3 n→+∞ 3
 n−1  n
1 1 1 1
En effet, comme < 1 et − < 1 alors : lim = 0 et lim − = 0.
2 2 n→+∞ 2 n→+∞ 2
• On démontre de même, toujours d’après les expressions obtenues en question 5. :
11 11
αn −→ ' 1, 8 et γn −→ − ' −1, 8
n→+∞ 6 n→+∞ 6

• Or, d’après la figure :

× la suite repérée par × semble converger vers un réel valant approximativement 1, 8.
Cette représentation graphique correspond à la suite (αn ).
× la suite repérée par ⊕ semble converger vers un réel valant approximativement −1, 3.

5
ECE2 2020-2021

Cette représentation graphique correspond à la suite (βn ).

× la suite repérée par ♦ semble converger vers un réel valant approximativement −1, 8.
Cette représentation graphique correspond à la suite (γn ).

Commentaire
Il est possible de rédiger autrement.
La représentation graphique commençant à 2, on peut calculer :
14 11
α2 = , β2 = −1 et γ2 = −
6 6
ce qui permet d’associer chaque représentation graphique à la bonne suite.

EDHEC − 2019
4n (n!)2
• On définit la suite (un ) par : ∀n ∈ N, un = .
(2n + 1)!
On admet que, si t est un vecteur, la commande prod(t) renvoie le produit des éléments de t.
Compléter le script Scilab suivant afin qu’il permette de calculer et d’afficher la valeur de un pour
une valeur de n entrée par l’utilisateur.
1 n = input('entrez une valeur pour n : ')
2 x = 1:n
3 m = 2 ? n + 1
4 y = 1:m
5 v = ...........
6 w = ...........
7 u = ........... ? v ∧ 2 / w
8 disp(u)

Démonstration.
• Commentons tout d’abord le début du programme proposé.
× On commence par demander à l’utilisateur d’entrer une valeur pour l’entier n.
1 n = input('entrez une valeur pour n :')
× On stocke ensuite dans la variable x la matrice ligne contenant les entiers de 1 à n.
2 x = 1:n
× On stocke de plus dans la variable m la quantité 2n + 1.
3 m = 1 ? n + 1
× On stocke enfin dans la variable y la matrice ligne contenant les entiers de 1 à m, c’est-à-dire les
entiers de 1 à 2n + 1.
4 y = 1:m
• On cherche maintenant à stocker dans la variable u la valeur de un .
D’après la question 5.b) , pour tout n ∈ N :
4n (n!)2
un =
(2n + 1)!

6
ECE2 2020-2021

× L’énoncé propose de compléter la commande suivante :

7 u = .......... ? v ∧ 2 / w

Par analogie avec la formule de la question 5.b) , on souhaite donc stocker dans la variable v la
valeur n! et dans la variable w la valeur (2n + 1)!.
× On cherche alors une commande permettant d’obtenir n! = 1 × · · · × n.
D’après l’énoncé, la commande prod(t) renvoie le produit des éléments de t.
La variable x contient les entiers de 1 à n. Ainsi, pour obtenir n!, on peut utiliser la commande :
prod(x). On obtient donc :

5 v = prod(x)

× De même, comme la variable y contient les entiers de 1 à 2n + 1, pour obtenir (2n + 1)!, on peut
utiliser la commande : prod(y). On obtient :

6 w = prod(y)

× Pour finir, on complète la ligne 7 de la façon suivante (toujours d’après la formule de 5.b) ) :

7 u = (4 ∧ n) ? v ∧ 2 / w

Commentaire
• On pouvait aussi stocker la valeur n! dans la variable v à l’aide d’une boucle for :

1 v = 1
2 for i = 1:n
3 v = v ? i
4 end

• Comme dit précédemment, compléter correctement le programme Scilab démontre la

bonne compréhension de la mécanismes en jeu et est suffisant pour obtenir les points
alloués à cette question.

II. Calcul du premier entier n qui vérifie une condition donnée

EDHEC − 2016
• On considère une suite (un )n∈N qui vérifie :
√ √
∀n ∈ N, e− un
6 un − n 6 e− n

a) Compléter les commandes Scilab suivantes afin qu’elles permettent d’afficher un entier n pour
lequel un − n est inférieur ou égal à 10−4 .

1 n = 0
2 while ––––––
3 n = ––––––
4 end
5 disp(n)

Démonstration.

7
ECE2 2020-2021

• D’après ce qui précède : √

∀n ∈ N, un − n 6 e− n

• Afin de trouver un entier n tel que un − n 6 10−4 , il suffit de trouver N ∈ N tel que :
√
e− N
6 10−4

• On obtient alors, par transitivité :

√
uN − N 6 e− N
6 10−4
√
• Il s’agit donc de trouver le premier entier N tel que e− N 6 10−4 .
Pour ce faire, on teste successivement tous les entiers naturels.
On arrête l’itération dès le premier entier qui satisfait cette relation.

2 while exp(-sqrt(n)) > 10 ∧ (-4)

3 n = n + 1
4 end

Commentaire
√
• La terminaison du programme présenté est assuré par le fait que e− n −→ 0. Ainsi,
√ n→+∞
pour tout ε > 0, il existe N ∈ N tel que : ∀n > N , e− n 6 ε.
C’est notamment vrai pour ε = 10−4 .
• L’énoncé original contenait une coquille sans gravité. En effet, la quesiton posée de-
mandait de trouver le premier n tel que vn est inférieur ou égal à 10−4 .
Or, la suite (vn ) n’est introduite qu’en question 4 .

b) Le script ci-dessous affiche l’une des trois valeurs n = 55, n = 70 et n = 85.

Préciser laquelle en prenant 2, 3 comme valeur approchée de ln(10).

Démonstration.
• On cherche à déterminer l’entier N précédent. Or :
√ √ (car x 7→ ln(x) est strictement
e− n 6 10−4 ⇔ − n 6 ln(10−4 ) = −4 ln(10)
croissante sur R∗+ )
√
⇔ n > 4 ln(10)

2 (car x 7→ x2 est strictement
⇔ n > 4 ln(10)
croissante sur [0, +∞[)
√
Ainsi, le premier entier vérifiant la relation : e− n 6 10−4 est l’entier N = (4 ln(10))2 .
 

(où x 7→ dxe désigne la fonction partie entière par excès)

• Cherchons maintenant une valeur approchée de (4 ln(10))2 .
D’après l’énoncé : ln(10) ' 2, 3, donc 4 ln(10) ' 9, 2 > 9.
On en déduit :
2
4 ln(10) > 92 = 81
La seule solution possible parmi celles proposées est n = 85.

Le script affiche n = 85.

8
ECE2 2020-2021

EML − 2016
x2 − x ln(x) si x 6= 0
(
• On considère la fonction f définie par : f (x) =
0 si x = 0
1
(
u0 = 2
et on définit la suite (un )n∈N∗ par :
∀n ∈ N, un+1 = f (un )
(on démontre que (un ) est croissante et qu’elle converge vers 1)
a) Écrire un programme en Scilab qui calcule et affiche un entier naturel N tel que :

1 − uN < 10−4

Démonstration.

1 n = 0
2 u = 1/2
3 while 1 - u >= 10 ∧ (-4)
4 u = u ∧ 2 - u ? log(u)
5 n = n + 1
6 end
7 disp(n)

EML − 2017
• On considère la fonction f : ]0, +∞[→ R définie par f : x 7→ ex − e ln(x).

u0 = 2
• On considère la suite réelle (un )n∈N définie par :
∀n ∈ N, un+1 = f (un )

a) Écrire un programme en Scilab qui, étant donné un réel A, renvoie un entier naturel N tel que
uN > A.

Démonstration.

1 A = input('A=')
2 N = 0
3 u = 2
4 while u < A
5 u = exp(u) - %e ? ln(u)
6 N = N + 1
7 end
8 disp(N)

III. Calcul de la valeur approchée de la limite d’une suite

EML − 2015
• On considère l’application f : R → R, x 7→ f (x) = x3 ex .
P 1 +∞
P 1
a) Montrer que la série converge. On note S = .
n>1 f (n) n=1 f (n)

Démonstration.

9
ECE2 2020-2021

P 1
• La série est à termes positifs.
n>1 f (n)
1
n2
 
1 1 1 n3 en 1
• De plus : = 3 n = o . En effet, 1 = = −→ 0.
f (n) n e n→+∞ n2 n2
n 3 en n en n→+∞
P 1
Or, d’après le critère de Riemann (2 > 1), la série 2
est convergente.
n>1 n

Ainsi, d’après le théorème de négligeabilité des séries à termes positifs, la série

P 1
est convergente.
n>1 f (n)

n 1 1
On démontre alors que : ∀n ∈ N∗ , S −
P
6 .
k=1 f (k) (e − 1) en
b) En déduire une fonction Scilab qui calcule une valeur approchée de S à 10−4 près.

Démonstration.
• Afin de calculer une valeur approchée de S à 10−4 près, il suffit de trouver n ∈ N∗ tel que :
1
6 10−4
(e − 1) en

• En effet, d’après la question précédente, on a alors :

n 1 1
6 10−4
P
S− 6
k=1 f (k) (e − 1) en
n
P 1
et constitue dans ce cas l’approximation recherchée.
k=1 f (k)
• On en déduit le programme suivant.

1 n = 1
2 S = 1 / exp(1)
3 while 1 / ((exp(1)-1) ? exp(n)) > 10 ∧ (-4)
4 n = n + 1
5 S = S + 1 / (n ∧ 3 ? exp(n))
6 end

10
ECE2 2020-2021

Commentaire

Le programme précédent propose de déterminer la valeur de n et de Sn en procédant

par itération. On peut aussi remarquer que :

1 −4 n 104
6 10 ⇔ e > ⇔ n > 4 ln(10) − ln(e − 1)
(e − 1) en (e − 1)

(par stricte croissance de la fonction ln)

Ainsi, Sn est une approximation de S pour tout n > m = d4 ln(10) − ln(e − 1)e.
On en déduit le programme Scilab suivant.
1 m = ceil(4 ? log(10) - log(exp(1)-1))
2 S = 0
3 for i = 1:m
4 S = S + 1 / (i ∧ 3 ? exp(i))
5 end

EML − 2018
• On pose : u0 = 4 et ∀n ∈ N, un+1 = ln(un ) + 2.
On devait démontrer les propriétés suivantes.
• ∀n ∈ N, un > b.
1
• ∀n ∈ N, un+1 − b 6 (un − b).
2
1
• ∀n ∈ N, 0 6 un − b 6 n−1 .
2
a) Écrire une fonction Scilab d’en-tête function u = suite(n) qui, prenant en argument un entier
n de N, renvoie la valeur de un .

Démonstration.

1 function u = suite(n)
2 u = 4
3 for k = 1:n
4 u = log(u) + 2
5 end
6 endfunction

Expliquons un peu ce programme.

La variable u est créée pour contenir successivement les valeurs u0 , u1 , . . ., un .
• On initialise donc cette variable à u0 = 4 avec la ligne 2

2 u = 4

• On met ensuite à jour u de manière itérative avec la ligne 4

4 u = log(u) + 2

11
ECE2 2020-2021

Commentaire
• On décrit ici de manière précise les instructions afin d’aider le lecteur un peu moins
habile en Scilab.
Cependant, l’écriture du script démontre la compréhension de toutes les commandes en
question et permet sans doute d’obtenir la totalité des points alloués à cette question.
• Si on avait souhaité afficher tous les n premiers termes de la suite (un ), on aurait modifié
le script précédent de la façon suivante :

1 function u = suite(n)
2 u = zeros(1, n)
3 u(1) = 4
4 for k = 2:n
5 u(k) = log(u(k-1)) + 2
6 end
7 endfunction

b) Recopier et compléter la ligne 3 de la fonction Scilab suivante afin que, prenant en argument un
réel epsilon strictement positif, elle renvoie une valeur approchée de b à epsilon près.

1 function b = valeur_approchee(epsilon)
2 n = 0
3 while ...........
4 n = n + 1
5 end
6 b = suite(n)
7 endfunction

Démonstration.
• D’après la question 6.b) :
1
∀n ∈ N, 0 6 un − b 6
2n−1
1
S’il existe N ∈ N tel que 6 ε, on obtiendra par transitivité :
2n−1
0 6 uN − b 6 ε

Donc uN est une valeur approchée de b à ε près.

• On complète alors le programme Scilab de la façon suivante :
3 while 1 / 2 ∧ (n-1) > epsilon

EML − 2019
• On considère la fonction f définie sur ]0, +∞[ par :
1
∀t ∈ ]0, +∞[, f (t) = t +
t
• On introduit la suite (un )n∈N∗ définie par :
1 1
u1 = 1 et ∀n ∈ N∗ , un+1 = un + = f (n un )
n2 un n

12
ECE2 2020-2021

• Dans l’exercice, on devait démontrer la convergence de la suite (un ) vers un réel ` (qu’il ne fallait
pas déterminer). De plus, on devait démontrer :
1
∀p > 2, 0 6 ` − up 6 (∗)
p−1
a) Recopier et compléter les lignes 3 et 4 de la fonction Scilab suivante afin que, prenant en argument
un entier n de N∗ , elle renvoie la valeur de un .

1 function u=suite(n)
2 u = 1
3 for k = ..................
4 u = ..................
5 end
6 endfunction

Démonstration.

1 function u=suite(n)
2 u = 1
3 for k = 1:(n-1)
4 u = (1/n) ? (n?u + 1/(n?u))
5 end
6 endfunction

Détaillons l’obtention de ce programme.

La variable u est crée pour contenir successivement les valeurs u1 , . . ., un .
• On initialise donc cette variable à u1 = 1 avec la ligne 2.

2 u = 1

• On met ensuite à jour u à l’aide d’une structure itérative (boucle for) avec les lignes 3 à 5.

3 for k = 1:(n-1)
4 u = (1/n) ? (n?u + 1/(n?u))
5 end

13
ECE2 2020-2021

Commentaire
• On décrit ici de manière précise les instructions afin d’aider le lecteur un peu moins
habile en Scilab. Cependant, l’écriture du script démontre la compréhension de toutes
les commandes en question et permet sans doute d’obtenir la totalité des points alloués
à cette question.
• On pouvait également coder la fonction f dans un script à part. On aurait alors obtenu
les deux programmes suivants :

1 function y=f(t)
2 y = t + 1/t
3 endfunction

1 function u=suite(n)
2 u = 1
3 for k = 1:(n-1)
4 u = (1/n) ? f(n?u)
5 end
6 endfunction

b) Déduire de la propriété (∗) une fonction Scilab qui renvoie une valeur approchée de ` à 10−4 près.

Démonstration.
• On cherche ici à trouver un entier N tel que uN est une valeur approchée de ` à 10−4 près.
Autrement dit, on souhaite exhiber N ∈ N tel que :

|` − uN | 6 10−4

1
• Or, d’après la question précédente : ∀p > 2, 0 6 ` − up 6 .
p−1
1
• Il suffit alors de trouver N ∈ N tel que : 6 10−4 .
N −1
Si c’est le cas, on obtient alors par transitivité :

0 6 ` − uN 6 10−4

• On propose alors le programme suivant :

1 function l = valeur_approchee()
2 n = 2
3 while 1 / (n-1) > 10 ∧ (-4)
4 n = n + 1
5 end
6 l = suite(n)
7 endfunction

Détaillons les éléments de ce script.

- Début du script
1
La variable n est initialisée à 2. En effet, on souhaite pouvoir effectuer le calcul : .
n−1
2 n = 2

14
ECE2 2020-2021

- Structure itérative
1
Les lignes 3 à 5 consistent à déterminer le plus petit entier n tel que 6 10−4 . On
  n−1
1
doit donc comparer les valeurs successives de la suite au réel 10−4 jusqu’à ce
n − 1 n>2
1
que 6 10−4 . Autrement dit, on doit comparer ces valeurs successives à 10−4 tant que
n−1
1
> 10−4 . Pour cela on met en place une structure itérative (boucle while) :
n−1
3 while 1 / (n-1) > 10 ∧ (-4)

On met alors à jour en conséquence

 la variable n : on ajoute 1 pour signaler qu’on va comparer

1
le terme suivant de la suite à 10−4 .
n − 1 n>2

4 n = n + 1

- Fin du script
1
À la fin de cette boucle, on est assuré que : 6 10−4 (on itère tant que ce n’est pas le
n−1
cas).
Il reste alors à calculer la valeur approchée de ` : on l’obtient par le calcul de un où n est la
valeur obtenue à l’issue de cette boucle.
6 l = suite(n)

Commentaire
• Lorsqu’on écrit une boucle while, il est préférable
 des’assurer en amont de sa termi-
1
naison. C’est bien le cas ici. En effet, la suite est convergente de limite 0.
n − 1 n>2
Ce qui signifie :
1
∀ε > 0, ∃n0 ∈ N, ∀n > n0 , −0 <ε
n−1
Ainsi, quelle que soit la précision ε > 0 choisie au départ (ici 10−4 ), on est toujours en
1
mesure de trouver un rang n0 à partir duquel on aura : < 10−4 .
n−1
• On pouvait déterminer, sans utiliser de boucle, un entier N tel que uN est une valeur
approchée à 10−4 près de `. Pour ce faire, on remarque :
1
6 10−4 ⇔ n − 1 > 104 ⇔ n > 104 + 1
n−1

L’entier N = d104 + 1e convient.

ECRICOME − 2018

Pn 1
• Pour tout entier naturel n non nul, on pose : un = − ln(n).
k=1 k
• On démontrait que la suite (un ) était convergente, vers une limite notée γ ∈ R puis :
1
∀n ∈ N∗ , |un − γ| 6
n

15
ECE2 2020-2021

a) Écrire une fonction d’en-tête : function y = u(n) qui prend en argument un entier naturel n non
nul et qui renvoie la valeur de un .

Démonstration.

1 function y = u(n)
2 S = 0
3 for k = 1:n
4 S = S + 1/k
5 end
6 y = S - log(n)
7 endfunction

Détaillons les différents éléments de ce code :

n
en ligne 2, on crée la variable S dont le but est de contenir, en fin de programme 1
P
×
k.
k=1
Cette variable S est donc initialisée à 0.
× de la ligne 3 à la ligne 5, on met à jour la variable S à l’aide d’une boucle.
Pour ce faire, on ajoute au k ème tour de boucle la quantité k1 .
n
Ainsi, S contient bien 1
P
k en sortie de boucle.
k=1
n
en ligne 6, on affecte à la variable y la valeur un = 1
P
×
k − ln(n).
k=1

Commentaire
n
P 1
Pour le calcul de la somme k, on peut aussi tirer profit des fonctionnalités Scilab :
k=1

S = sum(1 ./ 1:n)
Pour bien comprendre cette instruction, rappelons que :
× l’instruction 1:n permet de créer la matrice ligne (1 2 ... n).
× l’opérateur ./ permet d’effectuer la division terme à terme.
Ainsi, l’instruction 1 ./ 1:n permet de créer la matrice ligne ( 11 1
2 ... 1
n ).
× la fonction sum permet de sommer tous les coefficients d’une matrice.
On obtient donc bien la somme à calculer par cette méthode.

b) On rappelle que l’instruction floor(x) renvoie la partie entière d’un réel x et on suppose que
la fonction u a été correctement programmée. Expliquer l’intérêt et le fonctionnement du script
ci-dessous :
1 eps = input('Entrer un réel strictement positif : ')
2 n = floor(1/eps) + 1
3 disp(u(n))

Démonstration.
• Ce script a pour but d’afficher une valeur approchée de γ à ε près (où ε est un réel strictement
positif fourni par l’utilisateur et stocké dans la variable eps).
Pour ce faire, il faut commencer par trouver un entier N ∈ N∗ tel que :

uN − γ 6 ε

16
ECE2 2020-2021

• Or, d’après ce qui précède :

1
∀n ∈ N∗ , un − γ 6
n
Afin de trouver l’entier N recherché, il suffit de trouver un entier N ∈ N∗ tel que :
1
6 ε
N
Si c’est le cas, on obtient alors, par transitivité :
1
uN − γ 6 6 ε
N
• Raisonnons par équivalence pour trouver N :

1 1 (par décroissance de la
6 ε ⇔ N >
N ε fonction inverse sur ]0, +∞[)
1
Ainsi, tout entier plus grand que ε convient. En particulier, l’entier N = b 1ε c + 1 convient.

Ce script affiche la valeur uN où N = b 1ε c + 1. C’est une valeur approchée de γ à ε près.

IV. Calcul de la valeur approchée des éléments d’une suite

EML − 2020

• On note, pour tout n de N∗ , (En ) l’équation : xn + x − 1 = 0.

• On devait démontrer les propriétés suivantes :
× pour tout n ∈ N∗ , l’équation (En ) admet une unique solution sur R+ que l’on note un (via l’étude
de la fonction x 7→ xn + x − 1).
× pour tout n de N∗ , un appartient à l’intervalle ]0, 1[.
a) Recopier et compléter la fonction Scilab suivante afin que, prenant en argument un entier n
de N∗ , elle renvoie une valeur approchée de un à 10−3 près, obtenue à l’aide de la méthode par
dichotomie.
1 function u = valeur_approchee(n)
2 a = 0
3 b = 1
4 while ...
5 c = (a + b) / 2
6 if (c ∧ n + c - 1) > 0 then
7 ...
8 else
9 ...
10 end
11 u = ...
12 end
13 endfunction

17
ECE2 2020-2021

Démonstration.
• Afin de bien comprendre tous les mécanismes en jeu, on se permet d’apporter une réponse très
détaillée à cette question, accompagnée d’un aparté sur la méthode de recherche par dichotomie. Il
faut toutefois garder en tête qu’un tel niveau de détail n’est pas du tout attendu lors des concours.
Fournir la fonction Scilab démontre la bonne compréhension et permet d’obtenir la totalité des
points alloués à cette question.
Commençons par rappeler le cadre de la recherche par dichotomie.

Calcul approché d’un zéro d’une fonction par dichotomie

Données :
× une fonction f : R → R,
× un intervalle de recherche [a, b],
× une précision de recherche ε.
Résultat : une valeur approchée à ε près d’un zéro (sur l’intervalle [a, b]) de la fonction f .
Autrement dit, une valeur approchée (à ε près) d’un réel x ∈ [a, b] tel que : f (x) = 0.

• La dichotomie est une méthode itérative dont le principe, comme son nom l’indique, est de
découper à chaque itération l’intervalle de recherche en deux nouveaux intervalles. L’intervalle de
recherche est découpé en son milieu. On obtient deux nouveaux intervalles :
× un intervalle dans lequel on sait que l’on va trouver un zéro de f .
Cet intervalle est conservé pour l’itération suivante.
× un intervalle dans lequel ne se trouve pas forcément un zéro de f .
Cet intervalle n’est pas conservé dans la suite de l’algorithme.
La largeur de l’intervalle de recherche est ainsi divisée par 2 à chaque itération.
On itère jusqu’à obtenir un intervalle I contenant un zéro de f et de largeur plus faible que ε.
Les points de cet intervalle I sont tous de bonnes approximations du zéro de f contenu dans I.
• C’est le théorème des valeurs intermédiaires qui permet de choisir l’intervalle qu’il faut
garder à chaque étape. Rappelons son énoncé et précisons maintenant l’algorithme :

Théorème des Valeurs Intermédiaires

Soit f : [a, b] → R continue sur l’intervalle [a, b].
Supposons : f (a) f (b) 6 0.
Alors il existe c ∈ [a, b] tel que f (c) = 0.

Calcul des suites (am ), (bm ), (cm )

Cas f (a) 6 0 et f (b) > 0
• Initialement, a0 = a, b0 = b
• À chaque tour de boucle (tant que bm − am > ε) : a0 b0
am + bm
× cm = (point milieu de [am , bm ]) a1 b1
2
× si f (cm ) < 0 alors : × si f (cm ) > 0 alors :
a2 b2
∗ am+1 = cm ∗ am+1 = am a3 b3
∗ bm+1 = bm ∗ bm+1 = cm a4 b4

18
ECE2 2020-2021

• On construit ainsi une suite [am , bm ] m∈N
de segments emboîtés :
× contenant tous un zéro de f ,
× dont la largeur est divisée par deux d’un rang au suivant.
• Il reste enfin à adapter cet algorithme à l’énoncé.
Soit n ∈ N∗ . On cherche une valeur de x telle que : hn (x) = 0.
On se fixe initialement l’intervalle de recherche [0, 1] de sorte que l’équation hn (x) = 0 ne possède
qu’une solution, à savoir la valeur un qu’on cherche à approcher. D’un point de vue informatique,
on crée des variables a et b destinées à contenir les valeurs succesives de am et bm . Ces variables
sont initialisées respectivement à 0 et 1.

2 a = 0
3 b = 1

On procède alors de manière itérative, tant que l’intervalle de recherche n’est pas de largeur plus
faible que la précision 10−3 escomptée.

4 while (b-a) > 10 ∧ (-3)

On commence par définir le point milieu du segment de recherche.

5 c = (a+b) / 2

Puis on teste si hn (c) > 0.

Si c’est le cas, la recherche s’effectue dans le demi-segment de gauche.

6 if (c ∧ n + c - 1) > 0 then
7 b = c

Sinon, elle s’effectue dans le demi-segment de droite.

8 else
9 a = c
10 end

En sortie de boucle, on est assuré que le segment de recherche, mis à jour au fur et à mesure
de l’algorithme, est de largeur plus faible que 10−3 et contient un zéro de hn . Tout point de cet
intervalle est donc une valeur approchée à 10−3 près de ce zéro.
On peut alors choisir de renvoyer le point le plus à gauche du segment.

12 u = a

On peut tout aussi bien choisir le point le plus à droite :

12 u = b

Ou encore le point milieu :

12 u = (a + b) / 2

Ce dernier choix présente un avantage : tout point (dont le zéro recherché) du dernier intervalle
10−3
de recherche se situe à une distance d’au plus de ce point milieu.
2
10−3
On obtient ainsi une valeur approchée à du zéro recherché.
2

19
ECE2 2020-2021

Commentaire
• On peut se demander combien de tours de boucle sont nécessaires pour obtenir le résultat. Pour
le déterminer, il suffit d’avoir en tête les éléments suivants :
× l’intervalle de recherche initial [0, 1] est de largeur 1.
× la largeur de l’intervalle de recherche est divisée par 2 à chaque tour de boucle.
1
À la fin du mème tour de boucle, l’intervalle de recherche est donc de largeur m .
2
× l’algorithme s’arrête lorsque l’intervalle devient de largeur plus faible que 10−3 .
On obtient le nombre d’itérations nécessaires en procédant par équivalence :

1 (par stricte croissance de la

6 10−3 ⇔ 2m > 103
2m fonction inverse sur R∗+ )
(par stricte croissance de la
⇔ ln 2m > ln 103



fonction ln sur R∗+ )

⇔ m ln(2) > 3 ln(10)

ln(10)
⇔ m>3 (car ln(2) > 0)
ln(2)
 
ln(10)
Ainsi : 3 tours de boucle suffisent.
ln(2)
On retiendra que si l’on souhaite obtenir une précision de 3 chiffres après la virgule, il suffit
d’effectuer de l’ordre de 3 tours de boucle. Cet algorithme est donc extrêmement rapide.

• On obtient le programme complet suivant.

1 function u = valeur_approchee(n)
2 a = 0
3 b = 1
4 while (b-a) > 10 ∧ (-3)
5 c = (a+b) / 2
6 if (c ∧ n + c - 1) > 0 then
7 b = c
8 else
9 a = c
10 end
11 end
12 u = a
13 endfunction

20
ECE2 2020-2021

Commentaire
Dans le programme à trous donné par l’énoncé, l’instruction :

11 u = ...

apparaît en ligne 11, comme dernière instruction de la boucle. Dans ce cas, l’affectation u
= a va être effectuée à chaque tour de boucle. Ainsi, la valeur de la variable u est écrasée à
chaque tour de boucle. Il en résulte que la variable u contient en fin de boucle la dernière
valeur qui lui a été affectée. De ce fait, on peut s’interroger sur la pertinence d’une telle
présentation. Comme seule la dernière affectation u = a permet de définir la valeur de la
variable u, il apparaît bien plus raisonnable d’effectuer cette instruction une seule fois en
sortie de boucle. C’est le choix qui est fait dans ce corrigé.

b) On représente alors les premiers termes de la suite (un )n∈N∗ et on obtient le graphe suivant.
Quelles conjectures peut-on faire sur la suite (un )n∈N∗ concernant sa monotonie, sa convergence
et son éventuelle limite ?

Démonstration.
Le graphe permet d’effectuer les conjectures suivantes :
× la suite (un )n∈N∗ est strictement croissante,
× la suite (un )n∈N∗ est minorée par 12 ,
× la suite (un )n∈N∗ est majorée par 1,
× la suite (un )n∈N∗ est convergente de limite 1.

Commentaire
On lit sur ce graphe les valeurs :

u1 = 0.5 et u2 ' 0.61

Cela permet de vérifier les résultats donnés en question 8 . √

−1 + 5
En particulier, 0.61 est bien une valeur approchée de la quantité u2 = .
2

21
ECE2 2020-2021

ECRICOME − 2019
• Pour tout entier n non nul, on note hn la fonction définie sur R∗+ par :
1
∀x > 0, hn (x) = xn + 1 +
xn
• On devait démontrer les propriétés suivantes :
× pour tout entier naturel n non nul, la fonction hn est strictement décroissante sur ]0, 1[ et stric-
tement croissante sur [1, +∞[.
× pour tout entier n non nul, l’équation hn (x) = 4 admet exactement deux solutions, notées un et
vn et vérifiant : 0 < un < 1 < vn .
a) Écrire une fonction Scilab d’en-tête function y = h(n,x) qui renvoie la valeur de hn (x) lorsqu’on
lui fournit un entier naturel n non nul et un réel x ∈ R∗+ en entrée.

Démonstration.

1 function y = h(n, x)
2 y = x ∧ n + 1 + (1 / x ∧ n )
3 endfunction

Commentaire
Il n’y a aucune difficulté à coder en Scilab une fonction dont l’expression est donnée
dans l’énoncé. Il est donc impensable de ne pas traiter cette question.

b) Compléter la fonction suivante pour qu’elle renvoie une valeur approchée à 10−5 près de vn par la
méthode de dichotomie lorsqu’on lui fournit un entier n > 1 en entrée :
1 function res=v(n)
2 a = 1
3 b = 3
4 while (b-a) > 10 ∧ (-5)
5 c = (a+b)/2
6 if h(n,c) < 4 then
7 ........
8 else
9 ........
10 end
11 end
12 ..........
13 endfunction

Démonstration.
Commençons par rappeler le cadre de la recherche par dichotomie.
Calcul approché d’un zéro d’une fonction par dichotomie
Données :
× une fonction f : R → R,
× un intervalle de recherche [a, b],
× une précision de recherche ε.
Résultat : une valeur approchée à ε près d’un zéro (sur l’intervalle [a, b]) de la fonction f .
Autrement dit, une valeur approchée (à ε près) d’un réel x ∈ [a, b] tel que : f (x) = 0.

22
ECE2 2020-2021

• La dichotomie est une méthode itérative dont le principe, comme son nom l’indique, est de
découper à chaque itération l’intervalle de recherche en deux nouveaux intervalles. L’intervalle
de recherche est découpé en son milieu. On obtient deux nouveaux intervalles :
× un intervalle dans lequel on sait que l’on va trouver un zéro de f .
Cet intervalle est conservé pour l’itération suivante.
× un intervalle dans lequel ne se trouve pas forcément un zéro de f .
Cet intervalle n’est pas conservé dans la suite de l’algorithme.
La largeur de l’intervalle de recherche est ainsi divisée par 2 à chaque itération.
On itère jusqu’à obtenir un intervalle I contenant un zéro de f et de largeur plus faible que ε.
Les points de cet intervalle I sont tous de bonnes approximations du zéro contenu dans I.
• C’est le théorème des valeurs intermédiaires qui permet de choisir l’intervalle qu’il faut
garder à chaque étape. Rappelons son énoncé et précisons maintenant l’algorithme :

Théorème des Valeurs Intermédiaires

Soit f : [a, b] → R continue sur l’intervalle [a, b].
Supposons : f (a) f (b) 6 0.
Alors il existe c ∈ [a, b] tel que f (c) = 0.

Calcul des suites (am ), (bm ), (cm )

Cas f (a) 6 0 et f (b) > 0
• Initialement, a0 = a, b0 = b
• À chaque tour de boucle (tant que bm − am > ε) : a0 b0
am + bm
× cm = (point milieu de [am , bm ]) a1 b1
2
× si f (cm ) < 0 alors : × si f (cm ) > 0 alors :
a2 b2
∗ am+1 = cm ∗ am+1 = am a3 b3
∗ bm+1 = bm ∗ bm+1 = cm a4 b4

• On construit ainsi une suite [am , bm ] m∈N de segments emboîtés :
× contenant tous un zéro de f ,
× dont la largeur est divisée par deux d’un rang au suivant.
• Il reste enfin à adapter cet algorithme à l’énoncé.
Soit n ∈ N∗ . On cherche une valeur de x telle que : hn (x) = 4 ce qui s’écrit :

hn (x) − 4 = 0 ou encore fn (x) = 0 où fn : x 7→ hn (x) − 4

On se fixe initialement l’intervalle de recherche [1, 3] de sorte que l’équation fn (x) = 0 ne possède
qu’une solution, à savoir la valeur vn qu’on cherche à approcher. D’un point de vue informatique,
on crée des variables a et b destinées à contenir les valeurs succesives de am et bm . Ces variables
sont initialisées respectivement à 1 et 3.

2 a = 1
3 b = 3

On procède alors de manière itérative, tant que l’intervalle de recherche n’est pas de largeur plus
faible que la précision 10−5 escomptée.

23
ECE2 2020-2021

4 while (b-a) > 10 ∧ (-5)

On commence par définir le point milieu du segment de recherche.

5 c = (a+b) / 2

Puis on teste si fn (c) < 0, c’est-à-dire si hn (c) < 4.

Si c’est le cas, la recherche s’effectue dans le demi-segment de droite.

6 if h(n,c) < 4 then

7 a = c

Sinon, elle s’effectue dans le demi-segment de gauche.

8 else
9 b = c
10 end

En sortie de boucle, on est assuré que le segment de recherche, mis à jour au fur et à mesure
de l’algorithme, est de largeur plus faible que 10−5 et contient un zéro de fn . Tout point de cet
intervalle est donc une valeur approchée à 10−5 près de ce zéro.
On peut alors choisir de renvoyer le point le plus à gauche du segment.

12 res = a

On peut tout aussi bien choisir le point le plus à droite :

12 res = b

Ou encore le point milieu :

12 res = (a + b) / 2

Ce dernier choix présente un avantage : tout point (dont le zéro recherché) du dernier intervalle
10−5
de recherche se situe à une distance d’au plus de ce point milieu.
2
10 −5
On obtient ainsi une valeur approchée à du zéro recherché.
2

24
ECE2 2020-2021

Commentaire
• On peut se demander combien de tours de boucle sont nécessaires pour obtenir le résultat. Pour
le déterminer, il suffit d’avoir en tête les éléments suivants :
× l’intervalle de recherche initial [1, 3] est de largeur 2.
× la largeur de l’intervalle de recherche est divisée par 2 à chaque tour de boucle.
2
À la fin du mème tour de boucle, l’intervalle de recherche est donc de largeur m .
2
× l’algorithme s’arrête lorsque l’intervalle devient de largeur plus faible que 10−5 .
On obtient le nombre d’itérations nécessaires en procédant par équivalence :

2 2m (par stricte croissance de la

6 10−5 ⇔ > 105
2m 2 fonction inverse sur R∗+ )
⇔ 2m > 2 × 105 (car 4 > 0)
(par stricte croissance de la
⇔ m ln(2) > ln(2) + 5 ln(10)
fonction ln sur R∗+ )
 
ln(10)
Ainsi : 5 + 1 tours de boucle suffisent.
ln(2)
On retiendra que si l’on souhaite obtenir une précision de 5 chiffres après la virgule, il suffit
d’effectuer de l’ordre de 5 tours de boucle. Cette algorithme est donc extrêmement rapide.
• Afin de permettre une bonne compréhension des mécanismes en jeu, on a détaillé avec beaucoup
de précision la réponse à cette question. Cependant, compléter correctement le programme Sci-
lab (on place ci-dessous le programme obtenu) démontre la bonne compréhension de l’algorithme
demandé et permet d’obtenir tous les points alloués à cette question.

• On obtient le programme complet suivant.

1 function res = v(n)
2 a = 1
3 b = 3
4 while (b-a) > 10 ∧ (-5)
5 c = (a+b) / 2
6 if h(n,c) < 4 then
7 a = c
8 else
9 b = c
10 end
11 end
12 res = a
13 endfunction

c) À la suite de la fonction v, on écrit le code suivant :

1 X = 1:20
2 Y = zeros(1,20)
3 for k = 1:20
4 Y(k) = v(k) ∧ k
5 end
6 plot2d(X, Y, style=-2, rect=[1,1,20,3])

25
ECE2 2020-2021

À l’exécution du programme, on obtient la sortie graphique suivante :

Expliquer ce qui est affiché sur le graphique ci-dessus.

Que peut-on conjecturer ?

Démonstration.
• Le programme commence par définir deux tableaux (matrices lignes) X et Y.

1 X = 1:20
2 Y = zeros(1,20)

Le tableau X contient initialement [1, 2, . . . , 20], c’est-à-dire les 20 premiers entiers non nuls.
Le tableau Y est destiné à contenir les 20 premières valeurs de la suite (vn n ).
Il est initialement rempli de 0.
• À l’aide d’une boucle, la k ème case Y est modifiée de sorte à contenir une valeur approchée de vkk .

3 for k = 1:20
4 Y(k) = v(k) ∧ k
5 end

• On effectue alors le tracé des points d’abscisse une valeur de X et d’ordonnée la valeur correspon-
dante de Y. On obtient ainsi le tracé des points de coordonnées (k, vkk ) pour k variant de 1 à 20.

6 plot2d(X, Y, style=-2, rect=[1,1,20,3])

Le nuage de points obtenu correspond au tracé des 20 premières valeurs de la suite (vn n ).
Au vu de la représentation graphique obtenue, on peut faire la conjecture que la suite (vn n )
est constante et approximativement de valeur 2.61.

26