Algorithmie

Instructions et types lmentaires

Introduction l'algorithmique

Un algorithme sert transmettre un savoir faire. Il dcrit les tapes suivre pour raliser un travail. Il permet d'expliciter clairement les ides de solution d'un problme indpendamment d'un langage de programmation. L'utilisateur d'un algorithme n'aura qu' suivre toutes les instructions, dans l'ordre (en squence) pour arriver au rsultat que doit donner l'algorithme. Le "langage algorithmique" que nous utilisons est un compromis entre un langage naturel et un langage de programmation. Nous prsentons les algorithmes comme une suite d'instructions dans l'ordre des traitements. Ils sont toujours accompagns d'un lexique qui indique, pour chaque variable, son type et son rle. Un algorithme est dlimit par les mots cls dbut et fin. Nous manipulerons les types couramment rencontrs dans les langages de programmation : entier, rel, boolen, caractre, chane, tableau et type composite. Par convention, toutes les identifiants de variables seront nots en minuscule et auront un nom mnmonique. Il en va de mme pour les fonctions, dont leur identifiant doit tre le plus explicite sur son rle. Ce dernier peut tre une contraction de plusieurs mots, par consquet pour rendre la lecture plus facile, la premire lettre de chaque mot est mis en majuscule (sauf pour le premier, exemple : calculerAireRectangle).

Notions de variables, types et valeurs

Les variables d'un algorithme contiennent les informations ncessaires son droulement. Chaque variable a un nom (identifiant) et un type. Ce dernier correspond au genre d'information que l'on souhaite utiliser : _ entier pour manipuler des entiers, _ rel pour manipuler des nombres rels, _ boolen pour manipuler des valeurs boolennes vrai ou faux, _ caractre pour manipuler des caracts alphabtiques et numriques, _ chane pour manipuler des chanes de caractres permettant de reprsenter des mots ou des phrases.

Il faut noter qu' un type donn, correspond un ensemble d'oprations dfinies pour ce type. Une variable est l'associtation d'un nom avec un type, permettant de mmoriser une valeur de ce type.

Le type entier
Les oprations utilisables sur les entiers sont : _ les oprateurs arithmtiques classiques : + (addition), - (soustraction), * (produit) _ la division entire, note , telle que n p donne la partie entire du quotient de la dividion entire de n par p _ le modulo, not mod, telle que n mod p donne le reste de la division entire de n par p _ Les oprateurs de comparaison classiques : <, >, =, ...

Le type rel
Les oprations utilisables sur les rels sont : _ les oprations arithmtiques classiques : + (addition), - (soustraction), * (produit), / (division) _ Les oprateurs de comparaison classiques : <, >, =, ...

Le type boolen
Il s'agit du domaine dont les seules valeurs sont vrai ou faux. Les oprations utilisables sur les boolens sont ralises l'aide des connecteurs logiques : et (pour le et logique), ou (pour le ou logique), non (pour le non logique). Rappel des quations logiques : Non vrai faux faux vrai Et vrai faux vrai vrai faux faux faux faux Ou vrai faux vrai vrai vrai faux vrai faux

Le type caractre
Il s'agit du domaine constitu des caractres alphabtiques et numriques. Une variable de ce type ne peut contenir qu'un seul et unique caractre. Les oprations lmentaires ralisables sont les comparaisons : >, <, =, ...

Le type chane
Une chane est une squence de plusieurs caractres. Les oprations lmentaires ralisables sont les comparaisons : <, >, =, ... selon l'ordre lexicographique.

Instructions d'affectation et expressions

Une instruction est la spcification d'une ou de plusieurs actions portant sur une ou des variables. L'instruction la plus commune est l'affectation. Elle consiste doter une variable d'une valeur appartenant son domaine, c'est dire lui donner une premire valeur ou changer sa valeur courante. Elle se note <-. Une expression est une suite finie bien forme d'oprateurs portant sur des variables ou des valeurs et qui a une valeur. La valeur de l'expression doit tre conforme au domaine de la variable affecte.

Exemple d'algorithme
Algorithme dbut x <- 12 y <- x + 4 x <- 3 fin Lexique - x : entier - y : entier

Cet algorithme est constitu de trois instructions successives qui seront effectues les unes aprs les autres. Les variables x et y sont entires. La premire instruction consiste affecter la variable x la valeur 12. A la fin de cette instruction, la variable x vaut 12. La deuxime instruction est un peu plus complexe. C'est l'affectation d'une expression non rduite une valeur une variable entire. L'expression x + 4 est d'abord reconnue comme une somme effectuer portant sur deux valeurs entires. La premire valeur est celle de la variable x, qui existe, puisque l'instruction prcdente a affect 12 x. Ainsi, l'addition a bien ses deux oprandes entiers et elle peut tre effectue. Elle l'est, et la valeur entire 16 est affecte la variable y.

La troisime instruction modifie la valeur de la variable x, qui devient 3. L'ancienne valeur de x, qui tait 12, est dfinitivement perdue. Le droulement squentiel fait naturellement oublier les instructions effectues en ne conservant que les valeurs courantes des variables. On remarque que les deux premires instructions ne sont pas permutables car x n'aurait alors pas de valeur au moment du calcul.

Instructions de lecture et d'criture

