Mathématiques et Informatique pour la géologie

Pr. G. Mangoub

Master PVRM

Partie I : Informatique : programmation avec C++

Chapitre 1 : Rappel sur les algorithmes et les différentes structures algorithmiques

Cours préparé par :

Pr. Ghita Mangoub

A. U : 2019-2020
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Avant-propos

Ce cours est destiné à tout débutant désirant apprendre les bases d’écriture d’algorithme et sa
traduction en langage C++
Nous avons tenu à ce que ce cours ne présente pas de difficultés à l’apprenant et nous avons
veillé à le présenter d’une façon la plus pédagogique qui nous semble. Les différentes
structures algorithmiques seront exposées ainsi que leur traduction en C++ avec pour chaque
cas différentes applications.
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Chap.1 Rappel sur les algorithmes et les différentes structures algorithmiques

I Introduction
Si l’on s’attache au domaine informatique, la réalisation d’une application informatique peut
se schématiser de la façon suivante :

Problème Algorithme Programme Solution au

posé problème
posé

Analyse, choix codage exécution

méthode

Mise en Choix Choix Choix cas

équations méthode langage test
algorith-
mique

Nous remarquons que la phase de création de l’algorithme est en tête du processus qui va
fournir la solution du problème posé. La base de la programmation est donc l’analyse
algorithmique et lorsque l’analyse est bonne, il est possible de programmer dans n’importe
quel langage.
II Qu’est ce qu’un algorithme ?
C’est un inventaire et une mise en forme d’un ensemble d’actions permettant d’accomplir une
tache que l’on s’est fixée d’avance. En effet, c’est une sorte de recette qui donne un résultat
juste lorsque nous exécutons la suite d’actions répertoriées et classées au sein de l’algorithme.
Un algorithme doit être d’une lisibilité et d’une clarté exemplaires afin qu’il puisse être lu et
repris facilement par d’autre utilisateurs, d’où l’intérêt du choix d’une méthode algorithmique
simple et facile à implémenter. C’est-à-dire qu’un algorithme doit refléter une représentation
textuelle des différentes étapes conduisant à la solution du problème avec une série de
conventions ressemblant à un langage de programmation mais sans les problèmes de syntaxe.
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Structure d’un algorithme

Un algorithme doit en général comporter les étapes suivantes :
1) Partie déclaration
2) préparation du traitement et lecture des données
3) traitement
4) édition des résultats
Ces étapes peuvent être complétées par l’introduction de commentaires qui peuvent faciliter la
lecture de l’algorithme à l’étape d’édition mais aussi d’autres commentaires qui peuvent en
faciliter la lecture des résultats à l’étape d’exécution.
Dans chaque étape, un ordre fourni se traduit par un ensemble d’instructions. Ces instructions
manipulent des objets. Chaque objet est définit grâce à un ensemble de trois qualificatifs qui
sont :
- L’identificateur : c’est le nom de baptême de l’objet.
- Le type : c’est l’ensemble dans lequel l’objet prend sa valeur.
- La valeur : c’est une valeur précise dans l’ensemble définit par son type .
On note cela de la manière suivante :
objet→ ( identificateur, type, valeur)
Exemple : masse→ ( m, réel, 20 Kg)
Noter qu’un objet doit être déclaré avant d’être manipulé.

II- Les éléments de base d’un algorithme

Un algorithme doit être aussi lisible que possible, d’où l’intérêt des commentaires qui sont de
deux type :
a) Les commentaires qui n’apparaissent pas à l’étape d’exécution
Pour ces commentaires, on utilise le signe // s’il s’agit d’un commentaire sur une seule ligne.
Exemple
// Ceci est un commentaire sur une seule ligne

Pour le cas d’un commentaire qui porte sur plusieurs ligne, on le commence par le signe /*
et on le ferme par le signe */.
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Exemple
/* Ceci est un autre
Commentaire
Sur plusieurs lignes
*/
b) Les commentaires qui apparaissent à l’étape d’exécution
On les met entre deux guillemets, on les verra après les ordre d’entrée sortie.
III-1 Types de bases
3 types élémentaires

Les entiers
Courts(short int), normaux(int), long(long int)
Exemple :
a : entier
a, b :entiers courts

Les réels
Courts(float)(32 bits)(6 chiffres significatifs), long(double)(64 bits)(16 chiffres),très long(long
double)(80 bits)

Exemple :
a : réel
a, b :réels longs

Les caractères
Char
Exemple : char a,b,c ;

III-2 constantes, variables

Un algorithme traite une ou des variables entrantes : les données
Il restitue une ou des variables sortantes : les résultats
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Un algorithme qui ne satisfait pas à ces deux conditions n’a pas de justification et par
conséquent n’existe pas. Les données traitées par l’algorithme sont de deux types : variable ou
constante. Chaque variable et constante doit être déclarée avant d’être utilisé : nom + type.
Cette déclaration consiste en une réservation en mémoire de la place nécessaire et suffisante à
l’hébergement de la valeur.

Notion de constante : une constante porte un nom qu’on appelle identificateur et garde la
même valeur On la déclare de la façon suivante :
Const type identificateur = valeur_de_la_constante
Exemple :
Const entier N = 10 ;
C’est à dire qu’on déclare que N est une constante entière qui a pour valeur 10.

Notion de variable : Une variable est un endroit en mémoire permettant de stocker une
valeur. Une variable est caractérisée par un nom appelé un identificateur, par un type
(l’ensemble dans lequel elle prend ses valeurs) et par une valeur.
Exemple : si notre variable est la masse alors pour identificateur on peut choisir m, pour le
type c’est un réel et pour la valeur 30Kg.
La syntaxe de la déclaration est la suivante :
identificateur : type
Exemple1 : a : entier
Pour déclarer la variable dont le nom est l’identificateur a comme entier qui peut être positif
ou négatif.
Exemple2 : X,Y,Z : réels
Pour déclarer les 3 variables dont les noms respectifs sont les identificateurs X,Y et Z comme
réels qui peuvent être positifs ou négatifs.
Exemple3 : c : boelien
Pour déclarer la variable dont le nom est l’identificateur c comme boeliène. C’est à dire une
expression logique qui ne peut avoir que deux valeurs soit vrai soit faux.
Exemple4 : a,b,c : char
Pour déclarer les 3 variables dont les noms respectifs sont les identificateurs a, b et c comme
caractères.
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

En ce qui concerne l’identificateur, il peut être constitué de plusieurs lettres, chiffres et mots
dans ce derniers cas les différents mots sont séparés par un signe souligné c’est à dire « _
«
Exemple : X_a : entier ;
Y_b : réel;
Quelques notions utiles:
1) L’identificateur ne doit pas commencer par un chiffre. Il doit être en rapport avec ce que
contient la variable. Il ne doit pas contenir d’espaces ni contenir le caractère -. En général un
identificateur doit refléter la variable qu’il contient
Exemple : si notre variable est la masse d’un premier objet, on peut choisir comme
identificateur : masse_objet1
2) On peut copier directement une variable initialement déclarée comme entierdans une
variable initialement déclarée comme double.

Exemple a :entier ;
X :réel;
X=a ;
Alors que pour copier une variable initialement déclarée comme double dans une variable
initialement déclarée comme entier, il faut d’abord transformer la variable réelle en une
variable entière .

III-3- Opération entré – sortie

Lis (variable)
Écris ( variable )
Ecris(‘’X=’’,X) pour avoir à l’étape d’exécution X= valeur de X, ainsi, on a utilisé la notion
de commentaire affichable à l’étape d’exécution.

III-4 Expressions
Une expression peut être une instruction ou une suite d’instructions séparées par l’un des
opérateurs suivants :

Opérateurs d'assignation
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Affectation d’une valeur ou d’une expression x à une variable y : (y ← x) Addition de la

valeur de gauche à la valeur de droite : + = (x ← x+2) Soustraction de la valeur de gauche à la
valeur de droite : - =
Multiplication de la valeur de gauche à la valeur de droite : * =
Division de la valeur de gauche à la valeur de droite : / =
Incrémentation : ++ : I←I+1 est équivalent à I++
Décrémentation : - - : I←I-1 est équivalent à I--

Opérateurs comparateurs de nombres

Egalité : = =
Infériorité stricte : <
Supériorité stricte : > Infériorité : < =
Supériorité :> =
Différent : ! =

Opérateur logiques

OU : ||
ET : &&
NON :!

Exercice1
Ecrire un algorithme qui lit trois variables réelles A, B et C et qui calcule :
X= A+B
Y= (A*B)-C
W=A+C
On utilisera les commentaires autant que possible

Solution de l’Exercice1

//Utilisation des opérations arithmétiques

//Déclaration
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

A,B,C,X,Y,Z,W :reel
//lecture des données
Ecris(« donner trois reels A,B et C »)
Lis(A,B,C)
//traitement
X← A+B
Y← (A*B)-C
W←A+C
Si (W !=0)
{
Z← (A-B)/W
Ecris(« Z= »,Z)
}
//Edition des résultats
Ecris(« X=» ,X)
Ecris(« Y= »,Y)
Ecris (« FIN »)

IV- les différentes structures algorithmiques

IV-1 La structure séquentielle
Dans cette structure les étapes conduisant à la solution du problème à résoudre apparaissent
dans un ordre bien défini dans l’algorithme.
EX: Calculer la surface d’un rectangle

// calcul de la surface d’un rectangle

// Déclaration
L,L,S : réel
// préparation du traitement
Ecris(‘’donner la largeur et la longueur du rectangle)
Lis (l,L)
//traitement

S=l*L

// Edition des résultats

 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Ecris (‘’surface = ‘’,S)

Ecris (‘’Fin’’)

IV-2 Les boucles en algorithmique :la structure ittérative

Si pour résoudre un certain problème, on est obligé de répéter une instruction ou bien

un ensemble d’instructions un certain nombre de fois on parle de structure en boucle

ou encore de structure alternative ou répétitive. Il existe en gros trois façon pour

exprimer cette répétition.

IV-2-1 La structure itérative « pour »

La syntaxe algorithmique de cette structure est la suivante :

Identificateur : entier

Pour identificateur de « Val initiale » à « Val finale » pas de « pas » {traitement}

Fin pour

Remarque

1) Le nombre de traitement de la boucle =

(ValeurFinale – ValeurInitiale)/ pas

2) On utilise cette structure quand on connaît le nombre de passage dans la boucle

EX: Calculer la somme des N premiers entiers

// calcul de la somme des N premiers entiers avec la boucle pour

// Déclaration
I,N,somme : entiers
// préparation du traitement
Ecris(‘’donner un entier N positif’’)
Lis N
//traitement

somme = 0 //initialisation de somme

Pour I de 1 à N pas de 1
somme =somme +I

// Edition des résultats

 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Ecris (‘’somme = ‘’,Somme)

Ecris (‘’Fin’’)

Exemple d’exécution

donner un entier N positif

10
Somme = 55
Fin

EX: Afficher la table de multiplication d’un entier

// Afficher la table de multiplication d’un entier

// Déclaration
I,N : entiers
// préparation du traitement
Ecris(‘’donner un entier pour lequel vous voulez la table’’)
Lis N
//traitement

Pour I de 0 à 9 pas de 1
Ecris(I,’’*’’,N,’’=’’,I*N)

// Edition des résultats

Ecris (‘’Fin’’)

EX: Ecrire un algorithme qui permet d’afficher N fois de suite le mot ‘phrase1’, puis une
fois le mot ‘phrase2’.

/* Ecrire un algorithme qui permet d’afficher N fois de suite le mot ‘phrase1’, puis une
fois le mot ‘phrase2’. */

// Déclaration
N : entiers
// préparation du traitement
Ecris(‘’donner un entier positif N’’)
Lis N
//traitement

Pour I de 1 à N pas de 1
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

{
Ecris(‘’ phrase1 ‘’)
}
Ecris(‘’ phrase2 ‘’)
// Edition des résultats
Ecris (‘’Fin’’)

IV-2-2 La structure itérative « Tant que »

La syntaxe algorithmique de cette structure est la suivante :

TantQue (condition) Faire Bloc de traitement de la boucle FinTantQue

EX: Calculer la somme des N premiers entiers

Première méthode

// calcul de la somme des N premiers entiers avec la boucle tant que

// Déclaration
I,N,somme : entiers
// préparation du traitement
Ecris(‘’donner un entier N positif’’)
Lis N
//traitement

somme = 0 //initialisation de somme

I=0 //initialisation du compteur
Tant que ( I<N ) faire
{
I=I+1
somme =somme +I
}

// Edition des résultats

Ecris (‘’somme = ‘’,Somme)
Ecris (‘’Fin’’)

Deuxième méthode

// calcul de la somme des N premiers entiers avec la boucle tant que

// Déclaration
I,N,somme : entiers
// préparation du traitement
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Ecris(‘’donner un entier N positif’’)

Lis N
//traitement

somme = 0 //initialisation de somme

I=0 //initialisation du compteur
Tant que ( I<=N ) faire
{
somme =somme +I

I=I+1
}

// Edition des résultats

Ecris (‘’somme = ‘’,Somme)
Ecris (‘’Fin’’)

EX: Afficher la table de multiplication d’un entier. On ne tiendra compte de N que s’il est

>0.

/* Afficher la table de multiplication d’un entier. On ne tiendra compte de N que s’il est >0.

*/

// Déclaration
I,N : entiers
// préparation du traitement
Ecris(‘’donner un entier>0’’)
Lis N
Tant que (N<=0)
{
Ecris(‘’donner un entier>0 pour lequel vous voulez la table’’)
Lis N
}
//traitement
I=0 //initialisation du compteur
Tant que (I<=9) faire
Ecris(I,’’*’’,N,’’=’’,I*N)
// Edition des résultats
Ecris (‘’Fin’’)

EX: Ecrire un algorithme qui permet d’afficher N fois de suite le mot ‘phrase1’, puis une
fois le mot ‘phrase2’.
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

/* d’afficher N fois de suite le mot ‘phrase1’, puis une fois le mot ‘phrase2’.
*/

// Déclaration
I,N : entiers
// préparation du traitement
Ecris(‘’donner un entier>0’’)
Lis N
Tant que (N<=0)
{
Ecris(‘’donner un entier>0 pour lequel vous voulez la table’’)
Lis N
}
//traitement
I=0 //initialisation du compteur
// si on initialise le compteur à 1 la condition serait I<=N
Tant que (I<N) faire
{
Ecris(‘’phrase1’’)
I=I+1
}
Ecris(‘’phrase2’’)
// Edition des résultats
Ecris (‘’Fin’’)

IV-2-3 La structure itérative « répéter Tant que »

La syntaxe algorithmique de cette structure est la suivante :

Répéter Bloc d'instruction de la boucle TantQue (condition)

Remarque : on utilise cette structure quand on ne connaît pas le nombre de passage

dans la boucle mais que l'on va y passer au moins une fois.

EX: Calculer la somme des N premiers entiers

// calcul de la somme des N premiers entiers avec la boucle pour

// Déclaration
I,N,somme : entiers
// préparation du traitement
Ecris(‘’donner un entier N positif’’)
Lis N
//traitement
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

I=0 // initialisation du compteur I

somme = 0 //initialisation de somme
Répéter
{I=I+1

somme =somme +I
}
TantQue (I<N)

// Edition des résultats

Ecris (‘’somme = ‘’,Somme)
Ecris (‘’Fin’’)

Exemple d’exécution

donner un entier N positif

10
Somme = 55
Fin
EX: Afficher la table de multiplication d’un entier

// Afficher la table de multiplication d’un entier

// Déclaration
I,N : entiers
// préparation du traitement
Ecris(‘’donner un entier N positif’’)
Lis N
//traitement
I=0 // initialisation du compteur I
Répéter
{
Ecris(I,’’*’’,N,’’=’’,I*N)
I=I+1

}
TantQue (I<=9)

// Edition des résultats

Ecris (‘’Fin’’)

EX: Ecrire un algorithme qui permet d’afficher N fois de suite le mot ‘phrase1’, puis une
fois le mot ‘phrase2’.
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

/* Ecrire un algorithme qui permet d’afficher N fois de suite

le mot ‘phrase1’, puis une fois le mot ‘phrase2’. */
// Déclaration
I,N : entiers
// préparation du traitement
Ecris(‘’donner un entier N positif’’)
Lis N
//traitement
I=0 // initialisation du compteur I
Répéter
{
Ecris(‘’phrase1’’)
I=I+1

}
TantQue (I<N)

Ecris(‘’phrase2’’)

// Edition des résultats

Ecris (‘’Fin’’)

Remarque :

Avec la structure pour, le compteur est incrémenté automatiquement, il suffit de

préciser le pas. Par contre avec les deux autres structures, le compteur doit être

incrémenté(ou décrémenté) lors du traitement sans oublier de l’initialiser au départ.

IV-3 La sélection en algorithmique : La structure alternative

Dans cette structure, un certain nombre d’instructions est exécuté si la condition du test est
vérifiée, sinon, c’est un autre groupe d’instructions qui est exécuté. On distingue quatre
variantes de cette structure.
IV-3-1Sélection avec une seule alternative (structure alternative simple)

Lorsqu’il y’a une seule condition à vérifier, la syntaxe algorithmique se présente de la

manière suivante.
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Si (condition) { traitement}
EX-1 calculer l’inverse d’un nombre
// calcul de l’inverse d’un nombre
//réalisé par G. Mangoub
//29 Septembre 2014
//déclaration
Nombre,invnombre :réel
// préparation du traitement
Lis (Nombre)
// traitement
Si (Nombre !=0 )
{ invnombre= 1/ Nombre
Ecris (‘’ inverse= ‘’,invnombre)
}

// Edition des résultats

Ecris (‘’FIN’’)

IV-3-2 Sélection avec deux alternatives

Lorsqu’il y’a une deux condition à vérifier, la syntaxe algorithmique peut se présenter
deux manières.
IV-3-2-1 Première variante (structure alternative simple répétée)
Si (Condition1) {traitement1 }
Si (Condition2) {traitement2}

EX calculer la valeur absolue d’un nombre

// calcul de la valeur absolue d’un nombre
//réalisé par G. Mangoub
//29 Septembre 2014
//déclaration
Nombre,absnombre :réel
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

// préparation du traitement
Ecris(‘’donnez un reel’’)
Lis (Nombre)
// traitement
Si (Nombre>=0)
{ absnombre= Nombre
Ecris (‘’ val_absolue= ‘’,absnombre)
}
Si (Nombre<0)
{ absnombre= - Nombre
Ecris (‘’ val_absolue= ‘’,absnombre)
}

// Edition des résultats

Ecris (‘’FIN’’)
IV-3-2-2 Deuxième variante (structure alternative complète)
Si (Condition1) {traitement1 }
Sinon{traitement2}
EX calcul de l’inverse d’un nombre
// calcul de l’inverse d’un nombre
//réalisé par G. Mangoub
//29 Septembre 2014
//déclaration
Nombre,invnombre :réel
// préparation du traitement
Ecris’’Donner nombre reel’’
Lis (Nombre)
// traitement
Si (Nombre !=0)

{ invnombre= 1/ Nombre
Ecris (‘’ inverse= ‘’,invnombre)
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

}
Sinon
Ecris (‘’ Votre nombre est nul, pas d’inverse ‘’)

// Edition des résultats

Ecris (‘’FIN’’)

EX Editer le résultat pour la résolution d’une équation du second

/* Résolution d’une équation du second degré
A.X2 + B .X +C =0 avec A non nul */
//réalisé par G. Mangoub
//29 Septembre 2014
//déclaration
A,B,C,D :réel
// préparation du traitement
Ecris’’Donner trois reels A, B et C avec A non nul’’
Lis (A,B,C)
// traitement
D=B*B – 4*A*C
Si (D>=0)

{ Ecris (‘’ solution(s) reelle ‘’)}

Sinon
{Ecris (‘’ solutions complexe ‘’)}

// Edition des résultats

Ecris (‘’FIN’’)
IV-3-3 Imbrication de la sélection (la structure alternative complète imbriquée)
Elle est aussi utilisée lorsqu’il y’ a N conditions à vérifier, avec N>2.
Si (condition1) { traitement1}
Sinon Si (condition2) { traitement2}
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Sinon Si (condition3) { traitement3}

.
.
Sinon Si (conditionN-1) { traitementN-1}
Sinon { traitementN}
EX : Editer le résultat pour la résolution d’une équation du second degré uniquement sous
forme de message en utilisant la structure alternative complète imbriquée
/* Résolution d’une équation du second degré
A.X2 + B .X +C =0 avec A non nul */
//réalisé par G. Mangoub
//29 Septembre 2014
//déclaration
A,B,C,D :réel
// préparation du traitement
Ecris’’Donner trois reels A, B et C avec A non nul’’
Lis (A,B,C)
// traitement
D=B*B – 4*A*C
Si (D>0)

{ Ecris (‘’ deux racines reelles ‘’)}

Sinon
Si (D<0)

{Ecris (‘’ deux racines complexes ‘’)}

Sinon

{Ecris (‘’ une racine double reelle ‘’)}

// Edition des résultats

 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Ecris (‘’FIN’’)

IV-3-4 Le choix multiple (la structure alternative de cas)

Elle est aussi utilisée lorsqu’il y’a N conditions à vérifier.
Cette structure peut se présenter de la façon suivante :
Identificateur :entier
Si (condition1) identificateur=1 ;
Si (condition2) identificateur=2 ;

Si (conditionN-1) identificateur=N-1 ;

Si (conditionN) identificateur=N ;

selon(identificateur)
{
cas 1 :{traitement1 ;break ;}
cas 2 :{traitement2 ;break ;}
.
.
case N-1 :{traitementN-1 ;break ;}
default:{traitementN ;break ;}
}

Cette structure est aussi appelée la structure du switch.

