Affichage triangulaire des caractères d’un tableau de chaînes – Bac pratique 2006

Bac Pratique 02-09-24

87 0

Sujet bac pratique (scientifique 2026)

Ecrire un programme Python intitulé TRIANGLE qui permet :

- de remplir un tableau T de n chaînes de caractères (n dans l'intervalle [3,7]). Chaque chaîne doit avoir un nombre de caractères supérieurs ou égal à son indice dans le tableau.

- d'afficher pour chaque élément T[i] du tableau, les i premiers caractères de la chaîne.

Exemple : Soit T un tableau de 6 chaînes de caractères.

Solution Algorithmique

Algorithme du programme Principal

L’algorithme principal gère l’exécution complète du programme. Il commence par demander une taille valide n, affiche un message indiquant le début du remplissage, puis remplit le tableau t avec n chaînes de caractères. Enfin, il affiche progressivement les caractères de chaque chaîne : 1 caractère pour le premier élément, 2 pour le deuxième, 3 pour le troisième, etc.

Algorithme TRIANGLE
Debut
     # Appeler la fonction saisie() afin de demander
     # et de récupérer la taille du tableau.
     n <-- saisie()
     # Afficher un message avant le remplissage du tableau.
     Ecrire("*** Remplissage du tableau T ***")
     # Appeler la procédure remplir() pour saisir
     # les n éléments du tableau T.
     remplir(t, n)
     # Appeler la procédure afficher() pour afficher
     # les caractères sélectionnés dans chaque élément
     # du tableau T.
     #
     # Pour le premier élément, 1 caractère est affiché.
     # Pour le deuxième élément, 2 caractères sont affichés.
     # Pour le troisième élément, 3 caractères sont affichés, etc.
     afficher(t, n)
Fin

Algorithme TRIANGLE

Debut

# Appeler la fonction saisie() afin de demander

# et de récupérer la taille du tableau.

n <-- saisie()

# Afficher un message avant le remplissage du tableau.

Ecrire("*** Remplissage du tableau T ***")

# Appeler la procédure remplir() pour saisir

# les n éléments du tableau T.

remplir(t, n)

# Appeler la procédure afficher() pour afficher

# les caractères sélectionnés dans chaque élément

# du tableau T.

# Pour le premier élément, 1 caractère est affiché.

# Pour le deuxième élément, 2 caractères sont affichés.

# Pour le troisième élément, 3 caractères sont affichés, etc.

afficher(t, n)

Fin

Déclaration des objets

Objet	Type / Nature
t	tableau des chaînes des caractères
n	entier

La fonction saisie

Cette fonction permet de saisir et de contrôler la taille du tableau.
Elle demande à l’utilisateur une valeur n et vérifie que celle-ci respecte la condition 2 < n < 20. Tant qu’une valeur incorrecte est saisie, la fonction redemande une nouvelle valeur. Lorsque la taille est valide, la fonction retourne n au programme principal.

fonction saisie():entier
Début
    # La variable test permet de contrôler
    # la validité de la taille saisie.
    # Au départ, test vaut False car aucune valeur correcte
    # n'a encore été saisie.
    test <-- Faux
    # Répéter la saisie tant que la taille
    # n'est pas correcte.
    Tant que test = Faux faire
        # Demander à l'utilisateur de saisir
        # la taille du tableau.
        Ecrire("donner 2<n<20 : ")
        Lire(n)
        # Vérifier que la taille est strictement supérieure
        # à 2 et strictement inférieure à 20.
        #
        # Les valeurs acceptées sont donc :
        # 3, 4, 5, ..., 18, 19.
        Si 2 < n < 20 alors
            # La taille saisie est correcte.
            # On affecte True à test afin d'arrêter
            # la boucle de contrôle.
            test <-- Vrai
        Fin si
    Fin tant que
    # Retourner la taille correcte du tableau
    # vers le programme principal.
    Retourner n
Fin

fonction saisie():entier

Début

# La variable test permet de contrôler

# la validité de la taille saisie.

# Au départ, test vaut False car aucune valeur correcte

# n'a encore été saisie.

test <-- Faux

# Répéter la saisie tant que la taille

# n'est pas correcte.

Tant que test = Faux faire

# Demander à l'utilisateur de saisir

# la taille du tableau.

Ecrire("donner 2<n<20 : ")

Lire(n)

# Vérifier que la taille est strictement supérieure

# à 2 et strictement inférieure à 20.

# Les valeurs acceptées sont donc :

# 3, 4, 5, ..., 18, 19.

Si 2 < n < 20 alors

# La taille saisie est correcte.

# On affecte True à test afin d'arrêter

# la boucle de contrôle.

test <-- Vrai

Fin si

Fin tant que

# Retourner la taille correcte du tableau

# vers le programme principal.

Retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier
test	booléen

La procédure remplir

La procédure remplir permet de remplir les n premières cases du tableau t avec des chaînes de caractères, tout en vérifiant que chaque chaîne saisie respecte une condition de longueur.

Pour chaque élément t[i], elle demande une saisie à l’utilisateur et vérifie que sa longueur est strictement supérieure à i. Si la condition n’est pas respectée, la saisie est répétée jusqu’à obtenir une valeur valide.

Procédure remplir(var t:tab;n:entier)
Début  
     # Parcourir les n premières cases du tableau.
     Pour i de 0 à n-1 faire
        # La variable test permet de contrôler
        # la validité de l'élément saisi.
        test <-- Faux
        # Répéter la saisie tant que l'élément
        # ne respecte pas la condition demandée.
        Tant que test = Faux faire
            # Demander à l'utilisateur de saisir
            # une chaîne de caractères.
            Ecrire("donner un element du tableau : ")
            Lire(t[i])
            # Vérifier que la longueur de la chaîne saisie
            # est supérieure à l'indice i.
            Si long(t[i]) > i alors
                # La condition est respectée.
                # On affecte True à test pour arrêter
                # la boucle de contrôle.
                test <-- Vrai
            Fin si
        Fin tant que
Fin

Procédure remplir(var t:tab;n:entier)

Début

# Parcourir les n premières cases du tableau.

Pour i de 0 à n-1 faire

# La variable test permet de contrôler

# la validité de l'élément saisi.

test <-- Faux

# Répéter la saisie tant que l'élément

# ne respecte pas la condition demandée.

Tant que test = Faux faire

# Demander à l'utilisateur de saisir

# une chaîne de caractères.

Ecrire("donner un element du tableau : ")

Lire(t[i])

# Vérifier que la longueur de la chaîne saisie

# est supérieure à l'indice i.

Si long(t[i]) > i alors

# La condition est respectée.

# On affecte True à test pour arrêter

# la boucle de contrôle.

test <-- Vrai

Fin si

Fin tant que

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
test	booléen

La procédure afficher

La procédure afficher permet d’afficher progressivement les caractères des chaînes contenues dans le tableau t.

Pour chaque élément t[i], elle affiche uniquement les caractères dont les indices vont de 0 à i. Ainsi, le nombre de caractères affichés augmente progressivement à chaque ligne.

Procédure afficher(t:tab;n:entier)
Début  
     # Parcourir les n éléments du tableau.
     Pour i de 0 à n-1 faire
        # Parcourir les caractères de t[i]
        # depuis le premier caractère jusqu'au caractère
        # d'indice i inclus.
        #
        # Le nombre de caractères affichés augmente donc
        # progressivement à chaque ligne.
        Pour j de 0 à i faire
            # Afficher le caractère d'indice j de t[i].
            #
            # end='' permet d'afficher les caractères
            # sur la même ligne sans passer à la ligne.
            Ecrire(t[i][j])
        Fin pour 
        # Passer à la ligne suivante après avoir affiché
        # les caractères nécessaires de t[i].
        print()
     Fin pour
Fin

Procédure afficher(t:tab;n:entier)

Début

# Parcourir les n éléments du tableau.

Pour i de 0 à n-1 faire

# Parcourir les caractères de t[i]

# depuis le premier caractère jusqu'au caractère

# d'indice i inclus.

# Le nombre de caractères affichés augmente donc

# progressivement à chaque ligne.

Pour j de 0 à i faire

# Afficher le caractère d'indice j de t[i].

# end='' permet d'afficher les caractères

# sur la même ligne sans passer à la ligne.

Ecrire(t[i][j])

Fin pour

# Passer à la ligne suivante après avoir affiché

# les caractères nécessaires de t[i].

print()

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
j	entier

Solution en Python

# ==========================================================
# Importation de la bibliothèque NumPy
# ==========================================================

from numpy import array

# Importer la fonction array de la bibliothèque NumPy.
# Elle permet de créer et de manipuler des tableaux.


# ==========================================================
# Création du tableau
# ==========================================================

# Créer un tableau T de 100 éléments.
# Chaque élément du tableau est destiné à contenir une chaîne
# de caractères.
#
# Le tableau contient plus de cases que nécessaire afin de
# pouvoir choisir une taille n comprise entre 3 et 19.
t = array([str] * 100)


# ==========================================================
# Fonction de saisie de la taille du tableau
# ==========================================================

def saisie():

    # La variable test permet de contrôler
    # la validité de la taille saisie.
    # Au départ, test vaut False car aucune valeur correcte
    # n'a encore été saisie.
    test = False

    # Répéter la saisie tant que la taille
    # n'est pas correcte.
    while test == False:

        # Demander à l'utilisateur de saisir
        # la taille du tableau.
        n = int(input("donner 2<n<20 : "))

        # Vérifier que la taille est strictement supérieure
        # à 2 et strictement inférieure à 20.
        #
        # Les valeurs acceptées sont donc :
        # 3, 4, 5, ..., 18, 19.
        if 2 < n < 20:

            # La taille saisie est correcte.
            # On affecte True à test afin d'arrêter
            # la boucle de contrôle.
            test = True

    # Retourner la taille correcte du tableau
    # vers le programme principal.
    return n


# ==========================================================
# Procédure de remplissage du tableau
# ==========================================================

def remplir(t, n):

    # Parcourir les n premières cases du tableau.
    for i in range(n):

        # La variable test permet de contrôler
        # la validité de l'élément saisi.
        test = False

        # Répéter la saisie tant que l'élément
        # ne respecte pas la condition demandée.
        while test == False:

            # Demander à l'utilisateur de saisir
            # une chaîne de caractères.
            t[i] = input("donner un element du tableau : ")

            # Vérifier que la longueur de la chaîne saisie
            # est supérieure à l'indice i.
            #
            # Pour i = 0, la chaîne doit avoir au moins
            # 1 caractère.
            #
            # Pour i = 1, elle doit avoir au moins
            # 2 caractères, etc.
            if len(t[i]) > i:

                # La condition est respectée.
                # On affecte True à test pour arrêter
                # la boucle de contrôle.
                test = True


# ==========================================================
# Procédure d'affichage du tableau
# ==========================================================

def afficher(t, n):

    # Parcourir les n éléments du tableau.
    for i in range(n):

        # Parcourir les caractères de t[i]
        # depuis le premier caractère jusqu'au caractère
        # d'indice i inclus.
        #
        # Le nombre de caractères affichés augmente donc
        # progressivement à chaque ligne.
        for j in range(i + 1):

            # Afficher le caractère d'indice j de t[i].
            #
            # end='' permet d'afficher les caractères
            # sur la même ligne sans passer à la ligne.
            print(t[i][j], end='')

        # Passer à la ligne suivante après avoir affiché
        # les caractères nécessaires de t[i].
        print()


# ==========================================================
# Programme principal
# ==========================================================

# Appeler la fonction saisie() afin de demander
# et de récupérer la taille du tableau.
n = saisie()


# Afficher un message avant le remplissage du tableau.
print("*** Remplissage du tableau T ***")


# Appeler la procédure remplir() pour saisir
# les n éléments du tableau T.
remplir(t, n)


# Appeler la procédure afficher() pour afficher
# les caractères sélectionnés dans chaque élément
# du tableau T.
#
# Pour le premier élément, 1 caractère est affiché.
# Pour le deuxième élément, 2 caractères sont affichés.
# Pour le troisième élément, 3 caractères sont affichés, etc.
afficher(t, n)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

# ==========================================================

# Importation de la bibliothèque NumPy

# ==========================================================

from numpy import array

# Importer la fonction array de la bibliothèque NumPy.

# Elle permet de créer et de manipuler des tableaux.

# ==========================================================

# Création du tableau

# ==========================================================

# Créer un tableau T de 100 éléments.

# Chaque élément du tableau est destiné à contenir une chaîne

# de caractères.

# Le tableau contient plus de cases que nécessaire afin de

# pouvoir choisir une taille n comprise entre 3 et 19.

t = array([str] * 100)

# ==========================================================

# Fonction de saisie de la taille du tableau

# ==========================================================

def saisie():

# La variable test permet de contrôler

# la validité de la taille saisie.

# Au départ, test vaut False car aucune valeur correcte

# n'a encore été saisie.

test = False

# Répéter la saisie tant que la taille

# n'est pas correcte.

while test == False:

# Demander à l'utilisateur de saisir

# la taille du tableau.

n = int(input("donner 2<n<20 : "))

# Vérifier que la taille est strictement supérieure

# à 2 et strictement inférieure à 20.

# Les valeurs acceptées sont donc :

# 3, 4, 5, ..., 18, 19.

if 2 < n < 20:

# La taille saisie est correcte.

# On affecte True à test afin d'arrêter

# la boucle de contrôle.

test = True

# Retourner la taille correcte du tableau

# vers le programme principal.

return n

# ==========================================================

# Procédure de remplissage du tableau

# ==========================================================

def remplir(t, n):

# Parcourir les n premières cases du tableau.

for i in range(n):

# La variable test permet de contrôler

# la validité de l'élément saisi.

test = False

# Répéter la saisie tant que l'élément

# ne respecte pas la condition demandée.

while test == False:

# Demander à l'utilisateur de saisir

# une chaîne de caractères.

t[i] = input("donner un element du tableau : ")

# Vérifier que la longueur de la chaîne saisie

# est supérieure à l'indice i.

# Pour i = 0, la chaîne doit avoir au moins

# 1 caractère.

# Pour i = 1, elle doit avoir au moins

# 2 caractères, etc.

if len(t[i]) > i:

# La condition est respectée.

# On affecte True à test pour arrêter

# la boucle de contrôle.

test = True

# ==========================================================

# Procédure d'affichage du tableau

# ==========================================================

def afficher(t, n):

# Parcourir les n éléments du tableau.

for i in range(n):

# Parcourir les caractères de t[i]

# depuis le premier caractère jusqu'au caractère

# d'indice i inclus.

# Le nombre de caractères affichés augmente donc

# progressivement à chaque ligne.

for j in range(i + 1):

# Afficher le caractère d'indice j de t[i].

# end='' permet d'afficher les caractères

# sur la même ligne sans passer à la ligne.

print(t[i][j], end='')

# Passer à la ligne suivante après avoir affiché

# les caractères nécessaires de t[i].

print()

# ==========================================================

# Programme principal

# ==========================================================

# Appeler la fonction saisie() afin de demander

# et de récupérer la taille du tableau.

n = saisie()

# Afficher un message avant le remplissage du tableau.

print("*** Remplissage du tableau T ***")

# Appeler la procédure remplir() pour saisir

# les n éléments du tableau T.

remplir(t, n)

# Appeler la procédure afficher() pour afficher

# les caractères sélectionnés dans chaque élément

# du tableau T.

# Pour le premier élément, 1 caractère est affiché.

# Pour le deuxième élément, 2 caractères sont affichés.

# Pour le troisième élément, 3 caractères sont affichés, etc.

afficher(t, n)

Exécution du programme

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Apprendre à programmer un robot Maqueen avec Micro:bit

Micro:bit 31-07-26

Commande Bluetooth d’un servomoteur avec Arduino UNO et Smartphone

Arduino 26-07-26

Contrôle Bluetooth d’un servomoteur avec ESP32 et application mobile

ESP32 24-07-26

Analyse appréciations – Bac théorique – Section informatique – 2026

Bac Info 19-07-26

Contrôle d’un servomoteur avec Micro:bit et smartphone par Bluetooth

Micro:bit 09-07-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 14048vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 13536vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 11328vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 10923vues

Allumer une LED par la carte ESP32

ESP32 10587vues

Construction des robots

Tutoriels plus commentés

Balance électronique avec Arduino UNO et module HX711

Arduino 124 commentaires

Construire un GPS commandé par Arduino

Arduino 111 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 60 commentaires

Détection d’un objet en mouvement à l’aide de ESP32 et Webcam

ESP32 43 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 34 commentaires

Affichage triangulaire des caractères d’un tableau de chaînes – Bac pratique 2006

Sujet bac pratique (scientifique 2026)

Solution Algorithmique

Algorithme du programme Principal

La fonction saisie

La procédure remplir

La procédure afficher

Solution en Python

Exécution du programme

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles