Enoncé exercice 6

Ecrire un programme C qui vérifie si une chaîne de caractères est palindrome en utilisant deux pointeurs pour son parcours.

Correction exercice 6

Dans cet exercice on va vérifier, en se servant des pointeurs, si une chaîne de caractères s est palindrome ou non. Et à titre de rappel, une chaîne de caractères est dite palindrome si elle se lit de gauche à droite et de droite à gauche de la même façon. Par exemple, tot est palindrome.

Le principe est très simple, on va déclarer deux pointeurs p et q sur des variables de type char (ligne 7). Au départ p doit pointer sur la première case de s (ligne 11) et q sur sa dernière case (ligne 12). En utilisant ensuite une boucle for, on va à chaque fois incrémenter p et décrémenter q et à l’intérieur de la boucle on va comparer les deux caractères *p et *q. S’il sont différents, ceci est suffisant pour dire que s n’est pas palindrome. on le signalera en mettant la variable entière estPalin, initialisée par 1, à 0. Et on arrête dans ce cas la recherche à l’aide de l’instruction break (lignes 15-19).

Pour la condition d’arrêt de la boucle, la boucle doit s’arrêter quand les deux pointeurs se rencontrent au milieu ou lorsque la case pointée par p devient à droite de la case pointée par q (Ces deux cas différents sont dûs au fait que la taille de la chaîne peut être paire ou impaire). Ceci se résume dans la condition p<q (ligne 13).

A l’extérieur de la boucle for on fait un test sur la valeur de la variable estPalin et en fonction de sa valeur on affiche le message correspondant (lignes 21-22).

Solution exercice 6

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
    char s[100];
    char *p,*q;
    int estPalin = 1;
    printf("Entrez une chaine de cacacrteres: ");
    gets(s);
    p=s;
    q=s+strlen(s)-1;
    for(;p<q;p++,q--)
    {
        if(*p != *q)
        {
            estPalin = 0;
            break;
        }
    }
    if(estPalin == 1) printf("La chaine est palidrome.\n");
    else printf("La chaine n'est pas palidrome.\n");
    system("pause");
    return 0;
}

Enoncé exercice 7

Ecrire un programme C qui réserve l’espace mémoire à un tableau d’entiers de taille entrée par l’utilisateur, le lit puis l’affiche.

Correction exercice 7

Parmi les limites des tableaux statiques c’est qu’on doit préciser leur taille lors de la déclaration. Ainsi, si l’utilisateur décide de stocker un nombre d’éléments supérieur à la taille du tableau on aura un dépassement de l’espace mémoire réservé à ce dernier, chose qui peut générer des erreurs. Les pointeurs sont d’une grande utilité dans la création des tableaux dit dynamiques, qui pallie a ce problème en donnant à l’utilisateur la possibilité de définir la taille du tableau lors de l’exécution du programme.

Dans cet exercice, il est demandé de créer un tableau d’entiers dynamique. Pour cet effet on va commencer par la déclaration d’un pointeur t qui va servir comme identifiant pour ce tableau. On va ensuite demander à l’utilisateur la taille n souhaitée pour le tableau. La création de ce tableau revient à réserver n cases d’entiers consécutives au niveau de la mémoire. Cette tâche va être effectuée grâce à une fonction de la bibliothèque stdlib.h appelée malloc. Elle prend un seul paramètre qui représentent le nombre d’octets à réserver. Ce nombre d’octets sera calculé en multipliant n par le nombre d’octets sur lequel est représentée une seul variable de type int. Ce nombre est donné par l’expression sizeof(int). Le résultat renvoyé par la fonction malloc doit être converti vers le type du pointeur t qui est int * avant de l’intercepter par ce dernier (ligne 9).

Après la création du tableau dynamique t, on lit ses éléments puis on les affiche en suivant la démarche habituelle.

Solution exercice 7

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int *t;
    int n,i;
    printf("Entrez la taille du tableau: ");
    scanf("%d",&n);
    t = (int *)malloc(n*sizeof(int));
    printf("Entrez les elements du tableau: ");
    for(i=0;i<n;i++)
        scanf("%d",t+i);
    for(i=0;i<n;i++)
        printf("%d ",t[i]);    
    printf("\n");
    system("pause");
    return 0;
}

Enoncé exercice 8

Ecrire un programme C qui réserve l’espace mémoire à un tableau d’entiers à deux dimensions dont la taille est entrée par l’utilisateur, puis le lit et l’affiche.

Correction exercice 8

Dans cet exercice, il est demandé d’écrire un programme qui réserve l’espace mémoire à un tableau dynamique à deux dimensions. Cette opération se base sur le même principe que celui adopté pour les tableaux à une dimension.

Si on considère qu’un tableau à deux dimension comme un ensemble de tableaux à une dimension qui sont ses lignes alors on peut lui réserver l’espace mémoire tout simplement en le réservant à chaque une des lignes qui le constituent. Pour pouvoir faire ceci on doit créer des pointeurs sur le type des éléments du tableau et dont le nombre doit être égale au nombre de lignes de ce dernier. Et chacun de ces pointeurs va recevoir l’adresse de la première case du tableau à une dimension dont la fonction malloc va allouer l’espace au niveau de la mémoire. Et qui doit avoir une taille égale au nombre de colonnes du tableau 2D qu’on souhaite créer. Les pointeurs qui sont à l’origine de ces lignes seront obtenus en déclarant un tableau de pointeurs.

On va commencer le programme par la déclaration d’un pointeur p qui sera associé au tableau de pointeurs. Ces pointeurs sont de type int * donc le type de p, qui est un pointeur sur un pointeur, sera int ** (ligne 5). Ensuite on passe à la lecture de la taille du tableau dans les deux variables entières n et m.

Pour créer le tableau de pointeurs, on doit indiquer à la fonction malloc le nombre d’octets à réserver qui est le nombre d’octets sur lequel est codée un pointeur d’entiers (donné par sizeof(int *)) multiplié par n le nombre de pointeurs à créer (ligne 9). On peut accéder à ces pointeurs par p[i] où i appartient à l’intervalle [0,n-1]. Une fois ces pointeurs créés, on parcourt p à l’aide d’une boucle for de compteur i et chaque pointeur p[i] va recevoir l’adresse du premier élément du tableau d’entiers de taille m créé par la fonction malloc (ligne 11).

A la fin de ce processus, p sera un tableau à deux dimensions de n lignes et de m colonnes, qu’on peut lire et afficher comme on faisait pour les tableaux statiques.

Solution exercice 8

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int **p;
    int i,j,n,m;
    printf("Donnez le nombre de lignes et de colonnes:\n");
    scanf("%d%d",&n,&m);
    p = (int **) malloc(n*sizeof(int *));
    for(i=0;i<n;i++)
       p[i] = (int *) malloc(m*sizeof(int));
    printf("Entrez les elements du tableau:\n");
    for(i=0;i<n;i++)
       for(j=0;j<m;j++)
          scanf("%d",&p[i][j]);
    printf("Le tableau entre:\n");
    for(i=0;i<n;i++)
    {
       for(j=0;j<m;j++)
          printf("%4d ",p[i][j]);
       printf("\n");
    } 
    system("pause");
    return 0;
}

Enoncé exercice 9

Ecrire un programme C qui réserve l’espace mémoire à un tableau de caractères sous forme d’un triangle droit, le remplit par des étoiles (*) puis l’affiche.

Correction exercice 9

Dans cet exercice on va créer, d’une façon dynamique, un tableau à deux dimensions de forme triangulaire en ne réservant que l’espace mémoire nécessaire. C’est à dire qu’on va allouer une seule case pour la première ligne, et deux pour la deuxième et ainsi de suite. Pour ainsi faire, on va commencer par la déclaration d’un pointeur p de type char ** qui représentera le tableau de pointeurs (de type char *) et qui sera créé à l’aide de la fonction malloc (ligne 9). Ce dernier va contenir les pointeurs vers les premières cases des différentes lignes du tableau triangulaire.

