Module 3 : Les structures de données

Cours

1. Types numériques

Un programme manipule des données stockées dans la mémoire centrale. Les types numériques incluent les entiers (int $\mathbb{Z}$) et les réels (float $\mathbb{R}$).

📌 Règle Mnémonique PEMDAS : Ordre de priorité des opérations

En informatique comme en mathématiques, les expressions numériques sont évaluées selon l'ordre de priorité PEMDAS :

Parenthèses ( )
Exposants / Puissance **
Multiplication *
Division / , // , %
Addition +
Soustraction -
PEMDAS Opération Priorité Algorithme Python Exemple
P Parenthèses 1 (Max) ( ) ( ) (1 + 5) * (3 - 5) → -12
E Exposants / Puissance 2 Puissance(x, n) ** 2 ** 3 → 8
M Multiplication 3 * * 2 * 3 → 6
D Division réelle 3 / / 5 / 2 → 2.5
Division entière 3 div // 5 // 2 → 2
Reste division (Modulo) 3 mod % 5 % 2 → 1
A Addition 4 + + 5 + 3 → 8
S Soustraction 4 - - 5 - 3 → 2

b. Partie entière et partie décimale

Illustration Partie entière et partie décimale

c. Opérateurs de division & Division euclidienne

Illustration Division euclidienne

d. Les fonctions prédéfinies sur les nombres

Illustration du fonctionnement de la fonction round(x) en Python
Algorithme Python Description Exemple
Ent(x) int(x) Retourne la partie entière Ent(5.75) ⟶ 5
Arrondi(x) round(x) Retourne l'entier le plus proche (entier pair si .5) round(3.5) ⟶ 4
Racine(x) sqrt(x) (from math) Retourne la racine carrée d'un nombre positif sqrt(25) ⟶ 5.0
Abs(x) abs(x) Retourne la valeur absolue de x abs(-4) ⟶ 4
Aléa(a, b) randint(a, b) (from random) Retourne un nombre aléatoire dans [a, b] randint(1, 6) ⟶ 4

2. Le type booléen

Une variable booléenne ne peut prendre que la valeur Faux ou Vrai (False / True en Python).

1. Fonctions logiques de base (NON, ET, OU) & Portes logiques

