Annales – Suites géométriques (facile)

Les suites géométriques

Définition

 

Soit $q$ un réel et $(u_n)_{ninmathbb{N}}$ une suite à valeurs réelles.

On dit que $(u_n)$ est une suite géométrique si, et seulement si :

Pour tout $ninmathbb{N}$ : $u_{n+1}=qtimes u_n$

 

$ u_0 underset{times q}{longrightarrow} u_1 underset{times q}{longrightarrow} u_2 underset{times q}{longrightarrow} \cdots underset{times q}{longrightarrow} u_{n-1}underset{times q}{longrightarrow} u_n underset{times q}{longrightarrow} u_{n+1}$

On dit alors que $q$ est la raison de la suite géométrique $(u_n)$ et $u_0$ son premier terme.

 

Expression de $u_n$ en fonction de $n$

 

Soit $(u_n)$ une suite géométrique de raison $q$.

Si $u_0$ est le premier terme de la suite $(u_n)$, on peut démontrer facilement par récurrence que pour tout $ninmathbb{N}$,

$u_n=u_0times q^n$.

On peut encore écrire cette égalité de la manière suivante :

$u_n=u_ptimes q^{n-p}$ avec $pleqslant n$.

 

Somme de termes consécutifs

 

On souhaite calculer la somme de termes consécutifs d’une suite géométrique $(u_n)$.

 

La somme se calcule de la manière suivante :

$text{Somme}=text{(1er terme)} \times dfrac{1-q^{text{nombre de termes}}}{1-q}$

Comment montrer qu'une suite est géométrique ?

Comment montrer qu’une suite est géométrique ?

 

Afin de montrer qu’une suite $(u_n)$ est géométrique, on commence par calculer les premiers termes en s’assurant qu’ils \ne sont pas nuls puis on calcule les rapports des premiers termes : $dfrac{u_1}{u_0}$ et $dfrac{u_2}{u_1}$. 

 

Considérons par exemple la suite $u_n = 4 \times 3^n$. On a alors $dfrac{u_1}{u_0} = 3$ et $dfrac{u_2}{u_1} = 3$.

Si il apparait que le rapport des premiers termes est une constante $q$: on émet alors une conjecture en supposant que la constante ainsi trouvée est la raison de la suite

Il faut alors montrer en revenant à la définition d’une suite géométrique que $u_{n + 1} = q \times u_n$ pour tout $n \in mathbb{N}$.

 

En revenant à notre exemple, on souhaite montrer que $u_{n + 1} = 3 u_n$.

Or :

$3 u_n = 3 \times ( 4 \times 3^n ) $

$3 u_n= 4 \times 3^{n + 1} $

$3 u_n= u_{n + 1}$.

Donc $(u_n)$ est une suite géométrique de raison $3$ et de premier terme $u_0 = 4 \times 3^0 = 4 \times 1 = 4$.

 

La boucle Pour

La boucle Pour

 

Dans un algorithme, il est possible de vouloir écrire une boucle que l’on souhaite répéter un nombre de fois connu : on utilise alors une boucle Pour. 

 

Exemple :

On souhaite lancer $n$ fois un dé à six faces et afficher à chaque fois la face obtenue.

 

Un algorithme qui traduit cet exemple est le suivant.

 

Variables : $n, f$ (où $n$ est le nombre de répétitions de la boucle, c’est à dire le nombre de lancés et $f$ la face obtenue lors d’un lancé)

Entrée :     Saisir $n$ (on indique le nombre de fois que l’on souhaite lancer le dé)

Traitement : (on écrit la boucle Pour, on utilise un nombre $i$ appelé compteur qui varie de 1 à 6 et qui compte ainsi le nombre de répétitions des opérations comprises entre les instructions Pour et Fin Pour)

                Pour $i$ allant de 1 à $n$

                      nombre_entier(1, 6) $to f$ (il s’agit d’une fonctionnalité préexistante qui permet de donner un nombre entier compris entre 1 et 6 aléatoirement)

                      Afficher $f$

                Fin Pour

Sortie

 

Sans les commentaires, l’algorithme est donc :

 

  • Variables :    $n, f$ 
  • Entrée :        Saisir $n$ 
  • Traitement : Pour $i$ allant de 1 à $n$

                               nombre_entier(1, 6) $to f$ 

                               Afficher $f$

                           Fin Pour

  • Sortie

 

Remarque :

On considère par exemple que l’on souhaite faire $n = 3$ lancés.

Au début $i$ vaut 1. La fonction nombre_entier(1, 6) donne la face obtenue puis on l’affiche.

On recommence ensuite la boucle, $i$ vaut alors 2. A nouveau, la fonction nombre_entier(1, 6) donne la face obtenue puis on l’affiche.

On recommence de même la boucle, $i$ vaut alors 3. On obtient un nombre au hasard que l’on affiche.

Enfin, $i$ valant 3, on quitte la boucle et le programme se termine. 

Si on avait écrit l’instruction “Afficher $f$” en dehors de la boucle, l’algorithme aurait alors stocké 6 fois une face et aurait à la fin de la boucle affiché la dernière face obtenue.