Algorithme de classement des caractères selon leur nature

Bac SC 15-09-26

2 0

Plan de tutoriel

1- Principe de l'algorithme : classement des caractères selon leur nature

2- Algorithme : classement des caractères selon leur nature

3- Programme Python

Principe de l'algorithme : distribution des éléments pairs et impairs du tableau T dans T1 et T2

Cet algorithme permet de séparer les éléments d’un tableau T en deux tableaux selon leur parité. Le tableau T1 contiendra les nombres pairs, tandis que le tableau T2 contiendra les nombres impairs.

Dans un premier temps, l’utilisateur saisit la taille n du tableau, avec une valeur comprise entre 2 et 14. Ensuite, les n éléments du tableau T sont saisis par l’intermédiaire de la procédure remplir().

La procédure division() parcourt ensuite successivement tous les éléments du tableau T. Pour chaque élément, on utilise l’opérateur % afin de déterminer son reste dans la division par 2. Si t[i] % 2 == 0, l’élément est pair et il est placé dans le tableau T1. Sinon, il est impair et il est placé dans le tableau T2.

Deux compteurs, n1 et n2, permettent de suivre les positions disponibles dans les tableaux T1 et T2. Ainsi, chaque élément pair est ajouté à T1 et chaque élément impair à T2, tout en conservant l’ordre d’apparition des éléments du tableau initial.

Enfin, les deux tableaux obtenus sont affichés séparément. On obtient donc une organisation du tableau initial en deux tableaux : T1 pour les éléments pairs et T2 pour les éléments impairs.

Algorithme : distribution des éléments pairs et impairs du tableau T dans T1 et T2

Algorithme du programme Principal

L’algorithme principal commence par appeler la fonction saisie_taille() afin de déterminer le nombre n d’éléments du tableau T.

Ensuite, il appelle la procédure remplir(t,n) pour saisir les différents éléments du tableau T.

Après le remplissage, l’algorithme appelle la procédure division(t,t1,t2,n). Cette procédure analyse les éléments du tableau T et les répartit dans deux tableaux : T1 contient les nombres pairs et T2 contient les nombres impairs.

Enfin, l’algorithme affiche successivement le contenu de T1 et de T2. Les variables n1 et n2 indiquent respectivement le nombre d'éléments présents dans T1 et T2.

Algorithme Division_TABLEAU
Debut  
     # Appeler la fonction saisie_taille()
     # pour obtenir le nombre d'éléments du tableau.
     n <-- saisie_taille()
     # Afficher un message avant le remplissage du tableau.
     Ecrire("***Remplissage du tableau***")
     # Appeler la fonction remplir() pour saisir
     # les n éléments du tableau.
     remplir(t, n)
     # Appeler la procédure division().
     # Cette procédure sépare les éléments de T :
     # - les nombres pairs sont placés dans T1 ;
     # - les nombres impairs sont placés dans T2.
     division(t, t1, t2, n)
     # ==========================================================
     # Affichage du tableau T1
     # ==========================================================
     # Afficher un titre indiquant que T1 contient
     # les nombres pairs.
     Ecrire("***********Tableau T1 (nombres pairs)*************")
     # Afficher les éléments de T1.
     # n1 représente le nombre d'éléments réellement
     # placés dans T1.
     afficher(t1, n1)
     # ==========================================================
     # Affichage du tableau T2
     # ==========================================================
     # Afficher un titre indiquant que T2 contient
     # les nombres impairs.
     Ecrire("***********Tableau T2 (nombres impairs)*************")
     # Afficher les éléments de T2.
     # n2 représente le nombre d'éléments réellement
     # placés dans T2.
     afficher(t2, n2)
Fin

Algorithme Division_TABLEAU

Debut

# Appeler la fonction saisie_taille()

# pour obtenir le nombre d'éléments du tableau.

n <-- saisie_taille()

# Afficher un message avant le remplissage du tableau.

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

# Appeler la fonction remplir() pour saisir

# les n éléments du tableau.

remplir(t, n)

# Appeler la procédure division().

# Cette procédure sépare les éléments de T :

# - les nombres pairs sont placés dans T1 ;

# - les nombres impairs sont placés dans T2.

division(t, t1, t2, n)

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

# Affichage du tableau T1

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

# Afficher un titre indiquant que T1 contient

# les nombres pairs.

Ecrire("***********Tableau T1 (nombres pairs)*************")

# Afficher les éléments de T1.

# n1 représente le nombre d'éléments réellement

# placés dans T1.

afficher(t1, n1)

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

# Affichage du tableau T2

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

# Afficher un titre indiquant que T2 contient

# les nombres impairs.

Ecrire("***********Tableau T2 (nombres impairs)*************")

# Afficher les éléments de T2.

