Module 3 : Les structures de données

📌 Règles et astuces pour l'Exercice 1 :

• Division réelle (/) : En Python, la division simple produit toujours un flottant (float). Ainsi, 12 / 4 donne 3.0 (et non 3).
• Division entière (div → //) : Renvoie le quotient entier (ex : 11 // 5 donne 2, de type int).
• Reste de la division (mod → %) : Calcule le reste de la division euclidienne (ex : 11 % 4 donne 3 car $11 = 4 \times 2 + 3$, type int).
• Opérateurs relationnels en Python :
  • Égalité : == (ex : 1+2 == 3-0).
  • Différence : != (pour $\ne$).
  • Inférieur ou égal : <= (pour $\le$).
  • Appartenance : in avec une liste entre crochets (ex : 5 in [12, 6, -3, 5, 7]).
• Type booléen (bool) : Le résultat d'une comparaison est un booléen : True ou False (avec majuscule initiale).

📌 Règles et astuces pour l'Exercice 2 :

• Correspondance Algorithme → Python :
  • Abs(x) → abs(x) (valeur absolue).
  • Ent(x) → int(x) (partie entière, type int).
  • Arrondi(x) → round(x) (arrondi à l'entier le plus proche).
  • Racine(x) → sqrt(x) (module math). Attention : sqrt() retourne toujours un float (ex : sqrt(16) donne 4.0).
  • Aléa(a, b) → randint(a, b) (module random).
  • mod → % et div → //.
• Propagation du type réel (float) : Tout nombre avec un point décimal (ex: 15. ou 1.5) ou division réelle (/) convertit toute l'expression arithmétique en float.
• Priorité des opérations (PEMDAS) : Parenthèses → Exposants → Multiplications, Divisions et Modulo → Additions et Soustractions.
• Simulation conditionnelle : Dans x = (a > b) * a + (a <= b) * b, la condition vraie vaut 1 et la fausse vaut 0, sélectionnant la plus grande valeur (maximum).
• Test hors limites : Dans Aléa(10, 20) > 30, un nombre tiré entre 10 et 20 ne peut jamais être supérieur à 30, donc le résultat est toujours False (type bool).

📌 Conseils méthodologiques (Trace mémoire) :

• Initialisation : Tant qu'une variable n'a reçu aucune affectation, indiquer un tiret - (ou laisser vide).
• Conservation des valeurs : À chaque nouvelle ligne, seules les variables affectées changent de valeur. Les autres variables conservent leur valeur de la ligne précédente.
• Priorité des opérations : Les opérateurs *, div et mod sont prioritaires sur + et -. N'effectuez les additions ou soustractions qu'après avoir évalué les multiplications ou divisions.
• Rôle des parenthèses : Toute opération entre parenthèses ( ) doit être calculée en premier, avant toute autre opération extérieure.
• Rappel des opérateurs :
  • div : quotient entier de la division euclidienne (sans virgule ni décimales).
  • mod : reste entier de la division euclidienne.

📌 Règles et exemples d'encadrement des intervalles :

Traduction Python : Aléa(a, b) se traduit par x = randint(a, b) (module random), avec $a \le x \le b$.

• Multiplication par une constante positive (ex: $\times 2$) :
  On multiplie chaque membre de l'inégalité :
  
  1 ≤ x ≤ 5
  1 * 2 ≤ x * 2 ≤ 5 * 2
  → 2 ≤ x * 2 ≤ 10
• Multiplication par une constante négative (ex: $\times -3$) :
  Attention : multiplier par un nombre négatif inverse le sens des bornes :
  
  1 ≤ x ≤ 5
  5 * (-3) ≤ x * (-3) ≤ 1 * (-3)
  → -15 ≤ x * (-3) ≤ -3
• Division entière (ex: // 2) :
  On applique la division entière aux bornes :
  
  1 ≤ x ≤ 7
  1 // 2 ≤ x // 2 ≤ 7 // 2
  → 0 ≤ x // 2 ≤ 3
• Produit de deux tirages indépendants ($x \times y$) :
  Si $1 \le x \le 4$ et $0 \le y \le 3$ :
  
  Min : 1 * 0 = 0 • Max : 4 * 3 = 12
  → 0 ≤ x * y ≤ 12
• Quotient de deux tirages indépendants ($x / y$) :
  Si $10 \le x \le 40$ et $2 \le y \le 5$ :
  
  Min : plus petit numérateur / plus grand dénominateur = 10 / 5 = 2.0
  Max : plus grand numérateur / plus petit dénominateur = 40 / 2 = 20.0
  → 2.0 ≤ x / y ≤ 20.0

📌 Décomposition pas à pas des 6 expressions :

• Expression 1 (ch1[0]) : Extrait le 1er caractère (indice 0) de "python" → 'p'.
• Expression 2 (ch2.upper()) : Met toute la chaîne "javascript" en lettres majuscules.
• Expression 3 : Concatène les lettres aux indices donnés : ch1[0] ('p') + ch3[0] ('u') + ch2[5] ('c') + ch4[1] ('e').
• Expression 4 : ch2[9].upper() donne 'T', ch1[2].upper() donne 'T'. Assembler avec ch2[7] ('i'), ch2[8] ('p'), ch1[4] ('o') et ch1[0] ('p').
• Expression 5 : len(ch1) - len(ch4) = 6 - 4 = 2 → str(2) = "2". Pour le terme chr(ord(ch1[3]) - 3) : ch1[3] est 'h' (ASCII 104), et $104 - 3 = 101$ qui est la lettre 'e'.
• Expression 6 : Utiliser len(ch3) = 3 et len(ch4) = 4 : ch3[2] ('l') + ch2[3] ('a') + ch4[2] ('r') + ch3[1] ('m') + ch4[1] ('e').

📌 Règles et astuces pour l'Exercice 6 :

• Lignes 1 à 3 (Long, ConvCh, Valeur) : Long() → len() ; ConvCh() → str() (concatène `"13"` et `"6"` en `"136"`) ; Valeur() → int() (convertit `"613"` en nombre entier 613).
• Ligne 4 (Réel) : Réel(C) → float(C). La soustraction avec un nombre réel donne un float ($613 - 136.0 = 477.0$).
• Lignes 5 et 6 (Découpage et Effacement) : sous_chaine(ch, d, f) correspond à ch[d:f] (de l'indice $d$ à $f-1$). Effacer(F, 0, 2) supprime les 2 premiers caractères (équivaut à F[2:]). Note : $136 - 15 = 121$ et chr(121) = 'y'.
• Ligne 7 (EstNum / isdecimal) : isdecimal() vaut True (1) si la chaîne ne contient que des chiffres, sinon False (0). C ("136") est décimal mais pas G ("Rhythmique"), donc $1 \times 3 + 0 \times 10 = 3$.
• Ligne 8 (Pos / find) : Pos(motif, ch) → ch.find(motif). Retourne la position (indice à partir de 0) du motif dans la chaîne (ex: `"go"` commence à l'indice 2 dans `"Algorithmique"`).
• Lignes 9 et 10 (Combinaison finale) : Calcul arithmétique de $K$ ($4502 - 477 - 2000 = 2025$), puis assemblage des tranches de chaîne avec K.

📌 Principe algorithmique de génération du mot de passe :

• 2 Chiffres ('0' → '9') : Codes ASCII de 48 à 57. Obtenus par chr(alea(48, 57)) ou convch(alea(0, 9)).
• 2 Majuscules ('A' → 'Z') : Codes ASCII de 65 à 90. Obtenus par chr(alea(65, 90)).
• 2 Minuscules ('a' → 'z') : Codes ASCII de 97 à 122. Obtenus par chr(alea(97, 122)).
• Assemblage final : Concaténation des 6 caractères générés dans la variable résultat : mp ← c1 + c2 + m1 + m2 + min1 + min2.

📌 Décomposition arithmétique d'un entier à 2 chiffres :

• Chiffre des dizaines : Obtenu par la division entière par 10 : d ← a div 10 (en Python : d = a // 10). Pour 49, $49 // 10 = 4$.
• Chiffre des unités : Obtenu par le reste de la division par 10 : u ← a mod 10 (en Python : u = a % 10). Pour 49, $49 \% 10 = 9$.
• Reconstruction du nombre permuté : On multiplie les unités par 10 et on ajoute les dizaines : b ← u * 10 + d. Pour 49 : $9 \times 10 + 4 = 94$.

📌 Formules mathématiques et algorithmiques :

• Distance parcourue ($\text{dp}$) : Différence des compteurs kilométriques : $\text{dp} = \text{ikf} - \text{ikd}$ (en km).
• Énergie consommée ($\text{ec}$) : Baisse du niveau de batterie : $\text{ec} = \text{nib} - \text{nfb}$ (en %).
• Consommation moyenne aux 100 km ($\text{cm}$) : Règle de trois : $\text{cm} = \frac{\text{ec} \times 100}{\text{dp}}$ (% / 100 km).
• Distance maximale restante ($\text{dm}$) : Autonomie calculable par proportionnalité : $\text{dm} = \frac{\text{nfb} \times \text{dp}}{\text{ec}} = \frac{\text{nfb} \times 100}{\text{cm}}$ (en km).

📌 Analyse des portes logiques et de l'équation :

• Porte NON (Inverseur) : Calcule $\bar{c}$ ($0 \rightarrow 1$ et $1 \rightarrow 0$).
• Porte ET supérieure ($T_1 = a \cdot \bar{c}$) : Active (sortie 1) uniquement lorsque $a=1$ et $c=0$.
• Porte ET inférieure ($T_2 = b \cdot c$) : Active (sortie 1) uniquement lorsque $b=1$ et $c=1$.
• Porte OU finale ($L = T_1 + T_2$) : Allume la lampe si $T_1=1$ ou $T_2=1$.
• Rôle de sélection (Multiplexeur 2:1) : La variable $c$ agit comme un commutateur : si $c=0$, la lampe recopie l'état de l'entrée $a$ ($L=a$) ; si $c=1$, elle recopie l'état de l'entrée $b$ ($L=b$).

📌 Enchaînement des calculs de logistique :

• Nombre total de bouteilles : Division de la quantité par la contenance : $\text{bouteilles} = \text{Ent}(Q / \text{vol})$.
• Reste d'huile non embouteillée : $\text{reste\_huile} = Q \pmod{\text{vol}}$.
• Caisses pleines de 12 bouteilles : Quotient entier : $\text{caisses} = \text{bouteilles} \text{ div } 12$ (en Python : // 12).
• Bouteilles restantes sans caisse : Reste entier : $\text{bouteilles\_restantes} = \text{bouteilles} \text{ mod } 12$ (en Python : % 12).
• Voyages complets du camion (30 caisses) : $\text{voyages} = \text{caisses} \text{ div } 30$ (en Python : // 30).
• Caisses du dernier voyage partiel : $\text{caisses\_dernier} = \text{caisses} \text{ mod } 30$ (en Python : % 30).

📌 Règles des fonctions algorithmiques de chaînes et types :

• Types standards attendus : Entier, Réel, Caractère, Chaîne, Booleen.
• Fonction chr(code) : Convertit un code ASCII numérique en caractère (ex: ent(100.5) = 100, et le code ASCII 100 donne 'd', type Caractère). Mettre entre apostrophes simples.
• Fonction ord(car) : Retourne le code ASCII entier du caractère (ex: ord('o') donne 111, type Entier).
• Indices de la chaîne ch : ch[0]='p', ch[2]='o', ch[3]='g', ch[5]='a', ch[8]='e', ch[13]='5'.
• sous_chaine(ch, d, f) : Extrait les caractères de l'indice $d$ jusqu'à $f-1$ exclu (longueur $f-d$, type Chaîne, ex: sous_chaine(ch, 3, 9) donne "gramme").
• effacer(ch, d, f) : Supprime la portion entre $d$ et $f-1$ et recolle les morceaux (type Chaîne, ex: effacer(ch, 3, 9) donne "pro 2025").
• Génération de lettre majuscule : alea(0, 25) + 65 donne un code ASCII entre 65 ('A') et 90 ('Z'), donc chr(...) produit une lettre majuscule de type Caractère.
• Comparaison booléenne : La condition "A" ≤ e ≤ "Z" teste si e est une majuscule, ce qui est toujours VRAI (type Booleen).
• convch() et valeur() : convch() transforme un nombre en Chaîne, et valeur() transforme une chaîne en Entier.

📌 Décomposition pas à pas pour chaque nom d'utilisateur :

• Composante p1 (Prénom) : Les 3 premières lettres du prénom en majuscules + le nombre total de lettres du prénom.
  • Sami : 3 premières lettres SAM, longueur 4 → SAM4.
  • Mohamed : 3 premières lettres MOH, longueur 7 → MOH7.
  • Ali : 3 premières lettres ALI, longueur 3 → ALI3.
  • Yassine : 3 premières lettres YAS, longueur 7 → YAS7.
• Composante p2 (Nom de famille) : Les 3 dernières lettres du nom en majuscules + la longueur totale du nom (après le 1er espace).
  • Ben Salah : Dernières lettres LAH, longueur totale 9 → LAH9.
  • Mani : Dernières lettres ANI, longueur 4 → ANI4.
  • Bouazizi : Dernières lettres IZI, longueur 8 → IZI8.
  • Trabelsi : Dernières lettres LSI, longueur 8 → LSI8.
• Format du pseudonyme complet : Assembler avec tirets bas : p1_p2_XX (ex: SAM4_LAH9_XX où XX représente 2 chiffres quelconques de 10 à 99).