Traitements sur tableaux

Plan de cours

Quand 100 variables deviennent un seul tableau

Le tableau est la structure de données la plus utilisée du programme officiel. Manipuler 100 notes ne nécessite pas 100 variables note1, note2, … : un tableau notes[1..100] suffit, et tous les traitements deviennent automatisables par boucle.

Concepts clés

1. Un tableau = N éléments du même type, accessibles par indice.
2. Algo : indices 1..N. Python : indices 0..N-1.
3. Traitements canoniques : somme, max, min, recherche, comptage.
4. Un tableau est passé par référence (même sans VAR explicite).

Avant de commencer

• Q1. Comment accéder au 3ème élément d'un tableau T en notation algorithmique ?
• Q2. Comment l'accéder en Python ?
• Q3. Quelle valeur initiale donneriez-vous à un accumulateur pour calculer un produit cumulé ?

1. Le contenu du cours

1.1 Analogie : le casier scolaire

Un tableau est un casier numéroté :

Casier T :  [   ][   ][   ][   ][   ][   ][   ]
indices :    1    2    3    4    5    6    7

Pour accéder au contenu, vous donnez le numéro du casier (l'indice). Tous les casiers ont la même forme (le même type). C'est tout.

1.2 Déclaration

Notation algorithmique tunisienne

T.D.O
  notes  : tableau de 25 réels
  N      : entier = 25

Le tableau notes a 25 cases, indexées de 1 à 25, contenant chacune un réel.

Python — utilisation des listes

N = 25
notes = [0.0] * N    # initialise un tableau de 25 zéros

Ou en partant d'une liste pré-remplie :

notes = [12, 15, 8, 17, 13]

1.3 Accès aux éléments

1.4 Les six traitements canoniques

Tous les exercices de bac sur tableaux sont des variations de ces 6 traitements. Maîtrisez-les.

Traitement 1 — Saisie

def saisir_tableau(N):
    """Lit N entiers et retourne le tableau."""
    T = [0] * N
    for i in range(N):
        T[i] = int(input(f"T[{i+1}] = "))
    return T

Traitement 2 — Somme / Moyenne

def somme_tableau(T):
    s = 0
    for x in T:
        s = s + x
    return s

def moyenne_tableau(T):
    return somme_tableau(T) / len(T)

Traitement 3 — Recherche du maximum (et du minimum)

def maximum(T):
    """T non vide."""
    m = T[0]
    for i in range(1, len(T)):
        if T[i] > m:
            m = T[i]
    return m

Traitement 4 — Recherche d'une valeur (présence)

def contient(T, val):
    for x in T:
        if x == val:
            return True   # sortie anticipée
    return False

Traitement 5 — Compter les occurrences

def occurrences(T, val):
    nb = 0
    for x in T:
        if x == val:
            nb = nb + 1
    return nb

Traitement 6 — Filtrer (extraire un sous-tableau)

def positifs(T):
    """Retourne le sous-tableau des valeurs strictement positives."""
    resultat = []
    for x in T:
        if x > 0:
            resultat.append(x)
    return resultat

1.5 Tableau et passage par référence

Un tableau passé en paramètre est modifiable depuis le sous-programme (référence partagée, voir leçon 3.3).

Exemple — Doubler tous les éléments

def doubler(T):
    """Modifie T sur place : chaque élément est multiplié par 2."""
    for i in range(len(T)):
        T[i] = T[i] * 2

L = [1, 2, 3]
doubler(L)
print(L)   # [2, 4, 6]

Comparaison version « pure »

def double_pur(T):
    """Retourne un NOUVEAU tableau, sans modifier l'original."""
    return [x * 2 for x in T]

L = [1, 2, 3]
L2 = double_pur(L)
print(L, L2)   # [1, 2, 3] [2, 4, 6]

1.6 Trace d'exécution — Recherche du max

Tableau T = [12, 8, 15, 3, 17, 9], taille N = 6.

2. Exercices pratiques

Niveau Débutant — Type bac courant

def somme_positifs(T):
    s = 0
    for x in T:
        if x > 0:
            s = s + x
    return s

T = [-3, 5, -1, 8, 0, 12, -7]
print(somme_positifs(T))   # 25

def somme_positifs(T):
    return sum(x for x in T if x > 0)

Niveau Intermédiaire — Type bac difficile

def indice_minimum(T):
    """Indice du plus petit élément ; en cas d'égalité, le premier."""
    indice_min = 0
    for i in range(1, len(T)):
        if T[i] < T[indice_min]:
            indice_min = i
    return indice_min

T = [5, 3, 8, 1, 9, 1, 4]
print(indice_minimum(T))   # 3

Fonction indice_min(T : tableau, N : entier) : entier
    Variables : i, ind : entier
    Début
        ind ← 1
        Pour i de 2 à N Faire
            Si T[i] < T[ind] Alors
                ind ← i
            FinSi
        FinPour
        indice_min ← ind
    Fin
FinFonction

Niveau Avancé — Hors bac (bonus)

Procédure inverser(VAR T : tableau, N : entier)
    Variables : i : entier, temp : entier
    Début
        Pour i de 1 à N DIV 2 Faire
            temp ← T[i]
            T[i] ← T[N - i + 1]
            T[N - i + 1] ← temp
        FinPour
    Fin
FinProcédure

def inverser(T):
    n = len(T)
    for i in range(n // 2):
        temp = T[i]
        T[i] = T[n - 1 - i]
        T[n - 1 - i] = temp

L = [10, 20, 30, 40, 50]
inverser(L)
print(L)   # [50, 40, 30, 20, 10]

T[i], T[n - 1 - i] = T[n - 1 - i], T[i]   # swap sans temp

⚠️ Erreurs fréquentes au bac

Avant le quiz, mémorisez ces pièges classiques qui font perdre des points :

• Erreur 1. Indice hors borne : T[N] en Python (le dernier indice est N-1). Lève IndexError.
• Erreur 2. Confondre indexation 1-N (algorithmique tunisien) et 0-(N-1) (Python). Erreur de décalage de 1 (off-by-one).
• Erreur 3. Initialiser le max/min à 0 au lieu de T[0]. Pour un tableau de valeurs négatives, le max retourné est faux.
• Erreur 4. Modifier un tableau pendant qu'on le parcourt. Le for x in T: peut alors sauter ou répéter des éléments.

3. Quiz de vérification

En résumé

Avant la leçon 3.5 (Traitements sur chaînes), vous devez :

• ✅ Déclarer un tableau en algorithmique tunisien (T.D.O) et en Python,
• ✅ Implémenter sans hésiter les 6 traitements canoniques,
• ✅ Comprendre que les tableaux sont passés par référence (mutables),
• ✅ Initialiser correctement les variables (max ← T[0], somme ← 0, …).

Les chaînes de caractères se manipulent presque comme des tableaux (1 caractère = 1 case), avec quelques spécificités à venir.