Série de révision

Exercice 1: Algorithmique
1. 1. Ecrire un algorithme permettant de supprimer un élément dans un tableau.
Algorithme suppression
Var
T : tableau [1..100] de réels ;
N ,P,i: entiers ;
Rep : caractère ;
Debut
Si N=0 alors
Ecrire(‘le tableau est vide ‘) ;
Sinon
Ecrire(‘entrer l’indice de l’’élément à supprimer :’) ;
Lire(P) ;
Si (P<1) ou (P>N) alors
Ecrire(‘Position hors limites du tableau ‘)
Sinon
Ecrire(‘la valeur dans cette position est :‘,T[P]) ;
Ecrire(‘Confirmer la suppression (O/N) ‘) ;
Lire(Rep) ;
Si Rep=’O’ Alors
N <-- N+1 ;
Pour i <-- P à N-1 Faire
T[i] <-- T[i+1] ;
Fin pour
N <-- N-1; (*il y aura un élément en moins*)
Finsi
Finsi
Finsi
Fin

1. 2. Ecrire un algorithme permettant d’insérer un élément dans un tableau (au début , au

milieu ou à la fin).
Algorithme insertion
Var
T : tableau [1..100] de réels ;
N ,P,i: entiers ;
X : réel ;
Rep : caractère ;
Debut
Si N=0 alors
 Ecrire(‘le tableau est vide ‘) ;
Sinon
Ecrire(‘entrer la valeur de l’’élément à insérer :’) ;
Lire(X) ;
Ecrire(‘ Entrer la position d’insertion :’) ;
Lire(P) ;
Si (P<1) ou (P>N) alors
Ecrire(‘Position hors limites du tableau ‘)
Sinon
Ecrire(‘Confirmer l’insertion (O/N) ‘) ;
Lire(Rep) ;
Si Rep=’O’ Alors
N <-- N+1 ;
Pour i <-- N à P+1 Faire
T[i] <-- T[i-1] ;
Finpour i
T[P]<-- X ;
Finsi
Finsi
Finsi
Fin

Exercice 2 : Fonction récursive

Ecrire un programme C qui définit une fonction récursive qui calcule la somme des entiers entre
zéro et un nombre passé en paramètre.
Correction
Une fonction récursive est caractérisée par le fait qu'elle fait appel à elle même un certain
nombre de fois jusqu'à la réalisation d'une condition de sortie. Dans cet exercice il est
demandé de définir une fonction récursive qui permet de calculer la somme des entiers entre
zéro et un autre entier passé en paramètre. Pour faire ceci on doit établir dans un premier
temps une formule récursive puis une condition de sortie de la fonction.
• En appelant Somme la fonction à définir, on peut remarquer alors que pour un entier
donné n on a Somme(n), qui représente la somme des entiers de 0 jusqu'à n, est égale
à n+Somme(n-1), et que Somme(n-1)= n-1 + Somme(n-2) et ainsi de suite jusqu'à arriver
à Somme(1)=1+Somme(0).
• En faisant cette remarque on peut donc calculer Somme(n) en commençant
par Somme(0) pour calculer Somme(1) puis Somme(2) jusqu'à arriver à
calculer Somme(n) en suivant l'inverse du schéma de descente décrit auparavant (le fait de
commencer par Somme(0) est déterminé par la condition de sortie).
• Une fonction récursive prend en charge la réalisation de ce type de calcul en lui indiquant
seulement la formule de récursion à suivre dans la descente en fonction du paramètre n, et
qui est ici Somme(n)=n+Somme(n-1) (ligne 6) et la condition de sortie qui va déclencher le
calcul suivant le schéma inverse qui est ici: Somme(0) est égal à 0 (ligne 5).
Exercice 3 : Tableau +Pointeur

Dans cet exercice, vous allez saisir les notes de n étudiants (n doit être supérieur à 3).
Le nombre de notes (int) est variable d'un étudiant à un autre.
Soient les tableaux dynamiques suivants (voir schéma):
• Le 1 er tableau contient le nombre de notes de chaque étudiant.
• Le 2 ème tableau contient les notes de chaque étudiant.

Ecrire le programme qui:

1. Crée les tableaux dynamiques
2. Remplit les tableaux
3. Affiche les tableaux
4. Pour chaque étudiant: afficher sa meilleure et sa mauvaise note, ainsi que sa moyenne.

Exercice 4: Tableau + Fonction