# n2 représente le nombre d'éléments réellement

# placés dans T2.

afficher(t2, n2)

Fin

Déclaration des objets

Objet	Type / Nature
n	entier
t	tableau des entiers
n1	entier
t1	tableau des entiers
n2	entier
t2	tableau des entiers

La fonction saisie

La fonction saisie() permet de saisir et de contrôler le nombre d’éléments n du tableau. Elle demande à l’utilisateur de donner une valeur comprise entre 2 et 14.

Fonction saisie():entier
    # La variable test permet de contrôler
    # si la taille saisie est correcte.
    test <-- Faux
    # Répéter la saisie tant que la valeur
    # n'est pas comprise entre 2 et 14.
    Tant que test = Faux faire
        # Demander à l'utilisateur de saisir
        # la taille du tableau.
        Ecrire("donner n entre 2 et 14: ")
        Lire(n) 
        # Vérifier que n est comprise entre 2 et 14.
        Si 2 <= n <= 14 alors
            # La taille saisie est correcte.
            test <-- Vrai
        Fin si
    Fin tant que 
    # Retourner la taille du tableau.
    retourner n 
Fin

Fonction saisie():entier

# La variable test permet de contrôler

# si la taille saisie est correcte.

test <-- Faux

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

# n'est pas comprise entre 2 et 14.

Tant que test = Faux faire

# Demander à l'utilisateur de saisir

# la taille du tableau.

Ecrire("donner n entre 2 et 14: ")

Lire(n)

# Vérifier que n est comprise entre 2 et 14.

Si 2 <= n <= 14 alors

# La taille saisie est correcte.

test <-- Vrai

Fin si

Fin tant que

# Retourner la taille du tableau.

retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La procédure remplir

La procédure remplir a pour rôle de remplir les n premières cases du tableau t avec des valeurs saisies par l’utilisateur.

Procédure remplir(var t:tab; n:entier)
    # Parcourir les n premières cases du tableau.
    Pour i de 0 à n-1 faire
        # Demander à l'utilisateur de saisir
        # un élément du tableau.
        Ecrire("donner un element du tableau : ")
        Lire(t[i])
    Fin pour  
Fin

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

# Parcourir les n premières cases du tableau.

Pour i de 0 à n-1 faire

# Demander à l'utilisateur de saisir

# un élément du tableau.

Ecrire("donner un element du tableau : ")

Lire(t[i])

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La procédure division

La procédure division a pour rôle de séparer les éléments du tableau T en deux tableaux selon leur parité.

Elle parcourt les n éléments du tableau T un par un. Pour chaque élément, elle vérifie si celui-ci est pair en utilisant l’opération mod 2. Si le reste de la division par 2 est égal à 0, l’élément est pair et il est placé dans le tableau T1. Sinon, il est considéré comme impair et il est placé dans le tableau T2.

Les variables n1 et n2 permettent de suivre respectivement la dernière position occupée dans T1 et T2. Elles sont initialisées à -1, puis augmentées avant chaque insertion afin que le premier élément soit placé à l’indice 0.

Procédure division(t:tab; var t1,t2:tab, n:entier)
    # Initialiser les indices de T1 et T2 à -1.
    # Le premier élément sera donc placé à l'indice 0
    # après l'incrémentation.
    n1 <-- -1
    n2 <-- -1
    # Parcourir les n éléments du tableau T.
    Pour i de 0 à n-1 faire
        # Vérifier si l'élément T[i] est pair.
        # Un nombre est pair lorsque son reste dans
        # la division par 2 est égal à 0.
        Si t[i] mod 2 = 0 alors
            # Avancer à la prochaine position disponible
            # dans le tableau T1.
            n1 <-- n1 + 1
            # Placer l'élément pair dans T1.
            t1[n1] <-- t[i]
        Sinon
            # L'élément est impair.
            # Avancer à la prochaine position disponible
            # dans le tableau T2.
            n2 <-- n2 + 1
            # Placer l'élément impair dans T2.
            t2[n2] <-- t[i]
        Fin si
    Fin pour
Fin

Procédure division(t:tab; var t1,t2:tab, n:entier)

# Initialiser les indices de T1 et T2 à -1.

# Le premier élément sera donc placé à l'indice 0

# après l'incrémentation.

n1 <-- -1

n2 <-- -1

# Parcourir les n éléments du tableau T.

Pour i de 0 à n-1 faire

# Vérifier si l'élément T[i] est pair.

# Un nombre est pair lorsque son reste dans

# la division par 2 est égal à 0.

Si t[i] mod 2 = 0 alors

# Avancer à la prochaine position disponible

# dans le tableau T1.

n1 <-- n1 + 1

# Placer l'élément pair dans T1.

t1[n1] <-- t[i]

Sinon

