Enoncé exercice 6

Ecrire un programme C, qui définit et utilise une fonction Inserer, qui insère un entier dans un tableau. L’entier à insérer et la position d’insertion sont lus par cette fonction même.

Correction exercice 6

Dans cet exercice il est demandé d’insérer un nouvel élément dans un tableau d’entiers à l’aide d’une fonction. Elle doit en plus lire cet élément et la position où on souhaite l’insérer. Cette fonction qu’on va appeler Inserer aura comme premier paramètre un tableau d’entiers représenté par son nom qui est un pointeur sur un entier. Puis un deuxième paramètre pour la taille, et pour lequel on va opter pour la transmission par adresse puisque le nombre d’éléments du tableau va augmenter après l’opération d’insertion et on veut que ce changement subsiste à l’extérieur de la fonction (ligne 3).

A l’intérieur du bloc de définition de la fonction Inserer, on va demander à l’utilisateur d’entrer l’entier à insérer puis la position d’insertion et qu’on va lire respectivement dans les deux variables a et j (lignes 6-9). Ensuite on incrémente la taille du tableau qui est *n par 1 (ligne 10). Le *n ne doit pas être confondu avec n qui représente à l’intérieur de la définition de la fonction Inserer l’adresse du nombre d’éléments du tableau ou tout simplement un pointeur sur la variable contenant cette quantité.

Avant de pouvoir insérer a dans la position j, on décale les élément du tableau t qui se trouvent entre les deux indices *n-2 et j, y compris les deux bornes, d’un pas vers les indices supérieurs et en commençant obligatoirement par la case *n-2 (lignes 11-12). Après ceci, on place le nouvel élément dans sa position j (ligne 13).

Pour exploiter la fonction définie précédemment, on lit dans la fonction main un tableau t de taille n. Et on appelle ensuite cette fonction en lui passant les deux paramètres t et &n (ligne 32). On a aussi affiché le tableau avant et après l’appel de la fonction Inserer à l’aide de la fonction simple Afficher pour visualiser le changement (lignes 15-20).

Solution exercice 6

#include<stdio.h>
#include<stdlib.h>
void Inserer(int *t,int *n)
{
    int i,j,a;
    printf("Entrez l'entier a inserer:\n");
    scanf("%d",&a);
    printf("Entrez la position d'insertion:\n");
    scanf("%d",&j);
    (*n)++;
    for(i=*n-1;i>j;i--)
       t[i]=t[i-1];
    t[j]=a;
}
void Afficher(int *t,int n)
{
    int i;
    for(i=0;i<n;i++) printf("%d ",t[i]);
    printf("\n");
}
int main()
{
    int t[100];
    int i,n;
    printf("Donnez le nombre des elements du tableau:\n");
    scanf("%d",&n);
    printf("Entrez les elements du tableau:\n");
    for(i=0;i<n;i++)
       scanf("%d",&t[i]);
    printf("Le tableau avant l'insertion:\n");
    Afficher(t,n);
    Inserer(t,&n);
    printf("Le tableau apres l'insertion:\n");
    Afficher(t,n);
    system("pause");
    return 0;
}

Enoncé exercice 7

Ecrire un programme C qui définit et utilise une fonction de prototype char _* Reserver(int) qui réserve l’espace mémoire, d’une manière dynamique, à une chaîne de caractères.

Correction exercice 7

Dans cet exercice on va définir une fonction Reserver (lignes 4-9), qui permet d’allouer l’espace mémoire à une chaîne de caractères. La seule information à transmettre à cette fonction sera la taille maximale de la chaîne que va entrer l’utilisateur, et qui sera récupérée sous forme d’un paramètre entier n. Et elle va à son tour renvoyer un pointeur p sur le type char (ligne 8). Ce dernier contiendra l’adresse de la première des n cases qui seront créées à l’aide de fonction malloc.

La fonction malloc reçoit comme paramètre le nombre d’octets à réserver au niveau de la mémoire. Qui est dans ce cas égal au produit de la multiplication de n par le nombre d’octets sur lequel est représentée une variable de type char. Ce nombre est donnée par l’expression sizeof(char) (ligne 7).

Dans la fonction principale main, on demandera à l’utilisateur d’entrer une majoration de la taille de la chaîne de caractères qu’il souhaite entrer. Cette taille va être stockée dans une variable entière n, puis utilisée comme paramètre lors de l’appel de la fonction Reserver (ligne 17). L’adresse renvoyée par cette dernière va être interceptée par un pointeur s sur le type char. Ce pointeur peut être ensuite traité exactement comme une chaîne de caractères qu’on va lire avec la fonction gets puis afficher par puts (lignes 18-21).

