# Guide enseignant — Questions fréquentes par projet

---

## Questions communes à tous les projets

**"On peut utiliser `sort()` ou `sorted()` ?"**
Non. L'objectif est précisément d'implémenter les algorithmes vus en cours. Ces fonctions intégrées existent, mais leur utilisation ici invalide le travail demandé.

**"Comment copier une liste sans modifier l'original ?"**
```python
copie = ma_liste[:]   # ou list(ma_liste)
```
Ne pas faire `copie = ma_liste` : les deux variables pointeraient sur le même objet en mémoire.

**"La dichotomie ne fonctionne pas, j'ai une erreur ou un résultat faux."**
Vérifier que la liste est bien triée avant d'appeler la dichotomie. C'est la condition indispensable. Si la liste n'est pas triée, le résultat est imprévisible.

**"Mon tri modifie la liste originale, est-ce normal ?"**
Oui. `tri_insertion` et `tri_selection` trient la liste **en place** (ils la modifient directement). Si l'on veut conserver l'original, il faut travailler sur une copie : `tri_insertion(ma_liste[:])`.

**"J'ai une `IndexError`."**
La cause la plus fréquente est un indice qui dépasse la taille de la liste. Vérifiez les bornes de vos boucles (`range`) et les conditions d'arrêt (`while`).

---

## Projet 01 — Le Nombre Mystère

**"Pourquoi la condition est `while gauche <= droite` et pas `while gauche < droite` ?"**
Quand il ne reste qu'un seul élément possible, `gauche` et `droite` sont égaux. Si on exclut ce cas avec `<`, on rate le dernier candidat. Le `<=` permet de traiter ce dernier cas.

**"Pourquoi 7 essais suffisent toujours pour 100 nombres ?"**
Parce que la recherche dichotomique a une complexité logarithmique : log₂(100) ≈ 6,64, donc 7 essais au maximum. À chaque question, on élimine la moitié des candidats restants.

**"Et si l'utilisateur ment ou se trompe dans sa réponse ?"**
Le programme finira par épuiser l'intervalle et afficher "tu as triché". Ce comportement est déjà géré dans le starter (fin de boucle sans `return`).

**"Comment modifier `gauche` et `droite` selon la réponse ?"**
- Si le nombre cherché est `<` milieu : `droite = milieu - 1`
- Si le nombre cherché est `>` milieu : `gauche = milieu + 1`

---

## Projet 02 — Le Tri de Cartes

**"Comment accéder à la valeur d'une carte ?"**
Chaque carte est un tuple `(valeur, couleur)`. `carte[0]` donne la valeur, `carte[1]` donne la couleur.

**"Pourquoi l'As vaut 14 ?"**
C'est une convention pour qu'il soit la carte la plus forte (valeur maximale). Cela permet de le trier après le Roi (13) avec une simple comparaison numérique.

**"La condition du `while` dans le tri insertion : que faut-il écrire ?"**
```python
while j > 0 and main[j - 1][0] > x[0]:
```
On compare uniquement les valeurs (`[0]`), pas les couleurs.

**"Ma dichotomie retourne toujours `False` même si la carte est là."**
Vérifier que la main est bien triée avant la recherche. Et que la comparaison porte bien sur `main_triee[m][0]` (la valeur), pas sur la carte entière.

---

## Projet 03 — Le Podium

**"Comment trier des dictionnaires ?"**
On ne trie pas le dictionnaire en tant que tel, on trie la **liste** de dictionnaires. Dans le tri, on compare `athletes[j]["temps"]` et `athletes[mini]["temps"]`.

**"Que se passe-t-il si deux athlètes ont le même temps ?"**
Le tri par sélection n'est pas **stable** : il ne garantit pas que deux éléments égaux restent dans leur ordre d'origine. L'un des deux sera placé en premier de façon arbitraire. C'est une propriété à connaître pour le DS.

