CONCEPTION DE BASE DE ALGORITHME .pdf



Nom original: CONCEPTION DE BASE DE ALGORITHME.pdfTitre: CONCEPTION DE BASE DE ALGORITHMEAuteur: Lino christian

Ce document au format PDF 1.4 a été généré par PDFCreator Version 1.7.2 / GPL Ghostscript 9.10, et a été envoyé sur fichier-pdf.fr le 19/03/2014 à 23:06, depuis l'adresse IP 197.214.x.x. La présente page de téléchargement du fichier a été vue 1583 fois.
Taille du document: 140 Ko (15 pages).
Confidentialité: fichier public


Aperçu du document


ALGORITHME DE BASE
MODULE I

Lino Christian. Analyste Programmeur/Master II en Réseaux et Télécommunication
Brazzaville, CONGO. BackSpace©2014

CONCEPTION DE BASE DE
L’ALGORITHME
« Il y a 10 sortes de gens au monde : ceux qui connaissent le binaire et les autres » - Anonyme

Introduction
Ce cours se donne pour objectif ; la maîtrise des COMPÉTENCES suivantes :

⊗ comprendre et examiner un algorithme préexistant, son fonctionnement ou son but ;
⊗ modifier un algorithme pour obtenir un résultat précis ;
⊗ analyser une situation : identifier les données d’entrée et de sortie, le traitement, les
instructions... ;

⊗ créer une solution algorithmique à un problème donné : comment écrire un algorithme en «
langage courant » en respectant un code, identifier les boucles, les tests, les opérations
d’écriture, d’affichage... ;

⊗ valider la solution algorithmique par des traces d’exécution et des jeux d’essais simples ;
⊗ adapter l’algorithme aux contraintes du langage de programmation : identifier si nécessaire
la nature des variables... ;

Partie : 1
« Un langage de programmation est une convention pour donner des ordres à un ordinateur. Ce
n’est pas censé être obscur, bizarre et plein de pièges subtils. Ca, ce sont les caractéristiques de la
magie. » - Dave Small

1. Définitions
Un ALGORITHME est une suite finie d’instructions élémentaires (règles), qui s’appliquent dans un
ordre déterminé à un nombre fini de données pour fournir un résultat. Il doit respecter les règles
suivantes :

⊗ Il est défini sans ambiguïté
⊗ Il se termine après un nombre fini d’opérations
⊗ Toutes les opérations doivent pouvoir être effectuées par un homme utilisant des moyens
manuels

⊗ Il manipule des données qui doivent être définis de façon très précise.
NB : un algorithme doit donc contenir uniquement des instructions compréhensibles par celui qui
devra l’exécuter.

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 2

Toutes les données utilisées dans un algorithme doivent être déclarées, pour cela nous déterminons
quels sont les de valeurs constantes et variables.
Une CONSTANTE, comme une variable, peut représenter un chiffre, un nombre, un caractère, une
chaîne de caractères, un booléen. Toutefois, contrairement à une variable dont la valeur peut être
modifiée au cours de l’exécution de l’algorithme, la valeur d’une constante ne varie pas.
Une VARIABLE est une donnée (emplacement) stockée dans la mémoire de la calculatrice ou de
l’ordinateur. Elle est repérée par un identificateur (nom de la variable constitué de lettres et/ou de
chiffres, sans espace) et contient une valeur dont le type (nature de la variable) peut être un entier,
un réel, un booléen, un caractère, une chaîne de caractères… Il ne faut pas confondre constante et
variable.
OPERATEUR : est un outil qui permet d’agir sur une variable ou d’effectuer des calculs.
OPERANDE : est une donnée utilisée par un opérateur.
INCREMENTATION : c’est l’opération qui consiste à ajouter une valeur entière fixée à un compteur.

2.





Les données
Les données d’entrée : données fournies à l’algorithme ;
Les données de sortie : résultat produit par l’algorithme ;
Les données internes : ce sont les objets servant aux manipulations internes de l’algorithme ;
Le traitement d’un objet concerne la valeur de cet objet.

3. Formalisme d’un Algorithme
Un algorithme sera défini par :

⊗ Un nom
⊗ Déclarations des variables et de constantes ;
⊗ Les actions constituant le traitement à exécuté seront délimitées par les termes : DEBUT et
FIN.
Remarque : afin de permettre une plus grandes visibilité, il faudra utiliser des commentaires
délimités par : /* commentaires */.
Programme nom_du_programme
/* Déclarations des constantes et des variables */
CONST
nom_const = valeur
VAR
nom_var : type
DEBUT
Instructions_1
Instructions_2
---------------Instructions_n
FIN

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 3

4. Comment trouver un Algorithme
Question à me poser :

⊗ Quelles sont les données dont on dispose ?
⊗ Quelles sont les résultats que l’on doit obtenir ?
Comment obtenir ces résultats :

⊗ Appliquer les règles de gestion ;
⊗ Traité à plusieurs exemples significatifs (attention aux cas particuliers) ;
⊗ Ecrire les actions nécessaires pour le traitement.
5. Validité d’un Algorithme
Pour être valable un algorithme doit répondre aux critères suivants :

⊗ Le résultat donné doit être le résultat attendu, c'est-à-dire que le programme doit donner le
bon résultat dans tous les cas de figures, il faut donc procéder à des tests par l’intermédiaire
de différents essais ;

⊗ L’algorithme doit s’arrêter une fois sa tâche accomplie ;
⊗ Le résultat doit être donné dans un temps acceptable ;
⊗ L’algorithme doit gérer au mieux la mémoire de l’ordinateur.
6. Instruction élémentaire
Enfin, les ordinateurs, quels qu’ils soient, ne sont fondamentalement capables de comprendre que
quatre catégories d'ordres (en programmation, on n'emploiera pas le terme d'ordre, mais plutôt
celui d'instructions). Ces quatre familles d'instructions sont :






L’affectation ;
La lecture/écriture ;
Les tests ;
Les boucles.

a) AFFECTATION :
L’instruction d’AFFECTATION permet d’attribuer une valeur à une variable. Cette
instruction est notée « identificateur prend valeur ». On peut aussi noter :
« identificateur
valeur ».

b) INSTRUCTION D’ENTREE / SORTIE
Nous disposerons d’une instruction de saisie qui permet de récupérer une valeur entrée au clavier
et d’une instruction d’affichage qui permet l’édition d’une valeur à l’écran.

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 4

⊗ Instruction d’entée
L’ENTREE ou la lecture de données correspond à l’opération qui permet de saisir des valeurs
pour qu’elles soient utilisées par le programme. Cette instruction est notée « saisir identificateur »
ou « lire identificateur ».

⊗ Instruction de sortie
Afficher (valeur)
Précision : la valeur peut être :

⊗ Une constante ;
⊗ Une variable ;
⊗ Une expression.
Exemple 1 : Ecrire un algorithme permettant de calculer et d’afficher la somme de deux nombres
entiers saisie au clavier.
Programme

somme_deux_nombre

/* déclaration des variables */

VAR

nombre1, nombre2, somme : entier

Début
Afficher (« donner le premier nombre : ») /* demande du premier nombre */
Lire (nombre1) /* conservation de la valeur saisie au clavier dans la variable nombre1 */
Afficher (« donner le deuxième nombre : ») /* demande du premier nombre */
Lire (nombre2) /* conservation de la valeur saisie au clavier dans la variable nombre2 */
Somme
nombre1 + nombre2 /* calcul de la somme */
Afficher (« la somme est : », somme) /* affiche la valeur de la somme */
Fin

Exemple 2 : Ecrire un programme, qui n’à pas de variable, ni de constante, mais qui affiche un
résultat.
Si un tel programme existe, à vous de l’écrire…sinon oubliez cet exemple…Finsi

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 5

Partie 2 : LES STRUCTURES CONDITIONNELLES (les tests).
On appelle traitement conditionnel, un bloc d'instructions dont l'exécution est soumise à la vérification
d’un test. Une condition peut être tout type de test.

1. La structure conditionnelle simple
Si

condition alors
Action_1

Finsi
Précision : une Action_1 peut être :

⊗ Une instruction
⊗ Un ensemble d’instruction
2. La structure conditionnelle composée
Si

condition alors
Action_1
Sinon
Action_2
Finsi
Précision : Action_1 et Action_2 peuvent être :

⊗ Une instruction
⊗ Un ensemble d’instruction
Exemple 3 : écrire un algorithme permettant de calculer et d’afficher la valeur absolue issue de la
différence des deux nombres.
Programme valeur_absolue_de_la_difference
/ * déclaration des variables */

Var

x, y, dif, abs : réel

Début
Afficher (« donner le premier nombre : ») /* demande du premier nombre */
Lire (x) /* conservation de la valeur saisie au clavier dans la variable x */
Afficher (« donner le deuxième nombre : ») /* demande du premier nombre */
Lire (y) /* conservation de la valeur saisie au clavier dans la variable y */
dif
si

