Conception de base_de_l_algorithme

Chapitre 1 : Conception de base algorithme
Conception de base de l'algorithme

I - Notions générales

A - Définitions

Un algorithme peut être défini comme la séquence d'action permettant d'arriver à un résultat déterminé à partir d'une
situation donnée. Il doit respecter les règles suivantes :
1. il est défini sans ambiguïté
2. il se termine après un nombre fini d'opérations
3. toutes les opérations en doivent pouvoir être effectuées par un homme utilisant des moyens manuels
4. il manipule des objets qui doivent être définis de façon très précise.

B - Les objets

Les objets d'entrée : données fournies à l'algorithme
Les objets de sortie : résultats produits par l'algorithme
Les objets internes : ce sont les objets servant aux manipulations internes de l'algorithme

Le traitement d'un objet concerne la valeur de cet objet.
Un objet dont la valeur ne peut pas être modifiée dans un algorithme est une constante.
Un objet dont la valeur peut être modifiée dans un algorithme est une variable.

Un objet est parfaitement défini si nous connaissons ces trois caractéristiques :
- son identificateur (nom de l'objet) : il est représenté par une vie quelconque de caractères
alphanumériques commençant obligatoirement par une lettre.
- sa valeur (constantes ou variables)
- son type : le type d'un objet est défini par un ensemble de valeurs constantes et par l'ensemble des
opérations que nous pouvons appliquer à ces constantes :
- Réel ;
- Entier :
DIV : division entière (partie entière du quotient)
5 DIV 2 = 2
/ : division réelle
5 / 2 = 2,5
MOD : le reste de la division entière
5 MOD 2 = 1
- Booléen
opérateurs : et / ou / non
- Caractères :
représenté en code ASCII
permet d'avoir une relation d'ordre
Exemples : « A » < « a » ASCII : 65 < 97
« A » < « Z » ASCII : 65 <90
- chaîne de caractères : on considère comme prédéfini certaines fonctions
opérateurs :
- LONGUEUR (chaîne) : nombre de caractères de la chaîne
Exemple : « BON » & « JOUR » = BONJOUR

Tous les objets utilisés dans un algorithme doivent être déclarés pour cela nous déterminons quels sont les objets de
valeurs constantes et variables.

1 / 13 DAIGL Programmation


Les constantes :
CONST nom_objet = valeur
Les variables :
VAR nom_objet : type

Remarque : - si plusieurs variables sont de même type nous pouvons les regrouper sur une même ligne ;
- les constants sont déclarés en premier ;
- les termes réservés CONST et VAR ne figure qu'une seule fois dans l'algorithme ;
Exemples : CONST max. : 50
min. : 10
VAR jour, mois, année : chaîne de caractères

C - Formalisme d'un algorithme

Un algorithme sera défini par :
- un nom ;
- déclarations des variables et des constantes ;
- les actions constituant le traitement a exécuté seront délimitées par les termes : DEBUT et FIN ;

Remarque : afin de permettre une plus grande visibilité, il faudra utiliser des commentaires délimités par les sigles
/*commentaires*/.

Programme nom_pg

/*Déclarations des constantes*/
CONST nom_const = valeur
VAR nom_var : type

Début
| Action 1
| Action 2
| etc.
Fin

D - 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) ;
- écrire les actions nécessaires pour le traitement.

E - La 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.


II - Instructions élémentaires

A – Affectation

