Ce sujet de contrôle de mathématiques pour la Première spécialité est entièrement dédié aux généralités sur les suites numériques, avec une particularité : tous les exercices sont orientés vers la programmation en Python. C'est un excellent entraînement pour les élèves qui souhaitent lier leurs compétences en mathématiques et en algorithmique, une double compétence de plus en plus valorisée. Ce corrigé détaillé vous guidera pas à pas dans la résolution de chaque exercice, de la simple exécution de calculs à la création et la correction de fonctions Python. Mots clés : Contrôle corrigé, Sujet de maths, suites numériques, Python, algorithme, Première spécialité.
Exercice 1 : Analyse et correction d'un algorithme Python
Cet exercice s'intéresse à une suite \((u_n)\) définie sur \(\mathbb{N}\) par son premier terme \(u_0 = 8\) et la relation de récurrence : \(u_{n+1} = \frac{1}{5} u_n + \frac{1}{3^n}\).
- Calcul des premiers termes : La première question est un calcul direct pour s'approprier la définition de la suite.
- Pour calculer \(u_1\), on utilise la formule avec \(n=0\) : \(u_1 = \frac{1}{5} u_0 + \frac{1}{3^0} = \frac{1}{5} \times 8 + 1 = \frac{8}{5} + 1 = \frac{13}{5}\).
- Pour calculer \(u_2\), on utilise la formule avec \(n=1\) et la valeur de \(u_1\) précédemment trouvée : \(u_2 = \frac{1}{5} u_1 + \frac{1}{3^1} = \frac{1}{5} \times \frac{13}{5} + \frac{1}{3} = \frac{13}{25} + \frac{1}{3} = \frac{39+25}{75} = \frac{64}{75}\).
- Analyse d'un script Python : La deuxième question présente une fonction Python et demande de l'analyser. C'est un exercice classique de lecture et de compréhension de code. La fonction proposée est :
def terme(n):
u=8
for i in range(1,n):
u=1/5*u+1/(3**i)
return(u)
La question est double :- Que renvoie `terme(2)` ? En suivant l'exécution du code, on voit que la boucle `for` ne s'exécute qu'une seule fois pour \(i=1\). Le calcul effectué est \(u = \frac{1}{5} \times 8 + \frac{1}{3^1} = \frac{8}{5} + \frac{1}{3} = \frac{29}{15}\). C'est la valeur retournée.
- Pourquoi la fonction est-elle incorrecte ? On compare le résultat de la fonction avec les valeurs de la suite. `terme(1)` renvoie 8 (car la boucle n'est pas exécutée), ce qui est \(u_0\) et non \(u_1\). `terme(2)` renvoie \(\frac{29}{15}\), qui n'est ni \(u_1\) ni \(u_2\). L'erreur vient de deux points : l'indice dans la boucle `range` et la puissance de 3. La boucle devrait s'exécuter \(n\) fois pour calculer \(u_n\) à partir de \(u_0\), et l'exposant de 3 devrait correspondre à l'étape de la récurrence.
- Proposition d'une correction : Pour que la fonction calcule correctement \(u_n\), il faut modifier la boucle pour qu'elle parcoure les indices de \(0\) à \(n-1\). Une version corrigée serait :
def terme_corrige(n):
u = 8 # u_0
for i in range(n): # Boucle n fois, pour i de 0 à n-1
u = 1/5*u + 1/(3**i) # Calcule le terme suivant
return u
Exercice 2 : Calcul d'une somme de termes avec une boucle `while`
L'exercice 2 porte sur une autre suite, définie cette fois par \(u_1 = 1\) et, pour tout \(n \in \mathbb{N}^*\), \(u_{n+1} = 2u_n - n + 1\). Il faut compléter une fonction Python qui calcule la somme des \(n\) premiers termes \(S_n = \sum_{k=1}^{n} u_k\).
Le squelette de la fonction est donné, et l'objectif est de remplir les instructions manquantes dans une boucle `while`.
def somme(n):
U=1
S=1
K=0
while ... :
U = ...
S = ...
K = ...
return(S)
L'analyse de la logique est la suivante :
- Les variables `U`, `S` et `K` représentent respectivement le terme courant de la suite, la somme partielle et un compteur.
- Initialisation : `U=1` (\(u_1\)), `S=1` (\(S_1\)). On doit donc calculer les \(n-1\) termes suivants et les ajouter à la somme.
- La boucle `while` doit s'exécuter \(n-1\) fois. Si `K` est un compteur de boucles, il ira de \(0\) à \(n-2\). La condition est donc `while K < n-1`.
- À chaque itération, il faut :
- Calculer le terme suivant \(u_{k+1}\) à partir de \(u_k\). La formule est \(u_{k+1} = 2u_k - k + 1\). L'indice \(k\) dépend de la manière dont on a défini le compteur `K`. Si `K` va de 0 à n-2, l'indice \(k\) de la suite est \(K+1\). Le nouveau `U` est donc \(2 \times U - (K+1) + 1\).
- Ajouter ce nouveau terme à la somme `S`.
- Incrémenter le compteur `K`.
Une des fonctions complétées possibles est :
def somme(n):
if n == 1:
return 1
U=1
S=1
K=1 # k, l'indice du terme U
while K < n:
U = 2*U - K + 1 # Calcule u_{K+1}
S = S + U
K = K + 1
return(S)
Note : plusieurs logiques de compteur sont possibles pour respecter le code initial, celle-ci est l'une des plus directes.
Exercice 3 : Programmer une suite homographique
Cet exercice, plus direct, demande d'écrire une fonction Python pour la suite \((v_n)\) définie par \(v_0 = 1\) et \(v_{n+1} = \frac{9}{6-v_n}\). C'est une application directe de la traduction d'une formule de récurrence en algorithme itératif.
La démarche est la suivante :
- Initialiser une variable, disons `v`, avec la valeur de \(v_0\).
- Utiliser une boucle `for` qui se répète \(n\) fois.
- À chaque tour de boucle, mettre à jour la variable `v` en appliquant la formule de récurrence.
- Retourner la valeur finale de `v`.
Le code Python correspondant est :
def terme3(n):
v = 1 # v_0
for _ in range(n): # On répète n fois
v = 9 / (6 - v)
return v
Exercice 4 : Gestion de suites couplées en Python
Le dernier exercice introduit deux suites \((u_n)\) et \((v_n)\) qui dépendent l'une de l'autre (suites couplées ou imbriquées). Elles sont définies par \(u_0 = 2\), \(v_0 = 10\) et les relations : \(u_{n+1} = \frac{2u_n + v_n}{3}\) et \(v_{n+1} = \frac{u_n + 3v_n}{4}\).
L'objectif est d'écrire une fonction `terme4(n)` qui renvoie les valeurs de \(u_n\) et \(v_n\). La difficulté ici est de bien gérer la mise à jour des variables. Pour calculer \(v_{n+1}\), on a besoin de la valeur de \(u_n\) (et non de \(u_{n+1}\) qu'on vient de calculer).
Deux approches sont possibles :
- Utiliser une variable temporaire : On stocke la valeur de \(u_n\) avant de la modifier, pour pouvoir l'utiliser dans le calcul de \(v_{n+1}\).
def terme4_temp(n):
u, v = 2, 10
for _ in range(n):
u_temp = u
u = (2*u + v) / 3
v = (u_temp + 3*v) / 4
return u, v
- Utiliser l'affectation multiple de Python : C'est la méthode la plus élégante et "pythonique". Les expressions à droite du `=` sont toutes évaluées avant que les affectations à gauche ne soient effectuées.
def terme4(n):
u, v = 2, 10
for _ in range(n):
u, v = (2*u + v)/3, (u + 3*v)/4
return u, v
Ce contrôle est donc un excellent test sur la capacité à traduire des concepts mathématiques de suites en langage de programmation, une compétence essentielle en première spécialité.