Suites récurrentes

Algorithmique / programmation en python

Suites définies explicitement, à partir d'une fonction

Exercice 1:

Définition d'une suite explicite, à partir d'une fonction - Boucles et détermination d'un seuil

L'instruction def permet de définir une fonction en python. (voir éventuellement, en complément, les fonctions en python)
Qu'affiche le programme suivant ? (en python, * désigne la multiplication: 3*2 vaut 6, et ** désigne la puissance: 3**2 vaut 9)
```
def u(n):
    return 0.2*n**2-2

print(u(2))

n=10
print(u(n))
```
Modifier le programme précédent pour qu'il calcule les termes de la suite définie par l'expression
$u_n=\dfrac{2n^2-1}{n^2+2}$ .
Afficher en particulier les termes $u_{10}$ , $u_{100}$ et $u_{1000}$ .
Qu'observe-t-on pour des valeurs de plus en plus grandes de n ?
Avec une boucle for: ajouter les deux lignes suivantes au programme précédent:
```
for n in range(1,10):
    print(u(n))
```
Voir éventuellement à ce sujet les boucles for et plus spécialement le paragraphe boucles sur des entiers
Détermination d'un seuil: boucle while. Pour quelle valeur de n, les valeurs u_n de la suite de la question 1. dépassent-elles 1000 ?
Déterminer la valeur algébriquement, par le calcul.
Ajouter ensuite dans le programme précédent les quelques lignes suivantes:
```
n=0
while u(n)<1000:
    print(u(n))	     
    n=n+1

print(n)
```
Voir éventuellement à ce sujet les boucles conditonnelles while

Suites définies par récurrence

Une suite est définie par récurrence lorsque chaque terme (sauf le premier) est défini à partir du précédent (ou des précédents).

Exercice 2:

Qu'affiche le programme suivant ?
```
def u(n):
    if n==0:
        return 2
    else: 
        return 3*u(n-1)-2

print(u(0))
print(u(1))
print(u(2))

n=10
print(u(n))
```
La fonction définie et utilisée ici s'appelle une fonction récursive: c'est une fonction qui s'appelle elle-même…

Donner une formule algébrique définissant par récurrence la suite de ce programme.
Modifier le programme précédent pour qu'il calcule les termes de la suite définie par l'expression
$u_n=\dfrac{2u_{n-1}^2-1}{u_{n-1}^2+2}$ .
Afficher en particulier les premiers termes jusqu'à $u_{10}$ , puis jusqu'à $u_{20}$ , et enfin jusqu'à $u_{30}$ ,
Cette méthode de calcul est simple, fonctionne, mais n'est clairement pas efficace. Expliquer pourquoi, quelle est la difficulté ?
Une autre manière de programmer les calculs des termes d'une telle suite est d'utiliser directement la relation de récurrence reliant deux termes consécutifs:
```
u=2
n=10
for i in range(n):
    u=(2*u**2-1)/(u**2+2)
    print(u)
```
Ce programme calcule et affiche tous les premiers termes jusqu'à .
Utiliser ce programme pour afficher en particulier les termes , , et même et pourquoi pas .
Qu'observe-t-on pour des valeurs de plus en plus grandes de n ?

Exercice 3:

Suite de Héron
Soit

la fonction définie sur

par:

. On considère la suite

définie par:

Écrire un programme qui permet de calculer et afficher les 10 premiers termes de cette suite.
Conjecturer le sens de variation et la limite de cette suite.
Démontrer ces résultats en faisant l'exercice complet.

Exercice 4:

On considère la suite numérique

définie pour tout entier naturel

par

On souhaite écrire un algorithme affichant, pour un entier naturel donné, tous les termes de la suite, du rang 0 au rang n .
Parmi les trois algorithmes suivants, un seul convient. Préciser lequel en justifiant la réponse.

Algorithme n^o1

Variables:
v est un réel
i et n sont des entiers naturels

Début de l'algorithme:
Lire n
v prend la valeur 1
Pour i variant de 1 à n faire
v prend la valeur
9
6-v

Fin pour
Afficher v

Fin algorithme

Algorithme n^o2

Variables:
v est un réel
i et n sont des entiers naturels

Début de l'algorithme:
Lire n
Pour i variant de 1 à n faire
v prend la valeur 1
v prend la valeur
9
6-v

Fin pour
Afficher v

Fin algorithme

Algorithme n^o3

Variables:
v est un réel
i et n sont des entiers naturels

Début de l'algorithme:
Lire n
v prend la valeur 1
Pour i variant de 1 à n faire
Afficher v
v prend la valeur
9
6-v

Fin pour
Afficher v

Fin algorithme

Programmer l'algorithme et afficher les premiers termes de la suite. Quelle conjecture peut-on faire ? (variation, convergence, limite)
Démontrer ces résultats en faisant l'exercice complet (exercice posé au Bac S, en 2013 au Liban).

Exercice 5:

Suite récurrente définie par une racine carrée