Instructions de lecture
L'instruction de prise de donnes sur le priphrique d'entre (en gnral le clavier) est :
variable <- lire()

L'excution de cette instruction consiste affecter une valeur la variable en prenant cette valeur sur le priphrique d'entre. Avant l'excution de cette instruction, la variable avait ou n'avait pas de valeur. Aprs, elle a la valeur prise sur le priphrique d'entre.

Instruction d'criture
L'instruction de restitution de rsultats sur le priphrique de sortie (en gnral l'cran) est :
crire(liste d'expressions)

Cette instruction ralise simplement l'affichage des valeurs des expressions dcrites dans la liste. Ces instructions peuvent tre simplement des variables ayant des valeurs ou mme des nombres ou des commentaires crits sous forme de chanes de caractres. Exemple d'utilisation : crire(x, y+2, "bonjour")

Exemple d'algorithme
On dsire crire un algorithme qui lit sur l'entre standard une valeur reprsentant une somme d'argent et qui calcule et affiche le nombre de billets de 100 Euros, 50 Euros et 10 Euros, et de pices de 2 Euros et 1 Euro qu'elle reprsente. Principe :

L'algorithme commence par lire sur l'entre standard l'entier qui reprsente la somme d'argent et affecte la valeur une variable somme. Pour obtenir la dcomposition en nombre de billets et de pices de la somme d'argent, on procde par des divisions successives en conservant chaque fois le reste.
Algorithme dbut somme <- lire() b100 <- somme 100 r100 <- somme mod 100 b50 <- r100 50; r50 <- r100 mod 50 b10 <- r50 10 r10 <- r50 mod 10 p2 <- r10 2 r2 <- r10 mod 2 p1 <- r2 crire (b100, b50, b10, p2, p1) fin

Lexique - somme : entier, la somme d'argent dcomposer - b100 : entier, le nombre de billets de 100 Euros - b50 : entier, le nombre de billets de 50 Euros - b10 : entier, le nombre de billets de 10 Euros - p2 : entier, le nombre de pices de 2 Euros - p1 : entier, le nombre de pices de 1 Euro - r100 : entier, reste de la division entire de somme par 100 - r50 : entier, reste de la division entire de r100 par 50 - r10 : entier, reste de la division entire de r50 par 10 - r2 : entier, reste de la division entire de r10 par 2

Notion de fonctions

Une fonction est un algorithme autonome, ralisant une tche prcise, auquel on transmet des valeurs lors de son appel et qui retourne une valeur la fin de son exution. La notion de fonction est trs intressante car elle permet, pour rsoudre un problme, d'employer une mthode de dcomposition en sousproblmes distincts. Elle facilite aussi la rutilisation d'algorithmes dj dvelopps par ailleurs. Mais nous n'apprendrons pas dans ce chapitre les appeler ! Une fonction est introduite par un en-tte, appel aussi signature ou prototype, qui spcifie : le nom de la fonction les paramtres donns et leur type le type du rsultat La syntaxe retenue pour l'en-tte est la suivante :

fonction nomFonction (liste des paramtres) : type du rsultat

La liste des paramtres prcise, pour chaque paramtre, son nom et son type. La dernire instruction de la fonction indique la valeur retoune, nous la noterons :
retourne expression

Exemple de fonction
Ecrire une fonction calculant le primtre d'un rectangle dont on lui donne la longueur et la largeur.

Algorithme fonction calculerPrimtreRectangle (longueur:rel, largeur:rel):rel dbut primtre <- 2 * (longueur + largeur) retourne primtre fin

Lexique - longueur : rel, longueur du rectangle - largeur : rel, largeur du rectangle - primtre : rel, primtre du rectangle

Instructions conditionnelles

Les exemple prcdents montrent des algorithmes dont les instructions doivent s'excuter dans l'ordre, de la premire la dernire. Nous allons introduire une instruction prcisant que le droulement ne sera plus squentiel. Cette instruction est appele une conditionnelle. Il s'agit de reprsenter une alternative o, selon les cas, un bloc d'instructions est excut plutt qu'un autre. La syntaxe de cette instruction est :

si condition alors liste d'instructions sinon liste d'instructions fsi

Cette instruction est compos de trois partie distinctes : la condition introduite par si, la clause alors et la clause sinon. La condition est une expression dont la valeur est de type boolen. Elle est value. Si elle est

vraie, les instructions de la clause alors sont excutes. Dans le cas contraire, les instructions de la clause sinon sont excutes. On peut utiliser une forme simplifie de la conditionnelle, sans clause sinon. La syntaxe est alors : si condition alors liste d'instructions fsi

Exemple 1
Ecrire un algorithme qui permet d'imprimer le rsultat d'un tudiant un module sachant que ce module est sanctionn par une note d'oral de coefficient 1 et une note d'crit de coefficient 2. La moyenne obtenue doit tre suprieure ou gale 10 pour valider le module. Donnes : la note d'orale et la note d'crit Rsultat : impression du rsultat pour le module (reu ou refus) Principe : on calcule la moyenne et on la compare 10 Algorithme dbut ne <- lire() no <- lire() moy <- (2 * ne + no)/3 si moy >= 10 alors crire ("reu") sinon crire ("refus") fsi fin Lexique - ne : rel, note d'crit (coeeficient 2) - no : rel, note d'oral (coefficient 1) - moy : rel, moyenne du module

Exemple 2
On veut crire une fonction permettant de calculer le salaire d'un employ pay l'heure partir de son salaire horaire et du nombre d'heures de travail. Les rgles de calcul sont les suivantes : le taux horaire est major pour les heures supplmentaires : 25% au-del de 160 heures et 50% au-del de 200 heures. Algorithme

* sh

fonction calculerSalaire (sh:rel, nbh:entier):rel dbut si nbh < 160 alors salaire <- sh * nbh sinon si nbh < 200 alors salaire <- 160 * sh + (nbh - 160) * 1,25

sinon salaire <- 160 * sh + 40 * sh * 1,25 + (nbh - 200) * sh * 1,5 fsi fsi retourne salaire fin Lexique - sh : rel, salaire horaire - nbh : entier, nombre d'heures de l'employ - salaire : rel, salaire de l'employ

Les itrations

Il arrive souvent dans un algorithme que dans la mme action soit rpte plusieurs fois, avec ventuellement quelques variations dans les paramtres qui prcisent le droulement de l'action. Il est alors fastidieux d'crire un algorithme qui contient de nombreuses fois la mme instruction. De plus, ce nombre peut dpendre du droulement de l'algorithme. Il est alors impossible de savoir l'avance combien de fois la mme instruction doit tre dcrite. Pour grer ces cas, on fait appel des instructions en boucle qui ont pour effet de rpter plusieurs fois une mme instruction. Deux formes existent : la premire, si le nombre de rptitions est connu avant l'excution de l'instruction de rptition, la seconde s'il n'est pas connu. On appellera itration l'excution de la liste des instructions.

Rptitions inconditionnelles

Il est frquent que le nombre de rptitions soit connu l'avance, et que l'on ait besoin d'utiliser le numro de l'itration afin d'effectuer des calculs ou des tests. Le mcanisme permettant cela est la boucle Pour. Forme de la boucle Pour : Pour variable de valeur initiale valeur finale faire liste d'instructions fpour

La variable dont on donne le nom va prendre successivement toutes les valeurs entires entre valeur initiale et valeur finale. Pour chaque valeur prise par la variable, la liste des instructions est excute. La valeur utilise pour numrer les itrations est appele valeur d'itration, indice d'itration ou compteur. L'incrmentation par 1 de la variable est implicite. Autre forme de la boucle Pour : Pour variable dcroissante de valeur initiale valeur finale faire liste d'instructions fpour La variable d'itration est dcrmente de 1 aprs chaque itration.

Exemple 1 (cas simple, compteur croisant)

Ecrire l'algorithme permettant d'afficher la table de multiplication par 9. Un algorithme possible est le suivant : Algorithme dbut crire(1*9) crire(2*9) crire(3*9) crire(4*9) crire(5*9) crire(6*9) crire(7*9) crire(8*9) crire(9*9) crire(10*9) fin Il est plus simple d'utiliser une boucle avec un compteur prenant d'abord la valeur 1, puis augmentant peu peu jusqu' atteindre 10. Algorithme dbut pour i de 1 10 faire crire (i*9) fpour fin Lexique - i : entier, indice d'itration

Exemple 2
Compte rebours : crire l'algorithme de la fonction qui, partir d'un nombre entier positif n, affiche tous les nombres par ordre dcroissant jusqu' 0. Exemple : pour n=5, le rsultat sera 5 4 3 2 1 0.

Algorithme fonction compteARebours (n:entier) dbut pour i dcroissant de n O faire crire i fpour fin Lexique - n : entier - i : entier, indice d'itration

Exemple 3 (calcul de la rcurrence : cas de la somme)

On veut imprimer, pour n donn, la somme des carrs des n premiers entiers. Cette somme, note s, est obtenue en calculant le n-ime terme d'une suite dfinie par rcurrence : sn=sn-1+i Algorithmiquement, le calcul d'une telle suite se fait en deux tapes : - initialisation (ici, s0=0) - rptition de : calcul du ime terme en fonction du terme d'indice i-1 Algorithme dbut n <- lire() s <- 0 pour i de 1 n faire s <- s + i2 fpour crire (s) fin Lexique - s : entier, sommme des carr des n premiers entiers - n : entier - i : entier, indice d'itration Schma de l'volution de l'tat des variables instruction par instruction : On suppose que la valeur introduite par l'utilisateur est 4. //1 //2 //3 //4 //5

Instructions 1 2 3 4 3

n 4

s 0

1 1 2

4 3 4 3 4 3 5

5 3 14 4 30 (fin) crire()

Exemple 4 (calcul par rcurrence d'un maximum, initialisation un terme artificiel)

Ecrire l'algorithme qui permet d'imprimer le maximum de n entiers positifs donns au fur et mesure. Comment trouver ce maximum ? C'est le plus grand des 2 nombres : maximum des n-1 premiers entiers positifs donns, n-me entier donn. Ceci est une dfinition par rcurrence : Si nombren > maximumn-1 alors maximumn <- nombren sinon nombren <maximumn-1 fsi Comment initialiser la suite maximum ? Il faut que maximum1 prenne la valeur nombre1. Il suffit alors de choisir une valeur de maximum0 plus petite que tout entier positif, par exemple maximum0 = -1, de manire assurer que maximum1 aura bien nombre1 pour valeur. Il s'agit d'une initialisation un terme artificiel. Algorithme dbut n <- lire() maximum <- -1 pour i de 1 n faire nombre <- lire() si nombre > maximum alors maximum <- nombre fsi fpour crire (maximum) fin Lexique - n : entier, nombre d'entiers positifs donn - maximum : entier, maximum des i premiers entiers - nombre : entier, ime nombre lu - i : entier, indice d'itration Schma de l'volution de l'tat des variables instruction par instruction : On suppose que les valeurs introduites par l'utilisateur sont : 4 (nombre d'entiers comparer), 2, 0, 8, 7.

//1 //2 //3 //4 //5 //6 //7

Instructions

maximum

nombre

nombre >

maximum 1 2 3 4 5 6 3 4 5 3 4 5 6 3 4 5 3 7 4 -1 1 2 vrai 2 2 0 faux 3 8 vrai 8 4 7 faux (fin) crire()

Exemple 5 (calcul par rcurrence, initialisation un terme utile)

Ecrire l'algorithme qui permet d'imprimer le maximum de n entiers donns. L'initialisation a un terme artificiel n'est plus possible ici car les valeurs ne sont plus bornes infrieurement. Une solution consiste alors initialiser au premier terme et commencer la formule gnrale de rcurrence 2. Il s'agit d'une initialisation un terme utile. Algorithme dbut n <- lire() maximum <- lire() pour i de 2 n faire nombre <- lire() si nombre > maximum alors maximum <- nombre fsi fpour crire (maximum) fin Lexique - n : entier, nombre d'entiers positifs donn - maximum : entier, maximum des i premiers entiers - nombre : entier, ime entier positif donn - i : entier, indice d'itration Schma de l'volution de l'tat des variables instruction par instruction :

//1 //2 //3 //4 //5 //6 //7

On supppose que les valeurs introduites par l'utilisateur sont : 4 (nombre d'entiers comparer), 0, 2, 8, 7

Instructions 1 2 3 4 5 3 4 5 6 3 4 5 3 7

n 4

maximum 2

nombre

nombre > maximum

2 0 faux 3 8 vrai 8 4 7 faux (fin) crire()

Rptitions conditionnelles

L'utilisation d'une boucle pour ncessite de connatre l'avance le nombre d'itrations dsir, c'est--dire la valeur finale du compteur. Dans beaucoup de cas, on souhaite rpter une instruction tant qu'une certaine condition est remplie, alors qu'il est priori impossible de savoir l'avance au bout de combien d'itrations cette condition cessera d'tre satisfaite. Le mcanisme permettant cela est la boucle Tant que. Syntaxe de la boucle Tant que : tant que condition faire liste d'instructions ftant

Cette instruction a une condition de poursuite dont la valeur est de type boolen et une liste d'instructions qui est rpte si la valeur de la condition de poursuite est vraie : la liste d'instructions est rpte autant de fois que la condition de poursuite a la valeur vraie. Le droulement pas pas de cette instuction quivaut : si condition alors liste d'instructions si condition alors liste d'instructions si condition

alors liste d'instructions ...

Etant donn que la condition est value avant l'excution des instructions rpter, il est possible que celles-ci ne soient jamais excutes. Il faut que la liste des instructions ait une incidence sur la condition afin qu'elle puisse tre value faux et que la boucle se termine. Il faut toujours s'assurer que la condition devient fausse au bout d'un temps fini.

Exemple 1
On veut laisser un utilisateur construire des rectangles de taille quelconque, condition que les largeurs qu'il saisit soient suprieures 1 pixel. On peut utiliser une rptition conditionnelle qui permet de redemander l'utilisateur de saisir une nouvelle valeur tant que celle-ci n'est pas valide. Algorithme fonction saisirLargeurRectangle dbut crire ("indiquez la largeur du rectangle :") largeur <- lire() tant que largeur < 1 faire crire ("erreur : indiquez une valeur strictement positive") crire ("indiquez la largeur du rectangle :") largeur <- lire() ftant retourne largeur fin Lexique - largeur : entier, largeur courante saisie

Exemple 2
Un poissonier sert un client qui a demand 1Kg de poisson. Il pse successivement diffrents poissons et s'arrte ds que le poids total gale ou dpasse 1Kg. Donner le nombre de poissons servis. Remarque sur la terminaison : Ce problme est typique des cas o le dernier terme (celui qui fait basculer le test) doit tre retenu. Algorithme dbut poids_total <- 0 nb_poisson <- 0 tant que poids_total < 1000 faire poids_poisson <- lire()

//1 //2 //3 (itration i) //4

ftant crire (nb_poisson) fin

poids_total < poids_total + poids_poisson nb_poisson <- nb_poisson + 1

//5 //6 //7

Lexique - poids_total : rel, poids total des i premiers poissons - poids_poisson : rel, poids du ime poisson en grammes - nb_poisson : entier, nombre de poissons vendus aprs la ime itration

Schma de l'tat des variables instruction par instruction : On suppose que les valeurs introduites par l'utilisateur sont : 350, 280, 375.

Instructions 1 2 3 4 5 6 3 4 5 6 3 4 5 6 3 7

poids_total 0

nb_poisson 0

poids_poison

poids_total < 1000

vrai 350 350 1 vrai 280 630 2 vrai 375 1005 3 faux crire()

Boucles imbriques

Le corps d'une boucle est une liste d'instructions. Mais cette boucle est elle-mme une instruction. Donc le corps d'une boucle peut contenir une boucle dite imbrique, qui utilise un compteur diffrent. Il faut alors faire attention l'ordre d'excution des instructions : chaque passage dans le corps de la boucle principale, la boucle imbrique va tre excute totalement.

Exemple
Ecrire l'algorithme permettant d'imprimer le triangle suivant, le nombre de lignes tant donn par l'utilisateur : 1 12 123 1234 12345 ... Algorithme

dbut nblignes <- lire() Pour i de 1 nblignes faire Pour j de 1 i faire crire (j) fpour retour la ligne fpour fin

//1 //2 //3 //4 //5

Lexique - nblignes : entier, nombre de lignes imprimer - i : entier, indice d'itration sur les lignes - j : entier, indice d'itration sur les lments de la ime ligne

Schma d'volution de l'tat des variables instruction par instruction : On suppose que la valeur introduite pas l'utilisateur est 3.

Instructions 1 2 3 4 3 5 2 3 4 3 4 3 5 2 3 4 3 4 3 4 3 5

nblignes 3

i 1

1 crire () (fin) retour la ligne 2 1 crire () 2 crire () (fin) retour la ligne 3 1 crire() 2 crire() 3 crire() (fin) retour la ligne

(fin)

Complments sur les fonctions

Paramtres modifiables

L'entte d'une fonction spcifie son nom, le type de son rsultat, et les paramtres (avec leurs types). Ces paramtres sont considrs comme les donnes transmises la fonction, c'est dire l'entre de la fonction. Il peut arriver que la fonction modifie ces paramtres lors de l'excution de son algorithme. On parle alors de paramtre modifiable : il s'agit la fois d'une entre et d'une sortie de l'algorithme. La dclaration d'un tel paramtre dans la liste des paramtres se fait de la manire suivante : fonction nom(nom_param InOut : type_param):type_rsultat

Exemple 1
La fonction suivante prend deux paramtres rels et les modifie de manire ce qu'ils soient dans l'ordre croissant (N.B. : elle ne retourne pas de rsultat) : fonction ordonner2Rels(x InOut : rel, y InOut : rel) dbut si x > y alors tmp <- x x <- y y <- temp fsi fin Lexique : - x : rel, valeur fournie, est modifie (ventuellement) en le minimum de x et y - y : rel, valeur fournie, est modifie (ventuellement) en le maximum de x et y - tmp : rel, variable de stockage temporaire Il est videmment possible d'avoir des paramtres modifiables et des paramtres non modifiables dans une mme fonction.

Exemple 2
La fonction suivante prend trois paramtres rels : les deux premiers sont les bornes d'un intervalle, et le troisime est (ventuellement) modifi de manire rester dans l'intervalle spcifi. fonction seuillerRel(inf : rel, sup : rel, x InOut : rel) dbut si x < inf alors x <- inf sinon si x > sup alors x <- sup fsi fsi fin Lexique : - inf : rel, borne infrieure de l'intervalle - sup : rel, borne suprieure de l'intervalle - x : rel, valeur fournie, est modifie (ventuellement) par seuillage Enfin, une fonction qui utilise des paramtres modifiables peut gallement renvoyer un rsultat.

Exemple 3
La fonction suivante est similaire celle de l'exemple prcdent. Elle renvoie en plus un boolen gal vrai si et seulement si le paramtre x a t effectivement modifi. fonction modifierRelParSeuillage(inf : rel, sup : rel, x InOut : rel):boolen dbut res <- faux si x < inf alors x <- inf res <- vrai sinon si x > sup alors x <- sup res <- vrai fsi fsi retourne res fin Lexique : - inf - sup - x : seuillage - res

: rel, borne infrieure de l'intervalle : rel, borne suprieure de l'intervalle rel, valeur fournie, est modifie (ventuellement) par : boolen, rsultat vrai si x est modifi

Appels de fonction

Les fonctions ont jusqu' prsent t utilises de faon prsenter certains algorithme de manire autonome (donnes fournies, rsultat calcul). Plus gnrallement, les fonctions sont utilises pour dcrire les diffrentes tapes d'un algorithme plus complexe. On peut alors appeler ces fonctions pour raliser les tapes de calcul correspondantes : lors de l'appel, on indique grce aux paramtres les donnes sur lequelles la fonction doit travailler, puis on rcupre le rsultat retourn. Un appel de fonction provoque donc l'excution complte du corps de cette fonction. Le passage des paramtres sera dcrit ici de manire intuitive. Chaque langage de programmation traite cet aspect d'une manire rigoureuse, ce qui ncessite d'aborder les notions plus dtailles (paramtres formels et effectifs, passage par valeur ou par adresse, porte des paramtres, compatibilit des types, ...).

Exemple 1
Dcrire un algorithme qui calcule le maximum de 4 rels saisis au clavier. Le calcul du maximum de deux valeurs sera dcrit par une fonction. fonction calculerMax2Rels(x : rel, y : rel):rel dbut si x > y alors res <- x sinon res <- y fsi retourne res fin Lexique : - x : rel - y : rel - res : rel, maximum trouv

Algorithme dbut maximum <- lire() pour i de 2 4 faire nombre <- lire() maximum <- calculerMax2Rels(nombre, maximum) pour crire(maximum)

fin Lexique : - maximum : rel, maximum des i premiers nombre rels - nombre : rel, ime rel donn - i : entier, indice d'itration

Schma de l'volution de l'tat des variables instruction par instruction : Il est possible d'utiliser les mmes variables dans diffrentes fonctions et dans l'algorithme principal. On prcise donc chaque fois quelle fonction correspond la variable. On suppose que les valeurs intoduites par l'utilisateur sont : 35, 80, 37, 22. Variables : Instructions 1 2 3 4 f1 f2 f4 2 3 4 f1 f3 f4 2 3 4 f1 f2 f4 2 5 Algorithme principal maximum nombre i 35 2 80 fonction calculerMax2Rels x y x>y res / / / / / / / / / / / / 80 35 vrai 80 retourne 3 / / / / / / / / 37 80 faux 80 retourne 4 / / / / / / / / 22 80 faux 80 retourne (fin) / / / / / / / /

80 37

80 22

80 crire

Les paramtres fournis lors de l'appel peuvent tre des expressions, s'il ne s'agit pas de paramtres modifiables. Si une fonction a des paramtres modifiables, les paramtres fournis lors de l'appel doivent tre des variables. Les instructions d'affectation que contient la fonction appele peuvent alors modifier ces variables. Une fonction peut elle-mme contenir plusieurs appels de fonctions. Il est

galement possible d'utiliser le rsultat d'une fonction directement dans le paramtre fourni l'appel d'une autre fonction.

Exemple 2
Un tudiant doit, pour obtenir son diplme, passer un crit et un oral dans deux modules. le coefficient du premier module est le double de celui du second module. La moyenne d'un module, afin de ne pas pnaliser trop les ventuels checs accidentels, accorde un coefficient double la meilleure des deux notes obtenues. On veut dcrire un algorithme o, aprs saisie des quatre notes, la dcision finale est affiche (diplme obtenu si la moyenne est suprieure ou gale 10, aucun module ne devant avoir une moyenne infrieure 8).

fonction calculerMoyenne(n1:rel, n2:rel):rel dbut moy <- (n1 + 2*n2)/3 retourne moy fin Lexique : - n1 : rel, note de coefficient 1 - n2 : rel, note de coefficient 2 - moy : rel, moyenne calcule

fonction calculerNoteModule(n1:rel, n2:rel):rel dbut si n1 > n2 alors note <- calculerMoyenne(n2, n1) sinon note <- calculerMoyenne(n1, n2) fsi retourne note fin Lexique : - n1 : rel, premire note - n2 : rel, deuxime note - note : rel, note du module

fonction accorderDiplme(m1:rel, m2:rel):boolen dbut moy <- calculerMoyenne(m2, m1) si moy < 10 alors recu <- faux sinon

fin

fsi retourne recu

si (m1 < 8) ou (m2 < 8) alors recu <- faux sinon recu < vrai fsi

Lexique : - m1 : rel, moyenne premier module - m2 : rel, moyenne second module - moy : rel, moyenne gnrale - recu : boolen, vrai si l'tudiant a obtenu son diplme

Algorithme dbut ne_m1 <- lire() no_m1 <- lire() ne_m2 <- lire() no_m2 <- lire() obtenu <- accorderDiplme(calculerNoteModule(ne_m1, no_m1), calculerNoteModule(ne_m2, no_m2)) si obtenu alors crire("diplme obtenu") sinon crire("diplme non accord") fsi fin Lexique : - ne_m1 : rel, note d'crit du premier module - no_m1 : rel, note d'oral du premier module - ne_m2 : rel, note d'crit du second module - no_m2 : rel, note d'oral du second module - obtenu : boolen, vrai si le diplme est accord

Chanes de caractres

Le type chane permet de dcrire des objets forms par la juxtaposition de plusieurs caractres. Dans la plupart des langages de programmation, il existe des "outils" pour les manipuler. Au niveau des algorithmes, nous introduisons quelques fonctions prdfinies qui correspondent aux "outils" classiquement fournis par les langages. Cette liste partielle peut bien sr tre complte en fonction de vos besoins.

Quelques fonctions sur les chanes de caractres

Concatnation de chanes
fonction concat(ch1:chane, ch2:chane):chane retourne une chane forme par la concatnation de ch1 et de ch2. La chane rsultat est forme de ch1 suivi de ch2.

Longueur d'une chane

fonction longueur(ch:chane):entier retourne la longueur de la chane ch c'est--dire le nombre de caractres dont elle est constitue.

Sous-chane
fonction sousChane(ch:chane, i:entier, l:entier):chane retourne une sous-chane de longueur l extraite de la chane ch, la position i. exemple : sousChane("informatique"", 6, 2) retourne la chane "ma".

Accs au ime caractre

fonction ime(ch:chane, i:entier):caractre retourne le ime caractre de la chane ch.

Modification du ime caractre

fonction remplace(ch InOut:chane, i:entier, c:caractre) remplace le ime caractre de la chane ch par la caractre c.

Exemple

On donne un tlgramme mot par mot. On souhaite compter le nombre d'units de paiement du tlgramme sachant qu'il se termine par le mot "stop", qu'un mot de longueur l cote (110)+1 units et que le mot "stop" ne cote rien.

Algorithme dbut nup <- 0 mot <- lire() tant que Non (mot = "stop") faire prixmot <- (longueur(mot)10)+1 nup <- nup + prixmot mot <- lire() ftant crire (nup) fin Lexique : - nup : entier, nombre d'unit de paiement - mot : chane, ime mot du texte - prixmot : rel, prix du ime mot

Les tableaux

Notion de tableau

Les tableaux servent dsigner une suite finie d'lments de mme type au moyen d'une unique variable. Ces lments peuvent tre des entiers, des chanes, ... Ils sont stocks dans les diffrentes cases du tableau, habituellement numrotes de 0 n-1, n reprsentant la taille du tableau (le nombre de cases dans le tableau). Le type d'un tableau prcise l'intervalle de dfinition et le type (commun) des lments. tableau type_des_lments[borne_infrieure .. borne_suprieure] En gnral, nous choisirons toujours la valeur 0 pour la borne infrieure dans le but de faciliter la traduction de l'algorithme vers les autres langages (C, Java, ...). Par exemple, pour un tableau de 10 entiers, on pourra crire : t : tableau entier[0..9] Un tel tableau peut par exemple contenir les lments suivants : 0 45 1 54 2 1 3 -56 4 22 5 134 6 49 7 12 8 90 9 -27

Pour accder un lment du tableau, il suffit de prciser entre crochets l'indice de la case contenant cet lment. Par exemple, pour accder au septime

lment (49) du tableau d'entiers ci-dessus, on crit : t[6]. L'instruction suivante affecte la variable x la valeur du premier lment du tableau, c'est dire 45 : x <- t[0] L'lment dsign du tableau peut tre utilis comme n'importe quelle variable : t[6] <- 43 Cette instruction a modifi le tableau t : 0 45 1 54 2 1 3 -56 4 22 5 134 6 43 7 12 8 90 9 -27

Parcours complet d'un tableau

La plupart des algorithmes bass sur les tableaux utilisent des itrations permettant de faire un parcours complet ou partiel des diffrents lments du tableau. De tels algorithmes tablissent le rsultat recherch par rcurrence en fonction des lments successivement rencontrs. Les rptitions inconditionnelles sont le moyen le plus simple de parcourir compltement un tableau.

Exemple 1
Dans l'exemple suivant, la fonction affiche un un tous les lments d'un tableau de n lments : fonction crireTableau(n : entier, tab : tableau entier[0..n-1]) dbut pour i de 0 n-1 faire crire(tab[i]) fpour fin Lexique : - i : entier, indice d'itration - n : entier, taille du tableau - tab : tableau entier[0..n-1]

Algorithme dbut n <- lire() Pour i de 0 n-1 faire tab[i] <- lire()

fin

fpour crireTableau(n, tab)

Lexique : - n : entier, taille du tableau - tab : tableau entier[0..n-1]

Exemple 2
La fonction suivante multiplie par 2 tous les lments d'un tableau. fonction doublerTableau(n : entier, t InOut : tableau entier[0..n1]) dbut Pour i de 0 n-1 faire t[i] <- t[i]*2 fpour fin Lexique : - n : entier, taille du tableau - t : tableau entier[0..n-1], tableau modifiable

Parcours partiel d'un tableau

Certains algorithmes sur les tableaux se contentent de parcourir successivement les diffrents lments du tableau jusqu' rencontrer un lment satisfaisant une certaine condition. Un tel parcours partiel est le plus souvent bas sur une rptition conditionnelle.

Exemple
On cherche ici savoir si un tableau saisi au clavier n'est constitu que d'entiers positifs : Algorithme dbut tab <- lire() i <- 0 positif <- vrai tant que positif et i < n faire

si tab[i] < 0 alors positif <- faux fsi i <- i+1 ftant si positif alors crire("tableau d'entiers naturels") sinon crire("tableau d'entiers relatifs") fsi fin Lexique : - i : entier, indice d'itration - n : entier, taille du tableau - tab : tableau entier[O..n-1] - positif : boolen, vrai si aucun entier ngatif n'a t dtect

Parcours imbriqus

Certains algorithmes sur les tableaux font appel des boucles imbriques : la boucle principale sert gnralement parcourir les cases une une, tandis que le traitement de chaque case dpend du parcours simple d'une partie du tableau (par exemple toutes les cases restantes), ce qui correspond la boucle interne.

Exemple
La fonction suivante calcule, pour chaque case d'un tableau, le nombre de cases suivantes qui contiennent un lment strictement suprieur. Les rsultats sont placs dans un tableau. fonction calculerNbSuccesseurSup(n : entier, t : tableau entier[0..n-1]):tableau entier[0..n-1] dbut Pour i de 0 n-2 faire tres[i] <- 0 fpour Pour i de 0 n-2 faire Pour j de i+1 n-1 faire si t[i] < tres[i]+1 alors tres[i] <- tres[i]+1 fsi fpour fpour retourne tres fin

Lexique : - n : entier, taille du tableau - t : tableau entier[0..n-1] - tres : tableau entier[0..n-1], contient le nombre de cases de t indice strictement un lment suprieur t[i] - i : entier, indice d'itration (parcours pour remplir tres) - j : entier, indice d'itration des cases restantes de t)

tableau rsultat (case i suprieur i qui contiennent de la boucle principale de la boucle interne (parcours

Tableaux multidimensionnels

Les cases d'un tableau une dimension sont indices de manire conscutive (cases "alignes"). Il est possible de disposer ces cases selon des grilles (tableaux deux dimensions), des cubes (tableaux trois dimensions), ... Les algorithmes les plus simples sur ces tableaux utilisent nanmoins en gnral des boucles imbriques : chaque niveau de boucle correspond au parcours selon une dimension. Le type d'un tableau prcise l'intervalle de dfinition selon chaque dimension. tableau type_des_lments[borne_inf_dim1 .. borne_sup_dim1, borne_inf_dim2 .. borne_sup_dim2, ...]

Tableaux deux dimensions

Ces tableaux sont faciles se reprsenter comme une grille (ou matrice) ayant un certain nombre de lignes (premire dimension) et un certain nombre de colonnes (seconde dimension). tableau type_des_lments[0..nb_lignes-1, 0..nb_colonnes-1]

Un tel tableau, avec 5 colonnes et 3 lignes, peut par exemple contenir les lments suivants : 0 1 0 45 64 1 54 8 2 1 54 3 -56 34 4 22 2

56

23

-47

12

Pour accder un lment du tableau, il suffit de prciser entre crochets l'indice de la case contenant cet lment, et ce pour chacune des dimensions. Par exemple, pour accder l'lment 23 du tableau d'entiers ci-dessus, on crit : t[2,1]. L'instruction suivante affecte la variable x la valeur du premier lment du tableau, c'est dire 45. x <- t[0,0]

L'lment dsign du tableau peut alors tre utilis comme n'importe quelle variable : t[2,1] <- 43

Cette instruction a modifi le tableau : 0 1 2 0 45 64 56 1 54 8 43 2 1 54 -47 3 -56 34 0 4 22 2 12

Exemple : calcul de la somme

fonction somme(li : entier, co : entier, t : tableau entier[0..li1, 0..co-1]):entier dbut s <- 0 Pour i de 0 li-1 faire Pour j de 0 co-1 faire s <- s + t[i,j] fpour fpour retourne s fin Lexique : - li : entier, nombre de lignes du tableau - co : entier, nombre de colonnes du tableau - t : tableau entier[0..li-1, 0..co-1], tableau dont on cherche l'lment maximal - s : entier, somme des lments dj parcourus - i : entier, indice d'itration sur les lignes - j : entier, indice d'itration sur les colonnes

Recherche dichotomique

La fonction rechercheDicho recherche un lment dans un tableau tri et retourne l'indice d'une occurrence de cet lment (ou -1 en cas d'chec). Une telle recherche peut tre ralise de manire squentielle ou dichotomique. Nous dveloppons ici la version dichotomique qui est la plus efficace en temps d'excution. On compare l'lment cherch celui qui se trouve au milieu du tableau. Si l'lment cherch est plus petit, on continue la recherche dans la premire moiti du tableau sinon dans la seconde. On recommence ce processus sur la moiti. On s'arrte lorsqu'on a trouv ou lorsque l'intervalle de recherche est nul. Exemples :

Exemple de recherche dans le tableau d'entiers suivant dfini sur l'intervalle [3..10] : 5 3 13 4 18 5 23 6 46 7 53 8 89 9 97 10

Recherche

de

46

Etape 1 : comparaison de 46 avec t[6] (6=(10+3)2), t[6]<46 => recherche dans [7..10] Etape 2 : comparaison de 46 avec t[8], t[8]>46 => recherche dans [7..7] Etape 3 : comparaison de 46 avec t[7], t[7]=46 => lment cherch trouv l'indice 7 Recherche de 10 :

Etape 1 : comparaison de 10 avec t[6], t[6]<10 => recherche dans [3..5] Etape 2 : comparaison de 10 avec t[4], t[4]<10 => recherche dans [3..3] Etape 3 : comparaison de 10 avec t[3], t[3]>10 => recherche dans [4..3], Borne infrieure suprieure la borne suprieure donc on met fin l'algorithme et l'lment cherch n'a pas t trouv !

fonction rechercheDicho(e : entier, n : entier, t : tableau entier[0..n-1]):entier dbut debut <- 0 fin <- n-1 trouve <- faux

tant que debut <= fin et non trouve faire i <- (debut+fin)2 si t[i] = e alors trouve <- vrai sinon si t[i] > e alors fin <- i-1 sinon debut <- i+1 fsi fsi ftant si trouve alors indice <- i sinon indice <- -1 fsi retourne indice fin Lexique : - e : entier, lment recherch - n : entier, taille du tableau - t : tableau entier[0..n-1], tableau tri par ordre croissant - debut : entier, dbut de la zone de recherche - fin : entier, fin de la zone de recherche - trouve : boolen, faux tant que l'lment cherch n'est pas trouv - i : entier, indice de la case du milieu de la zone de recherche - indice : entier, indice de l'lment recherch ou -1 s'il n'est pas trouv