.

Exercices de

et d'algorithmique.

Partie 2.

The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++

Table des matières

1 Chaînes de caractères 5
1.1 Achage vertical . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Longueur d'une chaîne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Comparaison de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Copie de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Palindrome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.6 Nombre de e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.7 Sous-mot donné . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.8 Occurences d'une lettre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.9 Cryptage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.10 Suppression des e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Tableaux multidimensionnels 7
2.1 Transposition d'une matrice carrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Initialisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Recherche des points-col d'une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4 Carrés magiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Jeu du mémory (d'après E. Desseree) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6 Autour des carrés k-valides . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Tri de tableaux 11
3.1 Le tri bulle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Le tri sélectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.3 Tri par comptage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Structures 13
4.1 Nombres rationnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2 Gestion des voitures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

5 Fonctions récursives 15
5.1 Puissance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.2 Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.3 Factorielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.4 Fonction d'Ackerman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.5 Achage d'entiers (cf. C. David) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

6 Pointeurs 17
6.1 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

The Bourg Programming Team 3

 Bourg-en-Bresse
Langage C++ Première année

6.3 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.4 Echange de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.5 Passage de paramètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.6 Passage par adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4 The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++

Chapitre 1

Chaînes de caractères
1.1 Achage vertical
Ecrire une procédure appelée verticale qui reçoit en entrée une chaîne de caractères et qui ache les
caractères de cette chaîne à raison d'un caractère par ligne (d'où le nom de verticale). Le marqueur de
n de chaîne n'est pas aché.

Dans les exercices 1.2 à 1.4, nous proposons de réécrire les fonctions de la librairie "cstring" les plus
courantes et les plus signicatives suivantes :

1.2 Longueur d'une chaîne

int strlen(char ch[]);
/* retourne le nombre de caractères de ch, le '\0' n'est pas comptabilisé */

1.3 Comparaison de chaînes

int strcmp(char ch1[], char ch2[]);
/* compare, au sens lexicographique, les deux chaînes */
/* retourne 0 si ch1 et ch2 sont identiques, 1 si ch1 > ch2 et -1 si ch1 < ch2 */

La comparaison au sens lexicographique consiste à comparer les chaînes caractère par caractère en
appliquant l'ordre alphabétique.

1.4 Copie de chaînes

void copich(char ch1[], char ch2[])
/* copie ch2 dans ch1, cette fonction est hors-librairie */
/* if strlen(ch2) > strlen(ch1), ch2 est tronquée */
/* if strlen(ch2) < strlen(ch1), ch1 est complétée par des espaces */

1.5 Palindrome
Un mot est un palindrome s'il est symétrique par rapport à son milieu, par exemple les mots  RADAR
,  LAVAL , etc. Ecrire une fonction booléenne appelée bool palindrome(char mot[]) qui retourne

The Bourg Programming Team 5

 Bourg-en-Bresse
Langage C++ Première année

vrai si la chaîne mot est un palindrome et faux sinon. La casse des caractères est à prendre en compte
("LAVaL" n'est pas un palindrome car 'a' est diérent de 'A').

1.6 Nombre de e
Ecrire un algorithme qui compte le nombre de 'e' (majuscules et minuscules confondues) contenus dans
une chaîne lue au clavier.

1.7 Sous-mot donné

Écrire un algorithme qui ache le nombre de fois où la chaîne "eau" apparaît dans une autre chaîne
lue au clavier. Nous supposons que tout le texte est écrit en lettres minuscules.

1.8 Occurences d'une lettre

Écrire un algorithme qui compte le nombre d'occurrences de chaque lettre dans une chaîne lue au
clavier. La chaîne ne contient que des majuscules. Pour cela, on utilisera un tableau d'entiers ayant
pour indice l'ordre de la lettre dans l'alphabet et contenant le nombre d'apparitions de cette lettre.

1.9 Cryptage
Ecrire un programme qui transforme une chaîne de caractères ainsi : pour chaque lettre,
 si la lettre est une voyelle, la remplace par un _
 si c'est une consonne, la remplace par la lettre située deux lettres plus loin (y est remplacé par
' ', z par a, etc.)
 si c'est un espace, termine la chaîne de caractères

