Cours d'algorithmique

 

Par NDJO'O Pierre Anicet, IPR/INFO/OUEST

Tel: (+237) 77 97 01 25

 

 

Chapitre 1 : Utiliser les notions élémentaires de l’algorithmique

(12 heures en 1^ère A, C, D) et (10 heures en 1^ère TI)

Objectifs du cours : Il s'agit pour l'élève d'utiliser les structures algorithmiques de base.

 

I-                   Définitions :

Algorithme : est une séquence d’opérations visant la résolution d’un problème en un temps fini. L'algorithme est un moyen pour le programmeur de présenter son approche du problème à d'autres personnes.

Un langage d’expression : est un système de signes permettant l'expression et la communication de la pensée.

En général, tout moyen d'expression, de communication, d'instruction au moyen de signes:

Langage formel: langage qui utilise un ensemble de termes et de règles syntaxiques pour permettre de communiquer sans aucune ambiguïté.

Fonction : ensemble d’ordre accomplissant une tâche précise. Elle peut prendre des arguments et renvoie en général un résultat.

Procédure : est une fonction ne renvoyant pas de résultat.

 

II-                 Étapes et structure d’un algorithme

a)      Étapes

Dresser un algorithme c’est  fournir la solution à un problème, la première étape consiste donc à analyser le problème, c'est-à-dire en cerner les limites et le mettre en forme dans un langage descriptif.

Le langage de description utilisé pour écrire le résultat de l'analyse est appelé algorithme.

L'étape suivante consiste à traduire l'algorithme dans un langage de programmation spécifique, il s'agit :

-  de la phase de programmation : Le langage de programmation est l'intermédiaire entre l'humain et la machine.

-  Le programme est ensuite transformé en langage machine lors d'une étape appelée compilation. La compilation est une phase réalisée par l'ordinateur lui-même grâce à un autre programme appelé compilateur.

-          Caractéristiques d'un algorithme

Un algorithme doit  être :

• lisible: l'algorithme doit être compréhensible même par un non-informaticien
• de haut niveau: l'algorithme doit pouvoir être traduit en n'importe quel langage de programmation, il ne doit donc pas faire appel à des notions techniques relatives à un programme particulier ou bien à un système d'exploitation donné
• précis: chaque élément de l'algorithme ne doit pas porter à confusion, il est donc important de lever toute ambiguïté
• concis: un algorithme ne doit pas dépasser une page. Si c'est le cas, il faut décomposer le problème en plusieurs sous-problèmes
• structuré: un algorithme doit être composé de différentes parties facilement identifiables

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 de variables

·         La lecture / écriture

·         Les tests

·         Les boucles

         On utilisera généralement une série de conventions appelée « pseudo-code », qui ressemble à un langage de programmation authentique dont on aurait évacué la plupart des problèmes de syntaxe.

-          Structure

Un algorithme a les parties suivantes :

-          Le titre de l’algorithme ;

-          Les déclarations ;

-          Les instructions.

• Le titre d’un algorithme est le nom que vous donnez à celui-ci.
• La première chose à faire avant de pouvoir utiliser une variable est de la créer. Ceci se fait tout au début de l’algorithme, avant même les instructions proprement dites. C’est ce qu’on appelle la déclaration des variables.

Toutefois, une règle absolue est qu’un nom de variable peut comporter des lettres et des chiffres, mais qu’il exclut la plupart des signes de ponctuation, en particulier les espaces. Un nom de variable correct commence également impérativement par une lettre.

 

 

Schéma de la structure :

Programme nom_programme

Const

      Liste des constantes

Var

      Liste des variables

Debut

      Corps de l'algorithme

Fin

Exemple1 : d’algorithme

Programme affectationTI1

      x = 5;  y = 7;

      z , t : entier; 

Debut

    z ←  x + 8;

    t ←  z  + y;

    ecrire ( t ); 

Fin

III- Types de variable

1)   Types numériques classiques

Commençons par le cas très fréquent, celui d’une variable destinée à recevoir des nombres.

 

 

 

