1 Introduction
2 Alternatives (si)
3 Données traitées : variables, types et expressions
4 Les entrées/sorties
5 Résumé
6 Applications
>>> Retour page précédente
1 Introduction

Dans certains cas, les algorithmes doivent prendre une décision.
Si le chiffre d'affaire du représentant est supérieur à 100, alors il bénéficie d'une prime de 10 euros sinon, il n'obtient aucune prime. Lorsqu'un algorithme devient important, trop long ou trop complexe, on réutilise le vieux principe : diviser pour mieux régner. Divisons, divisons qu'ils disaient … On va donc créer des sous-algorithmes qui, plus petits, seront plus facile à maintenir, à créer et à comprendre. Faut-il déclarer les fonctions avant ou après l'algorithme principal ? Certains langages de programmation le demande (soit avant, soit après) mais nous sommes en algo donc peut importe. Quand utiliser une fonction ? On utilise une fonction lorsqu'on a l'une ou plusieurs conditions suivantes (liste incomplète): - une partie de l'algorithme, une série de traitements est répétitive, apparaît plusieurs fois. - Un algorithme est utilisé dans différents algorithmes d'appel. - Un algorithme trop complexe sera découpé en fonctions plus petites et donc plus simples à écrire et maintenir. - L'algorithme est découpé en fonctions élémentaires permettant de séparer la partie affichage de la partie calcul. - Lorsqu'on en ressent le besoin ou quand on en a envie.

Retour index
2 Alternatives (si)

