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
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.
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 indexUtiliser 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
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]) |
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./* Description : Cet algorithme effectue la comparaison entre deux entiers.
Il affiche l'entier maximum des deux */
Var // déclaration des variables
Saisir ("Entrez un second entier", nombre2) // lecture du second entier
Si (nombre1 > nombre2) alors
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.Variables
// 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
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
Saisir (continuer)
// Boucle de saisie des notes
TantQue (continuer="O" ou continuer="o") faire
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
Saisir (continuer)
// Affichage des informations élève
Afficher ("Élève : ", nom, ", ", prénom, " : ")
// Affichage des résultats
Si (nombre > 0) Alors
Afficher ("total des notes : ", total)
Afficher ("moyenne des notes", total/nombre)
// Affichage de fin du programme
Afficher ("Au revoir")
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.
/* 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
Saisir ("entrez un nombre positif (0 ou négatif pour sortir du programme)", nombre) // lecture du nombre
TantQue (nombre > 0)
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
Ecrire("Au revoir")
// 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,
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.
Variables
borneInf, borneSup, milieu, précision, resultat : réel
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
// Ordonner les bornes :
Si ( nombre > 1 ) Alors
// Recherche du 1er milieu
milieu<- (borneInf + borneSup)/2
TantQue (nombre - milieu * milieu > précision) faire
Si (milieu*milieu > nombre) Alors
// Recherche du (nouveau) milieu
milieu<- (borneInf + borneSup)/2
// Affecter le résultat (la racine)
resultat<- milieu
Retourner resultat
5.5 Amortissements
Variables
tauxPourcent, taux : réel
capitalInit, capitalRestant, intérêt, remboursement, annuité : réel
totalIntérêt, totalAnnuité : réel
n, durée : entier
continuer<- 'o'
Répéter
tauxPourcent<- 0
// Saisie des données
Afficher ("Choisissez un type d'amortissement")
Répéter
Saisir (mode)
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
remboursement<- 0
remboursement<- capitalInitial/durée
// Préparation de l'affichage des résultats : affichage de l'entête des colonnes
Si (mode = "A") alors
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)
Si (mode = "A") Alors
remboursement<- annuité - intérêt
// remboursement = constante
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
// 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)
// Traitements de fin du programme
Afficher ("À bientôt")
CONTINUER ICI &dif;
Passons à la suite : Algorithme structuré Retour index