# Utiliser les variables et les instructions élémentaires : maths Seconde

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

- Cours : https://www.optitab.net/ressources-gratuites/maths/seconde/utiliser-les-variables-et-les-instructions-elementaires/
- Fiche de révision : https://www.optitab.net/ressources-gratuites/maths/seconde/utiliser-les-variables-et-les-instructions-elementaires/fiche/
- Exercices corrigés : https://www.optitab.net/ressources-gratuites/maths/seconde/utiliser-les-variables-et-les-instructions-elementaires/exercices/

## Cours

**Objectifs : - Choisir ou reconnaître le type d’une variable : entier, flottant, chaîne de caractères, booléen.**
- Écrire une affectation, une séquence d’instructions et une formule combinant des variables.
- Programmer une instruction conditionnelle `if` / `elif` / `else`.
- Programmer une boucle bornée `for` et une boucle non bornée `while`.
- Lire, comprendre, compléter ou modifier un programme grâce à un tableau de suivi.

## I. Variables et types

**Définition : Variable**
Une **variable** est une case de la mémoire de l’ordinateur, repérée par un **nom**, qui contient une **valeur**. Le **type** de la variable indique la nature de cette valeur.

| Type | Nature de la valeur | Exemples |
|---|---|---|
| `int` | nombre entier | `7`, `-3`, `0` |
| `float` | nombre flottant (décimal) | `2.5`, `-0.1`, `3.0` |
| `str` | chaîne de caractères | `"bonjour"`, `"12"` |
| `bool` | booléen | `True`, `False` |

**Propriété : Reconnaître et changer un type**
- La fonction `type` donne le type d’une valeur : `type(2.5)` donne `float`.
- Une **comparaison** donne un booléen : `7 > 10` vaut `False`.
- `int`, `float` et `str` convertissent : `int("12")` donne l’entier $12$, `str(5)` donne la chaîne `"5"`.

**Attention : Le point décimal et les guillemets**
- En Python, la virgule décimale s’écrit avec un **point** : `2.5` et non `2,5`.
- `3` est un `int`, `3.0` un `float` : même valeur, types différents. Une division `/` donne toujours un `float` : `8 / 2` donne `4.0`.
- `"12"` (entre guillemets) est un texte, pas un nombre : `"12" + 1` provoque une erreur.

**Remarque : Noms de variables**
Un nom commence par une lettre (ou `_`), ne contient ni espace ni accent, et n’est pas un mot réservé de Python (`for`, `if`, `while`…). On choisit des noms parlants : `prix`, `moyenne`, `compteur`.

## II. Affectation et séquence d’instructions

**Définition : Affectation**
L’instruction `a = 5` **affecte** la valeur $5$ à la variable `a` : la valeur est rangée dans la case `a`, et l’ancienne valeur est **perdue**. Python calcule d’abord le membre de droite, puis range le résultat dans la variable de gauche.
**Une : **séquence d’instructions** s’exécute ligne par ligne, de haut en bas. La figure montre la mémoire après chacune des trois instructions `a = 5`, `b = 2 * a`, `a = a + 3` (en vert : la case qui vient de changer).**

![État de la mémoire après les instructions a = 5, puis b = 2 * a, puis a = a + 3 : a vaut 5, puis b vaut 10, puis a vaut 8 et b garde la valeur 10](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n177_co221_1_affectation.png)

**Attention : Le signe = n’est pas une égalité**
`a = a + 3` signifie « la nouvelle valeur de `a` est l’ancienne valeur plus $3$ ». Pour **tester** une égalité, on écrit `==`. Après `b = 2 * a`, modifier `a` ne change plus `b`.

**Exemple : Échanger deux variables**
On passe par une variable auxiliaire `c`, sinon l’une des deux valeurs est perdue.

```python
a = 3
b = 8
c = a
a = b
b = c
print(a, b)
```

```console
8 3
```

