Algorithme de classement des caractères selon leur nature

Bac SC 09-09-23

188 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 de classement des caractères selon leur nature

Cet algorithme permet de répartir les éléments d’un tableau T selon leur nature. Les éléments saisis peuvent être des lettres, des chiffres ou des symboles. Le tableau initial T est donc divisé en trois tableaux : T1 pour les lettres, T2 pour les chiffres et T3 pour les symboles.

Tout d’abord, l’utilisateur saisit la taille du tableau T, avec une valeur comprise entre 2 et 14. Ensuite, les différents éléments du tableau sont saisis un par un et mémorisés dans T. Les éléments sont considérés comme des caractères, ce qui permet de traiter aussi bien les lettres que les chiffres et les symboles.

La procédure division parcourt ensuite les éléments du tableau T un par un. Pour chaque élément, l’instruction match permet de déterminer sa nature. L'utilisation de upper() permet de reconnaître une lettre qu’elle soit écrite en majuscule ou en minuscule.

Si l’élément est une lettre comprise entre A et Z, il est placé dans le tableau T1. Si l’élément est un chiffre compris entre 0 et 9, il est placé dans le tableau T2. Dans tous les autres cas, l’élément est considéré comme un symbole et il est placé dans le tableau T3.

Les variables n1, n2 et n3 permettent de suivre les positions utilisées dans les trois tableaux. À chaque insertion, le compteur correspondant est augmenté afin de placer le nouvel élément à la position suivante.

Enfin, la procédure afficher permet d'afficher séparément le contenu des trois tableaux. Le programme affiche successivement T1 contenant les lettres, T2 contenant les chiffres et T3 contenant les symboles. Ainsi, les éléments du tableau initial T sont automatiquement classés selon leur nature.

Algorithme de classement des caractères selon leur nature

Algorithme du programme Principal

L’algorithme principal Division_TABLEAU_chaines assure la gestion complète du programme de classification des éléments d’un tableau de chaînes de caractères selon leur nature.

Il commence par appeler la fonction saisie_taille() afin de demander à l’utilisateur 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.

Après le remplissage, l’algorithme appelle la procédure division(t,t1,t2,t3,n). Cette procédure parcourt les éléments du tableau T et les répartit dans trois tableaux selon leur nature :

- T1 reçoit les lettres

- T2 reçoit les chiffres

- T3 reçoit les symboles

Enfin, l’algorithme principal affiche successivement les trois tableaux obtenus à l’aide de la procédure afficher(). Les expressions n1+1, n2+1 et n3+1 permettent d’indiquer le nombre réel d’éléments présents dans T1, T2 et T3.

Algorithme Division_TABLEAU_chaines
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 répartit les éléments de T :
     # - les lettres sont placées dans T1 ;
     # - les chiffres sont placés dans T2 ;
     # - les symboles sont placés dans T3.
     division(t, t1, t2, t3, n)
     # ==========================================================
     # Affichage du tableau T1
     # ==========================================================
     # Afficher un titre indiquant que T1 contient les lettres.
     Ecrire("*********** Tableau T1 (Lettres) *************")
     # Afficher les éléments de T1.
     # Comme n1 contient le dernier indice utilisé,
     # on ajoute 1 pour obtenir le nombre d'éléments à afficher.
     afficher(t1, n1 + 1)
     # ==========================================================
     # Affichage du tableau T2
     # ==========================================================
     # Afficher un titre indiquant que T2 contient les chiffres.
     Ecrire("*********** Tableau T2 (Chiffres) *************")
     # Afficher les éléments de T2.
     # Comme n2 contient le dernier indice utilisé,
     # on ajoute 1 pour obtenir le nombre d'éléments à afficher.
     afficher(t2, n2 + 1)
     # ==========================================================
     # Affichage du tableau T3
     # ==========================================================
     # Afficher un titre indiquant que T3 contient les symboles.
     Ecrire("*********** Tableau T3 (Symboles) *************")
     # Afficher les éléments de T3.
     # Comme n3 contient le dernier indice utilisé,
     # on ajoute 1 pour obtenir le nombre d'éléments à afficher.
     afficher(t3, n3 + 1)