Ecrire un programme C qui définit quatre fonctions pour effectuer les tâches suivantes:
•Réservation de l'espace mémoire pour un tableau d'entiers dynamique à deux dimensions;
•Lecture du tableau;
•Affichage du tableau;
•Libération de l'espace mémoire réservé.
Correction
• On va désigner par Reserver la fonction qui va allouer l'espace mémoire à un tableau
d'entiers dynamique à deux dimensions. Cette fonction aura deux arguments
entiers n et m qui représenteront respectivement le nombre de lignes et celui de colonnes du
tableau à créer. La fonction Reserver aura comme type de retour int ** (un pointeur sur un
pointeur). Qui est le type du pointeur qui permettra l'accès au tableau.
• La création du tableau commencera par la déclaration d'un pointeur p, qui va recevoir
l'adresse du premier élément d'un tableau de n pointeurs créé par la fonction malloc (ligne
7). Chacun de ces pointeurs lui sera ensuite affecté l'adresse du premier élément de la ligne
correspondante. Pour faire ceci on doit parcourir à l'aide d'une boucle for, de compteur i, le
tableau de pointeurs p. Et à chaque itération on va créer un tableau de m entiers
avec malloc et affecter le pointeur renvoyé par celle-ci à la variable p[i] (lignes 8-9). p sera
ensuite renvoyé par la fonction Reserver à l'aide d'un return.
• A l'intérieur de la fonction principale main on va lire le nombre de lignes et de colonnes. Et
on va les transmettre à la fonction Reserver puis intercepter le pointeur renvoyé dans le
pointeur t déclaré de type int ** (ligne 49). La lecture et l'affichage du tableau t se feront via
les deux fonctions Lire (lignes 12-19) et Afficher (lignes 20-30). Elles qui prennent trois
paramètres: le tableau à lire ou à afficher et sa taille représentés par le nombre de lignes et
de colonnes.
• Pour libérer l'espace réservé par la fonction malloc, on va transmettre à la
fonction Liberer (lignes 31-36) le tableau et le nombre de ces lignes. Et en utilisant la
fonction free elle va dans un premier temps libérer l'espace occupé par chaque ligne puis
celui occupé par les pointeurs qui contiennent les adresses des lignes.
N.B.: l'indication des prototypes des quatre fonctions est optionnelle, car leurs définitions
apparaissent avant la fonction main (lignes 41-44).

Exercice 5 : Structure+Tableau
Ecrire un programme C, qui lit le nom, le prénom et l'âge de plusieurs personne dans un tableau de
structures, puis insère une nouvelle personne dans une position entrée par l'utilisateur.
Correction
• Dans cet exercice, on va apprendre à insérer un élément de structure dans un tableau, en
utilisant comme support une structure nommée Personne, qui se compose de trois entités:
deux chaines de caractères pour le nom et le prénom d’une personne, et un entier pour
représenter son âge.
• Tout d'abords, on demande puis on lit le nombre de personnes qui seront entrées par
l'utilisateur (lignes 13-14). Et on remplit ensuite le tableau t, dont les éléments sont de
type struct Personne, à l'aide d'une boucle for, en lisant à chaque itération le nom, le prénom
et l'âge d'une personne (lignes 15-23). Et on affiche le tableau avant de passer aux tâches qui
suivent (lignes 25-26).
• Pour pouvoir insérer une nouvelle personne dans le tableau, on doit décaler tous ses
éléments qui se trouvent à droite de la position où on souhaite insérer le nouvel élément
 d’une case vers la droite (cette dernière elle aussi incluse). Mais avant, on demande à
l’utilisateur l’indice k de cette position, et on incrémente ensuite la taille n du tableau t par 1.
• Après, on décale les éléments du tableau t, en commençant par la dernière case jusqu'à
arriver à la case k. Et ceci en utilisant une boucle for (lignes 31-36). A titre de rappel
l'opération d'affectation entre les variables structure ou même entre les chaines de caractères
n’est pas valide, donc pour décaler les cases du tableau on va les déplacer élément par
élément. C'est à dire que le nom, le prénom et l'âge dans chaque case seront déplacés
séparément (lignes 33-35). Et pour le nom et le prénom qui sont des chaines de caractères,
on utilisera la fonction strcpy définie dans la bibliothèque standard string.h (lignes 33-34).
• Après avoir translaté les éléments du tableau, on demandera de saisir les informations de la
nouvelle personne, qu’on va lire dans les variables t[k].nom, t[k].prenom et t[k].age (lignes
38-43). Pour terminer le programme, on réaffiche le tableau pour noter les modifications
apportées.