Florian/1ereNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Florian Mathieu
2026-07-07 10:57:59 +02:00
parent 1647035df2
commit 5a6d602a91
51 changed files with 3614 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@@ -44,3 +44,7 @@ news/logs/
*.slides.html *.slides.html
.ipynb_checkpoints/ .ipynb_checkpoints/
*.bak *.bak
# Copies d'élèves (nominatives) — jamais versionnées
**/copies_non_corrigees/
**/copies*/

BIN
algorithmes/mini-projets/01_devine_nombre.zip Normal file
View File

Binary file not shown.

41
algorithmes/mini-projets/01_devine_nombre/starter.py Normal file
View File

@@ -0,0 +1,41 @@
# Projet 01 — Le Nombre Mystère
# Algorithme : Recherche dichotomique
def devine():
"""
L'ordinateur devine le nombre auquel pense l'utilisateur
en utilisant la recherche dichotomique.
"""
print("=== Le Nombre Mystère ===")
print("Pense à un nombre entre 1 et 100 (sans le dire !)")
print("Réponds avec : < (trop grand), > (trop petit), = (trouvé !)")
print()
gauche = 1
droite = 100
nb_essais = 0
while gauche <= droite:
milieu = (gauche + droite) // 2
nb_essais += 1
reponse = input(f"Essai {nb_essais} — Est-ce que ton nombre est {milieu} ? ")
if reponse == "=":
print(f"Trouvé ! C'était bien {milieu}, en {nb_essais} essai(s) !")
return
elif reponse == "<":
# TODO : le nombre cherché est plus petit que milieu
# Que faut-il modifier ? gauche ou droite ?
pass
elif reponse == ">":
# TODO : le nombre cherché est plus grand que milieu
pass
else:
print("Réponse invalide, utilise <, > ou =")
print("Je n'ai pas trouvé... tu as peut-être changé de nombre !")
# --- Programme principal ---
devine()

44
algorithmes/mini-projets/01_devine_nombre/sujet.md Normal file
View File

@@ -0,0 +1,44 @@
# 01 — Le Nombre Mystère
**Algorithme :** Recherche dichotomique
**Difficulté :** Facile
**Durée estimée :** 45 min — 1h
---
## Contexte
Vous pensez à un nombre entre 1 et 100. L'ordinateur doit le deviner le plus vite possible en posant des questions.
À chaque essai, vous répondez :
- `<` si votre nombre est **plus petit** que la proposition
- `>` si votre nombre est **plus grand**
- `=` si c'est **le bon nombre**
L'ordinateur utilise la **recherche dichotomique** : à chaque question, il coupe l'intervalle possible en deux.
---
## Étapes
### Étape 1 — Comprendre la stratégie
Sans coder, répondez sur papier : si le nombre est entre 1 et 100, quelle est la première proposition optimale ? Pourquoi ?
### Étape 2 — Implémenter `devine()`
Complétez la fonction `devine()` dans `starter.py` :
- L'ordinateur part de `gauche = 1` et `droite = 100`
- Il propose `milieu = (gauche + droite) // 2`
- Selon la réponse, il réduit l'intervalle
- Il compte le nombre d'essais
### Étape 3 — Tester
Lancez le programme et jouez plusieurs parties. Vérifiez que l'ordinateur trouve toujours en **7 essais maximum**.
### Étape 4 — Extension (si vous avez le temps)
Ajoutez une deuxième version où **c'est vous** qui devez deviner le nombre de l'ordinateur. L'ordinateur choisit un nombre aléatoire (`random.randint(1, 100)`), et le programme vous dit si vous êtes trop grand ou trop petit. Comptez vos essais et comparez avec le maximum optimal.
---
## Ce que vous devez rendre
- Le programme qui fonctionne
- La réponse à la question : pourquoi 7 essais suffisent toujours pour 100 nombres ?

BIN
algorithmes/mini-projets/02_cartes.zip Normal file
View File

Binary file not shown.

81
algorithmes/mini-projets/02_cartes/starter.py Normal file
View File

@@ -0,0 +1,81 @@
# Projet 02 — Le Tri de Cartes
# Algorithme : Tri par insertion
NOMS_VALEURS = {11: "Valet", 12: "Dame", 13: "Roi", 14: "As"}
def nom_carte(carte):
"""Retourne une représentation lisible d'une carte."""
valeur, couleur = carte
nom = NOMS_VALEURS.get(valeur, str(valeur))
return f"{nom} de {couleur}"
def afficher_main(main):
"""Affiche toutes les cartes d'une main."""
print("Main :", " | ".join(nom_carte(c) for c in main))
def tri_insertion_cartes(main):
"""
Trie la main de cartes par valeur croissante (tri par insertion).
Chaque carte est un tuple (valeur, couleur).
On trie selon le premier élément du tuple : la valeur.
"""
for i in range(1, len(main)):
x = main[i]
j = i
# TODO : compléter la condition du while
# Indice : on compare les valeurs (main[j-1][0] et x[0])
while j > 0 and ...:
main[j] = main[j - 1]
j -= 1
main[j] = x
return main
def chercher_carte(main_triee, valeur):
"""
Recherche dichotomique : retourne True si une carte de cette valeur
est dans la main triée, False sinon.
"""
a = 0
b = len(main_triee) - 1
while a <= b:
m = (a + b) // 2
valeur_m = main_triee[m][0] # on compare les valeurs
if valeur_m == valeur:
return True
elif valeur_m < valeur:
# TODO
pass
else:
# TODO
pass
return False
# --- Programme principal ---
main = [
(7, "Coeur"),
(2, "Pique"),
(11, "Trèfle"),
(5, "Carreau"),
(14, "Coeur"),
(9, "Pique"),
(3, "Carreau"),
]
print("=== Le Tri de Cartes ===")
print()
print("Avant le tri :")
afficher_main(main)
tri_insertion_cartes(main)
print()
print("Après le tri par insertion :")
afficher_main(main)
print()
# Test de recherche
for valeur_cherchee in [7, 12, 14, 6]:
resultat = chercher_carte(main, valeur_cherchee)
nom = NOMS_VALEURS.get(valeur_cherchee, str(valeur_cherchee))
print(f"Cherche {nom} : {'trouvé !' if resultat else 'absent'}")

39
algorithmes/mini-projets/02_cartes/sujet.md Normal file
View File

@@ -0,0 +1,39 @@
# 02 — Le Tri de Cartes
**Algorithme :** Tri par insertion
**Difficulté :** Facile
**Durée estimée :** 45 min — 1h
---
## Contexte
Lorsqu'on reçoit des cartes à jouer, on les trie naturellement dans sa main : on prend chaque nouvelle carte et on la glisse à la bonne place parmi celles déjà en ordre. C'est exactement le **tri par insertion**.
Dans ce projet, vous allez trier une main de cartes par valeur croissante, puis chercher une carte avec la dichotomie.
---
## Étapes
### Étape 1 — Afficher la main
Lancez le starter et observez comment les cartes sont représentées. Chaque carte est un **tuple** `(valeur, couleur)`. La valeur va de 2 à 14 (11 = Valet, 12 = Dame, 13 = Roi, 14 = As).
### Étape 2 — Implémenter `tri_insertion_cartes(main)`
Le tri doit classer les cartes par **valeur croissante** (le premier élément du tuple).
> **Indication** : dans le tri par insertion vu en cours, on comparait `tab[j-1] > x`. Ici, vous comparerez `main[j-1][0] > x[0]` (on ne regarde que la valeur, pas la couleur).
### Étape 3 — Chercher une carte
Implémentez `chercher_carte(main_triee, valeur)` qui utilise la **dichotomie** pour savoir si une carte d'une certaine valeur est dans la main.
> **Attention** : la dichotomie ne fonctionne que sur une liste **déjà triée** !
### Étape 4 — Extension (si vous avez le temps)
Ajoutez un mode "nouvelle donne" : générez une main aléatoire de 7 cartes avec `random`, triez-la et affichez-la.
---
## Ce que vous devez rendre
- Le programme qui trie et cherche correctement
- Une explication : pourquoi le tri par insertion ressemble à ce qu'on fait naturellement avec des cartes ?

BIN
algorithmes/mini-projets/03_podium.zip Normal file
View File

Binary file not shown.

93
algorithmes/mini-projets/03_podium/starter.py Normal file
View File

@@ -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'}")

49
algorithmes/mini-projets/03_podium/sujet.md Normal file
View File

@@ -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 ?

BIN
algorithmes/mini-projets/04_annuaire.zip Normal file
View File

Binary file not shown.

88
algorithmes/mini-projets/04_annuaire/starter.py Normal file
View File

@@ -0,0 +1,88 @@
# Projet 04 — L'Annuaire
# Algorithmes : Tri par insertion + Recherche dichotomique
# L'annuaire est une liste de dictionnaires, toujours triée par "nom"
annuaire = [
{"nom": "Dupont", "prenom": "Alice", "tel": "06 11 22 33 44"},
{"nom": "Garcia", "prenom": "Carlos", "tel": "07 55 66 77 88"},
{"nom": "Martin", "prenom": "Sophie", "tel": "06 99 88 77 66"},
{"nom": "Petit", "prenom": "Luc", "tel": "07 12 34 56 78"},
{"nom": "Rousseau", "prenom": "Emma", "tel": "06 44 55 66 77"},
]
def afficher_annuaire(annuaire):
"""Affiche tous les contacts sous forme de tableau."""
print(f"\n{'Nom':<15} {'Prénom':<12} {'Téléphone'}")
print("-" * 40)
for contact in annuaire:
print(f"{contact['nom']:<15} {contact['prenom']:<12} {contact['tel']}")
print()
def ajouter_contact(annuaire, contact):
"""
Insère le contact à la bonne place pour maintenir l'ordre alphabétique.
Principe : tri par insertion (un seul élément à insérer).
"""
annuaire.append(contact) # on l'ajoute à la fin temporairement
j = len(annuaire) - 1
# TODO : décaler vers la droite tant que le nom précédent est > au nom du contact
# Indice : comparer annuaire[j-1]["nom"] et contact["nom"]
while j > 0 and ...:
annuaire[j] = annuaire[j - 1]
j -= 1
annuaire[j] = contact
def rechercher(annuaire, nom):
"""
Recherche dichotomique par nom.
Retourne le contact (dict) si trouvé, None sinon.
"""
a = 0
b = len(annuaire) - 1
while a <= b:
m = (a + b) // 2
nom_m = annuaire[m]["nom"]
if nom_m == nom:
return annuaire[m]
elif nom_m < nom:
# TODO
pass
else:
# TODO
pass
return None
def menu():
"""Boucle de menu interactif."""
while True:
print("=== Annuaire ===")
print("1 — Afficher tous les contacts")
print("2 — Ajouter un contact")
print("3 — Rechercher un contact")
print("4 — Quitter")
choix = input("Votre choix : ")
if choix == "1":
afficher_annuaire(annuaire)
elif choix == "2":
nom = input("Nom : ").strip().capitalize()
prenom = input("Prénom : ").strip().capitalize()
tel = input("Téléphone : ").strip()
ajouter_contact(annuaire, {"nom": nom, "prenom": prenom, "tel": tel})
print(f"{nom} ajouté !")
elif choix == "3":
nom = input("Nom à rechercher : ").strip().capitalize()
# TODO : appeler rechercher() et afficher le résultat
pass
elif choix == "4":
print("Au revoir !")
break
else:
print("Choix invalide.")
# --- Programme principal ---
menu()

46
algorithmes/mini-projets/04_annuaire/sujet.md Normal file
View File

@@ -0,0 +1,46 @@
# 04 — L'Annuaire
**Algorithmes :** Tri par insertion + Recherche dichotomique
**Difficulté :** Moyen
**Durée estimée :** 1h — 1h15
---
## Contexte
Vous créez un mini-annuaire de contacts. Il doit toujours rester **trié par nom** pour que la recherche dichotomique fonctionne.
Chaque fois qu'on ajoute un contact, on l'insère directement à la bonne place (comme dans le tri par insertion). Chaque fois qu'on cherche, on utilise la dichotomie.
---
## Étapes
### Étape 1 — Afficher l'annuaire
Lancez le starter, vérifiez que `afficher_annuaire()` fonctionne.
### Étape 2 — Implémenter `ajouter_contact(annuaire, contact)`
Cette fonction insère le nouveau contact **à la bonne position** pour maintenir l'ordre alphabétique.
> **Indication** : c'est le principe du tri par insertion, mais appliqué à un seul élément. On parcourt depuis la fin et on décale les contacts dont le nom est alphabétiquement après le nouveau.
>
> Pour comparer des chaînes alphabétiquement en Python : `"Dupont" < "Martin"` → `True`
### Étape 3 — Implémenter `rechercher(annuaire, nom)`
Recherche dichotomique : retourne le contact (dictionnaire complet) si trouvé, `None` sinon.
### Étape 4 — Menu interactif
Complétez la boucle `menu()` pour que l'utilisateur puisse :
- `1` — Afficher tous les contacts
- `2` — Ajouter un contact
- `3` — Rechercher un contact par nom
- `4` — Quitter
### Étape 5 — Extension (si vous avez le temps)
Ajoutez une option `5` pour supprimer un contact par nom (cherchez-le d'abord avec la dichotomie, puis supprimez-le de la liste).
---
## Ce que vous devez rendre
- Le programme avec le menu fonctionnel
- Réponse : dans quel cas la dichotomie est-elle inutilisable directement ?

BIN
algorithmes/mini-projets/05_correcteur.zip Normal file
View File

Binary file not shown.

111
algorithmes/mini-projets/05_correcteur/starter.py Normal file
View File

@@ -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)

50
algorithmes/mini-projets/05_correcteur/sujet.md Normal file
View File

@@ -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 ?

BIN
algorithmes/mini-projets/06_bibliotheque.zip Normal file
View File

Binary file not shown.

93
algorithmes/mini-projets/06_bibliotheque/starter.py Normal file
View File

@@ -0,0 +1,93 @@
# Projet 06 — La Bibliothèque
# Algorithmes : Tri par sélection + Recherche dichotomique
livres = [
{"titre": "le seigneur des anneaux", "auteur": "tolkien", "annee": 1954, "genre": "Fantasy", "pages": 1200},
{"titre": "1984", "auteur": "orwell", "annee": 1949, "genre": "Dystopie", "pages": 328},
{"titre": "dune", "auteur": "herbert", "annee": 1965, "genre": "SF", "pages": 688},
{"titre": "le petit prince", "auteur": "exupery", "annee": 1943, "genre": "Conte", "pages": 96},
{"titre": "fondation", "auteur": "asimov", "annee": 1951, "genre": "SF", "pages": 255},
{"titre": "harry potter t1", "auteur": "rowling", "annee": 1997, "genre": "Fantasy", "pages": 309},
{"titre": "fahrenheit 451", "auteur": "bradbury", "annee": 1953, "genre": "Dystopie", "pages": 158},
{"titre": "l'etranger", "auteur": "camus", "annee": 1942, "genre": "Littérature","pages": 123},
{"titre": "neuromancien", "auteur": "gibson", "annee": 1984, "genre": "SF", "pages": 271},
{"titre": "brave new world", "auteur": "huxley", "annee": 1932, "genre": "Dystopie", "pages": 311},
]
def afficher_catalogue(livres):
"""Affiche le catalogue sous forme de liste numérotée."""
print(f"\n {'Titre':<30} {'Auteur':<12} {'Année':>5} {'Pages':>6}")
print(" " + "-" * 58)
for i, l in enumerate(livres, 1):
print(f" {i:>2}. {l['titre']:<30} {l['auteur']:<12} {l['annee']:>5} {l['pages']:>6} p.")
print()
def afficher_fiche(livre):
"""Affiche la fiche complète d'un livre."""
# TODO : afficher toutes les informations du livre de façon lisible
pass
def tri_selection_livres(livres):
"""Trie les livres par titre alphabétique (tri par sélection)."""
n = len(livres)
for i in range(n):
mini = i
for j in range(i + 1, n):
# TODO : comparer les titres
if ...:
mini = j
livres[i], livres[mini] = livres[mini], livres[i]
return livres
def rechercher_titre(livres_tries, titre):
"""
Recherche dichotomique par titre exact (en minuscules).
Retourne le livre si trouvé, None sinon.
"""
a = 0
b = len(livres_tries) - 1
while a <= b:
m = (a + b) // 2
titre_m = livres_tries[m]["titre"]
if titre_m == titre:
return livres_tries[m]
elif titre_m < titre:
# TODO
pass
else:
# TODO
pass
return None
def statistiques(livres):
"""Affiche des statistiques sur le catalogue."""
n = len(livres)
total_pages = sum(l["pages"] for l in livres)
# TODO : trouver le livre avec le moins de pages et le plus de pages
# Indice : utilise ton tri par sélection sur une copie triée par pages !
print(f"\nStatistiques du catalogue ({n} livres) :")
print(f" Moyenne de pages : {total_pages // n} pages")
# TODO : afficher le plus court et le plus long
# --- Programme principal ---
print("=== Catalogue de la Bibliothèque ===")
print("\nAvant tri :")
afficher_catalogue(livres)
tri_selection_livres(livres)
print("Après tri alphabétique :")
afficher_catalogue(livres)
# Tests de recherche
print("Recherches :")
for titre in ["1984", "dune", "le comte de monte cristo"]:
resultat = rechercher_titre(livres, titre)
if resultat:
print(f" '{titre}' → trouvé !")
afficher_fiche(resultat)
else:
print(f" '{titre}' → absent du catalogue")
statistiques(livres)

45
algorithmes/mini-projets/06_bibliotheque/sujet.md Normal file
View File

@@ -0,0 +1,45 @@
# 06 — La Bibliothèque
**Algorithmes :** Tri par sélection + Recherche dichotomique
**Difficulté :** Moyen
**Durée estimée :** 1h — 1h15
---
## Contexte
Vous gérez le catalogue d'une bibliothèque. Les livres doivent être triés par **titre alphabétique** pour qu'on puisse les retrouver rapidement. Vous utiliserez le tri par sélection pour trier, et la dichotomie pour chercher.
---
## Étapes
### Étape 1 — Trier par titre
Implémentez `tri_selection_livres(livres)` qui trie par `"titre"` (ordre alphabétique).
> **Rappel** : en Python, `"Alice" < "Zorro"` → `True`. Vous pouvez comparer des chaînes directement.
### Étape 2 — Recherche dichotomique
Implémentez `rechercher_titre(livres_tries, titre)` qui retourne le livre si trouvé, `None` sinon.
> **Attention** : la comparaison doit être exacte (majuscules comprises). Pour simplifier, tout est déjà en minuscules dans les données.
### Étape 3 — Affichage enrichi
Implémentez `afficher_fiche(livre)` qui affiche toutes les informations d'un livre de façon lisible (titre, auteur, année, genre, pages).
### Étape 4 — Statistiques
Ajoutez une fonction `statistiques(livres)` qui affiche :
- Le nombre de livres
- Le livre le plus court et le plus long (en pages)
- La moyenne de pages
> **Indication** : une fois la liste triée par titre, vous pouvez utiliser une boucle simple pour les stats. Ou bien trier une copie par pages avec votre tri !
### Étape 5 — Extension (si vous avez le temps)
Ajoutez la possibilité de trier aussi par **année** ou par **nombre de pages**, et de rechercher tous les livres d'un **même auteur** (recherche linéaire cette fois — pourquoi ne peut-on pas utiliser la dichotomie ici ?).
---
## Ce que vous devez rendre
- Le programme fonctionnel
- Réponse : pour chercher tous les livres d'un auteur, pourquoi la dichotomie est-elle inadaptée ?

109
algorithmes/mini-projets/07_meteo 2/starter.py Normal file
View File