Fin

Algorithme Division_TABLEAU_chaines

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 répartit les éléments de T :

# - les lettres sont placées dans T1 ;

# - les chiffres sont placés dans T2 ;

# - les symboles sont placés dans T3.

division(t, t1, t2, t3, n)

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

# Affichage du tableau T1

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

# Afficher un titre indiquant que T1 contient les lettres.

Ecrire("*********** Tableau T1 (Lettres) *************")

# Afficher les éléments de T1.

# Comme n1 contient le dernier indice utilisé,

# on ajoute 1 pour obtenir le nombre d'éléments à afficher.

afficher(t1, n1 + 1)

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

# Affichage du tableau T2

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

# Afficher un titre indiquant que T2 contient les chiffres.

Ecrire("*********** Tableau T2 (Chiffres) *************")

# Afficher les éléments de T2.

# Comme n2 contient le dernier indice utilisé,

# on ajoute 1 pour obtenir le nombre d'éléments à afficher.

afficher(t2, n2 + 1)

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

# Affichage du tableau T3

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

# Afficher un titre indiquant que T3 contient les symboles.

Ecrire("*********** Tableau T3 (Symboles) *************")

# Afficher les éléments de T3.

# Comme n3 contient le dernier indice utilisé,

# on ajoute 1 pour obtenir le nombre d'éléments à afficher.

afficher(t3, n3 + 1)

Fin

Déclaration des objets

Objet	Type / Nature
n	entier
t	tableau des caractères
n1	entier
t1	tableau des caractères
n2	entier
t2	tableau des caractères
n3	entier
t3	tableau des caractères

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 caractères 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

Elle parcourt successivement les n éléments du tableau T. Pour chaque élément, elle utilise Majus(t[i]) afin de convertir les lettres minuscules en majuscules et de pouvoir reconnaître aussi bien les lettres majuscules que les lettres minuscules.

Selon la nature de l’élément, la procédure effectue l’une des trois opérations suivantes :

- si l’élément est une lettre comprise entre A et Z, il est placé dans le tableau T1 ;

- si l’élément est un chiffre compris entre 0 et 9, il est placé dans le tableau T2 ;

- sinon, l’élément est considéré comme un symbole et il est placé dans le tableau T3.

Les compteurs n1, n2 et n3 indiquent respectivement la dernière position utilisée dans T1, T2 et T3. Ils commencent à -1 afin que le premier élément soit placé à l’indice 0.

Procédure division(t:tab; var t1,t2,t3:tab, n:entier)
    # Initialiser les compteurs à -1.
    # Le premier élément sera placé à l'indice 0
    # après l'incrémentation du compteur.
    n1 <-- -1
    n2 <-- -1
    n3 <-- -1
    # Parcourir les n éléments du tableau T.
    Pour i de 0 à n-1 faire
        # Convertir l'élément courant en majuscule.
        # Cela permet de reconnaître aussi bien les lettres
        # minuscules que les lettres majuscules.
        Selon Majus(t[i]) faire
            # Si l'élément est une lettre comprise entre A et Z.
            ["A".."Z"] :
                # Passer à la position suivante de T1.
                n1 <-- n1 + 1
                # Copier la lettre dans T1.
                t1[n1] <-- t[i]
            # Si l'élément est un chiffre compris entre 0 et 9.
            ["0".."9"] :
                # Passer à la position suivante de T2.
                n2 <-- n2 + 1
                # Copier le chiffre dans T2.
                t2[n2] <-- t[i]
            # Si l'élément n'est ni une lettre ni un chiffre,
            # il est considéré comme un symbole.
            Sinon
                # Passer à la position suivante de T3.
                n3 <-- n3 + 1
                # Copier le symbole dans T3.
                t3[n3] <-- t[i]
        Fin selon
    Fin pour
