Eliminer occurrence dans un tableau – Bac pratique 2006 [ Algorithme + Python ]

Bac Pratique 23-09-24

1419 0

Sujet bac informatique pratique 2006 (Bac scientifique)

On se propose d’écrire un programme Python permettant :

a) de saisir un tableau de N chaînes non vides composées chacun d’un maximum de 10 caractères (N est une constante de valeur 10).

b) de garder la première occurrence pour les éléments redondants(qui apparaissent plus qu’une fois) et de remplacer toutes les autres occurrences par des chaînes vides. c) d’afficher les chaînes non vides restantes du tableau T.

Exemple : T à l’état initial

Ali

Salem

Amel

Eya

Mohamed

Amel

Salem

Aziz

T à l’état final

Ali

Salem

Amel

Eya

Mohamed

Aziz

Solution Algorithmique

Voici une approche algorithmique pour résoudre le problème, étape par étape :

a) Saisir un tableau de n chaînes :

Nous allons d'abord saisir un tableau de n chaînes, où chaque chaîne est non vide et a un maximum de 10 caractères, et où 5 ≤ n ≤ 15.

b) Garder la première occurrence pour les éléments redondants :

Pour chaque élément qui apparaît plus d'une fois, nous allons garder la première occurrence dans le tableau, et remplacer toutes les autres occurrences par des chaînes vides.

c) Afficher les chaînes non vides restantes :

Nous afficherons uniquement les chaînes non vides du tableau final.

Algorithme du programme Principal

Algorithme suppression_redondances
Debut
     # Afficher un message annonçant le remplissage du tableau.
     Ecrire('Remplissage du tableau t')
     # Remplir les 10 premières cases avec des chaînes valides.
     remplir(t)
     # Effacer les occurrences répétées des chaînes de caractères.
     effacer_redondance(t)
     # Afficher un message annonçant le résultat du traitement.
     Ecrire('Elements du tableau t non vides')
     # Afficher uniquement les éléments non vides du tableau.
     afficher(t)
Fin

Algorithme suppression_redondances

Debut

# Afficher un message annonçant le remplissage du tableau.

Ecrire('Remplissage du tableau t')

# Remplir les 10 premières cases avec des chaînes valides.

remplir(t)

# Effacer les occurrences répétées des chaînes de caractères.

effacer_redondance(t)

# Afficher un message annonçant le résultat du traitement.

Ecrire('Elements du tableau t non vides')

# Afficher uniquement les éléments non vides du tableau.

afficher(t)

Fin

Déclaration des objets

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

La procédure remplir

Cette procédure remplit le tableau t par des chaines dont leurs longueurs entre 1 et 10.

Procédure remplir(var t:tab)
Début
     # Parcourir les 10 premières cases du tableau.
     Pour i de 0 à 9 faire
        # Initialiser la variable test à False.
        # Elle permet de contrôler la validité de la saisie.
        test <-- Faux
        # Répéter la saisie tant que la chaîne fournie
        # ne respecte pas la condition demandée.
        Tant que test = Faux faire
            # Demander à l'utilisateur de saisir une chaîne
            # de caractères pour la case d'indice i.
            # La longueur doit être comprise entre 1 et 10.
            Ecrire( "donner elt N°" + str(i) + " dont 1<= sa longueur<=5: " )
            Lire(t[i])
            # Vérifier que la longueur de la chaîne
            # est comprise entre 1 et 10 caractères.
            Si 1 <= long(t[i]) <= 10 alors
                # Si la condition est vérifiée, la saisie
                # est valide : arrêter la boucle while.
                test <-- Vrai
            Fin si
        Fin tant que
     Fin pour
Fin

Procédure remplir(var t:tab)

Début

# Parcourir les 10 premières cases du tableau.

Pour i de 0 à 9 faire

# Initialiser la variable test à False.

# Elle permet de contrôler la validité de la saisie.

test <-- Faux

# Répéter la saisie tant que la chaîne fournie

# ne respecte pas la condition demandée.

Tant que test = Faux faire

# Demander à l'utilisateur de saisir une chaîne

# de caractères pour la case d'indice i.

# La longueur doit être comprise entre 1 et 10.

Ecrire( "donner elt N°" + str(i) + " dont 1<= sa longueur<=5: " )

Lire(t[i])

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

# est comprise entre 1 et 10 caractères.

Si 1 <= long(t[i]) <= 10 alors

# Si la condition est vérifiée, la saisie

# est valide : arrêter la boucle while.

test <-- Vrai

Fin si

Fin tant que

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
test	booléen

La procédure effacer_redondance

Cette procédure garde la première occurrence pour les éléments redondants (qui apparaissent plus qu’une fois) et remplace toutes les autres occurrences par des chaînes vides.

procedure effacer_redondance(var t:tab)
Début 
    # Parcourir les 9 premières cases du tableau.
    # L'indice i varie de 0 à 8.
    Pour i de 0 à 8 faire
        # Vérifier que la case courante n'est pas vide.
        # Une case vide contient la chaîne ''.
        Si t[i] != '' alors
            # Parcourir toutes les cases situées après i,
            # de l'indice i+1 jusqu'à l'indice 9.
            Pour j de i+1 à 9 faire
                # Comparer la chaîne t[i] avec la chaîne t[j].
                Si t[i] = t[j] alors
                    # Si les deux chaînes sont identiques,
                    # effacer la répétition située à l'indice j.
                    # La chaîne est remplacée par une chaîne vide.
                    # La première occurrence est ainsi conservée.
                    t[j] <-- ''
                Fin si
            Fin pour
        Fin si
    Fin pour
Fin

procedure effacer_redondance(var t:tab)

Début

# Parcourir les 9 premières cases du tableau.

# L'indice i varie de 0 à 8.

Pour i de 0 à 8 faire

# Vérifier que la case courante n'est pas vide.

# Une case vide contient la chaîne ''.

Si t[i] != '' alors

# Parcourir toutes les cases situées après i,

# de l'indice i+1 jusqu'à l'indice 9.

Pour j de i+1 à 9 faire

# Comparer la chaîne t[i] avec la chaîne t[j].

Si t[i] = t[j] alors

# Si les deux chaînes sont identiques,

# effacer la répétition située à l'indice j.

# La chaîne est remplacée par une chaîne vide.

# La première occurrence est ainsi conservée.

t[j] <-- ''

Fin si

Fin pour

Fin si

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
j	entier

La procédure afficher

Cette procédure affiche les éléments du tableau

procedure afficher(t:tab)
Début 
     # Parcourir les 10 premières cases du tableau.
     Pour i de 0 à 9 faire
         # Vérifier que la case n'est pas vide.
         Si if t[i]!=""  alors
            # Afficher l'indice de la case et son contenu.
            Ecrire('t['+i+']= '+t[i])
         Fin si
     Fin pour
Fin

procedure afficher(t:tab)

Début

# Parcourir les 10 premières cases du tableau.

Pour i de 0 à 9 faire

# Vérifier que la case n'est pas vide.

Si if t[i]!="" alors

# Afficher l'indice de la case et son contenu.

Ecrire('t['+i+']= '+t[i])

Fin si

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

Solution en Python

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

# Importer la fonction array de NumPy.
# Elle permet de créer et de manipuler des tableaux.
from numpy import array


# ==========================================================
# Déclaration du tableau
# ==========================================================

# Déclarer un tableau t de 20 éléments.
# Chaque élément est destiné à contenir une chaîne de caractères.
# Le programme utilise uniquement les 10 premières cases,
# dont les indices vont de 0 à 9.
t = array([str] * 20)


# ==========================================================
# Fonction de remplissage du tableau
# ==========================================================