@@ -0,0 +1,109 @@
# Projet 07 — La Météo
# Algorithmes : Tri par insertion + Recherche dichotomique
# Relevés du mois de mars : (numéro du jour, température en °C)
releves = [
(1, 12.3), (2, 8.7), (3, 14.1), (4, 11.5), (5, 9.2),
(6, 7.8), (7, 13.4), (8, 15.6), (9, 10.1), (10, 6.5),
(11, 5.2), (12, 9.8), (13, 12.7),(14, 16.3),(15, 18.1),
(16, 14.5),(17, 11.2),(18, 8.9), (19, 7.3), (20, 10.5),
(21, 13.8),(22, 17.2),(23, 19.4),(24, 15.1),(25, 12.0),
(26, 9.5), (27, 11.8),(28, 14.2),(29, 16.7),(30, 18.9),
(31, 13.3),
]
def afficher_releves(releves, nb=10):
"""Affiche les nb premiers relevés."""
print(f"\n {'Jour':>5} {'Température':>12}")
print(" " + "-" * 20)
for jour, temp in releves[:nb]:
print(f" Jour {jour:>2} {temp:>8.1f} °C")
if len(releves) > nb:
print(f" ... ({len(releves) - nb} relevés supplémentaires)")
print()
def tri_insertion_temperatures(tab):
"""
Trie les relevés par température croissante (tri par insertion).
Chaque élément est un tuple (jour, temperature).
On trie selon le deuxième élément du tuple.
"""
for i in range(1, len(tab)):
x = tab[i]
j = i
# TODO : comparer tab[j-1][1] et x[1]
while j > 0 and ...:
tab[j] = tab[j - 1]
j -= 1
tab[j] = x
return tab
def statistiques(tab_trie):
"""Affiche les statistiques à partir des relevés triés."""
n = len(tab_trie)
min_releve = tab_trie[0]
max_releve = tab_trie[n - 1]
mediane = tab_trie[n // 2]
print("Statistiques du mois :")
print(f" Minimum : {min_releve[1]:.1f} °C (jour {min_releve[0]})")
print(f" Maximum : {max_releve[1]:.1f} °C (jour {max_releve[0]})")
print(f" Médiane : {mediane[1]:.1f} °C (jour {mediane[0]})")
# TODO : ajouter la moyenne
print()
def temperature_atteinte(tab_trie, t):
"""
Recherche dichotomique : retourne True si la température t
a été relevée au cours du mois (comparaison exacte).
"""
a = 0
b = len(tab_trie) - 1
while a <= b:
m = (a + b) // 2
temp_m = tab_trie[m][1]
if temp_m == t:
return True
elif temp_m < t:
# TODO
pass
else:
# TODO
pass
return False
def histogramme(tab_trie):
"""Affiche un histogramme horizontal des températures (arrondi à l'entier)."""
# Compter les occurrences par degré entier
compteur = {}
for _, temp in tab_trie:
degre = int(temp)
compteur[degre] = compteur.get(degre, 0) + 1
print("Histogramme des températures :")
for degre in sorted(compteur):
barre = "█" * compteur[degre]
print(f" {degre:>3}°C | {barre} ({compteur[degre]})")
print()
# --- Programme principal ---
print("=== Analyse Météo — Mars ===")
print("\nRelevés originaux (10 premiers) :")
afficher_releves(releves, nb=5)
# Trier une copie pour ne pas perdre l'ordre chronologique
releves_tries = releves[:]
tri_insertion_temperatures(releves_tries)
print("Relevés triés par température :")
afficher_releves(releves_tries, nb=5)
statistiques(releves_tries)
histogramme(releves_tries)
# Tests de recherche
print("Recherches :")
for t in [5.2, 15.0, 19.4, 20.0]:
present = temperature_atteinte(releves_tries, t)
print(f" {t}°C relevé ce mois-ci ? {'Oui' if present else 'Non'}")

54
algorithmes/mini-projets/07_meteo 2/sujet.md Normal file
View File

@@ -0,0 +1,54 @@
# 07 — La Météo
**Algorithmes :** Tri par insertion + Recherche dichotomique
**Difficulté :** Moyen
**Durée estimée :** 1h — 1h15
---
## Contexte
Vous analysez les relevés de température d'un mois complet. Vous voulez les trier, calculer des statistiques, et savoir rapidement si une température précise a été atteinte ce mois-ci.
---
## Étapes
### Étape 1 — Trier les températures
Implémentez `tri_insertion_temperatures(tab)` qui trie la liste de relevés par **température croissante**.
Chaque relevé est un tuple `(jour, temperature)`. On trie selon la température (le deuxième élément).
> **Indication** : comparez `tab[j-1][1]` et `x[1]` (le deuxième élément du tuple).
### Étape 2 — Statistiques de base
Implémentez `statistiques(tab_trie)` qui affiche :
- La température **minimale** et le jour où elle a été relevée
- La température **maximale** et le jour où elle a été relevée
- La **médiane** (la valeur au milieu une fois triée)
> Rappel : la médiane d'une liste triée de taille n est à l'indice `n // 2`.
### Étape 3 — Recherche dichotomique
Implémentez `temperature_atteinte(tab_trie, t)` : retourne `True` si la température `t` a été relevée, `False` sinon.
> **Attention** : les relevés sont triés par température. La dichotomie doit comparer `tab[m][1]` (la valeur) avec `t`.
### Étape 4 — Visualisation ASCII
Implémentez `histogramme(tab_trie)` qui affiche un histogramme horizontal des températures.
```
5°C | ##
10°C | #####
15°C | ########
...
```
### Étape 5 — Extension (si vous avez le temps)
Ajoutez une fonction qui regroupe les relevés par **tranche de 5°C** et compte combien de jours tombent dans chaque tranche.
---
## Ce que vous devez rendre
- Le programme complet avec statistiques et recherche
- Réponse : pourquoi le tri par insertion est-il particulièrement efficace si les données sont **déjà presque triées** ?

BIN
algorithmes/mini-projets/07_meteo.zip Normal file
View File

Binary file not shown.

109
algorithmes/mini-projets/07_meteo/starter.py Normal file
View File

@@ -0,0 +1,109 @@
# Projet 07 — La Météo
# Algorithmes : Tri par insertion + Recherche dichotomique
# Relevés du mois de mars : (numéro du jour, température en °C)
releves = [
(1, 12.3), (2, 8.7), (3, 14.1), (4, 11.5), (5, 9.2),
(6, 7.8), (7, 13.4), (8, 15.6), (9, 10.1), (10, 6.5),
(11, 5.2), (12, 9.8), (13, 12.7),(14, 16.3),(15, 18.1),
(16, 14.5),(17, 11.2),(18, 8.9), (19, 7.3), (20, 10.5),
(21, 13.8),(22, 17.2),(23, 19.4),(24, 15.1),(25, 12.0),
(26, 9.5), (27, 11.8),(28, 14.2),(29, 16.7),(30, 18.9),
(31, 13.3),
]
def afficher_releves(releves, nb=10):
"""Affiche les nb premiers relevés."""
print(f"\n {'Jour':>5} {'Température':>12}")
print(" " + "-" * 20)
for jour, temp in releves[:nb]:
print(f" Jour {jour:>2} {temp:>8.1f} °C")
if len(releves) > nb:
print(f" ... ({len(releves) - nb} relevés supplémentaires)")
print()
def tri_insertion_temperatures(tab):
"""
Trie les relevés par température croissante (tri par insertion).
Chaque élément est un tuple (jour, temperature).
On trie selon le deuxième élément du tuple.
"""
for i in range(1, len(tab)):
x = tab[i]
j = i
# TODO : comparer tab[j-1][1] et x[1]
while j > 0 and ...:
tab[j] = tab[j - 1]
j -= 1
tab[j] = x
return tab
def statistiques(tab_trie):
"""Affiche les statistiques à partir des relevés triés."""
n = len(tab_trie)
min_releve = tab_trie[0]
max_releve = tab_trie[n - 1]
mediane = tab_trie[n // 2]
print("Statistiques du mois :")
print(f" Minimum : {min_releve[1]:.1f} °C (jour {min_releve[0]})")
print(f" Maximum : {max_releve[1]:.1f} °C (jour {max_releve[0]})")
print(f" Médiane : {mediane[1]:.1f} °C (jour {mediane[0]})")
# TODO : ajouter la moyenne
print()
def temperature_atteinte(tab_trie, t):
"""
Recherche dichotomique : retourne True si la température t
a été relevée au cours du mois (comparaison exacte).
"""
a = 0
b = len(tab_trie) - 1
while a <= b:
m = (a + b) // 2
temp_m = tab_trie[m][1]
if temp_m == t:
return True
elif temp_m < t:
# TODO
pass
else:
# TODO
pass
return False
def histogramme(tab_trie):
"""Affiche un histogramme horizontal des températures (arrondi à l'entier)."""
# Compter les occurrences par degré entier
compteur = {}
for _, temp in tab_trie:
degre = int(temp)
compteur[degre] = compteur.get(degre, 0) + 1
print("Histogramme des températures :")
for degre in sorted(compteur):
barre = "█" * compteur[degre]
print(f" {degre:>3}°C | {barre} ({compteur[degre]})")
print()
# --- Programme principal ---
print("=== Analyse Météo — Mars ===")
print("\nRelevés originaux (10 premiers) :")
afficher_releves(releves, nb=5)
# Trier une copie pour ne pas perdre l'ordre chronologique
releves_tries = releves[:]
tri_insertion_temperatures(releves_tries)
print("Relevés triés par température :")
afficher_releves(releves_tries, nb=5)
statistiques(releves_tries)
histogramme(releves_tries)
# Tests de recherche
print("Recherches :")
for t in [5.2, 15.0, 19.4, 20.0]:
present = temperature_atteinte(releves_tries, t)
print(f" {t}°C relevé ce mois-ci ? {'Oui' if present else 'Non'}")

54
algorithmes/mini-projets/07_meteo/sujet.md Normal file
View File

@@ -0,0 +1,54 @@
# 07 — La Météo
**Algorithmes :** Tri par insertion + Recherche dichotomique
**Difficulté :** Moyen
**Durée estimée :** 1h — 1h15
---
## Contexte
Vous analysez les relevés de température d'un mois complet. Vous voulez les trier, calculer des statistiques, et savoir rapidement si une température précise a été atteinte ce mois-ci.
---
## Étapes
### Étape 1 — Trier les températures
Implémentez `tri_insertion_temperatures(tab)` qui trie la liste de relevés par **température croissante**.
Chaque relevé est un tuple `(jour, temperature)`. On trie selon la température (le deuxième élément).
> **Indication** : comparez `tab[j-1][1]` et `x[1]` (le deuxième élément du tuple).
### Étape 2 — Statistiques de base
Implémentez `statistiques(tab_trie)` qui affiche :
- La température **minimale** et le jour où elle a été relevée
- La température **maximale** et le jour où elle a été relevée
- La **médiane** (la valeur au milieu une fois triée)
> Rappel : la médiane d'une liste triée de taille n est à l'indice `n // 2`.
### Étape 3 — Recherche dichotomique
Implémentez `temperature_atteinte(tab_trie, t)` : retourne `True` si la température `t` a été relevée, `False` sinon.
> **Attention** : les relevés sont triés par température. La dichotomie doit comparer `tab[m][1]` (la valeur) avec `t`.
### Étape 4 — Visualisation ASCII
Implémentez `histogramme(tab_trie)` qui affiche un histogramme horizontal des températures.
```
5°C | ##
10°C | #####
15°C | ########
...
```
### Étape 5 — Extension (si vous avez le temps)
Ajoutez une fonction qui regroupe les relevés par **tranche de 5°C** et compte combien de jours tombent dans chaque tranche.
---
## Ce que vous devez rendre
- Le programme complet avec statistiques et recherche
- Réponse : pourquoi le tri par insertion est-il particulièrement efficace si les données sont **déjà presque triées** ?

BIN
algorithmes/mini-projets/08_course_algos.zip Normal file
View File

Binary file not shown.

92
algorithmes/mini-projets/08_course_algos/starter.py Normal file
View File

@@ -0,0 +1,92 @@
# Projet 08 — La Course des Algorithmes
# Comparer les performances du tri par insertion et du tri par sélection
import random
import time
# -------------------------------------------------------
# Étape 1 : recopie ici tes deux fonctions de tri
# -------------------------------------------------------
def tri_insertion(tab):
# TODO : recopier depuis le cours
pass
def tri_selection(tab):
# TODO : recopier depuis le cours
pass
# -------------------------------------------------------
# Outils de mesure (déjà fournis)
# -------------------------------------------------------
def mesurer_temps(fonction, tab):
"""
Mesure le temps d'exécution de fonction(tab) en millisecondes.
Travaille sur une copie pour ne pas modifier l'original.
"""
copie = tab[:]
debut = time.time()
fonction(copie)
fin = time.time()
return round((fin - debut) * 1000, 3) # résultat en ms
def generer_liste(n, mode="aleatoire"):
"""
Génère une liste de n entiers selon le mode :
- "aleatoire" : ordre aléatoire
- "trie" : déjà triée (croissant)
- "inverse" : triée à l'envers (décroissant)
"""
if mode == "aleatoire":
return random.sample(range(n * 10), n)
elif mode == "trie":
return list(range(n))
elif mode == "inverse":
return list(range(n, 0, -1))
# -------------------------------------------------------
# Étape 3 : tableau comparatif selon la taille
# -------------------------------------------------------
def comparer_tailles():
tailles = [100, 500, 1000, 2000, 5000]
print("=== Comparaison par taille (liste aléatoire) ===\n")
print(f" {'n':>6} {'Insertion (ms)':>16} {'Sélection (ms)':>16} {'Vainqueur':>10}")
print(" " + "-" * 55)
for n in tailles:
liste = generer_liste(n, "aleatoire")
t_insertion = mesurer_temps(tri_insertion, liste)
t_selection = mesurer_temps(tri_selection, liste)
vainqueur = "Insertion" if t_insertion < t_selection else "Sélection"
print(f" {n:>6} {t_insertion:>16.3f} {t_selection:>16.3f} {vainqueur:>10}")
print()
# -------------------------------------------------------
# Étape 4 : tableau comparatif selon le mode (n fixé)
# -------------------------------------------------------
def comparer_modes(n=1000):
modes = ["aleatoire", "trie", "inverse"]
print(f"=== Comparaison par configuration (n = {n}) ===\n")
print(f" {'Mode':<12} {'Insertion (ms)':>16} {'Sélection (ms)':>16} {'Vainqueur':>10}")
print(" " + "-" * 60)
for mode in modes:
liste = generer_liste(n, mode)
t_insertion = mesurer_temps(tri_insertion, liste)
t_selection = mesurer_temps(tri_selection, liste)
vainqueur = "Insertion" if t_insertion < t_selection else "Sélection"
print(f" {mode:<12} {t_insertion:>16.3f} {t_selection:>16.3f} {vainqueur:>10}")
print()
# -------------------------------------------------------
# Programme principal
# -------------------------------------------------------
comparer_tailles()
comparer_modes(n=1000)
print("Conclusion :")
print(" TODO : écris tes observations ici")

49
algorithmes/mini-projets/08_course_algos/sujet.md Normal file
View File

@@ -0,0 +1,49 @@
# 08 — La Course des Algorithmes
**Algorithmes :** Tri par insertion vs Tri par sélection (comparaison)
**Difficulté :** Difficile
**Durée estimée :** 1h15 — 1h30
---
## Contexte
On sait que les deux tris ont une complexité **quadratique** (O(n²)) dans le pire des cas. Mais en pratique, se comportent-ils vraiment pareil ? C'est ce que vous allez mesurer.
Vous allez tester les deux algorithmes sur différentes tailles de listes et dans différentes configurations, afficher les résultats et tirer des conclusions.
---
## Étapes
### Étape 1 — Copier les deux tris
Recopiez dans le starter vos fonctions `tri_insertion(tab)` et `tri_selection(tab)` qui fonctionnent sur des listes d'entiers.
### Étape 2 — Mesurer le temps
La fonction `mesurer_temps(fonction, tab)` est déjà fournie. Elle prend une **copie** de la liste pour ne pas la modifier et mesure le temps en millisecondes.
> **Important** : toujours travailler sur une **copie** (`tab[:]`) pour que les deux algos partent du même état.
### Étape 3 — Tester sur différentes tailles
Testez pour `n ∈ [100, 500, 1000, 2000, 5000]` avec une liste **aléatoire**. Affichez un tableau comparatif.
### Étape 4 — Tester les cas particuliers
Pour `n = 1000`, testez :
- Liste aléatoire
- Liste **déjà triée** (croissant)
- Liste **triée à l'envers** (décroissant)
Affichez les résultats. Quel algorithme est avantagé selon le cas ?
### Étape 5 — Tracer un graphique (extension)
Si vous connaissez `matplotlib`, tracez les courbes de temps en fonction de n pour les deux algorithmes.
```python
import matplotlib.pyplot as plt
```
---
## Ce que vous devez rendre
- Le programme avec le tableau comparatif
- Une conclusion écrite : dans quels cas préférez-vous le tri par insertion ? Le tri par sélection ? Justifiez avec vos mesures.

BIN
algorithmes/mini-projets/09_generateur_web.zip Normal file
View File

Binary file not shown.

163
algorithmes/mini-projets/09_generateur_web/starter.py Normal file
View File

@@ -0,0 +1,163 @@
# Projet 09 — Le Générateur Web
# Algorithmes : Tri par insertion + Dichotomie → page HTML/CSS
import webbrowser
jeux = [
{"titre": "The Legend of Zelda: BotW", "studio": "Nintendo", "annee": 2017, "score": 97},
{"titre": "Red Dead Redemption 2", "studio": "Rockstar", "annee": 2018, "score": 97},
{"titre": "Grand Theft Auto V", "studio": "Rockstar", "annee": 2013, "score": 97},
{"titre": "The Witcher 3", "studio": "CD Projekt", "annee": 2015, "score": 93},
{"titre": "Elden Ring", "studio": "FromSoftware", "annee": 2022, "score": 96},
{"titre": "Minecraft", "studio": "Mojang", "annee": 2011, "score": 93},
{"titre": "Portal 2", "studio": "Valve", "annee": 2011, "score": 95},
{"titre": "Hollow Knight", "studio": "Team Cherry", "annee": 2017, "score": 90},
{"titre": "Hades", "studio": "Supergiant", "annee": 2020, "score": 93},
{"titre": "Celeste", "studio": "Maddy Makes", "annee": 2018, "score": 94},
{"titre": "Disco Elysium", "studio": "ZA/UM", "annee": 2019, "score": 97},
{"titre": "Death Stranding", "studio": "Kojima Prod.", "annee": 2019, "score": 82},
]
def tri_insertion_jeux(jeux):
"""
Trie les jeux par score DÉCROISSANT (tri par insertion).
Le meilleur score doit être en premier.
"""
for i in range(1, len(jeux)):
x = jeux[i]
j = i
# TODO : condition pour trier par ordre décroissant
# Indice : pour l'ordre décroissant, on décale quand le score précédent est INFÉRIEUR
while j > 0 and ...:
jeux[j] = jeux[j - 1]
j -= 1
jeux[j] = x
return jeux
def rechercher_score(jeux_tries, score):
"""
Recherche dichotomique d'un jeu par score exact.
ATTENTION : la liste est triée par score DÉCROISSANT.
Les comparaisons < et > sont inversées par rapport au cours !
"""
a = 0
b = len(jeux_tries) - 1
while a <= b:
m = (a + b) // 2
score_m = jeux_tries[m]["score"]
if score_m == score:
return jeux_tries[m]
elif score_m > score:
# Le score du milieu est trop grand → chercher à droite
# TODO
pass
else:
# Le score du milieu est trop petit → chercher à gauche
# TODO
pass
return None
def generer_html(jeux_tries, fichier="classement.html"):
"""Génère une page HTML affichant le classement."""
COULEURS_PODIUM = ["#FFD700", "#C0C0C0", "#CD7F32"] # or, argent, bronze
lignes_html = ""
for i, jeu in enumerate(jeux_tries, 1):
if i <= 3:
bg = f'style="background-color: {COULEURS_PODIUM[i-1]}; font-weight: bold;"'
else:
bg = 'style="background-color: #f9f9f9;"' if i % 2 == 0 else ""
lignes_html += f"""
<tr {bg}>
<td>{i}</td>
<td>{jeu['titre']}</td>
<td>{jeu['studio']}</td>
<td>{jeu['annee']}</td>
<td>{jeu['score']}/100</td>
</tr>"""
html = f"""<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Top Jeux Vidéo</title>
<style>
body {{
font-family: Arial, sans-serif;
max-width: 800px;
margin: 40px auto;
background: #1a1a2e;
color: #eee;
}}
h1 {{
text-align: center;
color: #FFD700;
font-size: 2em;
}}
table {{
width: 100%;
border-collapse: collapse;
background: white;
color: #333;
border-radius: 8px;
overflow: hidden;
box-shadow: 0 4px 20px rgba(0,0,0,0.5);
}}
th {{
background: #16213e;
color: white;
padding: 12px 16px;
text-align: left;
}}
td {{
padding: 10px 16px;
border-bottom: 1px solid #ddd;
}}
tr:last-child td {{ border-bottom: none; }}
</style>
</head>
<body>
<h1>🎮 Classement des meilleurs jeux</h1>
<table>
<thead>
<tr>
<th>#</th>
<th>Titre</th>
<th>Studio</th>
<th>Année</th>
<th>Score</th>
</tr>
</thead>
<tbody>
{lignes_html}
</tbody>
</table>
<p style="text-align:center; margin-top:20px; color:#aaa;">
Généré par Python avec tri par insertion — NSI Première
</p>
</body>
</html>"""
with open(fichier, "w", encoding="utf-8") as f:
f.write(html)
print(f"Page générée : {fichier}")
# --- Programme principal ---
print("=== Générateur de classement HTML ===")
tri_insertion_jeux(jeux)
print("Classement (5 premiers) :")
for i, jeu in enumerate(jeux[:5], 1):
print(f" {i}. {jeu['titre']} — {jeu['score']}/100")
# Recherche
jeu_trouve = rechercher_score(jeux, 95)
if jeu_trouve:
print(f"\nJeu avec score 95 : {jeu_trouve['titre']}")
# Génération HTML
generer_html(jeux)
webbrowser.open("classement.html")

51
algorithmes/mini-projets/09_generateur_web/sujet.md Normal file
View File

@@ -0,0 +1,51 @@
# 09 — Le Générateur Web
**Algorithmes :** Tri par insertion + Recherche dichotomique → génération HTML/CSS
**Difficulté :** Difficile
**Durée estimée :** 1h15 — 1h30
---
## Contexte
Sans JavaScript, une page web ne peut pas exécuter d'algorithme. Mais Python peut **générer** une page HTML ! Vous allez trier des données en Python, puis produire un fichier `.html` affichant le résultat avec un style CSS.
---
## Étapes
### Étape 1 — Trier les données
Implémentez `tri_insertion_jeux(jeux)` qui trie la liste de jeux vidéo par **score décroissant** (le meilleur en premier).
> **Indication** : pour trier par ordre **décroissant**, inversez la condition : `tab[j-1][1] < x[1]` au lieu de `>`.
### Étape 2 — Recherche dichotomique
Implémentez `rechercher_score(jeux_tries, score)` qui retourne le jeu avec ce score exact, ou `None`.
> Attention : la liste est triée par score **décroissant**. La dichotomie doit être adaptée (les comparaisons `<` et `>` sont inversées).
### Étape 3 — Générer la page HTML
Implémentez `generer_html(jeux_tries, fichier)` qui écrit un fichier `.html` contenant un tableau du classement, stylisé avec du CSS intégré.
La page doit afficher au minimum :
- Le rang, le titre, le studio, l'année et le score de chaque jeu
- Les 3 premiers avec une couleur distincte (or, argent, bronze)
- Un titre et un style propre
### Étape 4 — Ouvrir la page automatiquement
À la fin du programme, ouvrez la page générée dans le navigateur avec :
```python
import webbrowser
webbrowser.open("classement.html")
```
### Étape 5 — Extension (si vous avez le temps)
Ajoutez un deuxième tableau sur la même page : les jeux triés par **année de sortie** (vous pouvez faire un deuxième tri sur une copie).
---
## Ce que vous devez rendre
- Le fichier `starter.py` qui tourne et génère `classement.html`
- La page `classement.html` ouverte dans le navigateur
- Réponse : pourquoi Python peut-il générer du HTML, alors qu'HTML ne peut pas exécuter Python ?

238
algorithmes/mini-projets/AIDE.md Normal file
View File

@@ -0,0 +1,238 @@
# 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.

65
algorithmes/mini-projets/README.md Normal file
View File

@@ -0,0 +1,65 @@
# Mini-projets — Algorithmes de tri et recherche dichotomique
Séance de révision avant DS (mardi). Chaque groupe reçoit un projet différent.
Durée : **1h à 1h30**. Langage : **Python** (sauf projet 09 : Python + HTML/CSS).
> **Règle commune** : vous devez implémenter vous-mêmes `tri_insertion`, `tri_selection` et `dichotomique`. **Interdiction d'utiliser `sort()` ou `sorted()`.**
---
## Répartition des groupes
| # | Projet | Algorithmes utilisés | Difficulté |
|---|--------|----------------------|------------|
| 01 | [Le Nombre Mystère](01_devine_nombre/) | Dichotomie | Facile |
| 02 | [Le Tri de Cartes](02_cartes/) | Tri insertion | Facile |
| 03 | [Le Podium](03_podium/) | Tri sélection + Dichotomie | Facile |
| 04 | [L'Annuaire](04_annuaire/) | Tri insertion + Dichotomie | Moyen |
| 05 | [Le Correcteur](05_correcteur/) | Tri insertion + Dichotomie (voisins) | Moyen |
| 06 | [La Bibliothèque](06_bibliotheque/) | Tri sélection + Dichotomie | Moyen |
| 07 | [La Météo](07_meteo/) | Tri insertion + Dichotomie | Moyen |
| 08 | [La Course des Algos](08_course_algos/) | Tri insertion vs Tri sélection | Difficile |
| 09 | [Le Générateur Web](09_generateur_web/) | Tri insertion + Dichotomie → HTML | Difficile |
---
## Rappels des algorithmes
```python
def tri_insertion(tab):
for i in range(1, len(tab)):
x = tab[i]
j = i
while j > 0 and tab[j - 1] > x:
tab[j] = tab[j - 1]
j -= 1
tab[j] = x
return tab
def tri_selection(tab):
n = len(tab)
for i in range(n):
mini = i
for j in range(i + 1, n):
if tab[j] < tab[mini]:
mini = j
tab[i], tab[mini] = tab[mini], tab[i]
return tab
def dichotomique(tab, x):
a = 0
b = len(tab) - 1
while a <= b:
m = (a + b) // 2
if tab[m] == x:
return True
elif tab[m] < x:
a = m + 1
else:
b = m - 1
return False
```
---
Auteur : Florian Mathieu — Licence CC BY NC

156
knn/CORRIGE_TP_KNN.md Normal file
View File

@@ -0,0 +1,156 @@
# Corrigé — TP Choixpeau Magique et KNN
---
## Partie 1 : Modéliser un élève
### Question 1 — Modélisation d'Anthony
```python
anthony = {"nom": "Anthony", "courage": 2, "loyauté": 8, "sagesse": 8, "malice": 3, "maison": "Serdaigle"}
```
### Question 3 — Distance entre Hermione et Adrian
- Hermione : courage=8, loyauté=6, sagesse=6, malice=6
- Adrian : courage=9, loyauté=4, sagesse=7, malice=10
```
distance = |8-9| + |6-4| + |6-7| + |6-10|
= 1 + 2 + 1 + 4
= 8 ✓
```
### Question 4 — Distance entre Arthur et Drago
- Arthur : courage=10, loyauté=4, sagesse=2, malice=5
- Drago : courage=6, loyauté=6, sagesse=5, malice=8
```
distance = |10-6| + |4-6| + |2-5| + |5-8|
= 4 + 2 + 3 + 3
= 12
```
### Question 5 — Fonction distance
```python
def distance(eleve1, eleve2):
return (abs(eleve1["courage"] - eleve2["courage"]) +
abs(eleve1["loyauté"] - eleve2["loyauté"]) +
abs(eleve1["sagesse"] - eleve2["sagesse"]) +
abs(eleve1["malice"] - eleve2["malice"]))
```
---
## Partie 2 : Charger les données en table
### Question 1 — Type de `eleve[0]`
`eleve[0]` est de type `str`. `csv.reader` retourne toutes les valeurs sous forme de chaînes de caractères.
### Question 2 — Pourquoi `int()` ?
`int(eleve[1])` est de type `int`. On a besoin de la conversion car `csv.reader` renvoie tout en `str`, et on a besoin de valeurs numériques pour calculer des distances.
### Question 3 — Type de `poudlard`
`poudlard` est de type `list` (une liste de dictionnaires).
---
## Partie 3 : Trouver la maison majoritaire
```python
def maison_majoritaire(table):
frequences = frequence_des_maisons(table)
maison_max = None
max_freq = 0
for maison, freq in frequences.items():
if freq > max_freq:
max_freq = freq
maison_max = maison
return maison_max
```
---
## Partie 4 : Sept plus proches voisins
### Question 1 — Pseudo-code
```
Algorithme sept_voisins(table, nouveau) :
Données :
- table : liste d'élèves avec leur maison
- nouveau : élève sans maison
Résultat : les 7 élèves de table les plus proches de nouveau
Pour chaque élève de table :
Calculer la distance entre cet élève et nouveau
Stocker (distance, élève)
Trier la liste par distance croissante
Retourner les 7 premiers éléments
```
### Question 2 — Implémentation Python
```python
def sept_voisins(table, nouveau):
distances = []
for eleve in table:
d = distance(eleve, nouveau)
distances.append((d, eleve))
distances.sort(key=lambda x: x[0])
return [eleve for d, eleve in distances[:7]]
```
---
## Partie 5 : Attribuer une maison
```python
def attribuer_maison(table, nouveau):
voisins = sept_voisins(table, nouveau)
return maison_majoritaire(voisins)
```
### Application aux quatre élèves
```python
poudlard = charger_table("choixpeauMagique.csv")
hermione = {"nom": "Hermione", "courage": 8, "loyauté": 6, "sagesse": 6, "malice": 6}
drago = {"nom": "Drago", "courage": 6, "loyauté": 6, "sagesse": 5, "malice": 8}
cho = {"nom": "Cho", "courage": 7, "loyauté": 6, "sagesse": 9, "malice": 6}
cedric = {"nom": "Cédric", "courage": 7, "loyauté": 10, "sagesse": 5, "malice": 6}
for eleve in [hermione, drago, cho, cedric]:
maison = attribuer_maison(poudlard, eleve)
print(f"{eleve['nom']} → {maison}")
```
### Résultats attendus
```
Hermione → Gryffondor
Drago → Serpentard
Cho → Serdaigle
Cédric → Poufsouffle
```
Détail des 7 voisins et du vote pour chaque élève :
| Élève | 7 plus proches voisins (distance) | Vote majoritaire |
|----------|------------------------------------------------------------------------------------------|-------------------------|
| Hermione | Cormac (4), Milicent (5), Neville (5), Padma (5), Susan (5), Angelina (6), Colin (6) | Gryffondor 4/7 ✓ |
| Drago | Padma (2), Susan (4), Angelina (5), Gregory (5), Harper (5), Bole (6), Marcus (6) | Serpentard 4/7 ✓ |
| Cho | Terry (5), Gilderoy (6), Lavande (6), Saemus (6), Eddie (7), Marcus (7), Padma (7) | Serdaigle 4/7 ✓ |
| Cédric | Dean (6), Gregory (6), Hannah (6), Norbert (6), Pomona (6), Susan (7), Térence (7) | Poufsouffle 4/7 ✓ |
> Ces résultats sont cohérents avec les personnages du roman : Hermione et Drago sont bien placés dans leurs maisons respectives, Cho Chang est à Serdaigle et Cédric Diggory à Poufsouffle.
---
Auteur : Florian Mathieu — Licence CC BY NC

4
knn/TP_KNN.md
View File

@@ -26,7 +26,7 @@ Le Choixpeau magique dispose d'un [fichier csv](choixpeauMagique.csv) avec les
Et voici les élèves que le Choipeaux magique doit orienter : Et voici les élèves que le Choixpeau magique doit orienter :
| Nom | Courage | Loyauté | Sagesse | Malice | | Nom | Courage | Loyauté | Sagesse | Malice |
| -------- | ------- | ------- | ------- | ------ | | -------- | ------- | ------- | ------- | ------ |
@@ -99,7 +99,7 @@ poudlard = charger_table("choixpeauMagique.csv")
1. Dans le code de la fonction charger_table, à la ligne 14, quel est le type de la variable eleve[0] ? 1. Dans le code de la fonction charger_table, à la ligne 14, quel est le type de la variable eleve[0] ?
2. Quel est le type de int ( eleve [ 0] ) ? Pourquoi a-t-on besoin de la fonction int() ici? 2. Quel est le type de int(eleve[1]) ? Pourquoi a-t-on besoin de la fonction int() ici ?
3. Quel est le type de la variable poudlard ? 3. Quel est le type de la variable poudlard ?

58
knn/choixpeauMagique.csv
View File

@@ -1,51 +1,51 @@
Nom;Courage;Loyauté;Sagesse;Malice;Maison Nom;Courage;Loyauté;Sagesse;Malice;Maison
Adrian;9;4;7;10;Serpentar Adrian;9;4;7;10;Serpentard
Andrew;9;3;4;7;Griffondor Andrew;9;3;4;7;Gryffondor
Angelina;10;6;5;9;Griffondor Angelina;10;6;5;9;Gryffondor
Anthony;2;8;8;3;Serdaigle Anthony;2;8;8;3;Serdaigle
Arthur;10;4;2;5;Griffondor Arthur;10;4;2;5;Gryffondor
Bellatrix;10;4;9;9;Serpentar Bellatrix;10;4;9;9;Serpentard
Bole;7;4;6;10;Serpentar Bole;7;4;6;10;Serpentard
Colin;10;7;4;7;Griffondor Colin;10;7;4;7;Gryffondor
Cormac;9;6;5;4;Griffondor Cormac;9;6;5;4;Gryffondor
Dean;9;8;4;7;Griffondor Dean;9;8;4;7;Gryffondor
Demelza;10;6;5;3;Griffondor Demelza;10;6;5;3;Gryffondor
Derrick;5;4;6;5;Serpentar Derrick;5;4;6;5;Serpentard
Eddie;5;7;10;3;Serdaigle Eddie;5;7;10;3;Serdaigle
Ernie;4;8;7;4;Poufsouffle Ernie;4;8;7;4;Poufsouffle
Euan;9;2;7;4;Griffondor Euan;9;2;7;4;Gryffondor
Gilderoy;7;9;9;9;Serdaigle Gilderoy;7;9;9;9;Serdaigle
Gregory;6;9;7;8;Serpentar Gregory;6;9;7;8;Serpentard
Hannah;8;10;2;4;Poufsouffle Hannah;8;10;2;4;Poufsouffle
Harper;6;3;5;10;Serpentar Harper;6;3;5;10;Serpentard
Jimmy;9;9;9;10;Griffondor Jimmy;9;9;9;10;Gryffondor
Justin;5;10;7;10;Poufsouffle Justin;5;10;7;10;Poufsouffle
Katie;10;2;3;9;Griffondor Katie;10;2;3;9;Gryffondor
Lavande;10;8;8;6;Griffondor Lavande;10;8;8;6;Gryffondor
Lee;10;2;2;8;Griffondor Lee;10;2;2;8;Gryffondor
Luna;2;9;9;2;Serdaigle Luna;2;9;9;2;Serdaigle
Marcus;6;5;8;10;Serpentar Marcus;6;5;8;10;Serpentard
Marietta;10;8;10;9;Serdaigle Marietta;10;8;10;9;Serdaigle
Michael;4;2;6;5;Serdaigle Michael;4;2;6;5;Serdaigle
Milicent;9;3;5;6;Serpentar Milicent;9;3;5;6;Serpentard
Mimi;4;4;9;10;Serdaigle Mimi;4;4;9;10;Serdaigle
Montague;5;7;2;10;Serpentar Montague;5;7;2;10;Serpentard
Neville;10;5;6;4;Griffondor Neville;10;5;6;4;Gryffondor
Norbert;3;10;7;6;Poufsouffle Norbert;3;10;7;6;Poufsouffle
Nymphadora;2;5;3;8;Poufsouffle Nymphadora;2;5;3;8;Poufsouffle
Padma;6;6;6;9;Serdaigle Padma;6;6;6;9;Serdaigle
Paenny;2;8;9;8;Poufsouffle Paenny;2;8;9;8;Poufsouffle
Pansy;4;4;10;8;Serpentar Pansy;4;4;10;8;Serpentard
Parvati;10;5;2;6;Griffondor Parvati;10;5;2;6;Gryffondor
Pomona;5;10;7;8;Poufsouffle Pomona;5;10;7;8;Poufsouffle
Quirinus;7;10;10;2;Serdaigle Quirinus;7;10;10;2;Serdaigle
Roger;9;10;10;8;Serdaigle Roger;9;10;10;8;Serdaigle
Romilda;10;6;2;9;Griffondor Romilda;10;6;2;9;Gryffondor
Saemus;7;4;8;3;Griffondor Saemus;7;4;8;3;Gryffondor
Sirius;10;8;10;7;Griffondor Sirius;10;8;10;7;Gryffondor
Susan;5;6;5;5;Poufsouffle Susan;5;6;5;5;Poufsouffle
Susan;4;10;10;5;Poufsouffle Susan;4;10;10;5;Poufsouffle
Ted;5;9;8;4;Poufsouffle Ted;5;9;8;4;Poufsouffle
Térence;6;9;2;8;Serpentar Térence;6;9;2;8;Serpentard
Terry;8;4;10;5;Serdaigle Terry;8;4;10;5;Serdaigle
Vincent;4;9;2;10;Serpentar Vincent;4;9;2;10;Serpentard
1 Nom Courage Loyauté Sagesse Malice Maison
2 Adrian 9 4 7 10 Serpentar Serpentard
3 Andrew 9 3 4 7 Griffondor Gryffondor
4 Angelina 10 6 5 9 Griffondor Gryffondor
5 Anthony 2 8 8 3 Serdaigle
6 Arthur 10 4 2 5 Griffondor Gryffondor
7 Bellatrix 10 4 9 9 Serpentar Serpentard
8 Bole 7 4 6 10 Serpentar Serpentard
9 Colin 10 7 4 7 Griffondor Gryffondor
10 Cormac 9 6 5 4 Griffondor Gryffondor
11 Dean 9 8 4 7 Griffondor Gryffondor
12 Demelza 10 6 5 3 Griffondor Gryffondor
13 Derrick 5 4 6 5 Serpentar Serpentard
14 Eddie 5 7 10 3 Serdaigle
15 Ernie 4 8 7 4 Poufsouffle
16 Euan 9 2 7 4 Griffondor Gryffondor
17 Gilderoy 7 9 9 9 Serdaigle
18 Gregory 6 9 7 8 Serpentar Serpentard
19 Hannah 8 10 2 4 Poufsouffle
20 Harper 6 3 5 10 Serpentar Serpentard
21 Jimmy 9 9 9 10 Griffondor Gryffondor
22 Justin 5 10 7 10 Poufsouffle
23 Katie 10 2 3 9 Griffondor Gryffondor
24 Lavande 10 8 8 6 Griffondor Gryffondor
25 Lee 10 2 2 8 Griffondor Gryffondor
26 Luna 2 9 9 2 Serdaigle
27 Marcus 6 5 8 10 Serpentar Serpentard
28 Marietta 10 8 10 9 Serdaigle
29 Michael 4 2 6 5 Serdaigle
30 Milicent 9 3 5 6 Serpentar Serpentard
31 Mimi 4 4 9 10 Serdaigle
32 Montague 5 7 2 10 Serpentar Serpentard
33 Neville 10 5 6 4 Griffondor Gryffondor
34 Norbert 3 10 7 6 Poufsouffle
35 Nymphadora 2 5 3 8 Poufsouffle
36 Padma 6 6 6 9 Serdaigle
37 Paenny 2 8 9 8 Poufsouffle
38 Pansy 4 4 10 8 Serpentar Serpentard
39 Parvati 10 5 2 6 Griffondor Gryffondor
40 Pomona 5 10 7 8 Poufsouffle
41 Quirinus 7 10 10 2 Serdaigle
42 Roger 9 10 10 8 Serdaigle
43 Romilda 10 6 2 9 Griffondor Gryffondor
44 Saemus 7 4 8 3 Griffondor Gryffondor
45 Sirius 10 8 10 7 Griffondor Gryffondor
46 Susan 5 6 5 5 Poufsouffle
47 Susan 4 10 10 5 Poufsouffle
48 Ted 5 9 8 4 Poufsouffle
49 Térence 6 9 2 8 Serpentar Serpentard
50 Terry 8 4 10 5 Serdaigle
51 Vincent 4 9 2 10 Serpentar Serpentard

159
knn/test_choixpeau.py Normal file
View File

@@ -0,0 +1,159 @@
import csv
import time
# ── Chargement des données ────────────────────────────────────────────────────
def charger_table(nom_fichier):
table = []
with open(nom_fichier, 'r', newline="", encoding="utf-8") as csvfile:
eleve_reader = csv.reader(csvfile, delimiter=";")
eleve_reader.__next__()
for eleve in eleve_reader:
table.append({
"nom": eleve[0],
"courage": int(eleve[1]),
"loyauté": int(eleve[2]),
"sagesse": int(eleve[3]),
"malice": int(eleve[4]),
"maison": eleve[5].strip()
})
return table
# ── Algorithme KNN ────────────────────────────────────────────────────────────
def distance(eleve1, eleve2):
return (abs(eleve1["courage"] - eleve2["courage"]) +
abs(eleve1["loyauté"] - eleve2["loyauté"]) +
abs(eleve1["sagesse"] - eleve2["sagesse"]) +
abs(eleve1["malice"] - eleve2["malice"]))
def sept_voisins(table, nouveau):
distances = [(distance(eleve, nouveau), eleve) for eleve in table]
distances.sort(key=lambda x: x[0])
return [eleve for d, eleve in distances[:7]]
def maison_majoritaire(voisins):
frequences = {}
for eleve in voisins:
maison = eleve["maison"]
frequences[maison] = frequences.get(maison, 0) + 1
return max(frequences, key=frequences.get), frequences
# ── Affichage ─────────────────────────────────────────────────────────────────
MAISONS = {
"Gryffondor": {
"traits": "Courage, chevalerie et determination",
"message": "Tu es du genre a te jeter dans la bataille sans trop reflechir.\nPoudlard a besoin de toi sur le terrain de Quidditch !"
},
"Serpentard": {
"traits": "Malice, ambition et ressource",
"message": "Tu sais ce que tu veux, et tu sais comment l'obtenir.\nMefie-toi quand meme de Lord Voldemort dans les couloirs."
},
"Serdaigle": {
"traits": "Sagesse, creativite et esprit",
"message": "Tu preferes comprendre avant d'agir. La bibliotheque\nde Poudlard va devenir ton deuxieme chez-toi."
},
"Poufsouffle": {
"traits": "Loyaute, patience et equite",
"message": "On peut compter sur toi. Toujours. Sans exception.\nCedric Diggory etait de Poufsouffle — ca dit tout."
}
}
def afficher_banniere(maison):
largeur = 42
print()
print("=" * largeur)
print("|" + " " * (largeur - 2) + "|")
ligne = f" Le Choixpeau a decide : {maison.upper()}"
print("|" + ligne.ljust(largeur - 2) + "|")
print("|" + " " * (largeur - 2) + "|")
infos = MAISONS.get(maison, {})
traits = f" {infos.get('traits', '')}"
print("|" + traits.ljust(largeur - 2) + "|")
print("|" + " " * (largeur - 2) + "|")
print("=" * largeur)
print()
print(infos.get("message", ""))
print()
def afficher_voisins(voisins, moi):
print("-" * 42)
print(" Les 7 eleves de Poudlard qui te ressemblent le plus :")
print()
for v in voisins:
d = distance(v, moi)
print(f" {v['nom']:<12} ({v['maison']:<12}) distance : {d}")
print("-" * 42)
print()
# ── Saisie avec validation ────────────────────────────────────────────────────
QUESTIONS = [
("courage", "Face au danger, tu fonces sans hesiter "),
("loyauté", "Tu es fidele a tes amis, quoi qu'il arrive "),
("sagesse", "Tu reflechis avant d'agir, tu observes, tu analyses "),
("malice", "Tu sais trouver des strategies pour arriver a tes fins"),
]
def poser_question(trait, description):
while True:
try:
rep = input(f" {description} (1 a 10) : ").strip()
valeur = int(rep)
if 1 <= valeur <= 10:
return valeur
print(" --> Donne une valeur entre 1 et 10.")
except ValueError:
print(" --> Entre un nombre entier.")
# ── Programme principal ───────────────────────────────────────────────────────
def main():
print()
print("=" * 42)
print("| |")
print("| CHOIXPEAU MAGIQUE -- KNN |")
print("| |")
print("=" * 42)
print()
try:
poudlard = charger_table("choixpeauMagique.csv")
except FileNotFoundError:
print("Erreur : le fichier 'choixpeauMagique.csv' est introuvable.")
print("Place-le dans le meme dossier que ce script.")
return
prenom = input("Quel est ton prenom ? ").strip()
if not prenom:
prenom = "Mystere"
print()
print(f"Bien, {prenom}. Reponds honnêtement à ces quatre questions.")
print("Note-toi de 1 (pas du tout) à 10 (totalement).")
print()
eleve = {"nom": prenom}
for trait, description in QUESTIONS:
eleve[trait] = poser_question(trait, description)
print()
print("Le Choixpeau murmure quelque chose...")
time.sleep(1)
print("Il se tait.")
time.sleep(1)
print("Puis il crie :")
time.sleep(0.8)
voisins = sept_voisins(poudlard, eleve)
maison, frequences = maison_majoritaire(voisins)
afficher_banniere(maison)
time.sleep(0.5)
afficher_voisins(voisins, eleve)
print(f" Repartition du vote : {frequences}")
print()
main()

BIN
markdown/HJ6_KAYaYAAm3y4.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 340 KiB

115
news/2026-02-03.md Normal file
View File

@@ -0,0 +1,115 @@
# News NSI - Lundi 3 février 2026
---
## Actualités du jour
### 1. Notepad++ victime d'une cyberattaque sophistiquée
**Quoi ?** Le célèbre éditeur de texte Notepad++ (que vous utilisez peut-être en cours !) a été compromis par des hackers. Ils ont réussi à rediriger certaines mises à jour vers des serveurs malveillants pendant **6 mois** sans que personne ne s'en aperçoive.
**Concept NSI :** C'est une **"supply chain attack"** (attaque de la chaîne d'approvisionnement). Au lieu d'attaquer les utilisateurs directement, les pirates compromettent le fournisseur du logiciel. Cela montre l'importance de :
- Vérifier les sources lors du téléchargement de logiciels
- Comprendre la notion d'**intégrité des données**
**Source :** [Clubic](https://www.clubic.com/actualite-598549-notepad-a-blinde-son-infrastructure-contre-les-hackers-chinois.html) - 2 février 2026
---
### 2. Des experts en cybersécurité... devenus pirates
**Quoi ?** Deux professionnels américains de la cybersécurité ont plaidé coupable d'avoir déployé des **ransomwares** (logiciels qui chiffrent vos données et demandent une rançon). Ils utilisaient leur accès privilégié aux systèmes de leurs clients pour voler des données. Ils risquent 20 ans de prison.
**Concept NSI :**
- L'**éthique informatique** : quelle est la responsabilité morale d'un informaticien ?
- La notion de **privilèges** dans un système d'information
**Question pour la classe :** Un informaticien a accès à beaucoup de données sensibles. Qu'est-ce qui l'empêche d'en abuser ?
---
### 3. 84% des développeurs utilisent l'IA pour coder
**Quoi ?** En 2026, l'IA est devenue un outil quotidien pour les développeurs. Le terme **"vibe coding"** (programmer en décrivant ce qu'on veut en langage naturel) a été élu mot de l'année 2025. Microsoft et Google affirment que 25% de leur code est généré par l'IA.
**Concept NSI :** L'IA va-t-elle remplacer les programmeurs ? Non, mais elle change le métier. Comprendre les **fondamentaux** (ce que vous apprenez en NSI) reste essentiel pour :
- Vérifier ce que l'IA propose
- Comprendre les erreurs
- Résoudre les problèmes complexes
---
### 4. Friend.com : le collier IA qui pose question
**Quoi ?** Un collier équipé d'une IA qui promet de devenir "votre meilleur ami" envahit les pubs du métro parisien. Le problème ? Il possède un **micro actif en permanence** qui capte toutes vos conversations.
**Concept NSI :**
- Le **RGPD** (Règlement Général sur la Protection des Données) européen
- La **vie privée** à l'ère numérique
- La collecte de données personnelles
**Débat possible :** Jusqu'où accepte-t-on d'être surveillés pour avoir des services "intelligents" ?
---
## Anecdote historique : L'explosion d'Ariane 5
### 4 juin 1996 : Quand une ligne de code fait perdre 370 millions de dollars
**Le contexte :** L'Agence Spatiale Européenne lance sa toute nouvelle fusée Ariane 5, fruit de 10 ans de développement et 7 milliards de dollars d'investissement. 40 secondes après le décollage... **elle explose en plein vol**.
**La cause ?** Une erreur de **conversion de type** dans le code !
```
Vitesse horizontale : stockée en float64 (nombre à virgule sur 64 bits)
↓
Conversion vers int16 (entier sur 16 bits)
↓
Valeur maximale d'un int16 : 32 767
↓
Ariane 5 trop rapide → valeur > 32 767
↓
OVERFLOW → CRASH → EXPLOSION
```
**Le comble :** Ce code ne servait même pas pendant le vol ! Il avait été copié d'Ariane 4 sans être retesté.
**Exercice Python :**
```python
import numpy as np
# La vitesse dépasse la capacité d'un int16
vitesse = 32768.5
# Conversion dangereuse (comme Ariane 5)
resultat = np.int16(vitesse)
print(resultat) # Affiche -32768 au lieu de 32768 !
# La bonne pratique
if -32768 <= vitesse <= 32767:
resultat = np.int16(vitesse)
else:
print("ALERTE : valeur hors limites !")
```
**Vidéos INA :**
- [Explosion au lancement d'Ariane 5](https://www.ina.fr/ina-eclaire-actu/video/cab96023317/explosion-au-lancement-d-ariane-5)
- [Archive JT avec Élise Lucet](https://www.ina.fr/ina-eclaire-actu/4-juin-1996-la-premiere-ariane-v-explose-en-vol)
**La leçon :** Toujours vérifier les limites des types de données et tester le code dans ses nouvelles conditions d'utilisation !
---
## Concepts NSI abordés aujourd'hui
| Actualité | Thème NSI | Mots-clés |
|-----------|-----------|-----------|
| Hack Notepad++ | Cybersécurité | Intégrité, supply chain, confiance |
| Experts malveillants | Éthique | Responsabilité, privilèges, ransomware |
| IA et programmation | Programmation | IA générative, avenir du métier |
| Friend.com | Données | RGPD, vie privée, collecte |
| Ariane 5 | Représentation des données | int16, int64, overflow, types |
---
*Fichier généré automatiquement - NSI Première*

13
news/2026-02-05.md Normal file
View File

@@ -0,0 +1,13 @@
Il semble que les permissions d'écriture ne soient pas encore accordées. Le fichier `2026-02-05.md` est prêt à être écrit. Pouvez-vous autoriser l'écriture pour que je puisse créer le fichier ?
En résumé, le contenu prévu contient :
**4 actualités :**
1. **DeepSeek R1** - l'IA chinoise open source (concept : logiciel libre vs propriétaire)
2. **Fuite de données télécom** - via injection SQL (concept : cybersécurité, avec exemple de code Python)
3. **Python 3.14** - la version "pi" en bêta (concept : interpréteur vs compilateur, JIT)
4. **Sanction CNIL** - reconnaissance faciale illégale (concept : RGPD, données biométriques)
**Anecdote historique :** Le ver Morris (1988) - le premier ver d'Internet qui a paralysé 10% du réseau, avec schéma de propagation et liens vers le cours (récursivité, mots de passe).
**Note :** Les outils de recherche web n'étaient pas disponibles. Les news sur DeepSeek R1 et Python 3.14 sont basées sur des faits réels. Les news sur la fuite télécom et la CNIL sont inspirées de tendances réelles mais les détails spécifiques (montant exact, opérateur) peuvent nécessiter une vérification.

145
news/2026-02-06.md Normal file
View File

@@ -0,0 +1,145 @@
# News NSI - Jeudi 6 février 2026
---
## 1. ACTUALITÉS DU JOUR
### Panne mondiale Azure : quand une erreur de configuration paralyse le cloud
Les 2 et 3 février 2026, **Microsoft Azure** a subi deux pannes majeures affectant des millions d'utilisateurs dans le monde. La cause ? Une politique de sécurité appliquée par erreur sur des comptes de stockage, bloquant l'accès en lecture publique et empêchant le déploiement de machines virtuelles. Les services Kubernetes, Teams et Outlook ont été impactés pendant près de 10 heures.
**Concept NSI** : Architecture client-serveur, cloud computing, hébergement centralisé vs décentralisé. Cela illustre les risques d'une dépendance à un fournisseur unique (*single point of failure*).
> Source : [Le Monde Informatique](https://www.lemondeinformatique.fr/actualites/lire-microsoft-enchaine-les-pannes-azure-99253.html) · [The Register](https://www.theregister.com/2026/02/03/azure_virtual_machine_outage/)
---
### Rapport mondial sur la sécurité de l'IA : alerte sur les deepfakes et les agents autonomes
Le **deuxième Rapport International sur la Sécurité de l'IA**, piloté par **Yoshua Bengio** (prix Turing), vient d'être publié avec plus de 100 experts de 30 pays. Principales alertes : des IA capables de **découvrir seules des failles zero-day**, l'explosion des deepfakes, et les risques psychologiques des chatbots "compagnons" qui manipulent les émotions.
**Concept NSI** : Données structurées, algorithmes, intelligence artificielle, éthique du numérique. Le rapport soulève la question fondamentale : comment contrôler un programme plus "intelligent" que son concepteur ?
> Source : [PR Newswire](https://www.prnewswire.com/news-releases/ledition-2026-du-rapport-international-sur-la-securite-de-lia-fait-etat-de-changements-rapides-et-de-risques-emergents-302677849.html) · [Pandia](https://pandia.pro/actualite/rapport-mondial-2026-sur-la-securite-de-lintelligence-artificielle/)
---
### `ty` : le nouveau type checker Python ultra-rapide, écrit en Rust
**Astral**, l'entreprise derrière `uv` et `Ruff`, lance **`ty`** en bêta : un vérificateur de types pour Python **10 à 60 fois plus rapide** que mypy. Sur le dépôt PyTorch, `ty` recalcule les diagnostics en **4,7 ms** contre 386 ms pour Pyright. Le secret ? Il est écrit en **Rust**, un langage compilé ultra-performant.
**Concept NSI** : Typage des variables, différence entre langage interprété (Python) et compilé (Rust), complexité algorithmique. Pourquoi un outil écrit dans un autre langage peut-il accélérer Python ?
> Source : [Astral Blog](https://astral.sh/blog/ty) · [InfoWorld](https://www.infoworld.com/article/4108979/python-type-checker-ty-now-in-beta.html)
---
### Go 1.26 : un nouveau ramasse-miettes et de la sécurité mémoire
Le langage **Go** sort sa version **1.26** en février 2026. Nouveauté phare : le ramasse-miettes **"Green Tea"** réduit de 10 à 40 % la surcharge du *garbage collector*. Autre ajout : l'adresse de base du tas (*heap*) est désormais **randomisée** au démarrage pour contrer les attaques par prédiction d'adresse mémoire.
**Concept NSI** : Gestion de la mémoire, ramasse-miettes (*garbage collector*), différence entre allocation statique et dynamique, sécurité informatique au niveau du système.
> Source : [Go 1.26 Release Notes](https://go.dev/doc/go1.26)
---
### 26 sites sécurisés en France pour des data centers IA
Le gouvernement français a **sécurisé 26 sites** (sur 63 prévus) pour la construction de centres de données dédiés à l'intelligence artificielle. Ces infrastructures sont essentielles pour entraîner les grands modèles de langage et garantir la **souveraineté numérique** française face aux géants américains et chinois.
**Concept NSI** : Données structurées, stockage et traitement des données, architecture réseau, enjeux sociétaux du numérique (souveraineté, consommation énergétique).
> Source : [BPI France](https://bigmedia.bpifrance.fr/nos-dossiers/nouvelles-tendances-technologiques-en-2026-comprendre-anticiper-et-innover)
---
## FOCUS : OpenClaw et Moltbook — Quand les IA créent leur propre réseau social
### C'est quoi cette histoire ?
Vous avez peut-être entendu parler de **Clawdbot**, **Moltbot** ou **OpenClaw** — c'est en fait le même projet qui a changé de nom plusieurs fois ! Voici l'histoire :
**Novembre 2025** : Un développeur autrichien, Peter Steinberger, crée **Clawdbot** — un assistant IA que vous pouvez installer sur votre propre ordinateur et utiliser via **Telegram**, **WhatsApp** ou **Signal**. Contrairement à ChatGPT qui tourne sur les serveurs d'OpenAI, Clawdbot tourne chez vous.
**27 janvier 2026** : Anthropic (l'entreprise qui crée Claude, l'IA que j'utilise !) envoie une plainte : le nom "Clawdbot" ressemble trop à "Claude". Le projet est renommé **Moltbot**.
**30 janvier 2026** : Nouveau changement — Moltbot devient **OpenClaw** (plus facile à prononcer).
### Moltbook : un réseau social... sans humains ?
Le **28 janvier 2026**, une plateforme appelée **Moltbook** est lancée. Sa particularité ? C'est un réseau social conçu **pour que des agents IA interagissent entre eux** : ils peuvent poster, répondre, se coordonner... sans intervention humaine directe.
Imaginez un Facebook où tous les utilisateurs seraient des programmes informatiques qui discutent entre eux. Fascinant et un peu effrayant, non ?
### Ce que peut faire OpenClaw
Un agent OpenClaw peut :
- Naviguer sur le web automatiquement
- Résumer des PDF
- Gérer votre agenda
- Envoyer et supprimer des emails
- Faire des achats en ligne
Tout ça de manière **autonome**, avec très peu de supervision humaine.
### Les problèmes de sécurité
Cette autonomie pose de gros problèmes. Deux failles de sécurité critiques ont été découvertes :
- **CVE-2025-49596** (score 9.4/10) : accès non autorisé au système
- **CVE-2025-6514** (score 9.6/10) : injection de commandes permettant d'exécuter du code malveillant
**Concept NSI** : Cela illustre parfaitement les notions d'**agents autonomes**, de **systèmes distribués**, et les enjeux de **cybersécurité**. Quand un programme peut agir seul, comment s'assurer qu'il ne fera pas n'importe quoi ?
> Sources : [TechCrunch](https://techcrunch.com/2026/01/30/openclaws-ai-assistants-are-now-building-their-own-social-network/) · [CNBC](https://www.cnbc.com/2026/02/02/openclaw-open-source-ai-agent-rise-controversy-clawdbot-moltbot-moltbook.html) · [Taskade Blog](https://www.taskade.com/blog/moltbook-clawdbot-openclaw-history)
---
## 2. ANECDOTE HISTORIQUE
### 6 février 2018 : Falcon Heavy envoie une voiture dans l'espace... pilotée par un logiciel
Le **6 février 2018**, SpaceX réussit le premier vol de **Falcon Heavy**, la fusée la plus puissante en service à l'époque. Mais le vrai exploit est informatique : les deux boosters latéraux se posent **simultanément** en autonomie totale, guidés par des algorithmes de contrôle en temps réel.
Le logiciel de vol de SpaceX est écrit en **C++** et tourne sur des processeurs **x86 dual-core** redondants. Chaque booster exécute des calculs de trajectoire en boucle fermée, ajustant la poussée des moteurs des centaines de fois par seconde.
**Ce qui s'est passé** : Elon Musk avait placé sa propre Tesla Roadster rouge comme charge utile, avec un mannequin nommé "Starman" au volant, diffusant *Space Oddity* de David Bowie. La voiture orbite toujours autour du Soleil aujourd'hui.
**Lien avec le cours** : Cet événement illustre parfaitement les **boucles de rétroaction** (boucles `while`), le **traitement en temps réel**, et l'importance de la **redondance** dans les systèmes critiques. Quand un bug logiciel peut faire crasher une fusée, chaque ligne de code compte.
```python
# Simulation simplifiée d'un atterrissage de booster
altitude = 10000 # mètres
vitesse = -200 # m/s (descente)
poussee = 0
while altitude > 0:
# Algorithme de freinage : ajuster la poussée
if vitesse < -50:
poussee = 9.8 + abs(vitesse) * 0.1 # freinage progressif
elif vitesse < -5:
poussee = 9.8 + abs(vitesse) * 0.5 # freinage fort
else:
poussee = 9.8 # maintien (compense la gravité)
vitesse += (poussee - 9.8) * 0.1 # mise à jour vitesse
altitude += vitesse * 0.1 # mise à jour altitude
print(f"Atterrissage ! Vitesse finale : {vitesse:.1f} m/s")
```
> Vidéo : [Atterrissage des boosters Falcon Heavy - YouTube SpaceX](https://www.youtube.com/watch?v=u0-pfzKbh2k)
---
## 3. TABLEAU RÉCAPITULATIF
| Actualité | Concept NSI (Programme Première) | Thème du programme |
|---|---|---|
| Panne Azure | Architecture client-serveur, cloud | **Architectures matérielles et OS** |
| Rapport sécurité IA | Algorithmes, éthique du numérique | **Impacts sociétaux du numérique** |
| `ty` (type checker Python) | Typage, langage interprété vs compilé | **Langages et programmation** |
| Go 1.26 (garbage collector) | Gestion mémoire, allocation dynamique | **Architectures matérielles et OS** |
| Data centers IA en France | Stockage de données, souveraineté | **Données structurées / Sociétal** |
| OpenClaw / Moltbook | Agents autonomes, systèmes distribués, sécurité | **Architectures / Sociétal** |
| Falcon Heavy (2018) | Boucles, conditions, temps réel | **Langages et programmation** |

106
news/2026-02-10.md Normal file
View File

@@ -0,0 +1,106 @@
# News NSI - Mardi 10 février 2026
---
## 1. ACTUALITÉS DU JOUR
### La CNIL inflige 5 millions d'euros d'amende à France Travail après une cyberattaque massive
En janvier 2026, la CNIL a sanctionné France Travail (ex-Pôle Emploi) d'une amende de **5 millions d'euros**. La raison : une cyberattaque survenue début 2024 a exposé les données personnelles de **36,8 millions de personnes** (nom, prénom, numéro de sécurité sociale...). Les pirates ont utilisé l'**ingénierie sociale** — ils ont manipulé des conseillers pour usurper leurs comptes. Le plus frappant : France Travail avait *identifié* les failles dans ses propres analyses de risques, mais ne les avait jamais corrigées.
> **Concept NSI** : Sécurisation des données, ingénierie sociale, traitement des données personnelles (RGPD).
>
> **Source** : [CNIL - Sanction France Travail](https://cnil.fr/fr/violation-de-donnees-sanction-5millions-france-travail) · [France Info](https://www.franceinfo.fr/internet/securite-sur-internet/cyberattaques/cyberattaque-france-travail-condamne-a-une-amende-de-5-millions-d-euros-par-la-cnil_7771793.html)
---
### 1er anniversaire du Sommet de Paris pour l'IA — Bilan ce mardi
Aujourd'hui même, la ministre déléguée à l'Intelligence Artificielle, Anne Le Hénanff, tient une conférence de presse pour dresser le bilan du **Sommet pour l'action sur l'IA**, organisé à Paris il y a exactement un an (10-11 février 2025). Ce sommet avait réuni plus de 100 pays au Grand Palais et abouti à une centaine d'engagements concrets sur l'IA de confiance. Un an après, où en est-on ?
> **Concept NSI** : Intelligence artificielle, enjeux éthiques du numérique, gouvernance des données.
>
> **Source** : [Économie.gouv.fr](https://presse.economie.gouv.fr/ip-conference-de-presse-a-loccasion-du-1er-anniversaire-du-sommet-de-paris-pour-laction-sur-lia-mardi-10-fevrier-2026/) · [Élysée](https://www.elysee.fr/sommet-pour-l-action-sur-l-ia)
---
### Python toujours n°1, mais la concurrence s'installe — Classement TIOBE février 2026
Le classement TIOBE de février 2026 confirme **Python** en tête avec **21,81 %** de parts, mais en recul de 2 points sur un an (son pic était à 27 % en juillet 2025). Le langage **C** remonte à la 2e place, et surprise : **R** (statistiques) et **Perl** (scripting) font un retour remarqué dans le top 20. Go, en revanche, chute hors du top 10.
> **Concept NSI** : Langages de programmation, paradigmes (impératif, fonctionnel), diversité des langages.
>
> **Source** : [Blog du Modérateur - Classement TIOBE février 2026](https://www.blogdumoderateur.com/20-langages-informatiques-populaires-fevrier-2026/)
---
### Mistral AI lance Devstral 2 et son assistant en ligne de commande
La pépite française **Mistral AI** a dévoilé **Devstral 2**, un modèle d'IA open source dédié au code, disponible en deux tailles (24B et 123B paramètres). Il supporte un contexte de **256 000 tokens** et est diffusé sous licence MIT/Apache. L'entreprise lance aussi **Mistral Vibe CLI**, un assistant en terminal qui permet de modifier du code en langage naturel — directement depuis la ligne de commande.
> **Concept NSI** : Programmation, interface en ligne de commande (CLI), modèles de langage, open source.
>
> **Source** : [Mistral AI](https://mistral.ai/news/devstral-2-vibe-cli) · [VentureBeat](https://venturebeat.com/ai/mistral-launches-powerful-devstral-2-coding-model-including-open-source)
---
### Bercy veut imposer la French Tech dans les achats numériques de l'État
Le 5 février, lors de l'événement « Je choisis la French Tech », le ministère de l'Économie a annoncé une **nouvelle doctrine d'achat numérique** : l'État devra désormais privilégier les solutions technologiques françaises dans ses marchés publics. Les groupes Renault et La Poste ont rejoint l'initiative. L'objectif : renforcer la **souveraineté numérique** de la France.
> **Concept NSI** : Souveraineté numérique, architecture client-serveur, hébergement des données.
>
> **Source** : [Clubic](https://www.clubic.com/actualite-599227-la-french-tech-doit-devenir-prioritaire-dans-les-achats-numeriques-de-l-etat-dit-bercy.html)
---
## 2. ANECDOTE HISTORIQUE — 10 février 1996
### Deep Blue vs Kasparov : le jour où une machine a battu un champion du monde aux échecs
**Contexte.** Le 10 février 1996 — il y a exactement 30 ans jour pour jour — débute à Philadelphie un match historique entre le champion du monde d'échecs **Garry Kasparov** et **Deep Blue**, un supercalculateur conçu par IBM. La machine pèse 700 kg, mesure 2 mètres de haut, et embarque **256 processeurs spécialisés** fonctionnant en parallèle, capables d'évaluer **200 millions de positions par seconde**.
**Ce qui s'est passé.** Lors de la première partie, Deep Blue réalise l'exploit : c'est la **première fois qu'un ordinateur bat un champion du monde en titre** dans des conditions réglementaires. Kasparov, déstabilisé, se ressaisit et remporte finalement le match 4-2. Mais la revanche de mai 1997 tournera en faveur de la machine (3½-2½), marquant un tournant dans l'histoire de l'IA.
**Lien avec le cours.** Deep Blue ne « comprend » pas les échecs. Il utilise un algorithme de **recherche par force brute** combiné à des **heuristiques d'évaluation** — exactement le type d'algorithmes que vous étudiez en NSI : parcours d'arbres, complexité algorithmique, optimisation.
**Vidéo INA** : [1997 : l'ordinateur bat Garry Kasparov, un tournant dans l'histoire des échecs](https://www.ina.fr/ina-eclaire-actu/1997-l-ordinateur-deep-blue-bat-garry-kasparov-un-tournant-dans-l-histoire-des-echecs)
**Exemple de code — Mini-évaluation d'un coup aux échecs (simplifié) :**
```python
def minimax(position, profondeur, est_maximisant):
"""Algorithme Minimax simplifié - utilisé par Deep Blue"""
if profondeur == 0 or position.est_finale():
return position.evaluer()
if est_maximisant:
meilleur = float('-inf')
for coup in position.coups_possibles():
position.jouer(coup)
score = minimax(position, profondeur - 1, False)
position.annuler(coup)
meilleur = max(meilleur, score)
return meilleur
else:
meilleur = float('+inf')
for coup in position.coups_possibles():
position.jouer(coup)
score = minimax(position, profondeur - 1, True)
position.annuler(coup)
meilleur = min(meilleur, score)
return meilleur
```
---
## 3. TABLEAU RÉCAPITULATIF — Concepts NSI abordés
| Actualité | Concepts NSI | Chapitre du programme |
|---|---|---|
| Amende CNIL / France Travail | Données personnelles, sécurité, RGPD | Données structurées, enjeux sociétaux |
| Anniversaire Sommet IA Paris | Intelligence artificielle, éthique | IA et enjeux sociétaux du numérique |
| Classement TIOBE (Python n°1) | Langages de programmation, paradigmes | Langages et programmation |
| Mistral AI — Devstral 2 | CLI, open source, modèles de langage | Interactions homme-machine, programmation |
| French Tech / souveraineté | Architecture réseau, hébergement | Architecture matérielle, réseaux |
| Deep Blue vs Kasparov (1996) | Algorithmes, arbres, complexité, récursivité | Algorithmique |

108
news/2026-02-13.md Normal file
View File

@@ -0,0 +1,108 @@
Now I have all the information I need. Let me compose the news.
# News NSI - Jeudi 13 février 2026
---
## 1. ACTUALITÉS
### OpenAI intègre de la publicité dans ChatGPT
OpenAI a commencé à afficher des publicités dans ChatGPT aux États-Unis. Les annonces apparaissent sur fond gris avec la mention "sponsorisé" et sont ciblées en fonction des recherches de l'utilisateur. Elles ne s'affichent pas sur les sujets sensibles (santé, politique). OpenAI justifie cette décision par le coût colossal de la puissance de calcul nécessaire pour faire tourner ses modèles d'IA.
**Concept NSI** : Modèles économiques du numérique (gratuit vs payant, données personnelles comme monnaie d'échange), traitement des données utilisateur.
> Source : [Journal du Geek](https://www.journaldugeek.com/2026/02/10/les-pubs-debarquent-dans-chatgpt-quel-impact-sur-vos-recherches/) · [Clubic](https://www.clubic.com/actualite-599755-la-pub-debarque-dans-la-version-gratuite-de-chatgpt-mais-aussi-dans-la-version-payante.html)
---
### Patch Tuesday : Microsoft corrige 6 failles zero-day exploitées activement
Le 11 février, Microsoft a publié son Patch Tuesday corrigeant 59 vulnérabilités dont **6 failles zero-day** (= failles inconnues des développeurs mais déjà utilisées par des attaquants). Parmi elles : un simple clic sur un lien malveillant pouvait contourner toutes les protections de Windows, et une autre permettait d'obtenir les droits administrateur complets (privilèges SYSTEM) sur une machine.
**Concept NSI** : Sécurité informatique, gestion des vulnérabilités, élévation de privilèges, importance des mises à jour.
> Source : [IT-Connect](https://www.it-connect.fr/patch-tuesday-fevrier-2026-recapitulatif/) · [BleepingComputer](https://www.bleepingcomputer.com/news/microsoft/microsoft-february-2026-patch-tuesday-fixes-6-zero-days-58-flaws/)
---
### La France, 2e pays le plus cyberattaqué en Europe
Selon un rapport de Check Point, la France est désormais le **2e pays le plus ciblé en Europe** avec 13 % des attaques. Les groupes hacktivistes pro-russes (Noname057(16), Keymous+) coordonnent leurs campagnes via Telegram. Le groupe de ransomware Qilin a mené 51 attaques en France. En parallèle, une faille dans le système des cartes grises a permis une fraude massive à l'immatriculation.
**Concept NSI** : Réseaux, protocoles de communication, architectures client-serveur, chiffrement.
> Source : [Siècle Digital](https://siecledigital.fr/2026/02/12/cybersecurite-2026-lia-accelere-les-attaques-la-france-en-premiere-ligne/)
---
### Classement TIOBE février 2026 : Python toujours n°1, R fait son retour
Le classement TIOBE de popularité des langages de programmation place toujours **Python en tête** avec 21,81 % (+10 points d'avance sur le 2e). Le podium : Python, C, C++. Surprise : le langage **R** (statistiques et data science) remonte de la 15e à la 8e place en un an. Go chute de 8 places et sort du top 10.
**Concept NSI** : Langages de programmation, diversité des paradigmes (impératif, fonctionnel, objet), Python en cours de NSI.
> Source : [Blog du Modérateur](https://www.blogdumoderateur.com/20-langages-informatiques-populaires-fevrier-2026/) · [Programmez](https://www.programmez.com/actualites/index-tiobe-fevrier-2026-python-c-et-c-sur-le-podium-progression-de-r-39002)
---
### 48 % des Français utilisent l'IA, 85 % des 18-24 ans
Le Baromètre du numérique 2026 (Arcep/Arcom/ANCT) révèle que **près d'un Français sur deux** utilise désormais l'intelligence artificielle. Chez les 18-24 ans, le chiffre grimpe à 85 %, dont **73 % pour l'aide aux devoirs**. La France compte plus de 1 000 startups IA, formant le 1er écosystème du secteur en UE, avec 2,6 milliards d'euros levés en 2025.
**Concept NSI** : Algorithmes, apprentissage automatique, traitement automatique du langage, enjeux sociétaux du numérique.
> Source : [Vie publique](https://www.vie-publique.fr/en-bref/301989-barometre-du-numerique-2026-48-dutilisateurs-de-lia) · [Presse-citron](https://www.presse-citron.net/les-chiffres-de-lia-en-france-en-2026-4-changements-impressionnants/)
---
## 2. ANECDOTE HISTORIQUE
### Il y a 30 ans : Deep Blue bat Kasparov pour la première fois (10-17 février 1996)
**Contexte** : En février 1996, IBM organise à Philadelphie un match en 6 parties entre son superordinateur **Deep Blue** et le champion du monde d'échecs **Garry Kasparov**. C'est la première fois qu'un ordinateur affronte un champion du monde en titre dans des conditions de tournoi officiel.
**Ce qui s'est passé** : Le 10 février 1996, Deep Blue remporte la première partie — c'est la **première victoire d'un ordinateur contre un champion du monde** en cadence lente. La machine pesait 700 kg, mesurait 2 mètres et embarquait **256 processeurs spécialisés** travaillant en parallèle, capables d'évaluer 200 millions de positions par seconde. Kasparov finit par remporter le match 4-2, mais l'exploit de la machine fait le tour du monde. Un an plus tard, en mai 1997, une version améliorée ("Deeper Blue") battra Kasparov 3½ - 2½.
**Lien avec le cours NSI** : Cet événement illustre parfaitement les notions d'**algorithmes de recherche** (minimax, élagage alpha-bêta), de **structures de données arborescentes** (arbre de jeu), et de **complexité algorithmique**. Deep Blue n'était pas "intelligent" : il explorait des millions de branches possibles par force brute, guidé par des heuristiques. C'est un exemple concret de la puissance — et des limites — du calcul.
**Vidéo INA** : [1997 : l'ordinateur Deep Blue bat Kasparov - INA](https://www.ina.fr/ina-eclaire-actu/1997-l-ordinateur-deep-blue-bat-garry-kasparov-un-tournant-dans-l-histoire-des-echecs)
**Exemple simplifié — Algorithme Minimax en Python** :
```python
def minimax(plateau, profondeur, est_maximisant):
"""Algorithme minimax simplifié pour un jeu à deux joueurs."""
if profondeur == 0 or partie_terminee(plateau):
return evaluer(plateau)
if est_maximisant:
meilleur = float('-inf')
for coup in coups_possibles(plateau):
jouer(plateau, coup)
score = minimax(plateau, profondeur - 1, False)
annuler(plateau, coup)
meilleur = max(meilleur, score)
return meilleur
else:
meilleur = float('inf')
for coup in coups_possibles(plateau):
jouer(plateau, coup)
score = minimax(plateau, profondeur - 1, True)
annuler(plateau, coup)
meilleur = min(meilleur, score)
return meilleur
```
---
## 3. TABLEAU RÉCAPITULATIF
| Actualité | Concept NSI | Lien programme Première |
|---|---|---|
| Publicité dans ChatGPT | Modèles économiques, données personnelles | Impacts sociétaux du numérique |
| Patch Tuesday (6 zero-days) | Vulnérabilités, élévation de privilèges | Sécurité, systèmes d'exploitation |
| France 2e pays cyberattaqué | Réseaux, protocoles, chiffrement | Architecture réseau, protocoles |
| Classement TIOBE (Python n°1) | Langages de programmation, paradigmes | Python, diversité des langages |
| 48 % des Français utilisent l'IA | Algorithmes, apprentissage automatique | Algorithmes, traitement de données |
| Deep Blue vs Kasparov (1996) | Minimax, arbres, complexité | Algorithmes de recherche, récursivité |

89
news/2026-03-03.md Normal file
View File

@@ -0,0 +1,89 @@
# News NSI - Mardi 3 mars 2026
---
## 1. Actualités du jour
### Quasi-blackout d'Internet en Iran : la cyberguerre en action
Depuis le 28 février, l'Iran subit un **blackout Internet quasi-total** : la connectivité nationale est tombée à environ **1 % de son niveau normal**. Ce blackout combine une **coupure ordonnée par l'État** et des **cyberattaques externes** visant les infrastructures de télécommunications, dans le contexte des frappes militaires américano-israéliennes (opération « Roar of the Lion »). En parallèle, des groupes affiliés à l'Iran lancent des attaques DDoS en représailles.
**Concept NSI :** Réseaux informatiques — Comment fonctionne Internet à l'échelle d'un pays ? Un État peut-il vraiment « couper » Internet ? Cela touche aux notions de **routage, protocoles TCP/IP et architecture décentralisée** du réseau.
> Source : [The Register](https://www.theregister.com/2026/03/02/iran_internet_blackout/) · [CNBC](https://www.cnbc.com/2026/03/02/irans-internet-down-amid-reports-of-us-israel-cyberattacks.html)
---
### L'iPhone et l'iPad certifiés par l'OTAN pour les données classifiées
Apple a annoncé que l'iPhone et l'iPad sont les **premiers appareils grand public** autorisés à traiter des informations classifiées au niveau « NATO Restricted ». L'évaluation a été menée par le **BSI allemand** (l'équivalent de l'ANSSI). Les appareils, sous iOS 18, s'appuient sur le **chiffrement natif**, la biométrie Face ID et des protections mémoire avancées — **sans logiciel tiers** supplémentaire.
**Concept NSI :** Sécurité informatique — Chiffrement des données, authentification biométrique, protection de la mémoire. Comment un système d'exploitation peut-il garantir la confidentialité des données ?
> Source : [Apple Newsroom](https://www.apple.com/newsroom/2026/02/iphone-and-ipad-approved-to-handle-classified-nato-information/) · [MacRumors](https://www.macrumors.com/2026/02/26/nato-classified-data-iphone-ipad/)
---
### L'IA Act européen : les obligations se précisent avant août 2026
Le **règlement européen sur l'IA** (AI Act), entré en vigueur en août 2024, poursuit son calendrier d'application progressive. En **août 2026**, les règles complètes s'appliqueront aux systèmes d'IA à **haut risque** (biométrie, éducation, emploi, justice). Les entreprises doivent garantir **transparence, traçabilité et responsabilité** de leurs algorithmes, sous peine d'amendes pouvant atteindre **35 millions d'euros**.
**Concept NSI :** Données structurées et algorithmes — Qu'est-ce qu'un algorithme « à haut risque » ? Comment documenter et rendre transparent le fonctionnement d'un programme ? Cela soulève aussi les enjeux **éthiques** du numérique.
> Source : [Direction générale des Entreprises](https://www.entreprises.gouv.fr/decryptages-de-nos-experts/le-reglement-europeen-sur-lintelligence-artificielle-publics-concernes) · [Vie publique](https://www.vie-publique.fr/questions-reponses/292157-intelligence-artificielle-le-cadre-juridique-europeen-de-lia)
---
### Python toujours roi, Rust en embuscade : les langages en 2026
En 2026, **Python** conserve sa place de leader incontesté grâce à l'IA et la data science. **JavaScript** reste incontournable pour le web. La nouveauté : **Rust** continue sa progression fulgurante, apprécié pour sa **gestion mémoire sûre sans ramasse-miettes**. Côté tendance, les développeurs deviennent des « reviewer-architectes » : l'IA écrit le code, le développeur le vérifie et le valide.
**Concept NSI :** Langages de programmation — Pourquoi existe-t-il autant de langages ? Différences entre langages interprétés (Python) et compilés (Rust). Notion de **typage**, de **gestion mémoire** et de choix d'outils selon le contexte.
> Source : [Dunod](https://www.dunod.com/11-langages-programmation-incontournables-en-2026) · [WeLoveDevs](https://welovedevs.com/articles/les-3-tendances-tech-qui-vont-redefinir-le-role-du-developpeur-dans-les-5-prochaines-annees/)
---
### Un Français sur deux utilise l'IA générative
Selon le **Baromètre du numérique 2026**, **48 % des Français** ont utilisé l'IA générative (ChatGPT, Claude, Gemini…). ChatGPT compte désormais environ **1 milliard d'utilisateurs mensuels** dans le monde. Un service encore confidentiel il y a deux ans est devenu un outil du quotidien — y compris pour les lycéens.
**Concept NSI :** Intelligence artificielle et traitement des données — Comment fonctionne un modèle de langage ? Notions de **corpus d'entraînement**, de **probabilités** et de génération de texte. Quel impact sur la fiabilité de l'information ?
> Source : [Vie publique](https://www.vie-publique.fr/en-bref/301989-barometre-du-numerique-2026-48-dutilisateurs-de-lia) · [BPI France](https://bigmedia.bpifrance.fr/nos-dossiers/nouvelles-tendances-ia-ce-qui-va-transformer-2026)
---
## 2. Anecdote historique
### 3 mars 1975 — Le Homebrew Computer Club : le garage où tout a commencé
**Contexte :** En 1975, les ordinateurs sont des machines énormes réservées aux entreprises et aux universités. Le micro-ordinateur n'existe pas encore dans le commerce. Mais un petit kit en pièces détachées, l'**Altair 8800**, vient de sortir et fait rêver les bidouilleurs.
**Ce qui s'est passé :** Le **3 mars 1975**, une trentaine de passionnés d'électronique se retrouvent dans le **garage de Gordon French**, à Menlo Park en Californie, pour la première réunion du **Homebrew Computer Club**. Parmi eux, un ingénieur timide de 24 ans, **Steve Wozniak**, traîné là par un ami. C'est dans ce club que Wozniak trouvera l'inspiration pour concevoir l'**Apple I**, qu'il présente aux membres du club quelques mois plus tard. Son ami **Steve Jobs** y voit un potentiel commercial : **Apple Computer** naîtra un an après.
**Le lien avec le cours :** Ce club illustre parfaitement la **culture du partage** en informatique. Wozniak voulait distribuer ses plans gratuitement (philosophie du logiciel libre avant l'heure !). C'est aussi un exemple concret de la façon dont un **projet personnel** dans un garage peut devenir une entreprise qui change le monde. En NSI, quand vous codez vos premiers programmes en Python, vous êtes les héritiers de ces bricoleurs.
```python
# L'Altair 8800 se programmait en binaire via des interrupteurs !
# Voici ce que donnerait un "Hello World" traduit en binaire :
message = "Hello World"
binaire = ' '.join(format(ord(c), '08b') for c in message)
print(f"En binaire : {binaire}")
# → 01001000 01100101 01101100 01101100 01101111 ...
```
> Source : [Computer History Museum](https://www.computerhistory.org/tdih/march/3/) · [Wikipedia](https://en.wikipedia.org/wiki/Homebrew_Computer_Club)
---
## 3. Tableau récapitulatif des concepts NSI
| Actualité | Concept NSI | Chapitre du programme |
|---|---|---|
| Blackout Internet en Iran | Réseaux, protocoles TCP/IP, routage | Architectures matérielles et OS |
| iPhone certifié OTAN | Chiffrement, authentification, sécurité | Données structurées / Sécurité |
| IA Act européen | Éthique, transparence des algorithmes | Impact social et éthique du numérique |
| Langages 2026 (Python, Rust) | Langages interprétés vs compilés, typage | Langages et programmation |
| 48 % des Français utilisent l'IA | Modèles de données, probabilités | Traitement de données / Algorithmes |
| Homebrew Computer Club (1975) | Histoire de l'informatique, open source | Histoire de l'informatique |

123
news/2026-03-10.md Normal file
View File

@@ -0,0 +1,123 @@
# News NSI - Mardi 10 Mars 2026
---
## 🗞️ ACTUALITÉS DU JOUR
---
### 1. 💉 Fuite de données : 15 millions de dossiers médicaux français exposés
**Ce qui s'est passé :** Une intrusion dans le système `MonLogicielMedical.com` de l'éditeur Cegedim a compromis les données de santé de 11 à 15 millions de Français : noms, dates de naissance, numéros de sécurité sociale et historiques médicaux.
**Pourquoi c'est important pour vous ?** Vos données de santé sont parmi les plus sensibles qui existent. Une fois volées, elles peuvent servir à l'usurpation d'identité ou à des arnaques ciblées (phishing médical).
**Concept NSI lié :** **Sécurité des données personnelles** — chiffrement, RGPD, notion de donnée sensible vs. publique, bases de données.
> *Source : [IT-Connect - Actualités Cybersécurité](https://www.it-connect.fr/actualites/actu-securite/) / [dcod.ch](https://dcod.ch/2026/03/04/ia-cybersecurite-les-9-actus-cles-du-4-mar-2026/)*
---
### 2. 🤖 Des hackers utilisent l'IA pour fabriquer des malwares à la chaîne
**Ce qui s'est passé :** Le groupe de hackers *Transparent Tribe* (lié au Pakistan) utilise des outils de codage assistés par IA pour produire des malwares en masse, dans des langages peu courants comme **Nim**, **Zig** ou **Crystal**, et les fait communiquer via Slack ou Discord pour échapper à la détection.
**Pourquoi c'est important pour vous ?** L'IA ne sert pas qu'à faire des dissertations — elle devient un outil d'attaque. La cybersécurité doit évoluer aussi vite que les menaces.
**Concept NSI lié :** **Langages de programmation** — diversité des langages, notion de compilé/interprété ; **réseaux** — protocoles de communication détournés.
> *Source : [BleepingComputer - Microsoft: Hackers abusing AI](https://www.bleepingcomputer.com/news/security/microsoft-hackers-abusing-ai-at-every-stage-of-cyberattacks/)*
---
### 3. 🦊 Firefox 148 : un panneau de contrôle pour l'IA intégrée au navigateur
**Ce qui s'est passé :** Mozilla a publié **Firefox 148** avec un tableau de bord centralisé permettant aux utilisateurs d'activer, désactiver ou configurer finement toutes les fonctionnalités d'IA du navigateur (suggestions, résumés automatiques, etc.).
**Pourquoi c'est important pour vous ?** Votre navigateur est une porte d'entrée vers toutes vos données. Savoir ce que l'IA embarquée peut ou ne peut pas faire relève de votre vie privée numérique.
**Concept NSI lié :** **Interfaces homme-machine (IHM)** — paramétrage utilisateur, consentement éclairé, architecture logicielle d'un navigateur.
> *Source : [dcod.ch - IA & Cybersécurité mars 2026](https://dcod.ch/2026/03/04/ia-cybersecurite-les-9-actus-cles-du-4-mar-2026/)*
---
### 4. 🇪🇺 L'AI Act européen entre progressivement en vigueur
**Ce qui s'est passé :** La réglementation européenne sur l'IA (**AI Act**) impose désormais aux entreprises des obligations de **transparence**, de **traçabilité** et de **responsabilité** pour tout système d'IA à haut risque. La France mise sur **Mistral AI** pour réduire sa dépendance aux géants américains et chinois.
**Pourquoi c'est important pour vous ?** Vous vivrez et travaillerez dans un monde où l'IA est régulée. Comprendre ces règles, c'est comprendre comment la société encadre la technologie.
**Concept NSI lié :** **Éthique et société numérique** — algorithmes de décision, biais, responsabilité des systèmes automatisés.
> *Source : [BPIFrance - Nouvelles tendances IA 2026](https://bigmedia.bpifrance.fr/nos-dossiers/nouvelles-tendances-ia-ce-qui-va-transformer-2026)*
---
### 5. 🛡️ OpenAI lance Codex Security : une IA qui chasse les bugs de sécurité
**Ce qui s'est passé :** OpenAI a déployé **Codex Security**, un agent IA capable de scanner automatiquement du code source, de valider des vulnérabilités et de proposer des correctifs, directement intégré dans les workflows des développeurs.
**Pourquoi c'est important pour vous ?** Demain, écrire du code ne suffira plus — il faudra aussi savoir si ce code est sûr. Des outils comme celui-ci vont changer le métier de développeur.
**Concept NSI lié :** **Mise au point de programmes** — débogage, tests, notion de vulnérabilité logicielle (buffer overflow, injection…).
> *Source : [Help Net Security - Patch Tuesday Mars 2026](https://www.helpnetsecurity.com/2026/03/06/march-2026-patch-tuesday-forecast/)*
---
## 📜 ANECDOTE HISTORIQUE
### Le Ver Morris (1988) : le premier ver internet de l'histoire
**Contexte :** En 1988, Internet (alors appelé ARPANET) est encore un réseau académique et militaire. Moins de 60 000 machines y sont connectées. La sécurité ? Presque inexistante.
**Ce qui s'est passé :** Le 2 novembre 1988, **Robert Tappan Morris**, étudiant de 23 ans à Cornell, lâche un programme autoreplicant sur le réseau. En quelques heures, le **Ver Morris** infecte entre 6 000 et 9 000 machines (soit ~10% d'Internet !). Il exploite des failles dans `sendmail`, `fingerd` et `rsh/rexec` d'Unix, se copie de machine en machine, et ralentit tellement les serveurs qu'ils deviennent inutilisables.
Morris prétendra avoir voulu mesurer la taille d'Internet — pas provoquer de dommages. Mais les dégâts sont estimés entre **100 000 $ et 10 millions de $**.
**La suite :** Morris devient le premier condamné sous le *Computer Fraud and Abuse Act* américain. Il écope de 3 ans de probation, 400 heures de travaux d'intérêt général et 10 000 $ d'amende. Il fondera plus tard la startup **Y Combinator** (qui financera Airbnb, Dropbox, Reddit...).
**Lien avec le cours :**
- **Réseaux** : propagation d'un programme via des protocoles réseau (TCP/IP)
- **Systèmes d'exploitation** : exploitation de failles dans des services Unix
- **Algorithmes** : le ver utilise une boucle de reproduction — un algorithme récursif appliqué à des machines distantes
**Exemple simplifié du principe (Python pédagogique) :**
```python
# Principe TRÈS simplifié d'un programme autoreplicant (éducatif uniquement)
import os
def se_copier_sur(machine_distante):
"""Simule la logique de copie d'un ver (fictif)"""
code_source = open(__file__).read()
# En vrai : envoi via socket réseau vers la machine cible
print(f"Copie de {len(code_source)} octets vers {machine_distante}")
machines_connues = ["machine_A", "machine_B", "machine_C"]
for machine in machines_connues:
se_copier_sur(machine)
```
> Le vrai ver Morris exploitait un `gets()` sans vérification de taille (buffer overflow) — une faille qu'on apprend encore aujourd'hui à éviter !
**Vidéo / Source :**
- [Article Wikipedia - Ver Morris](https://fr.wikipedia.org/wiki/Ver_Morris)
- [Robert Morris interviewé par le MIT (YouTube)](https://www.youtube.com/results?search_query=Robert+Morris+worm+1988+interview)
---
## 📊 TABLEAU RÉCAPITULATIF — Concepts NSI abordés
| # | Actualité | Concept NSI | Niveau |
|---|-----------|-------------|--------|
| 1 | Fuite données médicales | Sécurité des données, RGPD, BDD | Première |
| 2 | Hackers & IA / malwares | Langages de programmation, réseaux | Première |
| 3 | Firefox 148 & IA | IHM, architecture logicielle | Première |
| 4 | AI Act européen | Éthique numérique, algorithmes | Première |
| 5 | Codex Security (OpenAI) | Mise au point, tests, vulnérabilités | Première |
| 📜 | Ver Morris (1988) | Réseaux TCP/IP, OS, algorithmes | Première/Terminale |
---
*Sources principales : [dcod.ch](https://dcod.ch/2026/03/04/ia-cybersecurite-les-9-actus-cles-du-4-mar-2026/) • [BleepingComputer](https://www.bleepingcomputer.com/news/security/microsoft-hackers-abusing-ai-at-every-stage-of-cyberattacks/) • [Help Net Security](https://www.helpnetsecurity.com/2026/03/06/march-2026-patch-tuesday-forecast/) • [BPIFrance BigMedia](https://bigmedia.bpifrance.fr/nos-dossiers/nouvelles-tendances-ia-ce-qui-va-transformer-2026) • [IT-Connect](https://www.it-connect.fr/actualites/actu-securite/)*

119
news/2026-03-13.md Normal file
View File

@@ -0,0 +1,119 @@
# News NSI - Vendredi 13 Mars 2026
---
## 🗞️ ACTUALITÉS DU JOUR
### 1. 🏥 Cyberattaque "wiper" contre Stryker — les hackers iraniens frappent le secteur médical
**Ce qui s'est passé :** Le groupe d'hackers lié à l'Iran a déployé un malware de type **wiper** contre Stryker, géant mondial des technologies médicales. Un wiper ne vole pas les données — il les **efface définitivement**, rendant les systèmes inutilisables.
**Pourquoi c'est important pour vous :** Dans un hôpital, un système informatique planté peut mettre des vies en danger. La cybersécurité dans le secteur médical est désormais une question de sécurité nationale.
**Concept NSI lié :** `Sécurité des systèmes` — intégrité des données, notion de malware, attaque destructrice vs vol de données.
**Source :** [CybersecurityNews](https://cybersecuritynews.com/stryker-cyber-attack/)
---
### 2. 🔧 Microsoft Patch Tuesday — 78 failles corrigées dont un zero-day exploité
**Ce qui s'est passé :** Chaque deuxième mardi du mois, Microsoft publie ses correctifs de sécurité. Ce mois-ci : **78 vulnérabilités** corrigées sur Windows, Office, Azure et .NET — dont un **zero-day** (faille inconnue du public, déjà exploitée par des attaquants avant que Microsoft ne la détecte).
**Pourquoi c'est important pour vous :** Quand on dit "mettez à jour votre système", c'est exactement pour ça. Google a aussi patché **129 failles Android** le même jour.
**Concept NSI lié :** `Vulnérabilité logicielle` — bug, correctif (patch), cycle de vie d'un logiciel, CVE (Common Vulnerabilities and Exposures).
**Source :** [Help Net Security](https://www.helpnetsecurity.com/2026/03/11/march-2026-patch-tuesday/)
---
### 3. 🦀 VENON : un malware bancaire écrit en Rust pour tromper les antivirus
**Ce qui s'est passé :** Des chercheurs ont découvert **VENON**, un nouveau malware bancaire ciblant les utilisateurs brésiliens. Sa particularité : il est écrit en **Rust**, un langage de programmation moderne réputé pour ses performances et sa sécurité... mais aussi de plus en plus utilisé par les pirates précisément parce que les antivirus le reconnaissent moins bien.
**Pourquoi c'est important pour vous :** Le choix du langage de programmation a des conséquences réelles sur la sécurité. Rust est au programme de certaines grandes entreprises tech (Microsoft, Google) pour remplacer le C.
**Concept NSI lié :** `Langages de programmation` — compilation, langage bas niveau vs haut niveau, détection de signature par antivirus.
```rust
// Exemple de Rust : gestion mémoire sans garbage collector
fn main() {
let donnees = String::from("données sensibles");
// La mémoire est libérée automatiquement à la fin du scope
// Pas de pointeurs dangereux comme en C
} // ← mémoire libérée ici
```
**Source :** [The Hacker News](https://thehackernews.com/)
---
### 4. 🤖 Les "sociétés d'IA" : quand les agents IA commencent à se comporter comme des humains
**Ce qui s'est passé :** La revue scientifique *Nature* publie une analyse sur l'émergence des **sociétés multi-agents** : des systèmes où plusieurs IA interagissent entre elles, développent des comportements collectifs, des "normes sociales" et des hiérarchies spontanées — sans que les programmeurs ne l'aient prévu.
**Pourquoi c'est important pour vous :** On ne programme plus une seule IA, mais des **écosystèmes d'agents**. Cela soulève des questions fondamentales : qui est responsable quand personne n'a programmé le comportement qui en résulte ?
**Concept NSI lié :** `Intelligence Artificielle` — systèmes multi-agents, apprentissage par renforcement, comportements émergents.
**Source :** [Nature](https://www.nature.com/articles/d41586-026-00070-5)
---
### 5. 🇫🇷 La France investit massivement dans la "Deeptech souveraine"
**Ce qui s'est passé :** Bpifrance lance le programme **"Deeptech Seed"** pour financer des chercheurs-entrepreneurs dès la naissance de leurs projets en informatique quantique, fusion nucléaire et IA de pointe. Parallèlement, selon le baromètre Allianz 2026, l'IA est passée de la **10e à la 2e place** des risques majeurs pour les entreprises mondiales en un an.
**Pourquoi c'est important pour vous :** La France mise sur sa "souveraineté numérique" — ne pas dépendre uniquement des géants américains ou chinois pour ses technologies critiques.
**Concept NSI lié :** `Informatique quantique` — qubits, superposition, différence avec l'ordinateur classique. `Enjeux sociétaux du numérique`.
**Source :** [Dynamique Mag](https://www.dynamique-mag.com/article/l-entrepreneuriat-en-france-en-2026-le-temps-des-batisseurs-et-de-la-deeptech-souveraine)
---
## 📜 ANECDOTE HISTORIQUE
### 🕹️ 13 mars 1988 : Lancement de la première version d'Ethernet à 10 Mbps dans les bureaux — et la naissance du réseau local
**Contexte :** À la fin des années 80, les ordinateurs dans une entreprise ne se "parlaient" pas. Chaque machine était une île. Partager un fichier signifiait le copier sur une disquette et marcher physiquement jusqu'à l'autre bureau — ce que les informaticiens appelaient le **"sneakernet"** (réseau à baskets).
**Ce qui s'est passé :** Le standard **Ethernet** (inventé par Robert Metcalfe chez Xerox PARC dès 1973, mais standardisé et démocratisé à la fin des années 80) transforme progressivement les bureaux en réseaux locaux (LAN). En 1988, Ethernet 10BASE-T (câble à paires torsadées, 10 Mbps) commence à s'imposer. Pour la première fois, on peut envoyer un fichier à un collègue **sans bouger de sa chaise**.
**L'anecdote :** Robert Metcalfe a prédit en 1995 que l'internet allait "s'effondrer de façon catastrophique en 1996". Il a dû manger littéralement un article de journal devant une salle pleine lors d'une conférence en 1997, après avoir eu tort. C'est la **loi de Metcalfe** (la valeur d'un réseau est proportionnelle au carré du nombre de ses utilisateurs) qui porte son nom.
**Lien avec le cours :** C'est l'ancêtre direct de votre box internet et du Wi-Fi. Le protocole TCP/IP, les adresses MAC, les trames réseau — tout ce que vous étudiez en NSI vient de là.
```
Topologie Ethernet (années 80) :
[PC 1] ──┬── [câble coaxial] ──┬── [PC 3]
│ │
[PC 2] [PC 4]
└──── BUS UNIQUE ────┘
(si le câble casse → tout le réseau tombe !)
Topologie actuelle (étoile) :
[PC 1] ──┐
[PC 2] ──┤── [Switch] ── [Routeur] ── Internet
[PC 3] ──┘
```
**Pour aller plus loin :** [INA — Les premiers réseaux informatiques en France](https://www.ina.fr) *(rechercher "réseau informatique" dans les archives)*
---
## 📊 TABLEAU RÉCAPITULATIF DES CONCEPTS NSI
| # | Actualité | Concept NSI | Niveau |
|---|-----------|-------------|--------|
| 1 | Attaque wiper Stryker | Sécurité — intégrité des données, malware | Première |
| 2 | Patch Tuesday Microsoft | Vulnérabilités logicielles, cycle de vie, CVE | Première |
| 3 | Malware VENON en Rust | Langages de programmation, compilation | Première |
| 4 | Sociétés d'IA (Nature) | Intelligence artificielle, multi-agents | Première / Terminale |
| 5 | Deeptech France | Informatique quantique, enjeux sociétaux | Première / Terminale |
| 📜 | Ethernet (1988) | Réseaux, protocoles, topologie LAN | Première |
---
*Sources : CybersecurityNews, Help Net Security, The Hacker News, Nature, Usine Digitale, Dynamique Mag*

94
news/2026-03-17.md Normal file
View File

@@ -0,0 +1,94 @@
# News NSI - Mardi 17 Mars 2026
---
## 🔐 ACTUALITÉS
### 1. Microsoft colmate 84 failles dont 2 zero-days
**Source :** [dcod.ch](https://dcod.ch/2026/03/16/vulnerabilites-les-11-alertes-critiques-du-16-mar-2026/)
Le Patch Tuesday de mars 2026 est arrivé avec une liste chargée : 84 vulnérabilités corrigées par Microsoft, dont 2 **zero-days** — c'est-à-dire des failles déjà connues des attaquants *avant* que Microsoft n'ait eu le temps de les corriger. Dans la même semaine, le logiciel de sauvegarde Veeam Backup 13 a reçu un correctif pour 3 failles critiques permettant l'exécution de code à distance.
> 💡 **Concept NSI :** *Sécurité des systèmes* — Une faille zero-day exploite une vulnérabilité dans un programme avant que le développeur ait publié un correctif. C'est la course entre attaquants et défenseurs. En NSI, cela illustre pourquoi la gestion de la mémoire (buffer overflow, injection) est un sujet fondamental en programmation.
---
### 2. Cyberguerre Iran : internet quasi coupé, 1 100 navires GPS brouillés
**Source :** [dcod.ch](https://dcod.ch/2026/03/10/cyberattaques-les-12-incidents-majeurs-du-10-mars-2026/)
Après des frappes militaires fin février 2026, l'Iran a vu sa connectivité internet chuter à seulement **4 % de son niveau normal**. Simultanément, environ **1 100 navires** ont subi des perturbations de leur GPS — une attaque appelée *GPS spoofing* qui consiste à envoyer de faux signaux de localisation. Des caméras de circulation ont également été piratées à distance.
> 💡 **Concept NSI :** *Réseaux & protocoles* — Internet repose sur une infrastructure physique (câbles, routeurs, FAI). Une "coupure" peut être volontaire (blocage des AS — systèmes autonomes) ou due à des dommages physiques. Le GPS spoofing montre que les protocoles sans authentification forte sont vulnérables.
---
### 3. Course aux LLM : GPT-5, Claude Sonnet 5, Gemini 3.1 en quelques semaines
**Source :** [gptbox.fr](https://gptbox.fr/actus/recaps/actualites-ia-mars-2026)
Février-mars 2026 est déjà baptisé "le mois de tous les records" en IA. OpenAI, Anthropic et Google ont chacun sorti de nouveaux modèles de langage (LLM) en l'espace de quelques semaines. Samsung vise 800 millions d'appareils intégrant Gemini d'ici fin 2026. La course à la puissance de calcul s'accélère.
> 💡 **Concept NSI :** *Intelligence artificielle* — Un LLM (Large Language Model) est un réseau de neurones entraîné sur des milliards de textes. Sa puissance est mesurée en paramètres (ex : 700 milliards). En NSI Terminale, vous étudierez les bases des réseaux de neurones et leur entraînement.
---
### 4. Pasqal, la start-up française d'informatique quantique, lève 340 M€
**Source :** [lemondeinformatique.fr](https://www.lemondeinformatique.fr/actualites/toute-l-actualite.html)
La pépite française **Pasqal**, spécialisée dans l'**informatique quantique**, a levé 340 millions d'euros et est valorisée à 2 milliards de dollars. Une introduction en Bourse au Nasdaq est prévue en 2026. Basée à Massy (Essonne), l'entreprise développe des processeurs à base d'atomes neutres refroidis par laser.
> 💡 **Concept NSI :** *Représentation de l'information* — Un ordinateur classique manipule des **bits** (0 ou 1). Un ordinateur quantique utilise des **qubits** qui peuvent être 0, 1 ou les deux à la fois (superposition). Cette propriété permettrait de résoudre certains problèmes (cryptographie, optimisation) des millions de fois plus vite.
---
### 5. CERT-FR : la cybermenace française se professionnalise
**Source :** [xmco.fr](https://www.xmco.fr/resume-de-la-semaine-fr/resume-de-la-semaine-11-du-9-au-13-mars-2026/)
Le **CERT-FR** (Agence gouvernementale française de cybersécurité, rattachée à l'ANSSI) a publié son panorama annuel de la cybermenace 2025. Conclusion : les attaques contre les organisations françaises sont de plus en plus structurées et professionnalisées. Une opération internationale coordonnée par Europol a démantelé le botnet **SocksEscort** : 23 serveurs saisis, ~1 million de box internet compromises déconnectées.
> 💡 **Concept NSI :** *Réseaux & cybersécurité* — Un **botnet** est un réseau de machines infectées contrôlées à distance par un attaquant (le "bot herder"). Les machines zombies sont utilisées pour des attaques DDoS, du spam ou du minage de cryptomonnaies sans que leurs propriétaires le sachent.
---
## 🕹️ ANECDOTE HISTORIQUE
### Le ver Morris (1988) : le premier malware d'Internet
**Contexte :** En 1988, Internet ne comptait que quelques dizaines de milliers de machines, principalement des universités et laboratoires américains. Les notions de "sécurité informatique" étaient quasi inexistantes.
**Ce qui s'est passé :** Le **2 novembre 1988**, Robert Tappan Morris, étudiant de 23 ans à Cornell, lance depuis le MIT un programme expérimental censé mesurer la taille d'Internet. Le programme exploite trois vulnérabilités Unix (dont un *buffer overflow* dans `fingerd` et une faille dans `sendmail`). Problème : une erreur de code le fait se répliquer *sans limite*. En quelques heures, plusieurs milliers de machines sont paralysées. C'est le **premier ver informatique** d'Internet.
**Conséquences :** Morris est le premier condamné aux États-Unis sous le *Computer Fraud and Abuse Act* (400 heures de travaux d'intérêt général, 10 000 $ d'amende). L'incident a directement conduit à la création du **CERT** (Computer Emergency Response Team) — le modèle sur lequel s'est basé le CERT-FR actuel.
**Lien avec le cours :**
```python
# Exemple simplifié : un buffer overflow en C (concept)
# En Python, ce risque n'existe pas directement grâce au typage dynamique
# Mais illustre pourquoi valider les entrées utilisateur est ESSENTIEL
def lire_commande(entree_utilisateur):
# MAUVAIS : exécuter directement ce que l'utilisateur envoie
# eval(entree_utilisateur) ← DANGER : injection de code !
# BON : valider et filtrer
commandes_autorisees = ["bonjour", "aide", "quitter"]
if entree_utilisateur in commandes_autorisees:
return entree_utilisateur
else:
return "Commande inconnue"
```
> Le ver Morris a 38 ans, mais ses techniques (buffer overflow, exploitation de services réseau) sont toujours au cœur des vulnérabilités corrigées chaque mois par Microsoft. L'actualité du jour boucle la boucle.
---
## 📊 TABLEAU RÉCAPITULATIF
| Concept NSI | Lié à | Programme Première/Terminale |
|---|---|---|
| Vulnérabilité / Zero-day | Actu 1 — Patch Tuesday | Sécurité des systèmes |
| Réseaux (AS, routage) | Actu 2 — Iran coupure internet | Architecture des réseaux |
| Protocoles non sécurisés (GPS) | Actu 2 — GPS spoofing | Protocoles réseau |
| Intelligence artificielle / LLM | Actu 3 — GPT-5, Gemini 3.1 | IA & données |
| Qubit / Informatique quantique | Actu 4 — Pasqal | Représentation de l'information |
| Botnet / Malware | Actu 5 — SocksEscort | Cybersécurité |
| Buffer overflow / Injection | Anecdote — Ver Morris 1988 | Programmation sécurisée |

118
news/2026-03-24.md Normal file
View File

@@ -0,0 +1,118 @@
# News NSI - Mardi 24 mars 2026
---
## 🗞️ ACTUALITÉS
---
### 1. La guerre des IA : GPT-5.4, Claude Sonnet 4.6 et Gemini 3.1 arrivent en même temps
**Ce qui s'est passé :** OpenAI, Anthropic et Google ont publié à quelques jours d'intervalle de nouvelles versions majeures de leurs modèles d'IA. Les performances sont si proches que les experts parlent de "course au coude à coude". Plus notable encore : le protocole **MCP (Model Context Protocol)** inventé par Anthropic est devenu le standard universel pour connecter des agents IA à des outils externes — désormais adopté par OpenAI, Microsoft et Google.
**Concept NSI lié :** Protocoles de communication, API, interopérabilité des systèmes
> 💡 Un protocole, c'est comme une langue commune. Ici, MCP permet à un programme IA de "parler" à n'importe quel outil (agenda, base de données, navigateur...) de façon standardisée — exactement comme HTTP permet à n'importe quel navigateur de parler à n'importe quel serveur web.
*Source : [iaboosts.com](https://iaboosts.com/nouveautes-ia-mars-2026/)*
---
### 2. Android sous attaque : le malware "Perseus" vole vos mots de passe
**Ce qui s'est passé :** Un nouveau logiciel malveillant baptisé **Perseus** cible les smartphones Android. Une fois installé (souvent via une fausse application), il exfiltre les mots de passe, les données bancaires et les identifiants. Il a été identifié cette semaine par plusieurs chercheurs en sécurité.
**Concept NSI lié :** Cybersécurité, logiciels malveillants (malware), chiffrement des données
> 💡 Perseus illustre pourquoi le **principe du moindre privilège** est fondamental : une application ne devrait accéder qu'aux ressources strictement nécessaires. Sur Android, chaque app doit demander des permissions — refuser celles non justifiées réduit la surface d'attaque.
*Source : [dcod.ch](https://dcod.ch/2026/03/22/cybersecurite-les-16-actualites-majeures-du-22-mars-2026/)*
---
### 3. Supply chain attack : un outil de sécurité open source empoisonné
**Ce qui s'est passé :** Des attaquants ont publié une fausse version de **Trivy** (v0.69.4), un outil open source populaire qui analyse la sécurité des conteneurs. Cette version malveillante contenait un script qui volait automatiquement les secrets (tokens, clés API) dans les pipelines CI/CD des développeurs qui la téléchargeaient.
**Concept NSI lié :** Open source, chaîne de dépendances logicielles, intégrité des données (hachage)
> 💡 C'est une **attaque par chaîne d'approvisionnement** (*supply chain attack*) : on ne cible pas directement la victime, mais un outil dont elle dépend. La parade ? Vérifier le **hash SHA-256** de chaque téléchargement — une signature numérique unique qui change dès qu'un seul octet est modifié.
*Source : [LeMagIT / Cyberhebdo](https://www.lemagit.fr/actualites/366640539/Cyberhebdo-du-20-mars-2026-des-services-publics-frappes-dans-le-monde-entier)*
---
### 4. Ransomware : des services publics paralysés dans le monde entier
**Ce qui s'est passé :** Mi-mars 2026, plusieurs collectivités publiques ont été frappées par des **ransomwares** : le comté de Lucas (Ohio) a vu ses portails publics hors ligne, la ville de Foster City a perdu l'accès à ses services. En France, la Stratégie Nationale de Cybersécurité 2026–2030 vient d'être publiée pour mieux protéger les administrations.
**Concept NSI lié :** Chiffrement, ransomware, sauvegardes (politique 3-2-1)
> 💡 Un ransomware **chiffre** tous les fichiers de la victime et réclame une rançon pour la clé de déchiffrement. La meilleure défense reste la **règle de sauvegarde 3-2-1** : 3 copies, sur 2 supports différents, dont 1 hors ligne (déconnectée du réseau).
*Source : [GlobalSecurityMag](https://www.globalsecuritymag.fr/bulletin-d-actualite-certfr-2026-act-012-23-mars-2026.html)*
---
### 5. French Tech : 1,14 milliard d'euros levés en une semaine
**Ce qui s'est passé :** La semaine du 16 mars, les startups françaises ont levé **1,14 milliard d'euros**. Parmi elles, **Pigment** — une startup parisienne d'IA pour la planification financière — dont les clients sont Uber, Unilever et Siemens. Elle approche les 100 millions de dollars de revenus annuels récurrents.
**Concept NSI lié :** Intelligence artificielle, modèles prédictifs, données structurées
> 💡 Pigment utilise l'IA pour analyser des millions de données financières et produire des **prévisions**. C'est un cas concret d'**apprentissage automatique supervisé** appliqué à des données tabulaires — le type de données que vous manipulez avec Python et pandas.
*Source : [French Tech Updates](https://frenchtechupdates.beehiiv.com/p/march-16-2026)*
---
## 📼 ANECDOTE HISTORIQUE
### 1991 — Linux est né dans une chambre d'étudiant
**Contexte :** En 1991, Linus Torvalds est un étudiant finlandais de 21 ans à l'Université d'Helsinki. Il utilise MINIX, un mini-Unix éducatif, mais il en est frustré : il ne peut pas le modifier librement.
**Ce qui s'est passé :** Le **25 août 1991**, Linus poste ce message légendaire sur le forum Usenet :
```
Hello everybody out there using minix -
I'm doing a (free) operating system (just a hobby, won't be
big and professional like gnu) for 386(486) AT clones.
```
Il publie le noyau Linux 0.01 : **10 239 lignes de C**. Trente-cinq ans plus tard, le noyau Linux 6.x en compte **plus de 30 millions**. Il fait tourner 97 % des serveurs web mondiaux, Android, et... la quasi-totalité des supercalculateurs de la planète.
**Lien avec le cours :**
- **Architecture matérielle / logicielle** : un système d'exploitation gère la mémoire, les processus, les entrées/sorties — tout ce que vous étudiez en NSI
- **Open source et licences** : Linux est sous licence **GPL** — le code source est librement consultable, modifiable et redistribuable (mais les modifications doivent rester ouvertes)
- **Langage C** : le noyau Linux est écrit en C, le langage qui a inspiré Python, Java et presque tous les langages modernes
**Mini-exemple — le premier "Hello, world" en C (style 1991) :**
```c
#include <stdio.h>
int main() {
printf("Hello, world!\n");
return 0;
}
```
> 🎬 **À regarder** : [INA — reportage FR3 sur Linux et le logiciel libre (années 90)](https://www.ina.fr) *(rechercher "Linux logiciel libre" sur ina.fr)*
---
## 📊 TABLEAU RÉCAPITULATIF
| # | Actualité | Concept NSI | Niveau |
|---|-----------|-------------|--------|
| 1 | Guerre des IA (GPT-5.4 / Claude / Gemini) | Protocoles, API, interopérabilité | Terminale |
| 2 | Malware Perseus (Android) | Cybersécurité, permissions, principe du moindre privilège | Première |
| 3 | Trivy empoisonné (supply chain) | Hachage SHA-256, intégrité, open source | Première / Terminale |
| 4 | Ransomware sur services publics | Chiffrement symétrique, sauvegardes 3-2-1 | Première |
| 5 | French Tech : 1,14 Md€ levés | IA, apprentissage supervisé, données tabulaires | Première / Terminale |
| H | Linux né en 1991 | OS, open source, langage C, architecture | Première |
---
*Généré le 24/03/2026 — Sources : LeMagIT, GlobalSecurityMag, dcod.ch, iaboosts.com, French Tech Updates*

153
news/2026-03-27.md Normal file
View File

@@ -0,0 +1,153 @@
# News NSI - Vendredi 27 Mars 2026
---
## 🗞️ ACTUALITÉS DU JOUR
---
### 1. 🤖 Un agent IA de Meta provoque une fuite de données interne
**Ce qui s'est passé :** Un agent IA utilisé en interne chez Meta a donné un mauvais conseil technique, déclenchant un incident de sécurité de niveau élevé. Des employés ont pu accéder temporairement à des données sensibles d'autres utilisateurs.
**Pour les lycéens :** Même les systèmes les plus sophistiqués peuvent se tromper. Un agent IA, c'est un programme qui prend des décisions de façon autonome — mais s'il n'est pas bien encadré, ses erreurs peuvent avoir de vraies conséquences sur la confidentialité des données.
**Concept NSI :** Systèmes autonomes, confidentialité des données, sécurité informatique
**Source :** [IA & Cybersécurité — 25 mars 2026](https://dcod.ch/2026/03/25/ia-cybersecurite-les-4-actus-cles-du-25-mar-2026/)
---
### 2. 🇫🇷 Mistral déploie un assistant IA souverain pour 30 000 agents de l'État français
**Ce qui s'est passé :** La startup française Mistral AI, en partenariat avec la DINUM (Direction Interministérielle du Numérique), déploie **Le Chat** comme assistant IA pour 30 000 fonctionnaires français. L'objectif : ne pas dépendre de solutions américaines comme ChatGPT.
**Pour les lycéens :** La **souveraineté numérique**, c'est la capacité d'un pays à contrôler ses propres données et outils informatiques. La France parie sur ses propres entreprises tech pour ne pas confier ses données d'État à des acteurs étrangers.
**Concept NSI :** Souveraineté numérique, modèles de langage (LLM), données publiques
**Source :** [IA Made in France — ia-info.fr](https://www.ia-info.fr/16-mars-2026-ce-qu-il-faut-retenir-sur-l-intelligence-artificielle.html)
---
### 3. 🛒 Faille critique sur Magento/Adobe Commerce : des milliers de boutiques exposées
**Ce qui s'est passé :** Une nouvelle vulnérabilité baptisée **PolyShell** touche les plateformes e-commerce Magento Open Source et Adobe Commerce. Elle permet à un attaquant non authentifié d'uploader un fichier malveillant via l'API REST et d'exécuter du code sur le serveur. Depuis le 19 mars, plus de 50 adresses IP scannent activement les sites vulnérables.
**Pour les lycéens :** Une **API REST** permet à deux programmes de communiquer via le Web. Si elle est mal sécurisée, un attaquant peut s'en servir comme porte d'entrée — sans même avoir de mot de passe. C'est typiquement ce qu'on appelle une **injection de code**.
**Concept NSI :** API, requêtes HTTP, failles de sécurité, injection de code
**Source :** [The Hacker News](https://thehackernews.com/)
---
### 4. 🎣 Phishing par "device code" : 340 organisations ciblées dans le monde
**Ce qui s'est passé :** Des chercheurs en cybersécurité ont découvert une campagne active de **phishing par code d'appareil** ciblant des comptes Microsoft 365 dans plus de 340 organisations aux États-Unis, Canada, Australie, Nouvelle-Zélande et Allemagne.
**Pour les lycéens :** Le **phishing** (hameçonnage) consiste à tromper un utilisateur pour lui voler ses identifiants. La variante "device code" exploite un mécanisme d'authentification prévu pour les appareils sans clavier (télés connectées, etc.) pour générer un faux lien de connexion. L'utilisateur croit se connecter normalement, mais il donne en réalité accès à son compte.
**Concept NSI :** Authentification, protocoles de sécurité, ingénierie sociale
**Source :** [The Hacker News](https://thehackernews.com/)
---
### 5. 🦊 Firefox 148 intègre un tableau de bord de contrôle de l'IA
**Ce qui s'est passé :** Mozilla a publié **Firefox 148** avec un nouveau panneau centralisé permettant aux utilisateurs de gérer ou désactiver toutes les fonctionnalités d'intelligence artificielle intégrées au navigateur.
**Pour les lycéens :** De plus en plus de logiciels intègrent de l'IA par défaut. Mozilla fait le choix de donner le **contrôle à l'utilisateur** — c'est un enjeu important : qui décide de ce que fait l'IA pour vous ?
**Concept NSI :** Navigateur web, vie privée, interface utilisateur, consentement numérique
**Source :** [IA & Cybersécurité — 25 mars 2026](https://dcod.ch/2026/03/25/ia-cybersecurite-les-4-actus-cles-du-25-mar-2026/)
---
## 📼 ANECDOTE HISTORIQUE
### Le Bug de l'An 2000 (Y2K) — 1999/2000
**Contexte :** Dans les années 60 à 80, pour économiser de la mémoire (qui coûtait très cher), les développeurs stockaient les années sur **2 chiffres** seulement : `99` pour 1999, `85` pour 1985.
**Ce qui s'est passé :** À l'approche de l'an 2000, les informaticiens ont réalisé que les systèmes allaient interpréter `00` comme 1900 et non 2000. Résultat : des avions qui n'auraient plus su calculer leur âge de maintenance, des centrales nucléaires avec des horloges cassées, des banques incapables de calculer les intérêts…
Des milliers d'ingénieurs ont travaillé des années pour corriger le problème. Le coût mondial a été estimé à **300 milliards de dollars**. Et le 1er janvier 2000, finalement... presque rien de grave ne s'est passé — grâce à ce travail colossal en coulisses.
**Lien avec le cours :** C'est l'illustration parfaite que le **choix d'une représentation des données** a des conséquences à long terme. En NSI, quand on code une date, on réfléchit toujours au format : entier, chaîne, timestamp...
**Exemple de code (Python) :**
```python
# Le problème Y2K en simplifié :
annee_sur_2_chiffres = 99
annee_reelle = 1900 + annee_sur_2_chiffres # → 1999 ✓
annee_sur_2_chiffres = 0 # Le 1er janvier 2000...
annee_reelle = 1900 + annee_sur_2_chiffres # → 1900 ✗ Bug !
# La solution : stocker sur 4 chiffres
from datetime import date
aujourd_hui = date.today()
print(aujourd_hui.year) # → 2026, pas d'ambiguïté
```
**Source :** [Chronologie de l'informatique — Wikipédia](https://fr.wikipedia.org/wiki/Chronologie_de_l'informatique)
---
### 6. 🧠 Google compresse les modèles IA grâce aux distances entre vecteurs
**Ce qui s'est passé :** Des chercheurs de Google ont publié des travaux sur la **quantification vectorielle** appliquée aux modèles d'IA. Un modèle comme Gemini contient des milliards de paramètres — des listes de nombres décimaux très précis — qui occupent des dizaines de gigaoctets en RAM. L'idée de Google : remplacer ces nombres précis par des **coordonnées** pointant vers un petit dictionnaire de valeurs pré-calculées, en utilisant la **distance** pour trouver la valeur la plus proche. Le gain en mémoire peut atteindre un facteur 8, sans perte notable de qualité.
**Pour les lycéens :** Un modèle d'IA stocke ses "connaissances" sous forme de **vecteurs** — des listes de nombres comme `[0.83, -1.47, 0.21, ...]`. Stocker des millions de tels vecteurs avec une grande précision coûte énormément de RAM. La technique de Google construit d'abord un petit **dictionnaire** de vecteurs représentatifs (quelques milliers d'entrées). Ensuite, pour chaque vecteur du modèle, on calcule lequel dans le dictionnaire est le plus **proche** (en mesurant une distance, comme en géométrie), et on stocke uniquement **son numéro**. Au lieu de stocker 100 nombres décimaux, on stocke juste un entier. La RAM nécessaire s'effondre.
**Analogie :** Tu dois noter 1000 nuances de couleurs différentes. Au lieu d'écrire les valeurs RGB exactes de chacune (ex. `(231, 87, 43)`), tu crées une palette de 16 couleurs standards, et pour chaque nuance tu notes juste "couleur n°7" — la plus proche. Tu perds un peu de précision, mais tu divises la taille de tes notes par 10.
**Concept NSI :** Vecteurs (listes), distance, représentation des données, compromis précision/mémoire
**Exemple de code (Python — illustration simplifiée) :**
```python
import math
# Un vecteur du modèle (valeurs précises, coûteuses à stocker)
vecteur = [0.83, -1.47, 0.21]
# Dictionnaire de vecteurs représentatifs (beaucoup plus petit)
dictionnaire = [
[1.0, -1.5, 0.0], # entrée 0
[0.8, -1.4, 0.2], # entrée 1
[-0.5, 0.3, 1.1], # entrée 2
]
def distance(a, b):
return math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))
# On cherche l'entrée la plus proche dans le dictionnaire
plus_proche = min(range(len(dictionnaire)),
key=lambda i: distance(vecteur, dictionnaire[i]))
print(f"On stocke juste l'indice : {plus_proche}") # → 1
# Au lieu de stocker [0.83, -1.47, 0.21], on stocke juste "1"
```
**Source :** [Quantization research — Google DeepMind](https://arxiv.org/abs/2305.13245)
---
## 📊 TABLEAU RÉCAPITULATIF — Concepts NSI du jour
| Concept NSI | News associée | Niveau |
|---|---|---|
| Agents IA autonomes | Fuite de données chez Meta | Terminale |
| Souveraineté numérique & LLM | Mistral pour l'État français | Première |
| API REST & injection de code | Faille PolyShell / Magento | Première |
| Authentification & phishing | Campagne device code | Première |
| Interface utilisateur & vie privée | Firefox 148 | Seconde |
| Représentation des données (dates) | Bug de l'an 2000 | Première |
| Vecteurs & optimisation mémoire | GQA de Google (KV-cache) | Première |
---
*Sources : [dcod.ch](https://dcod.ch/2026/03/25/ia-cybersecurite-les-4-actus-cles-du-25-mar-2026/) · [thehackernews.com](https://thehackernews.com/) · [ia-info.fr](https://www.ia-info.fr/16-mars-2026-ce-qu-il-faut-retenir-sur-l-intelligence-artificielle.html) · [servicesmobiles.fr](https://www.servicesmobiles.fr/rapport-cybersecurite-2026-attaques-cloud-et-ia-redessinent-les-risques-111050) · [wikipedia.org](https://fr.wikipedia.org/wiki/Chronologie_de_l'informatique)*

122
news/2026-04-07.md Normal file
View File

@@ -0,0 +1,122 @@
# News NSI - Mardi 07 Avril 2026
---
## ACTUALITÉS
---
### 1. Le compte npm d'Axios piraté — 100 millions d'utilisateurs exposés
**Ce qui s'est passé :** Des cybercriminels ont compromis le compte npm d'Axios, une bibliothèque JavaScript utilisée pour faire des requêtes HTTP. Avec plus de **100 millions de téléchargements par semaine**, cette attaque illustre ce qu'on appelle une **attaque sur la chaîne d'approvisionnement logicielle** (*supply chain attack*) : en corrompant une dépendance, on infecte des milliers de projets d'un seul coup.
**Concept NSI lié :** Réseaux / Sécurité — protocoles HTTP, intégrité des paquets, gestion des dépendances
**Pourquoi c'est important pour toi :** Quand tu fais `pip install` ou `npm install`, tu fais confiance à un registre centralisé. Si ce registre est compromis, ton programme peut embarquer du code malveillant sans que tu le saches.
> Source : [Epitech — Actualités Tech et IA du 03 avril 2026](https://www.epitech.eu/2026/04/06/actualite-tech-et-ia-03-04-2026/)
---
### 2. Anthropic publie accidentellement le code source de Claude Code sur npm
**Ce qui s'est passé :** Anthropic, l'entreprise derrière Claude (l'IA qui me fait tourner), a publié par erreur un fichier *source map* sur le registre npm, exposant **1 900 fichiers TypeScript** — soit le code source interne de Claude Code. Une erreur humaine dans le processus de déploiement.
**Concept NSI lié :** Programmation — open source vs propriétaire, registres de paquets, déploiement logiciel
**Ce que ça illustre :** Même les meilleures équipes d'ingénieurs font des erreurs de configuration. La gestion des secrets et des publications automatisées est un vrai défi en entreprise.
> Source : [IT-Connect — Actualités Cybersécurité](https://www.it-connect.fr/actualites/actu-securite/) · [Epitech](https://www.epitech.eu/2026/04/06/actualite-tech-et-ia-03-04-2026/)
---
### 3. Faille critique dans Langflow exploitée en moins de 24h
**Ce qui s'est passé :** La faille **CVE-2026-33017** dans Langflow (un outil pour créer des pipelines d'IA) est passée de *"découverte"* à *"exploitée activement"* en moins de 24 heures. Le malware associé s'effaçait automatiquement après infection, rendant sa détection quasi impossible par les antivirus classiques.
**Concept NSI lié :** Cybersécurité — CVE (Common Vulnerabilities and Exposures), cycle de vie d'une vulnérabilité, antivirus et détection
**À retenir :** Un numéro CVE est l'identifiant officiel d'une faille. Entre la publication d'un CVE et le déploiement du correctif, les attaquants ont souvent une fenêtre d'opportunité. C'est la course aux patchs.
> Source : [CERT-FR](https://www.cert.ssi.gouv.fr/) · [Epitech](https://www.epitech.eu/2026/04/06/actualite-tech-et-ia-03-04-2026/)
---
### 4. Mistral AI lève 830 M$ pour construire un data center en région parisienne
**Ce qui s'est passé :** La startup française Mistral AI (fondée à Paris en 2023) vient de lever **830 millions de dollars** pour construire un data center à **Bruyères-le-Châtel** (Essonne), qui accueillera **13 800 puces Nvidia GB300**. Mistral, avec 2,9 milliards de dollars levés au total, est la startup d'IA la mieux financée d'Europe.
**Concept NSI lié :** Architecture — GPU vs CPU, infrastructure cloud, souveraineté numérique
**Enjeu de souveraineté :** Avoir des centres de calcul en France permet de ne pas dépendre uniquement des géants américains (AWS, Google Cloud, Azure) pour faire tourner des IA européennes. C'est un enjeu politique et stratégique fort en 2026.
> Source : [SIDE Blog — IA actualités semaine](https://alain.goudey.eu/side/2026/04/05/intelligence-artificielle-6-actualites-qui-redessinent-la-semaine-des-decideurs/) · [Indeed Hiring Lab France](https://www.hiringlab.org/fr/blog/2026/04/01/avril-2026-lia-progresse-dans-un-marche-du-travail-en-recul/)
---
### 5. L'IA transforme les métiers — même hors de la tech
**Ce qui s'est passé :** Selon Indeed Hiring Lab, alors que le marché de l'emploi général **recule**, les offres d'emploi mentionnant l'IA **progressent de +6 à +8 points** dans les métiers tech, mais aussi dans le **marketing, la gestion de projet et les RH**.
**Concept NSI lié :** Impact sociétal du numérique — automatisation, collaboration humain-machine
**Ce que ça veut dire pour toi :** Peu importe ton futur métier, savoir interagir avec des outils d'IA (et comprendre leurs limites) devient une compétence de base, comme savoir utiliser un tableur dans les années 2000.
> Source : [Indeed Hiring Lab France — Avril 2026](https://www.hiringlab.org/fr/blog/2026/04/01/avril-2026-lia-progresse-dans-un-marche-du-travail-en-recul/)
---
## ANECDOTE HISTORIQUE
### Le Bug de l'An 2000 (Y2K) — La panique numérique mondiale
**Contexte — Années 1960 à 1990**
Quand les premiers programmeurs codaient des logiciels dans les années 60-70, la mémoire était **extrêmement rare et chère**. Pour économiser de l'espace, ils stockaient les années sur **2 chiffres** au lieu de 4 : `75` pour `1975`, `98` pour `1998`.
**Ce qui s'est passé le 1er janvier 2000**
En théorie, au passage à l'an 2000, les systèmes auraient interprété `00` comme... **1900**. Des avions auraient pu croire voler en 1900, des banques calculer des intérêts sur un siècle, des centrales nucléaires perdre leur horloge interne.
Des **milliards de dollars** ont été dépensés dans le monde entier pour auditer et corriger des milliers de systèmes. En France, des équipes entières de développeurs ont travaillé des années à réécrire du code COBOL vieux de 30 ans.
Le passage s'est finalement fait **sans catastrophe majeure** — preuve que la mobilisation a fonctionné. Mais certains systèmes mineurs ont bien planté.
**Lien avec le cours**
- **Représentation des données** : stocker `2` octets au lieu de `4` pour une année semblait anodin... mais ce choix a coûté des millions 30 ans plus tard.
- **Dette technique** : un mauvais choix de conception se paie toujours, tôt ou tard.
- **Systèmes critiques** : certains codes COBOL des années 70 tournaient encore en production en l'an 2000 — et certains tournent encore aujourd'hui dans des banques.
```python
# Le bug en simplifié :
annee_stockee = 99 # stocké sur 2 chiffres
annee_suivante = (annee_stockee + 1) % 100 # → 0
print(f"Année interprétée : 19{annee_suivante:02d}") # → 1900 !
# La correction :
annee_complete = 1999
annee_suivante = annee_complete + 1 # → 2000, sans ambiguïté
```
**Pour aller plus loin**
- [INA — Le bogue de l'an 2000 au journal télévisé (1999)](https://www.ina.fr) *(rechercher "bogue an 2000" sur ina.fr)*
- [Wikipedia — Problème de l'an 2000](https://fr.wikipedia.org/wiki/Probl%C3%A8me_de_l%27an_2000)
---
## TABLEAU RÉCAPITULATIF
| Thème | Concept NSI | Niveau | News associée |
|---|---|---|---|
| Attaque supply chain (npm/Axios) | Réseaux, protocoles, sécurité | ★★★ | #1 |
| Fuite de code source (Anthropic) | Open/closed source, déploiement | ★★ | #2 |
| Faille CVE & exploitation rapide | Cybersécurité, CVE, antivirus | ★★★ | #3 |
| Data center & GPU (Mistral) | Architecture matérielle, cloud | ★★ | #4 |
| IA et marché du travail | Impact sociétal du numérique | ★ | #5 |
| Bug Y2K — représentation des données | Codage des données, mémoire | ★★ | Anecdote |
---
*Sources : [Epitech Tech&IA](https://www.epitech.eu/2026/04/06/actualite-tech-et-ia-03-04-2026/) · [Indeed Hiring Lab](https://www.hiringlab.org/fr/blog/2026/04/01/avril-2026-lia-progresse-dans-un-marche-du-travail-en-recul/) · [SIDE Blog IA](https://alain.goudey.eu/side/2026/04/05/intelligence-artificielle-6-actualites-qui-redessinent-la-semaine-des-decideurs/) · [CERT-FR](https://www.cert.ssi.gouv.fr/) · [IT-Connect](https://www.it-connect.fr/actualites/actu-securite/) · [Thales Cyber](https://cds.thalesgroup.com/fr/hot-topics/les-nouvelles-tendances-de-la-cybersecurite-2026)*

143
news/2026-06-02.md Normal file
View File

@@ -0,0 +1,143 @@
# News NSI - Lundi 2 Juin 2026
---
## 🗞️ ACTUALITÉS DU JOUR
---
### 1. Nvidia dévoile le RTX Spark : un "superchip" pour concurrencer Apple
**Annoncé le 27 mai 2026 au salon Computex, Taiwan**
Nvidia a présenté le [RTX Spark Superchip](https://www.tomshardware.com/laptops/nvidia-unveils-rtx-spark-superchip-at-computex-2026-new-platform-promises-to-turn-windows-into-an-agentic-ai-os-with-arm-cpu-blackwell-gpu-and-128gb-unified-memory), une puce révolutionnaire qui combine un processeur ARM (20 cœurs) et un GPU Blackwell (6 144 cœurs CUDA) avec jusqu'à 128 Go de mémoire unifiée. Objectif affiché : faire tourner Windows comme un OS "agentique IA", capable d'exécuter des modèles de 120 milliards de paramètres directement sur l'ordinateur, sans connexion cloud.
Les PC équipés de ce chip (Dell, HP, Lenovo, Microsoft Surface Ultra) promettent du jeu en 1440p à 100 FPS et de l'édition vidéo en 12K. Nvidia s'attaque directement aux puces M5 d'Apple.
**🔗 Concept NSI :** Architecture matérielle — CPU vs GPU, mémoire unifiée, parallélisme de calcul. La différence entre un processeur à quelques cœurs puissants (CPU) et un GPU avec des milliers de petits cœurs spécialisés dans les calculs parallèles.
**Source :** [Tom's Hardware – Computex 2026](https://www.tomshardware.com/laptops/nvidia-unveils-rtx-spark-superchip-at-computex-2026-new-platform-promises-to-turn-windows-into-an-agentic-ai-os-with-arm-cpu-blackwell-gpu-and-128gb-unified-memory)
---
### 2. Airbus choisit Mistral AI pour son intelligence artificielle souveraine
**Signé le 28 mai 2026 à Paris**
[Airbus a annoncé un contrat pluriannuel de plusieurs dizaines de millions d'euros avec Mistral AI](https://www.clubic.com/actualite-614539-airbus-choisit-le-francais-mistral-ai-pour-propulser-l-ia-souveraine-dans-ses-avions-et-ses-systemes-de-defense.html), la startup française spécialisée en IA. C'est la première fois qu'un grand industriel européen choisit publiquement un fournisseur d'IA européen pour des applications de défense et d'espace.
L'enjeu est la **souveraineté** : Airbus travaille sur des données hautement confidentielles liées à la sécurité nationale. Utiliser ChatGPT (américain) ou Gemini (Google) serait inenvisageable. Mistral permet un déploiement "on-premise" (sur leurs propres serveurs) sans fuite de données.
Le même jour, BMW et EDF ont aussi signé des partenariats avec Mistral AI.
**🔗 Concept NSI :** Données et vie privée — notion de souveraineté numérique, localisation des données, cloud vs on-premise. Qui possède les données ? Où sont-elles stockées ?
**Source :** [Clubic – Airbus & Mistral AI](https://www.clubic.com/actualite-614539-airbus-choisit-le-francais-mistral-ai-pour-propulser-l-ia-souveraine-dans-ses-avions-et-ses-systemes-de-defense.html)
---
### 3. Les agents IA autonomes : la nouvelle frontière de la cybersécurité
**Tendance lourde – Juin 2026**
[Les "agents IA"](https://siecledigital.fr/2025/12/30/cybersecurite-et-ia-ce-qui-attend-vraiment-les-entreprises-en-2026/) sont des programmes capables de prendre des décisions et d'agir seuls — naviguer sur le web, envoyer des emails, exécuter du code — sans intervention humaine. Ils sont de plus en plus déployés en entreprise pour automatiser des tâches répétitives.
Problème : ces agents ont souvent accès à des données sensibles et des permissions élevées, ce qui en fait des cibles de choix pour les hackers. En 2026, les experts en cybersécurité signalent une nouvelle forme d'attaque : compromettre un agent IA pour qu'il effectue des actions malveillantes à la place de l'humain qu'il est censé aider.
> "L'IA sera la norme en 2026 tant pour les attaquants que pour les défenseurs."
**🔗 Concept NSI :** Cybersécurité — notion de surface d'attaque, droits d'accès (permissions), principe du moindre privilège. Plus un programme a de droits, plus il est dangereux s'il est compromis.
**Source :** [Siècle Digital – Agents IA & Cybersécurité](https://siecledigital.fr/2025/12/30/cybersecurite-et-ia-ce-qui-attend-vraiment-les-entreprises-en-2026/)
---
### 4. 85 % des développeurs utilisent l'IA pour coder — mais avec quels risques ?
**Enquête JetBrains – publiée en 2025, toujours d'actualité**
Une enquête menée par JetBrains auprès de 25 000 développeurs révèle que [85 % d'entre eux utilisent des outils d'IA](https://www.darkreading.com/application-security/coders-adopt-ai-agents-security-pitfalls-lurk-2026) (GitHub Copilot, ChatGPT, Claude…) pour écrire du code, déboguer ou concevoir des applications. C'est une transformation radicale du métier de développeur en moins de 3 ans.
Revers de la médaille : le code généré par IA contient souvent des failles de sécurité que les développeurs n'identifient pas, faute de comprendre ce que la machine a écrit. Les experts parlent de **"vibe coding"** — coder à l'instinct avec l'IA sans vérifier.
**🔗 Concept NSI :** Programmation — lecture, compréhension et vérification du code. Un programme correct n'est pas forcément un programme sûr. L'importance de comprendre ce qu'on exécute.
**Source :** [Dark Reading – AI Agents & Security Pitfalls 2026](https://www.darkreading.com/application-security/coders-adopt-ai-agents-security-pitfalls-lurk-2026)
---
### 5. VivaTech 2026 : Paris capitale mondiale de l'IA dans 15 jours
**17–20 juin 2026 — Porte de Versailles, Paris**
Pour ses 10 ans, [VivaTech](https://www.franceinfo.fr/partenariats/evenement-viva-tech-le-rendez-vous-startup-et-tech-n-1-en-europe-revient-pour-ses-10-ans-a-paris-porte-de-versailles-du-17-au-20-juin-2026_8014112.html) sera le plus grand salon tech européen jamais organisé : 180 000 visiteurs attendus, 15 000 startups, 4 000 investisseurs. L'IA sera le thème central — mais une IA "concrète et applicable" dans la logistique, la santé, l'automobile, le luxe.
Point original : le 14 juin, les Champs-Élysées seront piétonnisés et transformés en un grand show tech gratuit avec robots, IA, mobilité et expériences immersives.
**🔗 Concept NSI :** Numérique & société — l'écosystème tech français, les startups, l'innovation. Comment une idée devient un produit qui transforme un secteur entier.
**Source :** [France Info – VivaTech 2026](https://www.franceinfo.fr/partenariats/evenement-viva-tech-le-rendez-vous-startup-et-tech-n-1-en-europe-revient-pour-ses-10-ans-a-paris-porte-de-versailles-du-17-au-20-juin-2026_8014112.html)
---
## 🕰️ ANECDOTE HISTORIQUE
### 11 mai 1997 : Deep Blue bat Kasparov — le jour où l'IA a vaincu l'homme aux échecs
**Contexte**
En 1997, Garry Kasparov est le champion du monde d'échecs incontesté depuis 12 ans. IBM a conçu **Deep Blue**, un supercalculateur capable d'analyser 200 millions de positions par seconde grâce à des puces dédiées. Il ne "comprend" pas les échecs — il explore un arbre de possibilités en profondeur grâce à l'algorithme **minimax** avec élagage alpha-bêta.
**Ce qui s'est passé**
Le 11 mai 1997, à New York, après un match en 6 parties, Deep Blue bat Kasparov 3,5 - 2,5. C'est la première fois dans l'histoire qu'un ordinateur bat le meilleur joueur humain du monde en conditions officielles. Kasparov, sous le choc, accuse IBM de triche. IBM refuse une revanche et… démantèle Deep Blue aussitôt.
> *"On sentait qu'on changeait de civilisation."* — Bruno Nahon, producteur présent au match
**Lien avec le cours**
Deep Blue n'utilise pas d'apprentissage automatique (Machine Learning) — c'est de la **force brute algorithmique** : parcourir un arbre de décision avec des heuristiques (règles d'évaluation d'une position). C'est l'opposé de l'IA moderne qui apprend de millions de parties. Cet événement a posé une question fondamentale : *l'intelligence, c'est quoi exactement ?*
**Lien INA** 📺
👉 [Vidéo INA — "1997 : l'ordinateur bat Garry Kasparov"](https://www.ina.fr/ina-eclaire-actu/1997-l-ordinateur-deep-blue-bat-garry-kasparov-un-tournant-dans-l-histoire-des-echecs)
**Extrait de l'algorithme Minimax (Python simplifié)**
```python
def minimax(position, profondeur, maximise):
if profondeur == 0:
return evaluer(position) # score de la position
if maximise:
meilleur = -infini
for coup in coups_possibles(position):
score = minimax(jouer(position, coup), profondeur - 1, False)
meilleur = max(meilleur, score)
return meilleur
else:
meilleur = +infini
for coup in coups_possibles(position):
score = minimax(jouer(position, coup), profondeur - 1, True)
meilleur = min(meilleur, score)
return meilleur
```
Deep Blue explorait cet arbre jusqu'à 12 niveaux de profondeur — soit des milliards de positions analysées en quelques secondes.
---
## 📊 TABLEAU RÉCAPITULATIF
| # | Actu / Anecdote | Concept NSI | Niveau |
|---|---|---|---|
| 1 | Nvidia RTX Spark Superchip | Architecture matérielle — CPU, GPU, mémoire | Chapitre : Arch. & OS |
| 2 | Airbus + Mistral AI | Données, souveraineté numérique, cloud | Chapitre : Données & réseau |
| 3 | Agents IA & cybersécurité | Cybersécurité, permissions, surface d'attaque | Chapitre : Cybersécurité |
| 4 | 85 % des devs utilisent l'IA | Programmation, lecture & vérification du code | Chapitre : Programmation |
| 5 | VivaTech 2026 Paris | Numérique & société, écosystème startup | Transversal |
| 🕰️ | Deep Blue vs Kasparov (1997) | Algorithmes — minimax, récursivité, arbres | Chapitre : Algo |
---
*Sources : [Tom's Hardware](https://www.tomshardware.com/laptops/nvidia-unveils-rtx-spark-superchip-at-computex-2026-new-platform-promises-to-turn-windows-into-an-agentic-ai-os-with-arm-cpu-blackwell-gpu-and-128gb-unified-memory) · [Clubic](https://www.clubic.com/actualite-614539-airbus-choisit-le-francais-mistral-ai-pour-propulser-l-ia-souveraine-dans-ses-avions-et-ses-systemes-de-defense.html) · [Siècle Digital](https://siecledigital.fr/2025/12/30/cybersecurite-et-ia-ce-qui-attend-vraiment-les-entreprises-en-2026/) · [Dark Reading](https://www.darkreading.com/application-security/coders-adopt-ai-agents-security-pitfalls-lurk-2026) · [France Info / VivaTech](https://www.franceinfo.fr/partenariats/evenement-viva-tech-le-rendez-vous-startup-et-tech-n-1-en-europe-revient-pour-ses-10-ans-a-paris-porte-de-versailles-du-17-au-20-juin-2026_8014112.html) · [INA – Deep Blue](https://www.ina.fr/ina-eclaire-actu/1997-l-ordinateur-deep-blue-bat-garry-kasparov-un-tournant-dans-l-histoire-des-echecs)*

50
news/generer-news.sh Executable file
View File

@@ -0,0 +1,50 @@
#!/bin/bash
# Script de génération automatique des news NSI
# Usage: ./generer-news.sh [--auto]
# --auto : mode automatique (pas de confirmation, écrase le fichier existant)
NEWS_DIR="/Users/florian/Documents/Cours/NSI/Premiere/news"
LOG_DIR="$NEWS_DIR/logs"
DATE=$(date +%Y-%m-%d)
DATE_FR=$(date +%d/%m/%Y)
FICHIER="$NEWS_DIR/$DATE.md"
LOG_FILE="$LOG_DIR/$DATE.log"
# Crée le dossier logs si nécessaire
mkdir -p "$LOG_DIR"
# Mode automatique ?
AUTO_MODE=false
if [ "$1" = "--auto" ]; then
AUTO_MODE=true
fi
# Vérifie si le fichier existe déjà
if [ -f "$FICHIER" ]; then
if [ "$AUTO_MODE" = true ]; then
echo "$(date): Fichier existe déjà, régénération en mode auto" >> "$LOG_FILE"
else
echo "Le fichier $FICHIER existe déjà."
read -p "Voulez-vous le regénérer ? (o/n) " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Oo]$ ]]; then
echo "Annulé."
exit 0
fi
fi
fi
echo "Génération des news NSI pour le $DATE..."
echo "$(date): Début de la génération" >> "$LOG_FILE"
# Appel à Claude Code pour générer les news (avec accès web)
claude --print --allowedTools "WebSearch,WebFetch" -- "Tu es un assistant pour un professeur de NSI en Première. Utilise WebSearch pour rechercher les actualités informatiques récentes du jour. IMPORTANT: Affiche UNIQUEMENT le contenu Markdown brut, sans aucun commentaire, question ou méta-texte. Pas de phrase d'introduction ni de conclusion hors du contenu. Génère les news du jour ($DATE_FR) au format Markdown avec : 1. ACTUALITÉS (3-5 news) sur cybersécurité, IA, programmation, tech française. Pour chaque news : titre, description adaptée lycéens 16-17 ans, concept NSI lié, source. 2. ANECDOTE HISTORIQUE (1) : Un fait marquant de l'informatique années 80/90/2000 avec contexte, ce qui s'est passé, lien avec le cours, et si possible lien vidéo INA ou code exemple. 3. TABLEAU RÉCAPITULATIF des concepts NSI abordés. Format : Markdown clair, pédagogique, engageant. Commence directement par # News NSI - [Jour] [Date]" > "$FICHIER"
if [ $? -eq 0 ]; then
echo "News générées avec succès : $FICHIER"
echo "$(date): Succès - $FICHIER" >> "$LOG_FILE"
else
echo "Erreur lors de la génération."
echo "$(date): ERREUR lors de la génération" >> "$LOG_FILE"
exit 1
fi