Algorithme et Programmation

Sommaire
Sommaire .................................................................................................................................... A
Chapitre I. Notion d’Algorithmique et de Programmation .............................................................. 1
1.1. Introduction .................................................................................................................................. 1
1.2. Les fondements de l’informatique (Architecture de Von Neumann) .......................................... 1
1.3. Algorithmique ............................................................................................................................... 2
1.3.1. Historique .............................................................................................................................. 2
1.3.2. Définition ............................................................................................................................... 2
Chapitre II. Instructions de Base.................................................................................................... 5
2.1. Structure d’un algorithme ............................................................................................................ 5
2.1.1. Partie En-tête......................................................................................................................... 5
2.1.2. Partie Déclaration .................................................................................................................. 5
2.1.3. Partie Traitement .................................................................................................................. 5
2.2. Les Variables ................................................................................................................................. 6
2.2.1. Principe .................................................................................................................................. 6
2.2.2. Déclaration ............................................................................................................................ 6
2.2.3. Les Types (Primitifs)............................................................................................................... 7
2.2.4. Saisie et affichage .................................................................................................................. 9
2.2.5. Opérateurs et Calculs .......................................................................................................... 10
2.2.6. Les opérateurs de comparaison .......................................................................................... 11
2.3. Travaux Dirigés ........................................................................................................................... 12
Chapitre III. Le Langage C (Les fondamentaux) ............................................................................. 13
3.1. Présentation d’un programme en C ........................................................................................... 13
3.2. Outils nécessaires au Programmeur........................................................................................... 14
3.3. Instructions de base en C ........................................................................................................... 14
3.3.1. Les Variables ........................................................................................................................ 14
3.3.2. Saisie et affichage ................................................................................................................ 17
3.4. Travaux Pratiques ....................................................................................................................... 17
Chapitre IV. Les Structures de Contrôle ....................................................................................... 18
4.1. Les tests et conditions ................................................................................................................ 18
4.1.1. Tests SI ................................................................................................................................. 18
4.2. Les Structures Itératives ............................................................................................................. 25
4.2.1. La boucle Tant Que .............................................................................................................. 25
4.2.2. Répéter … Jusqu’à ............................................................................................................... 26
4.2.3. Pour … Fin Pour ................................................................................................................... 27
Chapitre V. Les Tableaux............................................................................................................. 29

Prof : CAMARA Mohamed 1 A

Algorithme et Programmation

5.1. Les Tableaux ............................................................................................................................... 29

5.1.1. Principe et définition ........................................................................................................... 29
5.1.2. Les dimensions .................................................................................................................... 29
5.1.3. Types d’un tableau .............................................................................................................. 29
5.1.4. Déclaration d’un tableau ..................................................................................................... 30
5.1.5. Initialisation de tableaux à un indice ................................................................................... 30
5.1.6. Utilisation ............................................................................................................................ 30
Chapitre VI. Les Procédures et Fonctions ..................................................................................... 31
6.1. Les Procédures ........................................................................................................................... 32
6.2. Les fonctions ............................................................................................................................... 32
6.3. Variables Locales et Globales ..................................................................................................... 34
6.3.1. Locales ................................................................................................................................. 34
6.3.2. Globales ............................................................................................................................... 34
6.4. Les Paramètres ........................................................................................................................... 35
6.4.1. Procédures........................................................................................................................... 35
6.4.2. Les Fonctions ....................................................................................................................... 36
6.5. Travaux Pratiques ....................................................................................................................... 37

Prof : CAMARA Mohamed 1 B

Algorithme et Programmation

Chapitre I. Notion d’Algorithmique et de Programmation

1.1. Introduction
Apprendre à programmer, c’est savoir comment font les autres pour créer de superbes logiciels, c’est
savoir à terme comment les créer soi-même, et les développer. On ne s’improvise pas program-
meur. C’est un métier, et comme tout métier, cela s’apprend et demande l’apprentissage des no-
tions fondamentales de programmation et l’ensemble de ces notions s’appelle l’algorithmique ou
pseudocode.

Pour apprendre à programmer, il faut d’abord comprendre ce qu’est vraiment un ordinateur, com-
ment il fonctionne et surtout comment il peut faire fonctionner des programmes, comment il mani-
pule et stocke les données et les instructions, quelle est sa logique. Alors, au fur et à me-
sure, le reste coule de source comme une évidence: variables, tests, conditions, boucles, ta-
bleaux, fonctions, fichiers, jusqu’aux notions avancées comme les pointeurs et les objets.

1.2. Les fondements de l’informatique (Architecture de Von Neumann)

Un ordinateur est un ensemble de circuits électroniques permettant de manipuler des informa-
tions qu’on appelle des données et capable de faire "tourner" des programmes,
c’est­à­dire une suite ou séquence d’instructions programmées à l’avance et qu’il va dérouler du dé-
but à la fin dans le but d’obtenir des résultats. Pour comprendre comment un ordinateur peut dérou-
ler un programme, il faut étudier un peu plus en détail son fonctionnement.

C’est Von Neumann (mathématicien et physicien américano-hongrois) qui a défini en 1944 l’architec­
ture des ordinateurs modernes encore largement utilisée aujourd’hui (avec des variantes cepen-
dant). L’architecture de Von Neumann décompose l’ordinateur en quatre parties distinctes :

1. L’Unité Arithmétique et Logique UAL (ALU en anglais) est l’organe de l’ordinateur qui exé-
cute les calculs : additions, soustractions, multiplications, divisions, modulos, ges-
tion des signes (positif, négatif), opérations logiques (booléenne), comparaisons, parfois ro-
tations et décalages de valeurs (toujours dans le cadre d’une logique boo-
léenne). Il existe des UAL spécialisées dans les nombres à virgule flot-
tante, d’autres dans des traitements complexes comme les logarithmes, les inversions, les ra-
cines, les vecteurs, les calculs trigonométriques, etc. Certaines documentations lui rajou-
tent quelques registres (petites cases mémoires intégrées à l’UAL) et lui don-
nent le nom de processeur (CPU).
2. L‘Unité de Contrôle UC (CU en anglais), à ne pas confondre avec Unité Centrale, con-
trôle le séquençage des opérations, autrement dit le déroulement du pro-
gramme. Elle prend ses instructions dans la mémoire et donne ses ordres à l’UAL. Les résul-
tats retournés peuvent influer sur le séquençage. L’UC passe alors à l’instruction sui-
vante ou à une autre instruction telle que le programme lui ordonne d’effectuer.
3. La mémoire peut être décrite comme une suite de petites cases numéro-
tées, chaque case pouvant contenir une petite information (pe-
tite dans le sens où la taille de chaque case est fixe). Cette information peut être une instruc-
tion ou un morceau d’instruction du programme (une instruction peut occuper plu-
sieurs cases) ou une donnée (nombre, caractère, ou mor-
ceau de ceux-ci). C’est l’UC qui a comme rôle central de contrôler l’accès à la mé-
moire pour le programme et les données. Chaque numéro de case est ap-

Prof : CAMARA Mohamed 1 1

Algorithme et Programmation

pelé une adresse. Pour accéder à la mémoire, il suffit de connaître son adresse. Les instruc-
tions du programme pour l’UC et les données pour l’UAL sont placées dans des zones diffé-
rentes de la même mémoire physique.
4. Les Entrées/Sorties E/S (I/O en anglais) permettent de communiquer avec le monde exté-
rieur et donc vous : ce peut être un clavier pour entrer les données, et un écran pour affi-
cher les résultats. Il permet à l’ordinateur d’être interactif.

Les instructions du programme sont présentes dans la mémoire. L’unité de contrôle va pren-
dre la première instruction du programme et l’exécuter. Si l’instruction est par exemple d’addition­
ner deux nombres, elle va demander à l’UAL de prendre ces deux nombres en mémoire et de les ad-
ditionner et éventuellement de placer le résultat dans une nouvelle case. Puis l’UC passe à l’instruc­
tion suivante. Si elle consiste à afficher ce résultat, alors l’UC va lire le contenu de la mé-
moire à l’adresse où est placé le résultat, puis va envoyer le résultat via le composant d’E/S adé-
quat. Et ainsi de suite.
1.3. Algorithmique
Il existe plusieurs langages de programmation très simples, extrêmement simples parfois, qui peu-
vent donner un temps l’illusion que vous savez programmer. En entreprise même, certains em-
ployés sont appelés développeurs pour leurs quelques connaissances confuses de Visual Ba-
sic, de Delphi ou de WinDev. Les publicités sont alléchantes mais trompeuses. Les bons program-
meurs, y compris les autodidactes, ont tous à un moment ou un autre eu affaire avec les algo-
rithmes, car il existe en programmation une multitude de moyens d’arriver à un résultat,
mais très peu pour obtenir le meilleur résultat possible, ce qui explique pourquoi beaucoup de pro-
grammes ayant la même fonction, se ressemblent (au niveau de la programma-
tion) alors que ce ne sont pas les mêmes programmeurs qui les ont développés. Les débu-
tants qui se lancent dans des projets de programmation audacieux se retrouvent parfois blo-
qués, ne maîtrisant pas une technique particulière de logique de programmation. Certains aban-
donnent, d’autres trouvent un moyen de contournement (souvent peu reluisant). C’est pourquoi il
est souvent dit que « programmer, c’est un art »

