Site Atlantic: cours interactif gratuit "Algorithmique et Programmation".

II.4.LES EXPRESSIONS ARITHMETIQUES:

Chapitre précédent. Evaluation. Chapitre suivant.

II.4.1.DEFINITION:

Une EXPRESSION ARITHMÉTIQUE est une expression composée de variables, de constantes ou d'expressions arithmétiques séparées par des opérateurs mathématiques. Elles correspondent au schéma suivant:

<exp. arith> =::=

Remarquons que la définition précédente est récursive: une expression arithmétique de base est formée de deux termes séparés par un opérateur. Chacun de ces termes peut être une expression arithmétique, et ainsi de suite....

EXEMPLES:

var A, B, C en numerique
........................
A+B, 3-C, 4*D sont des expressions arithmétiques «minimales»
........................
A+(3*B+C), 5*(4*A+2*B) sont des expressions arithmétiques comprenant d'autres expressions arithmétiques mises entre parenthèses.

II.4.2.EVALUATION D'UNE EXPRESSION ARITHMETIQUE:

L'évaluation d'une expression arithmétique donne un résultat numérique. En algorithmique, les opérateurs mathématiques suivants sont les plus utilisés:

OPERATEUR	OPERATION
( )	Parenthèses
+	Addition
-	Soustraction
*	Multiplication
/	Division
%	Modulo. 40 % 7 signifie «reste de la division de 41 par 7» (c'est à dire 6 car 40=(5*7)+6)
^	Elévation à une puissance (5^3 =555)

L'évaluation d'une expression arithmétique obéït à l'ordre de priorité suivant:

Priorité 0: Expressions représentant des indices de tableaux
Priorité 1: Autres expressions placées entre parenthèses.
Priorité 2: Opérandes affectés des opérateurs *, / ou %
Priorité 3: Opérandes affectés des opérateurs + ou -

Les opérandes de même priorité sont exécutés de gauche à droite.

EXEMPLE:

3 - ( 7 - T(A-2) * (B - 8) ) est évalué dans l'ordre suivant:

A-2 est utilisée comme indice du tableau T
B – 8 Expression dans la parenthèse la plus intérieure
T(A-2)* (B – 8) L'opérateur * est prioritaire sur l'opérateur – de «7-T(A-2) »
(7 - T(A-2) * (B – 8)) L'expression entre parenthèse est prioritaire sur l'opérateur – de «3 - (7 -....»
3 - (7 - T(A-2) * (B – 8)) Il ne reste plus que l'opérateur – de 3 - ..... à exécuter.

II.4.3.REMARQUE:

Les langages de programmation mettent à disposition des développeurs beaucoup plus d'opérateurs arithmétiques que les pseudo-codes. Ceci vient du fait que le but de l'analyse algorithmique est beaucoup plus de faire ressortie la logique des traitements que leur contenu mathématique. En fait, il faut éviter autant que possible de faire figurer dans un pseudo-code des calculs détaillés qui diminuent la lisibilité et n'amènent rien à la compréhension de la logique du traitement. On se contentera en général d'évoquer ces calculs par une instruction en texte libre:

EXEMPLE:

DEBUT CalculPortee

// Déclaration des données
var VitesseInitiale en numerique
var Hausse en numerique
var Portee en numerique

// Debut procedure
ENTRER VitesseInitiale
ENTRER hausse
<Calcul de la portee de l'obus, puis transfer du résultat dans Portee>
SORTIR Portee

FIN CalculPortee

II.5.LES EXPRESSIONS LOGIQUES:

II.5.1.DEFINITION:

Les expressions logiques sont celles dont l'évaluation donne une valeur de type booléen: true (vrai) ou false (faux). On les nomme parfois «assertions».

EXEMPLES:

La terre est ronde est une assertion ayant la valeur vraie
Le prénom de Napoléon Bonaparte n'était pas Napoléon est une assertion ayant la valeur faux
3 fois 12 vaut 36 est une assertion ayant la valeur vraie

II.5.2.LES COMPARAISONS ARITHMETIQUES:

II.5.2.1.DEFINITION:

Une comparaison arithmétique consiste à comparer les valeurs de deux expressions arithmétiques à l'aide d'un opérateur de comparaison:

II.5.2.2.LES OPERATEURS DE COMPARAISON ARITHMETIQUE:

Les opérateurs de comparaison arithmétiques permettent de créer des variables logiques. En effet, le résultat d'une comparaison entre deux expressions arithmétiques est un booléen (valeurs true ou false, vrai ou faux). Les opérateurs de comparaison suivants sont les plus utilisés:

OPERATEUR	OPERATION DE COMPARAISON
=	Teste l'égalité numérique de deux expressions
<>	Teste l'inégalité numérique de deux expressions
<	x < y teste si x est plus petit que y
>	x > y teste si x est plus grand que y
<=	x <= y teste si x est plus petit ou égal à y
>=	x >= y teste si x est plus grand ou égal à y

EXEMPLES:

var A en numerique
A ← 25
B ← 15

A > 5 est une expression logique (comparaison) qui vaut vrai (true)
A > B est une expression logique (comparaison) qui vaut faux (false)
A-2 >= B+7 est une expression logique (comparaison) qui vaut vrai (true)

II.5.3.LES EXPRESSIONS LOGIQUES COMPOSEES:

II.5.3.1.DEFINITION:

Une expression logique composée est une expression composée de variables logiques, de constantes logiques (true/false), d'expressions logiques ou de comparaisons, séparées par des opérateurs logiques. Le schéma général est le suivant:

<exp. logique> :=:

Une expression logique composée a pour valeur un booléen (true/false).

II.5.3.2.LES OPERATEURS LOGIQUES:

L'INTERSECTION (OPERATEUR ET)

a	b	a ET b
FAUX	FAUX	FAUX
FAUX	VRAI	FAUX
VRAI	FAUX	FAUX
VRAI	VRAI	VRAI

LA RÉUNION (OPERATEUR OU)

a	b	a OU b
FAUX	FAUX	FAUX
FAUX	VRAI	VRAI
VRAI	FAUX	VRAI
VRAI	VRAI	VRAI

LA NÉGATION (OPERATEUR NON)

a	NON a
FAUX	VRAI
VRAI	FAUX

L'EXCLUSION (OPERATEUR XOR)

a	b	a XOR b
FAUX	FAUX	FAUX
FAUX	VRAI	VRAI
VRAI	FAUX	VRAI
VRAI	VRAI	FAUX

LES PARENTHÈSES:

Dans une expression logique comme dans une expression mathématique, les parenthèses délimitent une sous-expression qu'il faut évaluer individuellement.

EXEMPLES:

(<la terre est ronde>) ET (<Elle tourne autour du soleil>) est vraie
(<la lune est cubique>) OU (<Elle tourne autour de la terre>) est fausse
(<la lune est cubique>) XOR (<Elle tourne autour de la terre>) est vraie Si la variable A contient 25, NON( A > 15 ) est fausse.
(NON <la lune est cubique>) XOR (Elle tourne autour de la terre) est fausse.

II.5.3.3.EVALUATION DES EXPRESSIONS LOGIQUES:

Dans une expression logique:

Les parenthèses ne contenant pas d'autres parenthèses sont évaluées en premier, puis remplacées par leur valeur booléenne, et ainsi de suite.
L'opérateur NON est prioritaire sur ET, OU et XOR
Les opérateurs ET et XOR sont prioritaires sur OU
A égalité de priorités, l'évaluation se fait de gauche à droite.

EXEMPLE:

Si A = 12, B = -7, C = 9, l'expression VRAI ET ( ( A > B–2 ) OU NON ( C = 9 )) est évalué de la manière suivante:

On évalue d'abord (A > B-2), parenthèse ne contenant pas de parenthèse la plus à gauche: 12>-9 est VRAIE. L'expression devient: VRAI ET ( VRAI OU NON ( C = 9 ))
On évalue ensuite (C = 9), parenthèse ne contenant pas de parenthèse: 9 = 9 est VRAIE. L'expression devient: VRAI ET ( VRAI OU NON VRAI )
On évalue alors ( VRAI OU NON VRAI ). L'opérateur NON étant prioritaire, on évalue NON VRAI, ce qui donne FAUX. L'expression devient alors VRAI ET ( VRAI OU FAUX ), et comme VRAI OU FAUX donne VRAI, l'expression devient: VRAI ET VRAI.

Ce qui donne finalement: VRAI ET ( ( A > B – 2 ) OU NON ( C = 9)) a pour valeur logique: VRAI.

II.6.LES STRUCTURES ALTERNATIVES:

II.6.1.DEFINITIONS:

Un BLOC D'INSTRUCTIONS est constitué soit d'une seule instruction, soit d'une liste d'instructions consécutives dont l'exécution peut être assimilée à celle d'une seule instruction.

REMARQUE:

Ceci implique que l'exécution d'un bloc d'instructions débute à la première instruction de la liste et se termine toujours par la dernière: on ne peut pas «sortir» du bloc avant cette dernière instruction.

Une STRUCTURE ALTERNATIVE est un modèle de pseudo-code qui permet de conditionner l'exécution ou non de BLOCS D'INSTRUCTIONS à la vérification d'EXPRESSIONS LOGIQUES.

REMARQUE:

On appelle souvent «instructions conditionnelles» les structures alternatives. Cependant, il faut remarquer qu'une structure alternative n'est pas une instruction, mais un ensemble de blocs d'instructions «enchassées» dans un schéma logique matérialisé par des mots-clefs. L'appellation STRUCTURES conditionnelles serait plus adaptée.

II.6.2.L'ALTERNATIVE SIMPLE:

II.6.2.1.SCHÉMA GÉNÉRAL:

SI < expression logique > ALORS
Bloc d'instructions n° 1
SINON
Bloc d'instructions n° 2
FINSI

II.6.2.2.FONCTIONNEMENT:

Si l'expression logique est vraie alors, on exécute la séquence d'instruction n° 1
Sil'expression logique est fausse alors, on exécute la séquence d'instruction n° 2

On peut représenter ce mécanisme par le logigramme suivant:

II.6.2.3.SCHÉMA SIMPLIFIÉ:

Si le bloc d'instructions n° 2 est vide, on peut simplifier en:

SI < expression logique > ALORS
Bloc d'instructions n° 1
FINSI

II.6.2.4.EXEMPLE:

DEBUT TraitementDigicode

const Code = 3456
var Digicode en numerique

< Attendre l'entrée d'un code sur le digicode >
ENTRER Digicode // DEPUIS le clavier
SI ( Digicode = Code ) ALORS

<Déverrouiller la porte>
<Actionner le buzzer>
<Attendre le signal porte refermée>
<Verrouiller la porte>

SINON

FINSI

FIN TraitementDigicode

II.6.3.ALTERNATIVES MULTIPLES:

II.6.3.1.SCHÉMA GÉNÉRAL:

SI < expression logique 1 > ALORS
Bloc d'instructions n° 1
SINON SI < expression logique 2 > ALORS
Bloc d'instructions n° 2
SINON SI < expression logique 3> ALORS
Bloc d'instructions n° 3
....................
SINON SI < expression logique n-1> ALORS
Bloc d'instructions n° n-1
SINON
Bloc d'instructions n° n
FINSI

Le fonctionnement correspond au logigramme suivant:

II.6.3.2.EXEMPLE:

ENTRER EtatfeuTricolore
SI ( EtatFeuTricolore = ''vert'' ) ALORS
<Accélérer>
SINON SI ( EtatFeuTricolore = ''jaune'' ) OU ( EtatFeuTricolore = ''Rouge'' ) ALORS
<Tenter de s'arréter avant le feu>
SINON // Etat clignotant
<Ralentir>
FINSI

II.6.4.IMBRICATION D'ALTERNATIVES SIMPLES:

II.6.4.1.PRINCIPE:

Un bloc d'instructions devant obligatoirement se comporter comme une seule instruction, il doit obligatoirement englober entièrement les structures alternatives qu'il renferme. De ce fait, une structure alternative imbriquée dans une autre doit obligatoirement être englobée par un des blocs de cette dernière.

II.6.4.2.SCHÉMA GÉNÉRAL:

SI < expression logique 1 > ALORS
Séquence d'instruction n° 1
SINON

SI < expression logique 2 > ALORS
Séquence d'instruction n° 2
SINON
Séquence d'instruction n° 3
FINSI

FINSI

Ce qui donne le logigramme suivant:

II.6.4.3.EXEMPLE:

DEBUT Traitement digicode

const Code = 3456
var Digicode en numerique

< Attendre l'entrée d'un code sur le digicode >
ENTRER Digicode
SI ( Digicode = Code ) ALORS

SI <La porte est fermée> ALORS // alternative imbriquée

<Déverrouiller la porte>
<Actionner le buzzer>

FINSI

SINON

<Emettre sur le haut-parleur la phrase «code erronné»

FINSI

FIN TraitementDigicode

II.6.5.LES COMMUTATEURS (SWITCHES):

Les commutateurs (switches) sont des structures alternatives très employées dans les langages de programmation. Equivalents logiques des alternatives multiples, ils les remplacent avantageusement dans les cas complexe, car leur notation est plus adaptée.

II.6.5.1.SCHÉMA GENERAL:

SUIVANT LE CAS <expression> FAIRE

CAS <valeur n°1>:
Bloc d'instruction n° 1
CAS <valeur n°2>:
Bloc d'instruction n°
CAS ....................
........................
CAS <valeur n° m-1>:
Bloc d'instruction n° m-1
AUTRES CAS:
Bloc d'instruction n° m

FINCAS

REMARQUES:

Expression peut être une expression logique ou arithmétique ou une variable simple.
les valeurs qui suivent le mot clef CAS doivent être des constantes de même type que <expression>

II.6.5.2.FONCTIONNEMENT:

L'expression libellée dans la première ligne est évaluée, puis le bloc d'instruction correspondant au CAS ou la valeur est égale à celle de l'expression (et uniquement celui-ci) est exécuté. Si aucun cas ne convient, le bloc d'instructions AUTRES CAS est exécuté.

II.6.5.3.LOGIGRAMME:

II.6.5.4.EXEMPLE:

DEBUT TrouverPrenoms

var Nom en chaine de caracteres

<Attendre l'entrée d'un nom de famille>
ENTRER Nom
SUIVANT LE CAS Nom FAIRE

CAS BALZAC:
SORTIR «Honoré»
CAS Hugo:
SORTIR «Victor»
................................
................................
CAS Flaubert:
SORTIR «Gustave»
AUTRES CAS:
SORTIR «Prénom inconnu»

FINCAS

FIN TrouverPrenoms

II.7.LES STRUCTURES ITERATIVES (BOUCLES):

II.7.1.LA BOUCLE TANT QUE:

II.7.1.1.SCHÉMA GÉNÉRAL:

TANT QUE <expression logique ou variable booléenne> FAIRE
<Bloc d'instructions>
FIN TANTQUE

II.7.1.2.FONCTIONNEMENT:

Tant que <expression logique ou variable booléenne> a la valeur VRAI, on exécute la séquence d'instructions, puis on recommence jusqu'à ce que <expression logique ou variable booléenne> devienne fausse.

Si, au départ, <expression logique ou variable booléenne> est déjà fausse, on saute complêtement la boucle.

La boucle TANTQUE est utilisée quand le nombre d'itérations dépend d'une condition dont la valeur varie en fonction des traitements contenus dans la boucle: à priori, on ne sait pas combien d'itérations vont être effectuées.

ATTENTION:

cette boucle implique que le bloc d'instructions interne puisse modifier la valeur de <expression logique ou variable booléenne>. Sinon, il n'y a aucune raison que l'on puisse terminer la boucle après y être entré une fois...

II.7.1.3.LOGIGRAMME:

La boucle TANT QUE est équivalente au logigramme suivant:

II.7.1.4.EXEMPLES:

EXEMPLE 1

var A, B en numérique
A ← 5
B ← 300
i ← 1

TANTQUE ( A^i < B )
i = i+1
FIN TANTQUE

EXEMPLE 2

TANTQUE ( 3 < 5 )
séquence d'instructions
FIN TANTQUE

EXEMPLE 3

var A, B en numérique

ENTRER A
ENTRER B
i ← 1
TANT QUE (A^i< B) ET (i<10)
i = i+1
FIN TANTQUE

II.7.2.LA BOUCLE POUR:

II.7.2.1.SCHÉMA GÉNÉRAL:

POUR <compteur> ← <valeur debut> à <valeur fin> PAS DE <pas de progression>
<Bloc d'instructions>
<compteur> SUIVANT

<compteur>, <valeur debut>, <valeur fin> et <pas de progression> sont des nombres entiers négatifs, nuls ou positifs

II.7.2.2.FONCTIONNEMENT:

Au départ, le compteur est chargée à sa valeur de début.
Tant que le compteur n'est pas égal à la valeur de fin, on effectue la séquence d'instructions et on ajoute algébriquement le pas au compteur (on peut donc faire progresser ou régresser le compteur)

La boucle POUR est utilisée quand on sait combien d'itérations doivent être effectuées.

II.7.2.3.LOGIGRAMME ÉQUIVALENT:

II.7.2.4.EXEMPLE:

Calculer les 10 premières puissances paires d'un nombre et les afficher par ordre décroissant:

var A, P en numerique

ENTRER A
POUR C ← 20 A 2 PAS DE -2
P ← A^C
SORTIR «la puissance », C, «ieme de A est=», P
C SUIVANT

II.8.PROCEDURES ET FONCTIONS

II.8.1.LES PROCEDURES:

II.8.1.1.DEFINITION:

Une procédure est un algorithme qui satisfait aux conditions suivantes:

Son exécution peut être déclenchée depuis un autre algorithme, à l'aide d'une seule instruction, dite «instruction d'appel de procédure».
A la fin de son exécution, la procédure rend la main à l'algorithme appelant, qui peut reprendre son exécution à partir de l'instruction qui suit l'instruction d'appel.
L'algorithme appelant peut communiquer à la procédure des valeurs que celle-ci pourra utiliser dans ses traitements (passage d'arguments par valeurs) ou des noms de variables dans lesquelles la procédure pourra ranger les résultats de ses traitements, de façon à ce que l'appelant puisse récupérer ces résultats (passage d'arguments par référence).