Remarque : l'ordre des lettres est le suivant : <espace> a b c ... z

1.10 Suppression des e

Écrire une fonction qui prend une chaine de caractères en paramètre, et qui supprime tous les e de
cette chaine. Vous n'avez pas le droit d'utiliser une chaine temporaire.

6 The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++

Chapitre 2

Tableaux multidimensionnels
2.1 Transposition d'une matrice carrée
La transposition d'une matrice carrée consiste à intervertir les éléments tab[i][j] et tab[j][i].
Ecrire la procédure void Transpose(float m[10][10]) qui permet la transposition d'une matrice
carrée de taille 10.

2.2 Initialisations
Dans cet exercice on considère un tableau 8 ∗ 8 d'entiers prédaclaré : int tab[8][8]. Vous pourrez
être amenés à utiliser la fonction int abs(int n) de la librairie cmath, et calculant la valeur absolue
d'un entier relatif passé en paramètre.
 initialiser ce tableau comme une matrice identité (càd avec des 1 sur la diagonale principale et
des 0 ailleurs) et l'acher.
 l'initialiser comme une matrice "identité-sym", qui n'a que des 0 et des 1, où les 1 sont portés
par l'autre diagonale.
 l'initialiser comme une matrice 3-identité dont seules les 3 diagonales principales ont des 1.
 l'initialiser avec des 0 et des 1, comme un échiquier
 l'initialiser avec des diagonales de 0, des diagonales de 1, des diagonales de 2, . . . comme dans
le dessin ci-dessous :
0 1 2 3 4 5 6 7
1 0 1 2 3 4 5 6
2 1 0 1 2 3 4 5
3 2 1 0 1 2 3 4
4 3 2 1 0 1 2 3
5 4 3 2 1 0 1 2
6 5 4 3 2 1 0 1
7 6 5 4 3 2 1 0

2.3 Recherche des points-col d'une matrice

Rechercher dans une matrice donnée A (de taille N ∗ M , où N et M sont des constantes) les éléments
qui sont à la fois un maximum sur leur ligne et un minimum sur leur colonne. Ces éléments sont appelés
des points-cols. Acher les positions et les valeurs de tous les points-cols trouvés.

The Bourg Programming Team 7

 Bourg-en-Bresse
Langage C++ Première année

2.4 Carrés magiques

On appelle carré magique 3*3 un tableau carré 3*3 d'entiers, qui vérie :
1. chaque case contient un entier entre 1 et 9
2. aucun entier n'apparaît deux fois
3. la somme de chaque ligne vaut 15
4. la somme de chaque colonne vaut 15
5. la somme de chaque diagonale vaut 15.

On demande tout d'abord d'expliquer pourquoi dans un tel tableau :

 la case du milieu vaut 5
 si l'on xe deux cases de la première ligne alors les autres cases sont déterminées par les