On considère la suite $$\left( u_n\rp$ définie par

et, pour tout entier naturel

, par la relation de récurrence $u_{n+1} = \sqrt{2u_n}.$

Calculer à l'aide d'un algorithme / programme les premiers termes de cette suite et conjecturer son sens de variation et sa limite.
Calculs à l'aide d'un algorithme et d'une suite intermédiaire logarithmique: Démontrer les résultats précédents en faisant l'exercice complet (exercice posé au Bac S, en 2013 en Amérique du nord).

Somme des termes d'une suite

Exercice 6:

Que calcule le programme suivant:

n=int(input("Entrer n: "))
s=0
for i in range(n+1):
    s=s+i
    print("i= ",i, " - s= ",s)

Modifier le programme précédent pour qu'il calcule, à un nombre n donné (ou demandé à l'utilisateur), les sommes:
- 1+
  1
  2
  +
  1
  3
  +
  1
  4
  + … +
  1
  n
- 1
  1²
  +
  1
  2²
  +
  1
  3²
  + … +
  1
  4²
- 1
  2⁰
  +
  1
  2¹
  +
  1
  2²
  +
  1
  2³
  + … +
  1
  2ⁿ
Quelles conjectures peut-on faire pour ces trois suites ?

Exercice 7:

On considère la suite $$\left(u_n\right)$ définie par

et par la relation de récurrence: pour tout entier naturel

, $$u_{n+1} = f\left(u_n\right)$ , où la fonction

est définie sur l'intervalle $$[0~;~+ \infty[$ par

$f(x) = 5 - \dfrac{4}{x + 2}.$

On définit de plus, pour tout entier naturel

, la somme $$\left(S_n\right)$ par

$S_n = \sum_{k=0}^{n} u_k = u_0 + u_1 + \cdots + u_n.$

Calculer , et . Donner une valeur approchée des résultats à 10^-2 près.

Compléter l'algorithme suivant pour qu'il affiche la somme

pour la valeur de l'entier

demandée à l'utilisateur.

Entrée:	n, un entier naturel
Variables:	u et s sont des variables réelles n et i sont des variables entières
Initialisation:	u prend la valeur 1 s prend la valeur u i prend la valeur 0 Demander la valeur de n
Traitement:	Tant que ... Affecter à i la valeur i+1 Affecter à u la valeur ... Affecter à s la valeur ... Fin Tant que
Sortie:	Afficher s

Faire l'exercice complet (exercice posé au Bac S, en Nouvelle Calédonie en 2014).

Exercice 8:

Une association sportive compte 500 adhérents. On constate que, chaque mois,

5% des adhérents ne renouvellent pas leur adhésion
30 nouveaux adhérents s'inscrivent dans l'association

L'adhésion mensuelle coûte 10 euros.

Écrire un programme qui calcule et affiche le nombre d'adhérents dans l'association mois après mois, pendant 2 ans.
Calculer le montant total des cotisations perçues en 2 ans.
Quel devrait être le montant de l'adhésion mensuelle pour que l'association puisse financer complètement une nouvelle installation qui coûte 20 000 euros ?

Suites récurrentes imbriquées

Exercice 9:

Deux suites imbriquées
On définit les suites $\left( u_n\rp$ et $\left( v_n\rp$ par leur premier terme

et, pour tout entier

, par les relations de récurrence:

$\la\begin{array}{ll} u_{n+1}=\dfrac13u_n+\dfrac23v_n\\[.8em] v_{n+1}=\dfrac15u_n+\dfrac45v_n\enar\right.$

Écrire un programme qui calcule et affiche les 10 premiers termes de ces deux suites.
Pour tout entier , on pose .
Modifier le programme précédent pour qu'il calcule et affiche les 10 premiers termes de cette nouvelle suite.
Quelle conjecture peut-on faire ?
Démontrer cette conjecture.
On pose, pour tout entier , . Modifier le programme précédent pour qu'il calcule et affiche les 10 premiers termes de cette nouvelle suite.
Quelle conjecture peut-on faire ?
Démontrer cette conjecture.
Conjecturer le comportement asymptotique des deux suites $\left( u_n\rp$ et $\left( v_n\rp$ .

Démontrer ces résultats à l'aide des questions précédentes.

Voir éventuellement le sujet complet et corrigé

Exercice 10:

Dynamique de populations Une grande ville de 300 000 habitants et un village de 60 000 sont à proximité. Chaque année, 3% des habitants du village partent s'installer dans la ville tandis que 1% des habitants de la ville vont s'installer dans le village.
On note u_n le nombre d'habitants en ville la n-ième année et v_n le nombre d'habitants du village la n-ième année.
Initialement, on a donc u₀=300 000 et v₀=60 000.

Écrire un programme qui permet de calculer et d'afficher le nombre d'habitants u_n de la ville et du village v_n pendant 10 ans.
Conjecturer la limite de ces deux suites.
Calculer, en modifiant le programme précédent, le nombre d'habitants en 10 ans partis de la campagne pour aller s'installer en ville.
Modifier le programme précédent pour qu'il prenne en compte les données supplémentaires:
- chaque année, en ville, il y a 0,2% de naissances et 0,05% de morts.
- chaque année, dans le village, il y a 0,01% de naissances et 0,15% de morts.
Conjecturer avec ce nouveau modèle le comportement des populations.