II.8.1.2.FONCTIONNEMENT:

Le schéma suivant représente un algorithme appelant qui effectue deux appels à une procédure:

COMMENTAIRES:

Les instructions de l'algorithme appelant sont exécutées jusqu'à la première instruction d'appel
La première instruction d'appel interromp la séquence d'exécution de l'algorithme appelant et transfère l'exécution vers le début de la procédure.
La procédure est exécutée jusqu'à Fin procédure qui retransfère l'exécution vers l'appelant, juste après l'instruction d'appel.
L'exécution de l'algorithme appelant reprend donc avec l'instruction j et se poursuit jusqu'à la nouvelle instruction d'appel de procédure.
La deuxième instruction d'appel interromp de nouveau la séquence d'exécution de l'algo. appelant et transfère comme précédemment l'exécution vers le début de la procédure.
La procédure est exécutée jusqu'à Fin procédure qui retransfère l'exécution vers l'appelant, juste après l'instruction d'appel.
L'exécution de l'algorithme appelant reprend donc avec l'instruction k, et ainsi de suite....

REMARQUE:

Les procédures sont le plus souvent appelées «SOUS-PROGRAMMES»

II.8.1.3.SCHÉMA DE DÉCLARATION D'UNE PROCÉDURE:

PROCEDURE <Nom de procedure>