Exemple de déclaration de variable en pseudo-code.

Var G : entier ;                      (Variable G du type entier)

Var H: entier ;
Ou encore
Var G, H : entier ;

Certains langages autorisent d’autres types numériques, notamment :
·         le type monétaire ,   le type date (jour / mois / année).

2) Type alphanumérique
On dispose donc également du type alphanumérique (également appelé type caractère ou type chaîne ou en anglais, le type string.
Dans une variable de ce type, on stocke des caractères, qu’il s’agisse de lettres, de signes de ponctuation, d’espaces, ou même des chiffres.

Remarque : En pseudo-code, une chaîne de caractères est toujours notée entre guillemets.  Ainsi : "423" est une suite de caractères ou chaine de caractères alors que 423 est un nombre.

3)  Type booléen
le type booléen est un type logique  stockant  uniquement les valeurs logiques VRAI et FAUX.  On peut représenter ces notions abstraites de VRAI et de FAUX par tout ce qu'on veut : de l'anglais (TRUE et FALSE) ou des nombres (0 et 1). Peu importe. Ce qui compte, c'est de comprendre que le type booléen est très économique en termes de place mémoire occupée, puisque pour stocker une telle information binaire, un seul bit suffit.

4) Type tableau :

   Imaginons que dans un programme, nous ayons besoin simultanément de 10 valeurs (par exemple, les notes d’un élève pour calculer sa moyenne). Évidemment, la seule solution dont nous disposons à l’heure actuelle consiste à déclarer dix variables, appelées par exemple Note1, Note2, Note3, etc.

Dans notre exemple, nous créerons donc un tableau appelé Note. Chaque note individuelle (chaque élément du tableau Note) sera donc désignée Note(0), Note(1), etc.

Attention, les indices des tableaux commencent généralement à 0, et non à 1.  Dans le cas présent, les indices du tableau vont de 0 à 9.
Un tableau doit être déclaré comme tel, en précisant le plus grand indice et le type de valeurs qu’il contiendra.

Syntaxe : Tableau Note(9) : Entier ;

Pour dire qu’il s’agit de la déclaration d’un tableau à 10 cases.

 

 

IV- L’instruction d’affectation

Syntaxe et signification   En pseudo-code, l'instruction d'affectation se note avec le signe ←

Ainsi : attribuer la valeur 24 à la variable Toto se note : A ← 24 ;

Ceci, soit dit en passant,  que A  est une variable de type numérique.
On peut en revanche sans aucun problème attribuer à une variable la valeur d’une autre variable, telle quelle ou modifiée.

Exemple : T← H   Signifie que la valeur de H est maintenant celle de T.
Remarque : Notez bien que cette instruction n’a en rien modifié la valeur de H : une instruction d’affectation ne modifie que ce qui est situé à gauche de la flèche.
L’instruction  Tutu ← Toto + 4  signifie que Si Toto contenait  la valeur 24, alors Tutu  vaut maintenant 28.

 De même que précédemment, Toto vaut toujours 24. Tutu ← Tutu + 1 Si Tutu valait 28, il vaut maintenant 29. La valeur de Tutu est modifiée, puisque Tutu est la variable située à gauche de la flèche.
Pour revenir à présent sur le rôle des guillemets, comparons   les deux algorithmes suivants :

Exemple n°1                                                    Exemple n°2
Debut                                                          Debut
     Riri ← "Loulou" ;                                      Riri ← "Loulou" ;
     Fifi ← "Riri" ;                                             Fifi ← Riri ;
Fin                                                                Fin

La seule différence entre les deux algorithmes consiste dans la présence ou dans l’absence des guillemets lors de la seconde affectation. Et l'on voit que cela change tout ! 

Dans l'exemple n°1, ce que l'on affecte à la variable Fifi, c'est la suite de caractères  R – i – r - i. Et à la fin de l’algorithme, le contenu de la variable Fifi est donc la chaine de caractères : « Riri ».
Dans l'exemple n°2, en revanche, Riri étant dépourvu de guillemets, n'est pas considéré comme une suite de caractères, mais comme un nom de variable. Le sens de la ligne devient donc : « affecte à la variable Fifi le contenu de la variable Riri ». A la fin de l’algorithme n°2, la valeur de la variable Fifi est  la chaine  « Loulou ».  Ici, l’oubli des guillemets conduit certes à un résultat,  mais à un résultat différent.