**"Comment aligner le texte dans le podium ASCII ?"**
Avec les f-strings et le formatage d'alignement :
```python
f"{nom:^12}"   # centré sur 12 caractères
f"{nom:<12}"   # aligné à gauche
f"{nom:>12}"   # aligné à droite
```

**"La dichotomie sur les temps : pourquoi ça compare des flottants ?"**
Comparer des flottants avec `==` peut poser des problèmes de précision en Python (ex. `0.1 + 0.2 != 0.3`). Ici les données sont saisies à la main donc c'est acceptable, mais c'est un point de vigilance à mentionner.

---

## Projet 04 — L'Annuaire

**"Comment ajouter un élément à la fin d'une liste ?"**
```python
ma_liste.append(element)
```

**"Comment supprimer un élément d'une liste par sa valeur ?"**
```python
ma_liste.remove(element)   # supprime la première occurrence
```
Ou par indice :
```python
del ma_liste[i]
```

**"La condition du `while` dans `ajouter_contact` : que comparer ?"**
```python
while j > 0 and annuaire[j - 1]["nom"] > contact["nom"]:
```
On compare les noms alphabétiquement.

**"La dichotomie me retourne le bon contact mais je n'affiche rien."**
Vérifier que l'appel dans le `menu()` est bien `resultat = rechercher(annuaire, nom)` et que le résultat est ensuite utilisé (`if resultat is not None:`).

**"Le menu ne s'arrête jamais."**
C'est le comportement voulu (`while True`). Il faut saisir `4` pour déclencher le `break`.

---

## Projet 05 — Le Correcteur Orthographique

**"Pourquoi les bornes `a` et `b` donnent les voisins à la fin de la dichotomie ?"**
À la fin de la boucle (quand `a > b`), `b` vaut l'indice du dernier élément plus petit que le mot cherché, et `a` vaut l'indice du premier élément plus grand. Ce sont donc les deux voisins alphabétiques du mot absent. C'est une propriété de la dichotomie que l'on exploite ici de façon non conventionnelle.

**"Il faut vérifier quoi pour les cas limites des voisins ?"**
- Si `b < 0` : le mot serait avant tous les mots du dictionnaire → pas de voisin avant
- Si `a >= len(dictionnaire)` : le mot serait après tous les mots → pas de voisin après

```python
voisin_avant = dictionnaire[b] if b >= 0 else None
voisin_apres = dictionnaire[a] if a < len(dictionnaire) else None
```

**"La condition du `while` dans `ajouter_mot` : que comparer ?"**
```python
while j > 0 and dictionnaire[j - 1] > mot:
```
Les chaînes se comparent directement en Python (ordre alphabétique).

**"Les suggestions ne correspondent pas au mot saisi."**
Vérifier que la comparaison se fait bien en minuscules. Utiliser `.lower()` sur le mot saisi par l'utilisateur pour uniformiser.

---

## Projet 06 — La Bibliothèque

**"Comment trier par titre (chaînes) avec le tri sélection ?"**
```python
if livres[j]["titre"] < livres[mini]["titre"]:
```
Python compare les chaînes alphabétiquement avec `<` et `>`.

**"La dichotomie ne trouve pas un livre qui est pourtant dans la liste."**
Les titres dans le dictionnaire sont tous en **minuscules**. Si l'utilisateur saisit "1984" avec une majuscule ou des espaces en trop, la comparaison échouera. Appliquer `.strip().lower()` à la saisie.

**"Comment trier une copie sans modifier la liste originale ?"**
```python
livres_par_pages = livres[:]          # copie
tri_selection_livres_par_pages(livres_par_pages)   # trier la copie
```

**"Comment calculer la moyenne ?"**
```python
total = sum(l["pages"] for l in livres)
moyenne = total / len(livres)
```

---

## Projet 07 — La Météo

**"Comment accéder au jour et à la température dans un tuple ?"**
Chaque relevé est `(jour, temperature)`. On accède avec `releve[0]` pour le jour et `releve[1]` pour la température. Ou avec le déballage : `jour, temp = releve`.

