Support Algo Et Prog C C++Pascal

Cours d'algorithme et programmation réalisé par MATY Maman
Table des matières
Chap. 1 Structure d'un Algorithme(Programme) .................................................................................3

1. DEFINITION .............................................................................................................................3
2. Types ......................................................................................................................................3
3. Les variables............................................................................................................................3
4. Opérateurs ..............................................................................................................................4
5. Instructions d’écriture .............................................................................................................4
6. La lecture ................................................................................................................................5
7. Exemples.................................................................................................................................5
8. Applications ............................................................................................................................6
Chapitre 2. Les structures de contrôle .................................................................................................7
Les Tests .........................................................................................................................................7
1. Structure d’un test SI ...............................................................................................................7
a. Si simple ..............................................................................................................................7
b. Si sinon ...............................................................................................................................7
c. Si imbrique ..........................................................................................................................7
d. Exemples .............................................................................................................................8
2. Le choix .......................................................................................................................................8
Boucles ...........................................................................................................................................9
3. Pour ...........................................................................................................................................9
5. Tant que ..................................................................................................................................9
6. Répéter ................................................................................................................................. 11
TD1 Structures de contrôle ............................................................................................................... 11
Chapitre 3 Les sous programmes ...................................................................................................... 13
1. Les fonctions ............................................................................................................................ 13
2. Les procédures ...................................................................................................................... 15
3. La Récursivité ........................................................................................................................ 18
4. Exercices ............................................................................................................................... 20
Chapitre 4. Les tableaux .................................................................................................................... 21
1. Définition .............................................................................................................................. 21
2. Déclaration............................................................................................................................ 21
3. Saisie du tableau ................................................................................................................... 21
4. Afficher les éléments du tableau ........................................................................................... 21
Edition Avril 2022 : Page -1-

5. Rechercher une valeur dans un tableau ................................................................................. 22
6. Nombre d’occurrence............................................................................................................ 22
7. Les tris d'un tableau .............................................................................................................. 22
Tri par sélection ........................................................................................................................ 22
Tri à bulles................................................................................................................................. 23
8. TP TABLEAUX......................................................................................................................... 24
EXERCICE 1 ................................................................................................................................ 24
EXERCICE 2 ................................................................................................................................ 24
EXERCICE 3 ................................................................................................................................ 24
Chapitre 5 Les enregistrements......................................................................................................... 25
1. Déclaration............................................................................................................................ 25
2. Saisie..................................................................................................................................... 25
3. Affichage ............................................................................................................................... 25
4. Tris ........................................................................................................................................ 26
5. Programme Principal ............................................................................................................. 26
6. TP Structures ......................................................................................................................... 27
Chapitre 6 Les listes chainées ............................................................................................................ 28
1. Déclaration............................................................................................................................ 28
2. La pile.................................................................................................................................... 28
3. La file .................................................................................................................................... 28
4. Affichage ............................................................................................................................... 29
5. Saisie ordonnée..................................................................................................................... 29
6. Programme Principal ............................................................................................................. 30

Chap. 1 Structure d'un Algorithme(Programme)
Objectif: Apprendre les concepts de base de l'algorithmique et de la programmation. Être capable

de mettre en œuvre ces concepts pour analyser des problèmes simples et écrire les programmes
correspondants
1. DEFINITION
Un algorithme, c’est une suite d’instructions, qui une fois exécutée correctement, conduit à un
résultat donné. Si l’algorithme est juste, le résultat est le résultat voulu, et si l’algorithme est faux, le
résultat est aléatoire.
Pour fonctionner, un algorithme doit donc contenir uniquement des instructions

compréhensibles par celui qui devra l’exécuter.
2. Types
Le type d’une variable détermine l’ensemble des valeurs qu’elle peut prendre, les types offerts par la
plus part des langages sont:
Algo C++ C Pascal

entier int int integer
réel float float real
Booléen bool boulean
Caractère char char char
Chaine de caractères string string
3. Les variables
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), ou lues à travers un CD, une Clé USB. 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 ou des booléens
Déclaration des variables
La première chose à faire avant de pouvoir utiliser une variable est de créer la boîte et de lui
coller une étiquette. Ceci se fait tout au début de l’algorithme, avant même les instructions
proprement dites. C’est ce qu’on appelle la déclaration des variables.
Le nom de la variable (l’étiquette de la boîte) obéit à des impératifs changeant selon les langages.
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 également impérativement par une lettre. Quant au nombre maximal de signes
pour un nom de variable, il dépend du langage utilisé.
Lorsqu’on déclare une variable, il ne suffit pas de créer une boîte (réserver un emplacement
mémoire) ; encore doit-on préciser ce que l’on voudra mettre dedans, car de cela dépendent
la taille de la boîte (de l’emplacement mémoire) et le type de codage utilisé.
Algo C C++ Pascal

Variables Algo int a,b,c; int a,b,c; var a,b,c:integer;
a,b,c:entier float taille; float taille; taille:real;
taille:réel bool b1, b2 ; b1, b2 : boolean;
b1, b2 : booleen string nom, prenom ; nom, prenom : string ;
nom, prenom : chaine char reponse ; char reponse ; reponse : char ;
reponse : caractère
4. Opérateurs
Algo C++ et C Pascal Signification

+ + + Addition
- - - Soustraction
* * * Multiplication
/ / /, div pour les entiers Division
Modulo % Mod Reste de la division
Et && And et
Ou || or Ou
Non ! not Pas(non)
= == = Egal
≠ != <> différent
≤ <= <= Inférieur ou égal
≥ >= >= Supérieur ou égal
< < < Inférieur
> > > Supérieur
 = := affectation
5. Instructions d’écriture
C C++ Pascal
printf("Message") ; cout<< "message" ; Write(‘Message’) ;
cout<< variable ; Write(x) ;
printf("message %format" , variable) ; cout<< "message"<< variable ;
Revenir à la ligne; cout<<endl; Writeln(‘x vaut : ‘,x) ;
ou cout<<"\n"; Clrscr() ;
Effacer l'écran: system("cls");

Type Nom Format