b)      Ordre des instructions

Il va de soi que l’ordre dans lequel les instructions sont écrites va jouer un rôle essentiel dans le résultat final. Considérons les deux algorithmes suivants :

Var A : Entier ;                     Var A : Entier ;
Debut                                    Debut
  A ← 34 ;                                             A ← 12 ;
  A ← 12 ;                                            A ← 34 ;
Fin                                        Fin

Il est clair que dans le premier cas la valeur finale de A est 12, dans l’autre elle est 34 .
Enfin, il est également clair que si l’on met de côté leur vertu pédagogique, les deux algorithmes ci-dessus sont parfaitement idiots ; 

Tous les éléments sont maintenant en votre possession pour que ce soit à vous de jouer !

Exercice1.1 : Quelles seront les valeurs des variables A et B après exécution des instructions suivantes ?

Var A, B : Entier ;
Debut
  A ← 1 ;
  B ← A + 3 ;
  A ← 3 ;
Fin

 

Exercice1.2 : Quelles seront les valeurs des variables A, B et C après exécution des instructions suivantes ?
Var A, B, C : Entier ;
Debut
    A ← 5 ;
    B ← 3 ;
    C ← A + B ;
    A ← 2 ;
    C ← B – A ;
Fin

Exercice1.3 : Quelles seront les valeurs des variables A et B après exécution des instructions suivantes ?
Var  A, B : Entier ;
Début
    A ← 5 ;   B ← A + 4 ;
   A ← A + 1 ;  B ← A – 4 ;
Fin

 

Exercice1.4: Quelles seront les valeurs des variables A et B après exécution des instructions suivantes ?
Var A, B : Entier ;
Debut
  A ← 5 ;
  B ← 2 ;
  A ← B ;
  B ← A ;
Fin

Moralité : les deux dernières instructions permettent-elles d’échanger les deux valeurs de B et A ? Si l’on inverse les deux dernières instructions, cela change-t-il quelque chose ?

Correction :

Après exécution on a :
  A ← 5 ;           A = 5     B = ?
  B ← 2 ;           A = 5     B = 2
  A ← B ;           A = 2     B = 2
  B ← A ;           A = 2    B = 2

Les deux dernières instructions ne permettent donc pas d’échanger les deux valeurs de B et A, puisque l’une des deux valeurs (celle de A) est ici écrasée.
Si l’on inverse les deux dernières instructions, cela ne changera rien du tout, hormis le fait que cette fois c’est la valeur de B qui sera écrasée.

 

Exercice 1.5 Plus difficile, mais c’est un classique absolu, qu’il faut absolument maîtriser : écrire un algorithme permettant d’échanger les valeurs de deux variables A et B, et ce quel que soit leur contenu préalable.

Solution :

Début
  …
  C ← A ;
  A ← B ;
  B ← C ;
Fin
On est obligé de passer par une variable dite temporaire (la variable C).

 

Exercice1.6 : Donner l’algorithme qui demande les dix notes d’un élève et calcule la moyenne de ces notes (déclarer les notes dans un tableau).

Solution

Tableau Note(9) :Entier ;
   Variables i, Som : Entier ;
   Variable Moy :Réel ;
       Pour i ← 0 à 9
       Ecrire (“Entrez la note n°”, i) ;
       Lire Note(i) ;
          i ← i+1 ;
          Som ← 0 ;
      Pour i ← 0 à 9
      Som = Som + Note(i) ;
          i ← i+1 ;
         Moy = Som / 12 ;

 

c)       Expressions et opérateurs

Une expression est un ensemble de valeurs, reliées par des opérateurs, et équivalent à une seule valeur. Exemple :  123 + 45 ;  Toto-12+5-Riri ; sont des expressions à la condition que Toto et Riri soient des nombres.

Un opérateur est un signe qui relie deux valeurs, pour produire un résultat.

Opérateurs numériques :
Ce sont les quatre opérations arithmétiques :
+            addition
-             soustraction
*             multiplication

%            modulo   (x % y «reste de la division de x par y)
/            division

Mentionnons également le ^ qui signifie « puissance ». 45 au carré s’écrira donc 45 ^ 2.
Enfin, on a le droit d’utiliser les parenthèses, avec les mêmes règles qu’en mathématiques. La multiplication et la division ont « naturellement » priorité sur l’addition et la soustraction. Les parenthèses ne sont ainsi utiles que pour modifier cette priorité naturelle.

Cela signifie qu’en informatique, 12 * 3 + 5 et (12 * 3) + 5 valent strictement la même chose, à savoir 41. Pourquoi dès lors se fatiguer à mettre des parenthèses inutiles ?

Opérateur  alphanumérique  &:
cet opérateur  permet de concaténer, autrement dit d’agglomérer, deux chaînes de caractères.
 Attention : dans la suite char désigne le caractère et chaine : la chaine de caractère.

Exemple
Var A, B, C : Chaine ;
Debut
  A ← “Gloubi” ;
  B ← “Boulga” ;
  C ← A & B ;
Fin
La valeur de C à la fin de l’algorithme est “GloubiBoulga”

Exercice 1.6 : Que produit l’algorithme suivant ?
Var A, B, C : Char ;
Debut
   A ← “423“ ;
   B ← “12” ;
   C ← A + B ;
Fin

d)      Opérateurs logiques (ou booléens) :

Il s’agit du ET, du OU, du NON et du  XOR.

Exemple :

Var A, B, C booleens;
 Debut
       A ←  B ou C ;
       B ←   A et B ;
       C ← A  xor B ;
Fin

Les variables A, B et C ont chacune l’une des valeurs 1 ou 0 (vrai ou faux). Dire que :    A ←  B ou C ; signifie que A prend la valeur 1 si l’une des variables B et C a une valeur 1 ;   B ←   A et B ; signifie que B prend la valeur 1  si les variables A et B ont chacune la valeur 1 ; C ← A  xor B; signifie que C prend la valeur 1 si exclusivement A ou B a la valeur 1.

Remarque :  

a)      En mathématiques, une « variable » est généralement une inconnue, qui recouvre un nombre non précisé de valeurs. Lorsque j’écris : y = 3 x + 2 les « variables » x et y satisfaisant à l’équation existent en nombre infini (graphiquement, l’ensemble des solutions à cette équation dessine une droite).  En informatique, une variable possède à un moment donné une valeur et une seule. A la rigueur, elle peut ne pas avoir de valeur du tout (une fois qu’elle a été déclarée, et tant qu’on ne l’a pas affectée.

V- Les instructions de lecture et d’écriture

Tout bêtement, pour que l’utilisateur entre la (nouvelle) valeur de le variable Titi dans le programme, on mettra :    Lire (Titi );

Dès que le programme rencontre une instruction Lire, l’exécution s’interrompt, attendant la frappe d’une valeur au clavier. Dès lors, aussitôt que la touche Entrée (Enter) a été frappée, l’exécution reprend. Avant de Lire une variable, il est très fortement conseillé d’écrire des libellés à l’écran, afin de prévenir l’utilisateur de ce qu’il doit frapper (sinon, le pauvre utilisateur passe son temps à se demander ce que l’ordinateur attend de lui).

Ecrire (“Entrez votre nom : ”) ;
 Lire (NomFamille) ;
Dans le sens inverse, pour écrire quelque chose à l’écran, c’est aussi simple que :   Ecrire (Toto) ;

Exercice 1.8 : Écrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et  affiche le carré de ce nombre.

VI- Les structures de contrôle.

a)      Les tests

Il n’y a que deux formes possibles pour un test ; la forme  complète et  la forme simple. Le test se fait avec le mot si avec la syntaxe suivante :

Pour un test complet :

                            Si (conditions vraies) Alors 
                                  {  Instructions1 ; }
                            Sinon

                                  {  Instructions 2 ;}
                             Finsi

Pour un test simple :

                    Si (conditions vraies)  Alors
                        { Instructions ; }
                    Finsi

 

 

 

Organigramme de la structure si :

 

Une condition est une comparaison.  Elle est composée de trois éléments :

une valeur

un opérateur de comparaison

une autre valeur

Les valeurs peuvent être a priori de n’importe quel type (numériques, caractères…). Mais si l’on veut que la comparaison ait un sens, il faut que les deux valeurs de la comparaison soient du même type !

Les opérateurs de comparaison sont:  

    =   égal à…               <>    différent de…            <    strictement plus petit que…  

    >   strictement plus grand que…                      =<    plus petit ou égal à…  

   >=        plus grand ou égal à…

 

Exemple de test :

   var a, b entier;

   Debut

            a ← 20 ;  b ← 30;

             Si   (a > b)     Alors  {a ← b ;}

             Sinon  {b ← a ;}

             Finsi

             Ecrire (a, b) ;

  Fin

e)      Structure de test multiple : au cas où ….

La structure Si (...) Alors {...} Sinon {...} permet de réaliser un choix parmi deux possibilités. Il est possible d’imbriquer les Si (...) Alors {...} Sinon {...} les uns dans les autres pour tenir compte de choix plus nombreux. Mais la structure devient très lourde à écrire et à lire quand le nombre de cas augmente. On lui préférera alors la structure de tests multiples, qui permet de comparer une variable  à toute une série de valeurs.

Le code compilé par une suite de si ou un Au cas où n'est pas le même. Celui du Au cas où est plus optimisé. 

Syntaxe :

Var C, C1, C2, C3: entier;

Debut

  au cas où C vaut

      C1: Instruction1;

      C2: Instruction2;

      C3: Instruction3;

  Sinon Instruction4;

Fin

 

Organigramme de la structure au cas où :

 

 

 

 

Exemple :

Programme mention

Const C1=20; C2=10; C3=5;

Var C: entier;

Debut

  au cas où C vaut

  C1:  ecrire(²Bien²);

  C2: ecrire(²passable);

  C3: ecrire(²faible²);

 sinon  ecrire(²pas d’avis²);

Fin

 

f)       La boucle  tant que ….. faire

Cette itération a pour syntaxe :

TANT QUE ( condition est vraie ) FAIRE

      {  Bloc d'instructions}

fintantque

Exemple :

Programme tanque_faire

Var x:entier; 

Debut      

         x ← 10

         Tant que ( x > 0)  Faire

         {  x ← x – 3;

            Ecrire (x);  }

         Fintantque

Fin

Organigramme de la structure tantque

 

 

 

 

g)      La boucle repeter tant que :

Cette itération a pour syntaxe :

Repeter

        Bloc d’instructions

TANT QUE (condition est vraie)

FinRepeter

Organigramme de la boucle repeter tant que :

 

La boucle Repter … tant que équivaut à do ….  While

Alors que la boucle tant que …. Faire  Équivaut à while …. Do

Remarque : Le test se fait après le bloc d'instructions pour la boucle repeter … tant que, celui-ci est exécuté au moins une fois.

Par contre le test est d’abord réalisé pour la boucle tant que … faire avant l’exécution. Celle-ci peut ne pas avoir lieu.

 

h)      Boucle  pour …..  faire

Syntaxe :

POUR (initialisation ; condition de continuité vraie ; modification)

   {

Faire  bloc d'instructions

    }

FinPour

 

Exemple 1: donner les résultats que produit cet algorithme

             n ← 4 ;   a ← 0 ;

Pour  (i  allant  de  1  à  n)  Faire

   { Lire (x);                  (on lira 1, 4, 6, 9)

       a ← a + x;

       Ecrire (a);   }

FinPour

 

Exemple 2: donner les résultats que produit cet algorithme

n ← 4;  a ← 0;