def remplir(t):

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

        # Initialiser la variable test à False.
        # Elle permet de contrôler la validité de la saisie.
        test = False

        # Répéter la saisie tant que la chaîne fournie
        # ne respecte pas la condition demandée.
        while test == False:

            # Demander à l'utilisateur de saisir une chaîne
            # de caractères pour la case d'indice i.
            # La longueur doit être comprise entre 1 et 10.
            t[i] = input(
                "donner elt N°" + str(i) +
                " dont 1<= sa longueur<=5: "
            )

            # Vérifier que la longueur de la chaîne
            # est comprise entre 1 et 10 caractères.
            if 1 <= len(t[i]) <= 10:

                # Si la condition est vérifiée, la saisie
                # est valide : arrêter la boucle while.
                test = True


# ==========================================================
# Fonction de suppression des éléments redondants
# ==========================================================

def effacer_redondance(t):

    # Parcourir les 9 premières cases du tableau.
    # L'indice i varie de 0 à 8.
    for i in range(9):

        # Vérifier que la case courante n'est pas vide.
        # Une case vide contient la chaîne ''.
        if t[i] != '':

            # Parcourir toutes les cases situées après i,
            # de l'indice i+1 jusqu'à l'indice 9.
            for j in range(i + 1, 10):

                # Comparer la chaîne t[i] avec la chaîne t[j].
                if t[i] == t[j]:

                    # Si les deux chaînes sont identiques,
                    # effacer la répétition située à l'indice j.
                    # La chaîne est remplacée par une chaîne vide.
                    # La première occurrence est ainsi conservée.
                    t[j] = ''


# ==========================================================
# Fonction d'affichage du tableau
# ==========================================================

def afficher(t):

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

        # Vérifier que la case n'est pas vide.
        if t[i] != '':

            # Afficher l'indice de la case et son contenu.
            print('t[' + str(i) + ']= ' + t[i])


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

# Afficher un message annonçant le remplissage du tableau.
print('Remplissage du tableau t')

# Appeler la fonction remplir pour saisir les 10 chaînes.
remplir(t)

# Appeler la fonction effacer_redondance pour supprimer
# les occurrences répétées des chaînes de caractères.
effacer_redondance(t)

# Afficher un message annonçant le résultat du traitement.
print('Elements du tableau t non vides')

# Appeler la fonction afficher pour présenter les éléments
# conservés dans le tableau, avec leurs indices.
afficher(t)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

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

# Importation de la bibliothèque NumPy

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

# Importer la fonction array de NumPy.

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

from numpy import array

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

# Déclaration du tableau

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

# Déclarer un tableau t de 20 éléments.

# Chaque élément est destiné à contenir une chaîne de caractères.

# Le programme utilise uniquement les 10 premières cases,

# dont les indices vont de 0 à 9.

t = array([str] * 20)

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

# Fonction de remplissage du tableau

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

def remplir(t):

# Parcourir les 10 premières cases du tableau.

for i in range(10):

# Initialiser la variable test à False.

# Elle permet de contrôler la validité de la saisie.

test = False

# Répéter la saisie tant que la chaîne fournie

# ne respecte pas la condition demandée.

while test == False:

# Demander à l'utilisateur de saisir une chaîne

# de caractères pour la case d'indice i.

# La longueur doit être comprise entre 1 et 10.

t[i] = input(

"donner elt N°" + str(i) +

" dont 1<= sa longueur<=5: "

)

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

# est comprise entre 1 et 10 caractères.

if 1 <= len(t[i]) <= 10:

# Si la condition est vérifiée, la saisie

# est valide : arrêter la boucle while.

test = True

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

# Fonction de suppression des éléments redondants

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

def effacer_redondance(t):

# Parcourir les 9 premières cases du tableau.

# L'indice i varie de 0 à 8.

for i in range(9):

# Vérifier que la case courante n'est pas vide.

# Une case vide contient la chaîne ''.

if t[i] != '':

# Parcourir toutes les cases situées après i,

# de l'indice i+1 jusqu'à l'indice 9.

for j in range(i + 1, 10):

# Comparer la chaîne t[i] avec la chaîne t[j].

if t[i] == t[j]:

# Si les deux chaînes sont identiques,

# effacer la répétition située à l'indice j.

# La chaîne est remplacée par une chaîne vide.

# La première occurrence est ainsi conservée.