Le **tableau de suivi** donne la valeur de chaque variable après chaque instruction (– : pas encore de valeur).

| Instruction | `a` | `b` | `c` |
|---|---|---|---|
| `a = 3` | $3$ | – | – |
| `b = 8` | $3$ | $8$ | – |
| `c = a` | $3$ | $8$ | $3$ |
| `a = b` | $8$ | $8$ | $3$ |
| `b = c` | $8$ | $3$ | $3$ |

## III. Écrire une formule combinant des variables

| Opération | Python | Exemple | Résultat |
|---|---|---|---|
| somme, différence | `+`, `-` | `7 - 2` | `5` |
| produit | `*` | `7 * 2` | `14` |
| quotient | `/` | `7 / 2` | `3.5` |
| quotient entier | `//` | `7 // 2` | `3` |
| reste | `%` | `7 % 2` | `1` |
| puissance | `**` | `2 ** 3` | `8` |

**Propriété : Priorités**
Python respecte les priorités des mathématiques : d’abord les parenthèses, puis les puissances `**`, puis `*`, `/`, `//`, `%`, enfin `+` et `-`.

**Exemple : Traduire une formule**
L’aire d’un disque $A = \pi r^2$ et la moyenne $E = \dfrac{a + b}{2}$ s’écrivent :

```python
from math import pi, sqrt
r = 5
A = pi * r ** 2
a = 7
b = 13
E = (a + b) / 2
print(A, E, sqrt(16))
```

```console
78.53981633974483 10.0 4.0
```

La ligne `from math import pi, sqrt` donne accès à $\pi$ et à la racine carrée `sqrt`.

**Attention : Les parenthèses indispensables**
`a + b / 2` calcule $a + \dfrac{b}{2}$, soit $7 + 6{,}5 = 13{,}5$ : pour la moyenne, il faut écrire `(a + b) / 2`. De même, $2x$ s’écrit `2 * x` : le signe `*` ne s’omet jamais.

**Conseil : Parité et divisibilité**
`n % 2 == 0` est vrai lorsque $n$ est pair ; plus généralement, `n % d == 0` est vrai lorsque $d$ divise $n$.

## IV. Instruction conditionnelle

**Définition : Syntaxe**
```python
if condition:
    instructions_1
else:
    instructions_2
```

Si la condition est vraie, Python exécute le bloc `instructions_1`, sinon le bloc `instructions_2`. Le bloc `else` est facultatif ; `elif` (« sinon si ») ajoute d’autres cas, testés dans l’ordre.

![Organigramme d’une instruction conditionnelle : si age >= 18 est vrai, on affiche « majeur », sinon on affiche « mineur », puis le programme continue](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n177_co221_2_organigramme_si.png)

| Comparaison | Sens | Exemple vrai |
|---|---|---|
| `==` | égal à | `3 == 3` |
| `!=` | différent de | `3 != 4` |
| `<`, `<=` | $\lt$, $\leqslant$ | `2 <= 2` |
| `>`, `>=` | $\gt$, $\geqslant$ | `5 > 1` |

On combine des conditions avec `and` (et), `or` (ou), `not` (non) : `x >= 0 and x <= 10` est vrai lorsque $x \in [0\,;10]$.

**Exemple : Un tarif en trois cas**
```python
age = 15
if age < 12:
    prix = 5
elif age < 18:
    prix = 8
else:
    prix = 11
print(prix)
```

```console
8
```

Le test `age < 12` est faux ; le test `age < 18` est vrai : Python exécute `prix = 8` et ignore la suite (le `else`).

**Attention : Deux-points et indentation**
La ligne `if …`, `elif …` ou `else` se termine par **deux-points**, et le bloc qui suit est **indenté** (décalé de quatre espaces) : c’est l’indentation qui délimite le bloc. Dans une condition, on compare avec `==`, jamais avec `=`.

## V. Boucle bornée : for