contraintes (même si le carré alors obtenu n'est pas nécessairement magique)
 l'ensemble des carrés ainsi obtenu contient tous les carrés magiques

En déduire un programme qui ache l'ensemble des carrés magiques 3*3. Vérier que ces carrés
magiques sont tous équivalents aux symétries ou rotations près.

2.5 Jeu du mémory (d'après E. Desseree)

Le jeu "mémory" est un jeu de mémoire qui consiste à retrouver les paires d'images identiques dans
une grille d'images retournées. Ici, les images seront représentées par les mots qu'elles signient. La
grille sera un tableau 2 dimensions de mots (qu'on déclarera comme un tableau à 3 dimensions de
caractères).

lion chat chat poule

lion chien vache oie
poule oie canard tigre
vache tigre canard chien

1. Déclarez un tableau de taille T AILLE × T AILLE × 26 destiné à contenir les mots, où T AILLE
sera considéré comme une constante paire pour que le nombre de cases dans la grille soit pair
aussi. La troisième dimension (26) correspond à la longueur maximum d'un mot dans notre
langue.
2. Écrivez une fonction qui initialise un tableau T AILLE × T AILLE × 26 avec la chaîne "***" par
défaut dans chaque case.
3. Écrivez une fonction qui demande à l'utilisateur T AILLE 2 /2 chaînes de caractères qui seront
insérées aléatoirement dans la grille de jeu. Attention de bien vérier que la case sélectionnée est
vide avant d'insérer le mot.
4. Écrivez une fonction "Jouer" qui demande au joueur de choisir 2 cases, ache le contenu de ces
2 cases, et retourne un booléen indiquant si les deux cases ont le même contenu.
5. Simulez une partie jusqu'à ce que toutes les paires aient été trouvées. Le score de la partie est le
nombre d'essais du joueur, calculez-le.

8 The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++

Figure 2.1  Exemple de carré 14-valide

2.6 Autour des carrés k-valides

On considère un tableau de caractères à deux dimensions de taille N × N , où N sera une constante
dénie dans l'entête du programme. Les cases de ce tableau contiennent soit des caractères numériques
(valeurs comprises entre 1 et 9), soit le caractère #.
Etant donné un entier k, on dit qu'un tel tableau est k-valide si pour chaque bloc de chires compris
entre deux marqueurs # (ou bien le bord du tableau), la somme des chires de ce bloc ne dépasse pas k.
On ne considère que les blocs horizontaux et verticaux. Sur l'exemple ci-dessus, le tableau est 14-valide.

1. Construire une fonction booléenne qui prend un tableau de caractères N × N et un entier k en

paramètres, et qui retourne vrai si le tableau est k-valide, f aux sinon. Vous vous contenterez de
ne traiter que les blocs horizontaux.
2. Ecrire une fonction qui détermine la plus petite valeur k telle que le tableau passé en paramètre
soit k-valide.

The Bourg Programming Team 9

 Bourg-en-Bresse
Première année Langage C++

Chapitre 3

Tri de tableaux
On cherche à trier les éléments d'un tableau selon l'ordre croissant. Pour cela, on dispose de plusieurs
méthodes. En voici quelques-unes.

3.1 Le tri bulle

Le tri bulle consiste à comparer chaque élément du tableau avec celui qui suit. Si l'élément i + 1 est
inférieur à l'élément i, on permute ces 2 éléments puis on reprend les comparaisons au début du tableau.
La méthode s'arrête lorsqu'il n'y a plus de permutations possibles.
 Ecrire une procédure void Tri_Bulle(int tab[], int N) qui utilise cette méthode. (info :
tab est le tableau à trier et N sa taille)
 Quelle amélioration pourrait-on apporter à cette méthode pour la rendre plus rapide ? Créer
une procédure void Tri_Bulle2(int tab[], int N) qui tient compte de cette amélioration.

3.2 Le tri sélectif

Le tri sélectif est basé sur la recherche de la valeur minimum du tableau, de sa permutation avec le
premier élément, puis l'application de la même méthode pour le sous-tableau allant de 1 à N − 1.
Ecrire une procédure void Tri_Selectif(int tab[], int N) réalisant un tri sélectif.

Exemple : Soit le tableau suivant :

3 4 1 1 3
Itération 1 : Le minimum entre les cases 0 et 4 = 1, d'où le tableau
1 4 3 1 3
Itération 2 : Le minimum entre les cases 1 et 4 = 1, d'où le tableau
1 1 3 4 3
Itération 3 : Le minimum entre les cases 2 et 4 = 3, d'où le tableau
1 1 3 4 3
Itération 4 : Le minimum entre les cases 3 et 4 = 3, d'où le tableau
1 1 3 3 4

3.3 Tri par comptage

Il s'agit d'un tri indirect portant sur deux tableaux, l'un contenant les entiers à trier, l'autre les indices
des valeurs de ce tableau. On suppose que le tableau A (de taille N ) contient des entiers strictement
positifs à trier dont la valeur est strictement positive et n'excède pas une certaine limite (qui est une

The Bourg Programming Team 11

 Bourg-en-Bresse
Langage C++ Première année

constante), appelée M AX . Pour chaque entier compris donc entre 1 et M AX , on compte le nombre
d'apparitions dans A que l'on stocke dans un tableau B (de taille M AX ). Par exemple, si la valeur
i apparaît k fois dans A, on fait B[i] = k . On parcourt ensuite le tableau B pour restituer un 3ème
tableau C trié.

Exemple : on suppose M AX = 4, soit le tableau A de taille N = 5 :

3 4 1 1 3
tableau B :
2 0 2 1
Ce qui signie qu'il y a :
B[0](= 2) : 2 fois la valeur 1 dans A,
B[1](= 0) : 0 fois la valeur 2 dans A,
B[2](= 2) : 2 fois la valeur 3 dans A,
B[3](= 1) : 1 fois la valeur 4 dans A.

B[i] contient le nombre d'occurrences de la valeur (i + 1) dans A.

Le tableau C résultant est directement construit en parcourant B . Il serait ici :

1 1 3 3 4
Ecrire la procédure void Tri_Comptage(int A[], int C[], int N) de tri par comptage pour un ta-
bleau d'entiers.

PS : le tableau B est interne à la procédure.

12 The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++

Chapitre 4

Structures
4.1 Nombres rationnels
Dans cet exercice, on va chercher à dénir le type rationnel, an de décrire les nombres de la forme
p/q , avec p et q entiers. On n'impose aucune contrainte sur les valeurs p et q , ce qui fait qu'un même
nombre pourra avoir plusieurs écritures.
1. A l'aide d'une structure, dénir le type rationnel composé des champs numerateur et denominateur.
2. Ecrire la fonction void construireRationnel(rationnel& r, int n,int d) qui construit le
rationnel n/d passé en paramètre.
3. Ecrire la fonction void afficheRationnel(rationnel& r) qui ache le rationnel r sous la forme
n/d. Vous noterez que pour éviter les copies de structures, on pourra les passer en référence même
si le paramètre n'est pas modié par la fonction.
4. Ecrire une fonction inverse qui inverse la valeur d'un rationnel passé en paramètre.
5. Ecrire la fonction bool estEgal(rationnel& r1,rationnel& r2) qui retourne VRAI si r1 et r2
sont égaux, et FAUX sinon.
6. Ecrire une fonction bool estIrreductible(rationnel& r) qui indique si r est écrit sous sa
forme irréductible ou non (càd qu'on ne peut pas simplier le rapport n/d).
7. Ecrire un programme principal qui initialise aléatoirement un tableau de 100 rationnels puis les
ache.

4.2 Gestion des voitures

On s'intéresse à la gestion d'un parc de voitures. On dénit une structure pour représenter une voiture,
qui contient les informations suivantes : la marque (tableau de caractères de taille 30 maxi), le modèle
(tableau de caractères de taille 30 maxi), l'année de mise en service (entier), le prix de vente (entier)
et une plaque d'immatriculation. Pour ce dernier champ, on dénira une deuxième structure Plaque
composée d'une chaîne de caractères de taille 10 maxi et d'un numéro de département (entier).
Par ailleurs, un propriétaire est représenté par une troisième structure qui contient son nom et son
adresse (chaines de tailles respectives 50 et 100).
1. Dénir les structures Proprietaire, Plaque et Voiture.
2. Ecrire la fonction void construirePlaque(Plaque &p,char chaine[],int val) qui construit
une plaque d'immatriculation grâce aux valeurs passées en paramètres.
3. Ecrire la fonction void affichePlaque(Plaque& p) qui ache la plaque passée en paramètre.

The Bourg Programming Team 13

 Bourg-en-Bresse
Langage C++ Première année

Pour sauvegarder les diérentes données, il est prévu d'utiliser diérents tableaux. Le tableau T proprio[M AX]
contiendra l'ensemble des propriétaires, et le tableau T voitures[M AX] contiendra l'ensemble des voi-
tures. Ces tableaux sont déclarés (dans l'algorithme principal) avec une taille maximale (M AX ).
Proprietaire Tproprio[MAX];
Voiture Tvoitures[MAX];
An de savoir combien de données sont déjà saisies dans les tableaux, deux variables de type entier
sont utilisées : N proprio et N voitures.
5. Créer une fonction qui ajoute une nouvelle voiture dans le tableau, en demandant à l'utili-
sateur au clavier toutes les infos nécessaires. Le prototype de cette fonction sera de la forme
void ajoutVoiture(Voiture t[], int& N), où t est le taleau de voitures, et N le nombre de
voitures déjà présentes.
An de faire le lien entre un propriétaire et une voiture, on crée la structure suivante :
struct CarteGrise{
Proprietaire *proprio;
Voiture *auto;
};
Un tableau contenant toutes les cartes grises est alors créé (dans l'algorithme principal) comme suit :
CarteGrise Tcg[MAX];
Et un entier N cg est également déclaré indiquant combien de cartes grises sont déjà saisies dans le
tableau.
6. Créer une fonction qui lie dans le tableau T cg , un propriétaire et une voiture. Cette procédure
reçoit en paramètre les 3 tableaux, le nombre de cartes grises déjà rentrées, ainsi que les indices
du propriétaire et de la voiture à ajouter dans le tableau T cg .
7. Ecrire une procédure qui ache le nom de tous les propriétaires ayant une voiture dans un
département donné. La procédure recevra en paramètre le tableau et le nombre de cartes grises,
ainsi que le numéro du département choisi. Si un propriétaire possède plusieurs voiture dans ce
département, il pourra apparaître plusieurs fois dans la liste.
8. On souhaite connaître tous les propriétaires possédant au moins 2 voitures. Ecrire une procédure
qui ache le nom de ces propriétaires (le nom d'un propriétaire ne doit apparaître qu'une seule
fois).

14 The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++

Chapitre 5

Fonctions récursives
Une fonction récursive est une fonction qui contient un ou plusieurs appels à elle-même dans sa déni-
tion.

5.1 Puissance
Ecrivez une fonction int puissance(int n, int p) qui retourne la valeur de np , sans utiliser de
boucle for ni while. Pour cela, une façon de faire est d'utiliser la dénition récurrente de la fonction
puissance, c'est à dire : np = n ∗ np−1 . Faites attention à la condition d'arrêt, c'est à dire que votre
fonction ne doit pas être appelée indéniment.

5.2 Fibonacci
Ecrivez une fonction int fibo(int n) qui retourne le neme terme de la suite de Fibonnacci, sans
utiliser de boucle for ni while. Pour cela, une façon de faire est d'utiliser la dénition récurrente de le
suite de Fibonnacci :
Fn+2 = Fn+1 + Fn
F1 = 1
F0 = 1

Si vous appelez cette fonction pour n = 4, càd vous appelez f ibo(4), combien de fois la fonction est-elle
appelée au total ? Vous pouvez faire un arbre des appels pour vous simplier le calcul.

5.3 Factorielle
Même question que 5.2 pour la fonction factorielle. Pour rappel, n! = n × (n − 1) × . . . × 2.

5.4 Fonction d'Ackerman

La fonction d'Ackerman est dénie de la façon suivante :

A(0, p) = p + 1
A(n, 0) = A(n − 1, 1)
A(n, p) = A(n − 1, A(n, p − 1))

The Bourg Programming Team 15

 Bourg-en-Bresse
Langage C++ Première année

Ecrire une fonction récursive qui calcule cette fonction pour tout n et tout p entiers positifs. Expliquer
pourquoi votre fonction se termine. Que vaut A(1, 1) ? Faites un arbre des appels pour valider votre
réponse. Même question pour A(2, 1) ? Combien de fois la fonction est-elle appelée lors du calcul de
A(2, 1) ? Pensez-vous que votre fonction peut être optimisée ?

5.5 Achage d'entiers (cf. C. David)

 Ecrire une fonction récursive void descente(int n) qui ache les entiers de 1 à n dans l'ordre
décroissant (les espaces ne sont pas obligatoires).
 Ecrire une fonction récursive void montee(int n) qui ache les entiers de 1 à n dans l'ordre
croissant (les espaces ne sont pas obligatoires).
 Ecrire une fonction récursive void rebond(int n) qui donne le même résultat que le bloc
d'instructions
descente(n);
montee(n);
 Même question en inversant cette fois-ci :
montee(n);
descente(n);

16 The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++

Chapitre 6

Pointeurs
6.1 Exercice
int A[]={12, 23, 34, 45, 56, 67, 78, 89, 90};
char *C;
float F;
float* pF;
F=3.2;
pF=&F;
Dans le code ci-dessus, à quels types sont homogènes les valeurs/variables suivantes :
a) pF
b) &F
c) *C
d) A
e) *A
f) &pF
g) *&F