Le corps de l'instruction switch prend la forme d'un bloc { } renfermant une suite
d'instructions.
Le fonctionnement de cette instruction est le suivant : expression est évaluée ;
{ s'il existe un énoncé cas avec une constante qui égale la valeur de expression, le contrôle est
transféré à l'instruction qui suit cet énoncé ;
{ si un tel cas n'existe pas, et si l'énoncé default existe, alors le contrôle est transféré à
l'instruction qui suit l'énoncé default ;
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

{ si la valeur de expression ne correspond à aucun cas et s'il n'y a pas d'énoncé default, alors
aucune instruction n'est exécutée.
Attention. Lorsqu'il y a branchement réussi à un énoncé cas, toutes les instructions qui le
suivent sont exécutées, jusqu'à la fin du bloc ou jusqu'à une instruction de rupture (break).

EX Editer le résultat pour la résolution d’une équation du second avec A non nul.
/* Résolution d’une équation du second degré
A.X2 + B .X +C =0 avec A non nul */
//réalisé par G. Mangoub
//29 Septembre 2014
//déclaration
A,B,C,D :réel
I :entier
// préparation du traitement
Ecris’’Donner trois reels A, B et C avec A non nul’’
Lis (A,B,C)
// traitement
D=B*B – 4*A*C
Si (D>0) I=1

Sinon
Si (D<0) I=2

Sinon
I=3

// Edition des résultats

Ecris (‘’FIN’’)
selon(identificateur)
{
cas 1 :{ { Ecris (‘’ deux racines reelles ‘’) ;break ;}
cas 2 :{ {Ecris (‘’ deux racines complexes ‘’);break ;}
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

cas3:{ {Ecris (‘’ une racine double reelle ‘’) ;break ;}

}
Ecris(‘’ FIN de l algorithme’’)
Remarque :
On peut remarquer ici que la nature de la structure alternative nous a obligé dans la majorité
des cas de ne pas respecter la structure tracée au départ. C’est à dire l’affichage des résultats
dans le second bloc et non le troisième.

Combinaison de conditions

L'opérateur logique ET

si note >= 5 alors {

si note < 10 alors {
Ecrire ("vous devez passer le rattrapage du module");
}

Ces deux si imbriqués reflètent une combinaison de deux conditions qui peut se traduire
par si la valeur de note est supérieure ou égale à cinq et que la valeur de note est inférieure à
dix, alors effectuer l'instruction, ce que l'on écrira :

si note >= 5 et note <=10 alors {

Ecrire ("vous devez passer le rattrapage du module ");
}

L'opérateur logique OU
Pour exprimer l'alternative, on utilise l'opérateur ou, la condition du si sera vraie si au moins
une des sous-conditions est vraie. Il faut donc que toutes les sous-conditions soient fausses
pour que le sinon soit exécuté.

si x < 0 ou x == 0 alors {
Ecrire ("l inverse de la racine carre de votre nombre x ne peut pas être calculee");
}
sinon {
Ecrire ("l inverse de la racine carre de votre nombre x vaut :", 1/sqrt(x));
}

Il est possible de donner plusieurs conditions :

si cd1 ou cd2 ou cd3 alors {

traitement1
}
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

sinon {
traitement2

L'opérateur logique NON

L'opérateur non représente la négation, il peut s'appliquer à une variable ou à une condition à
évaluer. En effet, dire "X<0" est une négation de "X>=0".

si non(X<0) alors {
Ecrire (" Votre nombre X a une racine carre);
}
sinon {
Ecrire (" Votre nombre X n’a pas de racine carre);
}

EX : écrire un algorithme qui classe par ordre croissant et qui affiche trois nombres lus au
clavier.

V- Les tableaux statiques

Supposons qu’on a une grande liste d’éléments de même type à manipuler, dans ce cas il
est plus commode de les caser dans un tableau dont le nombre de case est égale au nombre
d’éléments qu’on veut manipuler.

V-1 Les tableaux statiques à un seul indice (1D)

Déclaration
Pour les tableaux statiques 1D, la taille N c’est à dire le nombre de cases est fixée une fois
pour toute au début du programme. La numérotation des éléments commence à partir de 0
et se termine à un indice égal à N-1. Le i ème élément occupe donc la case (i-1) du
tableau. L’indice est obligatoirement un entier.

Syntax algorithmique de déclaration d’un tableau 1D :

type nom_du_tableau[taille]

Exemple

entier T[10] pour déclarer un tableau de 10 entiers.

reel V[20] ; pour déclarer un tableau de 20 réels
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Autre façon de déclarer T

constante N=10
entier T[N]

Manipulation des tableaux statiques 1D

a) Lecture et affichage

Exemple
Ecrire un algorithme qui lit et affiche un tableau d’entiers

// algorithme qui lit et affiche un tableau d’entiers

//déclaration
entier T[10]
I :entier
//préparation du traitement
Pour(I allant de 0 jusqu’à 9 par pas de 1)
{ecris(‘’donner l’elmt ‘’,I)
Lis T[I]
}
//traitement et affichage
Ecris(‘’voici votre tableau ‘’)
Pour(I allant de 0 jusqu’à 9 par pas de 1)
Ecris(T[I])
Ecris(‘’FIN’’)

Exemple
Ecrire un algorithme qui lit et affiche un tableau d’entiers de dimension N avec la
dimension déclarée comme constante.

// algorithme qui lit et affiche un tableau d’entiers

//déclaration
Constante N=10
entier T[N]
I :entier
//préparation du traitement
Pour(I allant de 0 jusqu’à N-1 par pas de 1)
{ecris(‘’donner l’elmt ‘’,I)
Lis T[I]
}
//traitement et affichage
Ecris(‘’voici votre tableau ‘’)
Pour(I allant de 0 jusqu’à N-1 par pas de 1)
Ecris(T[I])
Ecris(‘’FIN’’)

b) Recherche dans un tableau un seul indice

Exemple :
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

trouver le plus petit élément et sa position

Syntax algorithmique :
entier I,pospp,pp
Contante entier N=10
Pospp=0
Pp=T[0]
Pour I allant de 0 jusqu’à N-1 par pas de 1 fait

{si(T[I]<PP
{ pp=T[I]
Pospp=I
}
}

c) Tri des éléments d’un tableau à un seul indice

Ici nous ne présentons qu’un cas simple d’algorithme de tri dont le principe est le suivant :

Supposons que l’on veut classer par ordre croissant N variables casées dans un tableau. On

commence par supposer que la première variable est celle qui est la plus petite et on la

compare aux N-1 autres variables. Si cela est toujours vrai, la première variable dans

l’ancienne numérotation garde sa place, sinon on échange la place de cette variable avec la

première petite trouvée et ainsi de suite jusqu’à ce que la première case soit occupée

effectivement par la variable minimale, ensuite on fait pareil avec la deuxième variable, sans

toucher à la première et ainsi de suite sans toucher aux variables déjà triées . L’algorithme se

présente de la manière suivante :

Syntax algorithmique :
entier I,ECH
Contante entier N=10

Pour I allant de 0 jusqu’à N-2 par pas de 1 fait

Pour J allant de J+1 jusqu’à N-1 par pas de 1 fait

{si(T[I]> T[J]
{ ECH=T[I]
T[I]=T[J]
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

T[J]=ECH
}
}
for (I = 0 ;I<N-1 ; I++)

for (J = I+1; J<N ; J++)

if (B[I]> B[J])

Valint= B[I];
B[I]= B[J];
B[J] = valint ;
}

d) Suppression et tassement

On veut dans un tableau supprimer certains éléments et décaler vers la gauche d’autres

éléments du tableau à leur place. Dans les cases vides, on mettra des zéro.

Exemple

On donne

2 4 0 0 10 0 3 5 6 12

Et on veut arriver au tableau suivant :

2 4 10 3 5 6 12 0 0 0

Ecrire l’algorithme correspondant

V-2 Les tableaux statiques à deux indices (2D)

Pour Ces tableaux statiques à deux indices, le nombre de lignes NL et le nombre de

colonnes NC sont fixés une fois pour toute au début du programme. La numérotation des
éléments commence à partir de (0,0) et se termine à un indice égal à (NL-1,NC-1).

Syntax de déclaration d’un tableau à deux indices :

type nom_du_tableau[NL][NC] ;
 Mathématiques et Informatique pour la géologie
Pr. G. Mangoub

Exemple : int A[5] [6]; pour déclarer une matrice à 5 lignes et 6 colonnes dont les
éléments sont des entiers.

Manipulation des tableaux statiques 2D

a) Lecture et affichage

Exemple
Ecrire un algorithme qui lit et affiche une matrice A(NL,NC)avec NL et NC déclarés
comme constante. NL=3 et NC=4

Exemple

b) Mise à zéro des éléments des deux diagonales

Ecrire un algorithme qui lit une matrice A(NL,NC)et qui met à zéro les éléments des deux
diagonales.

c) Produit de deux matrices

Exemple

Ecrire un algorithme en C qui lit deux matrices carrées A(N,N)et B(N,N) et calcule leur
produit, soit C=A*B.