1.3.1. Historique
Le mot « algorithme » n’est pas dérivé d’un mot latin ou grec, mais d’une contraction et d’une déri-
vation du nom du mathématicien persan ALKHUWARIZMI surnommé le père de l’algèbre dont les
travaux sur l’algèbre et l’arithmétique ont considérablement fait progresser la pensée mathéma-
tique. Trois siècles plus tard son œuvre sur les algorithmes fut traduite en latin et porta le nom « al-
gorismus ».

1.3.2. Définition
Une définition simple d’un algorithme : c’est une suite d’instructions qui, quand elles sont exécu-
tées correctement aboutissent au résultat attendu.

L’algorithme décrit formellement ce que doit faire l’ordinateur pour arriver à un but bien pré-
cis. Ce sont les instructions qu’on doit lui donner. Ces instructions sont souvent décrites dans un lan-
gage clair et compréhensible par l’être humain : faire ceci, faire cela si le résultat a telle va-
leur, et ainsi de suite. Un algorithme bien établi et qui fonctionne (tout au moins en théo-
rie) pourra être directement réécrit dans un langage de programmation évo-
lué comme le C, Java ou PHP.

Prof : CAMARA Mohamed 1 2

Algorithme et Programmation

Plus que cela, un algorithme décrit une méthode de résolution de problèmes courants. Un algo-
rithme est donc réutilisable. Il existe plusieurs moyens d’obtenir un même résultat, mais cer-
tains sont meilleurs que d’autres.

Remarque : il n’existe pas de méthode pour découvrir un algorithme, sa réalisation est un acte créatif
et ne dépend pas d’un langage de programmation mais par contre sa traduction en dépend.

Caractéristiques d’un algorithme

• Robustesse : aptitude à se protéger des conditions anormales d’utilisation.

• Réutilisabilité : aptitude est être réutilisé pour résoudre des tâches équivalentes (à celle
pour laquelle il a été conçu).
• Complexité : nombre d’instructions élémentaires à exécuter.
• Efficacité : aptitude à utiliser de manière optimale les ressources matérielles qui l’exécute.

Convention d’écriture d’un algorithme

Historiquement, plusieurs types de notation ont représenté des algorithmes.

Il y a eu notamment une représentation graphique avec des carrés des losanges, etc… qu’on appelait
des organigrammes. Aujourd’hui, cette représentation quasiment abandonnée pour deux raisons :

D’abord, parce que dès que l’algorithme commence à grossir un peu, ce n’est plus pratique du tout ;

Ensuite cette représentation favorise le glissement vers un certain type de programmation non struc-
turée.

C’est pourquoi on utilise généralement une série de convention appelée « pseudocode », qui res-
semble à un langage de programmation authentique dont on aurait supprimé la plupart des pro-
blèmes de syntaxe.

Le pseudocode est purement conventionnel.

Exemples d’algorithmes simples :

Informatique :

Algorithme qui fait la somme de deux nombres entiers naturels :

Traitement :

✓ Choisir deux (2) nombres : a et b ;

✓ Choisir un type : entier ;
✓ Faire la somme : a+b;

Prof : CAMARA Mohamed 1 3

Algorithme et Programmation

✓ Récupérer le résultat : c=a+b ;

Vie courante :

Algorithme de préparation d’une omelette :

Préparation :

✓ Avoir des œufs, une poêle, de l’huile, ingrédients ;

✓ Avoir du feu ;
✓ Casser les œufs et les battre ;
✓ Chauffer l’huile dans la poêle ;
✓ Y verser les œufs ;
✓ Fin de préparation et à table !!!

Prof : CAMARA Mohamed 1 4

Algorithme et Programmation

Chapitre II. Instructions de Base

2.1. Structure d’un algorithme
Un algorithme est généralement constitué de trois parties :

1. Une partie En-tête ;

2. Une partie Déclaration ;
3. Une partie Traitement.

2.1.1. Partie En-tête

Il sert à débuter et à donner un titre à l’algorithme. Il commence toujours par le mot clé « algo-
rithme » qui ne doit pas utilisé comme identificateur. Le titre de l’algorithme ne doit pas contenir
des espacements excepté l’underscore (tiret de huit) « _ » ou de commencer chaque mot du titre par
une majuscule sans utiliser l’underscore ou encore de de commencer le premier mot par une minus-
cule.

Syntaxe : Algorithme ou Algo <identificateur>

Exemples:

• Algorithme somme_des_entiers

• Algorithme SommeDesEntiers

• Algorithme sommeDesEntiers

NB : un mot clé ne doit pas être utilisé comme identificateur. Un identificateur est un mot choisi par le
programmeur pour désigner un objet (titre, variable, etc.)

2.1.2. Partie Déclaration

Elle sert à déclarer les objets appelés variables qui sont utilisés dans la partie Traitement d’un algo­
rithme. Elle commence par le mot clé « Variable » ou « Var ».

Syntaxe : Variable <identificateur 1>, <identificateur 2>, <identificateur n>: <Type>

Exemple :

Variable a, b : entier

2.1.3. Partie Traitement

La partie « Traitement », contient le bloc d’instructions qui est une partie du traitement d’un algo­
rithme, constituée d’opérations élémentaires commencée par les mots clés « Début » et terminée
par « Fin » suivi d’un point «.» pour exprimer la fin de l’algorithme.

Syntaxe :

Début
< Bloc d’instruction >
Fin.

Prof : CAMARA Mohamed 1 5

Algorithme et Programmation

Exemple :

Début
S a+b
Fin.

Conventionnellement un algorithme est composé comme suit :

Algorithme < nom_de_l’algorithme > Partie En-tête

Variable <déclaration de variables > Partie Déclaration

Début

< Bloc d’instruction > Partie Traitement

Fin.

Remarque : L’Algorithmique est le langage utilisé pour faire des algorithmes et la Programmation
est la traduction d’un algorithme dans un langage de programmation. Dans notre cas, on utilisera le
langage C pour compiler ou traduire nos algorithmes.

2.2. Les Variables

2.2.1. Principe
Dans un programme informatique, on va avoir en permanence besoin de stocker provisoirement des
valeurs. Il peut s’agir de données issues du disque dur, fournies par l’utilisateur (frappées au clavier).
Il peut aussi s’agir de résultats obtenus par le programme, intermédiaires ou définitifs. Ces données
peuvent être de plusieurs types : elles peuvent être des nombres, du texte, etc. Toujours est-il que
l’on a besoin de stocker une information au cours d’un programme, on utilise une « variable ».

Une variable est comme une boite, que le programme va réparer par une étiquette. Pour avoir accès
au contenu de la boite, il suffit de la designer par son étiquette.

Tout simplement une variable est un emplacement mémoire que le programme réserve sur la RAM
pour recueillir les données de façon temporaire. On le reconnait par son adresse mémoire.

2.2.2. Déclaration
Pour exister, une variable doit être déclarée, c’est­à­dire que vous devez indiquer au début de l’algo­
rithme comment elle s’appelle et ce qu’elle doit contenir. En effet, pour que l’algorithme uti-
lise votre variable, il doit déjà savoir qu’elle existe et ce qu’elle doit contenir. Il ne s’agit pas ici de dé-

Prof : CAMARA Mohamed 1 6

Algorithme et Programmation

finir la valeur de la variable, vous pourrez le faire dans la suite de l’algorithme en lui affectant une va-
leur. Il s’agit de donner son nom et de préciser le type de valeur qu’elle peut contenir. Les va-
riables se déclarent au début de l’algorithme, avant le programme lui-même mais après le mot « Va-
riable » ou « Var ». Toutefois, une règle absolue est qu’un nom de variable peut comporter des
lettres et des chiffres mais qu’il exclut la plupart des signes de ponctuation, en particulier les espaces.
Un nom de variable correct commence impérativement par une lettre.

Exemple :

Var
Variable1 : type
Variable2, variable3 : type
...
2.2.3. Les Types (Primitifs)
Une case mémoire contient généralement un octet, c’est-à-dire une valeur de 0 à 255. Mais une va-
riable peut très bien contenir le nombre 214862, le réel 3,1415926, le texte "bon-
jour", etc. Donc une variable n’est pas uniquement définie par la valeur qu’elle con-
tient, mais aussi par la place que cette valeur occupe et par la manière dont l’algorithme va la repré-
senter et l’utiliser : nombre, texte, etc. C’est le type de la variable. Que pouvez-
vous mettre comme valeur dans une variable ? En principe, tout ce que vous voulez. Cepen-
dant, vous devez tout de même préciser quel type la valeur représente. Est-ce un nombre ?

Si oui, un entier (sans virgule) ou un réel (avec virgule) ? Est-ce du texte ? Est-ce un ta-
bleau ? Et ainsi de suite. Vous entendrez parfois parler du "codage" de la variable : se-
lon le type et la taille de la valeur, celle-ci est encodée de manière différente dans la mémoire, uti-
lisant plus de cases.

a. Les Nombres

