# Notion de liste : maths Terminale

Chapitre 9 du programme de mathématiques de Terminale (thème : Algorithmique et programmation). Ressource gratuite OptiTAB.

- Cours : https://www.optitab.net/ressources-gratuites/maths/terminale/notion-de-liste/
- Fiche de révision : https://www.optitab.net/ressources-gratuites/maths/terminale/notion-de-liste/fiche/
- Exercices corrigés : https://www.optitab.net/ressources-gratuites/maths/terminale/notion-de-liste/exercices/

## Cours

**Objectifs : Consolider la notion de liste vue en Première : générer une liste (en extension, par ajouts successifs, en compréhension), manipuler ses éléments et leurs indices (ajouter, supprimer), la parcourir. L'utiliser en Terminale pour les termes d'une suite et un seuil, la simulation d'une loi binomiale, les échantillons et la loi des grands nombres, et le dénombrement des $k$-uplets et des combinaisons.**

**Prerequis : Notion de liste de Première ; boucles `for` et `while`, instruction `if`, fonctions. Terminale : suites, loi binomiale, loi des grands nombres, dénombrement.**

## I. Rappels : créer et lire une liste

**Définition : Liste**
Une **liste** est une suite finie et **ordonnée** de valeurs, écrite entre crochets : `u = [3, 5, 9, 17, 33]`. La liste vide s'écrit `[]` et `len(L)` donne le **nombre d'éléments** de `L`.

**Définition : Indices**
Le premier élément a l'indice $0$ : une liste de $n$ éléments a pour indices $0$, $1$, …, $n - 1$. L'élément d'indice `i` s'écrit `L[i]` ; `L[-1]` est le dernier élément. L'instruction `L[i] = v` remplace l'élément d'indice `i` par `v`.