Entier décimal int %d
Caractère char %c
Chaine de caractère Char* %s
Réel float %f
Entier long long %ld
Les instructions de lecture et d'écriture permettent à la machine de communiquer avec l'utilisateur
6. La lecture
La lecture permet d'entrer des donnés à partir du clavier
C C++ Pascal
scanf("%format", &variable) ; Cin>>variable ; Read(variable) ;
scanf("%d%f%c%",&v1,& v2,&v3) ; Cin>> v1>> v2>> … Read(v1, v2, …, vn) ;
>>n) ;
Remarque: Le programme s'arrête lorsqu'il rencontre une instruction Lire et ne se poursuit qu'après
la frappe d’une valeur au clavier et de la touche Entrée
Conseil: Avant de lire une variable, il est fortement conseillé d’écrire des messages à l’écran, afin de
prévenir l’utilisateur de ce qu’il doit frapper
Écrire un algorithme qui demande un nombre entier à l'utilisateur, puis qui calcule et affiche le
double de ce nombre
7. Exemples
C C++ Pascal
#include<stdio.h> #include<iostream> Program somme ;
int a,b,s; using namespace std; Var a,b,s : integer ;
int main() int a,b,s; Bigin
int main() Write(‘Donnez deux
{ entier :’) ;
printf("Donnez deux entiers :"); { cout<<"Donnez deux entiers"; Read(a,b) ;
scant("%d%d",&a,&b); Cin>>a>>b; S :=a+b ;
s=a+b; s=a+b; Write(a, ‘+’, b, ‘=’, s) ;
printf("%d+%d=%d\n”,a,b,s); cout<<a<<"+"<<b<<"="<<s; Readln ;
return 0; return 0; End.
} }

8. Applications
Écrire un programme qui:
1. Calcule et affiche la somme de trois entiers
2. Calcule et affiche le reste de la division entre deux entiers
3. Calcule et affiche le produit de trois entiers
4. Calcule et affiche la somme, le produit et la moyenne de trois entiers

Chapitre 2. Les structures de contrôle
Les Tests
1. Structure d’un test SI
Le si est utilisé si on a plusieurs cas et que c'est un seul choix qui se réalisera.
Nous avons trois formes possibles .
a. Si simple
Algo C++/C Pascal

Si condition Alors if(condition) If condition then
Instructions { Begin
Action ; Action ;
Finsi
} End ;
b. Si sinon
Algo C++/C Pascal

Si condition Alors if(condition) If condition then
Instructions 1 { Begin
Action1 ; Action1 ;
Sinon
} End
Instructions 1 else Else
Finsi { Begin
Action2 ; Action2 ;
} End ;
c. Si imbrique
Algo C++ Pascal

Si condition1 Alors if(condition1) If condition then
Instructions 1 { Begin
Sinon Action1 ; Action1 ;
Si condition2 Alors } End
else Else
Instructions 2
{ Begin
Sinon if(condition2) If condition 2 then
{ Begin
Instructions Action2 ; Action2 ;
} End
finsi else Else
Finsi { Begin
Action ; Action ;
} End ;
} End ;

d. Exemples
C C++ Pascal
#include <stdio.h> #include <iostream>
using namespace std; program signe;
int main() var
int main()
{ a : integer;
int a; begin
int a; cout << "Tapez la valeur de a : "; write('Tapez la valeur de a : ') ;
printf("Tapez la valeur de a :"); read(a);
cin >> a;
scanf("%d", &a); if a > 0 then
if (a< 0)
if (a< 0) write (a, ' est positif')
cout << a<< " est negatif »;
printf("%d est negatif", a); else
else if (a>0) else if (a>0) if <0 then
printf("%d est positif", a); cout << a<<" est positif " ; write (a, ' est negatif')
else else else
printf("%d est nul", a) ; cout << a<<" est nul " ; write(a, ‘ est nul’);
return 0; return 0; readln;
} }
end.
2. Le choix
La structure Si peut être remplacée par le choix dans certaines conditions, qui est plus simple à
représenter.
Algo C++ Pascal