# L'élément est impair.

# Avancer à la prochaine position disponible

# dans le tableau T2.

n2 <-- n2 + 1

# Placer l'élément impair dans T2.

t2[n2] <-- t[i]

Fin si

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
n1 (variable globale)	entier
n2 (variable globale)	entier
i	entier

La procédure afficher

La procédure afficher a pour rôle d’afficher les éléments d’un tableau t.

Procédure remplir(var t:tab; n:entier) :
    # Parcourir les n premières cases du tableau. 
    Pour i de 0 à n-1 faire 
      # Afficher l'élément situé à la position i. 
      Ecrire(t[i]) 
    Fin pour
Fin

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

# Parcourir les n premières cases du tableau.

Pour i de 0 à n-1 faire

# Afficher l'élément situé à la position i.

Ecrire(t[i])

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

Programme 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 des tableaux
# ==========================================================

# Créer un tableau T de 100 éléments initialisés à 0.
# T servira à mémoriser les éléments saisis par l'utilisateur.
t = array([int()] * 100)

# Créer le tableau T1 de 100 éléments.
# T1 contiendra les nombres pairs du tableau T.
t1 = array([int()] * 100)

# Créer le tableau T2 de 100 éléments.
# T2 contiendra les nombres impairs du tableau T.
t2 = array([int()] * 100)


# n1 représente le nombre d'éléments placés dans T1.
# n2 représente le nombre d'éléments placés dans T2.
n1 = 0
n2 = 0


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

def saisie():

    # La variable test permet de contrôler
    # la validité de la taille saisie.
    test = False

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

        # Demander à l'utilisateur de saisir
        # le nombre d'éléments du tableau.
        n = int(input("donner n entre 2 et 14: "))

        # Vérifier que la taille est comprise entre 2 et 14.
        if 2 <= n <= 14:

            # La taille saisie est correcte.
            test = True

    # Retourner la taille du tableau.
    return n


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

def remplir(t, n):

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

        # Demander à l'utilisateur de saisir un élément.
        # L'élément saisi est converti en entier
        # puis placé dans la case T[i].
        t[i] = int(input("donner un element du tableau : "))


# ==========================================================
# Procédure de division du tableau T
# ==========================================================

def division(t, t1, t2, n):

    # Utiliser les variables globales n1 et n2.
    # Elles permettent de connaître le nombre d'éléments
    # placés respectivement dans T1 et T2.
    global n1, n2

    # Initialiser les indices de T1 et T2 à -1.
    # Le premier élément sera donc placé à l'indice 0
    # après l'incrémentation.
    n1 = -1
    n2 = -1

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

        # Vérifier si l'élément T[i] est pair.
        # Un nombre est pair lorsque son reste dans
        # la division par 2 est égal à 0.
        if t[i] % 2 == 0:

            # Avancer à la prochaine position disponible
            # dans le tableau T1.
            n1 = n1 + 1

            # Placer l'élément pair dans T1.
            t1[n1] = t[i]

        else:

            # L'élément est impair.
            # Avancer à la prochaine position disponible
            # dans le tableau T2.
            n2 = n2 + 1

            # Placer l'élément impair dans T2.
            t2[n2] = t[i]


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

def afficher(t, n):

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

        # Afficher l'élément situé à la position i.
        print(t[i])


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

# Appeler la fonction saisie() pour obtenir
# le nombre d'éléments du tableau T.
n = saisie()


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


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


# Appeler la procédure division().
# Cette procédure sépare les éléments de T :
# - les nombres pairs sont placés dans T1 ;
# - les nombres impairs sont placés dans T2.
division(t, t1, t2, n)


# ==========================================================
# Affichage du tableau T1
# ==========================================================

# Afficher un titre indiquant que T1 contient
# les nombres pairs.
print("***********Tableau T1 (nombres pairs)*************")

# Afficher les éléments de T1.
# n1 représente le nombre d'éléments réellement
# placés dans T1.
afficher(t1, n1)


# ==========================================================
# Affichage du tableau T2
# ==========================================================

# Afficher un titre indiquant que T2 contient
# les nombres impairs.
print("***********Tableau T2 (nombres impairs)*************")

# Afficher les éléments de T2.
# n2 représente le nombre d'éléments réellement
# placés dans T2.
afficher(t2, n2)

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

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

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

# 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 des tableaux

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

# Créer un tableau T de 100 éléments initialisés à 0.

# T servira à mémoriser les éléments saisis par l'utilisateur.

t = array([int()] * 100)

# Créer le tableau T1 de 100 éléments.

# T1 contiendra les nombres pairs du tableau T.

t1 = array([int()] * 100)

# Créer le tableau T2 de 100 éléments.

# T2 contiendra les nombres impairs du tableau T.