(

var <nom argument_1> en <type de donnée> par <valeur/référence>,
var <nom argument_1> en <type de donnée> par <valeur/référence>,
.............................................................,
var <nom argument_1> en <type de donnée> par <valeur/référence>

)

<Déclaration des variables locales>

<instructions de la procedure>

FINPROCEDURE

REMARQUES:
La déclaration d'une procédure comprend non seulement le nom de cette procédure, mais aussi la déclaration des arguments que cette procédure attend de l'appelant. Chaque argument est une variable dont le rôle peut être:

Soit de récupérer une valeur (numérique, alphanumérique, caractère, booléene, etc.) transmise par l'appelant (C'est le passage d'argument par valeur)
Soit de récupérer une référence vers une variable de l'appelant (passage d'argument par référence)

- Dans le premier cas, la procédure ne dispose que d'une valeur qu'elle peut utiliser pour ses traitements internes. Les arguments passés par valeur sont donc uniquement des arguments d'entrée de la procédure.
- Dans le deuxième cas, la procédure peut:

Soit récupérer la valeur contenue dans la variable, comme elle le ferait pour un passage par valeur.
Soit utiliser cette variable pour retourner un résultat à l'appelant.

Les arguments passés par référence sont donc à la fois des arguments d'entrée et de sortie de la procédure.