**Définition : Syntaxe**
```python
for i in range(n):
    instructions
```

Le bloc indenté est répété $n$ fois ; la variable `i` prend successivement les valeurs $0, 1, \ldots, n - 1$. On utilise une boucle bornée quand on **connaît à l’avance** le nombre de répétitions.

| Écriture | Valeurs prises par `i` |
|---|---|
| `range(5)` | $0, 1, 2, 3, 4$ |
| `range(1, 5)` | $1, 2, 3, 4$ |
| `range(2, 11, 3)` | $2, 5, 8$ (de $3$ en $3$) |

**Attention : La borne de fin est exclue**
`range(a, b)` s’arrête à $b - 1$ : pour aller de $1$ à $n$ **inclus**, on écrit `range(1, n + 1)`.

**Méthode : Accumuler une somme**
1. Avant la boucle, on initialise un **accumulateur** : `s = 0` pour une somme, `p = 1` pour un produit.
2. Dans la boucle, on ajoute (ou on multiplie) le terme du tour : `s = s + i`.
3. Après la boucle (ligne non indentée), on affiche le résultat.

**Exemple : Somme des entiers de 1 à 4**
```python
s = 0
for i in range(1, 5):
    s = s + i
print(s)
```

```console
10
```

| | début | tour 1 | tour 2 | tour 3 | tour 4 |
|---|---|---|---|---|---|
| `i` | – | $1$ | $2$ | $3$ | $4$ |
| `s` | $0$ | $1$ | $3$ | $6$ | $10$ |

Le programme calcule $1 + 2 + 3 + 4 = 10$.

## VI. Boucle non bornée : while

**Définition : Syntaxe**
```python
while condition:
    instructions
```

Le bloc indenté est répété **tant que** la condition est vraie ; la condition est testée avant chaque tour. On utilise une boucle non bornée quand on **ne connaît pas à l’avance** le nombre de répétitions, par exemple pour chercher un seuil.

**Exemple : Plus petit entier n tel que 2 puissance n dépasse 1 000**
On cherche le plus petit entier $n$ tel que $2^n \gt 1\,000$. La variable `p` contient $2^n$.

```python
n = 0
p = 1
while p <= 1000:
    p = 2 * p
    n = n + 1
print(n)
```

```console
10
```

![Organigramme d’une boucle while : après n = 0 et p = 1, tant que p <= 1000 est vrai, on exécute p = 2 * p et n = n + 1 puis on revient au test ; quand le test est faux, on affiche n](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n177_co221_3_organigramme_tantque.png)

| Après le tour | `n` | `p` | `p <= 1000` ? |
|---|---|---|---|
| début | $0$ | $1$ | Vrai |
| 1 | $1$ | $2$ | Vrai |
| 2 | $2$ | $4$ | Vrai |
| … | … | … | … |
| 9 | $9$ | $512$ | Vrai |
| 10 | $10$ | $1\,024$ | Faux : on sort |

Comme $2^9 = 512 \leqslant 1\,000$ et $2^{10} = 1\,024 \gt 1\,000$, le programme affiche $10$.

**Attention : Boucle infinie et condition d’arrêt**
- La condition doit finir par devenir fausse : une variable de la condition doit être modifiée dans la boucle (ici `p` double à chaque tour). Sinon, le programme ne s’arrête jamais.
- La boucle s’arrête au **premier** tour où la condition est fausse : pour « dépasser $1\,000$ », on répète **tant que** `p <= 1000`.

**Méthode : for ou while ?**
- Nombre de répétitions connu (« $10$ fois », « pour $i$ de $1$ à $n$ ») : boucle `for`.
- Répétition jusqu’à ce qu’un seuil soit atteint (« à partir de quand… ? ») : boucle `while`, avec un **compteur** qui compte les tours.