#include <iostream> program choix;
#include <stdio.h> using namespace std; var n: integer;
int main() begin
int main() { write('Donnez le nombre:');
{ int a;
read(n);
int a; cout << "Tapez la valeur de a : ";
printf("Tapez la de a :"); cin >> a;
case a of
scanf("%d", &a); switch(a) 0..10: writeln('Vous etes petit!');
switch(a) { 11..17: writeln('Vous etes
{ case 1 : adolescent:');
case 1 : cout << "a vaut 1"; break; 18: writeln('Vous etes adulte!');
printf("%d vaut 1", a); case 2 : 19..50: writeln('Vous etes grand!');
break; cout << "a vaut 2"; break; 51..150: writeln('Vous etes Vieux
case 2 : case 3 : mon grand!');
printf("%d vaut 2", a); cout << "a vaut 3"; break; else: writeln('Quelle âge
break; default :
vraiment??');
case 3 : cout << "a ne vaut ni 1, 2, ni
printf("%d vaut 3", a); 3" ;
end;
break; } writeln();
default : return 0; readln;
printf("a est different } end.
de 1, 2 et 3") ;
}
return 0;
}

Boucles
Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instructions. Cet
ensemble d’instructions s’appelle le corps de la boucle. Chaque exécution du corps d’une
boucle s’appelle une itération, ou encore un passage dans la boucle. Il existe trois types de
boucle :
 Tant que
 Répéter ... jusqu’à
 Pour
Chacune de ces boucles a ses avantages et ses inconvénients. Nous les passerons en revue
ultérieurement.
3. Pour
Algo C++/C Pascal

Pour i= début allant à fin faire for (i=début ; i<= fin ; i++) For i := debut to fin do
Instruction { Begin
Fin pour Actions ; Actions ;
} end
Exemples
C C++ Pascal
#include <stdio.h> #include <iostream> program compter;
using namespace std;
int main() int main() var n,i: integer;
{ { int i,n; begin
int i, n; Cout<<”Donnez un entire:”
write('Donnez le nombre:');
printf("Saisir un nombre :"); read(n) ;
Cin>>n
scanf("%d", &n); for i :=1 to n do
for(i=0 ; i<=n ; i++)
for(i=0 ; i<=n ; i++) writeln(i, ‘ ‘);
cout << i << “ “;
printf(" %d ", i); readln() ;
return 0; return 0; end.
} }
5. Tant que
La syntaxe d’une boucle Tant que est la suivante.

La condition est évaluée avant chaque passage dans la boucle, à chaque fois qu’elle est vérifiée, on
exécute les instructions de la boucle. Une fois que la condition n’est plus vérifiée, l’exécution se
poursuit après le fin tant que

Algo C++/C Pascal
Initialisation Initialisation; Initialisation;
Tant que condition faire while (condition) While condition do
Début { begin
Action répétée Action répétée ; Action répétée ;
Action suivante Action suivante ; Action suivante ;
fin. } End;
Exemples
C C++ Pascal
#include <stdio.h> #include <iostream> Program somme ;
int main() using namespace std; Var s, n :integer ;
{ int main() Begin
int s=0,n; { int s=0,n; Write("Donnez un entier :") ;
printf("Saisir un entier :"); cout<<”Donnez un entier:”; Read(n) ;
scanf("%d", &n); S :=0 ;
cin>>n;
while(n !=0) While n<> 0 do
while(n !=0)
{ Begin
{
s+=n; S :=s+n ;
printf("Saisir un entier :"); s+=n; Write("Donnez un entier :" ;
scanf("%d", &n); cout<<”Donnez un entier:”; Read(n) ;
} cin>>n; End ;
printf("La somme est: %d", s); } Write(‘la somme=’,s) ;
return 0; cout<<”S=”<<s<<end; Readln() ;
return 0; End.
} }
Nombres aléatoires
C Pascal C++
#include<time.h> program alea; #include<iostream>
# include <stdio.h> uses crt ; #include<ctime>
# include <cstdlib>
int main() var i,k:integer; using namespace std;
{ begin int main()
srand(time(0)); {
int k=1; randomize; srand(time(NULL));
while( k<=10) k:=1; int k=1;
{ while k<=10 do while( k<=10)
int i=rand()%10; begin {
printf(" %d ", i); i:=random(10); int i=rand()%10;
k++; writeln(i); cout<<i<<endl;
} k:=k+1; k++;
return 0; end; }
} end. return 0;
}

6. Répéter
Le fonctionnement est analogue à celui de la boucle tant que à quelques détails près :
 la condition est évaluée après chaque passage dans la boucle.
 On exécute le corps de la boucle jusqu’à ce que la condition soit vérifiée, donc tant
que la condition est fausse.
Remarque : Une boucle Répéter est donc exécutée donc au moins une fois.
Algo C++/C Pascal

Initialisation Initialisation; Initialisation;
répéter do repeat
Action répétée { Action répétée ;
Action suivante Action répétée ; Action suivante ;
Jusqu’à condition. Action suivante ; Until condition;
}
while (condition);
Exemple
Algo C++ Pascal

#include <stdio.h> #include <iostream> Program somme ;
int main() using namespace std; Var s, n :integer ;
{ int main() Begin
int i=1,n; { int s=0,n; S :=0 ;
do
printf("Saisir un entier :"); repeat
{
scanf("%d", &n); cout<<”Donnez un entier:”;
Write("Donnez un entier :" ;
printf("Les diviseurs de %d Cin>>n; Read(n) ;
sont: \n", n); S+=n; S :=s+n ;
do } until n=0 ;
{ while(n !=0); Write(‘la somme=’,s) ;
if(n %i==0) Cout<<”S=”<<s<<end; Readln() ;
printf(" %d ", i); return 0; End.
i++; }
}
while(i<=n);
return 0;
TD1 Structures de contrôle
Exo 1
1. Écrire un programme qui résout l’équation ax2+bx+c=0 en envisageant tous les cas
particuliers.
2. Écrire un programme qui demande à l’utilisateur de saisir un entier X et qui affiche la valeur
absolue de X.
3. Écrire un programme qui demande à l’utilisateur de saisir 3 entiers A, B et C et qui indique si
C est compris entre A et B, bornes incluses.

4. Écrire un programme qui demande à l’utilisateur de saisir un entier A puis qui affiche
"ERREUR" si A n'est pas un nombre impair compris entre 83 et 101 bornes incluses.
Dans le cas contraire, on affiche "PAS D'ERREUR".
Exo 2
1. Écrire un programme ; qui dit si une année donnée est une année bissextile. Une année est
bissextile si elle est divisible par 4
2. Écrire un programme qui demande un numéro de mois à l’utilisateur et indique en retour
son nom et le nombre de jours dans ce mois.
Exo 3 :
Écrire un programme qui lit le nombre d'années le nombre de moi et des jours pour tout en jour.
Exemple: 9 ans 8 mois et 20 jours=3500jours
Exo 4 :
Écrire un programme qui lit un entier n et affiche entiers inférieurs ou égaux à n, leurs carrés et leurs
cubes. Il affiche à la fin la somme de ces entiers ; la somme des carrés et la somme des cubes.
Exo 5:
1. Écrire un programme qui va afficher à l’écran les entiers compris entre 5 et 35.
2. Écrire un programme qui va afficher les multiples de 3 compris entre deux bornes données
3. Écrire un programme qui va afficher les multiples de 4 compris entre deux bornes données
4. Écrire un programme qui calcule le maximum entre quatre entier a, b, c et d.
Exo 6:
1. Écrire un programme, qui affiche les multiple d'un entier donné inférieurs à 100;
2. Écrire un programme qui affiche les diviseurs d'un entier n donnée
Exo 7:
1. Écrire un programme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la
réponse convienne. En cas de réponse supérieure à 20, on fera apparaître un message :
« Plus petit ! », et inversement, « Plus grand ! » si le nombre est inférieur à 10.
2. Écrire un programme qui demande un nombre de départ, et qui calcule la somme des
entiers jusqu’à ce nombre.
3. Écrire un programme qui un réel n et calcule la somme
s= +…+
4. Écrire un programme ; qui lit une série de réels, calcule puis affiche leur somme S ; leur
produit P et leur Moyenne M. le programme va s'arrêter lorsque l'utilisateur entre 0 (zéro)
5. Écrire un programme qui demande à l’utilisateur de saisir 2 entiers A et B qu'il affiche à
l'écran. Le programme ne s'arrêtera que lorsque les deux entiers seront tous impairs

Chapitre 3 Les sous programmes
Certains problèmes conduisent à des programmes longs, difficiles à écrire et à

comprendre. On les découpe en des parties appelées sous-programmes ou modules. Les
fonctions et les procédures sont des modules (groupe d'instructions) indépendants
désignés par un nom. Elles ont plusieurs intérêts :
 permettent de "factoriser" les programmes, ce t à dire de mettre en

commun les parties qui se répètent
 permettent une structuration et une meilleure lisibilité des programmes
 facilitent la maintenance du code (il suffit de modifier une seule fois)
 ces procédures et fonctions peuvent éventuellement être réutilisées dans
d'autres programmes
1. Les fonctions
Le rôle d'une fonction en programmation est similaire à celui d'une fonction en

mathématique : elle retourne un résultat à partir des valeurs des paramètres
Une fonction s'écrit en dehors du programme principal sous la forme :
Fonction nom_fonction (paramètres et leurs types) : type_retour
Instructions constituant le corps de la fonction
retourne variable
FinFonction
Pascal
function nomfonction( variables :type):type retour;

variables;
begin
instructions
nomfonction:=variable retour;
end;
C++
type nomfonction(parametres)
{
Corps de la fonction;
Return type resultat;
}

Pour le choix d'un nom de fonction il faut respecter les mêmes règles que celles pour les
noms de variables
type_fonction est le type du résultat retourné
L'instruction retourne sert à retourner la valeur du résultat
La fonction SommeCarre suivante calcule la somme des carrées de deux réels x et y :
Fonction SommeCarre (x : réel, y: réel ) : réel int sommecarre(int x, int y)

variable z : réel {
z ←x*x+y*x int z;
retourne z z=(x*x)+(y*y);
FinFonction return z;
}
C C++ Pascal
int paire(int x) bool paire(int x) Function paire(x:integer) :
{ { integer
return x%2==0; return x%2==0; Begin
} } Paire :=x mod 2 ; end ;
int minimum(int a, int b) int minimum(int a, int b)
{ {
int mn=a; int mn=a;
if(b<mn) if(b<mn)
mn=b; mn=b;
return mn; return mn;
} }
int puissance(int a, int b) int puissance(int a, int b) function
{ { puissance(x,n:integer):integer;
int p=1,i; int p=1,i; var i,p:integer;
for(i=1;i<=b;i++) for(i=1;i<=b;i++) begin
p=p*a;//p*=a; p=p*a;//p*=a; p:=1;
return p; return p; for i:=1 to n do
} } p:=p*x;
puissance:=p;
end;
int factorielle(int n) int factorielle(int n)
{ {
int f=1,i; int f=1,i;
for(i=1;i<=n;i++) for(i=1;i<=n;i++)
f=f*i; f=f*i;
return f; return f;
} }

L'utilisation d'une fonction se fera par simple écriture de son nom dans le programme
principale. Le résultat étant une valeur, devra être affecté à une variable ou être utilisé
dans une expression, une écriture, ...
Algorithme exepmleAppelFonction
variables z : réel, b : booléen
Début
b ←Paire(3)
z ←5*SommeCarre(7,2)+1
écrire("SommeCarre(3,5)= ", SommeCarre(3,5))
Fin
2. Les procédures
Dans certains cas, on peut avoir besoin de répéter une tache dans plusieurs endroits du
programme, mais que dans cette tache on ne calcule pas de résultats ou qu'on calcule
plusieurs résultats à la fois.
Dans ces cas on ne peut pas utiliser une fonction, on utilise une procédure
Une procédure est un sous-programme semblable à une fonction mais qui ne retourne
rien ou plusieurs résultats
Une procédure s'écrit en dehors du programme principal sous la forme :
Procédure nom_procédure (paramètres et leurs types)

Instructions constituant le corps de la procédure
FinProcédure
Remarque : une procédure peut ne pas avoir de paramètres
L'appel d'une procédure, se fait dans le programme principal ou dans une autre
procédure par une instruction indiquant le nom de la procédure :
Procédure exemple (…)
instruction
FinProcédure

Algorithme exepmleAppelProcédure
Début
exemple (…)
Fin
Remarque : contrairement à l'appel d'une fonction, on ne peut pas affecter la procédure

appelée ou l'utiliser dans une expression. L'appel d'une procédure est une instruction
autonome
Les paramètres servent à échanger des données entre le programme principal (ou la
procédure appelante) et la procédure appelée
Les paramètres placés dans la déclaration d'une procédure sont appelés paramètres
formels. Ces paramètres peuvent prendre toutes les valeurs possibles mais ils sont
abstraits (n'existent pas réellement)
Les paramètres placés dans l'appel d'une procédure sont appelés paramètres effectifs.
Ils contiennent les valeurs pour effectuer le traitement
Le nombre de paramètres effectifs doit être égal au nombre de paramètres formels.

L'ordre et le type des paramètres doivent correspondre
Transmission des paramètres
Il existe deux modes de transmission de paramètres dans les langages de

programmation:
La transmission par valeur : les valeurs des paramètres effectifs sont affectées aux
paramètres formels correspondants au moment de l'appel de la procédure. Dans ce
mode le paramètre effectif ne subit aucune modification
La transmission par adresse (ou par référence) : les adresses des paramètres effectifs
sont transmises à la procédure appelante. Dans ce mode, le paramètre effectif subit les
mêmes modifications que le paramètre formel lors de l'exécution de la procédure
Remarque : le paramètre effectif doit être une variable (et non une valeur) lorsqu'il s'agit
d'une transmission par adresse
En pseudo-code, on va préciser explicitement le mode de transmission dans la

déclaration de la procédure
Procédure incrementer1 (x : entier par valeur, y : entier par adresse)
x ← x+1

y ← y+1
FinProcédure
Algorithme Test_incrementer1
variables n, m : entier
Début
n←3
m←3
incrementer1(n, m) résultat :
écrire (" n= ", n, " et m= ", m) n=3 et m=4
Fin
Remarque : l'instruction x ← x+1 n'a pas de sens avec un passage par valeur
Procédure qui calcule la somme et le produit de deux entiers :
Procédure SommeProduit (x,y: entier par valeur, som, prod : entier par adresse)
som ← x+y
prod ← x*y
FinProcédure
Procédure qui échange le contenu de deux variabales :
Procédure Echange (x : réel par adresse, y : réel par adresse)
variables z : réel
z←x
x←y
y←z
FinProcédure
La portée des variables
On peut manipuler 2 types de variables dans un module (procédure ou fonction) : des

variables locales et des variables globales. Elles se distinguent par ce qu'on appelle leur
portée (leur "champ de définition", leur "durée de vie")
Une variable locale n'est connue qu'à l'intérieur du module ou elle a été définie. Elle est
créée à l'appel du module et détruite à la fin de son exécution
Une variable globale est connue par l'ensemble des modules et le programme
principale. Elle est définie durant toute l’application et peut être utilisée et modifiée par
les différents modules du programme

3. La Récursivité
Un module (fonction ou procédure) peut s'appeler lui-même: on dit que c'est un module
récursif
Tout module récursif doit posséder un cas limite (cas trivial) qui arrête la récursivité
Exemple : Calcul de la factorielle
Fonction fact (n : entier ) : entier

Si (n=0) alors
retourne (1)
Sinon
retourne n*fact(n-1)
Finsi
FinFonction
Exemple
Écrivez une fonction récursive (puis itérative) qui calcule le terme n de la suite de
Fibonacci définie par : U(0)=U(1)=1
U(n)=U(n-1)+U(n-2)
Fonction Fib (n : entier ) : entier

Variable res : entier
Si (n=1 OU n=0) alors
res ←n
Sinon
res ← Fib(n-1)+Fib(n-2)
Finsi
retourne (res)
FinFonction
Une fonction itérative pour le calcul de la suite de Fibonacci :
Fonction Fib (n : entier ) : entier

Variables i, AvantDernier, Dernier, Nouveau : entier
Si (n=1 OU n=0) alors
retourne (n)
Finsi
AvantDernier ←1, Dernier ←1
Pour i allant de 2 à n faire
Nouveau← Dernier+ AvantDernier
AvantDernier ←Dernier
Dernier ←Nouveau
FinPour
retourne (Nouveau)
FinFonction

Remarque: la solution récursive est plus facile à écrire
Une procédure récursive qui permet d'afficher la valeur binaire d'un entier n
Procédure binaire (n : entier )

Si (n<>0) alors
binaire (n/2)
écrire (n mod 2)
Finsi
FinProcédure
#include <stdio.h>
void binaire(int n)
{
if(n!=0)
{
binaire(n/2);
printf("%d", n%2);
}
}
int main()
{
int n;
do
{
printf("\nSaisir un entier :");
scanf("%d", &n);
if (n!=0) printf("%d = ",n);
binaire(n);
}
while(n!=0);
return 0;
}

4. Exercices
1. Écrire une fonction qui prend en paramètre un entier et affiche ses diviseurs
2. Écrire une fonction qui prend en paramètre un entier et compte ses diviseurs
3. Écrire une fonction qui prend en paramètre un entier et affiche s’il est premier ou pas
4. Lire un nombre et afficher tous les nombres premiers inférieurs ou égaux à ce nombre
5. Écrire une fonction qui prend en paramètre un réel et renvoie son carré
6. Écrire une fonction qui prend en paramètre un réel et renvoie son carré, son cube et
7. Écrire une fonction qui prend en paramètre trois réels et renvoie le plus petit d’entre eux
8. Écrire la fonction polynôme suivant p(x)=2x²-3x+4
9. Écrire la fonction polynôme suivant z(x,y)=2x²-3xy+5y²-2
10. Écrire une fonction qui lit trois noms et les classe par ordre alphabétique croissant
11. Lire plusieurs nombre et renvoyez leur somme, leur minimum, leur moyenne, leur maximum
et leur produit
12. Lire une série et afficher sa variance et son écart type
13. Lire un nombre et afficher la somme des carrés jusqu’à ce nombre

Chapitre 4. Les tableaux
1. Définition
Un tableau est un regroupement de variables de même type, il est identifié par un nom.
Chacune des variables du tableau est numérotée, ce numéro s’appelle un indice. Chaque
variable du tableau est donc caractérisée par le nom du tableau et son indice.
2. Déclaration
Comme les variables d’un tableau doivent être de même type, il convient de préciser ce type
au moment de la déclaration du tableau. De même, on précise lors de la déclaration du
tableau le nombre de valeurs qu’il contient.
La syntaxe est :
Algo C++/c Pascal
Var Tableau[taille] : type Type nomtableau[taille] ; Var Tableau :array[1..N] of type ;
Par exemple,
Algo C++/C Pascal

Var T[10] : entier # define Taille=10 const taille =10;
int T[Taille] ; T : Array[1..taille] of real;
3. Saisie du tableau
Algo C++ Pascal
Affciher "Donnez la taille :" cout<<"Donnez la taille:"; Write(‘Donnez la taille :’) ;
Lire(N) cin>>n; Read(n) ;
for(i=0;i<n;i++) for i:=1 to n do
Pour i allant de 1 à N faire { begin
Ecire "donner la valeur :"
cout<<"Donnez la valeur :"; write('Donnez la valeur:');
lire E[i]
Finpour cin>>T[i]; read(T[i]);
} end;
4. Afficher les éléments du tableau
Algo C++ Pascal

Procedure afficher(t) void afficher(int T[]) procedure afficher(T: tab);
bebut { begin
Pour i allant de 1 a n faire for(i=0;i<nb;i++) for i:=1 to n do
Affciher(T[i]) cout <<T[i]<<" "; writeln(T[i]:3:2);
FinPour cout<<endl; end;
FinProcedure } ;

Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise des boucles
pour manier les tableaux, celles-ci permettent d’effectuer un traitement sur chaque élément
d’un tableau. Pour lire ou afficher un tableau il est plus facile d'utiliser la boucle pour.
5. Rechercher une valeur dans un tableau
C++ Pascal
void rechercher(int T[], int v) procedure rechercher(t:tab; v:real);
{ var trouver : boolean;
i=0; begin
bool trouver =false; trouver:=false;
while (!trouver && i<n ) i:=1;
{ while (not trouver) and (i<=n) do
if( T[i]==v) begin
trouver=true; if T[i]=v then
else trouver:=true
i++; else
} i:=i+1;
if (!trouver) end;
cout<<v<< " n'est pas dans le tableau"; if trouver then
else write(v:3:2 ,' est dans le tableau … l''indice: ' ,i)
cout<<v<<" est a la position:"<<i+1; else write(v, 'n''est dans le tableau!!');
cout<<endl; writeln;
} end;
6. Nombre d’occurrence
Le nombre d’occurrence est le nombre de fois qu’un élément appartient à un tableau. Il faut
parcourir le tableau du début jusqu’à sa fin et dénombrer cette valeur
C++ Pascal
int occurrence(int T[], int v) function occurrence(t:tab; v:real): integer;
{ var c:integer;
int c=0; begin
for(i=0; i<n;i++) c:=0;
if(T[i]==v) for i:=1 to n do
c++; if t[i]=v then
return c; c:=c+1;
} occurrence:=c;
end;
7. Les tris d'un tableau

Tri par sélection
La technique du tri par sélection est la suivante : on met en bonne position l’élément
numéro 1, c’est-à-dire le plus petit. Puis en met en bonne position l’élément suivant. Et ainsi
de suite jusqu’au dernier élément.

Algo C++ Pascal
Procedure Tri_par_sélection procedure trierparselection(var
Variables i,k,j,n,t[12],temp:entier t:tab);
Ecrire "donnez la taille:"
void triselection(int T[]) var aux:real; j,k:integer;
{ int i,j,k,aux; begin
Lire[n]
for(i=0 ;i<nb-1;i++) for i:=1 to n-1 do
Pour i ← 1 à n-1 faire
{ k=i; begin
k←i for(j=i+1; j<nb;j++) k:=i;
Pour j ← i + 1 à n faire if (T[j] < T[k]) for j:=i+1 to n do
Si t[k] < t[j] Alors k=j; if t[j] < t[k] then
k←j aux=T[k]; k:=j;
Finsi T[k]=T[i]; aux:=T[k];
fin pour T[i]=aux; T[k]:= T[i];
} T[i]:=aux;
temp← t[k]
} end;
t[k] ← t[i]
end;
t[i] ← temp
fin pour
Fin
Tri à bulles
L’idée de départ du tri à bulles consiste à se dire qu’un tableau trié en ordre croissant,
c’est un tableau dans lequel tout élément est plus petit que celui qui le suit.
En effet, prenons chaque élément d’un tableau, et comparons-le avec l’élément qui le
suit. Si l’ordre n’est pas bon, on permute ces deux éléments. Et on recommence jusqu’à ce
que l’on n’ait plus aucune permutation à effectuer. Les éléments les plus grands
« remontent » ainsi peu à peu vers les premières places, ce qui explique la dénomination de
« tri à bulle ».
Algo C++ Pascal

Algo Tri_par_sélection procedure trier(var t:tab);
Variables i,k,j,n,t[12]:entier void tribulle(int t[]) var aux:real;
Debut
{ int aux; j:integer;
for(i=0; i<nb-1; i++) begin
Pour i ← 1 à n-1 faire
for(j=i+1; j<nb; j++) for i:=1 to n-1 do
k←i if (t[i]>t[j]) for j:=i+1 to n do
Pour j ← i + 1 à n faire { if t[i] <= t[j] then
Si t[j] < t[i] Alors aux=t[j]; begin
temp← t[j] t[j]=t[i]; aux:=T[i];
t[j] ← t[i] t[i]=aux; T[i]:= T[j];
t[i] ← temp } T[j]:=aux;
fin si } end;
end;
fin pour
fin pour
Fin

8. TP TABLEAUX
EXERCICE 1
1. Écrire un programme qui demande à l'utilisateur de saisir n entiers stockés dans un tableau. Le
programme doit afficher le nombre d'entiers supérieurs ou égaux à 10.
2. Le programme doit rechercher si un réel V se trouve dans le tableau et afficher "V se trouve dans
le tableau" ou "V ne se trouve pas dans le tableau".
3. Le programme doit ensuite afficher l'indice du plus grand élément du tableau.
4. Le programme doit ensuite afficher soit "le tableau est croissant", soit "le tableau est
décroissant", soit "le tableau est constant", soit "le tableau est quelconque".
EXERCICE 2
Écrire un programme qui demande à l'utilisateur de saisir n réels stockés dans un tableau.
Le programme doit permettre de:
1. saisir et afficher k réels

2. Calculer et afficher leur somme
3. Calculer et afficher leur moyenne
4. Chercher et afficher leur minimum
5. Chercher et afficher leur Maximum
6. Trier le tableau par ordre croissant et le réafficher.
7. Rechercher les deux plus grandes valeurs du tableau
EXERCICE 3
Écrire un programme qui demande à l'utilisateur de saisir n nom stockés dans un tableau.
Le programme doit permettre de:
1. saisir et afficher les n Noms;
2. Chercher et afficher le plus petit nom
3. Chercher et afficher le grand nom
4. Trier le tableau par ordre croissant
5. réafficher le tableau.

Chapitre 5 Les enregistrements
Les tableaux traitent des éléments homogène (de même type), très nous avons besoin de manipuler
des éléments de types différents d’où utilité des enregistrements.
1. Déclaration
C C++ Pascal
#include <iostream> program enreg;
#include <cstdlib> uses crt;
using namespace std; const Taille=20;
type employes=record
struct employer nom, prenom: string;
{ salaire:longint;
string nom, prenom; end;
int salaire; type tab=array[1..Taille] of
}; employes;
var e:employes;
typedef struct employer emp; T:tab ;
emp e, *T; i,n:integer;
2. Saisie
C C++ Pascal
void saisie(emp *&T) procedure saisie(var T: tab);
{ begin
for(i=0; i<n; i++) for i:=1 to n do
{ begin
cout<<"Donnez le Nom:"; write('Donnez le nom:');
cin>>T[i].nom; readln(e.nom);
cout<<"Donnez le Prenom:"; write('Donnez le prenom:');
cin>>T[i].prenom; readln(e.prenom);
cout<<"Donnez le salaire:"; write('Salaire:') ;
cin>>T[i].salaire; readln(e.salaire);
} T[i]:=e;
} end;
end;
3. Affichage
C C++ Pascal
void afficher(emp * T) procedure afficher(t:tab);
{ begin
cout<<"\n----------------------------------\n"; writeln('Nom Prenom
cout<<"Nom\t\tPrenom\t\tSalaire\n"; Salaire');
for(i=0; i<n; i++) for i:=1 to n do
cout<<T[i].nom<<"\t\t"<<T[i].prenom<<"\t\t" writeln(T[i].nom, ' ',
<<T[i].salaire<<endl; t[i].prenom, ' ', t[i].salaire);
cout<<endl; writeln('---------------------);
} end

4. Tris
C C++ Pascal
void trier(emp *&T) procedure trier(var t:tab);
{ var j: integer;
for(int i=0; i<n-1;i++) begin
for(int j=i+1;j<n;j++) for i:=1 to n-1 do
for j:=i+1 to n do
if (T[i].salaire < T[j].salaire ) if T[i].salaire <t[j].salaire then
{ begin
e=T[i]; e:=T[i];
T[i]=T[j]; t[i]:=t[j];
T[j]=e; t[j]:=e;
} end;
} end;
5. Programme Principal
C C++ Pascal
int main() begin

{ clrscr;
cout<<"Donnez le nombre write('Donnez d''employes:');
d'employes:"; readln(n);
cin>>n; saisie(t);
T= new emp[n]; afficher(t);
saisie(T); trier(t);
system("cls"); afficher(t);
afficher (T); readln ;
trier(T); end.
afficher(T);
return 0;
}

6. TP Structures
Exo1 :
Soit une structure étudiant composée des champs Nom, Prénom, Age, Moyenne, Rang et Mention.
1. Écrire une fonction qui permet de saisir la liste des étudiants
2. Écrire une fonction qui permet d'afficher la liste des étudiants
3. Écrire une fonction qui permet d'affecter une mention aux étudiants
4. Écrire une fonction qui permet d'affecter le rang aux étudiants
5. Écrire une fonction qui permet d'afficher la liste des admis
6. Écrire une fonction qui permet d'afficher la liste des exclus
7. Écrire une fonction qui permet d'afficher la liste des redoublants
8. Écrire une fonction qui permet rechercher un étudiant en fonction de Nom et de son Prénom
9. Écrire le programme principal avec un menu correspondant aux différentes fonctions
Exo2 :
Soit une structure monôme composée des champs coefficient et exposant.
1. Écrire une fonction qui permet de saisir la liste des monômes (polynôme)
1. Écrire une fonction qui permet d'afficher la liste un polynôme
2. Écrire une fonction qui permet de calculer et afficher la dérivée d'un polynôme
3. Écrire une fonction qui permet de calculer et afficher la primitive d'un polynôme
4. Écrire une fonction qui permet de calculer et afficher la somme de deux polynômes
Exo3:
Soit une structure article composée des champs désignation; quantité; prix et Montant.
1. Écrire une fonction qui permet de saisir une liste d'articles
2. Écrire une fonction qui permet d'afficher la facture correspondante aux articles saisis;
3. Écrire une fonction qui permet de calculer et afficher le montant total hors taxe; le montant
TVA (18%) du montant hors taxe et le montant TTC.
Chapitre 6 Les listes chainées
1. Déclaration
C C++ Pascal
#include <stdio.h> # include <iostream> program listec;
#include <stdlib.h> using namespace std; uses crt;
typedef struct liste liste; struct liste type ptr=^liste;

struct liste{ { liste=record
int elm; int info; info: integer;
struct liste* svt; liste * svt; svt :ptr;
}; }; end;
typedef liste *chaine; liste *T, *P; var T, P, Q,F: ptr;

int e;char ter;
2. La pile
C C++ Pascal
chaine saisie(liste * t) void saisie(liste * & T) procedure saisie(var T:ptr );
{ { var ter: char; a:integer;
ter='n'; char ter='n'; begin
liste *p; while(ter=='n') ter:='n';
while (ter=='n') { while ter='n' do
{ cout<<"Donnez la valeur:"; begin
printf("Donnez P= new liste; new(P);
l'element: "); cin>>P->info; write('Donnez la valeur:');
scanf("%d",&e); P->svt=T; readln(a);
p=malloc(sizeof(liste)); T=P; p^.info:=a; ;
p->elm=e; cout<<"Ternier"; p^.svt:=T;
p->svt=t; cin>>ter; T:=P;
t=p; } write('Terminer?');
printf("Terminer? "); } read(ter);
scanf("%c",&ter); end;
scanf("%c",&ter);
} end;
return t;
}
3. La file
C++ Pascal
chaine file(liste * t) void file(liste* &T) procedure laFile(var t:ptr);
{ { var ter: char; a:integer;
ter='n'; liste* Q; begin
liste *p,*q; char ter='n'; ter:='n';
while (ter=='n') while(ter=='n') while ter='n' do
{ { begin

printf("Donnez cout<<"Donnez ka valeur:"; new(P);
l'element: "); P= new liste; write('Donnez la valeur:');
scanf("%d",&e); cin>>P->info; readln(a);
p=malloc(sizeof(liste)); P->svt=NULL; p^.info:=a; ;
p->elm=e; if (T==NULL) p^.svt:=nil;
p->svt=0; { if(T=nil) then
if(t==0) T=P; begin
{ Q=T; T:=P;
t=p; } Q:=T;
q=t; else end
} { else
else Q->svt=P; begin
{ Q=P; q^.svt:=P;
} q:=p;
q->svt=p; end ;
q=p; cout<<"Ternier";
} cin>>ter; write('Terminer?');
} read(ter);
printf("Terminer? "); } end;
scanf("%c",&ter); end;
scanf("%c",&ter);
}
return t;
}
4. Affichage
C C++ Pascal
void afficher(liste * t) void afficher(liste * T) procedure afficher(t:ptr);
{ { begin
liste *p=t; P=T; p:=t;
while (p!=NULL) while(P!=NULL) while p<>nil do
{ { begin
printf("%d ", p->elm); cout<<P->info<<"\t"; write(p^.info,' ');
p=p->svt; P=P->svt; p:=p^.svt;
} } end;
} cout<<endl; writeln();
} end;
5. Saisie ordonnée
C C++ Pascal
liste* saisieordonner(liste* &t) procedure saisieordonner(var
{ liste *s,*r; t:ptr);
ter='n'; var s,r:ptr; ter: char;
t=NULL; begin
while (ter=='n') ter:='n';
{ t:=niL;
cout<<"Donnez l'element: "; while ter='n' do

p=new(liste); begin
cin>>p->info; write('Donnez l''element:');
p->svt=NULL; new(p);
if(t==NULL) readln(p^.info);
t=p; p^.svt:=NiL;
else if t=nil then
if (p->info<t->info) t:=p
{ p->svt=t; else
t=p; if (p^.info<t^.info)then
} begin
else p^.svt:=t;
{ t:=p;
r=t; end
while(r->info<=p->info && r- else
>svt!=NULL) begin
{ s=r; r:=t;
r=r->svt; while(r^.info <= p^.info) and
} (r^.svt<>nil) do
if(r->info>p->info) begin
{ p->svt=r; s:=r;
s->svt=p; r:=r^.svt;
} end;
else if r^.info>p^.info then
r->svt=p; begin
} p^.svt:=r;
cout<<"Terminer? "; s^.svt:=p;
cin>>ter; end
} else
return t; r^.svt:=p;
} end;
write('Terminer?');
readln(ter);
end;
end
6. Programme Principal
C C++ Pascal
int main() int main() begin
{ T:=nil;
chaine t=k=0; { F:=nil;
t=file(t) ; T=NULL; {saisie(T);}
afficher(t); saisie(T); saisieordonner(T) ;
k=saisie(k); file(T); lafile(F);
affcoher(k); afficher (T); afficher(T);
return 1; return 0; afficher(F);
} } readln;
readln;
end.

Support Algo Et Prog C C++Pascal

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Support Algo Et Prog C C++Pascal

Transféré par

Droits d'auteur :

Formats disponibles

Cours d'algorithme et programmation réalisé par MATY Maman

Table des matières

Chap. 1 Structure d'un Algorithme(Programme) .................................................................................3

Edition Avril 2022 : Page -1-

Edition Avril 2022 : Page -2-

Objectif: Apprendre les concepts de base de l'algorithmique et de la programmation. Être capable

Pour fonctionner, un algorithme doit donc contenir uniquement des instructions

Algo C++ C Pascal

Dans un programme informatique, on va avoir en permanence besoin de stocker provisoirement

Déclaration des variables

Edition Avril 2022 : Page -3-

Algo C C++ Pascal

Algo C++ et C Pascal Signification

Edition Avril 2022 : Page -4-

Type Nom Format

Les instructions de lecture et d'écriture permettent à la machine de communiquer avec l'utilisateur

Edition Avril 2022 : Page -5-

Écrire un programme qui:

1. Calcule et affiche la somme de trois entiers

2. Calcule et affiche le reste de la division entre deux entiers

3. Calcule et affiche le produit de trois entiers

4. Calcule et affiche la somme, le produit et la moyenne de trois entiers

Edition Avril 2022 : Page -6-

1. Structure d’un test SI

Nous avons trois formes possibles .

Algo C++/C Pascal

Algo C++/C Pascal

Algo C++ Pascal

Edition Avril 2022 : Page -7-

Algo C++ Pascal

Edition Avril 2022 : Page -8-

Algo C++/C Pascal

La syntaxe d’une boucle Tant que est la suivante.

Edition Avril 2022 : Page -9-

Edition Avril 2022 : Page -10-

Algo C++/C Pascal

Algo C++ Pascal

TD1 Structures de contrôle

Edition Avril 2022 : Page -11-

Edition Avril 2022 : Page -12-

Certains problèmes conduisent à des programmes longs, difficiles à écrire et à

 permettent de "factoriser" les programmes, ce t à dire de mettre en

Le rôle d'une fonction en programmation est similaire à celui d'une fonction en

Fonction nom_fonction (paramètres et leurs types) : type_retour

Instructions constituant le corps de la fonction

function nomfonction( variables :type):type retour;

Edition Avril 2022 : Page -13-

type_fonction est le type du résultat retourné

L'instruction retourne sert à retourner la valeur du résultat

La fonction SommeCarre suivante calcule la somme des carrées de deux réels x et y :

Fonction SommeCarre (x : réel, y: réel ) : réel int sommecarre(int x, int y)

Edition Avril 2022 : Page -14-

variables z : réel, b : booléen

écrire("SommeCarre(3,5)= ", SommeCarre(3,5))

Une procédure s'écrit en dehors du programme principal sous la forme :

Procédure nom_procédure (paramètres et leurs types)

Remarque : une procédure peut ne pas avoir de paramètres

Procédure exemple (…)

Edition Avril 2022 : Page -15-

Remarque : contrairement à l'appel d'une fonction, on ne peut pas affecter la procédure

Le nombre de paramètres effectifs doit être égal au nombre de paramètres formels.

Transmission des paramètres

Il existe deux modes de transmission de paramètres dans les langages de

typedef liste chaine; liste T, *P; var T, P, Q,F: ptr;