Séance 6 : Tableaux 1D (Déclaration, Parcours indicé & Modules types)

Phase {{ currentPhase === 'all' ? 'Toutes' : currentPhase + ' / ' + phases.length }}

Phase active :

{{ currentPhase === 'all' ? 'Vue d\'ensemble (Toutes les phases)' : phases[currentPhase - 1].title }}

Étape 1

Situation & Labo 1D : Manipulation indicée

10 min

Énoncé

« Saisir un entier N (3 à 10), remplir un tableau T de N éléments entiers, calculer la somme, la moyenne et les valeurs extrêmes (Min, Max), puis afficher les éléments un par un. »

Laboratoire Interactif : Tableau T[0 .. N-1]

Presets :

Taille effective N (3 à 10) :

N =

Indices de 0 à {{ simN - 1 }} (modifiez directement les cases) :

T[{{ idx }}]

Taille (N)

Somme

Moyenne

Minimum

Maximum

Affichage Python indicé (for i in range(n))

Questions de réflexion :

Algorithmique

Python

Étape 2

Déclaration & Parcours indicé

15 min

Opération	Algorithmique (Norme Officielle)	Python 3 (numpy)
Importation	—	`from numpy import array`
Déclaration 1D (T.D.N.T.)	T.D.N.T. : `Tab = Tableau de N Entier` T.D.O. : `t : Tab`	`t = array([0] * N)`
Accès à la case `i`	`T[i]` avec `0 ≤ i < n`	`T[i]` avec `0 ≤ i < n`
Parcours complet	`Pour i de 0 à n - 1 Faire`	`for i in range(n):`
Affichage officiel	`Pour i de 0 à n - 1 Faire Écrire(T[i])`	`for i in range(n): print(T[i])`

Interdiction de print(T)

L'affichage d'un tableau en Python doit obligatoirement se faire élément par élément via une boucle.

Passage par adresse natif

En Python, les tableaux numpy sont automatiquement transmis par référence (adresse) sans mot-clé spécial.

Homogénéité & Statique

Tous les éléments sont de même type. La dimension maximale allouée est fixée à la création.

Étape 3

Algorithme & Programme Python

25 min

Solution Modulaire (Tableaux 1D) Modules Types

// 1. Module type de contrôle de la taille
Procédure Saisie_Taille (@n: Entier, min: Entier, max: Entier)
DEBUT
    Répéter
        Écrire("Donner la taille du tableau (", min, " à ", max, ") : ")
        Lire(n)
    Jusqu'à (n ≥ min) Et (n ≤ max)
FIN

// 2. Module type de remplissage indicé (@t: Tab)
Procédure Remplir (@t: Tab, n: Entier)
DEBUT
    Pour i de 0 à n - 1 Faire
        Écrire("Donner l'élément t[", i, "] : ")
        Lire(t[i])
    Fin Pour
FIN

// 3. Module type d'affichage élément par élément (t: Tab)
Procédure Afficher (t: Tab, n: Entier)
DEBUT
    Écrire_nl("Contenu du tableau :")
    Pour i de 0 à n - 1 Faire
        Écrire_nl("t[", i, "] = ", t[i])
    Fin Pour
FIN

// 4. Fonction de calcul de la somme (t: Tab)
Fonction calc_Somme (t: Tab, n: Entier) : Entier
DEBUT
    somme ← 0
    Pour i de 0 à n - 1 Faire
        somme ← somme + t[i]
    Fin Pour
    Retourner somme
FIN

// 5. Fonction de calcul de la moyenne (t: Tab)
Fonction calc_Moyenne (t: Tab, n: Entier) : Réel
DEBUT
    Retourner calc_Somme(t, n) / n
FIN

// 6. Fonction de recherche de la valeur minimale (Min)
Fonction calc_Min (t: Tab, n: Entier) : Entier
DEBUT
    min_val ← t[0]
    Pour i de 1 à n - 1 Faire
        Si t[i] < min_val Alors
            min_val ← t[i]
        Fin Si
    Fin Pour
    Retourner min_val
FIN

// 7. Fonction de recherche de la valeur maximale (Max)
Fonction calc_Max (t: Tab, n: Entier) : Entier
DEBUT
    max_val ← t[0]
    Pour i de 1 à n - 1 Faire
        Si t[i] > max_val Alors
            max_val ← t[i]
        Fin Si
    Fin Pour
    Retourner max_val
FIN

