1 Introduction
2 Alternatives (si)
3 Répétitives ou itératives
4 Résumé
5 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.
De même, certaines instructions peuvent être répétées plusieurs fois.
Tant que les notes ne sont pas toutes enregistrées, on enregistre la note suivante
Ou
On enregistre une note jusqu'à ce que toutes les notes soient enregistrées.
Ou
Pour note n=1 à note n=10, enregistrer une note (la n-ième)
Il y a des instructions spécifiques pour ces cas là.
2.1 Introduction
Dans certains, l'algorithme est censé faire un choix entre deux (ou plus) possibilités.Je veux afficher le plus grand de deux nombres saisis.
La réponse en français est :
Si le nombre 1 est plus grand que le nombre 2, alors afficher le nombre 1, sinon afficher le nombre 2.
On écrira donc l'alternative sous la forme :
Rappel : une condition est une comparaison de deux données (variable ou constante) ou plusieurs comparaisons reliées par des connecteurs logiques (ET, OU).
2.2 Cas d'utilisation
On utilise des alternatives dans différents cas :Effectuer un choix :
Prime<- chiffreAffaire * 0,1
Prime<- chiffreAffaire * 0,05
Contrôler une valeur
2.3 Exemples sur les algo vus aux chapitres précédents
Calcul de la surface du cercle ; on ne peut calculer de surface que si le diamètre est positif (et non nul)Variables
surface, diamètre : réel
Écrire ("Donnez le diamètre du cercle")
Lire (diamètre)
// Calcul de la surface si le diamètre est positif
Si (diamètre >= 0) alors
Écrire ("La surface du cercle est de :" , surface)
Échange de deux caractères ; l'échange n'est fait que si les deux caractères sont différents
Variables
Saisir ("Donner un 1er caractère pour la variable a :", a)
Saisir ("Donner un 2nd caractère pour la variable b :", b)
// Échange si les valeurs sont différentes
Si (a<>b) alors
a<- b
b<- tampon
// Fin de l'échange, affichage des résultats
Afficher ("la variable a contient maintenant : ", a)
Afficher ("la variable b contient maintenant : ", b)
Afficher ("le tampon contient : ", tampon)
Calcul du volume du tube ; on ne peut calculer un volume que si le diamètre extérieur est supérieur au diamètre intérieur.
Var
surface_cercle_extérieur, surface_cercle_interieur
Afficher ("donnez les diamètres intérieurs puis extérieur et la hauteur du tube :")
Saisir (diametreExt , diametreInt, hauteurTube)
Si (diametreExt < diametreInt) alors
surfaceCercleExt = π * diametreExt * diametreExt /4
surfaceCercleInt = π * diametreInt * diametreInt /4
surfaceAnneau = surfaceCercleExt - surfaceCercleInt
volumeTube = surfaceAnneau * hauteurTube
// Restitution des résultats
Afficher ("le volume du tube est de : ", volumeTube)
2.4 Conclusion
Si (condition) alors, sinon, finSi est l'instruction majeure pour créer des traitements ou 'chemins' alternatifs lorsque l'algo doit prendre une décision.L'instruction Sinon n'est pas obligatoire.
Un Si se fini toujours par un FinSi comme un début se fini par un Fin (répétez 15 fois aussi vite que possible … si, si, allez-y. Allez, si). Retour index
3.1 Introduction
Dans certains cas (assez courants), on est amené à exécuter plusieurs fois la même action.Calculer et afficher le tableau d'amortissement d'un emprunt à remboursement constant.
On écrira un tableau comportant autant de lignes que d'année de remboursement.
Chaque ligne du tableau est calculée selon le principe suivant :
Seconde colonne : intérêt d'emprunt ; c'est le capital emprunté multiplié par le taux de remboursement.
Troisième colonne : remboursement ; c'est le capital initial divisé par le nombre d'années de remboursement.
Quatrième colonne : annuité : c'est la somme des intérêts et du remboursement.
Premier jet de l'algo :
Var
txInteretPourcent, txInteret, interet : réel
durée, année : entier
Saisir (capital)
Afficher ("donnez le taux d'intérêt (en pourcentage)")
Saisir (txInteretPourcent)
Afficher ("donnez la durée de l'emprunt")
Saisir (durée)
// Afficher les entêtes de colonnes
Afficher ("Année, Capital, Intérêt, Capital remboursé, Annuité")
// Calcul des conditions de départ
rembousement<- capital / durée
txInteret<- txInteret/100
année<- 1
// Calcul d'une ligne
interet<- capitalEmprunté *txInteret
annuité<- interet+remboursement
// Afficher les résultats en colonnes
Afficher (année, capitalRestant, interet, capital remboursé, annuité")
capitalRestant<- capitalEmprunté-remboursement
Cet algo est correct mais on ne calcule qu'une seule ligne. Que faut-il faire pour calculer les suivantes ? Peut-on répéter la séquence suivante ? pour chaque année de la durée de remboursement ?
année<- 2
interet<- capitalRestant * txInteret
annuité<- interet + remboursement
// Afficher les résultats en colonnes
Afficher (année, capitalRestant, interet, capital remboursé, annuité")
Mais le capital restant dû de l'année suivante est le capital restant à devoir à la fin de l'année que l'on vient de calculer. Donc calculons le.
capitalRestant<- capitalRestant - remboursement
Oui mais il faut modifier l'algo à chaque fois que l'on change de durée (qu'elle soit saisie ou non).
En fait, en français on dit que pour chaque année, on calcule les intérêts du capital restant dû, le remboursement, l'annuité puis on affiche le tout. Donc en algo, ça donne :
Pour année de 1 à durée
annuité<- interet+remboursement
Afficher (année, capitalRestant, interet, capital remboursé, annuité")
capitalRestant<- capitalRestant - remboursement
On a donc ici une nouvelle instruction qui permet de répéter plusieurs fois un même traitement. Il en existe plusieurs.
3.2 Pour - FinPour
Format :Pour (variableDeComptage de borneDeDépart à borneD'Arrivée)
Cette instruction permet de construire une boucle lorsque l'on connaît le nombre de termes, le nombre de répétitions à faire.
Voir exemple ci dessus.
3.3 Répéter - Jusqu'à
Format :On répète les traitements jusqu'à ce que la condition soit vraie.
Répéter le calcul des annuités jusqu'à ce qu'on n'ait plus rien à rembourser
Répéter signifie qu'on effectue les traitements au moins une fois. De plus la condition de fin est bien placée après les traitements et elle vérifie s'il faut s'arrêter ou non.
3.4 TantQue - FinTantQue
Format :On exécute les traitements tant que la condition est vraie.
Tant que l'on a quelque chose à rembourser, on effectue le calcul de l'annuité
TantQue signifie qu'on effectue les traitements que si la condition est vérifiée, c'est à dire qu'avant le traitement, si la condition n'est pas vérifiée, le traitement n'est pas fait et on passe à la suite.
De plus la condition de fin est bien placée avant les traitements et elle vérifie s'il faut les faire ou non.
3.5 Exemples
3.5.1 Procédure d'accueil d'un client
Lorsqu'un (lorsque=Si) client fait appel à l'organisation pour avoir des renseignements.L'organisation renvoie un catalogue et des informations publicitaires
Éventuellement (éventuellement=Si), le client nous adresse une commande traitée par l'organisation.
Plus tard (=autre envoie d'un client), le client effectue le paient qui est enregistré et encaissé.
Encaisser paiement du client
3.5.2 Second exemple : le contrôle des factures impayées
Seconde procédure(Seconde procédure) Régulièrement, on analyse toutes les factures non payées. Si la date de la facture est vielle de plus d'un mois, c'est que le client tarde à payer. L'organisation envoie alors au client une lettre de relance. On note qu'une lettre a été envoyée pour que le client n'en reçoive q'une seule.
Noter dans la facture, qu'une lettre a été envoyée
Si (la date de la facture est ancienne et aucune lettre envoyée) Alors
Noter dans la facture, qu'une lettre a été envoyée
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 |
Instructions de boucles et leur structure
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
/* 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")
Passons à la suite : Les fonctions Retour index