6.2 Exercice
Soit P un pointeur qui pointe sur un tableau A :
int A[]={12, 23, 34, 45, 56, 67, 78, 89, 90};
int *P;
P = A;
Quelles valeurs ou adresses fournissent ces expressions :
a) *P+2
b) *(P+2)
c) P+1
d) A[4]-3
e) A+3
f) A[7]-P
g) P+(*P-10)
h) *(P+*(P+8)-A[7])

The Bourg Programming Team 17

 Bourg-en-Bresse
Langage C++ Première année

6.3 Exercice
int a=1,b=2,c=3;
int *p1,*p2;

On considère les déclarations ci-dessus. Après chacune des instructions qui suit, complétez le tableau
pour dire ce que vaut chacune des cinq variables :
a b c p1 p2
p1=&a
p2=&c
*p1=(*p2)++
p1=p2
p2=&b
*p1-=*p2
++*p2
*p1*=*p2
a=++*p2**p1
p1=&a
*P2=*P1/=*P2

6.4 Echange de variables

Ecrivez une fonction qui échange deux entiers passés en paramètre par référence.
Même question avec un passage par adresse.
Dans votre main, déclarez deux variables entières et échangez-les en appelant les deux fonctions pré-
cédentes.

6.5 Passage de paramètre

On considère les fonctions suivantes déjà codées :
void pgcd(int n,int m,int& res); //calcule pgcd(n,m) et le renvoie via res
void fibonacci(int n, int* tab); //calcule les n premiers terme de la suite
//et les stocke dans un tableau de taille n
void division(int n, int m, int* pq, int* pr);
//calcule n/m et stocke quotient et
//reste via les deux derniers paramètres

Ecrivez un programme principal qui utilise les fonctions ci-dessus pour :

1. Acher à l'écran le pgcd de 126 et 654.
2. Acher le quotient et le reste de la division euclidienne de 800 par 7.
3. Acher les 100 premiers termes de la suite de Fibonacci.

6.6 Passage par adresse

On vous donne une fonction
void tri_croissant(int* tab, int taille)

18 The Bourg Programming Team

 Bourg-en-Bresse
Première année Langage C++
qui trie le tableau tab (dont la taille est passée en paramètre) par ordre croissant.
En utilisant cette fonction, écrivez une autre fonction qui prend en paramètre un tableau (dont la
taille est passée en paramètre) et qui permet de récupérer les trois plus grandes valeurs du tableau,
SANS UTILISER DE PASSAGE PAR REFERENCE ! Appelez cette fonction dans votre main avec
un tableau de taille 100 initialisé avec des entiers aléatoires, et achez ces trois plus grandes valeurs.

The Bourg Programming Team 19