Skip to content

Algorithmique :

Introduction :

Définition d'un programme :

Définition de Wikipédia :

Un programme informatique est une liste d'ordres indiquant à un ordinateur ce qu'il doit faire. Il se présente sous la forme d'une ou plusieurs séquences d'instructions, comportant souvent des données de base, devant être exécutées dans un certain ordre par un processeur ou par processus informatique (cas des systèmes multitâches).[...]

À l'origine d'un programme, il y a un code source écrit par un programmeur dans un langage de programmation compréhensible par le dit programmeur.

Définition d'un algorithme :

Définition de Wikipédia :

Un algorithme est un moyen pour un humain de présenter la résolution par calcul d'un problème à une autre personne physique (un autre humain) ou virtuelle (un calculateur). En effet, un algorithme est un énoncé dans un langage bien défini d'une suite d'opérations.

Exemple de programme

programme Voyage_en_bus
début
    Je me rend à l'arrêt de Bus
    J'attend le bus qui va dans la direction où je souhaite aller
    Je monte dans le bus
    Je m'assieds à une place
    J'attend l'arrêt souhaité
    Je me lève
    Je sors du Bus
fin

Le programme a un nom explicite, un début et une fin définis, il exécute des actions dont l'ordre a une importance, il manipule des objets. Un algorithme est une suite d'actions ordonées en séquence qui portent sur des objets d'un univers fini.

Compilation / Interprétation :

Selon le langage dans lequel on écrit le script, le code est soit compilé soit interpreté :

Un programme compilé va être traduit une fois pour toutes par le compilateur afin de générer un ficher exécutable (binaire) autonome. Il n'aura plus besoin de quoi que ce soit pour être exécuté.

Un programme interprété est un code source qui a besoin d'un interprêteur pour être compréhensible par le processeur. L'interprêteur traduit le code ligne par ligne, s'il y a une erreur, l'interprétation s'arrête.

Avantages / Inconvénients :

L'avantage du programme compilé est que l'on peut voir les erreurs les plus graves dès la compilation, d'autre part, une fois dans un fichier binaire (ou exécutable) il est plus rapide car il n'a pas à être traduit, il n'a pas besoin de programme annexe pour être utilisé. Enfin, une fois en fichier binaire, le code source est plus sécurisé car il n'est pas lisible : On ne peut pas revenir en arrière (partir du fichier exécutable pour arriver au code source).

L'avantage du langage interprété est qu'il suffit d'avoir le logiciel qui interprète le langage pour l'exécuter. Par contre, il se pose des problème de versions de l'interpréteur et de lenteur.

Pour finir, certains langages se trouvent à l'intersection des deux : les langages intermédiaires. Ils sont compilés mais les fichiers résultants ont tout de même besoin d'être interprétés.

Principaux langages compilés :

  • C, C++, Cobol, Fortran, Pascal, ...

Intermédiaires :

  • Java, Python, LISP, ...

Interprétés :

  • Javascript, XML, Basic, Perl, PHP, ...

I- Variables / Constantes :

Le traitement d'un objet par un programme concerne la valeur de cet objet. Si cette valeur n'est pas censée changer, c'est une constante, sinon c'est une variable.

Exemples de constantes :

TVA c'est 19,6
année_en_cours c'est 2019
note_maxi c'est 20

On note le nom de l'objet à gauche et sa valeur à droite. Si un jour la TVA passe à 20,6 %, il n'y aura qu'à changer la valeur par 20,6 et le programme n'aura pas à être changé. Idem pour 2005 remplacé par 2006.

Exemples de variables :

nom, prénom : chaînes de caractères
age : entier
note : réel
existe : booléen
nom <- "Dupont"
prénom <- "Jean"
age <- 40
note <- 12,5
existe <- .faux.

Exemple de programme utilisant des variables

Programme Voyage en bus
// Temps en minutes    
Temps : entier                                                       
Début                                                                
    Temps <- 0                                                      
    Je me rends à l'arrêt de bus                                        
    Temps <- 7                                                      
    J'attend le bus                                                     
    Temps <- 10                                                     
    Je monte dans le bus                                                 
    Je m'assieds à une place                                            
    J'attend l'arrêt                                                   
    Temps <- 32                                                     
    Je me lève                                                           
    Je sors du bus                                                       