Placer des nombres dans la variable est le plus évident, et souvent le plus courant. Une case mé-
moire peut contenir un octet, c’est­à­dire une valeur comprise entre 0 et 255. Mais si elle doit conte-
nir une valeur négative ? Alors sur les 8 bits, un sera réservé au signe, et la case mémoire pourra con-
tenir des valeurs de -127 à +128. On dit alors que la variable est "signée" : elle peut contenir des va-
leurs positives et des valeurs négatives. Seulement, 8 bits ne sont pas suffisants pour des grandes va-
leurs. C’est pourquoi les nombres peuvent être pla-
cés dans deux cases (16 bits), quatre cases (32 bits) ou plus.

Si l’ordinateur est bien plus à l’aise et bien plus rapide avec des nombres entiers, il sait aussi manipu-
ler des nombres réels, bien que dans ce cas leur codage en binaire soit radicalement diffé-
rent. Vous trouverez plus bas toutes les explications nécessaires pour comprendre comment l’ordi­
nateur se représente exactement les nombres négatifs et réels : ce n’est pas si évident !

Au final, l’ordinateur est capable de gérer des nombres de longueur variable, signés ou non, en-
tiers ou réels. Suivant le langage de programmation, les types portent des noms différents. Cepen-

Prof : CAMARA Mohamed 1 7

Algorithme et Programmation

dant le C et ses dérivés proposent les types sui-

vants :

Pour les variables contenant des nombres réels, ces derniers s’écrivent avec une vraie vir-
gule comme en français "3,14" ou avec le point décimal, cependant dans les langages de program-
mation, ce sera bien souvent le point qui sera utilisé "3.14". Une variable numérique peut conte-
nir des nombres positifs ou négatifs, mais l’intervalle de valeurs se trouve "un peu" ré-
duite. Le seul type non signé est le type char (le type caractère) pour des raisons évidentes.

b. Les caractères

Une variable peut aussi contenir des caractères. Suivant les livres et sites Internet, vous trouve-
rez les types "Alphanumérique", "Caractère", "Chaîne", "String". Ainsi une va-
riable peut stocker votre nom, une ligne complète de texte, ou tout ce que vous voulez qui néces-
site une représentation alphanumérique. On appelle d’ailleurs une suite de caractères alphanumé-
rique une chaîne de caractères.

Si vous devez représenter un seul caractère, utilisez le type "caractère". Pour une chaîne, utili-
sez le type "chaîne".

Exemple :

Var
Texte: chaîne
Car: caractère

Quelle place occupe une chaîne de caractère ? En principe, un caractère occupe un oc-
tet. À chaque valeur comprise entre 0 et 255 est associé un caractère. C’est le principe de l’AS-
CII "American Standard Code for Information Interchange", norme de codage des carac-

Prof : CAMARA Mohamed 1 8

Algorithme et Programmation

tères la plus connue et la plus utilisée. La table ASCII, inventée par les américains, con-
tient à l’origine les 128 caractères utiles pour écrire en anglais. Par défaut elle ne con-
tient pas les accents. Or la table ASCII peut contenir 256 caractères. Les 128 autres (huitièmes
bits à un) contiennent des caractères semi-graphiques et des caractères spécifiques à cer-
taines langues, typiquement le français, pour les caractères accen-
tués. On parle alors de page de code ou de charset. Ces pages font l’objet d’une normalisa-
tion, par exemple la norme ISO 8859-15 qui est la page d’Europe de l’Ouest, avec le carac-
tère de l’euro "€". Dans la plupart des langages ce codage sur un octet suf-
fit et ainsi une chaîne de caractères de 50 caractères occupe 50 octets.

En pseudo-code algorithmique, les chaînes de caractères sont placées entre guillemets.

c. Le type booléen

Pour déterminer si une affirmation est vraie ou fausse, l’ordinateur doit se baser sur le résul-
tat de cette affirmation. En informatique, on emploie plus volontiers la notion d’expression et d’éva­
luation de cette expression. Une expression peut être décrite comme étant tout ce qui peut four-
nir une valeur que l’ordinateur peut déterminer, stocker, évaluer. Par exemple, l’affirma­
tion "a>b" selon laquelle a est supérieur à b. Si a vaut 3 et b vaut 2, l’affirmation est vraie. Si mainte-
nant a vaut 1 et b vaut 2, l’affirmation est fausse. Dans les deux cas "a>b" est une expres-
sion qui vaut soit vrai, soit faux. C’est le cas le plus simple, mais aussi le plus courant et le plus pra-
tique comme vous le verrez lors des tests et des conditions.

Comment l’ordinateur détermine-t-il ce qui est vrai et faux? C’est le rôle, dans l’architec-
ture de Von Neumann, de l’UAL. Sous quelle forme l’ordinateur se repré-
sente-t-il ce qui est vrai ou faux ? Sous forme numérique, comme toujours. Tout ce qui re-
tourne un résultat différent de zéro (0) est considéré comme étant vrai, donc si le résul-
tat vaut zéro (0) alors il sera considéré comme faux.

Exemple :

Var
Test: booléen

d. Affectation

Pour donner une valeur à une variable, il faut passer par un processus d’affecta­
tion à l’aide d’un opérateur. En pseudo-code, on utilise le symbole d’affecta­
tion «←». À gauche de ce symbole, vous placez le nom de la variable, à droite la valeur.

Syntaxe :

< NomVariable > ← <Valeur >

Exemple :

Nbre ← 2017

2.2.4. Saisie et affichage

Pour simuler l’affichage d’un texte ou d’une valeur sur l’écran, il faut utiliser la pseudo-instruc-
tion "Afficher" qui prend à sa suite une chaîne de texte ou une variable. Si vous mélan-
gez du texte et des variables, séparez ceux-ci par des virgules. À l’affichage, les virgules seront rem-
placées par des espaces.

Prof : CAMARA Mohamed 1 9

Algorithme et Programmation

Syntaxes : Afficher ("<message>")

Afficher ("<message>", <variable>)

Exemple :

Algorithme AFFICHE
Var
A: entier
Texte: chaîne
Début
A←10
Texte←"Hello World"
Afficher (a)
Afficher (texte)
Afficher ("Bonjour le monde", texte)
Fin.

Pour inviter un utilisateur à rentrer au clavier une valeur utilisez le mot "Lire". L’algorithme atten-
dra alors une entrée au clavier qui sera validée avec la touche d’entrée. La valeur que vous saisis-
sez sera placée dans la variable indiquée à la suite de " Lire".

Exemple :

Algorithme SAISIE
Var
reponse: chaîne
Début
Afficher ("Quel est votre nom ?")
Lire (reponse)
Afficher ("Vous vous appelez", reponse)
Fin.

Si vous devez saisir plusieurs valeurs à placer chacune dans une variable, vous pouvez utiliser plu-
sieurs "Lire", mais plus simplement placez les diverses variables à la suite d’un unique Saisir, sépa-
rées par des virgules. L’utilisateur devra alors saisir plusieurs valeurs (selon le langage fi-
nal : les unes à la suite des autres séparées par des espaces, ou en appuyant sur la touche [En-
trée] après chaque saisie).

Exemple :

Algorithme SAISIE_MULTIPLE
Var
nom, prenom: chaînes
Début
Afficher ("Quels sont vos noms et prénoms ?")
Lire (nom,prenom)
Fin.
2.2.5. Opérateurs et Calculs
a. Les opérateurs arithmétiques

Prof : CAMARA Mohamed 1 10

Algorithme et Programmation

Pour que les algorithmes puissent effectuer des calculs, il faut pouvoir au moins faire des opéra-
tions simples. Vous utiliserez pour cela les symboles suivants :

• + : addition
• - : soustraction
• ou x : multiplication (il est plus facile d’écrire un x pour fois qu’une étoile)
• / : division
• % ou mod : modulo
• DIV : La division entière

NB : Il est possible de grouper les calculs avec des parenthèses "(...)". Celles-ci influent sur la prio-
rité des calculs. Vous vous rendrez compte en effet que les opérateurs ont des degrés de priorité diffé-
rents. Par exemple, une multiplication est "plus forte" qu’une addition. Si vous souhaitez indi-
quer à l’algorithme, et donc ensuite dans un vrai langage, une modification des priorités, vous de-
vez utiliser les parenthèses.

b. Les opérateurs booléens

Les opérateurs ne permettent pas que de faire des calculs. Dans une expression, un opéra-
teur peut aussi effectuer des évaluations de booléens. Vous avez vu que pour l’ordina­
teur tout ce qui est vrai est différent de 0, ce qui est faux valant 0. Comment alors faire si deux ex-
pressions sont l’une vraie, l’autre fausse, pour connaître la valeur des deux conjuguées? Il faut utili-
ser des opérateurs booléens pour indiquer ce qui doit être consi-
déré comme vrai : l’un ou l’autre, les deux en même temps, etc.

• L’opérateur ET indique que les deux expressions situées avant et après doi-
vent être toutes les deux vraies pour que l’ensemble le soit aussi.
• L’opérateur OU indique que seule l’une des deux expressions, que ce soit celle si-
tuée avant ou celle située après, doit être vraie pour que l’expression com-
plète soit vraie aussi.
• Le NON est la négation. Si l’expression était vraie elle devient fausse, et vice versa.