t[j] = ''

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

# Fonction d'affichage du tableau

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

def afficher(t):

# Parcourir les 10 premières cases du tableau.

for i in range(10):

# Vérifier que la case n'est pas vide.

if t[i] != '':

# Afficher l'indice de la case et son contenu.

print('t[' + str(i) + ']= ' + t[i])

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

# Programme principal

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

# Afficher un message annonçant le remplissage du tableau.

print('Remplissage du tableau t')

# Appeler la fonction remplir pour saisir les 10 chaînes.

remplir(t)

# Appeler la fonction effacer_redondance pour supprimer

# les occurrences répétées des chaînes de caractères.

effacer_redondance(t)

# Afficher un message annonçant le résultat du traitement.

print('Elements du tableau t non vides')

# Appeler la fonction afficher pour présenter les éléments

# conservés dans le tableau, avec leurs indices.

afficher(t)

Exécution du programme

Solution en Python et Designer QT

Pour créer une application en Python et Designer QT qui garde la première occurrence pour les éléments redondants(qui apparaissent plus qu’une fois) et remplace toutes les autres occurrences par des chaînes vides, on va suivre ces étapes:

1- Créer l'interface graphique avec Qt Designer

a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.

b- Ajoutez ces widgets:

QLineEdit nommé 'ch' pour entrer les chaine.

QPushButton nommé 'remplir_bt pour mettre les chaines dans le tableau t

QLabel nommé 'msg' pour afficher des messages d'erreur

QPushButton nommé 'bt_eliminer' pour insérer le caractère c dans le tableau t.

Enregistrez le fichier avec l'extension .ui, par exemple tabtab-2.ui.

2- Créer le script Python pour l'application

Voici un exemple de script Python qui utilise l'interface graphique générée par Qt Designer.

from PyQt5.uic import loadUi
from PyQt5 import QtCore, QtGui
from PyQt5.QtWidgets import *
from PyQt5 import QtCore, QtGui, QtWidgets

from numpy import array

t=array([str]*30) # declaration d'un tableau des caractères

app = QApplication([])
windows = loadUi ("tabtab-2.ui")

# Fonction qui supprime des espaces de la chaine des carcatères
def supprimer_espaces (ch) :
    while(ch[0]==' '): # elimnier tous les espaces au début de la chaine
     ch=ch[1:len(ch)]
         
    while(ch[len(ch)-1]==' '): # elimnier tous les espaces a la fin de la chaine
     ch=ch[0:len(ch)-1]       
        
    while (ch.find('  ')>0): 
     ch=ch.replace("  ", " ") # remplacer les doubles espaces apar un seul espace
     
    return ch

def createTab():    
# Procedure qui remplit un tableau a partir d'une chaine des caractère   
    ch = windows.ch.text()
    global n # pour la taille di tableau 
    if ch=="":
            windows.msg.setText("Veuillez remplir la chaîne")
    else:      
        windows.msg.clear() # effacer le message d erreur
        ch= supprimer_espaces(ch)
        i=0
        j=0        
        ch1=''
        test_long=True
        # parcourir les caracteres de la chaine
        while i<len(ch) and test_long:
            if (ch[i]!=' '):
                ch1=ch1+ch[i]
            if ((ch[i]==' ') or (i==len(ch)-1)) :   
                t[j]=ch1
                ch1=''
                test_long=1<=len(t[j])<=10 # test du longueur du mot 
                j=j+1              
               
            i=i+1
        if test_long==True :   
          if 5<=j<=15: # test du taille du tableau
             n=j 
             tab=''
             for k in range (j) :
                tab=tab+ 't['+str(k)+']= '+ t[k]+ '\n'
          
             #afficher les elements du tableau  
             windows.tab_label.setText(tab)  
          else:
             windows.msg.setText("Le nbr des elements doit etre entre 5 et 15") 
        else:
             windows.msg.setText("La longueur des mots doit etre entre 1 et 5") 