**À retenir : - Une variable a un nom, un type (`int`, `float`, `str`, `bool`) et une valeur ; `=` affecte, `==` compare.**
- Une séquence d’instructions s’exécute de haut en bas ; une formule respecte les priorités et utilise les parenthèses.
- `if` / `elif` / `else` pour choisir ; `for` quand on connaît le nombre de répétitions ; `while` pour atteindre un seuil.
- Deux-points et indentation délimitent les blocs.
- Pour comprendre un programme, on fait son **tableau de suivi**.

## Fiche de révision

**Objectifs : Retenir l’essentiel : types, affectation, formules, conditions et boucles en Python (programme de Seconde).**

## I. Variables et affectation

| Type | Exemples |
|---|---|
| `int` (entier) | `7`, `-3` |
| `float` (flottant) | `2.5`, `4.0` |
| `str` (chaîne) | `"bonjour"` |
| `bool` (booléen) | `True`, `False` |

![État de la mémoire après les instructions a = 5, puis b = 2 * a, puis a = a + 3 : a vaut 5, puis b vaut 10, puis a vaut 8 et b garde la valeur 10](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n177_fi137_1_affectation.png)

- `a = a + 3` : on calcule à droite avec l’ancienne valeur, puis on range dans `a`.
- Opérations : `*` produit, `/` quotient, `//` quotient entier, `%` reste, `**` puissance.
- $\dfrac{a + b}{2}$ s’écrit `(a + b) / 2` ; `n % 2 == 0` teste si $n$ est pair.

## II. Conditions et boucles

```python
x = -2
if x > 0:
    print("positif")
elif x < 0:
    print("négatif")
else:
    print("nul")
```

```python
s = 0
for i in range(1, 5):
    s = s + i
```

```python
n = 0
p = 1
while p <= 1000:
    p = 2 * p
    n = n + 1
```

| Boucle | Quand l’utiliser ? |
|---|---|
| `for i in range(n)` | $n$ répétitions connues, `i` de $0$ à $n - 1$ |
| `while condition` | répéter tant que la condition est vraie (seuil) |

## III. Les pièges à éviter

**Attention : Les 5 erreurs classiques**
1. Écrire `=` au lieu de `==` dans une condition.
2. Oublier les deux-points ou l’indentation après `if`, `elif`, `else`, `for`, `while`.
3. Croire que `range(5)` va jusqu’à $5$ : il s’arrête à $4$.
4. Initialiser l’accumulateur `s = 0` **dans** la boucle au lieu d’avant.
5. Écrire une boucle `while` dont la condition reste toujours vraie.

**Remarque : Réflexe**
Pour comprendre un programme, je fais son tableau de suivi : une colonne par variable, une ligne par instruction ou par tour de boucle.

## Exercices corrigés

### Exercice 1 : Variables et types en Python

On travaille sur les types de variables en Python : `int`, `float`, `str` et `bool`.

1. Donner le type de chacune des valeurs suivantes : `42`, `3.14`, `True`, `"Bonjour"`.
2. On exécute les instructions ci-dessous. Donner la valeur et le type de chaque variable.

   ```python
   a = 7
   b = 2.0
   c = a > 10
   d = "maths"
   ```

3. Quelle est la différence entre `3` et `3.0` ? Quel est le type de `6 / 2` ?
4. Parmi les noms de variables suivants, lesquels sont valides en Python ?

   `age`, `2ndNom`, `ma_variable`, `for`, `moyenne_classe`.
5. L’instruction `print("Résultat : " + 5)` provoque une erreur. Pourquoi ? Comment la corriger ?

#### Correction détaillée

## Question 1 : Types des valeurs

**Méthode : Observer l’écriture de la valeur : chiffres sans point, avec un point, mot `True` / `False`, ou texte entre guillemets.**

**Etape : Analyse**
| Valeur | Écriture | Type |
|---|---|---|
| `42` | entier, sans point | `int` |
| `3.14` | avec un point décimal | `float` |
| `True` | vrai ou faux | `bool` |
| `"Bonjour"` | texte entre guillemets | `str` |

**Resultat : `42` : `int` ; `3.14` : `float` ; `True` : `bool` ; `"Bonjour"` : `str`.**

## Question 2 : Valeur et type de chaque variable

**Méthode : Exécuter chaque affectation ; pour `c`, évaluer d’abord la comparaison.**

**Etape : La comparaison**
`a > 10` compare $7$ et $10$ : $7 \gt 10$ est faux, donc `c` vaut `False`.

**Etape : Tableau**
| Variable | Valeur | Type |
|---|---|---|
| `a` | `7` | `int` |
| `b` | `2.0` | `float` |
| `c` | `False` | `bool` |
| `d` | `"maths"` | `str` |

![Quatre cases mémoire : a contient 7 (int, entier), b contient 2.0 (float, flottant), c contient False (bool, booléen), d contient "maths" (str, chaîne)](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n177_ex1968_1_e1968_types.png)

**Resultat : `a` : `7` (`int`) ; `b` : `2.0` (`float`) ; `c` : `False` (`bool`) ; `d` : `"maths"` (`str`).**

## Question 3 : 3 ou 3.0 ?

**Méthode : Le point décimal fait le type ; la division `/` donne toujours un flottant.**

**Etape : Comparer**
`3` est un entier (`int`), `3.0` un flottant (`float`) : ils ont la même valeur mathématique, mais pas le même type.

```python
print(type(3), type(3.0))
print(6 / 2, type(6 / 2))
```

```console
<class 'int'> <class 'float'>
3.0 <class 'float'>
```

**Resultat : `3` est un `int`, `3.0` un `float`. `6 / 2` vaut `3.0`, de type `float` (`6 // 2` donne l’entier `3`).**

## Question 4 : Noms de variables valides

**Méthode : Un nom commence par une lettre ou `_`, ne contient que des lettres, des chiffres et `_`, et n’est pas un mot réservé.**

**Etape : Vérifier chaque nom**
- `age` : valide.
- `2ndNom` : invalide, il commence par un chiffre.
- `ma_variable` : valide.
- `for` : invalide, c’est un mot réservé (boucle `for`).
- `moyenne_classe` : valide.

**Resultat : Valides : `age`, `ma_variable`, `moyenne_classe`. Invalides : `2ndNom` et `for`.**

## Question 5 : Mélanger texte et nombre

**Méthode : Le signe `+` additionne deux nombres ou **colle** deux chaînes, mais ne mélange pas les deux types.**

**Etape : L’erreur**
`"Résultat : "` est une chaîne (`str`) et `5` un entier (`int`) : Python affiche une erreur `TypeError`.

**Etape : Deux corrections**
- Convertir le nombre en chaîne : `"Résultat : " + str(5)`.
- Ou séparer par une virgule dans `print`, qui accepte plusieurs valeurs.

```python
print("Résultat : " + str(5))
print("Résultat :", 5)
```

```console
Résultat : 5
Résultat : 5
```

**Resultat : On ne peut pas additionner un `str` et un `int` : on écrit `"Résultat : " + str(5)` ou `print("Résultat :", 5)`.**

#### Réponses

1. `42` : `int` ; `3.14` : `float` ; `True` : `bool` ; `"Bonjour"` : `str`.
2. `a = 7` (`int`), `b = 2.0` (`float`), `c = False` (`bool`), `d = "maths"` (`str`).
3. Même valeur, types différents (`int` et `float`) ; `6 / 2` vaut `3.0`, de type `float`.
4. Valides : `age`, `ma_variable`, `moyenne_classe` ; invalides : `2ndNom`, `for`.
5. `TypeError` (chaîne + entier) ; corriger avec `str(5)` ou `print("Résultat :", 5)`.

### Exercice 2 : Instruction conditionnelle if, elif, else

On écrit et on simule des instructions conditionnelles.