Une fois l’espace pour ce tableau est réservé, on va parcourir ses n (nombre de lignes entré par l’utilisateur) éléments pour leur associer les lignes créées par un autre appel à la fonction malloc (ligne 12). Pour cette dernière on doit préciser à chaque fois le nombre d’octets à réserver, et qui est égal au produit du nombre de cases souhaité pour la ligne et le nombre d’octets sur lequel est représentée une variable de type char qui est donné par sizeof(char). Le nombre de cases à fournir à la fonction malloc sera fonction de l’indice de ligne. Il est égal à i+1 pour la ligne i.

Le remplissage des lignes par des étoiles (*) peut se faire juste après la création de la ligne en la parcourant par une boucle for de compteur j et en accédant aux éléments de celle-ci par la variable p[i][j] (lignes 13-14).

Pour terminer le programme on affiche le tableau p à l’aide de deux boucles for en faisant attention à la limite du compteur j de parcours des lignes qui doit aller seulement de 0 à i (lignes 16-21).

Solution exercice 9

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int n,i,j;
    char **p;
    printf("Donnez le nombre de lignes:\n");
    scanf("%d",&n);
    p = (char **)malloc(n*sizeof(char*));
    for(i=0;i<n;i++)
    {
       p[i] = (char *)malloc( (i+1)*sizeof(char) );
       for(j=0;j<i+1;j++)
          p[i][j] = '*';
    }
    for(i=0;i<n;i++)
    {
       for(j=0;j<i+1;j++)
          printf("%c ",p[i][j]);
       printf("\n");
    }
    system("pause");
    return 0;
}

Enoncé exercice 10

Ecrire un programme C qui lit une phrase et l’affiche à partir du deuxième mot. En s’aidant dans ceci de la fonction strchr et sans utiliser aucune boucle.

N.B. : Si un seul mot est entré, il faudra seulement le réafficher.

Correction exercice 10

On va commencer le programme par la déclaration d’une chaîne de caractères s et d’un pointeur p sur le type char. Puis on demandera à l’utilisateur de saisir une phrase qu’on va lire vers la chaîne s à l’aide de la fonction gets.

Sachant qu’une phrase est constituée de mots séparés par des espaces, on va chercher alors le premier espace y figurant, pour détecter ainsi où commence le deuxième mot de la phrase. Pour retrouver cet espace, on va faire appel à la fonction strchr définie dans la bibliothèque string.h. Cette fonction prend deux paramètres, une chaîne de caractère s et un caractère et renvoie un pointeur sur la première occurrence du caractère. Ce pointeur sera affecté directement au pointeur p (ligne 10).

Le pointeur p, peut être traité en tant qu’une chaîne de caractères qui commence par le premier espace de la chaîne s. Pour tomber sur le début du deuxième mot, et constituer la phrase demandée par l’exercice, il suffira d’incrémenter p par 1. On affiche ensuite la chaîne p en utilisant la fonction puts (lignes 13-14).

Il se peut que la phrase entrée, soit constituée d’un seul mot. Dans ce cas, la fonction strchr aura renvoyé le pointeur NULL puisqu’elle ne trouvera aucun espace sur la chaîne. Pour prendre en considération ce cas particulier, il faudra effectuer un test sur la valeur de p pour la comparer à NULL.

Dans le cas où p est différent de NULL, on exécutera le traitement décrit précédemment. Et dans l’autre cas, on affichera la chaîne comme elle est (lignes 11-17).

Solution exercice 10

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	char s[80];
	char *p;
	printf("Saisir une phrase:\n");
	gets(s);
	p=strchr(s,' ');
	if(p!=NULL)
	{
	   p++;
	   puts(p);
	}
	else
	   puts(s);
	system("pause");
	return 0;
}