Cours A.Denise du lundi 13 septembre 2004

Chapitre I : Bases de l’algorithme

I. Introduction

Le nom ‘algorithme’ vient d’un mathématicien arabe ‘Abu Ja Far Mohammed Ibn

mûsâ Al-Kha-Rizme’ (Bagdad, vers 780 – 850 ). Mais la notion d’algorithme est plus

ancienne. Dans l’antiquité par exemple, l’algorithme d’Euclide (300 avant J-C) permettait de

trouver les PGCD (Plus Grand Commun Diviseur) :

PGCD (42,63) = 21

42/21 = 2

63/21 = 3

La notion d’algorithme est indépendante de celle d’ordinateur.

Définition : Un algorithme est ‘Une suite finie d’instructions qui décrit un traitement

sur un nombre fini de données structurées, et qui doit se terminer après un nombre fini

d’opérations pour donner un résultat.’

L’architecture de l’algorithme doit être réfléchie, selon une décomposition du

problème en sous problèmes.

Pour comprendre :

Pour faire un gratin d’endives au jambon (pour 4 personnes)

- 4 endives

- 4 tranches de jambon

- du gruyère

- ingrédients pour une béchamel

- …

- un plat en pyrex

• faire cuire les endives à la vapeur *

• les entourer de jambon

• les mettre dans un plat allant au four *

• préparer une sauce béchamel

• recouvrir les endives de béchamel

• râper le gruyère, le mettre sur le plat

• mettre à gratiner 20 minutes au four

Certaines étapes devraient être détaillées (*), mais pour qu’un algorithme soit lisible,

il ne faut pas tout écrire d’un coup ( par exemple : ‘aller acheter du jambon cher l’épicier, s’il

est fermer aller au supermarché, etc.…’ )

II. Un premier algorithme informatique

Action DuréeDeVol

/* Demande l’heure et la minute de départ et l’heure et la minute d’arrivée

d’un avion, puis écrit la durée de vol. On suppose que le départ et l’arrivée ont

lieu le même jour et qu’il n’y a pas de décalage horaire. */

lexique

hd, md, /*heure & minute de départ */

ha, ma, /* heure & minute d’arrivée */

ht, mt, /* heure et minute de la durée du trajet */

cd, ca: /* conversion en minutes des horaires de départ & d’arrivée */

entiers

début

lire (hd, md, ha, ma)

cd ← 60 x hd + md /* ‘←’ est le symbole d’affectation */

ca ← 60 x ha + ma

mt ← ca – cd /*mt contient la durée du voyage en minutes */

ht ← mt div 60 /* division entière ou euclidienne */

mt ← mt mod 60 /* donne le reste de la division entière */

écrire (ht, mt)

fin

Les spécifications sont très importantes pour les personnes susceptibles de reprendre le

programme, par exemple pour l’inclure dans un autre programme plus complexe.

L’écriture d’un algorithme est assez libre. On n’est pas obligé de tout écrire, par

exemple en ce qui concerne les interactions utilisateur / machine. Dans le programme, il faut

écrire ces instructions pour que l’utilisateur comprenne.

III. Les instructions

1. L’affectation

< nom de variable > ← < expression >

ou

< nom de variable > := < expression >

L’affectation calcule la valeur de l’expression et range cette valeur dans la variable.

Exemples :

a ← 2

x ← 2y + 1

Il ne faut pas utiliser ‘=’ pour l’affectation, pour qu’il n’y ait pas d’ambiguïté avec le

test d’égalité ( ‘si a=3 alors…’ )

Pb : En langage C, l’affectation s’écrit ‘ := ’ et l’opérateur d’égalité s’écrit ‘ = = ’.

Spécification Que fait le

programme ?

Réalisation Comment le

fait-il ?

2. Lecture et écriture

Pour que l’ordinateur communique avec l’utilisateur :

- lecture : sur le clavier (ou dans un fichier, …)

- écriture : sur l’écran ( ou fichiers, imprimante, …)

• lire ( <nom de variable > )

→ Range dans la variable la valeur que l’utilisateur tape au clavier.

Exemple :

lire ( < var1 >, < var2 >, < var3 >, … , < var n > )

• écrire ( < expression > )

Exemples :

Ecrire ( 3 )

Ecrire ( x ) /* si x est une variable */

Ecrire ( ‘Bonjour’ )

Ecrire ( 3x – 7 )

Ecrire ( ‘Bonjour je m’appelle’ , mon_nom, ‘j’ai’, mon_age, ‘ans’ )

3. Séquence et bloc d’instructions

• Séquence d’instructions

lire ( x, y )

y ← y +2

écrire ( x – y )

ou

lire ( x, y ) ; y ← y+2 ; écrire ( x – y )

• Bloc d’instructions

début

lire (x)

y ← y + 2

écrire ( x – y )

fin

On peut remplacer début et fin par des accolades ‘{ … }’.

4. Instructions conditionnelles

• Si < expression booléenne >

Alors < instruction ou bloc >

Sinon < instruction ou bloc >

Une expression booléenne est une expression dont la valeur est soit VRAI soit FAUX.

Exemple :