1. Qu’affiche le programme suivant ?

   ```python
   note = 14
   if note >= 16:
       print("Très bien")
   elif note >= 12:
       print("Bien")
   elif note >= 10:
       print("Passable")
   else:
       print("Insuffisant")
   ```

2. Qu’affiche ce programme si la première ligne est `note = 16` ? et `note = 8` ?
3. Une valeur a été affectée à la variable `x`. Écrire des instructions qui affichent `positif`, `négatif` ou `nul` selon le signe de `x`.
4. Qu’affiche le programme suivant ? Quel est son rôle ?

   ```python
   a = 3
   b = 7
   if a > b:
       m = a
   else:
       m = b
   print(m)
   ```

5. Écrire des instructions qui affichent si un entier `n` est pair ou impair. On rappelle que `n % 2` est le reste de la division de `n` par $2$.
6. Écrire une condition Python qui est vraie lorsque $x$ appartient à l’intervalle $[0\,;10]$, puis une condition vraie lorsque $x$ n’y appartient pas.

#### Correction détaillée

## Question 1 : Résultat pour note = 14

**Méthode : Tester les conditions dans l’ordre : dès que l’une est vraie, Python exécute son bloc et ignore tous les cas suivants.**

**Etape : Premier test**
`note >= 16` : $14 \geqslant 16$ est faux, on passe au `elif`.

**Etape : Deuxième test**
`note >= 12` : $14 \geqslant 12$ est vrai, Python exécute `print("Bien")`.
**Le : chemin suivi par le programme, en vert :**

![Organigramme du if, elif, else des notes : pour note = 14, le test note >= 16 est faux, le test note >= 12 est vrai, le programme affiche Bien (chemin en vert)](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n177_ex1971_1_e1971_organigramme.png)

**Resultat : Le programme affiche `Bien`.**

**Attention : Le test `note >= 10` est aussi vrai, mais il n’est jamais examiné : seul le premier cas vrai est exécuté.**

## Question 2 : Résultats pour 16 et pour 8

**Méthode : Même démarche : tester les conditions dans l’ordre.**

**Etape : Pour note = 16**
`16 >= 16` est vrai (« supérieur **ou égal** ») : le programme affiche `Très bien`.

**Etape : Pour note = 8**
`8 >= 16`, `8 >= 12` et `8 >= 10` sont faux : on arrive au `else`, qui affiche `Insuffisant`.

**Resultat : Pour $16$ : `Très bien` ; pour $8$ : `Insuffisant`.**

## Question 3 : Signe d’un nombre

**Méthode : Trois cas, donc `if`, `elif` et `else` : le dernier cas (nul) est ce qui reste quand $x$ n’est ni positif ni négatif.**

```python
x = -5
if x > 0:
    print("positif")
elif x < 0:
    print("négatif")
else:
    print("nul")
```

```console
négatif
```

**Resultat : Avec $x = -5$, le programme affiche `négatif` ; il affiche `positif` pour $x = 3$ et `nul` pour $x = 0$.**

## Question 4 : Maximum de deux nombres

**Méthode : Évaluer la condition `a > b`, puis suivre le bloc correspondant.**

**Etape : Le test**
`a > b` : $3 \gt 7$ est faux, Python exécute le bloc `else` : `m = b`, donc `m` vaut $7$.

**Resultat : Le programme affiche `7` : il range dans `m` le **plus grand** des deux nombres `a` et `b`.**

## Question 5 : Pair ou impair

**Méthode : Un entier est pair lorsque le reste de sa division par $2$ est nul : on teste `n % 2 == 0`.**

```python
n = 17
if n % 2 == 0:
    print(n, "est pair")
else:
    print(n, "est impair")
```

```console
17 est impair
```

**Resultat : $17 = 2 \times 8 + 1$ : le reste vaut $1$, donc `17 % 2 == 0` est faux et le programme affiche `17 est impair`.**