II.8.1.4.SCHEMA D'APPEL D'UNE PROCÉDURE:

<Nom de procédure> ( <argument 1>, <argument 2>,...,<argument n> )

Les arguments seront libellés dans l'instruction d'appel dans le même ordre que dans l'instruction de déclaration de la procédure. Ils doivent être de même type que dans la déclaration.
Un argument passé en valeur peut être une étiquette de variable ou une valeur (numérique, alphanumérique, caractère, booléenne)
Un argument passé en référence doit être obligatoirement une étiquette de variable (en effet, dans ce cas, ce n'est pas la valeur de la variable qui est passée, mais une «référence» sur cette variable(ce qui correspont à l'adresse de son conteneur).

II.8.1.5.EXEMPLE:

Procédure de comparaison de deux nombres:
compare 2 nombres X et Y et renvoie une chaîne de caractères indiquant le résultat:

PROCEDURE Compare

(

var X en numerique par valeur,
var Y en numerique par valeur,
var R en chaîne de caractères par référence

)

SI X > Y ALORS
R ←''Y est plus grand que X''
SINON
R ←''Y est plus petit ou égal à X''
FINSI

FIN PROCEDURE

Algorithme appelant:

DEBUT

......................................
var PremierNombre, SecondNombre en numerique
var TroisiemeNombre, QuatrièmeNombre en numerique
var Reponse en chaîne de caractères
......................................
......................................
ENTRER PremierNombre, SecondNombre
Compare ( PremierNombre, SecondNombre, Reponse ) // Premier appel à Compare
SORTIR Reponse
......................................
...................................... ENTRER TroisiemeNombre, QuatriemeNombre
Compare ( TroisiemeNombre, QuatriemeNombre, Reponse ) // Deuxième appel à Compare
SORTIR Reponse
......................................