Dans quel cas les opérateurs booléens sont-ils utiles? Dans les expressions utilisées dans des condi-
tions (exécuter une action selon tel ou tel critère) quand ces conditions sont mul-
tiples. Par exemple, si vous voulez exécuter une action uniquement si deux va-
riables a et b sont vraies (contiennent autre chose que 0).

2.2.6. Les opérateurs de comparaison

Pour évaluer une expression, il faut parfois avoir besoin de comparer des valeurs. Comment savoir si
un utilisateur de votre logiciel a répondu oui ou non à votre question? Comment sa-
voir si le chiffre saisi dans le jeu du lancer de dé correspond au bon résultat ? Vous allez devoir utili-
ser les opérateurs de comparaison. Il y en a plusieurs. Ceux-ci sont des opérateurs binaires : ils pren-
nent deux valeurs, une avant et une après. Ces valeurs peuvent être soit des scalaires (entiers, ré-
els, chaînes de caractère - selon le langage utilisé) directement, soit leur représenta-
tion sous forme de variable. L’ordinateur évaluera le résultat de cette comparaison sous forme boo-
léenne : le résultat sera vrai ou faux.

a. L’égalité

Prof : CAMARA Mohamed 1 11

Algorithme et Programmation

L’opérateur d’égalité s’écrit avec le signe "=" et sert à vérifier si les deux va-
leurs à droite et à gauche sont identiques, c’est­à­dire qu’elles ont la même va-
leur. Dans cet exemple, l’expression a=b est vraie, mais a=c est fausse.

Il ne faut surtout pas confondre, tant en algorithmique que dans les langages de programma-
tion, l’opérateur d’affectation "←" et l’opérateur d’égalité "=". En mathématique et en langage cou-
rant, a=b peut avoir deux significations : soit a reçoit la valeur de b, soit on cherche à véri-
fier si a et b sont égaux. Laquelle est la bonne ? Dans un langage comme le BASIC, l’interpréta­
tion du signe « = » dépend du contexte. Avec une variable avant et hors contexte de condi-
tion, c’est une affectation. Dans une expression conditionnelle, c’est une comparaison.

b. La différence

L’opérateur de différence est décrit par le symbole "<>" qu’il faut comprendre comme la néga-
tion (voir opérateur booléen) de l’égalité. Attention, une expression "a<>b" est vraie si la va-
leur de a est différente de b.

c. Inférieur, supérieur

Quatre opérateurs permettent de comparer des valeurs inférieures et supérieures, avec ou sans éga-
lité :

• < : inférieur
• <= : inférieur ou égal
• > : supérieur
• >= : supérieur ou égal
La compréhension de ces quatre opérateurs ne doit pas poser de problème. Le résul-
tat est vrai si la valeur de gauche est inférieure, inférieure ou égale, supérieure, supé-
rieure ou égale à la valeur de droite.

2.3. Travaux Dirigés

Prof : CAMARA Mohamed 1 12

Algorithme et Programmation

Chapitre III. Le Langage C (Les fondamentaux)

C’est un langage de programmation (ensemble d’instructions et de règles syntaxiques) impératif ou
séquentiel, généraliste et simple. Inventé au début des années 1970 pour réécrire Unix, c’est devenu
un des langages les plus utilisés. De nombreux langages plus moderne comme C++, C#, Java et PHP
ont une syntaxe similaire au C et reprennent en parti sa logique. II fut conçu par développeur améri-
cain Dennis Ritchie. Sa première version fut apparue en 1972.

3.1. Présentation d’un programme en C

Le minimum de code en langage C :

# include <stdio.h>

# include <stdlib.h>

int main ( )

return 0;

Ce code ci-dessus est ce qu’on appelle une fonction à partir de « main ». Un programme en langage C
est constitué de fonctions, ils ne contiennent quasiment que ça.

Une fonction permet de rassembler plusieurs commandes à l’ordinateur. Regroupées dans une fonc­
tion, les commandes permettent de faire quelque chose de précis.

• # include <stdio.h> et # include <stdlib.h>, ces lignes on les appelle Directives de Préproces-
seurs.

D’abord le mot « include » en anglais signifie « inclure » en français. Ces lignes demandent d’inclure
des fichiers au projet, c’est-à-dire d’ajouter des fichiers pour la compilation.

Elles sont aussi appelées Bibliothèques, certains parlent aussi de Librairies. En gros, ces fichiers con-
tiennent du code tout prêt qui permet d’afficher du texte à l’écran.

• « main » en français principal, est la fonction principale du programme c’est toujours par la
fonction « main » que le programme commence. Une fonction a un début et une fin délimi-
tés par des accolades { }.
• « return 0 » ; cette ligne indique qu’on arrive à la fin de notre fonction « main » et demande
de renvoyer la valeur 0 qui signifie que tout s’est bien passé.

NB: Toute instruction se termine obligatoirement par un point-virgule « ; » sinon le programme ne

compilera pas.

Quelques Caractères Spéciaux en C :

• \n : retour à la ligne, exemple : printf ("hello world! \n");

• = : permet d’affecter une valeur ou expression à une variable
• && = ET
• || = OU

Prof : CAMARA Mohamed 1 13

Algorithme et Programmation

3.2. Outils nécessaires au Programmeur

Voici le strict minimum dont un programmeur a besoin pour un faire des programmes :

• Un éditeur de texte pour écrire le code source du programme. En théorie un logiciel comme
le Bloc-notes sous Windows, ou « vi » sous Linux fait l'affaire. L'idéal, c'est d'avoir un éditeur
de texte intelligent qui colore tout seul le code, ce qui vous permet de vous y repérer bien
plus facilement ;
• Un compilateur pour transformer « compiler » votre code source en binaire ;
• Un débogueur pour vous aider à traquer les erreurs dans votre programme. On n'a malheu-
reusement pas encore inventé le « correcteur » qui corrigerait tout seul nos erreurs. Ceci dit,
quand on sait bien se servir du débogueur, on peut facilement retrouver ses erreurs!

D’où l’utilité des « trois-en-un » ou Environnement de Développement Intégré « IDE » ou tout sim-
plement des « Compilateurs » (abus de langage) qui regroupe en son sein les trois logiciels dont un
programmeur a besoin. Dans notre cas, on utilisera le compilateur « Dev-C++ » ou « Code::Blocks »
pour coder nos programmes.

3.3. Instructions de base en C

3.3.1. Les Variables
C’est une petite information temporaire qu’on stocke dans la RAM. On dit qu’elle est variable car
c’est une valeur qui peut changer pendant le déroulement du programme.

En langage C, une variable est constituée de deux choses :

• Une valeur : c’est le nombre qu’elle stocke, par exemple : 7 ;

• Un nom : c’est ce qui permet de la reconnaitre.

a. Types de Variables

Lorsque vous créez une variable, vous allez donc devoir indiquer son type.

Voici les principaux types de variables existant en langage C :

Les trois premiers types (signed char, int, long) permettent de stocker des nombres entiers : 1, 2, 3,

4…

Les deux derniers (float, double) permettent de stocker des nombres décimaux (appelés nombres
flottants) : 13.8, 16.911…

Prof : CAMARA Mohamed 1 14

Algorithme et Programmation

Vous verrez que la plupart du temps on manipule des nombres entiers.

Ce n'est pas tout ! Pour les types entiers (signed char, int, long…), il existe d'autres types dits un-
signed (non signés) qui eux ne peuvent stocker que des nombres positifs. Pour les utiliser, il suffit
d'écrire le mot unsigned devant le type :

Pour les caractères et les chaînes de caractères en C, on utilise le type «char». Pour l’initialisation on
utilise « ‘ » pour les simples caractères et « ‘‘ » pour les chaines de caractères

Exemples :

1. #include<stdio.h>
int main()
{
char mot;
char mot2='C';
printf("saisissez une lettre\n");
scanf("%c", &mot);
printf("bravo votre lettre saisie est: %c et voici: %c\n", mot, mot2);
return 0;
}

2. #include<stdio.h>
int main()
{
char chaine= ‘‘chaine de caractères‘‘;

printf("saisissez une chaine\n");

gets(chaine);
printf("bravo votre lettre saisie est: %s\n", mot);
return 0;
}

b. Déclaration d’une Variable

Une déclaration de variable, c'est très simple maintenant que vous savez tout ce qu'il faut, souvent
faite dans les accolades en début de fonction. Il suffit dans l'ordre :

1. D’indiquer le type de la variable que l'on veut créer ;

2. D’insérer un espace ;
3. D’indiquer le nom que vous voulez donner à la variable ;
4. Et enfin, de ne pas oublier le point-virgule.

Par exemple, si on veut créer une variable nombreDeVies de type int, on doit taper la ligne suivante :

Prof : CAMARA Mohamed 1 15

Algorithme et Programmation

Code : C

int nombreDeVies;

c. Affectation d’une valeur à une Variable

Il suffit de procéder comme ceci :

Code : C

nombreDeVies = 5;

Le symbole de l’affectation est « = »

d. Affichage du contenu d’une Variable