**Attention : `if n % 2 = 0:` provoque une erreur : dans une condition, on compare avec `==`.**

## Question 6 : Appartenance à un intervalle

**Méthode : $x \in [0\,;10]$ signifie $x \geqslant 0$ **et** $x \leqslant 10$ : on relie les deux comparaisons par `and`.**

**Etape : Condition d’appartenance**
`x >= 0 and x <= 10`

**Etape : Condition contraire**
$x$ n’appartient pas à l’intervalle si $x \lt 0$ **ou** $x \gt 10$ : `x < 0 or x > 10` (ou encore `not (x >= 0 and x <= 10)`).

```python
x = 12
if x >= 0 and x <= 10:
    print("dans [0 ; 10]")
else:
    print("hors de [0 ; 10]")
```

```console
hors de [0 ; 10]
```

**Resultat : Appartenance : `x >= 0 and x <= 10` ; non-appartenance : `x < 0 or x > 10`.**

#### Réponses

1. `Bien`.
2. `note = 16` : `Très bien` ; `note = 8` : `Insuffisant`.
3. `if x > 0:` … `elif x < 0:` … `else:` … (affichages `positif`, `négatif`, `nul`).
4. `7` : le programme calcule le maximum de `a` et `b`.
5. Tester `n % 2 == 0` : pour $n = 17$, affichage `17 est impair`.
6. `x >= 0 and x <= 10` ; contraire : `x < 0 or x > 10`.

### Exercice 3 : Diviseurs et nombres premiers : lire et modifier un programme

On étudie des programmes qui combinent variables, conditions et boucles : il faut les lire, les simuler, puis les modifier ou les compléter.

1. Qu’affiche le programme suivant ? Quel est son rôle ?

   ```python
   n = 15
   nb = 0
   for i in range(1, n + 1):
       if n % i == 0:
           nb = nb + 1
   print(nb)
   ```

2. Modifier le programme de la question 1 pour qu’il **affiche** les diviseurs de `n` au lieu de les compter.
3. Qu’affiche le programme suivant ? Expliquer son rôle.

   ```python
   n = 7
   nb = 0
   for i in range(1, n + 1):
       if n % i == 0:
           nb = nb + 1
   if nb == 2:
       print(n, "est premier")
   else:
       print(n, "non premier")
   ```

4. On additionne les nombres impairs $1 + 3 + 5 + \cdots$ jusqu’à ce que la somme dépasse $100$. Écrire un programme qui affiche le nombre d’impairs additionnés et la somme obtenue.
5. Compléter la ligne `if ...:` du programme suivant pour qu’il affiche tous les nombres premiers compris entre $2$ et $20$. Qu’affiche-t-il alors ?

   ```python
   for n in range(2, 21):
       c = 0
       for i in range(1, n + 1):
           if n % i == 0:
               c = c + 1
       if ...:
           print(n)
   ```

#### Correction détaillée

## Question 1 : Rôle du premier programme

**Méthode : Repérer les structures (une boucle `for` qui contient un test `if`), puis simuler le programme.**

**Etape : La boucle**
`range(1, n + 1)` donne les entiers de $1$ à $15$ : la variable `i` prend successivement ces $15$ valeurs.

**Etape : Le test**
`n % i == 0` est vrai lorsque le reste de la division de $15$ par `i` est nul, c’est-à-dire lorsque `i` **divise** $15$. Cela arrive pour `i` égal à $1$, $3$, $5$ et $15$.

**Etape : Le compteur**
La variable `nb` est un **compteur** : elle part de $0$ et augmente de $1$ à chaque diviseur trouvé : il vaut $4$ à la fin de la boucle.

**Resultat : Le programme affiche `4` : il **compte les diviseurs** de `n`.**

## Question 2 : Afficher les diviseurs

**Méthode : Quand `i` divise `n`, on affiche `i` au lieu d’augmenter le compteur ; le compteur devient inutile.**