FIN

II.8.1.6.PORTEE DES DECLARATIONS DE DONNEES:

Les données déclarées à l'intérieur d'une procédure (données dites «locales») ne sont utilisables qu'à l'intérieur de cette procédure. Les données déclarées en dehors d'une procédure ne sont pas utilisables par celle-ci. De ce fait, deux données différentes peuvent avoir la même étiquette pourvu qu'elles ne soient pas déclarées dans la même procédure.

REMARQUE:

La plupart des langages informatiques permettent de déclarer certaines données «GLOBALES», c'est à dire utilisables quel que soit l'endroit ou on se trouve. Cependant, cette pratique n'est pas très recommandée, car elle peut favoriser les effets de bord. De ce fait, cette possibilité n'est en général pas donnée dans les langages algorithmiques.

II.8.2.LES FONCTIONS

II.8.2.1.DEFINITION:

Les fonctions sont des procédures conçues pour renvoyer une valeur et une seule.

II.8.2.2.SCHEMA DE DECLARATION D'UNE FONCTION:

FONCTION <Nom de fonction>

(

var <nom arg_1> en <type donnée 1> par valeur|reference,
................................
var <nom arg_n> en <type donnée n> par valeur|reference

) en <Type de la valeur de retour>

<Déclaration des variables locales>