t2 = array([int()] * 100)

# n1 représente le nombre d'éléments placés dans T1.

# n2 représente le nombre d'éléments placés dans T2.

n1 = 0

n2 = 0

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

# Fonction de saisie de la taille du tableau

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

def saisie():

# La variable test permet de contrôler

# la validité de la taille saisie.

test = False

# Répéter la saisie tant que la taille n'est pas correcte.

while test == False:

# Demander à l'utilisateur de saisir

# le nombre d'éléments du tableau.

n = int(input("donner n entre 2 et 14: "))

# Vérifier que la taille est comprise entre 2 et 14.

if 2 <= n <= 14:

# La taille saisie est correcte.

test = True

# Retourner la taille du tableau.

return n

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

# Procédure de remplissage du tableau

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

def remplir(t, n):

# Parcourir les n premières cases du tableau T.

for i in range(n):

# Demander à l'utilisateur de saisir un élément.

# L'élément saisi est converti en entier

# puis placé dans la case T[i].

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

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

# Procédure de division du tableau T

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

def division(t, t1, t2, n):

# Utiliser les variables globales n1 et n2.

# Elles permettent de connaître le nombre d'éléments

# placés respectivement dans T1 et T2.

global n1, n2

# Initialiser les indices de T1 et T2 à -1.

# Le premier élément sera donc placé à l'indice 0

# après l'incrémentation.

n1 = -1

n2 = -1

# Parcourir les n éléments du tableau T.

for i in range(n):

# Vérifier si l'élément T[i] est pair.

# Un nombre est pair lorsque son reste dans

# la division par 2 est égal à 0.

if t[i] % 2 == 0:

# Avancer à la prochaine position disponible

# dans le tableau T1.

n1 = n1 + 1

# Placer l'élément pair dans T1.

t1[n1] = t[i]

else:

# L'élément est impair.

# Avancer à la prochaine position disponible

# dans le tableau T2.

n2 = n2 + 1

# Placer l'élément impair dans T2.

t2[n2] = t[i]

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

# Procédure d'affichage d'un tableau

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

def afficher(t, n):

# Parcourir les n premières cases du tableau.

for i in range(n):

# Afficher l'élément situé à la position i.

print(t[i])

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

# Programme principal

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

# Appeler la fonction saisie() pour obtenir

# le nombre d'éléments du tableau T.

n = saisie()

# Afficher un message avant le remplissage du tableau.

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

# Appeler la procédure remplir() pour saisir

# les n éléments du tableau T.

remplir(t, n)

# Appeler la procédure division().

# Cette procédure sépare les éléments de T :

# - les nombres pairs sont placés dans T1 ;

# - les nombres impairs sont placés dans T2.

division(t, t1, t2, n)

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

# Affichage du tableau T1

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

# Afficher un titre indiquant que T1 contient

# les nombres pairs.

print("***********Tableau T1 (nombres pairs)*************")

# Afficher les éléments de T1.

# n1 représente le nombre d'éléments réellement

# placés dans T1.

afficher(t1, n1)

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

# Affichage du tableau T2

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

# Afficher un titre indiquant que T2 contient

# les nombres impairs.

print("***********Tableau T2 (nombres impairs)*************")

# Afficher les éléments de T2.

# n2 représente le nombre d'éléments réellement

# placés dans T2.

afficher(t2, n2)

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

Algorithme de classement des caractères selon leur nature

Bac SC 15-09-26

Distribution des éléments pairs et impairs du tableau T dans T1 et T2

Bac SC 12-09-26

Algorithme pour compter le nombre d’apparitions d’un élément dans un tableau

Bac SC 11-09-26

Algorithme de recherche dichotomique dans un tableau

Bac SC 09-09-26

Algorithme de recherche séquentielle dans un tableau

Bac SC 05-09-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 13908vues

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

Arduino 13398vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 11210vues

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

Arduino 10715vues

Allumer une LED par la carte ESP32

ESP32 10482vues

Construction des robots

Tutoriels plus commentés

Balance électronique avec Arduino UNO et module HX711

Arduino 121 commentaires

Construire un GPS commandé par Arduino

Arduino 107 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 59 commentaires

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

ESP32 36 commentaires

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

Arduino 32 commentaires

Algorithme de classement des caractères selon leur nature

Plan de tutoriel

1- Principe de l'algorithme : classement des caractères selon leur nature

2- Algorithme : classement des caractères selon leur nature

3- Programme Python

Principe de l'algorithme : distribution des éléments pairs et impairs du tableau T dans T1 et T2

Algorithme : distribution des éléments pairs et impairs du tableau T dans T1 et T2

Algorithme du programme Principal

La fonction saisie

La procédure remplir

La procédure division

La procédure afficher

Programme en Python

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