On utilise en fait « printf » de la même manière, sauf que l’on rajoute un symbole spécial à l’endroit
où l’on veut afficher la valeur de la variable.

Exemple : printf ("Il vous reste %d vies", v) ;

Si la variable v est égale à 7 par exemple, à l’affichage on aura « Il vous reste 7 vies », comme mes-
sage à l’écran.

Ce « symbole spécial » dont on vient de vous parler est en fait un « % » suivi d'une lettre (dans notre
exemple, la lettre « d »). Cette lettre permet d'indiquer ce que l'on doit afficher. « d » signifie que
l'on souhaite afficher un int.

Il existe plusieurs autres possibilités, mais pour des raisons de simplicité on va se contenter de retenir
celles-ci :

e. Formatage du contenu d’une variable

Exemple : printf ("le prix est de %.2f\n", p) ;

« .2 » signifie qu’on aura deux (2) chiffres après la virgule.

f. Les Constantes

Est une variable qui garde la même valeur pendant toute la durée du programme.

Pour déclarer une constante, on utilisera le mot « const » juste devant le type ou le préprocesseur
#define sans besoin de préciser le type.

Prof : CAMARA Mohamed 1 16

Algorithme et Programmation

Exemples :

const int C=7 ;

Ou

#include<stdio.h>
#define C 7

3.3.2. Saisie et affichage

a. Saisie
Pour demander à l'utilisateur d'entrer quelque chose dans la console, on va utiliser une autre fonc-
tion toute prête : « scanf ».

Cette fonction ressemble beaucoup à « printf ». Vous devez mettre un format pour indiquer ce que
l'utilisateur doit entrer (un int, un float, ...). Puis vous devez ensuite indiquer le nom de la variable
qui va recevoir le nombre.

Exemple :

Code : C

int age;

scanf("%d", &age);

On doit mettre le %d entre guillemets. Par ailleurs, il faut mettre le symbole « & » (qui permet d’indi­
quer l’adresse) devant le nom de la variable qui va recevoir la valeur.

NB : Attention, il y a une petite divergence de format entre printf et scanf ! Pour récupérer un float,
c'est le format "%f" qu'il faut utiliser, mais pour le type double c'est le format "%lf".

Exemple :

Code : C

double poids;

scanf("%lf", &poids);

b. Affichage
« printf () » est une instruction ou fonction qui permet d’afficher un message à l’écran.

Code: C

Exemple: printf ("hello world! \n");

3.4. Travaux Pratiques

Prof : CAMARA Mohamed 1 17

Algorithme et Programmation

Chapitre IV. Les Structures de Contrôle

4.1. Les tests et conditions
Dans le précédent chapitre vous avez pu vous familiariser avec les expressions met-
tant en place des opérateurs, qu’ils soient de calcul, de comparaison (l’égalité) ou booléens. Ces opé-
rateurs et expressions trouvent tout leur sens une fois utilisés dans des conditions (qu’on ap-
pelle aussi des branchements conditionnels). Une expression évaluée est ou vraie (le résul-
tat est différent de zéro) ou fausse. Suivant ce résultat, l’algorithme va effectuer une ac-
tion, ou une autre. C’est le principe de la condition.

Une instruction conditionnelle permet d’exécuter ou non une série d’instructions selon la valeur
d’une condition. Une condition est une expression ou une variable logique évaluée à « VRAI » ou «
FAUX », elle est composée de trois éléments :

• Une valeur ;
• Un opérateur de comparaison ;
• Une autre valeur

Les valeurs peuvent être a priori de n’importe quel type (numériques, caractères…). Mais si l’on veut
que la comparaison ait un sens, il faut que les deux valeurs de la comparaison soient du même type!

Les opérateurs de comparaison en Algorithmique :

• = : égal à…
• <> : différent de…
• < : strictement plus petit que…
• > : strictement plus grand que…
• <= : plus petit ou égal à…
• >= : plus grand ou égal à…
Les opérateurs de comparaison en C:

• == : égal à…
• ! = : différent de…
• < : strictement plus petit que…
• > : strictement plus grand que…
• <= : plus petit ou égal à…
• >= : plus grand ou égal à…
4.1.1. Tests SI
a. Forme simple

Il n’y a, en algorithmique, qu’une seule instruction de test : "Si", qui prend cepen-
dant deux formes : une simple et une complexe. Le test SI permet d’exécuter du code si la condi-
tion (la ou les expressions qui la composent) est vraie.

La forme simple est la suivante :

Syntaxe :

Si (condition) Alors
<Bloc d’instructions>

Prof : CAMARA Mohamed 1 18

Algorithme et Programmation

FinSi

Code : C