**"La condition du `while` dans le tri : que comparer ?"**
```python
while j > 0 and tab[j - 1][1] > x[1]:
```
On compare le deuxième élément du tuple (la température).

**"Qu'est-ce que `.get()` sur un dictionnaire ?"**
`compteur.get(degre, 0)` retourne la valeur associée à la clé `degre` si elle existe, sinon retourne `0`. C'est équivalent à :
```python
if degre in compteur:
    return compteur[degre]
else:
    return 0
```

**"Pourquoi travailler sur une copie des relevés ?"**
Pour conserver l'ordre chronologique original. Si on trie directement `releves`, on perd l'information "quel jour avait quelle température".

**"Comment calculer la médiane ?"**
Sur une liste triée de taille `n`, la médiane est l'élément à l'indice `n // 2` :
```python
mediane = tab_trie[len(tab_trie) // 2]
```

---

## Projet 08 — La Course des Algorithmes

**"Les temps mesurés varient à chaque exécution, c'est normal ?"**
Oui. Le temps dépend de la charge du processeur au moment de l'exécution. Pour des résultats plus stables, on peut faire la moyenne sur plusieurs exécutions. Mais les tendances (quel algorithme est plus rapide) restent les mêmes.

**"Pourquoi travailler sur une copie dans `mesurer_temps` ?"**
Si on trie directement la liste passée en argument, elle sera triée pour la deuxième mesure : les deux algorithmes ne partiraient pas dans les mêmes conditions.

**"Mon tri insertion est beaucoup plus rapide sur une liste déjà triée, pourquoi ?"**
Parce que sur une liste déjà triée, la boucle `while` interne ne s'exécute jamais (la condition est fausse dès le premier tour). Sa complexité devient linéaire O(n) au lieu de O(n²). Ce n'est pas le cas du tri sélection, qui parcourt toujours toute la liste restante.

**"Qu'est-ce que `random.sample(range(n * 10), n)` ?"**
Cela génère une liste de `n` entiers distincts choisis aléatoirement entre 0 et `n*10`. Le `* 10` évite les doublons dans la liste.

**"Comment interpréter les résultats pour la conclusion ?"**
Le tri insertion est plus rapide sur des listes presque triées. Le tri sélection est plus constant (toujours O(n²) quel que soit le cas). Pour des listes aléatoires de grande taille, les deux sont comparables.

---

## Projet 09 — Le Générateur Web

**"Le fichier HTML se génère où ?"**
Dans le même dossier que `starter.py`. Si le navigateur ne s'ouvre pas automatiquement, ouvrir manuellement `classement.html` depuis ce dossier.

**"La dichotomie inversée : comment ça marche ?"**
Quand la liste est triée par ordre décroissant, un score plus grand se trouve à gauche. Les comparaisons sont donc inversées :
- Si `score_m > score` (le milieu est trop grand) → chercher à droite (`a = m + 1`)
- Si `score_m < score` (le milieu est trop petit) → chercher à gauche (`b = m - 1`)

**"La condition du `while` dans le tri décroissant : que mettre ?"**
```python
while j > 0 and jeux[j - 1]["score"] < x["score"]:
```
On décale quand le score précédent est **inférieur** (l'inverse du tri croissant).

**"Comment écrire dans un fichier en Python ?"**
```python
with open("fichier.html", "w", encoding="utf-8") as f:
    f.write(contenu)
```
Le `with` garantit que le fichier est bien fermé après l'écriture.

**"Pourquoi Python peut générer du HTML mais HTML ne peut pas exécuter Python ?"**
HTML est un langage de **description** (il décrit une structure), pas un langage d'exécution. Python, lui, s'exécute côté serveur ou en local et peut produire n'importe quel texte en sortie, y compris du HTML. Un navigateur lit le HTML généré, mais ne sait pas d'où il vient.