nom_var ← valeur (permet d'affecter une valeur à une variable)

La valeur peut être :
-- une variable du même que nom_var ;
-- une constante du dit nom_var ;
-- une expression dont l'évaluation produit un résultat du type nom_var

Exemples : VAR R : entier
R ← 10
VAR X, Y : entier
R←Y R prend la valeur de X
R←X+Y X←R X prend la valeur de R
R ← R +1 on évalue R + 1 avec l'ancienne valeur de R et on range le
résultat dans R.

Exemple : écrire un algorithme permettant de calculer le nombre de caractères du mot DUPONT.

Programme Compte v.1

CONST nom : « Dupont »
VAR compte : entier

Début Deux inconvénients :
| compte ← longueur (nom) -- pas d'affichage du résultat ;
Fin -- travaille avec le même mot ;

B - Instructions d'entrée / 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.

1 -- Instructions d'entrée

Saisir (nom_var)
nom_var est une variable déclarée

Exemple : VAR R : entier que
Saisir (R)

2 -- Instructions de sortie

Afficher (valeur)

La valeur peut être :
-- une variable ;
-- une expression ;
-- une constante.



Exemples : VAR R, X, Y : entier

Afficher (« Bonjour ») Bonjour
Afficher (R) Valeur de R
Afficher ( 3 + 2) 5
Afficher (« 3 + 2 = 5 ») 3+2=5
Afficher (« 3 + 2 = 3 + 2 ») 3 + 2 =, 3 + 2
Afficher (« 3 + 2 = », 3 + 2) 3 + 2 =, 5
Afficher ( X + Y ) Valeur de X + Y
Afficher ( « X + Y ») X+Y
Afficher (« La somme est de : », X + Y La somme est de, X + Y

Remarque : dans le cas d'un dialogue via le clavier, il convient d'afficher des messages facilitant la communication.

Exemple : écrire un algorithme permettant de calculer et d'afficher le nombre de caractères d'un mot quelconque.

Programme Compte v 1.1

Var compte : entier
nom : chaîne de caractères

Début
| Afficher (« Quel est le nom ? »)
| Saisir (nom)
| compte ← longueur (nom)
| Afficher (« Le nombre de caractères et de : », compte)
Fin

Exemple : écrire un algorithme permettant d'afficher la table des carrés de 1 à 5 ;
Résultats à afficher : 1^2 = 1, 2^2 = 4, 3^2 = 9, 4^2 = 16, 5^2 = 25 ;

Début Début
| Afficher (« 1^2 = », 1^2) | Afficher (« 1^2 = 2 »)
Fin Fin

III -- Les structures conditionnelles

A -- La structure alternative

Si condition alors
| action 1
Sinon action 2
Fsi

Action 1 et action 2 peuvent être :
-- une instruction ;
-- un ensemble d'instructions ;
-- un algorithme.



Exemple : écrire un algorithme permettant de calculer et d'afficher la valeur absolue et la différence entre le nombre.

Programme Calcul v 1

Var x, y, dif, abs : réel

Début
| Afficher (« Veuillez saisir le premier nombre »)
| Saisir (x)
| Afficher (« Veuillez saisir le deuxième nombre »)
| Saisir (y)
| Si dif < 0 alors
| | abs ← dif * - 1
| | sinon abs ← dif
| Fsi
| Afficher (« La valeur absolue est de », abs)
Fin

Remarque : il n'est pas obligatoire de spécifier une partie sinon.

B -- La structure conditionnelle

Si condition alors
| action
Fsi

Action peut être :
-- un algorithme ;

Programme Calcul v 1.1

Var x, y, dif, abs : réel

Début
| Afficher (« Veuillez saisir le premier nombre »)
| Saisir (x)
| Afficher (« Veuillez saisir le deuxième nombre »)
| Saisir (y)
| dif ← x - y
| Si dif < 0 alors
| | abs ← dif * - 1
| Fsi
| Afficher (« La valeur absolue est de », dif)
Fin


Exemple : un robot conduit une voiture, ils peuvent exécuter trois actions, « s'arrêter », « ralentir », « passer » en
fonction de la couleur des feux qui sera saisi.

Programme robot v 1

Var couleur : chaîne de caractères

Début
| Afficher (« saisir la couleur »)
| Saisir (couleur)
| Suivants couleur faire
| | vers : afficher (« passer »)
| | orange : afficher (« ralentir »)
| | rouge : afficher (« s'arrêter »)
| Sinon
| | Afficher (« veuillez saisir une couleur correcte »)
| Finsuivant
Fin

IV-- Les structures itératives

A -- L'instruction TANT QUE

Tant que condition faire
| Action 1
| Action 2
| etc.
Fintantque

Action 1, action 2, … peut être :
-- un algorithme ;

Cette structure est utilisée lorsque l'action peut être exécutée de zéro en n fois
instructions permettant la sortie de la boucle


Programme carré v 1.1

Var nb, nbcarre : entier

Début
| nb ← 1
| Tant que nb <= 5 faire
| | nbcarre ← nb * nb
| | Afficher ( nb, «^2 = », nbcarre)
| | nb ← nb + 1
| FTQ
Fin



Exemple : écrire un algorithme permettant d'afficher la longueur de chaque mot saisi. Nous souhaitons également
compter le nombre de mots saisis. L'utilisateur entre autant de mots qui le souhaitent

Programme Mot v 1

Var mot, choix : chaîne de caractères
nbmot, lgmot : entier

Début
| nbmot ← 0
| Tant que choix <> « N » Faire
| | Afficher (« Veuillez saisir un mot. »)
| | Saisir (mot)
| | lgmot ← LONGUEUR (mot)
| | lgmot ← nbmot + 1
| | Afficher (« Le mot », mot, « se compose », lgmot, « caractères. »)
| | Afficher (« Vous ne vous continuez O/N)
| | Saisir (choix)
| FTQ
| Afficher (« vous avez saisi », nbmot, « mots. »)
Fin

B -- L'instruction répéter

Répéter
| Action
Jusqu'à condition

Action peut être :
-- un algorithme ;

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 1 à n fois.



Var nb: entier

Début
| nb ← 1
| Répéter
| | Afficher ( nb, «^2 = », nb * nb)
| | nb ← nb + 1
| Jusqu’à nb = 6
Fin



Exemple : écrire un algorithme permettant de calculer l'âge d'une personne à partir de son année de naissance.
Nous recommençons autant de fois que possible.

Programme age v 1

Const anné_cours = 2005
Var anné_naiss, âge : entier
choix : chaîne de caractères

Début
| Répéter
| | Afficher (« Quel est l'année de naissance »)
| | Saisir (anné_naiss)
| | âge ← anné_naiss * anné_cours
| | Afficher (« La personne née en », anné_naiss, « à », âge, « ans. »)
| | Afficher (« Voulez vous continuez O/N)
| | Saisir (choix)
| Jusqu’à choix = « N » ou choix = « n »
Fin

Gestion des erreurs de saisie :

Première méthode : Deuxième méthode :
Répéter Afficher (« »)
| Afficher (« ») Saisir (identifiant)
| Saisir (identifiant) Tant que condition Faire
Jusqu’à condition | Afficher (« »)
| Saisir (identifiant)
FTQ

Exemple : écrire un algorithme (2 versions) permettant de saisir un nombre compris entre un et 100.

Programme nombre v 1

Var nbre : réel

Début
| Répéter
| | Afficher (« Veuillez saisir un nombre compris entre 1 et 100 : »)
| | Saisir (nbre)
| Jusqu’à nbre >= 1 et nbre <= 100
Fin



Programme nombre v 2

Var nbre : réel

Début
| Tant que nbre <= 1 ou nbre > 100 faire
| | Afficher (« Entrez un nombre entre un et 100 : »)
| | Saisir (nbre)
| FTQ
Fin

C -- L'instruction pour

Pour identifiant De valeur-initiale A valeur-finale [PAS DE incrément] Faire
| Action
Finpour

Action peut être :
-- un algorithme ;

Cette structure permet de répéter une action un nombre connu de fois.
Identificateur identifiant est 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 positif ou négatif) par défaut 1



Var nb, nbcarre: entier

Début
| Pour nbre De 1 A 5 Faire
| | nbcarre ← nb * nb
| | Afficher ( nb, «^2 = », nbcarre)
| Finpour
Fin

Exemple : écrire un algorithme permettant d'afficher
1*9=9 3 * 9 = 27 5 * 9 = 45 7 * 9 = 18 9 * 9 = 91

Programme calcul v 1

Var nbre, résultat : entier

Début
| Pour nbre De 1 A 9 Pas de 2 Faire
| | résultat ← nbre * 9
| | Afficher (nbre, «* 9 = », résultat)
| Finpour

Fin

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

Programme Table v 1

Var nbre, table : entier

Début
| Pour table De 2 A 9 Faire
| | Pour nb De 1 A 10 Faire
| | | afficher (nb, « * », table, « = », nb * table)
| | Finpour
| Finpour
Fin

D -- Comparaison entre les différentes itérations

on utilise la boucle « Pour » quand l’on connaît le nombre d'itérations à l'avance ;
on utilise « Répéter » quand l’on ne connaît pas le nombre d'itérations à l'avance et que l'on doit entrer au
moins une fois dans la boucle ;
on utilise « Tant que » lorsqu'on ne connaît pas le nombre d'itérations à l'avance et que l'on n'est pas sur de
rentrer au moins une fois dans la boucle.


Conception de base_de_l_algorithme

Contenu connexe

Tendances (20)

En vedette (20)

Similaire à Conception de base_de_l_algorithme (20)

Conception de base_de_l_algorithme