if (condition)
{

< Bloc d’instructions >

Que se passe-t-il si la condition est vraie? Le bloc d’instructions situé après le "Alors" est exé-
cuté. Sa taille (le nombre d’instructions) n’a aucune importance : de une ligne à n lignes, sans li-
mite. Dans le cas contraire, le programme continue à l’instruction suivant le "FinSi".

Exemple :

Algorithme absolue
Var
nombre : entier
Début
nombre←-15
Si (nombre<0) Alors
nombre←-nombre
FinSi
Afficher ("la valeur absolue est : ", nombre)
Fin.

Code en C :

#include <stdio.h>
int main()
{
Int nombre;
nombre=-17 ;
if(nombre<0)
{
nombre=-(nombre) ;
}
printf("la val abs est %d", nombre);
return 0 ;
}

b. Forme complexe

La forme complexe n’a de complexe que le nom. Il y a des cas où il faut exécuter quelques instruc-
tions si la condition est fausse sans vouloir passer tout de suite à l’instruction si-
tuée après le FinSi. Dans ce cas, utilisez la forme suivante :

Syntaxe :

Si (condition) Alors
<Bloc d’instructions>

Prof : CAMARA Mohamed 1 19

Algorithme et Programmation

Sinon
<Bloc d’instructions>
FinSi

Code C :

if (condition)
{
<Bloc d’instructions>
}
else
{
<Bloc d’instructions>
}

Si la condition est vraie, le bloc d’instructions situé après le Alors est exécuté. Ceci ne dif-
fère pas du tout de la première forme. Cependant, si la cond-
tion est fausse, cette fois c’est le bloc d’instructions situé après le Sinon qui est exécuté. En-
suite, le programme reprend le cours normal de son exécution après le FinSi.

Notez que vous auriez pu très bien faire un équivalent de la forme complexe en utili-
sant deux formes simples : la première avec la condition vraie, la seconde avec la néga-
tion de cette condition. Mais ce n’est pas très joli, même si c’est correct.

Exemple :

Algorithme TRI
Var
a,b,c: entiers
Début
Afficher ("Entrez trois valeurs entières distinctes")
Lire (a,b,c)
Si (c>b ET b>a) Alors
Afficher (" Triés en ordre croissant")
Sinon
Afficher ("Ces nombres ne sont pas triés")
FinSi
Fin

Code C :
#include <stdio.h>
int main()
{
int a,b,c;
printf("Entrez trois valeurs entières distinctes");
scanf("%d %d %d",&a,&b,&c);
if(c>b && b>a)
{
printf("Triés en ordre croissant");
}
else

Prof : CAMARA Mohamed 1 20

Algorithme et Programmation

{
printf("Ces nombres ne sont pas triés");
}
return 0 ;
}

c. Tests imbriqués

Vous pouvez en effet parfaitement imbriquer vos tests en plaçant des Si en cas-
cade dans les blocs d’instructions situés après les Alors et les Sinon. Pour ce cas l’instruction qui sera
exécutée est l’instruction dont la condition est vraie, si aucune n’a la valeur VRAI, c’est l’instruction
qui suit « Sinon » qui sera exécutée.

Syntaxe :

Si (condition) Alors
<Bloc d’instructions 1>
SinonSi (condition) Alors
<Bloc d’instructions 2>
SinonSi (condition) Alors
<Bloc d’instructions n>
Sinon
<Bloc d’instructions final>
FinSi

Code C :

if (condition)
{
<Bloc d’instructions 1>
}
else if (condition)
{
<Bloc d’instructions 2>
}
else if (condition)
{
<Bloc d’instructions n>
}
else
{
<Bloc d’instructions final>
}

Prof : CAMARA Mohamed 1 21

Algorithme et Programmation

Exemple :

Algorithme eqt_scd_deg
Var
a, b, c, delta, x1, x2:réels
Début
Afficher ("Donnez a b et c")
Lire (a, b, c)
delta← (b * b) - (4 * a * c)
Si (a=0 ET b=0) Alors
Afficher ("Pas d’equation")
SinonSi(a=0) Alors
Afficher ("Equation du premier degre ")
SinonSi (delta>0) Alors
x1← (-b + racine (delta)) / (2 * a)
x2← (-b - racine (delta)) / (2 * a)
Afficher ("Les deux solutions sont x1=", x1, "x2=", x2)
SinonSi (delta=0) Alors
x1← -b / (2 * a)
Afficher ("L’unique solution est :", x1)
Sinon
Afficher ("L’équation n’a pas de solution")
FinSi
Fin.

Code C :

#include <stdio.h>
#include <math.h>
int main()
{
float a,b,c,delta,x1,x2;
printf("Entrez trois valeurs entières distinctes\n");
scanf("%f %f %f",&a,&b,&c);
delta=(b*b)-(4*a*c);
if(a==0 && b==0)
{
printf("Pas d’equation \n");
}
else if(a==0){
printf("equation du premier degre\n");
}
else if(delta>0){
x1=(-b + sqrt(delta))/(2*a);
x2=(-b-sqrt(delta))/(2*a);
printf("Les deux solutions sont x1=%.2f et x2=%.2f", x1, x2);
}
else if(delta==0){
x1=-b/(2*a);

Prof : CAMARA Mohamed 1 22

Algorithme et Programmation

printf("L'unique solution est %.2f:", x1);

}
else{
printf("pas de solution");
}
return 0 ;
}

Remarque : la bibliothèque <math.h> permet d’insérer des fonctions mathématiques en C

d. Choix multiples

Si les tests imbriqués facilitent parfois la vie, ils deviennent parfois trop lourds lors-
que le nombre de tests devient trop important. Certains langages ont trouvé une intéressante pa-
rade à ce problème en proposant des structures de tests selon que telle expres-
sion est vraie, ou telle autre, et ainsi de suite. Au lieu de faire des Si imbriqués ou des SinonSi, il suf-
fit alors d’indiquer quoi faire quand telle ou telle valeur est rencontrée. En algorith-
mique, cela se traduit par la pseudo-instruction "Selon que".

Syntaxe :

Selon
Cas <condition 1> : <bloc d’instructions 1>
Cas <condition 2> : <bloc d’instructions 2>
Cas <condition n> : <bloc d’instructions n>
Autrement : bloc final
Fin Selon

Code C :

switch (variable_entier) {
case <valeur1> : <bloc d’instructions 1> ;
break ;
case <valeur2> : <bloc d’instructions 2>;
break ;
case <valeurn> : <bloc d’instructions n>;
break ;
default : <bloc d’instructions> ;
}

Exemple :

Algorithme Opération
Var a, b, c : réel
choix : entier
Début
Afficher("donnez deux nombres distincts")
Lire (a,b)
Afficher("1- addition")

Prof : CAMARA Mohamed 1 23

Algorithme et Programmation

Afficher("2- soustraction")
Afficher("3- multiplication")
Afficher("4- division")
Lire (choix)
Selon
Cas choix=1 :
c←a+b
Afficher ("la somme est :", c)
Cas choix=2 :
c←a-b
Afficher ("la difference est : ", c)
Cas choix=3 :
c←a*b
Afficher ("le produit est : ", c)
Cas choix=4 :
c←a/b
Afficher ("le quotient est : ", c)
Autrement : Afficher ("vous n’avez pas fait de choix ")
Fin Selon
Fin.

Code C :

#include <stdio.h>
Int main ()
{
Float a, b, c;
Int choix;
Printf ("Entrez deux valeurs distinctes\n");
scanf("%f %f",&a,&b);
printf("1- addition\n");
printf("2- soustraction\n");
printf("3- multiplication\n");
printf("4- division\n");
scanf("%d",&choix);
switch(choix)
{
case 1:
c=a+b;
printf("la somme est: %.0f\n",c);
break;
case 2:
c=a-b;
printf("la difference est: %.0f\n",c);
break;
case 3:
c=a*b;
printf("le produit est: %.0f\n",c);
break;

Prof : CAMARA Mohamed 1 24

Algorithme et Programmation

case 4:
c=a/b;
printf("le quotient est: %f\n",c);
break;
default:
printf("vous n avez pas fait de choix\n");
}
return 0;
}

4.2. Les Structures Itératives

Les boucles sont des structures itératives. Une itération ou structure itérative est une séquence d’ins­
tructions destinée à être exécutée plusieurs fois. Vous entendrez parler parfois de structures répéti-
tives, c’est la même chose dite autrement. Le but d’une boucle est de répéter un bloc d’instruc­
tions plusieurs fois. Selon le type de boucle, ce bloc va être ré-
pété un nombre fixe de fois (n fois) ou selon un certain nombre de critères (un test de une ou plu-
sieurs conditions) que vous connaissez très bien maintenant.

La boucle est un élément très simple au premier abord. Les premiers exemples que vous rencontre-
rez seront bien souvent évidents. Pourtant elle devient rapidement l’une des bêtes noires du pro-
grammeur en herbe à cause justement des fameux critères de sortie. Si les tests exécutent une ac-
tion donnée (structure SI) en cas de réussite ou non, une erreur dans une condition de sor-
tie peut amener au mauvais nombre de boucles, à ne jamais y rentrer ou même pire, à ne ja-
mais en sortir.

Les boucles mettent en évidence au moins trois choses :

• Il existe plusieurs types de boucles : certaines ont un nombre fixe d’itérations, d’autres dé-
pendent de conditions de sortie que vous aurez à définir.
• Il est possible d’imbriquer plusieurs niveaux de boucles : vous pou-
vez faire des boucles dans des boucles, autant de fois que vous le voulez.
• Il existe une quantité infinie d’utilisation des boucles qui en font une structure incontour-
nable en programmation pour la moindre des applications un tant soit peu complexe.

Dans une boucle, on retrouve généralement trois phases à savoir :

• L'initialisation : cette première instruction est utilisée pour préparer notre variable « Comp-
teur » ;
• La condition : c'est la condition qui dit si la boucle doit être répétée ou non. Tant que la con-
dition est vraie, la boucle continue ;
• Enfin, il y a l'incrémentation : cette dernière instruction est exécutée à la fin de chaque tour
de boucle pour mettre à jour la variable « Compteur », sinon de se retrouver avec une boucle
infinie. La quasi-totalité du temps on fera une incrémentation, mais on peut aussi faire une
décrémentation ou encore n'importe quelle autre opération.

4.2.1. La boucle Tant Que

La boucle de type "Tant Que" permet la répétition d’un bloc d’instructions tant que la condition tes-
tée est vérifiée, donc vraie. Sa syntaxe est la suivante :

Tant Que (condition) Faire

Prof : CAMARA Mohamed 1 25

Algorithme et Programmation

<Bloc d’instructions>

FinTantQue
Code C :

While (condition) {
<bloc d’instructions>
}

Exemple :

Algorithme Comptage
Var
Cpt: entier
Début
Cpt←1
Tant que (Cpt<=10) Faire
Afficher (Cpt)
Cpt←Cpt+1
FinTantQue
Fin.

Code C :

#include<stdio.h>
int main()
{
int cpt;
while(cpt<=10){
printf("%d\n",cpt);
cpt++;
}
return 0;
}

NB : l’utilisation d’un compteur permet d’éviter une boucle infinie quand il s’agit de définir le nombre
de fois que la boucle doit être exécutée

4.2.2. Répéter … Jusqu’à

Le "Répéter" en algorithmique ressemble fortement au "Tant que" avec cependant deux impor-
tantes différences :

• Quoi qu’il arrive, il y aura toujours au moins un passage dans la boucle : le bloc d’instruc­
tions sera exécuté au moins une fois,
• L’expression booléenne finale est inversée. Un « tant que a <>1 » devient un "jusqu’à a=1".

Syntaxe :

Répéter

<Bloc d’instructions>

Prof : CAMARA Mohamed 1 26

Algorithme et Programmation

Jusqu’à (condition)

Le "jusqu’à" se comprend comme "jusqu’à ce que la condition soit vérifiée".

Code C :

do {

<Bloc d’instructions>

}while (condition) ;

NB : attention, en C : La structure « do…while » c’est-à-dire « faire…tanque ». Alors que la structure

algorithmique est « répéter…jusqu’à ». C’est-à-dire qu’en C on exécute l’action tant qu’une condition
est vraie alors qu’en algorithme on exécute une action tant que la condition est fausse, c’est-à-dire
jusqu’à ce que la condition inverse soit vraie.

Exemple :

Algorithme REPETE
Var
i: entier
Début
Répéter
Afficher(i)
i←i+1
Jusqu’à (i>=10)
Fin.

Code C :

#include<stdio.h>
int main()
{
int i;
do{
printf("%d\n",i);
i++;
}while(i<=10);
return 0;
}
4.2.3. Pour … Fin Pour

"Pour … Fin Pour" est une boucle à l’usage quasi-exclusif des compteurs. À chaque pas-
sage dans la boucle, un compteur est incrémenté ou décrémenté, se-
lon le cas. On dit alors qu’il s’agit d’une structure incrémentale. Sa syntaxe en pseudo-code est la sui-
vante :

Pour <variable> De début à fin [PAS <pas>] Faire

<Bloc d’instructions>
Fin Pour

Code C :

Prof : CAMARA Mohamed 1 27

Algorithme et Programmation

for (condition) {
<Bloc d’instructions>
}

À chaque passage dans la boucle, la variable prendra successivement chacune des valeurs dans l’in­
tervalle [a;b] (a et b inclus). Le pas est optionnel et est de 1 par défaut. Le pseudo-code sui-
vant compte de 1 à 10 :

Algorithme COMPTER
Variable j : entier
Début
Pour j De 1 à 10 Faire
Afficher(j)
Fin Pour
Fin.

Code C :

#include<stdio.h>
int main()
{
int j;
for(j=0;j<=10;j++){
printf("%d\n",j);
}
return 0;
}

Prof : CAMARA Mohamed 1 28

Algorithme et Programmation

Chapitre V. Les Tableaux

5.1. Les Tableaux
5.1.1. Principe et définition
Imaginons que dans un programme, nous ayons besoin simultanément de 12 valeurs (par exemple,
des notes pour calculer une moyenne). Evidemment, la seule solution dont nous disposons à l’heure
actuelle consiste à déclarer douze variables, appelées par exemple Notea, Noteb, Notec, etc. Bien
sûr, on peut opter pour une notation un peu simplifiée, par exemple N1, N2, N3, etc. Mais cela ne
change pas fondamentalement notre problème, car arrivé au calcul, et après une succession de
douze instructions « Lire » distinctes, cela donnera obligatoirement une atrocité du genre :
Moy ← (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10+N11+N12)/12

Ridicule, n’est­ce pas ? Maintenant, si vous savez qu’il y a douze étudiants dans une classe et donc
douze notes à saisir, ne serait-il pas plus simple de remplacer toutes par une seule, mais qui pourrait
contenir toutes les notes ? L’idée serait donc d’avoir un nom de variable mais qui pourrait asso-
cier une note à un numéro. Prenez la variable "note". Il suffirait alors de dire que "note 1 vaut 15,
note 2 vaut 17, note 3 vaut 8, etc.".

Un ensemble de valeurs représenté par le même nom variable et identifié par un numéro s’ap­
pelle un tableau. Le numéro qui sert à identifier un élément (une valeur) du tableau s’appelle un in-
dice. En représentation algorithmique, un élément du tableau est représenté par le nom de la va-
riable auquel on accole l’indice entre crochets :
Note [1] ←15

Remarque : Un tableau n’est pas un type de données, mais une liste d’éléments d’un type donné.
On parlera d’un tableau de n éléments de type numérique, ou Alphanumérique, etc.

5.1.2. Les dimensions

Faites courir un peu plus votre imagination et maintenant vous avez trois classes de vingt étudiants.
Devez-vous utiliser trois tableaux ? Ce qu’il y a de bien avec les tableaux, c’est qu’on peut rajou-
ter des indices aux indices.

Note[1][10]←17

Ceci pourrait se traduire par : La 10ème note de la 1ère classe.

Rajouter un indice à un tableau s’appelle rajouter une dimension à un tableau. Avec une dimension
le tableau peut être représenté sur une ligne. Avec deux dimensions, le tableau peut être repré-
senté en lignes et colonnes, comme dans un tableur ou une grille quelconque.

5.1.3. Types d’un tableau

Un tableau n’est pas un type de données mais un ensemble de valeurs, elles mêmes typées, regrou-
pées et indicées sous un nom de variable unique. Pouvez-vous créer un tableau contenant n’im­
porte quel type de valeurs ? Attention à l’interprétation de cette question. Un tableau con-
tient-il n valeurs du même type, ou au contraire n valeurs de types différents ?

En algorithmique, le principe est simple : un tableau contient n éléments de même type. Autre-
ment dit, vous allez déclarer un tableau de vingt notes en numérique, dix réels, cinq chaînes de ca-
ractères, etc.

Prof : CAMARA Mohamed 1 29

Algorithme et Programmation

Cependant en dehors du pseudo-code algorithmique la définition, la déclaration et l’utilisa­

tion des tableaux dépendent fortement du langage. Les tableaux simples en C par exemple ne con-
tiennent qu’un seul type possible de valeurs. Tandis qu’en PHP, vous pouvez mélanger tout ce que
voulez l’indice 1 contenant un entier, l’indice 2 du texte, etc.

5.1.4. Déclaration d’un tableau

En pseudo-code algorithmique, les tableaux se déclarent au même endroit que les va-
riables, juste avant le début du traitement lui-même, sous cette forme :

Var
MonTableau : tableau [1..nbelements] d’entiers

MonTab2:tableau [1..dim1] [1..dim2] de réels

Code C :
int MonTableau [nbelements]

float MonTab2 [dim1] [dim2]

Entre les crochets, placez le nombre d’éléments du tableau.

5.1.5. Initialisation de tableaux à un indice

Il est possible d’initialiser le contenu du tableau à sa création comme ceci :

Var
mois : tableau [1..12] <- {1,...,12} d’entier

Code C :

int tableau[12] = { 1, …, 12 } ;

Ce même tableau pourrait être placé dans la section CONST, ce qui en ferait une constante.

Comme cela sera revu un peu plus loin, les indices des tableaux peuvent démarrer à 0 ou 1, se-
lon les langages, les usages, les professeurs, etc. Il n’y a malheureusement pas de règle pré-
cise en ce domaine. L’évidence, vis-à-vis de l’organisation de la mémoire de l’ordinateur, vou-
drait que la numérotation démarre à zéro : ça simplifie les calculs de la position des différents élé-
ments du tableau dans la mémoire. Cependant comment alors comprendre ce tableau ?

Valeurs : tableau [1..10] de réels

Selon les usages, si ce tableau représente dix valeurs alors :

• Si la numérotation commence à 1, les indices vont de valeur[1] à valeur[10].

• Si la numérotation commence à 0, les indices vont de valeur[0] à va-
leur[9]. C’est le cas du langage C

5.1.6. Utilisation
Un élément de tableau reçoit une valeur comme une variable, se lit comme une va-
riable et s’écrit comme une variable. Ce sont dans les structures itératives que les tableaux pren-
nent toutes leurs significations.

Exemple :

Algorithme UTIL
Var

Prof : CAMARA Mohamed 1 30

Algorithme et Programmation

notes:tableau[1..10] de réels
i:entier
DEBUT
Pour i de 1 à 10 Faire
Afficher ("Note",i," ?")
Lire (note[i])
FinPour
Pour i de 1 à 10 Faire
Afficher ("note[",i,"]=", note[i])
FinPour
Fin.

Code C :

#include<stdio.h>
int main(){
float notes[10];
int i,n;
for(i=1;i<=10;i++){
printf("note %d\n",i);
scanf("%f",&notes[i]);
}
for(i=1;i<=10;i++){
printf("note[%d]=%.0f\n",i,notes[i]);
}
return 0;
}

Chapitre VI. Les Procédures et Fonctions

Lorsque l'on progresse dans la conception d'un algorithme, ce dernier peut prendre une taille et une
complexité croissante. De même des séquences d'instructions peuvent se répéter à plusieurs en-
droits.

Un algorithme écrit d'un seul tenant devient difficile à comprendre et à gérer dès qu'il dépasse deux
pages. La solution consiste alors à découper l'algorithme en plusieurs parties plus petites. Ces parties
sont appelées des sous-algorithmes. Le sous-algorithme est écrit séparément du corps de l'algo-
rithme principal et sera appelé par celui-ci quand ceci sera nécessaire.

Les sous-programmes sont chargés de divers rôles, ils peuvent aller du calcul d’une valeur abso-
lue à celui d’une puissance quelconque, une conversion de date, le formatage d’une chaîne de carac-
tères, l’affichage d’un en-tête quelconque, bref tout ce que vous voudrez bien en faire. Sui-
vant les langages, vous trouverez les expressions sous-programmes, mais aussi et sur-
tout les mots fonctions et procédures pour les décrire. C’est le programme princi-
pal qui se charge d’appeler les sous-programmes. Ceux-ci ne se lancent jamais d’eux-mêmes.

Remarque : Un sous-programme ne se lance jamais tout seul, il doit être appelé depuis le pro-
gramme principal. Cependant, un sous-programme peut parfaitement faire ap-
pel à un autre sous-programme. Par exemple, un sous-programme chargé de calculer une racine car-
rée peut appeler le sous-programme chargé des valeurs absolues…

Prof : CAMARA Mohamed 1 31

Algorithme et Programmation

6.1. Les Procédures

Les procédures sont des sous-programmes constitués d’une suite d’instructions indépen-
dantes. Une procédure ne retourne pas de résultat ou de valeur au programme qui l’a ap-
pelé, tout comme les valeurs passées en paramètre ne sont pas forcément modifiées de manière glo-
bale. Une procédure pourrait faire l’objet d’un programme à part. Son contenu peut cependant par-
fois influer sur le déroulement global du programme, s’il modifie un fichier, une base de don-
nées, etc.

Exemple :

Procédure RepeteCar()
Var
i:entier
Début
Pour i de 1 à 20 Faire
Afficher ("-")
FinPour
FinProc

Vous constatez qu’un sous-programme est constitué de :

• Un identifiant sous forme de nom : RepeteCar(), qui lui servira pour être appelé.
• Une zone de déclaration de variables.
• Un bloc d’instructions encadré entre Début et Fin.
• Le tout étant ici et dans le cadre de cet exemple, précisément entre les mots-clés Procé-
dure et FinProc.

Code C :

#include <stdio.h>
void RepeteCar(){
int i;
for(i=1;i<=20;i++)
printf("-\n");
}

Remarque : étant donné que tout est question de fonctions en C, le mot-clé « void » permet néan-
moins de déclarer une fonction qui ne retourne pas de valeur comme une procédure

6.2. Les fonctions

En mathématique, vous avez probablement rencontré la notion de fonction. Dans le cadre de la réso-
lution d’une équation du second degré, l’équation s’écrit généralement ainsi :

f(x)=ax²+bx+c

Le résultat de f(x) ou fonction de x est le résultat du contenu de la fonction, c’est­à­dire l’équa­

tion. La valeur de f(x) est ce résultat. C’est pareil en algorithmique : une fonction est un sous-pro-
gramme qui retourne une valeur. Une fonction se décrit ainsi :

Fonction nom():type

Prof : CAMARA Mohamed 1 32

Algorithme et Programmation

Var
<variables>
Début
<bloc d’instructions>
Retourne <valeur>
FinFonc

Code C :

type nom()
{
<Bloc d’Instructions>
}
Return <valeur>

• Une fonction se déclare avec le mot-clé Fonction, suivi de son nom et du type de va-
leur qu’elle retourne. Ce peut être n’importe quel type (entier, réel, chaîne…).
• Une fonction peut contenir une zone de déclaration de variable et de types structurés.
• Le bloc d’instructions est encadré entre Début et FinFonc.
• La valeur de la fonction est retournée par l’instruction Retourne. La valeur retour-
née doit être du même type que celle attendue par la déclaration de la fonction.

Exemple :

Fonction Maximum (x: réel, y: réel) : réel

Début
Si x > y Alors
Retourner x
Sinon
Retourner y
FinSi
FinFonct

Code C :
#include <stdio.h>
#include <stdlib.h>
float Maximum(int x, int y)
{if(x>y)
return x;
else return y;
}

Une fonction est une série d’instruction regroupé sous un nom qui permet d’effectuer des actions
par son simple appel dans l’algorithme, elles sont aussi appelées sous algorithme sous-programme ;
et ou modules.

Il existe une différence très importante entre une procédure et une fonction :

• La procédure est vue comme une instruction.

• La fonction est vue comme une valeur.

Prof : CAMARA Mohamed 1 33

Algorithme et Programmation

6.3. Variables Locales et Globales

6.3.1. Locales
L’endroit où les variables sont déclarées est très important. Selon cet endroit, les va-
riables ont une "portée" différente. La portée d’une variable est sa visibilité au sein des diffé-
rentes parties du programme.

Le cas général dit qu’une variable n’est visible et accessible par défaut que dans le bloc d’instruc­
tions où elle a été déclarée. Une variable déclarée dans un sous-programme sous le mot-clé Fonc-
tion ne pourra dans ce cas qu’être lisible et modifiable uniquement dans ce sous-pro-
gramme. Idem pour le programme principal : une variable déclarée sous le mot-clé Pro-
gramme ne sera accessible que par celui-ci.

Les variables accessibles uniquement par le programme ou sous-programme dans les-

quels elles sont déclarées, sont appelées des variables locales. Toutes les va-
riables que vous avez rencontrées jusqu’à présent sont des variables locales.

Les variables locales de même nom n’ont aucun rapport entre elles. Elles sont totalement indépen-
dantes les unes des autres et aucune interaction entre elles n’est possible. Les variables locales peu-
vent donc parfaitement porter un même nom. Du côté de la mémoire, le contenu de ces deux va-
riables est cloisonné et distinct, à des adresses différentes.

6.3.2. Globales
Il serait pourtant très pratique de pouvoir accéder à une variable depuis n’importe quel en-
droit du programme, qu’il soit principal ou un sous-programme. Ce mécanisme permettrait d’utili­
ser son contenu et d’en modifier la valeur partout dans le programme. La portée d’une telle va-
riable s’étendrait à tout le code. Ce type de variable s’appelle une variable glo-
bale, et elle existe tant en algorithmique que dans la plupart des langages.

Une variable globale est déclarée en dehors des sous-programmes et du programme princi-
pal, avant ceux-ci, c’est­à­dire en premier dans l’algorithme. Étant globale, elle est accessible de par-
tout, tant en accès (lecture du contenu) qu’en modification (affectation d’une nouvelle va-
leur). Les variables globales sont déclarées de cette manière :

Var globales
nbcar:entier
c:caractère
Procédure RepeteCar()
VAR
i:entier
Début
Pour i de 1 à nbcar Faire
Afficher (c)
FinPour
FinProc
PROGRAMME LIGNES
VAR
i:entier
DEBUT
c←"*"
Pour nbcar de 1 à 10 Faire

Prof : CAMARA Mohamed 1 34

Algorithme et Programmation

RepeteCar()
FinPour
FIN

Code C :

#include <stdio.h>
int nbcar;
char c;
void RepeteCar(void)
{
int i ;
for(i=1;i<=nbcar ;i++)
printf("%c", c);
printf("\n");
}
int main(){
c='*';
for(nbcar=1;nbcar<=10;nbcar++)
RepeteCar();
return 0;
}
6.4. Les Paramètres
Maintenant que vous réservez les variables globales à des cas bien précis, il vous faut trou-
ver un autre moyen de passer des valeurs aux procédures et aux fonctions. Quand en mathéma-
tiques vous calculez la valeur d’une fonction f(x), vous lui demandez en fait de calculer la va-
leur de la fonction selon la valeur de x. Vous passez donc la valeur de x à la fonction.

Le principe est le même avec vos algorithmes : vous pouvez transmettre des valeurs à vos procé-
dures et fonctions, tout comme vous pouvez en recevoir. La syntaxe diffère légère-
ment entre les fonctions et les procédures pour cette raison. Dans les deux cas cependant, les para-
mètres se placent entre les parenthèses situées après leur nom.

Les paramètres passés à un sous-programme sont généralement des variables locales au pro-
gramme ou sous-programme l’appelant, mais ils ne portent pas forcé-
ment le même nom. Ils sont "récupérés" au sein du sous-programme comme des variables lo-
cales au sous-programme. Il est cependant possible de passer comme paramètre toute expres-
sion retournant une valeur, que ce soit un scalaire, une variable, un tableau, un enregistre-
ment, une table, ou encore une fonction (qui sera substituée par son résultat).

6.4.1. Procédures
La syntaxe de passage des paramètres est la suivante :

Procédure nom_proc(E param1:type, ES param2:type, S param3:type)

Les paramètres d’une procédure sont de trois catégories :

• Ceux en entrée, qui correspondent aux valeurs que vous souhaitez transmettre à la pro-
cédure. Entre les parenthèses, ils sont précédés d’un "E", comme Entrée, car ce sont les va-
leurs en entrée de la procédure.

Prof : CAMARA Mohamed 1 35

Algorithme et Programmation

• Ceux en sortie, qui correspondent aux valeurs retournées par la procédure au pro-
gramme ou au sous-programme l’ayant appelé. Ils sont précédés d’un "S", comme Sor-
tie, car ce sont les valeurs en sortie de la procédure. Ces paramètres sont des va-
riables qui doivent être déclarées dans le programme ou sous-programme appelant.
• Ceux en entrée et en sortie, précédés de "ES".

Exemple :

Procédure RepeteCar(E nbcar:entier, E c:caractère)

VAR
i:entier
Début
Pour i de 1 à nbcar Faire
Afficher (c)
FinPour
FinProc
Algo LIGNES
Var
i:entier
Début
Pour i de 1 à 10 Faire
RepeteCar(i,"*")
FinPour
Fin.

Code C :

#include <stdio.h>
void RepeteCar(int nbcar,char c)
{
int i ;
for(i=1;i<=nbcar ;i++)
printf("%c", c);
printf("\n");
}
int main(){
int i ;
for(i=1;i<=10;i++)
RepeteCar(i,'*');
return 0;
}
6.4.2. Les Fonctions
Les fonctions ne retournent qu’une seule valeur via l’instruction Retourne. Aussi il n’y a pas be-
soin de spécifier si les paramètres sont en entrée ou en sortie. Ils sont forcément en en-
trée. Par contre, la valeur de la fonction peut être de n’importe quel type.

Exemple :

Algorithme Appel_fonction_Max
Variables n1, n2, max : réel

Prof : CAMARA Mohamed 1 36

Algorithme et Programmation

Fonction Maximum (x: réel, y: réel) : réel

Début
Si x > y Alors
Retourner x
Sinon
Retourner y
FinSi
FinFonct
Début
Afficher("Entrez un premier nombre")
Saisir(n1)
Afficher("Entrez un second nombre")
Saisir(n2)
max ← Maximum(n1,n2)
Afficher("Le plus grand de ces deux nombres est : ", max
Fin.

Code C :

#include <stdio.h>
#include <stdlib.h>
float Maximum(float x, float y)
{if(x>y)
return x;
else return y;
}
int main()
{
float n1, n2, max;
printf("Entrez un premier nombre\n ");
scanf("%f", &n1);
printf("Entrez un second nombre\n"),
scanf("%f", &n2);
max=Maximum(n1,n2);
printf("Le maximum est %.0f\n", max);
return 0;
}
6.5. Travaux Pratiques

Prof : CAMARA Mohamed 1 37