Si (condition) alors
{1er groupe d'instructions, exécutées si condition est Vraie}
Sinon
{2nd groupe d'instructions, exécutées si condition est Fausse}
FinSi
Déclaration d'une fonction Une fonction s'écrit comme un algorithme. Les seuls changements sont dans l'utilisation du mot fonction à la place du mot algorithme. Exemple : Algorithme gestionOuvrage Cet algo sert à gérer les ouvrages d'une bibliothèque Fonction ajouterOuvrage(oNum : entier, oCode : chaîne, oTitre : chaîne, oDedition : date) Fonction calculNbTotalOuvrage() : entier Sont des fonctions utilisées par l'algorithme (ajouter un ouvrage à la bibliothèque, calculer le nombre total d'ouvrages de celle-ci) Que sont les choses écrites entre les parenthèses ? Ce sont des paramètres. Ces paramètres sont les données nécessaires à la fonction pour fonctionner. Ils sont écrits comme dans le paragraphe de déclaration des variables et, pour la fonction, c'est une vraie déclaration de ces variables. Ces variables paramètre ne seront pas re-déclarées dans le paragraphe 'Variables'. Qu'est ce qu'il y a d'écrit après la fonction ? Une fonction peut retourner un résultat (c'est son but). On indiquera, après la parenthèse fermante, un double point suivi du type du résultat retourné. UNE FONCTION NE RETOURNE QU'UN SEUL RÉSULTAT ! Une fonction retourne-t-elle toujours un résultat ? Non, cependant, si une fonction ne retourne aucun résultat, on l'appellera procédure. Les procédures sont toute fois moins courantes que les fonctions. De plus, on aura souvent un résultat qui sera un indicateur de bon fonctionnement, donc une fonction et non une procédure … Une fonction possède-t-elle toujours des paramètres ? Non, mais les parenthèses sont toujours marquées. Certains professionnels, ouvrages ou professeurs ajoutent même des parenthèses aux algorithmes qui peuvent contenir des paramètres d'appel de l'algorithme. Comment faire pour retourner le résultat ? C'est simple, on utilise l'instruction 'retourner' suivie d'une expression. Cette expression est souvent la variable qui contient le résultat. Exemple : Dans le cas de notre calcul de volume, le calcul de la surface est effectué plusieurs fois. On va donc l'extraire de notre algorithme principal pour le mettre dans une fonction. Cette fonction aura besoin du diamètre du cercle pour calculer la surface. La fonction renverra la surface calculée. En algo, le prototype (la définition, la première ligne) de la fonction est le suivant : Fonction calculSurface(diamètre : réel) : réel -> on met le mot fonction à la place d'algorithme -> on écrit les paramètres nécessaires entre parenthèses (ça ressemble à une déclaration de variables …) -> on écrit le type de la fonction (ça ressemble aussi à une déclaration …) Ensuite, on écrit l'algo de la fonction comme un algo normal (ou presque). Les différences sont les suivantes : o Les paramètres sont déclarés dans le prototype donc pas besoin de les redéclarer dans le paragraphe des variables (ce serait même une faute) o Si la fonction a un type (elle retourne une valeur), on utilisera l'instruction retourner pour indiquer quelle valeur est retournée ou quelle variable (ou expression) permet de la connaître. Si la fonction n'a pas de type, c'est une procédure et elle ne retourne aucun résultat. Fonction calculSurface(diamètre : réel) : réel Variables surface : réel // déclaration des variables non paramètres Début surface <- Pi*diamètre*diamètre // calcul Retourner surface // retour du résultat Fin Et voilà.

Retour index
3 Répétitives ou itératives

Utiliser une fonction Mais comment utiliser une fonction ? Rien de plus simple : on utilise une fonction comme une variable Exemple : On avait avant : surfaceExt <- Pi*damètreExt*diamètreExt On aura maintenant : surfaceExt <- calculSurface(diamètreExt) L'ordinateur évaluera la fonction en exécutant son algorithme, avec les valeurs des paramètre cités et remplacera l'appel à la fonction par son résultat retourné. Waou quelle révolution ! Mouais, bon, ici une fonction n'a pas beaucoup d'intérêt mais faites un algo qui permet de faire des simulations d'amortissement selon l'amortissement constant, l'annuité constante ou les deux et ça devient déjà plus intéressant. Zone de Texte: Afficher(texte : chaîne) est une fonction qui décompose le texte en une suite de caractères et les écrit un par un, à la queue leu leu à l'écran. De la même façon, et c'est le cas de certains profs et bouquins, on devrait écrire : 'variable<-lire()' à la place de la fonction saisir.D'ailleurs, pouvez vous me dire comment est faite l'instruction afficher ? Hein ? Hein ? On n'en sait rien et on s'en moque. Tant que cette fonction fonctionne correctement. Idem pour lire ou saisir. Ce sont effectivement des fonctions. Exemple : Tube … Fonction calculSurface(diamètre : réel) : réel Variables surface : réel // déclaration des variables non paramètres Début surface <- Pi*diamètre*diamètre // calcul Retourner surface // retour du résultat Fin Algo volumeTube Var diametreExt, diametreInt, hauteurTube : réel surfaceCercleExt, surfaceCercleInt, surfaceAnneau, volumeTube : réel Début // Saisie des informations : Afficher ("donnez les diamètres intérieurs puis extérieur et la hauteur du tube :") Saisir (diametreExt , diametreInt, hauteurTube) // Calculs surfaceCercleExt <- calculSurface (diametreExt) surfaceCercleInt <- calculSurface (diametreInt ) surfaceAnneau <- surfaceCercleExt – surfaceCercleInt volumeTube <- surfaceAnneau * hauteurTube // Restitution des résultats Afficher ("le volume du tube est de : ", volumeTube) Fin

Retour index
4 Résumé

Utiliser une fonction Mais comment utiliser une fonction ? Rien de plus simple : on utilise une fonction comme une variable Exemple : On avait avant : surfaceExt <- Pi*damètreExt*diamètreExt On aura maintenant : surfaceExt <- calculSurface(diamètreExt) L'ordinateur évaluera la fonction en exécutant son algorithme, avec les valeurs des paramètre cités et remplacera l'appel à la fonction par son résultat retourné. Waou quelle révolution ! Mouais, bon, ici une fonction n'a pas beaucoup d'intérêt mais faites un algo qui permet de faire des simulations d'amortissement selon l'amortissement constant, l'annuité constante ou les deux et ça devient déjà plus intéressant. Zone de Texte: Afficher(texte : chaîne) est une fonction qui décompose le texte en une suite de caractères et les écrit un par un, à la queue leu leu à l'écran. De la même façon, et c'est le cas de certains profs et bouquins, on devrait écrire : 'variable<-lire()' à la place de la fonction saisir.D'ailleurs, pouvez vous me dire comment est faite l'instruction afficher ? Hein ? Hein ? On n'en sait rien et on s'en moque. Tant que cette fonction fonctionne correctement. Idem pour lire ou saisir. Ce sont effectivement des fonctions. Exemple : Tube … Fonction calculSurface(diamètre : réel) : réel Variables surface : réel // déclaration des variables non paramètres Début surface <- Pi*diamètre*diamètre // calcul Retourner surface // retour du résultat Fin Algo volumeTube Var diametreExt, diametreInt, hauteurTube : réel surfaceCercleExt, surfaceCercleInt, surfaceAnneau, volumeTube : réel Début // Saisie des informations : Afficher ("donnez les diamètres intérieurs puis extérieur et la hauteur du tube :") Saisir (diametreExt , diametreInt, hauteurTube) // Calculs surfaceCercleExt <- calculSurface (diametreExt) surfaceCercleInt <- calculSurface (diametreInt ) surfaceAnneau <- surfaceCercleExt – surfaceCercleInt volumeTube <- surfaceAnneau * hauteurTube // Restitution des résultats Afficher ("le volume du tube est de : ", volumeTube) Fin

Retour index
5 Résumé

Groupe Description banale Description informaticienne Instruction
La remarque Commentaire pour expliquer l'algo Ligne de remarque ou de commentaire // … ; /* … */
L'affectation Remplir une boite avec une valeur Affecter une valeur à une variable … <- …
Entrées/Sorties Capter ou restituer des informations Les entrées/sorties, lecture/écriture Lire, écrire ; Saisir, afficher
Alternatives Choix d'un traitement, selon des conditions données à vérifier Conditionnelle ou alternative Si (condition) Alors
  Traitement_si_condition_vraie
Sinon
  Traitement_si_condition_fausse
FinSi
Les boucles Faire plusieurs fois le même travail Les répétitives ou itérations Répéter ... jusqu'à (condition de fin de traitement) ;
Tant Que (condition de répétition) faire ... fin tant que ;
Pour (initialisation, vérification et incrémentation d'un indice) ... fin pour
Les fonctions Sous-traiter le travail Fonctions et procédures Fonction nom_de_la_fonction ([liste de paramètres]) : type_du_résultat …
Procedure nom_de_la_procédure([liste de paramètres])

Retour index
5 Applications

Dans certains exemples, j'ai utilisé différentes notations des entrées/sorties afin de présenter les différentes façons de les écrire.

5.1 Calcul du maximum

Applications Dans certains exemples, j'ai utilisé différentes notations des entrées/sorties afin de présenter les différentes façons de les écrire. 6.1 Calcul de la surface d'un cercle, fonction à utiliser dans un algorithme.
Fonction surfaceCirculaire(rayon : réel) : réel
/*Description : … */ Var // déclaration des variables Surface, rayon : réel, variables : surface et rayon du cercle PI : réel <- 3.1415926535897932384626433832795, constante Pi
Début // corps
surface <- 2*PI*rayon^2 retourner(S)
Fin
6.2 Procédure afficher()
Procédure afficherEntête (nom : chaîne, prénom : chaîne)
/* Description : Cette procédure affiche le nom et prénom de l'utilisateur dans un cadre. */ /* elle ne retourne rien, forcément, c'est une procédure … */ Var // déclaration des variables: Aucune variable locale nécessaire, elles sont toutes transmises en paramètre
Début // corps
Ecrire ("========================") Ecrire ("> ", nom, " ", prénom) Ecrire ("========================")
Fin
6.3 Fonctions calcul de quelque chose
Fonction calculerPrime (somme : réel) : réel
/* Description : Calcul de la prime. Renvoie la valeur de la prime selon la valeur de la somme : si la somme est inférieure à 1000, alors la prime est de 1% de la somme, sinon la prime est de 2% de la somme. */ Var // déclaration des variables Prime : réel, montant de la prime calculée
Début // corps
Si (somme<1000)
Alors prime ß somme*0,01
Sinon
prime ß somme*0,02
FinSi Retourner (prime)
Fin
6.4 Utilisation de fonctions et procédures
calculPrime()
/* Description : Calcul de la prime d'une personne en fonction de son chiffre d'affaire */ Var // déclaration des variables nom, prénom : chaîne, nom et prénoms de la personne chiffreAffaire : réel, chiffre d'affaire de la personne
Début // corps
Lire("nom ? ", nom) Lire("prénom ? ", prénom) Lire("chiffre d'affaire ? ", chiffreAffaire) prime <- calculerPrime(chiffreAffaire) // appel à la fonction de calcul de la prime afficherEntête(nom, prénom) // appel à la procédure d'affichage des données sur la personne Ecrire("prime sur chiffre d'affaire : ", prime)
Fin
Algorithme maximum()
/* Description : Cet algorithme effectue la comparaison entre deux entiers.
Il affiche l'entier maximum des deux */
Var // déclaration des variables
nombre1, nombre2 : entier, nombres à comparer
Début // corps
Saisir ("Entrez un entier", nombre1) // lecture du premier entier
Saisir ("Entrez un second entier", nombre2) // lecture du second entier
Si (nombre1 > nombre2) alors
Afficher ("Le maximum est : ", nombre1)
Sinon
Afficher ("Le maximum est : ", nombre2)
Fin si
Fin

5.2 Calcul de la moyenne des notes d'un élève

L'algo doit faire la saisie des nom et prénom de l'élève, celle de ses notes s'il y en a puis afficher leur nombre, le total et la moyenne de celles-ci, à la fin.
Algorithme moyenneElève()
Variables
nom, prénom : chaîne
// nom et prénom : informations élève à rappeler en fin de calcul de la moyenne
continuer : caractère
// continuer : indicateur qui permet de savoir ce que veut faire l'utilisateur
note, nombre, total : réel
// note : la dernière note saisie
// nombre : nombre de notes saisies, nécessaire pour effectuer le calcul de la moyenne
// total : somme de l'ensemble des notes
Début
// Initialisations
nombre<- 0
// Saisie des informations élève
Afficher ("donnez les nom et prénom de l'élève")
Saisir (nom, prénom)
// Saisie initiale de continuer
Répéter
Afficher ("y a-t-il des notes à saisir (o/n) ? ")
Saisir (continuer)
Jusqu'à (continuer="O" ou continuer="o" ou continuer="N" ou continuer=n")

// Boucle de saisie des notes
TantQue (continuer="O" ou continuer="o") faire
// Saisie de la note
Afficher ("Donnez la note ", nombre+1," : ")
Saisir (note)
// Calculs
nombre<- nombre+1 // incrémenter le nbre de notes saisies
total<- total+note // accumuler la note dans le total
// Saisie de la continuation
Répéter
Afficher ("y a-t-il d'autres notes à saisir (o/n) ? ")
Saisir (continuer)
Jusqu'à (continuer="O" ou continuer="o" ou continuer="N" ou continuer=n")
FinTantQue

// Affichage des informations élève
Afficher ("Élève : ", nom, ", ", prénom, " : ")
// Affichage des résultats
Si (nombre > 0) Alors
Afficher ("nombres de notes : ", nombre)
Afficher ("total des notes : ", total)
Afficher ("moyenne des notes", total/nombre)
Sinon
Afficher ("aucune note saisie")
FinSi

// Affichage de fin du programme
Afficher ("Au revoir")
Fin

Transformer cet algorithme pour effectuer la saisie tant qu'il y a des élèves à saisir.
Noter la boucle de contrôle de saisie autour de la saisie de continuer pour être sûr d'avoir saisi un O, o, N ou n.

5.3 Programme de calcul de la racine carrée d'un nombre

Utilisation d'une fonction racineCarrée(nombre : réel, precision : entier) : réel.
Cette fonction retourne la racine carrée du nombre et -1 si le nombre donné est négatif.
La précision indique le nombre de décimales calculées.
Algorithme racine()
/* Description : Cet algorithme calcule et affiche la racine carrée d'un nombre.
Il s'arrête lorsqu'on donne un nombre inférieur ou égal à zéro
*/
Variable // déclaration des variables
nombre, racine : réel précision : entier
Début // corps
précision<- 10
Saisir ("entrez un nombre positif (0 ou négatif pour sortir du programme)", nombre) // lecture du nombre
TantQue (nombre > 0)
racine<- racineCarrée(nombre, précision)
Afficher("la racine carrée de ",nombre, " est ", racine)
Saisir ("entrez un nombre positif (0 ou négatif pour sortir du programme)", nombre) // lecture du nombre
FinTantQue
Ecrire("Au revoir")
Fin
// fin de l'algorithme

5.4 Calcul de la racine carrée à l'aide de la dichotomie

La définition de la racine carrée d'un nombre A est un nombre B qui, multiplié par lui-même donne A.
La racine carrée d'un nombre négatif n'est pas valide dans l'ensemble des réels (R) mais seulement dans l'ensemble des complexes.
Si le nombre A donné est négatif, le résultat calculé sera donc de -1 afin d'exprimer l'erreur.

Par principe, la racine carrée d'un nombre est inférieure à ce nombre si il est supérieur à 1 et supérieure si il est inférieur à 1.
La dichotomie est une méthode de recherche de solution d'une équation.
Pour rechercher la racine d'un nombre, nous utiliserons l'équation suivante :
Nombre - (racine(nombre))² = 0
Mais on ne connaît pas racine(nombre) donc on le calcul en recherchant une valeur approchée.
Cette valeur approchée est recherchée comme suit.
On prend le milieu d'entre le nombre et 1 et on calcule milieu*milieu.
Si milieu*milieu est supérieur à nombre,
alors la racine se trouve entre notre milieu et la borne inférieure
sinon, la racine se trouve entre milieu et le nombre.

Si on n'a pas retrouvé la racine du premier coup, on recommence en calculant le milieu d'entre milieu et la borne concernée.
Dans notre cas, on utilisera l'équation
nombre - milieu² <= précision
sinon on n'a pas fini de calculer…. La précision est donnée en nombre de décimales.
Fonction racineCarrée(nombre : réel, précisionNbDecimales : entier): réel
Variables
// borneInf, borneSup bornes inférieure et supérieure ; précision : nombre 1 précédé de précisionNbDécimales décimales
borneInf, borneSup, milieu, précision, resultat : réel
Début
// vérification des paramètres
Si (nombre < 0 ou précisionNbDecimales < 0) Alors

// calcul d'une racine d'un nombre négatif invalide
resultat <- -1

sinon

// effectuer le calcul
// Initialisations
borneInf<- 1
borneSup<- 1

// Calcul de la précision
précision<- 1
Pour i de 1 à précisionNbDécimales
précision<- précision/10
FinPour

// Ordonner les bornes :
Si ( nombre > 1 ) Alors
borneSup<- nombre
Sinon
borneInf<- nombre
FinSi

// Recherche du 1er milieu
milieu<- (borneInf + borneSup)/2

TantQue (nombre - milieu * milieu > précision) faire
// Ordonner les bornes
Si (milieu*milieu > nombre) Alors
borneSup<- milieu
Sinon
borneInf<- milieu
Finsi

// Recherche du (nouveau) milieu
milieu<- (borneInf + borneSup)/2
FinTantQue

// Affecter le résultat (la racine)
resultat<- milieu
Finsi
Retourner resultat
fin
Analysez le texte et observez l'algo. Si vous comprenez mieux l'algo que le texte, vous avez tout gagné

5.5 Amortissements

Algo CalculAmortissement()
Variables
mode, continuer : caractère
tauxPourcent, taux : réel
capitalInit, capitalRestant, intérêt, remboursement, annuité : réel
totalIntérêt, totalAnnuité : réel
n, durée : entier
Début
// Initialisation globale des variables
continuer<- 'o'
Répéter
// Initialisation locale des variables
tauxPourcent<- 0
// Saisie des données
Afficher ("Choisissez un type d'amortissement")
Répéter
Afficher ("Annuité constante=A ; Remboursement constant=R")
Saisir (mode)
Jusqu'à (mode = "A" ou mode = "R")
Afficher ("Donnez le capital initial")
Saisir (capitalInit)
Afficher ("Donnez la durée de l'emprunt")
Saisir (durée)
Afficher ("Donnez le taux (en %) pour un amortissement par annuités constantes")
Saisir (tauxPourcent)

// Calculs préliminaires : taux en valeur absolue, annuité (cste)
taux<- tauxPourcent/100
Si (mode = "A") alors
annuité<- capitalInit * taux/100 * (1-(1+ taux/100)^(-durée))
remboursement<- 0
Sinon
annuité<- 0
remboursement<- capitalInitial/durée
FinSi

// Préparation de l'affichage des résultats : affichage de l'entête des colonnes
Si (mode = "A") alors
Afficher ("Amortissement par annuités constantes")
Sinon
Afficher("Amortissement par remboursements constants")
FinSi
Afficher ("Année \tCapital \tIntérêt \tRemboursement \tAnnuité")

// Calculs et affichage des résultat au fur et à mesure ; n est l'année en cours
capitalRestant<- capitalInitial
Pour (n=1 à durée)
intérêt<- capitalRestant * taux
Si (mode = "A") Alors
// anuité = constante
remboursement<- annuité - intérêt
Sinon
annuité<- intérêt +remboursement
// remboursement = constante
FinSi
Afficher (n, "\t", capitalRestant, "\t", intérêt, "\t", remboursement, "\t", annuité)

// Calcul des totaux de récapitulation en fin d'algo
totalAnnuité<- totalAnnuité+annuité
totalIntérêt<- totalIntérêt<- intérêt

// Préparation du calcul de la ligne suivante
capitalRestant<- capitalRestant - remboursement
FinPour
// Affichage de fin de calcul
Afficher ("Le total des intérêts se monte à : ", totalIntérêt)
Afficher ("Le total des annuités s'élève à : ", totalAnnuité

// Recommencer ?
Afficher ("Voulez-vous effectuer une nouvelle simulation ? (o/n) ")
Saisir (continuer)
Jusqu'à (continuer <> 'o' et continuer <>'O')

// Traitements de fin du programme
Afficher ("À bientôt")
Fin

CONTINUER ICI &dif;


Passons à la suite : Algorithme structuré

Retour index