Mini-projets algorithmique, corrigé TP KNN, news, notebooks IA

algorithmes/mini-projets/05_correcteur/starter.py

@@ -0,0 +1,111 @@
+# Projet 05 — Le Correcteur Orthographique
+# Algorithmes : Tri par insertion + Recherche dichotomique
+
+# Dictionnaire de base, déjà trié alphabétiquement
+dictionnaire = [
+    "algorithme", "annuaire", "arbre", "binaire", "boucle",
+    "cellule", "chaine", "chat", "chien", "circuit",
+    "clavier", "code", "complexite", "condition", "donnee",
+    "ecran", "entier", "fichier", "flottant", "fonction",
+    "graphe", "indice", "instruction", "langage", "liste",
+    "logiciel", "memoire", "module", "nombre", "octet",
+    "ordinateur", "pixel", "programme", "python", "recursion",
+    "reseau", "serveur", "tableau", "terminal", "variable",
+]
+
+def verifier(dictionnaire, mot):
+    """
+    Recherche dichotomique : retourne True si le mot est dans le dictionnaire,
+    False sinon.
+    """
+    a = 0
+    b = len(dictionnaire) - 1
+    while a <= b:
+        m = (a + b) // 2
+        if dictionnaire[m] == mot:
+            return True
+        elif dictionnaire[m] < mot:
+            # TODO
+            pass
+        else:
+            # TODO
+            pass
+    return False
+
+def verifier_avec_voisins(dictionnaire, mot):
+    """
+    Recherche dichotomique améliorée.
+    Retourne un tuple (trouve, voisin_avant, voisin_apres) :
+    - trouve      : True si le mot existe, False sinon
+    - voisin_avant : le mot juste avant dans le dictionnaire (ou None)
+    - voisin_apres : le mot juste après dans le dictionnaire (ou None)
+
+    Indication : à la fin de la boucle, si le mot n'est pas trouvé,
+    b pointe vers le mot juste avant et a vers le mot juste après.
+    """
+    a = 0
+    b = len(dictionnaire) - 1
+    while a <= b:
+        m = (a + b) // 2
+        if dictionnaire[m] == mot:
+            return (True, None, None)
+        elif dictionnaire[m] < mot:
+            a = m + 1
+        else:
+            b = m - 1
+    # TODO : récupérer les voisins avec les indices a et b
+    # Attention aux cas limites : b peut valoir -1, a peut dépasser la taille
+    voisin_avant = None  # TODO : dictionnaire[b] si b >= 0, sinon None
+    voisin_apres = None  # TODO : dictionnaire[a] si a < len(dictionnaire), sinon None
+    return (False, voisin_avant, voisin_apres)
+
+def ajouter_mot(dictionnaire, mot):
+    """
+    Insère le mot à la bonne place pour maintenir l'ordre alphabétique.
+    Principe : tri par insertion sur un seul élément.
+    """
+    dictionnaire.append(mot)
+    j = len(dictionnaire) - 1
+    # TODO : décaler vers la gauche tant que le mot précédent est après le mot inséré
+    while j > 0 and False:  # TODO : remplacer False par la bonne condition
+        dictionnaire[j] = dictionnaire[j - 1]
+        j -= 1
+    dictionnaire[j] = mot
+
+def corriger(dictionnaire, mot):
+    """Affiche le résultat de la correction pour un mot donné."""
+    trouve, avant, apres = verifier_avec_voisins(dictionnaire, mot)
+    if trouve:
+        print(f'  "{mot}" : correct')
+    else:
+        suggestions = [v for v in [avant, apres] if v is not None]
+        if suggestions:
+            proposition = '" ou "'.join(suggestions)
+            print(f'  "{mot}" : mot inconnu. Vouliez-vous dire "{proposition}" ?')
+        else:
+            print(f'  "{mot}" : mot inconnu, aucune suggestion.')
+
+
+# --- Programme principal ---
+print("=== Correcteur Orthographique ===")
+print(f"Dictionnaire : {len(dictionnaire)} mots\n")
+
+# Tests de correction
+print("Tests automatiques :")
+for mot in ["python", "pithon", "algorithme", "algorythme", "variable", "varible", "zzz"]:
+    corriger(dictionnaire, mot)
+
+# Ajout d'un mot
+print()
+print("Ajout du mot 'reseau' (déjà présent) et 'robot' (nouveau) :")
+ajouter_mot(dictionnaire, "robot")
+print(f'  "robot" ajouté. Vérification : {verifier(dictionnaire, "robot")}')
+
+# Interface interactive
+print()
+print("--- Mode interactif (tapez 'fin' pour quitter) ---")
+while True:
+    mot = input("Mot à vérifier : ").strip().lower()
+    if mot == "fin":
+        break
+    corriger(dictionnaire, mot)