![La liste u = 3, 5, 9, 17, 33 en cinq cases, avec les indices 0 à 4 au-dessus et les termes u0 à u4 au-dessous : l'indice est le rang](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n99_co105_1_liste_suite.png)

```python
u = [3, 5, 9, 17, 33]
print(len(u))
print(u[0], u[2], u[-1])
u[4] = 34
print(u)
```

```console
5
3 9 33
[3, 5, 9, 17, 34]
```

**Méthode : Indice et rang d'une suite**
Si la liste `u` contient $u_0$, $u_1$, $u_2$, … dans cet ordre, alors `u[n]` est le terme $u_n$ : **l'indice est le rang**. Le dernier terme calculé est `u[-1]`, de rang `len(u) - 1`.

**Attention : Indice hors de la liste**
Avec $5$ éléments, les indices vont de $0$ à $4$ : `u[5]` provoque l'erreur `IndexError` (« list index out of range » : indice hors de la liste). Le dernier élément est `u[-1]` ou `u[len(u) - 1]`, jamais `u[len(u)]`.

## II. Générer une liste

### 1. Trois façons de générer une liste

- **En extension** : on écrit toutes les valeurs, `[2, 3, 5, 7]`.
- **Par ajouts successifs** : on part d'une liste et une boucle ajoute un élément à chaque tour avec `append`.
- **En compréhension** : `[expression for x in …]`, éventuellement avec un filtre `if`.

```python
u = [1]
for k in range(5):
    u.append(2 * u[-1] + 1)
print(u)
print([n**2 for n in range(6)])
```

```console
[1, 3, 7, 15, 31, 63]
[0, 1, 4, 9, 16, 25]
```

La première liste contient les termes $u_0$ à $u_5$ de la suite définie par $u_0 = 1$ et $u_{n+1} = 2u_n + 1$ : chaque terme est calculé à partir du précédent, `u[-1]`. La seconde est la liste des carrés des entiers de $0$ à $5$.

### 2. Listes en compréhension et ensembles

Une liste en compréhension s'écrit comme un ensemble défini par une propriété :

- l'ensemble $\{n^2 \mid n \in \{0, …, 5\}\}$ s'écrit `[n**2 for n in range(6)]` ;
- l'ensemble $\{x \in E \mid x \text{ pair}\}$ s'écrit `[x for x in E if x%2 == 0]`.

**Propriété : Conditions et opérations sur les ensembles**
Avec deux propriétés $\mathcal{P}_A$ et $\mathcal{P}_B$ qui définissent les parties $A$ et $B$ de $E$ :
- `and` (« et ») donne l'**intersection** $A \cap B$ ;
- `or` (« ou ») donne la **réunion** $A \cup B$ ;
- `not` (« non ») donne le **complémentaire** $\overline{A}$.

**Exemple : Multiples de $2$ et de $3$ entre $1$ et $20$**
$E = \{1, 2, …, 20\}$ ; $A$ est l'ensemble des multiples de $2$ et $B$ celui des multiples de $3$. Le test `x % 2 == 0` est vrai quand le reste de la division de `x` par $2$ est nul.

```python
E = range(1, 21)
A = [x for x in E if x % 2 == 0]
B = [x for x in E if x % 3 == 0]
I = [x for x in E
     if x % 2 == 0 and x % 3 == 0]
U = [x for x in E
     if x % 2 == 0 or x % 3 == 0]
print(len(A), len(B))
print(I)
print(len(U))
```

```console
10 6
[6, 12, 18]
13
```

Les éléments de $A \cap B$ sont les multiples de $6$. On retrouve la formule
$$
\begin{aligned}
\mathrm{card}(A \cup B) &= \mathrm{card}(A) + \mathrm{card}(B) \\
&\quad - \mathrm{card}(A \cap B) \\
&= 10 + 6 - 3 = 13
\end{aligned}
$$

![Diagramme de Venn dans E = {1, …, 20} : A les multiples de 2, B les multiples de 3, et leur intersection {6, 12, 18}](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n99_co105_2_venn_cours.png)

## III. Ajouter et supprimer des éléments

| Instruction | Effet sur la liste `L` |
|---|---|
| `L.append(x)` | ajoute `x` à la fin |
| `L.pop()` | retire le dernier élément et le renvoie |
| `L.pop(i)` | retire l'élément d'indice `i` et le renvoie |
| `L.remove(x)` | supprime la première valeur égale à `x` |
| `x in L` | vaut `True` si `x` est dans `L` |

**Exemple : Deux tirages sans remise**
Une urne contient cinq boules numérotées de $1$ à $5$. La fonction `choice(L)` du module `random` choisit un élément de `L` au hasard ; on le **supprime** de l'urne avec `remove`, puis on l'**ajoute** à la liste des boules tirées. L'instruction `seed(2026)` fixe la graine du générateur pseudo-aléatoire : le programme donne toujours le même affichage, celui imprimé ici.

```python
from random import choice, seed

seed(2026)
urne = [1, 2, 3, 4, 5]
tirage = []
for k in range(2):
    b = choice(urne)
    urne.remove(b)
    tirage.append(b)
print(tirage)
print(urne)
```

```console
[1, 4]
[2, 3, 5]
```

![Évolution des listes urne et t : au départ 1, 2, 3, 4, 5 et  , puis la boule 1 passe de urne à t, puis la boule 4](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n99_co105_3_urne_remove.png)

Une boule tirée n'est plus dans l'urne : le second tirage se fait parmi les $4$ boules restantes. C'est un tirage **sans remise**.

**Attention : Valeur ou indice**
`L.remove(x)` supprime une **valeur**, alors que `L.pop(i)` retire l'élément d'**indice** `i`. `L.remove(x)` provoque une erreur `ValueError` si `x` n'est pas dans `L` : on teste d'abord `if x in L:`.

## IV. Parcourir une liste

**Propriété : Deux parcours**
- **Par les éléments** : `for x in L:` ; `x` prend chaque valeur de `L`.
- **Par les indices** : `for i in range(len(L)):` ; on utilise `L[i]`. Ce parcours est nécessaire quand la position compte : rang d'un terme, comparaison de deux termes voisins.

| Écriture | Renvoie |
|---|---|
| `sum(L)`, `len(L)` | la somme, le nombre d'éléments |
| `max(L)`, `min(L)` | le plus grand, le plus petit élément |
| `L.count(x)` | le nombre d'éléments égaux à `x` |

**Exemple : Somme, moyenne et différences**
On parcourt la liste des termes $u_0$ à $u_5$ de la partie II.

```python
u = [1, 3, 7, 15, 31, 63]
s = 0
for x in u:
    s = s + x
print(s, s / len(u))
d = [u[i+1] - u[i]
     for i in range(len(u) - 1)]
print(d)
```

```console
120 20.0
[2, 4, 8, 16, 32]
```

La liste `d` des différences $u_{n+1} - u_n$ se parcourt par les indices : avec `range(len(u) - 1)`, l'indice `i + 1` reste dans la liste. Tous ses éléments sont positifs : la suite semble croissante.

## V. Listes et suites : termes et seuil

**Méthode : Seuil avec une liste**
On ajoute les termes **tant que** le seuil n'est pas dépassé. À la sortie, le dernier terme `u[-1]` est le premier qui dépasse le seuil, et son rang est `len(u) - 1`. La liste garde tous les termes : on peut les représenter.

**Exemple : $u_0 = 2$, $u_{n+1} = 1{,}5\,u_n$ et le seuil $100$**
On cherche le plus petit rang $n$ tel que $u_n \gt 100$.

```python
u = [2]
while u[-1] <= 100:
    u.append(1.5 * u[-1])
print(len(u) - 1)
print(round(u[-2], 2))
print(round(u[-1], 2))
```

```console
10
76.89
115.33
```

Le rang cherché est $n = 10$ : $u_9 \approx 76{,}89 \le 100$ et $u_{10} \approx 115{,}33 \gt 100$. Par le calcul, la suite étant géométrique :
$$
\begin{aligned}
2 \times 1{,}5^n \gt 100 &\iff 1{,}5^n \gt 50 \\
&\iff n \gt \frac{\ln(50)}{\ln(1{,}5)} \approx 9{,}65
\end{aligned}
$$

![Termes de la suite u_n = 2 × 1,5^n et seuil 100 : u9 ≈ 76,89 est en dessous, u10 ≈ 115,33 (en vert) est le premier au-dessus](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n99_co105_4_seuil_liste.png)

**Remarque : Sommes partielles**
La liste des sommes $S_n = u_0 + u_1 + \dots + u_n$ se construit aussi par ajouts successifs : `S.append(S[-1] + u[n])`. Elle permet de conjecturer la limite d'une somme.

## VI. Listes et probabilités

### 1. Simuler une loi binomiale : effectifs et fréquences

**Exemple : Nombre de « pile » en $6$ lancers d'une pièce**
$X$ suit la loi binomiale $\mathcal{B}(6\,;0{,}5)$. On range $10\,000$ valeurs simulées de $X$ dans la liste `R`, puis on compte les effectifs avec `count` et on calcule les fréquences en compréhension.

```python
from random import random, seed

seed(2026)
R = []
for i in range(10000):
    x = 0
    for k in range(6):
        if random() < 0.5:
            x = x + 1
    R.append(x)
E = [R.count(k) for k in range(7)]
F = [e / 10000 for e in E]
for k in range(7):
    print(k, E[k], F[k])
```

```console
0 130 0.013
1 930 0.093
2 2328 0.2328
3 3124 0.3124
4 2405 0.2405
5 933 0.0933
6 150 0.015
```

`E[k]` est l'effectif de la valeur $k$ et `F[k]` sa fréquence. Par exemple, la fréquence de $X = 3$ est proche de
$$
\begin{aligned}
P(X = 3) &= \dbinom{6}{3} \times 0{,}5^6 \\
&= \frac{20}{64} = 0{,}3125
\end{aligned}
$$

![Diagramme en barres des fréquences de 10 000 valeurs simulées de la loi binomiale B(6 ; 0,5), comparées aux probabilités P(X = k)](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n99_co105_5_histo_binom6.png)

### 2. Échantillons, moyennes et loi des grands nombres

**Exemple : Moyennes de $5$ échantillons de taille $10\,000$**
On lance un dé équilibré : l'espérance du numéro obtenu est $3{,}5$. La liste `M` contient les moyennes de $5$ échantillons de $10\,000$ lancers.

```python
from random import randint, seed

seed(2026)
M = []
for j in range(5):
    s = 0
    for i in range(10000):
        s = s + randint(1, 6)
    M.append(s / 10000)
for m in M:
    print(m)
```

```console
3.4689
3.4871
3.4743
3.4951
3.4917
```

Les moyennes varient d'un échantillon à l'autre, mais restent toutes proches de l'espérance $3{,}5$ : c'est la loi des grands nombres.

## VII. Listes et dénombrement

### 1. Les $k$-uplets : une liste de listes

**Définition : Liste de listes**
Les éléments d'une liste peuvent être des listes. Si `C` est une liste de listes, `C[i]` est une liste et `C[i][j]` est l'élément d'indice `j` de cette liste.

```python
E = ["a", "b", "c"]
C = [[x, y] for x in E for y in E]
print(len(C))
print(C[0], C[1], C[5])
print(C[5][0])
```

```console
9
['a', 'a'] ['a', 'b'] ['b', 'c']
b
```

Les deux `for` sont imbriqués : pour chacune des $3$ valeurs de `x`, `y` prend les $3$ valeurs. On obtient les $3^2 = 9$ couples d'éléments de $E$ ; il y a de même $n^k$ $k$-uplets d'éléments d'un ensemble à $n$ éléments.

![Tableau des 9 couples x, y d'éléments de {a, b, c} : la diagonale x = y en gris, les 3 couples x < y en vert, qui correspondent aux parties à 2 éléments](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n99_co105_6_grille_couples.png)

### 2. Arrangements et combinaisons

| Condition | Ce que l'on obtient | Nombre |
|---|---|---|
| aucune | couples (2-uplets) | $n^2$ |
| `x != y` | couples d'éléments distincts | $n(n-1)$ |
| `x < y` | parties à $2$ éléments | $\dbinom{n}{2}$ |

```python
E = [1, 2, 3, 4]
D = [[x, y] for x in E
     for y in E if x != y]
P = [[x, y] for x in E
     for y in E if x < y]
print(len(D), len(P))
for p in P:
    print(p)
```

```console
12 6
[1, 2]
[1, 3]
[1, 4]
[2, 3]
[2, 4]
[3, 4]
```

On retrouve $4 \times 3 = 12$ couples d'éléments distincts et $\dbinom{4}{2} = 6$ parties à $2$ éléments. La condition `x < y` impose l'ordre croissant : chaque partie $\{x, y\}$ n'est écrite qu'une fois.

**Remarque : Pour aller plus loin**
Le module `itertools` de Python fournit des fonctions qui génèrent directement ces objets (`product`, `permutations`, `combinations`). Elles renvoient des $k$-uplets d'un autre type que les listes : au lycée, les listes en compréhension suffisent.

## VIII. Erreurs fréquentes

**Attention : Les erreurs classiques**
1. Oublier que le premier indice est $0$ : `L[len(L)]` provoque une erreur `IndexError`.
2. Écrire `u = u.append(x)` : `append` ne renvoie rien, la liste est perdue.
3. Se tromper de rang : à partir de `[u0]`, après $n$ ajouts, le dernier terme est $u_n$ et la liste a $n + 1$ éléments.
4. Confondre `remove(x)` (une valeur) et `pop(i)` (un indice).
5. Supprimer des éléments d'une liste pendant qu'on la parcourt : certains sont « sautés ». On construit plutôt une nouvelle liste par filtrage.
6. Confondre `or` et `and` dans un filtre : `or` donne la réunion, `and` l'intersection.

**À retenir : - Indices de $0$ à `len(L) - 1` ; `L[-1]` est le dernier élément ; pour une suite, l'indice est le rang.**
- Générer : en extension, par ajouts successifs (`append`), en compréhension (avec `if`, `and`, `or`, `not`).
- Ajouter : `append` ; supprimer : `pop`, `remove`.
- Seuil : `while u[-1] <= A:` puis rang `len(u) - 1`.
- Simulation : liste des résultats, effectifs avec `count`, fréquences en compréhension.
- Dénombrement : une liste de listes en compréhension, avec deux `for` et un filtre éventuel, donne les couples ($n^2$), les couples distincts ($n(n-1)$), les parties à $2$ éléments ($\binom{n}{2}$).

Fiche de synthèse dans l'onglet Fiches !

## Fiche de révision

**Objectifs : L'essentiel sur les listes en Terminale : générer, manipuler, parcourir, et les utiliser pour les suites, les simulations et le dénombrement.**

## I. Éléments et indices

- `L = [3, 5, 9, 17, 33]` ; `len(L)` vaut $5$.
- Indices de $0$ à `len(L) - 1` ; `L[-1]` est le dernier élément ; `L[len(L)]` provoque une erreur `IndexError`.
- Si `u` contient $u_0$, $u_1$, …, alors `u[n]` est $u_n$ : l'indice est le rang.

![La liste u = 3, 5, 9, 17, 33 avec ses indices 0 à 4 et les termes u0 à u4 correspondants](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n99_fi37_1_liste_suite.png)

## II. Générer une liste

**Méthode : Trois façons**
- En extension : `[2, 3, 5, 7]`.
- Par ajouts successifs : `u = [1]` puis `u.append(2 * u[-1] + 1)` dans une boucle (suite récurrente).
- En compréhension : `[n**2 for n in range(6)]`, avec un filtre `if`.

| Dans le filtre | Ensemble obtenu |
|---|---|
| `and` | intersection $A \cap B$ |
| `or` | réunion $A \cup B$ |
| `not` | complémentaire $\overline{A}$ |

## III. Ajouter et supprimer

- `L.append(x)` ajoute `x` à la fin.
- `L.pop()` retire le dernier élément, `L.pop(i)` celui d'indice `i`.
- `L.remove(x)` supprime la première valeur `x` (tester d'abord `x in L`).

## IV. Parcourir

- Par les éléments : `for x in L:`.
- Par les indices : `for i in range(len(L)):` puis `L[i]`.
- `sum(L)`, `max(L)`, `min(L)`, `L.count(x)`.

## V. En Terminale

**Méthode : Seuil d'une suite**
```python
u = [2]
while u[-1] <= 100:
    u.append(1.5 * u[-1])
print(len(u) - 1)
```

```console
10
```

Le rang du premier terme qui dépasse le seuil est `len(u) - 1`.

- **Simulation** : liste `R` des résultats ; effectif de $k$ : `R.count(k)` ; fréquences en compréhension : `[e / N for e in E]`.
- **Loi des grands nombres** : la liste des moyennes d'échantillons de grande taille reste proche de l'espérance.

**Méthode : Dénombrement**
Une liste de listes en compréhension, avec deux `for` :

```python
E = [1, 2, 3, 4]
P = [[x, y] for x in E
     for y in E if x < y]
print(len(P))
```

```console
6
```

Selon le filtre :
- sans condition : les $n^2$ couples ;
- avec `x != y` : les $n(n-1)$ couples d'éléments distincts ;
- avec `x < y` : les $\dbinom{n}{2}$ parties à $2$ éléments.

![Les 9 couples d'éléments de {a, b, c} ; en vert les 3 couples x < y, c'est-à-dire les parties à 2 éléments](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n99_fi37_2_grille_couples.png)

**Attention : Les pièges**
1. Le premier indice est $0$.
2. `u = u.append(x)` perd la liste : écrire `u.append(x)` seul.
3. À partir de `[u0]`, après $n$ ajouts, le dernier terme est $u_n$.
4. `remove(x)` : une valeur ; `pop(i)` : un indice.
5. `or` donne la réunion, `and` l'intersection.

## Exercices corrigés

### Exercice 1 : Indices et termes d'une suite

La suite $(u_n)$ est définie par $u_0 = 100$ et, pour tout entier naturel $n$, $u_{n+1} = 0{,}5\,u_n + 20$. On exécute le programme suivant.

```python
u = [100]
for k in range(4):
    u.append(0.5 * u[-1] + 20)
```

1. Quelle est la liste `u` à la fin du programme ? Combien a-t-elle d'éléments ?
2. Que valent `u[0]`, `u[2]` et `u[-1]` ? À quels termes de la suite correspondent-ils ?
3. Que provoque l'instruction `print(u[5])` ? Écrire une instruction qui ajoute le terme $u_5$ à la liste.
4. Écrire une instruction qui affiche le rang du dernier terme de `u`, quelle que soit la longueur de la liste.
5. On admet que $u_n = 40 + 60 \times 0{,}5^n$. Construire en compréhension la liste `v` des termes $u_0$ à $u_5$ calculés avec cette formule, et vérifier qu'elle est égale à `u`.

#### Correction détaillée

## Question 1 : Contenu de la liste

**Méthode : La liste part de `[100]` ; chaque tour ajoute le terme suivant, calculé à partir du dernier, `u[-1]`.**

**Etape : Calcul des termes**
$$
\begin{aligned}
u_1 &= 0{,}5 \times 100 + 20 = 70 \\
u_2 &= 0{,}5 \times 70 + 20 = 55 \\
u_3 &= 0{,}5 \times 55 + 20 = 47{,}5 \\
u_4 &= 0{,}5 \times 47{,}5 + 20 = 43{,}75
\end{aligned}
$$
**Vérification : par l'exécution :**

```python
print(u)
print(len(u))
```

```console
[100, 70.0, 55.0, 47.5, 43.75]
5
```

Python écrit `70.0` : le résultat d'un calcul avec un nombre décimal est un nombre décimal.

**Resultat : `u` contient les $5$ termes $u_0$ à $u_4$ : $100$ ; $70$ ; $55$ ; $47{,}5$ ; $43{,}75$. La boucle fait $4$ tours, mais $u_0$ était déjà dans la liste.**

## Question 2 : Lire des éléments

**Méthode : L'indice est le rang : `u[n]` est $u_n$. `u[-1]` est le dernier élément.**

**Etape : Exécution**
```python
print(u[0], u[2], u[-1])
```

```console
100 55.0 43.75
```

![La liste u = 100, 70.0, 55.0, 47.5, 43.75 avec ses indices 0 à 4 et les termes u0 à u4, en vert](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n99_ex836_1_e836_corrige.png)

**Resultat : `u[0]` $= u_0 = 100$, `u[2]` $= u_2 = 55$ et `u[-1]` $= u_4 = 43{,}75$.**

## Question 3 : Indice hors de la liste, ajout de $u_5$

**Etape : L'erreur**
Les indices vont de $0$ à $4$ : `u[5]` n'existe pas, et Python s'arrête sur l'erreur `IndexError` (« list index out of range »).

**Etape : Ajouter $u_5$**
```python
u.append(0.5 * u[-1] + 20)
print(u[5])
```

```console
41.875
```

**Resultat : `print(u[5])` provoque une erreur `IndexError` ; l'instruction `u.append(0.5 * u[-1] + 20)` ajoute $u_5 = 41{,}875$.**

## Question 4 : Rang du dernier terme

**Méthode : Une liste de $N$ éléments a pour indices $0$ à $N - 1$ : le dernier terme a pour rang `len(u) - 1`.**

**Etape : Exécution**
```python
print(len(u) - 1)
```

```console
5
```

**Resultat : `print(len(u) - 1)` affiche le rang du dernier terme ; ici $5$, puisque l'on a ajouté $u_5$.**

## Question 5 : Avec la formule explicite

**Méthode : Pour une formule explicite $u_n = f(n)$, on écrit la liste en compréhension : `[f(n) for n in range(6)]`.**

**Etape : Programme**
```python
v = [40 + 60 * 0.5**n
     for n in range(6)]
print(v[5])
print(v == u)
```

```console
41.875
True
```

**Etape : Pourquoi la formule est juste**
La suite $w_n = u_n - 40$ vérifie $w_{n+1} = 0{,}5\,u_n + 20 - 40 = 0{,}5\,w_n$ : elle est géométrique de raison $0{,}5$ et $w_0 = 60$. Donc $u_n = 40 + 60 \times 0{,}5^n$.

**Resultat : Les deux listes sont égales (`True`) : on obtient les mêmes termes par ajouts successifs et en compréhension.**

#### Réponses

1. $100$ ; $70$ ; $55$ ; $47{,}5$ ; $43{,}75$ : $5$ éléments, $u_0$ à $u_4$.
2. `u[0]` $= u_0 = 100$, `u[2]` $= u_2 = 55$, `u[-1]` $= u_4 = 43{,}75$.
3. Erreur `IndexError` ; `u.append(0.5 * u[-1] + 20)` ajoute $u_5 = 41{,}875$.
4. `print(len(u) - 1)`.
5. Liste en compréhension des `40 + 60 * 0.5**n` ; `v == u` vaut `True`.

### Exercice 2 : Ajouter et supprimer : tirages sans remise

Une urne contient cinq boules numérotées de $1$ à $5$. La fonction `tirer(n)` simule le tirage successif et sans remise de $n$ boules ; `choice(L)` choisit au hasard un élément de la liste `L`.

```python
from random import choice, seed

def tirer(n):
    urne = [1, 2, 3, 4, 5]
    t = []
    for k in range(n):
        b = choice(urne)
        urne.remove(b)
        t.append(b)
    return t
```

1. Expliquer le rôle des instructions `urne.remove(b)` et `t.append(b)`. Que contient `urne` à la fin de l'appel `tirer(2)` si l'on a tiré les boules $1$ puis $4$ ?
2. Combien y a-t-il de tirages possibles de $2$ boules, l'ordre comptant ? Combien de parties à $2$ boules ?
3. Écrire un programme qui simule $10\,000$ tirages de $2$ boules et calcule la fréquence des tirages dont la somme vaut $5$. Comparer avec la probabilité.
4. Que se passe-t-il lors de l'appel `tirer(6)` ?
5. Que devient l'expérience si l'on supprime la ligne `urne.remove(b)` ? Calculer alors la probabilité que la somme vaille $5$.

#### Correction détaillée

## Question 1 : Supprimer et ajouter

**Méthode : `remove` **supprime** une valeur de la liste ; `append` **ajoute** une valeur à la fin d'une liste.**

**Etape : Rôle des deux instructions**
- `urne.remove(b)` retire la boule tirée de l'urne : elle ne peut plus être tirée, c'est un tirage **sans remise**.
- `t.append(b)` ajoute la boule tirée à la liste `t` des résultats, dans l'ordre des tirages.

![Évolution des listes urne et t lors du tirage de la boule 1 puis de la boule 4 : urne finit à 2, 3, 5 et t à 1, 4](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n99_ex837_1_urne_remove.png)

**Resultat : Après le tirage de $1$ puis de $4$ : `t` vaut `[1, 4]` et `urne` vaut `[2, 3, 5]`.**

## Question 2 : Dénombrement

**Méthode : Ordre compté : $5$ choix pour la première boule, puis $4$ pour la seconde. Sans ordre : on compte les parties à $2$ éléments.**

**Etape : Calculs**
- Tirages ordonnés : $5 \times 4 = 20$.
- Parties à $2$ boules : $\dbinom{5}{2} = \dfrac{5 \times 4}{2} = 10$.

**Resultat : $20$ tirages ordonnés et $10$ parties.**

## Question 3 : Simulation

**Méthode : Les tirages ordonnés sont équiprobables. La somme vaut $5$ pour $(1\,;4)$, $(4\,;1)$, $(2\,;3)$ et $(3\,;2)$ : la probabilité est $\dfrac{4}{20} = 0{,}2$.**

**Etape : Programme**
```python
seed(2026)
N = 10000
c = 0
for i in range(N):
    t = tirer(2)
    if t[0] + t[1] == 5:
        c = c + 1
print(c / N)
```

```console
0.1959
```

`seed(2026)` fixe la graine : le programme donne toujours ce résultat ; une autre graine donnerait une fréquence voisine.

**Resultat : La fréquence observée, $0{,}1959$, est proche de la probabilité $0{,}2$.**

## Question 4 : Appel `tirer(6)`

**Etape : Exécution pas à pas**
Après $5$ tirages, l'urne est vide : `urne` vaut `[]`. Au sixième tour, `choice([])` provoque une erreur `IndexError` : on ne peut pas choisir dans une liste vide.

**Resultat : `tirer(6)` provoque une erreur : on ne peut pas tirer $6$ boules sans remise dans une urne qui en contient $5$.**

## Question 5 : Tirage avec remise

**Etape : Nouvelle expérience**
Sans `remove`, la boule reste dans l'urne : c'est un tirage **avec remise**. Il y a $5 \times 5 = 25$ couples équiprobables, et la somme vaut $5$ pour les $4$ mêmes couples.

**Resultat : Avec remise, la probabilité que la somme vaille $5$ est $\dfrac{4}{25} = 0{,}16$.**

#### Réponses

1. `remove` retire la boule de l'urne (sans remise), `append` l'ajoute aux résultats ; `urne` vaut `[2, 3, 5]`.
2. $20$ tirages ordonnés ; $10$ parties.
3. Fréquence $0{,}1959$ ; probabilité $\dfrac{4}{20} = 0{,}2$.
4. Erreur au sixième tirage : l'urne est vide.
5. Tirage avec remise ; probabilité $\dfrac{4}{25} = 0{,}16$.

### Exercice 3 : Sondage, échantillons et inégalité de Bienaymé-Tchebychev

Dans une ville, $52\,\%$ des électeurs votent pour la candidate A. On interroge au hasard $n = 400$ électeurs (tirage assimilé à un tirage avec remise) et on calcule la fréquence $F$ de votes pour A dans l'échantillon. Le programme simule $200$ sondages ; `seed(2026)` fixe la graine.

```python
from random import random, seed

def frequence(n, p):
    c = 0
    for i in range(n):
        if random() < p:
            c = c + 1
    return c / n

seed(2026)
L = [frequence(400, 0.52)
     for j in range(200)]
```

![Nuage des fréquences de 200 sondages simulés de 400 personnes, dispersées autour de p = 0,52](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n99_ex5537_1_sondages_enonce.png)

**Partie A : simulation**

1. Que contient la liste `L` ? Combien a-t-elle d'éléments ?
2. Calculer la moyenne des éléments de `L`.
3. Calculer la proportion des sondages dont la fréquence est dans l'intervalle $[0{,}47\,;0{,}57]$.

**Partie B : inégalité de Bienaymé-Tchebychev**

On note $F_n$ la fréquence de votes pour A dans un échantillon de taille $n$ ; $F_n = \dfrac{X_1 + \dots + X_n}{n}$ où les $X_i$ sont des variables de Bernoulli indépendantes de paramètre $p = 0{,}52$.

4. Calculer $E(F_n)$ et $V(F_n)$.
5. Montrer que, pour $n = 400$, $P\big(|F_n - 0{,}52| \lt 0{,}05\big) \ge 0{,}75$. Comparer avec la partie A.
6. Écrire un programme qui détermine la plus petite taille $n$ pour laquelle l'inégalité garantit $P\big(|F_n - 0{,}52| \ge 0{,}05\big) \le 0{,}05$.

#### Correction détaillée

## Partie A : simulation

## Question 1 : La liste `L`

**Etape : Lecture du programme**
`frequence(400, 0.52)` simule un sondage : $400$ réponses, chacune pour A avec la probabilité $0{,}52$, et renvoie la fréquence des réponses pour A. La liste en compréhension répète $200$ fois ce sondage.

**Etape : Exécution**
```python
print(len(L))
print(L[0], L[1])
```

```console
200
0.4975 0.5325
```

**Resultat : `L` contient les $200$ fréquences de $200$ sondages simulés.**

## Question 2 : Moyenne des fréquences

**Etape : Exécution**
```python
m = sum(L) / len(L)
print(round(m, 4))
```

```console
0.5214
```

**Resultat : La moyenne des $200$ fréquences, environ $0{,}521$, est très proche de $p = 0{,}52$.**

## Question 3 : Proportion dans $[0{,}47\,;0{,}57]$

**Méthode : On filtre les fréquences $x$ de la liste telles que $|x - 0{,}52| \le 0{,}05$, puis on divise leur nombre par $200$.**

**Etape : Programme**
```python
B = [x for x in L
     if abs(x-0.52) <= 0.05]
print(len(B) / len(L))
```

```console
0.925
```

![Fréquences des 200 sondages : en vert celles de la bande 0,47 ; 0,57, en orange les 15 qui en sortent](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n99_ex5537_2_sondages_corrige.png)

**Resultat : $92{,}5\,\%$ des sondages simulés donnent une fréquence dans $[0{,}47\,;0{,}57]$.**

## Partie B : inégalité de Bienaymé-Tchebychev

## Question 4 : Espérance et variance

**Méthode : Linéarité de l'espérance ; la variance d'une somme de variables **indépendantes** est la somme des variances, et $V(aX) = a^2V(X)$.**

**Etape : Calculs**
$E(X_i) = p$ et $V(X_i) = p(1 - p)$, donc
$$
\begin{aligned}
E(F_n) &= \frac{np}{n} = p = 0{,}52 \\
V(F_n) &= \frac{n\,p(1 - p)}{n^2} = \frac{0{,}2496}{n}
\end{aligned}
$$

**Resultat : $E(F_n) = 0{,}52$ et $V(F_n) = \dfrac{0{,}2496}{n}$.**

## Question 5 : Minoration pour $n = 400$

**Méthode : Inégalité de Bienaymé-Tchebychev, pour $\delta \gt 0$ :**
$$P\big(|F_n - E(F_n)| \ge \delta\big) \le \frac{V(F_n)}{\delta^2}$$

**Etape : Application avec $\delta = 0{,}05$**
$$
\begin{aligned}
\frac{V(F_{400})}{0{,}05^2} &= \frac{0{,}2496}{400 \times 0{,}0025} \\
&= 0{,}2496
\end{aligned}
$$

Donc $P\big(|F_{400} - 0{,}52| \ge 0{,}05\big) \le 0{,}2496$. Par passage à l'événement contraire :
$$P\big(|F_{400} - 0{,}52| \lt 0{,}05\big) \ge 0{,}7504$$

**Resultat : La probabilité est au moins $0{,}75$ ; la simulation donne $0{,}925$ : l'inégalité est vraie mais loin d'être précise.**

## Question 6 : Taille d'échantillon

**Méthode : On augmente $n$ **tant que** le majorant $\dfrac{0{,}2496}{n \times 0{,}05^2}$ est strictement supérieur à $0{,}05$.**

**Etape : Programme**
```python
m = 0.2496 / 0.0025
n = 1
while m / n > 0.05:
    n = n + 1
print(n)
```

```console
1997
```

**Etape : Vérification par le calcul**
$$
\begin{aligned}
\frac{0{,}2496}{0{,}0025\,n} \le 0{,}05 &\iff n \ge \frac{0{,}2496}{0{,}05 \times 0{,}0025} \\
&\iff n \ge 1\,996{,}8
\end{aligned}
$$

**Resultat : Il faut interroger au moins $1\,997$ électeurs.**

#### Réponses

1. Les $200$ fréquences de $200$ sondages simulés de taille $400$.
2. Moyenne $\approx 0{,}521$.
3. Proportion $0{,}925$.
4. $E(F_n) = 0{,}52$ et $V(F_n) = \dfrac{0{,}2496}{n}$.
5. Majorant $0{,}2496$, donc probabilité au moins $0{,}7504$ ; la simulation donne $0{,}925$.
6. $n = 1\,997$.