On peut aussi libérer l’espace qu’on a réservé, à l’aide de la fonction malloc, en utilisant la fonction free réservée à cette effet (ligne 22). Et à titre de rappel, les deux fonctions malloc et free font partie de la bibliothèque stdlib.h.

Solution exercice 7

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char * Reserver(int n)
{
     char *p;
     p=(char *)malloc(n*sizeof(char));
     return p;
}
int main()
{
    char *s;
    int n;
    printf("Entrez une taille maximale pour la chaine: ");
    scanf("%d",&n);
    getchar();
    s=Reserver(n);
    printf("Entrer une chaine de caracteres:\n");
    gets(s);
    printf("La chaine de caracteres entree est: ");
    puts(s);
    free(s);
    system("pause");
    return 0;
}

Enoncé exercice 8

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 exercice 8

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).

Solution exercice 8

#include<stdio.h>
#include<stdlib.h>
int ** Reserver(int n, int m)
{
     int **p;
     int i;
     p=(int **)malloc(n*sizeof(int *));
     for(i=0;i<n;i++)
        p[i]=(int *)malloc(m*sizeof(int));
     return p;
}
void Lire(int **p, int n, int m)
{
     int i,j;
     printf("Entrez les elements du tableau:\n");
     for(i=0;i<n;i++)
        for(j=0;j<m;j++)
           scanf("%d",&p[i][j]);
}
void Afficher(int **p, int n, int m)
{
     int i,j;
     printf("Les elements du tableau:\n");
     for(i=0;i<n;i++)
     {
        for(j=0;j<m;j++)
           printf("%3d ",p[i][j]);
        printf("\n");
     }
}
void Liberer(int **p, int n)
{
     int i;
     for(i=0;i<n;i++) free(p[i]);
     free(p);
}
int main()
{
    int **t;
    int n,m;
    int ** Reserver(int,int);
    void Lire(int **,int,int);
    void Afficher(int **,int,int);
    void Liberer(int **,int);
    printf("Entrez le nombre de lignes: ");
    scanf("%d",&n);
    printf("Entrez le nombre de colonnes: ");
    scanf("%d",&m);
    t=Reserver(n,m);
    Lire(t,n,m);
    Afficher(t,n,m);
    Liberer(t,n);
    system("pause");
    return 0;
}

Enoncé exercice 9

Ecrire un programme C qui définit et utilise une fonction Trier qui trie, dans un ordre croissant, les éléments d’un tableau d’entiers.

Correction exercice 9

Dans cet exercice on doit définir une fonction Trier qui trie dans un ordre croissant les éléments d’un tableau d’entiers (lignes 3-14). Pour pouvoir faire ceci la fonction doit avoir deux paramètres: le premier est le tableau à trier et le deuxième sera la taille de ce dernier. Et puisque cette fonction ne va rien renvoyer, on doit indiquer void à l’emplacement du type de renvoi dans l’entête de la fonction (ligne 3).

A l’intérieur de la fonction on déclarera les variables nécessaires pour effectuer l’opération de tri. Pour trier le tableau on doit utiliser un des algorithmes de tri. On a opté ici pour celui du tri à bulles.

Afin d’exploiter cette fonction on a lu les éléments d’un tableau d’entiers t, qui sera ensuite trié par la fonction Trier puis affiché.

Solution exercice 9

#include<stdio.h>
#include<stdlib.h>
void Trier(int *p, int n)
{
    int i,j,tmp;
    for(i=0;i<n-1;i++)
       for(j=0;j<n-i-1;j++)
          if(p[j]>p[j+1])
          {
              tmp = p[j];
              p[j] = p[j+1];
              p[j+1] = tmp;
          }
}
int main()
{
    int i,n;
    int t[100];
    printf("Donnez le nombre d'elements du tableau: ");
    scanf("%d",&n);
    printf("Entrez les elements du tableau:\n");
    for(i=0;i<n;i++)
        scanf("%d",&t[i]);
    Trier(t,n);
    printf("Le tableau trie:\n");
    for(i=0;i<n;i++)
        printf("%d ",t[i]);
    printf("\n");
    system("pause");
    return 0;
}

Enoncé exercice 10

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 exercice 10

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).

Solution exercice 10

#include<stdio.h>
#include<stdlib.h>
int Somme(int n)
{
    if(n==0) return 0;
    else return n+Somme(n-1);
}
int main()
{
    int n;
    printf("Entrez un entier: ");
    scanf("%d",&n);
    printf("La somme des entiers jusqu'a %d est: %d.\n",n,Somme(n));
    system("pause");
    return 0;
}