Fin

II- Types et opérateurs :

Les variables peuvent être de différents types :

Booléens :

Ne peut prendre que 2 valeurs : soit .vrai., soit .faux.

Les opérations que l'on peut faire sont elles aussi booléenes, on utilise trois opérateurs :

ET (et logique) : OU (ou logique) : PAS (ou NON) :
Vrai et Vrai = Vrai Vrai ou Vrai = Vrai Pas Vrai = Faux
Vrai et Faux = Faux Vrai ou Faux = Vrai Pas Faux = Vrai
Faux et Vrai = Faux Faux ou Vrai = Vrai
Faux et Faux = Faux Faux ou Faux = Faux

Numériques :

Ils peuvent être entiers ou réels. On peut faire des opérations avec les opérateurs suivants :

  • +
  • -
  • *
  • /
  • ^ : élévation à la puissance (ex : 5^2 => 5² => 25)
  • DIV : division entière (ex : 5 DIV 2 => 2)
  • MOD (ou modulo) : le reste de la division (ex : 11 DIV 8 => 3)
  • ENT : la partie entière d'un réel (8,5 ENT => 8)

Caractères et chaînes de caractères :

Un caractère est lié à un code numérique (par exemple le code ASCII) qui l'associe à une valeur numérique pour être ensuite codée en binaire.

On représente un caractère ou une chaîne de caractères entre des guillemets, par exemple :

"un texte"

Le code numérique comprend une relation d'ordre :

"A" < "B"

"ABC" < "B"

Pour faire des opérations sur les chaînes de caractères, on utilise des fonctions ou des procédures spécifiques à chaque langage. D'une manière générale, on retrouve toujours :

Concaténation (&)

Pour placer une chaîne de caractères à la suite d'une autre, vous pouvez les concaténer avec & :

"Bon" & "jour" donnent "Bonjour"

SSCHAINE (chaîne, position, nb de caractères)

Renvoie un certain nombre de caractères à partir d'une certaine position de la chaîne.

SSCHAINE ("Ceci est un texte", 6, 8) # Donne : "est un t"

LONGUEUR (chaîne)

Renvoie la longueur de la chaine

LONGUEUR ("ceci est un texte") # Donne : 18

RANG (chaine1, chaine2, position)

Renvoie la position du premier caractère de chaine2 dans chaine1 en partant de la position voulue.

RANG ("Ceci est un texte", "un", 3) # Donne : 13
RANG ("Ceci est un texte", "est", 10) # Donne : 0

CODE(caractère) et CAR(nombre)

Renvoie le code ASCII associé au caractère (code) et le caractère associé au code (car)

CODE ("A") # Donne : 65
CAR (65) # Donne "A"

CVCHAINE(nombre) et CVNOMBRE(caractère)

Convertit le nombre en caractère et le caractère en nombre.

CVCHAINE (23) # Donne : "23"
CVNOMBRE ("23") # Donne : 23

III- Affectation :

L'affectation donne une valeur à une variable. Cela réserve un espace mémoire dédié et le remplit de la valeur.

variable <- valeur

L'identificateur est le nom de la variable ou de l'objet.

La valeur peut être soit un objet, soit une opération, soit une expression. Elle est forcément du même type que l'identificateur.

Exemples :

note <- 12
nom <- "Dupont"
age <- annee_en_cours - annee_naiss
lg <- longueur("bonjour")
double <- nb * 2

IV- Entrée et sortie standard :

Affichage d'un texte ou d'une ou plusieurs variables à l'écran :

L'affichage permet de sortir une information vers la sortie standard, l'écran. On l'écrit de cette façon :

Afficher "texte à afficher"

Par exemple :

Afficher "Bonjour, bienvenue dans mon programme"
    Bonjour, bienvenue dans mon programme

Pour afficher ce que contient une variable, on écrit :

afficher variable

Par exemple, si la variable nom contient la valeur "Dupont" :

afficher nom
    Dupont

On peut aussi afficher à la fois du texte et le contenu d'une variable :

afficher "Votre nom est", nom
    Votre nom est Dupont

Enfin, on peut afficher plusieurs textes et plusieurs variables à la fois :

afficher "Vous vous appellez", nom, "et vous avez", age, "ans"
    Vous vous appellez Dupont et vous avez 35 ans

Saisie d'une ou plusieurs variables :

La saisie d'une variable permet à l'utilisateur de taper une valeur à l'aide du clavier qui est l'entrée standard.

lire nom # Demande à l'utilisateur de saisir la variable qui s'appelle nom

Ou

lire variable1, variable2, ...

Quand on demande à l'utilisateur de saisir une valeur, on précède l'instruction lire de l'instruction afficher pour que l'utilisateur sache ce qu'il doit saisir :

afficher "Veuillez entrer votre nom :"
lire nom

    Veuillez entrer votre nom :
    _

V- Les conditions :

Pour le moment, les algorithmes que nous savons faire sont forcément linéaires :

Je traverse la route
J'attend le bus
Je monte dans le bus
...

Pour rendre le programme plus souple, on peut y ajouter des conditions :

Je regarde la route
SI il y a une voiture alors
    J'attend
SINON
    Je traverse la route
FIN DE SI
J'attend le bus
...

Conditions en si :

Si <condition(s)> alors
    <instruction(s)>
fsi

La condition est une comparaison entre deux variables ou entre une variable et une valeur.

La ou les instructions sont un ensemble de code a effectuer si la condition est respectée.

Les opérateurs de comparaison sont : = ; < ; > ; <= ; >= ; <> (différent de)

Par exemple :

Si a < b ...
Si nom = "Dupont" ...
Si age >= 18 ...

On peut combiner plusieurs conditions en utilisant ET (à la fois l'un et l'autre) et OU (soit l'un, soit l'autre, soit les deux) :

Si note >= 0 ET note <= 20 // note comprise entre 0 et 20
Si age < 19 OU prénom = "Bernard" // personne de - de 19 ans ou qui s'appelle Bernard

Si ... alors ... sinon ...

On peut complêter l'instruction si avec l'instruction sinon dont la partie de code qui suit sera

exécutée si la condition n'est pas respectée, par exemple :

si feu = "vert" alors
    afficher "continuez"
sinon
    afficher "arrêtez-vous"
fsi

si note > 10 alors
    afficher "Bravo, vous avez au dessus de la moyenne"
sinon
    afficher "Révisez, vous êtes en-dessous de la moyenne"
fsi

Si imbriqués :

On peut aussi imbriquer les si pour tester plus de 2 conditions :

Si condition(s) alors
    si condition(s) alors
        instruction(s)
    fsi
sinon
    instruction(s)
fsi

Si condition(s) alors
    instruction(s)
sinon
    si condition(s) alors
        instruction(s)
    fsi
fsi

On peut imbriquer les si indéfiniment :

si ... alors
    si ... alors
        si ... alors
            instructions
        sinon
            instructions
        fsi
    sinon
        instructions
    fsi
sinon
    instructions
fsi

Pour s'y retrouver dans les si imbriquées (et d'une manière générale dans toutes les structures imbriquées les unes dans les autres), on décale d'une tabulation chaque bloc d'instructions.

Exemple :

si feu = "rouge" alors
    afficher "Stop !"
sinon
    si feu = "orange" alors
        afficher "ralentissez"
    sinon
        si feu = "vert" alors
            afficher "Continuez"
        sinon
            afficher "erreur de couleur du feu"
        fsi
    fsi
fsi

Conditions avec suivant :

Plutôt que d'écrire beaucoup de si imbriqués, on peut lister toutes les valeurs possibles de la condition et appliquer les instructions avec la structure suivant.

Suivant valeur faire
    possibilité 1 : instruction(s)
    possibilité 2 : instruction(s)
    ...
    possibilité X : instruction(s)
    sinon : instruction(s)
fsuivant

L'identificateur est une variable que l'on veut tester. Les valeurs sont les différentes valeurs que l'on attend de l'objet (par exemple on s'attend à ce qu'un feu soit vert, orange ou rouge).

exemple 1 :

suivant feu faire
    "rouge" : afficher "Freinez"
    "orange" : afficher "Ralentissez"
    "vert" : afficher "Continuez"
    sinon : afficher "Erreur dans la couleur du feu"
fsuivant

exemple 2 :

afficher "Quel est le carré de 4 ..."
afficher "15, 16 ou 17 ?"
lire réponse
suivant réponse faire
    15 : afficher "Ce n'est pas la bonne réponse"
    16 : afficher "La réponse est correcte, bravo"
    17 : afficher "Ce n'est pas la bonne réponse"
    sinon : afficher "Le chiffre que vous avez entré est érroné, veuillez recommencer"
fsuivant

VI- Les boucles :

Toujours dans le but de rendre le programme plus souple, on peut imaginer qu'à certains moments on puisse recommencer une partie de programme. C'est dans ce cas qu'on utilise les boucles.

...
Je regarde la route
Si il y a une voiture alors
    J'attend
Sinon
    Je traverse la route
Fsi
J'attend le bus
...

Dans le code ci-dessus, si il y a une voiture, j'attend. Il serait pratique de recommencer cette instruction jusqu'à ce que la route soit libre, par exemple :

Je regarde la route
Tant qu'il y a une voiture
    J'attend
Fin Tant Que
Je traverse la route

Répéter ... jusqu'à :

Cette structure permet de répéter le code qu'elle contient jusqu'à ce que la condition de sortie soit remplie.

répéter
    instructions
jusqu'à condition(s)

Avec cette structure, la partie du programme se trouvant dans la boucle est forcément exécutée au moins une fois. Les conditions se posent de la même façon que pour les si ou les suivant.

Exemples :

répéter
    afficher "Veuillez saisir un nom"
    lire nom
    afficher "Voulez-vous recommencer ? O / N"
    lire choix
jusqu'à choix = "N"

Le programme ci-dessus exécute au moins une fois la saisie du nom. Si l'utilisateur saisit "O", la boucle recommence, mais si il saisit "N", la boucle s'arrête et on passe à la suite du code.

Ce morceau de programme peut donc être effectué infiniment.

i <- 10
répéter
    afficher "Ce programme va encore s'exécuter", i, "fois"
    i <- i-1
jusqu'à i = 0

Dans cet exemple, on répète le bout de code 10 fois. i est diminué de 1 à chaque tour de boucle donc quand il arrive à 0, il ne respecte plus la condition et on sort de la boucle.

Incrémentation et décrémentation :

Dans cet exemple, on dit que i est décrémenté, car il diminue à chaque tour (ici il part de 10 et diminue de 1 à chaque fois). L'incrémentation est l'inverse : augmenter la valeur d'une variable à chaque tour de boucle.

i <- i+1 # ici i est incrémenté.
j <- j-1 # ici, j est décrémenté. C'est l'inverse, il perd 1 à chaque tour.

On se sert surtout de l'incrémentation dans les boucles pour donner une limite à l'exécution de la boucle.

Exemples :

i <- 0
répéter
    i <- i+1
jusqu'à i = 5

Dans cet exemple on incrémente i de 1 à chaque tour, ainsi le programme tournera 5 fois.

j <- 10
répéter
    j <- j-2
jusqu'à i = 0

Ici, le programme tournera 5 fois puisque i est décrémenté de 2 à chaque tour.

Tant que ... Faire :

Cette boucle est identique à répéter si ce n'est que la condition est testée avant l'exécution des instructions, ce qui veut dire que les instructions peuvent ne jamais être exécutées ce qui n'est pas vrai pour une boucle répéter.

tant que condition faire
    instruction(s)
ftq

Exemples :

age <- 0
tant que age < 18 faire
    afficher "Vous avez", age, "ans. Vous êtes mineur !"
    age <- age + 1
    afficher "un an passe ..."
ftq


tant que feu <> "orange ET feu <> "rouge"
    afficher "Continuez"
    lire feu
ftq

boucles pour avec une liste

Cette boucle a de particulier qu'elle contient dès le départ une liste d'éléments à traiter avant de sortir.

pour variable avec valeur1 valeur2 ... valeurN faire
    instructions
fpour

Par exemple :

Pour i avec 1 10 5 8
    afficher i
fpour
# Affiche 
    1 10 5 8

exemple :

On veut répéter les mêmes instructions pour 3 personnes :

Pour personne avec "Toto" "Titi" "Tata" faire
    afficher "Bonjour ", personne, "indiquez votre numéro de client"
    lire numclient
fpour

boucles pour avec incrément défini

Dans certains langages, on lui donne directement l'affectation (la valeur de départ), la condition de sortie (valeur d'arrivée) et l'incrémentation (le pas) :

pour variable de val_départ à val_arrivée par incrément de pas
    instructions
fpour

Dans certains cas, elle est plus utile que les autres boucles. Par exemple il est plus simple d'écrire cette instruction avec pour qu'avec tantque :

Pour i de 1 à 10 pas de 1
    afficher i
fpour
# Affiche :
    1 2 3 4 5 6 7 8 9 10

exemple :

On veut répéter 50 fois les mêmes instructions :

Pour i de 1 jusqu'à 50 pas de 1
    afficher "Entrez deux nombres que vous voulez multiplier :"
    lire a, b
    resultat a * b
    afficher a, "multiplié par", b, "=", résultat
fpour

VII- Les tableaux :

Définition :

Un tableau est un structure qui permet de stocker des données de même type en son sein.

C'est une variable qui contient plusieurs valeurs.

Chaque valeur correspond a une indice du tableau :

1 2 3 4 5 6
Notes 9 15 12,5 - 8,5 12

Ici, notes est le nom du tableau, les différentes notes sont contenues à une certaine indice.

  • L'indice 1 a pour valeur 9.
  • L'indice 2 a pour valeur 15.
  • L'indice 3 a pour valeur 12,5.
  • L'indice 4 est vide.
  • ...

Déclaration :

Un tableau se déclare de la manière suivante :

nom_du_tableau (indice_min : indice_max) : tableau de type de données

exemple :

notes(1:6) : tableau de réels

Utilisation :

Si on reprend l'exemple du tableau de notes, on a :

  • notes(1) = 9 (l'indice 1 du tableau contient la valeur 9)
  • notes(2) = 15 (l'indice 2 du tableau contient la valeur 15)
  • ...

Exemple de calcul utilisant les valeurs d'un tableau :

moyenne (notes (1) + notes (2) + notes (3) + notes (5) + notes (6)) / 5
moyenne = 11,6

Remplissage :

Pour remplir un tableau, il faut saisir les valeurs une à une. Souvent, on s'aide d'une boucle :

Programme saisir_tab
VAR repertoire (1:10) : tableau d'entiers
n : entier
DEBUT
    (* Boucle de traitement *)
    Pour n 1 à 10 pas de 1
        lire repertoire (n)
    Fpour
FIN

lire repertoire (n) peut aussi s'écrire :

lire nom
Repertoire (n) nom

Affichage :

Pour afficher toutes les valeurs d'un tableau, il faut afficher une à une les valeurs à l'aide d'une boucle :

(* on considère que le tableau est déjà rempli *)
Pour i 1 jusqu'à 10 pas de 1
    (* affichage du nom *)
    afficher repertoire (i)
Fpour

Opérations sur les valeurs d'un tableau :

Somme des valeurs d'un tableau (pour la soustraction, la multiplication et la division on procède de la même manière) :

( On considère qu'un tableau d'entiers de 1 à 12 est déjà rempli )

somme 0
pour i 1 jusqu'à 12 pas de 1
    somme somme + tab(i)
fpour
afficher "la somme des valeurs est :", somme

Recherche d'une valeur dans un tableau :

(un tableau de nom est déjà rempli On recherche "Dupont" dans ce tableau On aurait pu faire pareil en utilisant une variable saisie à la place de "Dupont" )

indice_max 12
i <- 0
répéter
    i <- i + 1
jusqu'à tab (i) = "Dupont" OU i = indice_max
si tab = "Dupont"
    afficher "Dupont figure dans le tableau"
fsi

Recherche du minimum (ou du maximum) dans un tableau :

( On considère qu'un tableau de 1 à 25 est déjà rempli )

min tab(1)
pour i <- 1 à 25 pas de 1
    si tab(i) < min
        min <- tab(i)
    fsi
fpour
afficher "le minimum de ce tableau est", min

Somme (ou soustraction, multiplication, division) de deux tableaux dans un autre :

( On considère que deux tableaux d'entiers de 1 à 10 sont déjà remplis ) ( On met la somme des deux colonnes dans la colonne d'un troisième tableau )

pour i <- 1 à 10 pas de 1
    tab3 (n) <- tab1 (n) + tab2 (n)
fpour

( Affichage de ce troisième tableau )

pour i <- 1 jusqu'à 10 pas de 1
    afficher tab1 (n), "+", tab2 (n), "=", tab3 (n)
fpour

Suppression d'une valeur :

Afficher "Entrez la valeur à supprimer :"
lire var
i <- 0
répéter
    i <- i + 1
    tab (i) tab (i+1)
jusqu'à tab (i) = var ou i = indice_max
si tab (i) = var
    répéter
        tab (i) tab (i+1)
    jusqu'à i = indice_max ou i = "»
    tab (i+1) 
fsi

Tri de tableau par recherche du minimum (ou maximum)

pour i <- 1 jusqu'à indice_max pas de 1
    mini <- i
        pour j <- i +1 jusqu'à indice_max pas de 1
            si tab(j) < tab (mini) alors
                temp <- tab (i)
                tab (i) <- tab (mini)
                tab (mini) <- temp
            fsi
    fpour
fpour

Tri de tableau par échanges successifs des valeurs :

répéter
    échange .faux.
    pour i 1 jusqu'à indice_max pas de 1
        si tab (i) > tab (i+1) alors
            échange <- .vrai.
            temp <- tab (i)
            tab (i) <- tab (i+1)
            tab (i+1) <- temp
        fsi
    fpour
jusqu'à NON échange

VIII- Les tableaux à deux dimensions :

Définition :

Un tableau à deux dimensions est utilisable à la fois en largeur et en hauteur.

Notes Maths Anglais Français Histoire Economie Sport
Dupont 9 15 13 12,5 7 7
Durand 5 - 9 10,5 9 14
Martin 3 8,5 14 - 11 9

Par rapport à un tableau à une dimension, il y a une indice en plus.

Déclaration :

nom_tableau (ind_ligne_min : ind_ligne_max) ( ind_col_min : ind_col_max) : tableau de type

exemple :

notes(1:3)(1:6) : tableau de réels

Utilisation :

On utilise les tableaux à deux dimension(s) (et à N dimensions) de la même manière que les tableaux à une dimension, sauf que l'on tient compte d'une indice en plus.

Exemple de remplissage :

Programme saisir_tab
VAR notes (1:10) (1:5) : tableau d'entiers
i, j : entier
(* Boucle de traitement *)
Pour i 1 à 10 pas de 1
    Pour j de 1 à 5 pas de 1
        lire notes (i)(j)
    Fpour
Fpour

IX- Les sous-programmes :

Définition :

Quand un programme doit exécuter plusieurs fois le même type d'actions, plutôt que de taper N fois le code, on préfère exécuter les actions dans un sous-programme qui exécutera les actions quand le programme principal l'appellera.

En général, un programme principal ne doit donc pas être trop gros. Il est préférable de le découper en plusieurs petits morceaux de programme.

Exemple :

Je sors.
Je marche à pied.
Je traverse la route.
Je tourne à droite.
Je continue à marcher à pied.
Je traverse une autre route.
J'arrive.

Puisqu'il y a plusieurs fois à traverser la route, autant créer une action (un sous-programme) qui me permette de le faire, ainsi, si j'ai un nouveau trajet qui me fait traverser 5 routes, j'appellerais 5 fois ce sous-programme. Le contexte peut changer (feu rouge, passage protégé, ...) mais l'action reste la même.

Les actions nommées :

Ce sont des sous-programmes que le programme principal ne fait qu'appeler, il ne leur passe pas de paramètres. Le contexte ne peut donc pas changer.

Ces actions se déclarent comme suit :

programme nom-programme-principal
    ... déclarations ...
Début
    ... instructions ...
    (* appel du sous-programme *)
    nom-sous-programme
    ... instructions ...
Fin

(* déclaration de l'action nommée *)
sous-programme nom-sous-programme
    ... déclarations locales ...
Début
    ... instructions ...
Fin

Les sous-programmes s'écrivent comme les programmes principaux, avec des déclarations de variables (locales), un début, une fin et des instructions.

Exemple d'action nommée :

(* Programme principal *)
PROGRAMME RECHERCHE-MAX-MIN
    (* variables globales *)
    VAR nb1, nb2 : réels
DEBUT
    afficher "Veuillez saisir deux nombres"
    lire nb1, nb2
    (* appel de l'action mini qui recherche le minimum *)
    mini
    (* exécution du sous-programme mini *)
    afficher "Veuillez saisir un autre nombre"
    lire nb2
    mini
FIN

SOUS PROGRAMME MINI
    (* variable locale *)
    VAR min : réel
DEBUT
    si nb1 < nb2 alors
        min nb1
    sinon
        min nb2
    fsi
    afficher "le minimum est :", min
FIN

Dans le programme RECHERCHE-MAX-MIN, 3 éléments sont à retenir :

  • Le programme principal s'exécute normalement et appelle le(s) sous-programme(s) : Il peut les appeller autant de fois qu'il le souhaite.

  • Les variables globales (déclarées avant le début du programme) sont utilisables par tous les sous-programmes.

  • Les variables locales (déclarées à l'intérieur d'un sous programme) ne sont utilisables que dans ce sous-programme.

Local / Global :

Déclaration locale :

Une variable est dite locale si elle est déclarée à l'intérieur d'une structure avant la première instruction. Elle sera alors utilisable uniquement par la structure en question. Elle prendra une place en mémoire à l'ouverture de la structure puis cette place sera libérée dès que la structure sera quittée.

Déclaration globale :

Une variable est dite globale si elle est déclarée dans le programme principal. Elle sera alors accessible par tous les sous-programmes.

Les actions paramétrées :

Les actions paramétrées sont des actions auxquelles on passe des paramètres, et qui nous permettent de récupérer un ou plusieurs résultats.

Parmi les actions paramétrées, on distingue les fonctions des procédures.

  • Les fonctions peuvent recevoir 0, 1 ou plusieurs paramètres et renvoient 1 seul résultat.

  • Les procédures peuvent recevoir 0, 1 ou plusieurs paramètres et ne renvoient pas réelement de résultat.

Procédures simples (sans résultats)

Une procédure est une action à laquelle on passe des paramètres et qui effectue un traitement à partir de ces paramètres.

Déclaration générale :

PROCEDURE nom_de_la_procédure (donnée(s) : variables correspondantes : type)
Déclarations des variables locales
DEBUT
...
instructions
...
FIN

Appel :

PROGRAMME PRINCIPAL
Déclarations globales
DEBUT
    instructions
    ...
    resultat nom_de_la_procedure (liste des paramètres)
    ...
FIN

Exemple :

(* programme principal *)
DEBUT
    (* exécution du programme, ... *)
    afficher "Veuillez saisir deux nombres"
    lire a, b
    multiplication (a, b)
FIN

(* procédure *)
PROCEDURE multiplication (données : nb1, nb2 : entiers)
    (* variables loacles *)
    nb1, nb2, resultat : entiers
DEBUT
    (* instructions de la procédure *)
    resultat nb1*nb2
    afficher resultat
FIN

Les fonctions :

Les fonctions sont des sous-programmes paramétrés qui renvoient un et un seul résultat.

Déclaration :

FONCTION nom_de_la_fonction (donnée(s) : variables correspondantes : type) : type
Déclarations locales
DEBUT
    ...
    instructions
    ...
    retourner resultat
FIN

Appel :

PROGRAMME PRINCIPAL
Déclarations globales
DEBUT
    instructions
    ...
    variable nom_de_la_fonction (liste des paramètres)
    ...
FIN

Etant donné qu'une fonction renvoie toujours un résultat, quand on l'appelle on doit stocker son résultat dans une variable.

Une fonction est toujours d'un certain type : celui-ci dépend du type de variable que renvoie la fonction. Par exemple si le résultat retourné est un entier, la fonction sera de type entier.

Exemple :

Calcul de la factorielledu nombre passé en paramètre :

(* Fonction principale *)
PROGRAMME MATHS
    (* variables globales *)
    VAR nb, factorielle : réels
DEBUT
    (* instructions ... *)
    afficher "Veuillez entrer un nombre"
    lire nb
    (* calcul de la factorielle de ce nombre gràce à la fonction facto *)
    factorielle = facto(nb)
    afficher factorielle
FIN

(* fonction appellée *)
FONCTION FACTO (données : nombre : réel) : réel
    (* variables locales *)
    VAR result : réel
    i : entier
DEBUT
    result = 1
    si i ` 0 alors
        pour i de 1 à nombre
            result = result * nombre
        fpour
    fsi
    retourner result
FIN

Ici, on a vu que la fonction permettait de recevoir un résultat. On ne peut pas utiliser la fonction FACTO toute seule, il faut forcément faire quelque chose du résultat qu'elle retourne :

  • soit la stocker dans une variable, par exemple result facto (nombre)

  • soit l'afficher, par exemple afficher facto (nombre)

Comment peut-on faire pour récupérer plusieurs résultats depuis une action paramétrée ?

Les procédures avec paramètres et résultats :

Pour récupérer plusieurs résultat on utilise une procédure qui renvoie des données résultats et/ou des résultats.

1- A l'appel de la procédure, on passe les données en paramètres.

2- A la fin de la procédure, on donne des résultats à la fonction appelante.

3- A l'appel de la procédure, on passe les données-résultats en paramètres et elles sont rendues à la fin de la procédure.

Résultats :

Les résultats sont rendus à la fonction principale dès que la procédure est finie. Souvent ils sont indéterminés avant l'exécution de la procédure mais c'est elle qui s'occupe de les initialiser.

Exemple de procédure avec un paramètre résultat :

PROCEDURE saisie_tab (résultat : tab : tableau (1:30) de réels)
    var i : entier
DEBUT
    pour i de 1 à 30
        lire tab[i]
    fpour
    (* tab[i] sera récupéré par le programme appellant *)
FIN

Exemple 2 :

PROGRAMME NOTES
    tab (1:30) : tableau de réels
    notemin, notemax : réels
DEBUT
    afficher "Veuillez saisir les 30 notes"
    saisie_tab()
    min_max(tab, notemin, notemax)
    afficher "Le minimum est :", notemin, "et le maximum est :", notemax
FIN

A la fin de la procédure, le tableau est rempli. C'est le résultat de la procédure.

PROCEDURE min_max (donnée : tab(1:30) : tableau d'entiers ; résultats : min, max : réels)
    i : entier
DEBUT
    min tab(1)
    max tab(1)
    pour i de 2 à 30
        si min > tab(i) alors
            min tab(i)
        fsi
        si max < tab(i) alors
            max tab(i)
        fsi
    fpour
    (* A la fin de la procédure, min et max sont renvoyés au programme appellant *)
FIN

Données-résultats :

Les paramètres données-résultats sont des données qui doivent être modifiées par une procédure. Elles sortiront avec une valeur différente de celle qu'elles avaient en entrant.

PROGRAMME NOTES
    var tab(1:10) : tableau d'entiers
DEBUT
    Afficher "veuillez entrer 10 valeurs"
    pour i de 1 à 10
        lire tab (i)
    fpour
    tri (tab)
    afficher "Voilà les valeurs classées dans l'ordre :"
    pour i de 1 à 10
        afficher tab (i)
    fpour
FIN

PROCEDURE tri (donnée : tab(1:10) : tableau d'entiers)
    VAR i, fin, temp : entiers
    echange : booléen
DEBUT
    échange <- .faux.
    fin <- 9
    répéter
        tantque i < fin faire
            si tab(i) > tab(i+1) alors
                échange <- vrai
                temp <- tab(i)
                tab(i) <- tab(i+1)
                tab(i+1) <- temp
            fsi
        ftq
        fin <- fin-1
    jusqu'à NON échange
FIN

Pour conclure

Les fonctions peuvent recevoir des paramètres mais n'en renvoient qu'un et un seul que la fonction appellante doit récupérer.

Les procédures utilisent des paramètres :

  • données (pg-appelant ss-prog) : Utilisable dans la procédure, elles restent inchangées au final.

  • résultats (ss-prog appelant) : la valeur initiale du paramètre est ignorée par la procédure, la valeur finale du paramètre est copiée dans le paramètre effectif correspondant.

  • données-résultats (ss-prog appelant) : Données qui seront modifiées par la procédure. La valeur initiale est utilisée par la procédure et la valeur finale est copiée dans le paramètre effectif correspondant.

Liens Internet :

Le logiciel Algobox :

Logiciel pédagogique d'aide à la création et à l'exécution d'algorithmes

http://www.xm1math.net/algobox/

Tutoriels d'algorithmique en ligne :

http://julp.developpez.com/

http://www.pise.info/algo/

Programmation en langage C :

http://www-ipst.u-strasbg.fr/pat/program/tpc.htm