x – y /* la différence de deux nombres */

dif < 0 alors / * vérification de la valeur de la différence */
abs
dif * (-1) / * si la valeur dif est inferieure à zéro */
sinon / * si la valeur dif est supérieure à zéro */
abs
dif

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 6

finsi
Fin
Exemple 4 : Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce
nombre est positif ou négatif (on laisse de côté le cas où le nombre vaut zéro).
Programme positif_ou_negatif
/ * déclaration des variables */

Var

nombre : entier

Début
Afficher (« entrez un nombre : ») /* demande du nombre */
Lire (nombre) /* conservation de la valeur saisie au clavier dans la variable x */
si

nombre < 0 alors / * si la valeur contenue dans nombre est inférieur à zéro */
afficher (« le nombre est négatif »)
sinon / * si la valeur contenu dans nombre est supérieure à zéro */
afficher (« le nombre est négatif »)

finsi
Fin

3. IMBRICATION DE SI
Il se peut que dans certains cas que l’expression d’un SI ne suffise pas à exprimer tous les cas de
figure.
Si condition_1 alors
Action_1
Sinon
Si condition_2 alors
Action_2
Sinon
Action_3
Finsi
Finsi
Exemple 5 : écrire un algorithme permettant d’afficher la tarification de la viande de bœuf en
fonction de son poids.
Poids < = 20 g ; prix = 500 frs
20 < poids <= 50 ; prix = 1000 frs
Poids > 50g ; prix = 2000 frs

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 7

Programme tarification_viande
/ * déclaration des variables */

Var

poids, prix : réel

Debut
Afficher (« saisissez le poids : »)
Lire (poids)
Si poids <= 20 alors
prix
500
sinon
si < 20 poids < = 50 alors
prix
1000
sinon
prix
2000
finsi
finsi
Fin

Exemple 6: un programme devant donner l’état de l’eau selon sa température doit pouvoir choisir
entre trois réponses possibles (solide, liquide ou gazeuse).
Programme tarification_viande
/ * déclaration des variables */

Var temp : entier
Debut
Afficher (« saisissez la temperature : »)
Lire (temp)
Si temp <= 0 alors
afficher (« c’est de la glace »)
sinon
si temp < 100 alors
afficher (« c’est du liquide »)
sinon
afficher (« c’est de la vapeur »)
finsi
finsi
Fin

4. STRUCTURE DE CHOIX
Principe
Suivant variable faire
Valeur _1 : action_1
Valeur_2 : action_2
------------------------Valeur_n : action_n
Finsuivant
Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 8

Remarque : plusieurs valeurs peuvent entrainer un même traitement.
Exemple 7 : écrire un algorithme permettant de demander un numéro et d’afficher le mois de
l’année correspondant dans le calendrier chrétien.

Programme afficher_mois_par_numéro
Var
numero : entier
mois : chaine de caractère
Debut
Afficher (« entrez un numéro : »)
Lire (numero)
Suivant numero faire
1 : mois
« janvier»
2 : mois
« février»
3 : mois
« mars»
4 : mois
« avril»
5 : mois
« mai»
6 : mois
« juin»
7 : mois
« juillet»
8 : mois
« août»
9 : mois
« septembre»
10 : mois
« octobre»
11 : mois
« novembre»
12 : mois
« décembre»
Sinon
Afficher (« mauvais numéro »)
finsuivant
Fin

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 9

Partie 3 : LES STRUCTURES ITERATIVES (les boucles)
« Les premiers 90% du code prennent les premiers 90% du temps de développement. Les 10%
restants prennent les autres 90% du temps de développement » - Tom Cargill

Les boucles, c'est généralement le point douloureux de l'apprenti programmeur. C'est là que ça
coince, car autant il est assez facile de comprendre comment fonctionnent les boucles, autant il est
souvent long d'acquérir les réflexes qui permettent de les élaborer judicieusement pour traiter un
problème donné.
Une boucle permet d'exécuter plusieurs fois de suite une même séquence d'instructions. Cet
ensemble d'instructions s'appelle le corps de la boucle. Chaque exécution du corps d'une boucle
s'appelle une itération, ou encore un passage dans la boucle. Il existe trois types de boucle :
⊗ Tant que
⊗ Repeter ... jusqu'_a
⊗ Pour