Pour  i  allant  de  1  à  n  Faire

   Lire (x);   (on lira 1, 4, 6, 9)

   Si (x  >  5)

   Alors  a ← a + x ;

   Fsi

    Ecrire (a);

FinPour

 

Organigramme de la boucle pour

 

 

 

Exercices :

-  Un démarcheur à domicile est rémunéré avec un salaire fixe de 3000 frs par mois. Il perçoit aussi une commission qui représente 5% du montant des ventes qu'il a réalisé. Le salaire ainsi obtenu est également augmenté de 10 % pour prendre en compte ses frais de déplacement. Écrire un algorithme qui calcule son salaire étant donné le montant des ventes réalisé.

-  Transformer l’algorithme précédent afin qu’il s’applique à un certain nombre de vendeurs.

-  Écrire un algorithme qui affecte et permute la valeur de deux variables.

-  Écrire un algorithme qui affecte et permute la valeur de trois variables.

- Exécuter les algorithmes partiels suivants et déterminer les valeurs qui seront affichées à l'écran :

 

i)         

 

j)         

 

VII- Procédures et fonctions

k)      Fonctions

Les fonctions sont des sous-programmes admettant des paramètres et retournant un seul résultat.

Exemple la fonction mathématique :  z=f(x,y) les paramètres sont dans ce cas x et y.

Une  fonction possède un seul type, qui est le type de la valeur retournée. Le  passage de paramètre est uniquement en entrée : c'est pour cela qu'il n'est pas précisé lors de l'appel, on peut donc utiliser comme paramètre des variables, des constantes mais aussi des résultats de fonctions. La  valeur de retour est spécifiée par l'instruction retourner (ou return).

Déclaration d’une fonction :

fonction nom_de_la_fonction (paramètre(s) de la fonction) : type de la valeur retournée ;

Déclaration variable locale 1 : type 1; . . ….

debut

   instructions de la fonction avec au moins une fois l'instruction   

   retourner

fin

 

 

Exemple de déclaration de la  fonction valeur absolue :

fonction abs (x : Entier) : Entier ;

debut

   si x >= 0 alors

       retourner x ;

   sinon

        retourner –x ;

   finSi

Fin             

Exemple de programme avec appel  de  fonction :

Programme valeur_positive

Var a , b : Entier ;

fonction abs (x : Entier) : entier ;

  var y : entier ;                (y est une variable dite locale)

debut

   si (x >= 0) alors

      { y ← x ;}

  sinon

      {y ←  -x ; }

  finSi

retourner y ;

Fin

debut

ecrire("Entrez un entier :")

   lire(a) ;

  b ← abs(a) ;

ecrire("la valeur absolue de ",a," est ",b) ;

Fin

Exemple2 de fonction

fonction  max( valeur a,b: reel) : reel;

    var m : reel ;

debut

    si (a > b)

    alors

       m <- a ;

   sinon

     m <- b ;

  fin si

   retourner m ;

fin

 

l’expression : max(pi()*pi()  , 10) vaut 10.

 

Autre exemple de fonction.

fonction minimum2 (a, b : Entier) : Entier ;

debut

     si a> b alors

         retourner b ;

     sinon

         retourner a ;

      Finsi

 Fin

 

fonction minimum3 (valeur a,b,c : Entier) : Entier ;

debut

   retourner minimum2(a,minimum2(b,c)) ;

Fin

Exemple d’une fonction n’ayant pas de paramètres :

fonction pi(): reel ;

debut

   retourner 3.1415926535897931 ;

fin

Remarque: on définit une fonction avec des paramètres et on l’appelle avec des arguments.

l)        procédure

Les procédures sont des sous-programmes qui ne retournent aucun résultat. Chaque procédure aura:

1. Une définition qui dit

                 - Le type des paramètres.

                 -  comment on la calcule.

1. Un ou plusieurs appels: c'est l'utilisation de la procédure.

 

Syntaxe d’une procédure

On déclare une procédure de la façon suivante :

procédure nom_de_la_procédure ( E paramètre(s) en entrée;  S paramètre(s) en sortie;  E/S paramètre(s) en entrée/sortie )

    Déclaration variable(s) locale(s)

