forked from menault/2026_TD2_DEV51_Qualite_Algo
92 lines
2.7 KiB
Markdown
92 lines
2.7 KiB
Markdown
# Compte rendu – TD Complexité cyclomatique (R5.A.04)
|
||
|
||
## Partie 1 – Graphes de flot de contrôle
|
||
|
||
Pour chaque fonction, on construit le graphe de flot de contrôle (un nœud = un bloc sans branchement, une décision = un nœud à deux sorties, un seul nœud de sortie), puis on applique :
|
||
|
||
**M = E − N + 2P** (E = arêtes, N = nœuds, P = 1 pour une fonction)
|
||
|
||
On vérifie ensuite le résultat avec la règle pratique **M = décisions + 1**.
|
||
|
||
### C2 – `moyenne` (C)
|
||
|
||
|
||
|
||
| Nœud | Contenu |
|
||
|---|---|
|
||
| 1 | `somme = 0 ; i = 0` |
|
||
| 2 | décision `i < n` |
|
||
| 3 | `somme += t[i]` |
|
||
| 4 | `i++` (arête de retour vers 2) |
|
||
| 5 | décision `n > 0` (ternaire) |
|
||
| 6 | `somme / n` |
|
||
| 7 | `0` |
|
||
| 8 | sortie (`return`) |
|
||
|
||
- N = 8, E = 9, P = 1
|
||
- **M = 9 − 8 + 2 × 1 = 3**
|
||
- Vérification : 1 `for` + 1 ternaire `?:` + 1 = 3
|
||
|
||
### J2 – `estDisponible` (Java)
|
||
|
||
|
||
|
||
La méthode ne contient aucun `if`, mais les `&&` sont évalués paresseusement : chaque opérande est une décision (si `livre.emprunte` est vrai, on sort directement sans évaluer la suite).
|
||
|
||
| Nœud | Contenu |
|
||
|---|---|
|
||
| 1 | décision `!livre.emprunte` |
|
||
| 2 | décision `!livre.reserve` |
|
||
| 3 | décision `!livre.abime` |
|
||
| 4 | sortie (`return`) |
|
||
|
||
- N = 4, E = 5, P = 1
|
||
- **M = 5 − 4 + 2 × 1 = 3**
|
||
- Vérification : 2 opérateurs `&&` + 1 = 3
|
||
|
||
### P2 – `signe` (Python)
|
||
|
||
|
||
|
||
| Nœud | Contenu |
|
||
|---|---|
|
||
| 1 | décision `x > 0` |
|
||
| 2 | `return 1` |
|
||
| 3 | décision `x < 0` (`elif`) |
|
||
| 4 | `return -1` |
|
||
| 5 | `return 0` |
|
||
| 6 | sortie |
|
||
|
||
- N = 6, E = 7, P = 1
|
||
- **M = 7 − 6 + 2 × 1 = 3**
|
||
- Vérification : 1 `if` + 1 `elif` + 1 = 3
|
||
|
||
### P3 – `notes_valides` (Python)
|
||
|
||
|
||
|
||
La compréhension de liste cache une boucle et un filtre : elle se lit comme un `for` contenant un `if`.
|
||
|
||
| Nœud | Contenu |
|
||
|---|---|
|
||
| 1 | initialisation de la liste résultat |
|
||
| 2 | décision : reste-t-il un élément `n` dans `notes` ? |
|
||
| 3 | décision `0 <= n <= 20` |
|
||
| 4 | ajout de `n` au résultat (retour vers 2) |
|
||
| 5 | sortie (`return`) |
|
||
|
||
- N = 5, E = 6, P = 1
|
||
- **M = 6 − 5 + 2 × 1 = 3**
|
||
- Vérification : 1 `for` + 1 `if` (dans la compréhension) + 1 = 3
|
||
|
||
> Remarque : `0 <= n <= 20` est une comparaison chaînée, équivalente à `0 <= n and n <= 20`. Si on compte ce `and` implicite comme une décision, on obtient M = 4. Nous l'avons compté comme une seule condition, comme le font la plupart des outils (aucun opérateur `and` n'apparaît dans le code).
|
||
|
||
### Récapitulatif
|
||
|
||
| Fonction | N | E | M | Classe |
|
||
|---|---|---|---|---|
|
||
| C2 `moyenne` | 8 | 9 | 3 | Simple |
|
||
| J2 `estDisponible` | 4 | 5 | 3 | Simple |
|
||
| P2 `signe` | 6 | 7 | 3 | Simple |
|
||
| P3 `notes_valides` | 5 | 6 | 3 | Simple |
|