TermNSI/Modularité/Corrige_TP.md

# Corrigé du TP Modularité

---

## Partie 1 : Lancer de dé

### Question 0 : Création du module

Créer un fichier `de.py`.

### Question 1 : Fonction de base

```python
# de.py
import random

def de():
    """
    Simule un lancer de dé à 6 faces.

    :return: (int) un entier entre 1 et 6
    """
    return random.randint(1, 6)
```

### Question 2 : Fonction paramétrable

```python
def de(n=6):
    """
    Simule un lancer de dé à n faces.

    :param n: (int) le nombre de faces du dé (6 par défaut)
    :return: (int) un entier entre 1 et n
    """
    return random.randint(1, n)
```

### Question 3 : Docstring et doctest complets

```python
# de.py
import random
import doctest

def de(n=6):
    """
    Simule un lancer de dé à n faces.

    :param n: (int) le nombre de faces du dé (6 par défaut)
    :return: (int) un entier entre 1 et n
    :CU: n >= 1

    Exemple:
    >>> de() in [1, 2, 3, 4, 5, 6]
    True
    >>> de(12) in range(1, 13)
    True
    >>> de(1)
    1
    """
    return random.randint(1, n)

if __name__ == "__main__":
    doctest.testmod(verbose=True)
```

---

## Partie 2 : Année bissextile

### Question 4 : Création du module

Créer un fichier `bissextile.py`.

### Question 5 : Fonction de saisie

```python
def saisir_annee():
    """
    Demande à l'utilisateur de saisir une année.

    :return: (int) l'année saisie par l'utilisateur
    """
    annee = input("Entrez une année : ")
    return int(annee)
```

### Question 6 : Fonction de vérification

Une année est bissextile si :
- Elle est divisible par 4
- MAIS pas par 100
- SAUF si elle est divisible par 400

```python
# bissextile.py
import doctest

def verifie(annee):
    """
    Vérifie si une année est bissextile.

    :param annee: (int) l'année à vérifier
    :return: (bool) True si bissextile, False sinon
    :CU: annee > 0

    Exemple:
    >>> verifie(2000)
    True
    >>> verifie(2022)
    False
    >>> verifie(1900)
    False
    >>> verifie(2024)
    True
    >>> verifie(2100)
    False
    """
    if annee % 400 == 0:
        return True
    if annee % 100 == 0:
        return False
    if annee % 4 == 0:
        return True
    return False

if __name__ == "__main__":
    doctest.testmod(verbose=True)
```

---

## Partie 3 : Fusion de modules

### Questions 7-8 : Module fusion

```python
# fusion.py
import doctest
from de import de
from bissextile import verifie

def avance(dep, pas, arr):
    """
    Avance d'année en année selon le pas en paramètre et en partant
    de l'année de départ jusqu'à l'arrivée et renvoie le nombre
    d'années bissextiles rencontrées.

    :param dep: (int) l'année de départ
    :param pas: (int) le pas
    :param arr: (int) l'année d'arrivée
    :return: (int) le nombre d'années bissextiles rencontrées

    Exemple:
    >>> avance(2020, 2, 2024)
    2
    >>> avance(2018, 4, 2024)
    0
    >>> avance(2000, 1, 2010)
    3
    """
    compteur = 0
    annee = dep
    while annee < arr:
        if verifie(annee):
            compteur += 1
        annee += pas
    return compteur

if __name__ == "__main__":
    doctest.testmod(verbose=True)
```

**Explication de l'exemple `avance(2018, 4, 2024)` → 0 :**
- On part de 2018, on avance de 4 en 4 : 2018, 2022
- 2018 n'est pas bissextile, 2022 non plus
- On s'arrête avant 2024, donc on ne compte pas 2024
- Résultat : 0

**Note :** La fonction `de` n'est pas utilisée ici. Elle pourrait servir pour une extension où le pas serait aléatoire.

---

## Partie 4 : Documentations

### Question 9-10 : Docstrings du module arithmetique

```python
# arithmetique.py
import doctest

def expo(a, b, n):
    """
    Calcule le reste de la division par n de a puissance b.
    Utilise l'exponentiation modulaire pour plus d'efficacité.

    :param a: (int) la base
    :param b: (int) l'exposant (positif ou nul)
    :param n: (int) le modulo (strictement positif)
    :return: (int) a^b mod n
    :CU: b >= 0 et n > 0

    Exemple:
    >>> expo(2, 10, 1000)
    24
    >>> expo(3, 4, 5)
    1
    >>> expo(7, 0, 10)
    1
    """
    return pow(a, b, n)


def pgcd(a, b):
    """
    Calcule le plus grand diviseur commun entre a et b
    en utilisant l'algorithme d'Euclide.

    :param a: (int) un entier
    :param b: (int) un entier
    :return: (int) le PGCD de a et b
    :CU: a et b ne sont pas tous les deux nuls

    Exemple:
    >>> pgcd(48, 18)
    6
    >>> pgcd(17, 13)
    1
    >>> pgcd(100, 25)
    25
    >>> pgcd(0, 5)
    5
    """
    a, b = abs(a), abs(b)
    while b != 0:
        a, b = b, a % b
    return a


def decomposition(n):
    """
    Décompose un entier positif en facteurs premiers.
    Renvoie une liste de tuples (facteur, multiplicité).

    :param n: (int) un entier strictement positif
    :return: (list) liste de tuples (facteur, multiplicité)
    :CU: n > 0

    Exemple:
    >>> decomposition(12)
    [(2, 2), (3, 1)]
    >>> decomposition(100)
    [(2, 2), (5, 2)]
    >>> decomposition(17)
    [(17, 1)]
    >>> decomposition(1)
    []
    """
    facteurs = []
    diviseur = 2
    while diviseur * diviseur <= n:
        compteur = 0
        while n % diviseur == 0:
            compteur += 1
            n //= diviseur
        if compteur > 0:
            facteurs.append((diviseur, compteur))
        diviseur += 1
    if n > 1:
        facteurs.append((n, 1))
    return facteurs


if __name__ == "__main__":
    doctest.testmod(verbose=True)
```

---

## Structure finale des fichiers

```
Modularité/
├── de.py
├── bissextile.py
├── fusion.py
└── arithmetique.py
```

Chaque module peut être testé individuellement avec :

```bash
python de.py
python bissextile.py
python fusion.py
python arithmetique.py
```

---

Auteurs : Florian Mathieu, Enzo Frémeaux, Timothée Decoster

Licence CC BY-SA

<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International</a>.