debut

      instructions de la procédure

Fin

Et on appelle une procédure comme une fonction, en indiquant son nom suivi des arguments entre parenthèses.

 

Exemple de déclaration d’une procédure :

procédure calculerMinMax3 ( E a,b,c : Entier ; S m,M : Entier ) ;

debut

    m ←minimum3(a,b,c)

    M ←maximum3(a,b,c)

Fin

 

Programme complet avec procédure et appel de procédure :

Programme echangez

Var  a : entier, b : entier ;

procédure echanger ( E/S val1 Entier; E/S val2 Entier;)

  var  temp : Entier

debut

temp ← val1 ;

val1  ←val2 ;

val2  ← temp ;

Fin

debut

   ecrire("Entrez deux entiers :") ;

   lire(a,b) ;

   echanger(a,b) ;

  ecrire("a=",a," et b = ",b) ;

Fin

Création d’une fonction dans le cas des questions à réponse : oui ou non.

…
Ecrire “Etes-vous marié ?”
Rep1 ← ""
TantQue Rep1 <> "Oui" et Rep1 <> "Non"
    Ecrire "Tapez Oui ou Non"
    Lire Rep1
FinTantQue
…
Ecrire “Avez-vous des enfants ?”
Rep2 ← ""
TantQue Rep2 <> "Oui" et Rep2 <> "Non"
    Ecrire "Tapez Oui ou Non"
    Lire Rep2
FinTantQue

On le voit bien, il y a là une répétition quasi identique du traitement à accomplir. A chaque fois, on demande une réponse par Oui ou Non, avec contrôle de saisie. La seule chose qui change, c'est le nom de la variable dans laquelle on range la réponse. Alors, il doit bien y avoir un truc.
La solution consiste à isoler les instructions demandant une réponse par Oui ou Non, et à appeler ces instructions à chaque fois que nécessaire. Ainsi, on évite les répétitions inutiles, et on a découpé notre problème en petits morceaux autonomes.
Nous allons donc créer une fonction dont le rôle sera de renvoyer la réponse (oui ou non) de l'utilisateur.
 

Fonction RepOuiNon() en caractère
Truc ← ""
TantQue Truc <> "Oui" et Truc <> "Non"
    Ecrire "Tapez Oui ou Non"
    Lire Truc
FinTantQue
Renvoyer Truc
Fin Fonction

On remarque au passage l’apparition d’un nouveau mot-clé : Renvoyer, qui indique quelle valeur doit prendre la fonction lorsqu'elle est utilisée par le programme. Cette valeur renvoyée par la fonction (ici, la valeur de la variable Truc) est en quelque sorte contenue dans le nom de la fonction lui-même, exactement comme c’était le cas dans les fonctions prédéfinies.

Une fonction s'écrit toujours en-dehors de la procédure principale. Selon les langages, cela peut prendre différentes formes. Mais ce qu'il faut comprendre, c'est que ces quelques lignes de codes sont en quelque sorte des satellites, qui existent en dehors du traitement lui-même. Simplement, elles sont à sa disposition, et il pourra y faire appel chaque fois que nécessaire. Si l'on reprend notre exemple, une fois notre fonction RepOuiNon écrite, le programme principal comprendra les lignes :

…
Ecrire “Etes-vous marié ?”
Rep1 ← RepOuiNon()
…
Ecrire “Avez-vous des enfants ?”
Rep2 ← RepOuiNon()
…

Et le tour est joué ! On a ainsi évité les répétitions inutiles, et si d'aventure, il y avait un bug dans notre contrôle de saisie, il suffirait de faire une seule correction dans la fonction RepOuiNon pour que ce bug soit éliminé de toute l'application.

La fonction sera dorénavant déclarée comme suit :
 

Fonction RepOuiNon(Msg  Chaine) en Chaine ;
Ecrire Msg
Truc ← ""
TantQue Truc <> "Oui" et Truc <> "Non"
    Ecrire ("Tapez Oui ou Non") ;
    Lire (Truc) ;