1. La structure TANT QUE
Tant que booleen faire
Action_1
Action_2
----------FINTANTQUE
Cette structure est utilisée lorsque l’action peut être de zéro à n fois. Instruction permettant la sortie
en boucle.
Le principe est simple : le programme arrive sur la ligne du TantQue. Il examine alors la valeur du
booléen (qui, je le rappelle, peut être une variable booléenne ou, plus fréquemment, une condition).
Si cette valeur est VRAI, le programme exécute les instructions qui suivent, jusqu’à ce qu’il rencontre
la ligne FinTantQue. Il retourne ensuite sur la ligne du TantQue, procède au même examen, et ainsi
de suite. Le manège enchanté ne s’arrête que lorsque le booléen prend la valeur FAUX.
Exemple 8 : un algorithme qui afficher par exemple tous les nombres de 1 à 5 dans l’ordre croissant.
Programme affiche_1_a_5
Var

i : entier /* déclaration des variables */

DEBUT
i
1 /* initialisation de i par la valeur 1*/
TANT QUE i <= 5 faire
Afficher i /* affichage des valeurs de i */
i
i + 1 /* incrémentation de i de 1*/
Fintantque
FIN

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 10

Cet algorithme initialise i à 1 et tant que la valeur de i n'excède pas 5, cette valeur est affichée puis
incrémentée. Les instructions se trouvant dans le corps de la boucle sont donc exécutées 5 fois de
suite.
La variable i s'appelle un compteur, on gère la boucle par incrémentations successives de i et on sort
de la boucle une fois que i a atteint une certaine valeur.
L'initialisation du compteur est très importante ! Si vous n'initialisez pas i explicitement, alors cette
variable contiendra n'importe quelle valeur et votre algorithme ne se comportera pas du tout
comme prévu.

Exemple 9 : écrire un programme permettant d’afficher le carré d’un nombre allant de 1 à 5.
Programme carré_nombre
/* déclaration des variables */
Var
nb, nbcarre : entier
Debut
nb
1 / * initialisation de la variable à 1 */
TANT QUE nb <= 5 faire / * vérification de la condition */
nbcarre
nb *nb / * affectation du produit calculé dans nb */
afficher (nb, « son carré est : », nbcarre) / * affichage du nombre et de son carré */
nb
nb +1 /* incrémentation de 1 de la valeur contenue dans la variable nb et
affectation dans de la nouvelle valeur dans nb */

Fintantque
Fin