algorithmes/mini-projets/05_correcteur/sujet.md

@@ -0,0 +1,50 @@
+# 05 — Le Correcteur Orthographique
+
+**Algorithmes :** Tri par insertion + Recherche dichotomique
+**Difficulté :** Moyen
+**Durée estimée :** 1h — 1h15
+
+---
+
+## Contexte
+
+Vous construisez un mini correcteur orthographique. Il dispose d'un dictionnaire de mots déjà triés par ordre alphabétique. Il peut vérifier si un mot existe, proposer des mots voisins en cas d'erreur, et permettre d'ajouter de nouveaux mots en maintenant l'ordre.
+
+Ce projet utilise la dichotomie différemment des autres : au lieu de renvoyer seulement `True` ou `False`, elle doit aussi indiquer **où** le mot aurait dû se trouver, pour proposer des suggestions.
+
+---
+
+## Étapes
+
+### Étape 1 — Vérifier un mot
+Implémentez `verifier(dictionnaire, mot)` qui retourne `True` si le mot est dans le dictionnaire, `False` sinon.
+
+C'est une recherche dichotomique classique sur des chaînes de caractères.
+
+> Rappel : en Python, les chaînes se comparent alphabétiquement : `"chat" < "chien"` → `True`.
+
+### Étape 2 — Proposer des voisins
+Modifiez votre fonction pour qu'elle retourne aussi les **mots voisins** quand le mot est absent : le mot qui se trouverait juste avant et juste après dans le dictionnaire.
+
+> **Indication** : à la fin de la dichotomie, si le mot n'est pas trouvé, les bornes `a` et `b` indiquent l'endroit où il aurait dû être inséré. Les mots en `dictionnaire[b]` et `dictionnaire[a]` sont ses voisins alphabétiques.
+
+Retournez un tuple `(trouve, voisin_avant, voisin_apres)`.
+
+### Étape 3 — Ajouter un mot
+Implémentez `ajouter_mot(dictionnaire, mot)` qui insère le mot à la bonne place pour maintenir l'ordre alphabétique.
+
+> **Indication** : c'est le même principe que le tri par insertion, appliqué à un seul élément. Ajoutez le mot à la fin avec `append()`, puis décalez vers la gauche tant que le mot précédent est alphabétiquement après lui.
+
+### Étape 4 — Interface de correction
+Complétez la boucle principale : l'utilisateur saisit un mot, le programme répond :
+- `"chat" : correct`
+- `"chzt" : mot inconnu. Vouliez-vous dire "chute" ou "chat" ?`
+
+### Étape 5 — Extension (si vous avez le temps)
+Ajoutez une fonction `charger_mots(fichier)` qui lit un fichier texte (un mot par ligne) et retourne la liste triée. Testez avec un vrai fichier de mots français.
+
+---
+
+## Ce que vous devez rendre
+- Le programme fonctionnel avec la suggestion de voisins
+- Réponse : pourquoi les bornes `a` et `b` à la fin de la dichotomie indiquent-elles le point d'insertion ?