FinTantQue
    Renvoyer Truc ;
Fin Fonction

Il y a donc maintenant entre les parenthèses une variable, Msg, dont on précise le type, et qui signale à la fonction qu’un argument doit lui être envoyé à chaque appel. Quant à ces appels, justement, ils se simplifieront encore dans la procédure principale, pour devenir :

…
Rep1 ← RepOuiNon(“Etes-vous marié ?”)
…
Rep2 ← RepOuiNon(“Avez-vous des enfants ?”)
…

Et voilà le travail.
Une remarque importante : là, on n'a passé qu’un seul argument en entrée. Mais bien entendu, on peut en passer autant qu’on veut, et créer des fonctions avec deux, trois, quatre  arguments ; Simplement, il faut éviter d'être gourmands, et il suffit de passer ce dont on en a besoin, ni plus, ni moins !
Imaginons qu'à plusieurs reprises au cours du programme, on ait à calculer la moyenne des éléments de différents tableaux. Plutôt que répéter le code à chaque fois, on va donc créer une fonction Moy, chargée spécialement de calculer cette moyenne. Cette fonction a besoin :

- du tableau, bien sûr. Comment calculer la moyenne de ses éléments sans cela ?

- mais il faut également le nombre d'éléments du tableau, ou, au choix, l'indice maximal du tableau. Enfin,  quelque chose qui permette à la fonction de savoir combien de tours de boucle elle devra faire.
Voilà donc une situation où la fonction a absolument besoin de deux arguments. Ecrivons-la, juste histoire de vérifier qu'on est bien d'accord :

Fonction Moy(T  tableau numérique, n  entier) :Numérique ;
  var som :entier ;    

  Som ← 0 ;
    Pour i ← 0 à n-1 faire
          Som ← Som + T(i) ;
          i← i+1 ;
         m ← som / n
         Renvoyer m
    Fin Fonction

Quant aux différents appels dans la procédure principale, si j'ai un tableau Riri de 43 éléments, un tableau Fifi de 5 éléments et un tableau Loulou de k éléments, et que je range respectivement les moyennes dans les variables M1, M2 et M3, cela donnera :
 

M1 ← Moy ( Riri, 43) ;
M2 ← Moy ( Fifi, 5) ;

M3 ← Moy ( loulou, k) ;

En fait, tout cela, c'est simple comme bonjour... Le plus important, c'est d'acquérir le réflexe de constituer systématiquement les fonctions adéquates quand on doit traiter un problème donné.

Cette partie de la réflexion s'appelle d'ailleurs l'analyse fonctionnelle d'un problème, et c'est toujours par là qu'il faut commencer : en gros, dans un premier temps, on découpe le traitement en modules, et dans un deuxième temps, on écrit chaque module. Cependant, avant d'en venir là, il nous faut découvrir un dernier outil, qui prend le relais là où les fonctions deviennent incapables de nous aider.

VIII- La récursivité :

Un algorithme récursif est simplement un algorithme qui s'appelle lui-même. Il se caractérise par :

-  une ou plusieurs conditions d'arrêt, pour traiter les cas de base,

-  un ou plusieurs appels récursifs, qui permettent de résoudre le problème à traiter à partir d'appels sur des arguments plus petits.

Pour que l'algorithme termine, il faut veiller à ce que la suite des appels récursifs conduise toujours à un cas de base, géré par une condition d'arrêt.

Exemple : Écrivez une fonction récursive qui calcule la factorielle d'un entier.

Fonction facto(N :entier) :entier ;

   Debut

      Si (N=0 ou N=1) alors

           retourner  1 ;

      Sinon

          retourner N*facto(N-1) ;

   Fin

Une autre fonction récursive :

function Fibonacci(N: entier;) entier;

debut

    si ( N<=1) alors

      return N;

   sinon

   return Fibonacci(N-1)+Fibonacci(N-2);

finsi;

finFibonacci;

 

 

NDJO'O  Pierre Anicet, IPR/INFO/OUEST

Tel: (+237) 77 97 01 25