Si x mod 2 = 0

Alors écrire ( ‘nombre pair’)

Sinon écrire ( ‘nombre impair’)

Si l’expression est VRAIE, exécute le ‘alors’ puis passe à l’instruction suivante. Si elle

est FAUSSE, exécute le ‘sinon’ puis passe à l’instruction suivante.

Si < expression booléenne >

Alors < instruction ou bloc >

Si l’expression est VRAIE, exécute le ‘alors’ puis passe à l’instruction suivante, sinon

passe directement à l’instruction suivante.

Exemple :

Si x < 0

Alors x ← -x

Ecrire (x)

Si x < 0

Alors

y ← x + 2

x ← - x

Ecrire (x)

Il faut écrire :

Si x < 0

Alors {

y ← x + 2

x ← - x }

Ecrire (x)

Mardi 14 septembre 2004

• ‘ selon le cas’

Si a = 0 alors …

Sinon si a = 1 alors …

Sinon si a = 2 alors …

Sinon …

� ‘Selon le cas’ permet de simplifier la syntaxe :

Selon le cas a

a = 0 : …

a = 1 : …

a = 2 : …

Sinon …

Syntaxe générale :

Selon le cas < nom de variable >

< expression booléenne sur la variable > : < instruction ou bloc >

Ce n’est pas un bloc d’instructions

< expression booléenne sur la variable > : < instruction ou bloc >

< expression booléenne sur la variable > : < instruction ou bloc >

…

[Sinon < instruction ou bloc >] /* Les ‘[…]’ signifient que cette instruction est

optionnelle */

� exécute l’instruction ou le bloc d’instruction correspondant à la première

expression VRAIE dans la liste. Si aucune n’est vraie, exécute l’instruction ou le bloc du

sinon s’il y en a un. Puis passe à l’instruction suivante.

Exemple :

Lire (n)

Selon le cas n :

n = 1 : écrire ( ‘lundi’ )

n = 2 : écrire ( ‘mardi’ )

n = 3 : écrire ( ‘mercredi’ )

n = 4 : écrire ( ‘jeudi’ )

n = 5 : écrire ( ‘vendredi’ )

n = 6 : écrire ( ‘samedi’ )

n = 7 : écrire ( ‘dimanche’ )

sinon écrire ( ‘le numéro doit être compris entre 1 et 7’ )

5. Itérations

Exemple : /* sans itération */

Action TableDeMultiplication /* Lit un entier et écrit sa table de multiplication */

Lexique

n : entier

Début

Lire (n)

Ecrire ( ‘1 x’, n , ‘=’ , n )

Ecrire ( ‘2 x’, n , ‘=’ , 2 x n )

Ecrire ( ‘3 x’, n , ‘=’ , 3 x n )

…

Ecrire ( ‘10 x’, n , ‘=’ , 10 x n )

Fin

Problème : Si on veut écrire jusqu’à 1000 x n, le programme devient très long.

� On fait une itération ( ou boucle ) qui permet de faire une même instruction en

changeant une variable à chaque tour de boucle

• La boucle ‘pour’

Pour < nom de variable >

allant de < expression entière 1>

à < expression entière 2 >

faire < instruction ou bloc >

La variable prend la valeur de la première expression, puis le bloc est exécuté ( * ),

puis la variable est incrémentée de 1.

Si sa valeur est inférieure ou égale à l’expression 2, on revient à ( * ), sinon on passe à

l’instruction suivante.

Exemple :

Lexique

n, i : entiers

Début

Lire (n)

Pour i allant de 1 à 10 faire

Ecrire ( i, ‘x’, n, ‘=’, i x n )

Fin

Il est interdit de :

- modifier la valeur de l’indice de boucle ( i ) à l’intérieur de la

boucle

- modifier les valeurs des bornes à l’intérieur de la boucle, par

exemple quand on a :

b ← 4

pour j allant de a à b faire

j ← 0

b ← 2b

Remarque : Si a>b, le bloc ne s’exécute pas.

Mercredi 15 septembre 2004

• Les boucles ‘tant que’

Il en existe deux :

1. Tant que < expression booléenne >

Faire < instruction ou bloc >

2. Faire < instruction ou bloc >

Tant que < expression booléenne >

La boucle 1. : (*) Regarde la valeur de l’expression

Si elle est VRAIE, exécute l’instruction ou le bloc et revient à (*)

Sinon, passe à l’instruction suivante

La boucle 2. : (*) Exécute l’instruction ou le bloc, puis

Si l’expression a pour valeur VRAI, revient en (*)

Sinon passe à l’instruction suivante

Dans la version 2, l’instruction (ou bloc) est exécutée au moins une fois, ce qui n’est

pas le cas dans la version 1.

Exemples :

- Tables de multiplication :

lire (x)

i ← 1

tant que i ≤ 10 faire

{

écrire (i, ‘*’, x, ‘=’, i * x)

i ← i + 1

}

- /* Nombre de fois qu’un nombre entier est divisible par 2*/

lire (x)

compteur ← 0

tant que n mod 2 = 0 faire

{

n ← n div 2

compteur ← compteur +1

}

écrire (compteur)