En informatique et en électronique numérique, les opérations logiques fondamentales sont concrétisées par des portes logiques (symboles normalisés ANSI / IEEE d'origine américaine et CEI / IEC européenne).

Fonction NON (Négation) not x / non x
Équation : S = x̄ Python : not x
Schémas à porte logique :
Porte logique NON (symboles ANSI et CEI)
Entrée x Sortie S = non x
0 (Faux) 1 (Vrai)
1 (Vrai) 0 (Faux)
⚡ Circuit Inverseur (NF) : Fermé Fermé ⟶ Éteinte Éteinte
Ouvert Ouvert ⟶ Allumée Allumée
Fonction ET (Conjonction) x and y / x et y
Équation : S = x • y Python : x and y
Schémas à porte logique :
Porte logique ET (symboles ANSI et CEI)
x y Sortie S = x et y
0 0 0 (Faux)
0 1 0 (Faux)
1 0 0 (Faux)
1 1 1 (Vrai)
⚡ Circuit en Série : Allumée Allumée uniquement si x ET y sont tous les deux Fermé Fermés (1).
Fonction OU (Disjonction) x or y / x ou y
Équation : S = x + y Python : x or y
Schémas à porte logique :
Porte logique OU (symboles ANSI et CEI)
x y Sortie S = x ou y
0 0 0 (Faux)
0 1 1 (Vrai)
1 0 1 (Vrai)
1 1 1 (Vrai)
⚡ Circuit en Parallèle : Allumée Allumée dès qu'au moins x OU y est Fermé Fermé (1).

2. ⚡ Simulation Interactive des Portes Logiques (Circuits & Diodes)

Testez chaque circuit indépendamment des autres : cliquez directement sur les entrées (0 ou 1) de chaque porte logique (ou sur ses boutons) pour faire basculer son état et observer la diode de sortie en temps réel !

1. Opérateur NON non x
Schéma & Entrée Cliquez sur x
Diode NON
⚡ Diode ALLUMÉE (Vrai)
not (False) ⟶ True
2. Opérateur ET x et y
Schéma & Entrées Cliquez sur x ou y
Diode ET
⚡ Diode ÉTEINTE (Faux)
False and False ⟶ False
3. Opérateur OU x ou y
Schéma & Entrées Cliquez sur x ou y
Diode OU
⚡ Diode ÉTEINTE (Faux)
False or False ⟶ False

3. 🔢 Ordre d'évaluation des opérateurs de Comparaison et des opérateurs logiques

Priorité Catégorie d'opérateurs Algorithme Python Exemple d'évaluation
1 (Max) Parenthèses ( ) ( ) (5 > 2) et (3 < 4) → Vrai
2 Opérateurs Arithmétiques + , - , * , / , mod , div + , - , * , / , % , // 5 + 3 > 7 → 8 > 7 → Vrai
3 Opérateurs de Comparaison = , ≠ , > , ≥ , < , ≤ == , != , > , >= , < , <= x == 5 , age >= 18
4 NON Logique (Négation) non not not (5 > 2) → False
5 ET Logique (Conjonction) et and True and False → False
6 (Min) OU Logique (Disjonction) ou or True or False → True

3. Les types textuels

Les données textuelles sont stockées, en algorithmique, dans des variables de type :

  • Caractère ;
  • Chaîne.

En Python, on dispose uniquement du type str.

Différence entre chaîne et caractère

a. Le type caractère

i. Présentation

Le type caractère représente un seul caractère qui peut être :

  • Une lettre : majuscule ("A", "B", ...) ou minuscule ("a", "b", ...)
  • Un chiffre : "0", "1", "2", ..., "9"
  • Un symbole : "!", "\"", "#", "$", "%", ...
ii. Table ASCII

Dans la mémoire de l'ordinateur, un caractère est représenté par son code ASCII (American Standard Code for Information Interchange). Ainsi, chaque caractère possède un code (un nombre) correspondant :

🔎 Recherche interactive Table ASCII (Standard 32-127)
Code Car. Code Car. Code Car. Code Car. Code Car. Code Car. Code Car. Code Car.
48 0 65 A
iii. Les fonctions prédéfinies sur les caractères
Algorithme Python Description Exemple
ord(car) ord(car) Retourne le code ASCII du caractère car. ord("A") → 65
chr(code) chr(code) Retourne le caractère ASCII équivalent au code. chr(65) → "A"
⚠️
Important : En algorithme, il n'y a pas de fonction minus(car).
Pour convertir une lettre majuscule car en minuscule, on peut écrire :
chr(ord(car) + 32)

b. Le type Chaîne

i. Présentation

Une Chaîne de caractères est la succession de n caractères ASCII ($n \ge 0$).

  • Si $n$ est nulle ($n = 0$), on parle d'une Chaîne vide : ch ← ""  // Chaîne vide
    Illustration Chaîne vide vs Chaîne non vide
  • On peut accéder au $i^e$ caractère ($0 \le i < n$) d'une Chaîne ch en utilisant la notation : ch[i]
    Schéma d'indexation de la Chaîne Youssef
  • Pour concaténer (coller) deux Chaînes, on utilise l'opérateur + :
    Schéma de concaténation Langage + Py + thon
ii. Les fonctions prédéfinies sur les Chaînes
Algorithme Python Description Exemple
long(ch) len(ch) Calcule la longueur de la Chaîne ch. long("BAC26") → 5
long("") → 0
Pos(ch1, ch2) ch2.find(ch1) Retourne la position (indice) de la 1ère occurrence de ch1 dans ch2 (-1 si non trouvée). Pos("26", "BAC26") → 3
Pos("Hi", "BAC26") → -1
ConvCh(x) str(x) Convertir une valeur numérique x en Chaîne. ConvCh(10) → "10"
ConvCh(17.5) → "17.5"
Valeur(ch) int(ch)
float(ch)		 Convertit une Chaîne en une valeur numérique, sinon provoque une erreur. Valeur("10") → 10
Valeur("17.5") → 17.5
EstNum(ch) ch.isdecimal() Vérifie si la Chaîne ch est composée uniquement de chiffres. EstNum("10") → Vrai
EstNum("2k") → Faux
sous_chaîne(ch, d, f) ch[d:f] Extrait de la Chaîne ch les caractères situés entre la position d (incluse) et f (non incluse). sous_chaîne("BAC26", 3, 5) → "26"
effacer(ch, d, f) ch[:d] + ch[f:] Efface de la Chaîne ch les caractères situés entre la position d (incluse) et f (non incluse). effacer("BAC26", 3, 5) → "BAC"
majus(ch) ch.upper() Convertit la Chaîne ch en majuscules. majus("bac 26") → "BAC 26"

Exercices Interactifs

Exercice 1 – Opérateurs numériques

Compléter le tableau ci-dessous (Expression Python équivalente, Résultat et Type) :

Expression en Algorithme Expression en Python Résultat Type ✔️
5 + 6
4.5 - 2.5
12 / 4
11 mod 4
11 div 5
12 ≠ (10+2)
4 ≤ 4
5 ∈ {12, 6, -3, 5, 7}
1+2 = 3-0

Exercice 2 – Expressions numériques / logiques

Compléter le tableau ci-dessous. Les cellules grises sont données, les cases blanches sont à remplir :

# Expression en algorithme Expression en Python Résultat Type ✔️
1 x = 15 + 3 * 2 + 5
2 x ← (18 mod 5) / 2
3 x = (13 % 5) // 2
4 x ← Abs(-12.5)+3
5 a = 3 ; b = 6
x = (a > b) * a + (a <= b) * b
6 c ← 8 ; d ← 1 ; x ← Abs(a-c) + Abs(b-d)
7 x ← Ent(Racine((a-c)*(a-c)+(b-d)*(b-d)))
8 x ← 15 + 3 * 2 + Ent(5.56)
9 x ← 15. + 3 * 2 + Ent(5.56)
10 x = (7+ round(14.36)) % 2
11 x ← 20 > 10 * 1.5
12 x ← Aléa(10, 20) > 30
13 x ← Arrondi(Abs(-12.9)) + Racine(16)

Exercice 3 – Exécution manuelle (Trace mémoire)

Donner la trace d'exécution des variables X, Y et Z après l'exécution de chaque instruction :

💡 Indications :
  • Si une variable n'a pas encore été initialisée, indiquer un tiret - (ou laisser vide).
  • Une variable conserve sa valeur précédente tant qu'une nouvelle affectation ne la modifie pas.
  • Respecter la priorité des opérateurs : *, div, et mod sont prioritaires sur + et -.
# Instruction X Y Z ✔️
1 X ← 10
2 Y ← 2
3 X ← X + Y * 2
4 Z ← X div 2 + Y
5 Y ← (Z + X) mod 2
6 Z ← X * 3 + 4 mod 2

Exercice 4 – Fonction Aléa

Compléter le tableau ci-dessous avec l'instruction Python équivalente et l'intervalle de variation de la variable X :

💡 Indications :
  • La fonction algorithmique Aléa(a, b) se traduit en Python par x = randint(a, b) (bibliothèque random).
  • L'intervalle de variation s'obtient en déterminant les valeurs minimale et maximale possibles pour X.
  • Attention aux opérations avec un nombre négatif (ex: * -2) : les bornes s'inversent car la valeur min provient de la plus grande valeur d'origine.
# Instruction Algorithme Instruction Python Intervalle de variation ✔️
1 x ← Aléa(1, 6)
≤ X ≤
2 x ← Aléa(1, 6) * 10
≤ X ≤
3 x ← Aléa(1, 6) * -2
≤ X ≤
4 x ← Aléa(1, 6) // 2
≤ X ≤
5 x ← Aléa(1, 6) * Aléa(0, 2)
≤ X ≤
6 x ← Aléa(10, 90) / Aléa(1, 9)
≤ X ≤

Exercice 5 – Concaténation de Chaînes

Soient les variables Python : ch1 = "python", ch2 = "javascript", ch3 = "uml" et ch4 = "perl".

📊 Représentation visuelle des chaînes et des indices de leurs caractères (0 à n-1)
ch1 = "python"
0 p
1 y
2 t
3 h
4 o
5 n
ch2 = "javascript"
0 j
1 a
2 v
3 a
4 s
5 c
6 r
7 i
8 p
9 t
ch3 = "uml"
0 u
1 m
2 l
ch4 = "perl"
0 p
1 e
2 r
3 l
💡 Indices de résolution pour les expressions complexes :
  • Expression 4 : ch2[9].upper() donne 'T', ch1[2].upper() donne 'T'. Assembler dans l'ordre avec les lettres ch2[7] ('i'), ch2[8] ('p'), ch1[4] ('o'), 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' (code ASCII 104), et $104 - 3 = 101$ qui correspond au caractère 'e'.
  • Expression 6 : Évaluer les longueurs : len(ch3) = 3 et len(ch4) = 4.
    • ch3[len(ch3)-1] → ch3[2] = 'l' • ch2[len(ch3)] → ch2[3] = 'a' • ch4[len(ch4)-2] → ch4[2] = 'r'
    • ch3[3 // 2] → ch3[1] = 'm' • ch4[4 - 3] → ch4[1] = 'e'.

Remplir le tableau ci-dessous par l'affichage de chacune des instructions (résultat sans les guillemets) :

# Instruction Python Résultat affiché ✔️
1 print(ch1[0])
2 print(ch2.upper())
3 print(ch1[0] + ch3[0] + ch2[5] + ch4[1])
4 print(ch2[9].upper() + ch2[7] + ch2[8] + ch1[2].upper() + ch1[4] + ch1[0])
5 print(str(len(ch1) - len(ch4)) + ch4[1] + " " + ch2[4] + ch2[5] + ch2[7] + chr(ord(ch1[3]) - 3) + ch1[5])
6 print(ch3[len(ch3) - 1] + ch2[len(ch3)] + ch4[len(ch4) - 2] + ch3[len(ch3) // 2] + ch4[len(ch4) - len(ch3)])

Exercice 6 – Manipulation de Chaînes

Soient les variables : ch1 = "Algorithmique", ch2 = "Python", et ch3 = "4502".

📊 Représentation visuelle des chaînes et des indices de leurs caractères (0 à n-1)
ch1 = "Algorithmique"
0 A
1 l
2 g
3 o
4 r
5 i
6 t
7 h
8 m
9 i
10 q
11 u
12 e
ch2 = "Python"
0 P
1 y
2 t
3 h
4 o
5 n
ch3 = "4502"
0 4
1 5
2 0
3 2

Compléter le tableau ci-dessous en évaluant chaque instruction :

💡 Indications :
  • sous_chaine(ch, d, f) en Algorithme équivaut au découpage ch[d:f] en Python.
  • Effacer(ch, d, f) supprime les caractères de l'indice d à f (ex: Effacer(F, 0, 2) supprime les 2 premiers caractères → F[2:]).
  • ch1.find(sub) retourne l'indice de la 1ère occurrence de sub, ou -1 si la sous-chaîne n'est pas trouvée.
  • En Python, isdecimal() retourne True (évalué comme 1 dans un calcul) ou False (évalué comme 0).
# Instruction Algorithme Instruction Python Résultat Type ✔️
1 A ← Long(ch1)
B ← Long(ch2)
2 C ← ConvCh(A) + ConvCh(B)
3 D ← Valeur(ConvCh(B) + ConvCh(A))
4 E = D - float(C)
5 F ← sous_chaine(ch1, Long(ch3), Long(ch1))
6 G ← Majus(F[0]) + Chr(Valeur(C) - 15) + Effacer(F, 0, 2)
7 H = C.isdecimal() * len(C) + G.isdecimal() * len(G)
8 I = ch1.find("go")
J = ch1.find("que")
9 K ← Valeur(ch3) – Ent(E) – Valeur(ch3[3]) * 1000
10 L ← Effacer(ch1, I+2, Long(ch1)) + ConvCh(K) + Effacer(ch1, 0, J)

Exercice 7 – Fonctions prédéfinies Chaînes (QCM)

🧪 Simulateur Graphique SVG des Fonctions Prédéfinies Mode Interactif

Cocher la ou les bonnes réponses pour chacune des propositions ci-dessous :

1. Soit l'instruction X ← Ent(12.33) :
💡 Afficher l'indication
Indication : La fonction Ent(x) extrait la partie entière d'un nombre réel (ex : Ent(12.33) = 12). Le résultat obtenu est toujours un nombre entier.
2. L'instruction R ← arrondi(12.75) permet d'affecter à la variable R :
💡 Afficher l'indication
Indication : La fonction Arrondi(x) arrondit au nombre entier le plus proche. Comme la partie décimale 0.75 est supérieure ou égale à 0.5, 12.75 s'arrondit à 13.
3. Soit l'instruction : C ← sous_chaine("informatique", 2, 5) :
💡 Afficher l'indication
Indication : sous_chaine("informatique", 2, 5) extrait les caractères de l'indice 2 à 5 (exclu), ce qui correspond aux positions 2 ('f'), 3 ('o') et 4 ('r') → "for". Le résultat d'une fonction sous_chaine est toujours une chaîne de caractères (string).
4. L'instruction T ← EstNum("123") affecte à T :
💡 Afficher l'indication
Indication : La fonction EstNum(ch) vérifie si la chaîne est composée exclusivement de chiffres. Elle renvoie un résultat booléen (VRAI ou FAUX). Pour "123", elle renvoie VRAI.
5. Soit l'instruction : P ← Pos("2", "FIFA 2022") :
💡 Afficher l'indication
Indication : La fonction Pos(ch1, ch2) recherche l'indice de la première occurrence de ch1 dans ch2. Dans "FIFA 2022", le premier '2' se trouve à l'indice 5. Une position/indice est toujours de type entier.

Exercice 8 – Générateur de Mot de Passe (Password)

Création d'un mot de passe mp de 6 caractères composé de 2 chiffres (0 → 9), 2 majuscules ("A" → "Z") et 2 minuscules ("a" → "z") :

🔑 Mot de passe :

Exercice 9 – Permutation des Chiffres

Saisir un entier a composé de 2 chiffres (10 → 99) et permuter ses chiffres pour obtenir b (ex: 49 → 94) :

Entier a =

Exercice 10 – Autonomie de la Batterie

Calculer la consommation moyenne (en % aux 100 km) et la distance maximale dm (autonomie restante en km) qu'un véhicule électrique peut parcourir avec le niveau de batterie actuel :

Autonomie de la Batterie
Autonomie de la Batterie

Exercice 11 – Circuit Logique et Portes Logiques

Simulation du circuit logique de l'équation booleénne : $$L = (a \cdot \bar{c}) + (b \cdot c)$$

État de la Lampe L : FAUX (0) — Éteinte 🔴
📊 Table de Vérité de la fonction $L = (a \cdot \bar{c}) + (b \cdot c)$ :
a b c c̄ T1 = a • c̄ T2 = b • c L = T1 + T2
0 0 0 1 0 0 0
0 0 1 0 0 0 0
0 1 0 1 0 0 0
0 1 1 0 0 1 1
1 0 0 1 1 0 1
1 0 1 0 0 0 0
1 1 0 1 1 0 1
1 1 1 0 0 1 1

Exercice 12 – Citerne d'Huile et Logistique de Transport

Un oléiculteur dispose d'une quantité d'huile Q (Litres). L'huile est mise en bouteilles de 1L, rangées dans des caisses de 12 bouteilles, puis transportées par un camion de 30 caisses max par voyage :

Exercice 13 – Fonctions sur les Chaînes

Compléter le tableau ci-dessous avec la chaîne ch ← "programme 2025" :

🔤 Visualisation de la chaîne ch ← "programme 2025" 14 Caractères (indices 0 à 13)
Instruction en algorithme Type Résultat ✔️
a ← chr(ent(100.5))
b ← majus(ch[0]) + ch[5] + ch[3] + ch[8]
c ← sous_chaine(ch, 3, 9)
d ← effacer(ch, 3, 9)
e ← chr(65 + alea(0, 25))
f ← convch(45 div 10 + 15 mod 2 + arrondi(3.2))
g ← "A" ≤ e ≤ "Z"
i ← valeur(ch[13] + sous_chaine(ch, 10, 13))
j ← ord(ch[2])

Exercice 14 – Générateur de Pseudonymes

Un site propose des pseudonymes automatisés lors de la création d'un compte.
Le pseudonyme est composé par les trois premières lettres du prénom suivies par la longueur du prénom, les trois dernières lettres du nom suivies par la longueur du nom, le tout succédé par un nombre aléatoire de 2 chiffres.
Exemple : Nom & Prénom = "Sami Ben Salah" → Pseudonyme proposé : SAM4_LAH9_31

🧪 Simulateur Interactif de Pseudonymes Chaîne Unique (Prénom Nom)
📘 Correction : Algorithme & Code Python de Génération
📜 En Algorithme :
Algorithme Pseudonyme
Variables
    ch, prenom, nom, p1, p2, p3, pseudo : Chaîne
    p : Entier
Début
    Ecrire("Nom & Prénom : ") ; Lire(ch)
    p ← pos(" ", ch)
    prenom ← sous_chaine(ch, 0, p)
    nom ← sous_chaine(ch, p + 1, long(ch))
    
    p1 ← majus(sous_chaine(prenom, 0, 3)) + convch(long(prenom))
    p2 ← majus(sous_chaine(nom, long(nom) - 3, long(nom))) + convch(long(nom))
    p3 ← convch(alea(10, 99))
    
    pseudo ← p1 + "_" + p2 + "_" + p3
    Ecrire("Pseudonyme proposé : ", pseudo)
Fin
🐍 En Python :
import random

ch = input("Nom & Prénom : ")
p = ch.find(" ")
prenom = ch[:p]
nom = ch[p+1:]

p1 = prenom[:3].upper() + str(len(prenom))
p2 = nom[-3:].upper() + str(len(nom))
p3 = str(random.randint(10, 99))

pseudo = f"{p1}_{p2}_{p3}"
print("Pseudonyme proposé :", pseudo)
✍️ Exercice d'entraînement : Compléter le tableau

Appliquer les règles de génération pour trouver les composantes et le pseudonyme de chaque utilisateur :

Nom & Prénom p1 (3 1ères lettres prénom + long) p2 (3 dèr. lettres nom + long) Pseudonyme (ex: SAM4_LAH9_31) ✔️
Sami Ben Salah
Mohamed Mani
Ali Bouazizi
Yassine Trabelsi