<Bloc d'instructions (corps de la fonction)>

RETOUR <Valeur de retour>

FIN FONCTION

On peut donc associer à chaque fonction un type, qui est le type de la donnée retournée (par l'instruction RETOUR).

II.8.2.3.APPEL D'UNE FONCTION:

Une fonction ayant une valeur de retour et une seule, elle peut être manipulée comme une variable du type de cette valeur de retour:

- Dans une affectation:

Var R en <Même type que la fonction)>
R ← <Nom de fonction> ( Valeur_arg 1,..., Valeur_arg n °)

- Dans une expression (fonction Cos):

SI ( 3*Cos( X ) < 1 ) alors ....

II.8.2.4.EXEMPLE:

//-----------------------------------------------------------------------------
// FONCTION CompareDeuxNombres
//-----------------------------------------------------------------------------
// PRINCIPE:
// Fonction de comparaison de deux nombres: compare 2 nombres X et Y
// et renvoie une chaîne de caractères indiquant le résultat
// La fonction réalise le même traitement que la procédure du sous-chapitre
// précédent, mais le résultat est passé dans la valeur de retour de la
// fonction au lieu d'être passé par référence).
//-----------------------------------------------------------------------------
// DONNEES D'ENTREE:
// X: Valeur du premier nombre
// Y: Valeur du second nombre
//----------------------------------------------------------------------------- // DONNEE DE SORTIE:
// Chaîne de caractère indiquant le résultat
//-----------------------------------------------------------------------------

FONCTION CompareDeuxNombres ( var X en numerique par valeur, var Y en numerique par valeur )

SI X > Y ALORS
RETOUR ''Y est plus grand que X''
SINON
RETOUR ''Y est plus petit ou égal à X''
FINSI

FIN FONCTION

//-----------------------------------------------------------------------------
// Algorithme appelant:
//-----------------------------------------------------------------------------

DEBUT

......................................
var PremierNombre, SecondNombre en numerique
var TroisiemeNombre, QuatrièmeNombre en numerique
var Reponse en chaîne de caractères
......................................
ENTRER PremierNombre, SecondNombre
Reponse = CompareDeuxNombres ( PremierNombre, SecondNombre )
SORTIR Reponse
......................................
......................................
ENTRER TroisiemeNombre, QuatriemeNombre
Reponse = Compare ( TroisiemeNombre, QuatriemeNombre )
SORTIR Reponse
......................................

FIN

Chapitre précédent. Evaluation. Chapitre suivant.