// 8. Algorithme Principal
ALGORITHME GestionTableau1D
DEBUT
    Saisie_Taille(n, 3, 10)
    Remplir(t, n)
    Afficher(t, n)
    som ← calc_Somme(t, n)
    moy ← calc_Moyenne(t, n)
    min_val ← calc_Min(t, n)
    max_val ← calc_Max(t, n)
    Écrire_nl("Somme des éléments = ", som)
    Écrire_nl("Moyenne des éléments = ", moy)
    Écrire_nl("Valeur minimale (Min) = ", min_val)
    Écrire_nl("Valeur maximale (Max) = ", max_val)
FIN

Déclarations : T.D.N.T., T.D.O.L. & T.D.O.G.

T.D.N.T. (Nouveaux Types)

Type
`Tab = Tableau de 10 Entier`

T.D.O.L. (Remplir & Afficher)

Objet	Type / Nature
`i`	Entier (compteur de boucle)

T.D.O.L. (calc_Somme)

Objet	Type / Nature
`i, somme`	Entier

T.D.O.L. (calc_Moyenne)

Objet	Type / Nature
`calc_Somme`	Fonction

T.D.O.L. (calc_Min & calc_Max)

Objet	Type / Nature
`i, min_val` (ou `max_val`)	Entier

T.D.O.G. (Programme Principal)

Objet	Type / Nature
`t`	Tab
`n, som, min_val, max_val`	Entier
`moy`	Réel
`Saisie_Taille, Remplir, Afficher`	Procédures
`calc_Somme, calc_Moyenne, calc_Min, calc_Max`	Fonctions

tableaux_1d.py

from numpy import array

# 1. Module de saisie de la taille N (sans break)
def saisie_taille(borne_min, borne_max):
    taille = 0
    while not (borne_min <= taille <= borne_max):
        taille = int(input(f"Donner la taille du tableau ({borne_min} à {borne_max}) : "))
    return taille

# 2. Module de remplissage (t mutable passé par adresse)
def remplir_tab(t, n):
    for i in range(n):
        t[i] = int(input(f"Donner l'élément t[{i}] : "))

# 3. Module d'affichage (élément par élément)
def afficher_tab(t, n):
    print("Contenu du tableau :")
    for i in range(n):
        print(f"t[{i}] = {t[i]}")

# 4. Fonction de calcul de la somme
def calc_somme(t, n):
    somme = 0
    for i in range(n):
        somme = somme + t[i]
    return somme

# 5. Fonction de calcul de la moyenne
def calc_moyenne(t, n):
    return calc_somme(t, n) / n

# 6. Fonction de recherche de la valeur minimale (Min)
def calc_min(t, n):
    min_val = t[0]
    for i in range(1, n):
        if t[i] < min_val:
            min_val = t[i]
    return min_val

# 7. Fonction de recherche de la valeur maximale (Max)
def calc_max(t, n):
    max_val = t[0]
    for i in range(1, n):
        if t[i] > max_val:
            max_val = t[i]
    return max_val

# --- Programme Principal ---
# Déclaration statique numpy de 10 entiers
t = array([0] * 10)

n = saisie_taille(3, 10)
remplir_tab(t, n)
afficher_tab(t, n)

som = calc_somme(t, n)
moy = calc_moyenne(t, n)
min_val = calc_min(t, n)
max_val = calc_max(t, n)

print(f"Somme des éléments = {som}")
print(f"Moyenne des éléments = {moy:.2f}")
print(f"Valeur minimale (Min) = {min_val}")
print(f"Valeur maximale (Max) = {max_val}")

Conformité Officielle

T.D.N.T. obligatoire : Le type Tab = Tableau de 10 Entier est déclaré dans le T.D.N.T., puis utilisé dans les en-têtes (@t: Tab).
Bibliothèque numpy : Déclaration obligatoire via from numpy import array et t = array([0] * 10).
Affichage indicé : Interdiction formelle du print(t) direct ; affichage boucle élément par élément.
Passage par adresse : En algorithmique via @t: Tab, en Python transmis naturellement par référence d'objet.

Étape 4

Bilan & Auto-évaluation (Quiz)

5 min

Questions flash :

Algo {{ f.resAlgo }}

Python {{ f.resPy }}

Auto-évaluation : Quiz Tableaux 1D (10 questions)

Score : {{ quizScore }} / {{ quizQuestions.length }}

Explication : {{ q.explanation }}

Séance 6 terminée !

Les tableaux à une dimension et les modules types sont maîtrisés.

Passer à la Série N°7 (8 exercices)

Étape {{ currentPhase }} / {{ phases.length }} {{ phases[currentPhase - 1].shortTitle }}