Passer au contenu principal

Exercice 3

Exercice 3

Un exercice de base, assez simple, sur une suite de référence...

Un objet valant $1,000$ euros décote de 5% par an.
Soit $u_n$ la valeur de l'objet (en euros) au bout de $n$ années. Ainsi, $u_0=1,000$.
1.a. Exprimer $u_{n+1}$ en fonction de $u_n$ pour tout naturel $n$.
1.b. Qu'en déduire concernant la suite $(u_n)$?
1.c. Exprimer $u_{n}$ en fonction de $n$ .
1.d. Donner le sens de variation de $(u_n)$ ainsi que sa limite.
2.a. Ecrire l'algorithme d'un programme permettant de déterminer la plus petite valeur $n_0$ telle que $u_{n_0}<500$.
2.b. Programmer un tel programme sur votre calculatrice (langage au choix) et donner la valeur de $n_0$ proposée.

2. Programmation en Python pour trouver ( n_0 ) tel que ( u_{n_0} < 500 )**

2.a. Écrire un programme en Python qui calcule la valeur de l'objet année après année et s'arrête dès que cette valeur devient inférieure à 500. Le programme doit afficher le nombre d'années ( n_0 ) correspondant.**

2.b. Tester ce programme et donner la valeur de ( n_0 ) trouvée.**

Exemple de programme Python :

valeur = 1000  # Valeur initiale
n = 0          # Nombre d'années

while valeur >= 500:
    valeur = valeur * 0.95  # On applique la décote de 5%
    n = n + 1               # On compte une année de plus

print("Le nombre d'années nécessaires est :", n)

Résultat obtenu :
Le programme affichera le plus petit nombre d'années ( n_0 ) pour lequel la valeur de l'objet passe en dessous de 500 €.

(Pour vérification, la réponse correcte est ( n_0 = 14 ).)

Explication simple :
Le programme part de 1000 € et multiplie la valeur par 0,95 chaque année (ce qui correspond à une baisse de 5%). Il compte combien d'années il faut pour que la valeur devienne inférieure à 500 €.

  • Inline: $e^{i\pi} + 1 = 0$
  • Display: $$ \frac{d}{dx}\left( \int_{0}^{x} f(u),du\right)=f(x) $$
  • Parenthèses: ( \sqrt{2} ) et [ \sum_{i=1}^n i ]
Corrigé

1.a. Pour tout naturel $n$: $u_{n+1}=u_n-\frac{5}{100}×u_n=(1-\frac{5}{100})×u_n=0,95×u_n$.
Soit: $u_{n+1}=0,95×u_n$

1.b. Par conséquent, la suite $(u_n)$ est géométrique de raison $r=0,95$ de premier terme $u_0=1,000$.

1.c. Et par là, pour tout naturel $n$: $u_n=1,000× 0,95^n$.

1.d. Comme $0<0,95<1$, alors $(0,95^n)$ est strictement décroissante.
Et comme $1,000>0$, $(u_n)$ est également strictement décroissante.
Par ailleurs:
Comme $0≤0,95<1$, on a: $\lim\limits_{n→+∞}(r^n)=0$.
Et par là: $\lim\limits_{n→+∞}(u_n)$$=1,000×0$ $=0$.

2.a. Nous proposons deux algorithmes possibles.
A la fin de chacun d'eux, la variable N contient la valeur $n_0$ cherchée.

Le premier utilise
la formule de récurrence.

N ← 0
U ← $1,000$
Tant que U$≥500$
   U ← U$× 0,95$
   N ← N+1
Fin du Tant que

Le second utilise
la formule explicite.

N ← 0
Tant que $1,000× 0,95^N≥500$
   N ← N+1
Fin du Tant que

2.b. Exemples de programmes utilisant la formule explicite.
La dernière ligne de ces programmes (qui n'apparaît pas dans les algorithmes précédents) permet d'afficher la valeur finale de N.

programmes en BASIC

Pour une Casio:
$0→N$
While $1,000× 0,95^N≥500$
$N+1→N$
WhileEnd
N

Pour une TI:
$0→N$
While $1,000× 0,95^N≥500$
$N+1→N$
End
Disp N

programme en PYTHON

  # Exercice 3 - Programme de calcul de décote

def trouver_n0():
    """Détermine le nombre d'années nécessaires pour que la valeur passe sous 500€"""
    n = 0
    valeur = 1000  # u0 = 1000€
    
    while valeur >= 500:
        valeur *= 0.95  # Décote de 5%
        n += 1
        
    return n

def calculer_somme_decote(annees):
    """Calcule la somme totale dépensée sur une période donnée"""
    somme = 0
    for n in range(annees + 1):  # De 0 à annees inclus
        somme += 1000 * (0.95 ** n)
    return somme

# 1. Calcul de n0 (valeur < 500€)
n0 = trouver_n0()
print(f"La valeur passe sous 500€ après {n0} ans")

# 2. Calcul sur 14 ans (2013-2000+1)
somme_totale = calculer_somme_decote(14)
print(f"Somme totale dépensée sur 14 ans: {somme_totale:.2f}€")

# Version alternative avec formule mathématique
def somme_geometrique(u0, raison, n):
    """Calcule la somme des termes d'une suite géométrique"""
    return u0 * (1 - raison**(n+1)) / (1 - raison)

# Vérification
verif_somme = somme_geometrique(1000, 0.95, 14)
print(f"Vérification par formule: {verif_somme:.2f}€")

Les trois programmes donnent une valeur de $N$ égale à 14.

Retour en haut