{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "
Classe Seconde
\n", "
\n", "
SNT
\n", "
\n", "

đŸ•”ïž Escape Game — Cyber-enquĂȘte Ă  La FlĂšche

\n", "
Sciences Numériques et Technologie · 6 énigmes · ~1h30
\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 🎬 Le mystĂšre\n", "\n", "Une cyber-enquĂȘte frappe La FlĂšche. Un message chiffrĂ© a Ă©tĂ© retrouvĂ© sur le smartphone d'un tĂ©moin.\n", "\n", "**Ta mission :** rĂ©soudre **6 Ă©nigmes** couvrant tout le programme SNT pour reconstituer un **code secret Ă  6 chiffres** et identifier le suspect.\n", "\n", "🔗 Si tu bloques, retrouve les cours sur [mathamine.fr/snt](https://mathamine.fr/snt/).\n", "\n", "## 📋 Consignes\n", "\n", "**1. ExĂ©cute la cellule \"Initialisation\" — elle gĂ©nĂšre TES donnĂ©es personnelles.**\n", "\n", "**2. Pour chaque Ă©nigme : complĂšte le code, puis appelle `verif_En(...)` pour valider.**\n", "\n", "**3. Note le chiffre indiquĂ© par chaque Ă©nigme validĂ©e.**\n", "\n", "**4. À la fin, colle les 6 chiffres pour former ton code secret.**\n", "\n", "---\n", "\n", "### Sommaire\n", "1. [⚙ Initialisation](#INIT)\n", "2. [🌐 Énigme 1 — Internet : reconstituer une IP](#E1)\n", "3. [🔍 Énigme 2 — Web : balises HTML](#E2)\n", "4. [📊 Énigme 3 — DonnĂ©es : filtrer un fichier](#E3)\n", "5. [đŸ—ș Énigme 4 — Cartographie : GPS et distance](#E4)\n", "6. [đŸ“· Énigme 5 — Photo numĂ©rique : pixels RVB](#E5)\n", "7. [🌍 Énigme 6 — RĂ©seaux sociaux : graphe](#E6)\n", "8. [🔐 Code final](#FINAL)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

⚙ Initialisation

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? info Comment ça marche ?\n", "\n", "Cette cellule gĂ©nĂšre tes donnĂ©es Ă  partir de ton identifiant Capytale.\n", "Tes donnĂ©es sont **toujours les mĂȘmes** si tu reviens sur cette activitĂ©.\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "from _init import *\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "
\n", "

🧰 Boüte à outils Python — à consulter en cas de besoin

\n", "
\n", "\n", "??? info 📩 Tuples : (a, b)\n", "\n", "Un **tuple** est une paire (ou triplet, etc.) de valeurs : `t = (3, 5)`.\n", "\n", "```python\n", "p = (1, 192)\n", "p[0] # → 1 (1er Ă©lĂ©ment)\n", "p[1] # → 192 (2e Ă©lĂ©ment)\n", "```\n", "\n", "**DĂ©baller** dans une boucle : `for seq, val in liste_de_couples:` donne directement chaque Ă©lĂ©ment.\n", "\n", "???\n", "\n", "??? info 📊 sorted() et tri par clĂ© (lambda)\n", "\n", "```python\n", "liste = [(3, 'C'), (1, 'A'), (2, 'B')]\n", "sorted(liste) # tri sur le 1er Ă©lĂ©ment par dĂ©faut\n", "sorted(liste, key=lambda p: p[0]) # idem, explicitement par p[0]\n", "sorted(liste, key=lambda p: p[1]) # tri sur le 2e Ă©lĂ©ment\n", "```\n", "\n", "**`lambda p: p[0]`** veut dire : « la clĂ© de tri = le premier Ă©lĂ©ment du tuple ».\n", "\n", "???\n", "\n", "??? info 📜 Listes en comprĂ©hension\n", "\n", "CondensĂ© d'une boucle qui construit une liste :\n", "\n", "```python\n", "[expression for Ă©lĂ©ment in liste]\n", "```\n", "\n", "Exemples :\n", "```python\n", "nombres = [1, 2, 3, 4]\n", "[n*10 for n in nombres] # → [10, 20, 30, 40]\n", "[val for (seq, val) in [(1,'A'),(2,'B')]] # → ['A', 'B']\n", "```\n", "\n", "???\n", "\n", "??? info 🔍 str.find() et tranches\n", "\n", "```python\n", "texte = \"Bonjour monde !\"\n", "i = texte.find(\"\") # position du dĂ©but\n", "j = texte.find(\"\", i) # cherche aprĂšs position i\n", "texte[i + len(\"\") : j] # → \"monde\"\n", "```\n", "\n", "Tranche : `texte[debut:fin]` extrait les caractĂšres entre les positions `debut` (inclus) et `fin` (exclu).\n", "\n", "???\n", "\n", "??? info 🔁 Boucle for + condition\n", "\n", "```python\n", "nb = 0\n", "for r in table:\n", " if r[\"classe\"] == \"2A\" and r[\"age\"] >= 15:\n", " nb = nb + 1\n", "```\n", "\n", "`and` = ET logique (les deux conditions doivent ĂȘtre vraies).\n", "\n", "???\n", "\n", "??? info 📐 math.cos() et radians\n", "\n", "Le module `math` fournit cos, sin, sqrt, etc. **En Python, les angles sont en radians**.\n", "\n", "```python\n", "import math\n", "math.cos(math.radians(60)) # cos(60°) = 0.5\n", "math.sqrt(9) # → 3.0\n", "math.radians(180) # → 3.1415... (π)\n", "```\n", "\n", "???\n", "\n", "??? info 📖 Dictionnaires : .items()\n", "\n", "```python\n", "graphe = {\"Alice\": [\"Bob\", \"Clara\"], \"Bob\": [\"Alice\"]}\n", "\n", "# Parcourir clĂ©s et valeurs ensemble :\n", "for nom, amis in graphe.items():\n", " print(nom, \"a\", len(amis), \"amis\")\n", "```\n", "\n", "`len(liste)` compte les Ă©lĂ©ments d'une liste.\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

🌐 Énigme 1 — Internet : Reconstituer une adresse IP

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? question Contexte\n", "\n", "Le pirate s'est connectĂ© Ă  un serveur depuis une machine X. Les 4 paquets contenant l'adresse IPv4 ont Ă©tĂ© interceptĂ©s **dans le dĂ©sordre**.\n", "\n", "Chaque paquet contient :\n", "- son **n° de sĂ©quence** (1, 2, 3 ou 4) — qui indique sa position dans l'adresse\n", "- la **valeur de l'octet** correspondant (entre 0 et 255)\n", "\n", "Reconstitue l'adresse IPv4 au format `a.b.c.d` en remettant les paquets dans l'ordre.\n", "\n", "Appelle `verif_E1(\"a.b.c.d\")` pour vĂ©rifier.\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? danger Rappel — Adresse IPv4\n", "\n", "Une adresse IPv4 est composĂ©e de **4 octets** (0–255) sĂ©parĂ©s par des points.\n", "\n", "Exemple : `192.168.1.42`\n", "\n", "L'octet n°1 est le plus Ă  gauche. 🔗 Voir [SNT Internet sur mathamine.fr](https://mathamine.fr/snt/cours_th1_internet.html).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? hint 💡 Indice rapide\n", "\n", "`sorted(liste, key=lambda p: p[0])` trie selon le 1er Ă©lĂ©ment du tuple. La syntaxe `[val for seq, val in liste]` ne garde que `val`.\n", "\n", "???\n", "\n", "??? note 📚 MĂ©thode + cours\n", "\n", "Un tuple `(seq, val)` se \"dĂ©balle\" en deux variables. Sur chaque couple :
\n", "- `p[0]` = `seq` (n° de séquence)
\n", "- `p[1]` = `val` (la valeur)

\n", "**Tri par clé** : `sorted(liste, key=lambda p: p[0])` trie en utilisant le 1er élément comme critÚre.
\n", "**Liste en comprĂ©hension** : `[val for seq, val in liste]` parcourt et garde seulement les `val`.\n", "\n", "🔗 **Concept SNT** : [Adresse IPv4](https://mathamine.fr/snt/cours_th1_internet.html) \n", "🐍 **Syntaxe Python** : [🧰 BoĂźte Ă  outils : tuples, sorted, lambda, listes en comprĂ©hension](#OUTILS) (en haut du notebook)\n", "\n", "???\n", "\n", "??? tip 🎯 Étapes guidĂ©es (en dernier recours !)\n", "\n", "1. Premier `...` : on veut trier par n° de sĂ©quence → tape p[0].
\n", "2. Deuxiùme `...` : on veut juste la valeur → tape val.
\n", "3. La ligne finale `\".\".join(...)` recolle les 4 octets avec des points pour faire l'IP.\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Énigme 1 : reconstitue l'adresse IP ──────────────────────────────────────\n", "print(\"Paquets reçus (dans le dĂ©sordre) :\")\n", "for seq, val in E1_paquets:\n", " print(f\" seq={seq} → octet = {val}\")\n", "print()\n", "\n", "# 🔧 À COMPLÉTER : tri des paquets par seq puis extraction des valeurs\n", "# Astuce : la fonction sorted() trie selon une clĂ©\n", "\n", "octets_ordonnes = sorted(E1_paquets, key=lambda p: ...) # trie selon le n° de sĂ©quence\n", "valeurs = [... for seq, val in octets_ordonnes] # garde seulement les valeurs\n", "\n", "ip = \".\".join(str(v) for v in valeurs)\n", "print(f\"IP reconstituĂ©e : {ip}\")\n", "\n", "verif_E1(ip)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? success Note ton chiffre 1\n", "\n", "**Chiffre 1 = ____**\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

🔍 Énigme 2 — Web : Code source HTML

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? question Contexte\n", "\n", "Le pirate a laissĂ© sa signature dans le code source HTML d'une page web. Cette signature est cachĂ©e dans une **balise `` de classe `secret`**.\n", "\n", "Ouvre le code HTML stockĂ© dans la variable `E2_html`, repĂšre la balise et extrais le mot.\n", "\n", "Appelle `verif_E2(\"MOT\")` pour vĂ©rifier (en majuscules).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? danger Rappel — Balises HTML\n", "\n", "Une page web est structurĂ©e par des **balises** : `contenu`.\n", "\n", "```html\n", "

texte normal

\n", "mot cachĂ©\n", "```\n", "\n", "🔧 **En Python**, tu peux chercher une sous-chaĂźne avec `find()` :\n", "```python\n", "i = texte.find(\"AVANT\") # position du dĂ©but\n", "j = texte.find(\"APRÈS\", i) # position de la fin\n", "mot = texte[i+len(\"AVANT\") : j]\n", "```\n", "\n", "🔗 Voir [SNT Web sur mathamine.fr](https://mathamine.fr/snt/cours_th2_web.html).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? hint 💡 Indice rapide\n", "\n", "`str.find(\"AVANT\")` donne la position du dĂ©but. Puis `str.find(\"APRÈS\", i)` cherche APRÈS la position `i`. Le mot est entre les deux.\n", "\n", "???\n", "\n", "??? note 📚 MĂ©thode + cours\n", "\n", "**`find()`** retourne la position (un entier) oĂč commence le texte cherchĂ© :

\n", "```python\n", "texte = \"Hello monde !\"\n", "i = texte.find(\"\") # position du < dans \n", "j = texte.find(\"\", i) # position du < dans APRÈS i\n", "mot = texte[i + len(\"\") : j] # tranche entre les deux\n", "print(mot) # → \"monde\"\n", "```\n", "\n", "🔗 **Concept SNT** : [Balises HTML](https://mathamine.fr/snt/cours_th2_web.html) \n", "🐍 **Syntaxe Python** : [🧰 BoĂźte Ă  outils : str.find() et tranches](#OUTILS) (en haut du notebook)\n", "\n", "???\n", "\n", "??? tip 🎯 Étapes guidĂ©es (en dernier recours !)\n", "\n", "1. Premier `...` : on cherche le dĂ©but → tape debut_balise.
\n", "2. Deuxiùme `...` : on cherche la fin → tape fin_balise.
\n", "3. TroisiĂšme `...` (la borne droite de la tranche) : tape j (la position de ).\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Énigme 2 : trouve le mot cachĂ© dans le HTML ──────────────────────────────\n", "print(\"Aperçu du HTML reçu :\")\n", "print(E2_html[:300] + \" ...\")\n", "print()\n", "\n", "# 🔧 À COMPLÉTER : rĂ©cupĂšre le mot situĂ© entre et \n", "debut_balise = ''\n", "fin_balise = ''\n", "\n", "i = E2_html.find(...) # position du dĂ©but de la balise ouvrante\n", "j = E2_html.find(..., i) # position de la balise fermante\n", "mot = E2_html[i + len(debut_balise) : ...]\n", "\n", "print(f\"Mot trouvĂ© : {mot}\")\n", "\n", "verif_E2(mot)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? success Note ton chiffre 2\n", "\n", "**Chiffre 2 = ____**\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

📚 Mini-topo — Parcourir une table (liste de dictionnaires)

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? info Tables en Python : ce dont tu as besoin pour l'Ă©nigme 3\n", "\n", "### Une ligne = un dictionnaire\n", "```python\n", "ligne = {\"prenom\": \"Alice\", \"classe\": \"2A\", \"age\": 15, \"score\": 17}\n", "ligne[\"classe\"] # → \"2A\" accĂšs Ă  une colonne\n", "ligne[\"age\"] # → 15\n", "```\n", "\n", "### Une table = une liste de dictionnaires\n", "```python\n", "table = [\n", " {\"prenom\": \"Alice\", \"classe\": \"2A\", \"age\": 15, \"score\": 17},\n", " {\"prenom\": \"Bob\", \"classe\": \"2B\", \"age\": 14, \"score\": 12},\n", "]\n", "```\n", "\n", "### Filtrer = boucle for + condition if\n", "```python\n", "nb = 0\n", "for ligne in table:\n", " if ligne[\"classe\"] == \"2A\" and ligne[\"age\"] >= 15:\n", " nb = nb + 1\n", "print(nb)\n", "```\n", "\n", "🔗 [SNT DonnĂ©es structurĂ©es sur mathamine.fr](https://mathamine.fr/snt/cours_th4_donnees.html).\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Mini-exercices de prĂ©paration ────────────────────────────────────────────\n", "\n", "# ① AccĂ©der Ă  un champ\n", "eleve = {\"prenom\": \"LĂ©a\", \"classe\": \"2C\", \"age\": 16, \"score\": 14}\n", "print(eleve[\"prenom\"]) # attendu : LĂ©a\n", "print(eleve[...]) # affiche la classe de LĂ©a\n", "\n", "# ② Compter dans une boucle\n", "table_demo = [\n", " {\"prenom\": \"A\", \"classe\": \"2A\"},\n", " {\"prenom\": \"B\", \"classe\": \"2B\"},\n", " {\"prenom\": \"C\", \"classe\": \"2A\"},\n", "]\n", "n = 0\n", "for r in table_demo:\n", " if r[...] == \"2A\":\n", " n = n + 1\n", "print(n) # attendu : 2\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

📊 Énigme 3 — DonnĂ©es structurĂ©es : filtrer la table

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? question Contexte\n", "\n", "Une table d'Ă©lĂšves `E3_table` a Ă©tĂ© rĂ©cupĂ©rĂ©e sur un serveur. Chaque ligne contient :\n", "`id`, `prenom`, `classe`, `age`, `score`.\n", "\n", "Le suspect appartient Ă  un groupe prĂ©cis. **Combien d'Ă©lĂšves** de la classe `E3_classe`\n", "ont au moins `E3_age_min` ans ?\n", "\n", "Appelle `verif_E3(nombre)` pour vĂ©rifier.\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? danger Indice\n", "\n", "Utilise une boucle `for` avec un compteur, et une condition combinĂ©e avec `and`.\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? hint 💡 Indice rapide\n", "\n", "Une condition combinĂ©e avec `and` : `r[\"classe\"] == E3_classe and r[\"age\"] >= E3_age_min`\n", "\n", "???\n", "\n", "??? note 📚 MĂ©thode + cours\n", "\n", "**Filtrer une table** : on parcourt chaque ligne avec une boucle `for`, on teste avec un `if`, et on compte si la condition est vraie.

\n", "```python\n", "nb = 0\n", "for r in table:\n", " if r[\"colonne1\"] == valeur1 and r[\"colonne2\"] >= valeur2:\n", " nb = nb + 1\n", "```
\n", "Le `and` combine deux conditions : les **deux** doivent ĂȘtre vraies.\n", "\n", "🔗 **Concept SNT** : [DonnĂ©es structurĂ©es](https://mathamine.fr/snt/cours_th7_donnees.html) \n", "🐍 **Syntaxe Python** : [🧰 BoĂźte Ă  outils : boucle for + condition if](#OUTILS) (en haut du notebook)\n", "\n", "???\n", "\n", "??? tip 🎯 Étapes guidĂ©es (en dernier recours !)\n", "\n", "1. Premier `...` : la classe cible → tape E3_classe.
\n", "2. Deuxiùme `...` : l'ñge minimum → tape E3_age_min.
\n", "3. La boucle parcourt la table et incrĂ©mente nb chaque fois que la condition est vraie.\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Énigme 3 : filtre la table ────────────────────────────────────────────────\n", "print(f\"Classe cible : {E3_classe} | Âge minimum : {E3_age_min}\")\n", "print(f\"Table de {len(E3_table)} Ă©lĂšves :\")\n", "for r in E3_table:\n", " print(f\" id={r['id']:2d} {r['prenom']:10s} classe={r['classe']} age={r['age']} score={r['score']}\")\n", "print()\n", "\n", "# 🔧 À COMPLÉTER\n", "nb = 0\n", "for r in E3_table:\n", " if r[\"classe\"] == ... and r[\"age\"] >= ...:\n", " nb = nb + 1\n", "\n", "print(f\"Nombre d'Ă©lĂšves correspondants : {nb}\")\n", "\n", "verif_E3(nb)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? success Note ton chiffre 3\n", "\n", "**Chiffre 3 = ____**\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

đŸ—ș Énigme 4 — Cartographie : coordonnĂ©es GPS et distance

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? question Contexte\n", "\n", "Deux lieux suspects ont Ă©tĂ© repĂ©rĂ©s prĂšs de La FlĂšche. Leurs coordonnĂ©es GPS sont en **DMS** (degrĂ©s, minutes, secondes).\n", "\n", "Convertis-les en degrĂ©s dĂ©cimaux puis calcule la **distance approximative en mĂštres** entre les deux points.\n", "\n", "Appelle `verif_E4(distance_metres)` pour vĂ©rifier (tolĂ©rance ±10 %).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? danger Rappel — Conversion DMS → dĂ©cimal\n", "\n", "$$\\text{dĂ©cimal} = \\text{deg} + \\dfrac{\\text{min}}{60} + \\dfrac{\\text{sec}}{3600}$$\n", "\n", "Les longitudes **ouest** sont **nĂ©gatives** (La FlĂšche est Ă  l'ouest du mĂ©ridien de Greenwich).\n", "\n", "### Distance entre deux points proches (Ă©chelle locale)\n", "\n", "Pour deux points proches en France :\n", "- 1° de **latitude** ≈ 111 km\n", "- 1° de **longitude** Ă  47°N ≈ 111 × cos(47°) ≈ 75,7 km\n", "\n", "$$d \\approx \\sqrt{(\\Delta_{lat} \\cdot 111)^2 + (\\Delta_{lon} \\cdot 75{,}7)^2} \\quad \\text{(en km)}$$\n", "\n", "🔗 [SNT Cartographie sur mathamine.fr](https://mathamine.fr/snt/cours_th5_carto.html).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? hint 💡 Indice rapide\n", "\n", "À 47°N : 1° de longitude ≈ **111 km × cos(47°)**. Distance ≈ √(ΔlatÂČ + ΔlonÂČ) en km.\n", "\n", "???\n", "\n", "??? note 📚 MĂ©thode + cours\n", "\n", "**Distance plane** (valide Ă  petite Ă©chelle) :

\n", "$$d \\approx \\sqrt{(\\Delta_{lat} \\cdot 111)^2 + (\\Delta_{lon} \\cdot 111 \\cdot \\cos(\\theta))^2}$$

\n", "oĂč $\\theta$ est la latitude moyenne en radians. À La FlĂšche (≈47°N), on a $\\cos(47°) ≈ 0.68$.

\n", "**Important** : en Python, `math.cos()` prend des **radians**, donc utilise `math.radians(47.7)` pour convertir.\n", "\n", "🔗 **Concept SNT** : [Localisation / GPS](https://mathamine.fr/snt/cours_th4_localisation.html) \n", "🐍 **Syntaxe Python** : [🧰 BoĂźte Ă  outils : math.cos() et math.radians()](#OUTILS) (en haut du notebook)\n", "\n", "???\n", "\n", "??? tip 🎯 Étapes guidĂ©es (en dernier recours !)\n", "\n", "1. Premier `...` (facteur longitude) : tape 111 (km/°).
\n", "2. Le deuxiĂšme `...` (radicande) : dlat_km**2.
\n", "3. Le troisiĂšme `...` : dlon_km**2.
\n", "4. Pour les mĂštres : distance_km * 1000.\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Énigme 4 : GPS et distance ───────────────────────────────────────────────\n", "import math\n", "\n", "# Chaque tuple = (lat_deg, lat_min, lat_sec, lon_deg, lon_min, lon_sec)\n", "print(f\"Point A (DMS) : {E4_A_DMS}\")\n", "print(f\"Point B (DMS) : {E4_B_DMS}\")\n", "print()\n", "\n", "def dms_to_dd(deg, mn, sec):\n", " return deg + mn / 60 + sec / 3600\n", "\n", "# Convertir en degrĂ©s dĂ©cimaux\n", "lat_A = dms_to_dd(E4_A_DMS[0], E4_A_DMS[1], E4_A_DMS[2])\n", "lat_B = dms_to_dd(E4_B_DMS[0], E4_B_DMS[1], E4_B_DMS[2])\n", "lon_A = -dms_to_dd(E4_A_DMS[3], E4_A_DMS[4], E4_A_DMS[5]) # ouest nĂ©gatif\n", "lon_B = -dms_to_dd(E4_B_DMS[3], E4_B_DMS[4], E4_B_DMS[5])\n", "\n", "print(f\"A : lat={lat_A:.6f}, lon={lon_A:.6f}\")\n", "print(f\"B : lat={lat_B:.6f}, lon={lon_B:.6f}\")\n", "\n", "# 🔧 À COMPLÉTER : calcule la distance en km puis en mĂštres\n", "dlat_km = (lat_B - lat_A) * 111\n", "dlon_km = (lon_B - lon_A) * ... * math.cos(math.radians(47.7))\n", "\n", "distance_km = math.sqrt(... + ...)\n", "distance_m = ...\n", "\n", "print(f\"Distance ≈ {distance_m:.0f} m\")\n", "\n", "verif_E4(distance_m)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? success Note ton chiffre 4\n", "\n", "**Chiffre 4 = ____**\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

đŸ“· Énigme 5 — Photo numĂ©rique : pixels RVB

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? question Contexte\n", "\n", "Quatre pixels ont Ă©tĂ© extraits d'une photo numĂ©rique. Chaque pixel a 3 composantes : **R** (rouge), **V** (vert), **B** (bleu), chacune entre 0 et 255.\n", "\n", "Calcule **la somme des composantes Rouges** des 4 pixels, puis **divise par 50** (division entiĂšre).\n", "\n", "Appelle `verif_E5(code)` avec ce rĂ©sultat.\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? danger Rappel — Codage RVB\n", "\n", "Chaque pixel d'une image couleur est codĂ© par 3 entiers (0–255) :\n", "- **R** = niveau de rouge\n", "- **V** = niveau de vert\n", "- **B** = niveau de bleu\n", "\n", "Un pixel `(255, 0, 0)` est rouge pur. `(255, 255, 255)` est blanc, `(0, 0, 0)` est noir.\n", "\n", "En Python : `pixel[0]` = R, `pixel[1]` = V, `pixel[2]` = B.\n", "\n", "La **division entiĂšre** en Python : `15 // 4 = 3`.\n", "\n", "🔗 [SNT Photographie numĂ©rique sur mathamine.fr](https://mathamine.fr/snt/cours_th6_photo.html).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? hint 💡 Indice rapide\n", "\n", "`pix[0]` accĂšde au **R** (rouge) d'un pixel `(R, V, B)`. Division entiĂšre : `//`.\n", "\n", "???\n", "\n", "??? note 📚 MĂ©thode + cours\n", "\n", "Un pixel est un **tuple** `(R, V, B)`. Pour accĂ©der Ă  un Ă©lĂ©ment :
\n", "- `pix[0]` → R (rouge)
\n", "- `pix[1]` → V (vert)
\n", "- `pix[2]` → B (bleu)

\n", "**Division entiĂšre** : `//` donne le quotient sans virgule.
\n", "Exemple : `347 // 50 = 6`.\n", "\n", "🔗 **Concept SNT** : [Photographie numĂ©rique](https://mathamine.fr/snt/cours_th_photo.html) \n", "🐍 **Syntaxe Python** : [🧰 BoĂźte Ă  outils : indices de tuple pix[0], division entiĂšre //](#OUTILS) (en haut du notebook)\n", "\n", "???\n", "\n", "??? tip 🎯 Étapes guidĂ©es (en dernier recours !)\n", "\n", "1. Premier `...` : on veut le rouge → tape 0 (pour pix[0]).
\n", "2. Deuxiùme `...` : le diviseur → tape 50.
\n", "3. La boucle parcourt les 4 pixels et accumule la somme des R.\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Énigme 5 : dĂ©coder les pixels ────────────────────────────────────────────\n", "print(\"Pixels reçus :\")\n", "for i, pix in enumerate(E5_pixels, start=1):\n", " print(f\" Pixel {i} : R={pix[0]:3d} V={pix[1]:3d} B={pix[2]:3d}\")\n", "print()\n", "\n", "# 🔧 À COMPLÉTER : calcule la somme des R, puis divise par 50\n", "somme_R = 0\n", "for pix in E5_pixels:\n", " somme_R = somme_R + pix[...] # composante rouge\n", "\n", "code = somme_R // ... # division entiĂšre par 50\n", "\n", "print(f\"Somme des R = {somme_R}, code = {code}\")\n", "\n", "verif_E5(code)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? success Note ton chiffre 5\n", "\n", "**Chiffre 5 = ____**\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

📚 Mini-topo — Graphes en Python (dictionnaire d'amis)

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? info ReprĂ©senter un graphe\n", "\n", "Un **graphe** modĂ©lise des relations (amitiĂ©s, contacts...). Chaque sommet est une personne et chaque arĂȘte une relation.\n", "\n", "En Python, on utilise un **dictionnaire** : Ă  chaque personne, on associe la liste de ses amis.\n", "\n", "```python\n", "graphe = {\n", " \"AĂŻcha\": [\"Boris\", \"Clara\"],\n", " \"Boris\": [\"AĂŻcha\", \"Dimitri\"],\n", " \"Clara\": [\"AĂŻcha\"],\n", " \"Dimitri\":[\"Boris\"],\n", "}\n", "\n", "# Nombre d'amis (degrĂ©) d'une personne :\n", "len(graphe[\"AĂŻcha\"]) # → 2\n", "\n", "# Parcourir tout le monde :\n", "for nom, amis in graphe.items():\n", " print(nom, \"→\", len(amis), \"amis\")\n", "```\n", "\n", "🔗 [SNT RĂ©seaux sociaux sur mathamine.fr](https://mathamine.fr/snt/cours_th3_reseaux.html).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

🌍 Énigme 6 — RĂ©seaux sociaux : trouver l'influenceur

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? question Contexte\n", "\n", "Un graphe de relations a Ă©tĂ© extrait du compte du suspect : `E6_graphe`. La clĂ© est le nom d'une personne, la valeur est la liste de ses amis.\n", "\n", "**Question :** Qui est l'**influenceur** — la personne avec le **plus d'amis** ?\n", "Donne aussi son **degrĂ©** (nombre d'amis).\n", "\n", "Appelle `verif_E6(nom, degre)` pour vĂ©rifier.\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? danger Indice\n", "\n", "Parcours le dictionnaire avec `.items()`. Pour chaque personne, calcule `len(amis)`.\n", "Garde la meilleure au fil de la boucle (variable `meilleur_nom`, `meilleur_degre`).\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? hint 💡 Indice rapide\n", "\n", "`len(amis)` compte le nombre d'amis. Mets Ă  jour `meilleur_nom` et `meilleur_degre` si on trouve mieux.\n", "\n", "???\n", "\n", "??? note 📚 MĂ©thode + cours\n", "\n", "**Parcourir un dictionnaire** : `for nom, amis in graphe.items()` donne `nom` (clĂ©) et `amis` (valeur = liste).

\n", "**Algorithme du maximum** : on garde au fil de la boucle la meilleure valeur trouvée jusqu'ici.

\n", "```python\n", "meilleur = -1\n", "for x in liste:\n", " if x > meilleur:\n", " meilleur = x\n", "```\n", "\n", "🔗 **Concept SNT** : [RĂ©seaux sociaux](https://mathamine.fr/snt/cours_th3_reseaux_sociaux.html) \n", "🐍 **Syntaxe Python** : [🧰 BoĂźte Ă  outils : dict.items() et len()](#OUTILS) (en haut du notebook)\n", "\n", "???\n", "\n", "??? tip 🎯 Étapes guidĂ©es (en dernier recours !)\n", "\n", "1. Premier `...` : le nombre d'amis → tape len(amis).
\n", "2. Deuxiùme `...` : la nouvelle valeur de meilleur_degre → tape degre.
\n", "3. Troisiùme `...` : la nouvelle valeur de meilleur_nom → tape nom.
\n", "4. À la fin, meilleur_nom contient l'influenceur et meilleur_degre son nombre d'amis.\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Énigme 6 : trouver l'influenceur ──────────────────────────────────────────\n", "print(\"Graphe d'amitiĂ©s :\")\n", "for nom, amis in E6_graphe.items():\n", " print(f\" {nom:10s} → {len(amis)} amis : {', '.join(amis)}\")\n", "print()\n", "\n", "# 🔧 À COMPLÉTER : trouve la personne avec le plus d'amis\n", "meilleur_nom = None\n", "meilleur_degre = -1\n", "\n", "for nom, amis in E6_graphe.items():\n", " degre = ... # nombre d'amis\n", " if degre > meilleur_degre:\n", " meilleur_degre = ...\n", " meilleur_nom = ...\n", "\n", "print(f\"Influenceur : {meilleur_nom} ({meilleur_degre} amis)\")\n", "\n", "verif_E6(meilleur_nom, meilleur_degre)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? success Note ton chiffre 6\n", "\n", "**Chiffre 6 = ____**\n", "\n", "???\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

🔐 Code final — Cyber-enquĂȘte rĂ©solue

\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "??? question Combine tes 6 chiffres\n", "\n", "Colle les 6 chiffres notĂ©s (Ă©nigmes 1 Ă  6) pour former un code **Ă  6 chiffres**.\n", "\n", "Exemple : si tu as trouvĂ© 3, 7, 2, 5, 8, 1 → code = `372581`.\n", "\n", "Appelle `verif_final(\"code\")` pour rĂ©vĂ©ler le verdict.\n", "\n", "???\n" ] }, { "cell_type": "code", "metadata": {}, "execution_count": null, "outputs": [], "source": [ "# ── Code final ────────────────────────────────────────────────────────────────\n", "# Remplace les ... par les 6 chiffres notĂ©s au fil des Ă©nigmes\n", "chiffre_1 = ...\n", "chiffre_2 = ...\n", "chiffre_3 = ...\n", "chiffre_4 = ...\n", "chiffre_5 = ...\n", "chiffre_6 = ...\n", "\n", "code = f\"{chiffre_1}{chiffre_2}{chiffre_3}{chiffre_4}{chiffre_5}{chiffre_6}\"\n", "print(f\"Code proposĂ© : {code}\")\n", "\n", "verif_final(code)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "
\n", "🌐 Tous les cours SNT Seconde sur mathamine.fr/snt\n", "
\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }