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

algorithmes/mini-projets/03_podium/starter.py

@@ -0,0 +1,93 @@
+# Projet 03 — Le Podium
+# Algorithme : Tri par sélection
+
+athletes = [
+    {"nom": "Marcus",  "pays": "JAM", "temps": 9.97},
+    {"nom": "Alice",   "pays": "FRA", "temps": 9.85},
+    {"nom": "Yusuf",   "pays": "TUR", "temps": 10.03},
+    {"nom": "Carla",   "pays": "BRA", "temps": 9.97},
+    {"nom": "Bob",     "pays": "USA", "temps": 9.91},
+    {"nom": "Lena",    "pays": "GER", "temps": 10.11},
+    {"nom": "Kwame",   "pays": "GHA", "temps": 9.99},
+    {"nom": "Sofia",   "pays": "ITA", "temps": 10.07},
+]
+
+def tri_selection_athletes(athletes):
+    """
+    Trie la liste d'athlètes par temps croissant (tri par sélection).
+    Le meilleur (temps le plus bas) sera en premier.
+    """
+    n = len(athletes)
+    for i in range(n):
+        mini = i
+        for j in range(i + 1, n):
+            # TODO : comparer les temps pour trouver le minimum
+            if ...:
+                mini = j
+        athletes[i], athletes[mini] = athletes[mini], athletes[i]
+    return athletes
+
+def afficher_podium(athletes):
+    """Affiche un podium ASCII avec les 3 premiers athlètes."""
+    if len(athletes) < 3:
+        print("Pas assez d'athlètes pour un podium !")
+        return
+
+    or_ = athletes[0]
+    ar_ = athletes[1]
+    br_ = athletes[2]
+
+    print()
+    print("         🥇")
+    print("        ┌───┐         🥈          🥉")
+    print("        │   │        ┌───┐       ┌───┐")
+    print("        │ 1 │        │ 2 │       │ 3 │")
+    print("        │   │        │   │       │   │")
+    print("        └───┘        └───┘       └───┘")
+    print(f"   {or_['nom']:^10} ({or_['pays']})  {ar_['nom']:^10} ({ar_['pays']})  {br_['nom']:^10} ({br_['pays']})")
+    print(f"      {or_['temps']} s          {ar_['temps']} s          {br_['temps']} s")
+    print()
+
+def temps_atteint(temps_liste, t):
+    """
+    Recherche dichotomique : retourne True si le temps t
+    a été réalisé par un athlète, False sinon.
+    La liste temps_liste doit être triée.
+    """
+    a = 0
+    b = len(temps_liste) - 1
+    while a <= b:
+        m = (a + b) // 2
+        if temps_liste[m] == t:
+            return True
+        elif temps_liste[m] < t:
+            # TODO
+            pass
+        else:
+            # TODO
+            pass
+    return False
+
+
+# --- Programme principal ---
+print("=== Compétition de Sprint ===")
+print()
+print("Résultats bruts :")
+for a in athletes:
+    print(f"  {a['nom']} ({a['pays']}) : {a['temps']} s")
+
+tri_selection_athletes(athletes)
+
+afficher_podium(athletes)
+
+# Classement complet
+print("Classement final :")
+for i, a in enumerate(athletes, 1):
+    print(f"  {i}. {a['nom']} ({a['pays']}) — {a['temps']} s")
+
+# Recherche dichotomique
+temps_liste = [a["temps"] for a in athletes]
+print()
+for t in [9.85, 10.00, 9.97]:
+    trouve = temps_atteint(temps_liste, t)
+    print(f"Temps {t}s réalisé ? {'Oui' if trouve else 'Non'}")

algorithmes/mini-projets/03_podium/sujet.md

@@ -0,0 +1,49 @@
+# 03 — Le Podium
+
+**Algorithme :** Tri par sélection
+**Difficulté :** Facile
+**Durée estimée :** 45 min — 1h
+
+---
+
+## Contexte
+
+Vous gérez le classement d'une compétition de sprint. Vous devez trier les athlètes par **temps croissant** (le plus rapide en premier) et afficher le podium.
+
+Le tri par sélection fonctionne comme un vrai classement : à chaque étape, on cherche le meilleur parmi tous les restants et on le place en tête.
+
+---
+
+## Étapes
+
+### Étape 1 — Implémenter `tri_selection_athletes(athletes)`
+La liste `athletes` contient des dictionnaires `{"nom": ..., "pays": ..., "temps": ...}`.
+Il faut trier par `temps` croissant (le plus petit temps = le plus rapide).
+
+> **Indication** : dans le tri par sélection, au lieu de comparer `tab[j] < tab[mini]`, vous comparerez `athletes[j]["temps"] < athletes[mini]["temps"]`.
+
+### Étape 2 — Afficher le podium
+Implémentez `afficher_podium(athletes_tries)` qui affiche les 3 premiers avec un podium en ASCII.
+
+```
+        1er
+       +---+         2e           3e
+       |   |        +---+        +---+
+       | 1 |        | 2 |        | 3 |
+       |   |        |   |        |   |
+       +---+        +---+        +---+
+     Alice (FR)   Bob (USA)  Carla (BR)
+      9.85 s       9.91 s     9.97 s
+```
+
+### Étape 3 — Recherche dichotomique
+Après le tri, créez une liste des temps uniquement. Implémentez `temps_atteint(temps_liste, t)` qui utilise la dichotomie pour dire si un temps exact a été réalisé lors de la compétition.
+
+### Étape 4 — Extension (si vous avez le temps)
+Affichez aussi le classement complet sous forme de tableau numéroté.
+
+---
+
+## Ce que vous devez rendre
+- Le programme qui trie et affiche le podium
+- Réponse : pourquoi le tri par sélection fait-il **moins de déplacements** que le tri par insertion ?