Distribution des éléments pairs et impairs du tableau T dans T1 et T2
Plan de tutoriel
1- Principe de l'algorithme : distribution des éléments pairs et impairs du tableau T dans T1 et T2
2- Algorithme : distribution des éléments pairs et impairs du tableau T dans T1 et T2
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 déterminer le nombre de fois qu’une valeur donnée apparaît dans un tableau. La valeur recherchée est notée x. Le programme parcourt les éléments du tableau un par un et vérifie si chacun d’eux est égal à x.
Tout d’abord, l’utilisateur saisit la taille du tableau. Cette taille doit être comprise entre 2 et 14. Ensuite, les éléments du tableau sont saisis et stockés dans les n premières cases du tableau.
Après le remplissage du tableau, l’utilisateur saisit la valeur dont il souhaite connaître le nombre d’apparitions. Cette valeur est ensuite transmise à la fonction occurrence() avec le tableau et sa taille.
Dans la fonction occurrence(), une variable compteur est initialisée à 0. Le programme parcourt successivement toutes les cases utilisées du tableau. À chaque fois qu’il trouve un élément égal à x, il augmente le compteur de 1.
Lorsque toutes les cases ont été examinées, la fonction retourne la valeur de compteur. Cette valeur représente le nombre total d’occurrences de x dans le tableau et elle est affichée par le programme principal.
Exemple : pour le tableau 2, 5, 2, 8, 2, 10, 5 et la valeur recherchée 2, l’algorithme trouve trois éléments égaux à 2. Le résultat affiché sera donc 3.
Algorithme : distribution des éléments pairs et impairs du tableau T dans T1 et T2
Algorithme du programme Principal
L’algorithme principal Recherche_TABLEAU assure la coordination de toutes les étapes du programme. Il commence par appeler la fonction saisie_taille() afin de déterminer le nombre n d’éléments à utiliser dans le tableau. Ensuite, il lance la procédure remplir(t, n) pour permettre à l’utilisateur de saisir les éléments du tableau.
Après le remplissage, l’algorithme appelle la fonction saisie() pour demander à l’utilisateur la valeur x recherchée. Enfin, il appelle la fonction occurrence(t, n, x) qui parcourt les éléments du tableau et compte le nombre de fois où x apparaît. Le résultat obtenu est ensuite affiché à l’écran.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Algorithme Occurrences_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 dans l'ordre croissant. remplir(t, n) # Appeler la fonction saisie() # afin de demander à l'utilisateur # la valeur dont il veut compter # le nombre d'apparitions. x <-- saisie() # Appeler la fonction occurrence() # pour compter le nombre de fois # où la valeur x apparaît dans le tableau. # # La valeur retournée par occurrence() # est directement affichée à l'écran. Ecrire("Le nombre d'apparitions est", occurrence(t, n, x)) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| x | entier |
| t | tableau des entiers |
La fonction saisie_taille
La fonction saisie_taille() 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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Fonction saisie_taille():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.
|
1 2 3 4 5 6 7 8 9 |
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 fonction saisie
La fonction saisie() permet de demander à l'utilisateur de saisir une valeur entière à compter le nombre d'apparitions. dans le tableau, puis de retourner cette valeur.
|
1 2 3 4 5 |
Fonction saisie():entier Ecrire("donner un entier ") Lire(n) retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction occurrence
La fonction occurrence permet de compter le nombre de fois qu’une valeur x apparaît dans un tableau.
La fonction parcourt les n éléments du tableau. À chaque fois qu’elle trouve un élément égal à x, elle augmente le compteur de 1.
À la fin du parcours, la fonction retourne le nombre total d’apparitions de x dans le tableau.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Fonction occurrence(t:tab; n:entier; x:entier) : entier # Initialiser le compteur à 0. # # Cette variable permettra de compter # le nombre de fois où x apparaît dans le tableau. compteur <-- 0 # Parcourir les n premières cases du tableau. Pour i de 0 à n-1 faire # Comparer l'élément situé dans la case t[i] # avec la valeur recherchée x. Si t[i] = x alors # Si t[i] est égal à x, # une occurrence de x est trouvée. # # Augmenter le compteur de 1. compteur <-- compteur + 1 # Retourner le nombre total d'occurrences # trouvées dans le tableau. retourner compteur Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| compteur | entier |
Programme en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 |
# ========================================================== # Importation de la bibliothèque NumPy # ========================================================== from numpy import array # Importer la fonction array de NumPy. # Elle permet de créer et de manipuler des tableaux. # ========================================================== # Création du tableau # ========================================================== # Créer un tableau de 100 éléments. # Toutes les cases sont initialisées à 0. # # Le tableau peut donc contenir au maximum 100 éléments. # Dans ce programme, seules les n premières cases # seront utilisées. t = array([int()] * 100) # ========================================================== # Fonction de saisie de la taille du tableau # ========================================================== def saisie_taille(): # 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 comprise entre 2 et 14. while test == False: # Demander à l'utilisateur de saisir # la taille du tableau. n = int(input("donner n entre 2 et 14: ")) # Vérifier que la taille saisie # est comprise entre 2 et 14. if 2 <= n <= 14: # La taille saisie est correcte. # Affecter True à test pour arrêter # la boucle de saisie. test = True # Retourner la taille valide du tableau. return n # ========================================================== # Fonction de saisie de la valeur à rechercher # ========================================================== def saisie(): # Demander à l'utilisateur de saisir # la valeur dont on veut compter # le nombre d'apparitions dans le tableau. x = int(input("donner la valeur à rechercher: ")) # Retourner la valeur saisie. return x # ========================================================== # Procédure de remplissage du tableau # ========================================================== def remplir(t, n): # Parcourir les n premières cases du tableau. for i in range(n): # Demander à l'utilisateur de saisir # un élément du tableau. # # La valeur saisie est convertie en entier # puis placée dans la case t[i]. t[i] = int(input("donner un element du tableau : ")) # ========================================================== # Fonction de comptage des occurrences # ========================================================== def occurrence(t, n, x): # Initialiser le compteur à 0. # # Cette variable permettra de compter # le nombre de fois où x apparaît dans le tableau. compteur = 0 # Parcourir les n premières cases du tableau. for i in range(n): # Comparer l'élément situé dans la case t[i] # avec la valeur recherchée x. if t[i] == x: # Si t[i] est égal à x, # une occurrence de x est trouvée. # # Augmenter le compteur de 1. compteur = compteur + 1 # Retourner le nombre total d'occurrences # trouvées dans le tableau. return compteur # ========================================================== # Programme principal # ========================================================== # Appeler la fonction saisie_taille() # afin d'obtenir le nombre d'éléments # qui seront utilisés dans le tableau. n = saisie_taille() # Afficher un message indiquant # le début du remplissage du tableau. print("***Remplissage du tableau***") # Appeler la procédure remplir() # afin de saisir les n éléments du tableau. remplir(t, n) # Afficher une ligne de séparation. print("*************************") # Appeler la fonction saisie() # afin de demander à l'utilisateur # la valeur dont il veut compter # le nombre d'apparitions. x = saisie() # Afficher une ligne de séparation. print("*************************") # Appeler la fonction occurrence() # pour compter le nombre de fois # où la valeur x apparaît dans le tableau. # # La valeur retournée par occurrence() # est directement affichée à l'écran. print("Le nombre d'apparitions est", occurrence(t, n, x)) |
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