**Resultat : ```python**
n = 15
for i in range(1, n + 1):
    if n % i == 0:
        print(i)
```

Le programme affiche $1$, $3$, $5$ puis $15$, un nombre par ligne.

## Question 3 : Test de primalité

**Méthode : Le programme compte les diviseurs de $7$ puis teste si ce nombre vaut $2$.**

**Etape : Diviseurs de 7**
| `i` | `7 % i` | `i` divise $7$ ? | `nb` |
|---|---|---|---|
| $1$ | $0$ | oui | $1$ |
| $2$ | $1$ | non | $1$ |
| $3$ | $1$ | non | $1$ |
| $4$ | $3$ | non | $1$ |
| $5$ | $2$ | non | $1$ |
| $6$ | $1$ | non | $1$ |
| $7$ | $0$ | oui | $2$ |

**Etape : Le test final**
Après la boucle, `nb == 2` est vrai : Python exécute le bloc du `if`.

**Resultat : ```console**
7 est premier
```

Le programme teste si `n` est **premier** : un nombre premier a exactement deux diviseurs, $1$ et lui-même.

## Question 4 : Somme d’impairs jusqu’à dépasser 100

**Méthode : On ne sait pas combien d’impairs il faudra : boucle `while`, avec un accumulateur `S`, la variable `impair` qui augmente de $2$ à chaque tour et un compteur `k`.**

**Etape : Initialisation**
`S = 0` (rien n’est encore ajouté), `impair = 1` (premier impair), `k = 0` (aucun tour).

**Etape : Condition de la boucle**
On veut **dépasser** $100$ : on continue **tant que** `S <= 100`.

```python
S = 0
impair = 1
k = 0
while S <= 100:
    S = S + impair
    impair = impair + 2
    k = k + 1
print(k, S)
```

```console
11 121
```

**Point : Vérification**
Les sommes successives sont les carrés $1, 4, 9, \ldots, 100, 121$. Après $10$ impairs, $S = 100$ : la condition `100 <= 100` est encore vraie, donc on ajoute $21$ et $S = 121$.

**Resultat : Il faut additionner $11$ impairs ($1 + 3 + \cdots + 21$) ; la somme vaut alors $121$.**

**Attention : Avec `while S < 100`, la boucle s’arrêterait à $S = 100$, qui ne **dépasse** pas $100$.**

## Question 5 : Afficher les nombres premiers jusqu’à 20

**Méthode : La boucle intérieure est celle de la question 3 : elle compte les diviseurs de `n` dans `c`. La boucle extérieure fait varier `n` de $2$ à $20$.**

**Etape : La condition à écrire**
`n` est premier lorsqu’il a exactement deux diviseurs : on complète par `if c == 2:`.

**Etape : Le rôle de c = 0**
`c = 0` est **dans** la boucle extérieure : le compteur repart de zéro pour chaque nouvelle valeur de `n`.

```python
for n in range(2, 21):
    c = 0
    for i in range(1, n + 1):
        if n % i == 0:
            c = c + 1
    if c == 2:
        print(n)
```

**Resultat : Le programme affiche $2$, $3$, $5$, $7$, $11$, $13$, $17$, $19$ (un nombre par ligne).**

**Attention : Si `c = 0` était placé avant la première boucle, les diviseurs de tous les nombres s’additionneraient : seul $2$ serait affiché.**

#### Réponses

1. Le programme affiche `4` : il compte les diviseurs de `n` ($1$, $3$, $5$, $15$).
2. On remplace `nb = nb + 1` par `print(i)` (et on supprime le compteur) : affichage $1$, $3$, $5$, $15$.
3. Il affiche `7 est premier` : il teste si `n` a exactement deux diviseurs.
4. Boucle `while S <= 100` : $11$ impairs, somme $121$.
5. `if c == 2:` ; affichage $2$, $3$, $5$, $7$, $11$, $13$, $17$, $19$.