Exemple 10 : Ecrire un algorithme qui permet de retrouver le maximum, le minimum ainsi que la
somme d’une liste de nombres positifs saisis par l’utilisateur. La fin de la liste est indiquée par un
nombre négatif. La longueur de la liste n’est pas limitée.
Exemple exécution :
si la liste des éléments est : 7 3 20 15 2 6 5 -1
Le maximum est 20, le minimum est 2.
Programme max_min_nombre
Var nb, max, min : entier
Debut
Afficher (« entrer le nombre : »
Lire (nb)
max
n
min
n
TANT QUE n > 0 faire
Afficher (« entrer le nombre : »)
Lire(nb)
Si min > nb alors
min
nb
finsi
si max < n alors
max
nb
finsi
Fintantque

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 11

Afficher (« le maximun est : », max, « et le minimum est : », min)
Fin

2. La structure REPETER
La structure répéter :
Repeter
Action
Jusqu'à condition
La condition est testée après l’exécution de l’action définie. Sa structure peut être utilisée lorsque
l’action peut être exécutée au moins une fois.
Cet ordre d'itération permet de répéter le traitement une ou plusieurs fois et de s'arrêter sur une
condition. En effet, lorsque la condition est vérifiée, la boucle s'arrête, si non elle ré-exécute le
traitement.
Remarque : Dans cette boucle, le traitement est exécuté au moins une fois avant l'évaluation de la
condition d'arrêt. Il doit y avoir une action dans le traitement qui modifie la valeur de la condition
(le principe d’utilisation d’un compteur).

Exemple 11 : un algorithme qui afficher par exemple tous les nombres de 1 à 5 dans l’ordre croissant.
Programme affiche_1_a_5
Var i : entier
DEBUT
i
1
Répéter
Afficher i
i
i+1
Jusqu'à i > 5
FIN
De la même façon que pour la boucle Tant que, le compteur est initialise avant le premier passage
dans la boucle. Par contre, la condition de sortie de la boucle n'est pas la même, on ne sort de la
boucle qu'une fois que la valeur 5 a été affichée.
Or, i est incrémenté après l'affichage, par conséquent i aura la valeur 6 à la fin de l'itération pendant
laquelle la valeur 5 aura été affichée. C'est pour cela qu'on ne sort de la boucle qu'une fois que i a
dépassé strictement la valeur 5.
L’une des utilisations courant de la boucle Repeter...Jusqu’à est le contrôle d’une saisie.
Exemple 12 : écrire un algorithme permettant de calculer l’âge d’une personne à partir de son année
de naissance. Le programme recommence autant de fois que possible.

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 12

Programme

age_par_annee_naissance

/*déclaration constante et variables */

CONST
VAR

annee_cours = 2005
annee_naiss, age, : entier
Choix : chaîne de caractère

Debut
Repeter
Afficher (« quel est l’année de naissance : ») /*donnez votre année de naissance */
Lire (annee_naiss) /* prise en compte de la valeur saisie*/
age
annee_naiss - annee_cours /*calcule de l’âge*/
Afficher (« vous êtes née en », anne_naiss, « votre âge est : », age, « ans »)
Afficher (« Voulez-vous continuer O/N » / *si vous voulez continuer tapez O sinon N*/
Lire (choix) /*prise en compte de la valeur saisie*/
Jusqu’à choix <> « N »
Fin

3. La structure POUR
La structure POUR, permet de répéter une instruction un nombre de fois connu à l’avance. Se
présente :
Pour identifiant De

valeur-initiale A

valeur-final

[PAS DE incrément] Faire

Action
Finpour

⊗ Identificateur et identifiant : sont de type entier ;
⊗ Valeur-initiale et valeur-finale sont des constantes ou des variables.
⊗ Incrément : valeur d’augmentation ou de diminution progressive de l’identifiant (entier ou
négatif) par défaut la valeur 1.
Exemple 13 : un algorithme qui afficher par exemple tous les nombres de 1 à 5 dans l’ordre croissant
Programme affiche_1_a_5
Var i : entier /*déclaration des variables */
DEBUT
Pour i allant de 1 à 5 /* parcours les valeurs de 1 à 5 */
Afficher i /*affichage de la valeur de i */
Finpour
FIN
Observez les similitudes entre cet algorithme et la version utilisant la boucle tant que. Noté bien que
l'on utilise une boucle pour quand on sait en rentrant dans la boucle combien d'itérations devront
être faites. Par exemple, n'utilisez pas une boucle pour contrôler une saisie !

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 13

Exemple 14: écrire un algorithme permettant d’afficher les tables de multiplication de 1 à 9 pour
les premiers nombres entiers.

Programme table_multiplication
Var n, m, i : entier /*déclaration des variables */
Debut
Afficher (« donner la valeur, pour afficher sa table de multiplication : »)
Lire(n)
Pour i De 0 A 10 Faire
m
n * I /* calcul du produit et affectation dans m */
afficher ( n, « x », i, « = », m) /* affichage de la table */
Finpour
Fin
Exemple 15 : écrire un algorithme permettant d’afficher le carré des 5 premiers entiers.
Programme carré_5 _nombre
Var nb, nbcarre : entier
Debut
Pour nb De 0 A 4 Faire
Nbcarre
nb * nb
Afficher (nb , « son carré est : », nbcarre)
Finpour
Fin

COMPARAISON ENTRE LES DIFFERENTES ITERATIONS

⊗ On utilise la boucle POUR quand on connait le nombre d’itération à l’avance ;
⊗ On utilise la boucle REPETER quand l’on ne connait pas le nombre d’itération à l’avance et
que l’on doit entrer au moins une fois dans la boucle ;

⊗ On utilise TANT QUE lorsqu’on ne connait pas le nombre d’itérations à l’avance et que l’on
n’est pas sur de rentrer au moins une dans la boucle.

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 14

QUESTIONS

Lino Christian.

Analyste Programmeur/Master 2 en Réseaux télécom

Page 15


Aperçu du document CONCEPTION DE BASE DE ALGORITHME.pdf - page 1/15
 
CONCEPTION DE BASE DE ALGORITHME.pdf - page 3/15
CONCEPTION DE BASE DE ALGORITHME.pdf - page 4/15
CONCEPTION DE BASE DE ALGORITHME.pdf - page 5/15
CONCEPTION DE BASE DE ALGORITHME.pdf - page 6/15
 




Télécharger le fichier (PDF)


Télécharger
Formats alternatifs: ZIP



Documents similaires


conception de base de algorithme
annexe pic 4t  2020 2021
cours algorithmique
o1um9q0
algo
19221855 exercices corriges dalgorithmique

Sur le même sujet..




🚀  Page générée en 0.163s