Fin

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

# Initialiser les compteurs à -1.

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

# après l'incrémentation du compteur.

n1 <-- -1

n2 <-- -1

n3 <-- -1

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

Pour i de 0 à n-1 faire

# Convertir l'élément courant en majuscule.

# Cela permet de reconnaître aussi bien les lettres

# minuscules que les lettres majuscules.

Selon Majus(t[i]) faire

# Si l'élément est une lettre comprise entre A et Z.

["A".."Z"] :

# Passer à la position suivante de T1.

n1 <-- n1 + 1

# Copier la lettre dans T1.

t1[n1] <-- t[i]

# Si l'élément est un chiffre compris entre 0 et 9.

["0".."9"] :

# Passer à la position suivante de T2.

n2 <-- n2 + 1

# Copier le chiffre dans T2.

t2[n2] <-- t[i]

# Si l'élément n'est ni une lettre ni un chiffre,

# il est considéré comme un symbole.

Sinon

# Passer à la position suivante de T3.

n3 <-- n3 + 1

# Copier le symbole dans T3.

t3[n3] <-- t[i]

Fin selon

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
n1 (variable globale)	entier
n2 (variable globale)	entier
n3 (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 des tableaux.


# ==========================================================
# Création des tableaux
# ==========================================================

# Créer un tableau T de 100 éléments initialisés avec une chaîne vide.
# T servira à mémoriser les éléments saisis par l'utilisateur.
t = array([""] * 100)

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

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

# Créer le tableau T3 de 100 éléments.
# T3 contiendra les symboles du tableau T.
t3 = array([""] * 100)


# ==========================================================
# Initialisation des compteurs
# ==========================================================

# n1 représente le nombre de lettres placées dans T1.
# n2 représente le nombre de chiffres placés dans T2.
# n3 représente le nombre de symboles placés dans T3.
n1 = 0
n2 = 0
n3 = 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 est mémorisé sous forme de caractère.
        t[i] = input("donner un element du tableau : ")


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

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

    # Déclarer n1, n2 et n3 comme variables globales.
    # Ces variables permettent de mémoriser le nombre
    # d'éléments placés dans T1, T2 et T3.
    global n1, n2, n3

    # Initialiser les compteurs à -1.
    # Le premier élément sera placé à l'indice 0
    # après l'incrémentation du compteur.
    n1 = -1
    n2 = -1
    n3 = -1

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

        # Convertir l'élément courant en majuscule.
        # Cela permet de reconnaître aussi bien les lettres
        # minuscules que les lettres majuscules.
        match t[i].upper():

            # Si l'élément est une lettre comprise entre A et Z.
            case c if "A" <= c <= "Z":

                # Passer à la position suivante de T1.
                n1 = n1 + 1

                # Copier la lettre dans T1.
                t1[n1] = t[i]

            # Si l'élément est un chiffre compris entre 0 et 9.
            case c if "0" <= c <= "9":

                # Passer à la position suivante de T2.
                n2 = n2 + 1

                # Copier le chiffre dans T2.
                t2[n2] = t[i]

            # Si l'élément n'est ni une lettre ni un chiffre,
            # il est considéré comme un symbole.
            case _:

                # Passer à la position suivante de T3.
                n3 = n3 + 1

                # Copier le symbole dans T3.
                t3[n3] = 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 T ***")


# 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 répartit les éléments de T :
# - les lettres sont placées dans T1 ;
# - les chiffres sont placés dans T2 ;
# - les symboles sont placés dans T3.
division(t, t1, t2, t3, n)


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

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

# Afficher les éléments de T1.
# Comme n1 contient le dernier indice utilisé,
# on ajoute 1 pour obtenir le nombre d'éléments à afficher.
afficher(t1, n1 + 1)


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

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

# Afficher les éléments de T2.
# Comme n2 contient le dernier indice utilisé,
# on ajoute 1 pour obtenir le nombre d'éléments à afficher.
afficher(t2, n2 + 1)


# ==========================================================
# Affichage du tableau T3
# ==========================================================

# Afficher un titre indiquant que T3 contient les symboles.
print("*********** Tableau T3 (Symboles) *************")

# Afficher les éléments de T3.
# Comme n3 contient le dernier indice utilisé,
# on ajoute 1 pour obtenir le nombre d'éléments à afficher.
afficher(t3, n3 + 1)

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

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

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

# Importation de la bibliothèque NumPy

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

from numpy import array

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

# Elle permet de créer des tableaux.

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

# Création des tableaux

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

# Créer un tableau T de 100 éléments initialisés avec une chaîne vide.

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

t = array([""] * 100)

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

# T1 contiendra les lettres du tableau T.

t1 = array([""] * 100)

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

# T2 contiendra les chiffres du tableau T.

t2 = array([""] * 100)

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

# T3 contiendra les symboles du tableau T.

t3 = array([""] * 100)

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

# Initialisation des compteurs

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

# n1 représente le nombre de lettres placées dans T1.

# n2 représente le nombre de chiffres placés dans T2.

# n3 représente le nombre de symboles placés dans T3.

n1 = 0

n2 = 0

n3 = 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 est mémorisé sous forme de caractère.

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

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

# Procédure de division du tableau T

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

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

# Déclarer n1, n2 et n3 comme variables globales.

# Ces variables permettent de mémoriser le nombre

# d'éléments placés dans T1, T2 et T3.

global n1, n2, n3

# Initialiser les compteurs à -1.

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

# après l'incrémentation du compteur.

n1 = -1

n2 = -1

n3 = -1

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

for i in range(n):

# Convertir l'élément courant en majuscule.

# Cela permet de reconnaître aussi bien les lettres

# minuscules que les lettres majuscules.

match t[i].upper():

# Si l'élément est une lettre comprise entre A et Z.

case c if "A" <= c <= "Z":

# Passer à la position suivante de T1.

n1 = n1 + 1

# Copier la lettre dans T1.

t1[n1] = t[i]

# Si l'élément est un chiffre compris entre 0 et 9.

case c if "0" <= c <= "9":

# Passer à la position suivante de T2.

n2 = n2 + 1

# Copier le chiffre dans T2.

t2[n2] = t[i]

# Si l'élément n'est ni une lettre ni un chiffre,

# il est considéré comme un symbole.

case _:

# Passer à la position suivante de T3.

n3 = n3 + 1

# Copier le symbole dans T3.

t3[n3] = 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 T ***")

# 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 répartit les éléments de T :

# - les lettres sont placées dans T1 ;

# - les chiffres sont placés dans T2 ;

# - les symboles sont placés dans T3.

division(t, t1, t2, t3, n)

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

# Affichage du tableau T1

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

# Afficher un titre indiquant que T1 contient les lettres.

print("*********** Tableau T1 (Lettres) *************")

# Afficher les éléments de T1.

# Comme n1 contient le dernier indice utilisé,

# on ajoute 1 pour obtenir le nombre d'éléments à afficher.

afficher(t1, n1 + 1)

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

# Affichage du tableau T2

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

# Afficher un titre indiquant que T2 contient les chiffres.

print("*********** Tableau T2 (Chiffres) *************")

# Afficher les éléments de T2.

# Comme n2 contient le dernier indice utilisé,

# on ajoute 1 pour obtenir le nombre d'éléments à afficher.

afficher(t2, n2 + 1)

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

# Affichage du tableau T3

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

# Afficher un titre indiquant que T3 contient les symboles.

print("*********** Tableau T3 (Symboles) *************")

# Afficher les éléments de T3.

# Comme n3 contient le dernier indice utilisé,

# on ajoute 1 pour obtenir le nombre d'éléments à afficher.

afficher(t3, n3 + 1)

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

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 de classement des caractères selon leur nature

Algorithme de classement des caractères selon leur nature

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