Objectifs

• Utiliser les structures de contrôle : boucle bornée for, boucle non bornée while, test if.
• Créer et parcourir des listes en Python.
• Écrire des algorithmes de dénombrement (factorielle, combinaisons, énumération).
• Calculer les termes d'une suite et déterminer un seuil.
• Approcher une intégrale par la méthode des rectangles.

1. Rappels : boucles, tests et listes

Une liste est une suite ordonnée de valeurs : L = [3, 7, 2]. On accède au premier élément par L[0], on ajoute un élément avec L.append(x), on obtient la longueur avec len(L). On peut aussi créer une liste « en compréhension » :

carres = [k**2 for k in range(1, 6)]   # [1, 4, 9, 16, 25]
pairs = [k for k in range(10) if k % 2 == 0]   # [0, 2, 4, 6, 8]

flowchart LR
A[Initialiser] --> B{Condition vraie}
B -- oui --> C[Executer le bloc]
C --> D[Mettre a jour]
D --> B
B -- non --> E[Afficher le resultat]

2. Algorithmes de dénombrement

Factorielle

Le nombre de façons de ranger \(n\) objets est \(n! = 1\times 2\times\cdots\times n\). L'idée de l'algorithme : partir de 1 et multiplier successivement par 2, 3, …, \(n\), comme on empile des briques une à une.

def factorielle(n):
    p = 1
    for k in range(1, n + 1):
        p = p * k
    return p

Trace de factorielle(5) : déroule les étapes.

Combinaisons

Le nombre de parties à \(k\) éléments d'un ensemble à \(n\) éléments est \(\binom{n}{k} = \dfrac{n!}{k!\,(n-k)!}\).

def combinaison(n, k):
    return factorielle(n) // (factorielle(k) * factorielle(n - k))

Énumérer pour compter

Deux boucles imbriquées listent tous les duos \((i, j)\) avec \(i < j\) :

duos = []
for i in range(1, 6):
    for j in range(i + 1, 6):
        duos.append((i, j))
print(len(duos))

Que va afficher ce programme ? Cherche d'abord.

3. Algorithmes sur les suites

Calculer un terme et la liste des termes

Soit la suite définie par \(u_0 = 2\) et \(u_{n+1} = 0{,}5\,u_n + 3\).

def termes(n):
    u = 2
    L = [u]
    for k in range(n):
        u = 0.5 * u + 3
        L.append(u)
    return L

termes(4) renvoie [2, 4.0, 5.0, 5.5, 5.75] : \(u_1 = 0{,}5\times2+3 = 4\), \(u_2 = 5\), \(u_3 = 5{,}5\), \(u_4 = 5{,}75\). La suite semble converger vers \(6\) (en effet \(u_n = 6 - 4\times 0{,}5^n\)).

Manipule : la courbe de \(x\mapsto 6 - 4q^{x}\) passe par les points \((n ; u_n)\) quand \(q = 0{,}5\). Fais varier \(q\) entre 0 et 1 : la limite reste 6, mais l'approche est plus ou moins rapide.

Algorithme de seuil

def seuil(s):
    n = 0
    u = 2
    while u <= s:
        u = 0.5 * u + 3
        n = n + 1
    return n

Que renvoie seuil(5.9) ? Cherche d'abord.

Exemple résolu : l'épargne d'Awa

Écrire l'algorithme et trouver le nombre d'années.

c = 100000
n = 0
while c <= 150000:
    c = c * 1.05
    n = n + 1
print(n)

4. Approcher une intégrale : méthode des rectangles

On partage \([a;b]\) en \(n\) intervalles de largeur \(h = \dfrac{b-a}{n}\). Avec les rectangles « à gauche », la hauteur de chaque rectangle est la valeur de \(f\) au bord gauche :

def rectangles(f, a, b, n):
    h = (b - a) / n
    s = 0
    for k in range(n):
        s = s + f(a + k * h)
    return h * s

def carre(x):
    return x**2

print(rectangles(carre, 0, 1, 4))

Exemple résolu

Calculer à la main rectangles(carre, 0, 1, 4), puis comparer à \(\int_0^1 x^2\,dx\).

Récapitulatif

• for quand le nombre de tours est connu, while quand on attend qu'une condition change.
• Dénombrement : un produit accumulé pour \(n!\), des boucles imbriquées pour énumérer et vérifier une formule.
• Suites : une variable mise à jour dans une boucle ; un seuil se trouve avec while.
• Intégrale : \(S_n = h\sum_{k=0}^{n-1} f(a+kh)\) avec \(h = \frac{b-a}{n}\) ; plus \(n\) est grand, meilleure est l'approximation.