def effacer_redondance():
     for i in range(n-1):
       if (t[i]!=''):
         for j in range(i+1,n): 
            if (t[i]==t[j]):
                    t[j]=''

     tab=''
     for k in range (n) :
        tab=tab+ 't['+str(k)+']= '+ t[k]+ '\n'
          
     #afficher les elements du tableau  
     windows.tab_label.setText(tab) 
 
         
windows.remplir_bt.clicked.connect ( createTab )
windows.bt_eliminer.clicked.connect ( effacer_redondance ) 

windows.show()
app.exec_()

from PyQt5.uic import loadUi

from PyQt5 import QtCore, QtGui

from PyQt5.QtWidgets import *

from PyQt5 import QtCore, QtGui, QtWidgets

from numpy import array

t=array([str]*30) # declaration d'un tableau des caractères

app = QApplication([])

windows = loadUi ("tabtab-2.ui")

# Fonction qui supprime des espaces de la chaine des carcatères

def supprimer_espaces (ch) :

while(ch[0]==' '): # elimnier tous les espaces au début de la chaine

ch=ch[1:len(ch)]

while(ch[len(ch)-1]==' '): # elimnier tous les espaces a la fin de la chaine

ch=ch[0:len(ch)-1]

while (ch.find(' ')>0):

ch=ch.replace(" ", " ") # remplacer les doubles espaces apar un seul espace

return ch

def createTab():

# Procedure qui remplit un tableau a partir d'une chaine des caractère

ch = windows.ch.text()

global n # pour la taille di tableau

if ch=="":

windows.msg.setText("Veuillez remplir la chaîne")

else:

windows.msg.clear() # effacer le message d erreur

ch= supprimer_espaces(ch)

i=0

j=0

ch1=''

test_long=True

# parcourir les caracteres de la chaine

while i<len(ch) and test_long:

if (ch[i]!=' '):

ch1=ch1+ch[i]

if ((ch[i]==' ') or (i==len(ch)-1)) :

t[j]=ch1

ch1=''

test_long=1<=len(t[j])<=10 # test du longueur du mot

j=j+1

i=i+1

if test_long==True :

if 5<=j<=15: # test du taille du tableau

n=j

tab=''

for k in range (j) :

tab=tab+ 't['+str(k)+']= '+ t[k]+ '\n'

#afficher les elements du tableau

windows.tab_label.setText(tab)

else:

windows.msg.setText("Le nbr des elements doit etre entre 5 et 15")

else:

windows.msg.setText("La longueur des mots doit etre entre 1 et 5")

def effacer_redondance():

for i in range(n-1):

if (t[i]!=''):

for j in range(i+1,n):

if (t[i]==t[j]):

t[j]=''

tab=''

for k in range (n) :

tab=tab+ 't['+str(k)+']= '+ t[k]+ '\n'

#afficher les elements du tableau

windows.tab_label.setText(tab)

windows.remplir_bt.clicked.connect ( createTab )

windows.bt_eliminer.clicked.connect ( effacer_redondance )

windows.show()

app.exec_()

Exécution du programme

1) Remplissage du tableau

2) Après la suppression des éléments redondants

Vous pouvez voir aussi :

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 14214vues

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

Arduino 13702vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 11451vues

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

Arduino 11073vues

Allumer une LED par la carte ESP32

ESP32 10713vues

Construction des robots

Tutoriels plus commentés

Balance électronique avec Arduino UNO et module HX711

Arduino 126 commentaires

Construire un GPS commandé par Arduino

Arduino 113 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 48 commentaires

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

Arduino 37 commentaires

Eliminer occurrence dans un tableau – Bac pratique 2006 [ Algorithme + Python ]

Sujet bac informatique pratique 2006 (Bac scientifique)

Solution Algorithmique

Algorithme du programme Principal

La procédure remplir

La procédure effacer_redondance

La procédure afficher

Solution en Python

Solution en Python et Designer QT

1- Créer l'interface graphique avec Qt Designer

2- Créer le script Python pour l'application

1) des exercices sur les chaînes des caractères

2) des exercices sur les tableaux

3) des sujets Bac pratique

4) des sujets Bac théorique

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