Enoncé exercice 1

Ecrire un programme C qui définit une structure point qui contiendra les deux coordonnées d’un point du plan. Puis lit deux points et affiche la distance entre ces deux derniers.

Correction exercice 1

Pour cet exercice, on aura besoin d’une structure point à deux éléments réels x et y. Et ceux, pour contenir respectivement l’abscisse et l’ordonné d’un point du plan.

La définition de la structure (lignes 4-7) doit ce faire impérativement avant la fonction main et doit être suivie d’un point virgule après l’accolade fermante.

Une fois la structure définie, on peut utiliser le type qu’on a construit struct point pour déclarer les deux variables A et B (ligne 10). Chacune de ces variables contient deux composants x et y auxquels on peut accéder par les deux variables réelles A.x et A.y pour le point A et B.x et B.y pour B.

Pour la lecture de A et B, il n’existe pas de possibilité pour dire à la fonction scanf de lire une structure. Ceci dit, elles doivent être lues composant par composant (lignes 13 et 15).

La variable réelle dist est utilisée pour recevoir la valeur de la distance entre les deux points (ligne 16). Le résultat sera affiché juste après le calcul de cette distance (ligne 17).

Solution exercice 1

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
struct point{
       float x;
       float y;
       };
int main()
{
    struct point A,B;
    float dist;
    printf("Entrez les coordonnees du point A:\n");
    scanf("%f%f",&A.x,&A.y);
    printf("Entrez les coordonnees du point B:\n");
    scanf("%f%f",&B.x,&B.y);
    dist = sqrt( (A.x-B.x)*(A.x-B.x) + (A.y-B.y)*(A.y-B.y) );
    printf("La distance entre les points A et B est: %.2f\n",dist);
    system("pause");
    return 0;
}

Enoncé exercice 2

Ecrire un programme C qui définit une structure etudiant où un étudiant est représenté par son nom, son prénom et une note. Lit ensuite une liste d’étudiants entrée par l’utilisateur et affiche les noms de tous les étudiants ayant une note supérieure ou égale à 10 sur 20.

Correction exercice 2

On définit une structure à trois éléments: deux chaînes de caractères pour le nom et le prénom et un entier pour la note (lignes 4-8). La nouveauté dans cet exercice est qu’on aura besoin d’un tableau de structures car le nombre d’étudiants que va entré l’utilisateur n’est pas connu d’avance. La procédure pour ça sera la même que pour les types simples: on précise le type des éléments du tableau qui est dans notre cas struct etudiant, puis le nom du tableau et sa taille (ligne 11). On lit ensuite le nombre d’étudiants (ligne 14), et on procède à la lecture du tableau avec une boucle for (ligne 15).

Un élément du tableau t[i] est une variable de type struct etudiant qui a trois composants: deux chaînes de caractères t[i].nom et t[i].prenom et un entier t[i].note. A chaque itération de la boucle for on doit lire ces trois variables qui constituent les données d’un étudiant (lignes 17-18).

Après la lecture du tableau t, on le parcourt et on fait un test sur la composante note (ligne 22). Si elle est supérieure ou égale à 10, on affiche les deux autres composantes, à savoir le nom et le prénom (ligne 23).

Solution exercice 2

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct etudiant{
       char nom[20];
       char prenom[20];
       int note;
       };
int main()
{
    struct etudiant t[100];
    int n,i;
    printf("Donner le nombre d'etudiants:\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
       printf("donnez le nom, prenom et la note de l'etudiant %d:\n",i+1);
       scanf("%s%s%d",t[i].nom,t[i].prenom,&t[i].note);
    }
    for(i=0;i<n;i++)
    {
        if(t[i].note>=10)
        printf("%s %s\n",t[i].nom,t[i].prenom);
    }
    system("pause");
    return 0;
}

Enoncé exercice 3

Ecrire un programme C, qui lit les noms complets des étudiants et leurs moyennes dans un tableau de structures. Puis actualise ces moyennes en ajoutant un bonus de:

• 1 point pour les étudiants ayant une note strictement inférieure à 10.
• 0.5 point pour les étudiants ayant une note entre 10 et 15 incluses.

N.B.: la structure doit avoir deux éléments: une chaîne de caractères et un réel.

Correction exercice 3

Cet exercice sur les structures illustre la possibilité de changement de la valeur d’un élément d’une structure. En effet, on va écrire un programme qui ajoute un bonus aux moyennes d’un ensemble d’étudiants.

Pour ce faire, on va définir une structure Etudiant à deux éléments (lignes 3-6): une chaîne de caractères pour le nom et le prénom, et un nombre de type float pour la note. On déclare ensuite un tableau t de cette structure pour contenir ces deux informations pour un groupe d’étudiants (ligne 9).

Pour remplir le tableau on demandera d’entrer le nombre d’étudiants, puis à l’aide d’une boucle for on va lire à chaque itération i les deux variables t[i].nom et t[i].note qui représentent respectivement le nom et la note de l’étudiant i (lignes 13-20). Il est à noter que le nom doit être lu avec la fonction gets et non pas scanf, au cas où il contient des espaces. En plus, il faut veiller à ce que cette fonction soit précédée d’un getchar pour la séparer des scanf (ligne 15); dans la première itération, de celle qui lit le nombre d’étudiants (ligne 12) et dans le reste des itérations de celle qui lit la note (ligne 19) puisqu’elle sera toujours suivie de l’exécution de la fonction gets de l’itération suivante.

Après la lecture des noms et des notes des étudiants, on les affiche un étudiant par ligne (lignes 22-23). On procède ensuite à l’ajout des bonus (lignes 24-28). Pour ceci, on parcourt le tableau de structures t, et on vérifie à l’aide d’un test if si la note de l’étudiant actuel appartient à l’un des deux intervalles concernés par le bonus. S’il en est le cas, on actualise la variables t[i].note par l’ajout du bonus correspondant (lignes 26-27). Il est important de commencer ici par l’ajout des bonus pour les notes supérieures à 10 avant celles qui lui sont inférieures, sinon, une note de 9 par exemple, deviendra 10 après l’ajout d’un bonus de 1 et de cette façon elle sera aussi éligible au bonus de 0.5. Ce qui va résulter dans un bonus total de 1.5.

On réaffiche ensuite le tableau t pour observer les changements apportés (lignes 30-31).

Solution exercice 3

#include<stdio.h>
#include<stdlib.h>
struct Etudiant{
       char nom[20];
       float note;
};
int main()
{
    struct Etudiant t[100];
    int n,i;
    printf("Donnez le nombre d'etudiants:\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        getchar();
        printf("Entrez le nom complet de l'etudiant N%d:\t",i+1);
        gets(t[i].nom);
        printf("Entrez la note de %s:\t",t[i].nom);
        scanf("%f",&t[i].note);
    }
    printf("\nLes notes avant l'ajout du bonus:\n");
    for(i=0;i<n;i++)
        printf("%s : %.2f\n",t[i].nom,t[i].note);
    for(i=0;i<n;i++)
    {
        if(t[i].note >= 10 && t[i].note <= 15) t[i].note+=0.5;
        if(t[i].note < 10) t[i].note+=1;
    }
    printf("\nLes notes apres l'ajout du bonus:\n");
    for(i=0;i<n;i++)
        printf("%s : %.2f\n",t[i].nom,t[i].note);
    system("pause");
    return 0;
}

Enoncé exercice 4

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

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.

Solution exercice 4

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Personne{
       char nom[20];
       char prenom[20];
       int age;
};
int main()
{
    struct Personne t[100];
    int n,i,k;
    printf("Donnez le nombre de personnes a lire:\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        printf("Entrez le nom  de la personne N%d:\t",i+1);
        scanf("%s",t[i].nom);
        printf("Entrez le prenom de cette personne:\t");
        scanf("%s",t[i].prenom);
        printf("Entrez son age:\t");
        scanf("%d",&t[i].age);
    }
    printf("\nLe tabeau avant l'insertion:\n");
    for(i=0;i<n;i++)
        printf("L'age de %s %s est: %d ans.\n",t[i].nom,t[i].prenom,t[i].age);
 
    printf("\Donnez la position d'insertion souhaitee:\n");
    scanf("%d",&k);
    n++;
    for(i=n-1;i>k;i--)
    {
        strcpy(t[i].nom, t[i-1].nom);
        strcpy(t[i].prenom, t[i-1].prenom);
        t[i].age = t[i-1].age;
    }
 
    printf("\nEntrez le nom  de la personne a inserer:\t");
    scanf("%s",t[k].nom);
    printf("Entrez la prenom de cette personne:\t",t[i].nom);
    scanf("%s",t[k].prenom);
    printf("Entrez son age:\t",t[i].nom);
    scanf("%d",&t[k].age);
 
    printf("\nLe tableau apres l'insertion:\n");
    for(i=0;i<n;i++)
        printf("L'age de %s %s est: %d ans.\n",t[i].nom,t[i].prenom,t[i].age);
    system("pause");
    return 0;
}

Enoncé exercice 5

Ecrire un programme C, qui lit un ensemble de villes avec leur nombre d’habitants dans un tableau de structures, les trie et les affiche dans l’ordre croissant des nombres d’habitants.

Correction exercice 5

On va définir pour cet exercice la structure ville qui se compose de deux éléments: une chaîne de caractères pour le nom de la ville et un entier pour le nombre de ses habitants (lignes 4-7). Et on introduira le mot clé typedef qui permet de renommer les types de données, et qui sera utilisé ici pour remplacer le type struct ville par la nomination abrégée: Ville (ligne 8), et dont on va se servir dans les déclarations au lieu de struct ville.

Pour commencer, on va lire le nombre de villes, suivi de l’ensemble des villes chacune avec son nombre d’habitants dans un tableau de structures (lignes 16-22). On affichera juste après ce tableau, avant de passer à son tri.

Le tri adopté pour ce programme et le tri à bulles. La seule différence qui existe avec le tri d’un tableau dont les éléments sont des entiers ou d’un autre type primitif, sera l’opération de permutation. Pour permuter deux cases contigües du tableau, dont celle d’indice inférieur a un nombre d’habitants supérieur à celui de celle qui la suit, on aura à permuter les noms et les nombres d’habitants des deux cases. On peut alors utiliser une chaîne de caractères et un entier comme intermédiaires pour réaliser cette tâche ou plus adéquatement une troisième variable de type Ville.

On va opter pour la dernière option, et on va mettre la case j dans la variable tmp de type Ville. Ceci en copiant la composante nom de t[j] dans celle de tmp à l’aide de la fonction strcpy. Et on affecte la composante nbr de t[j] à celle de tmp (lignes 30-31). Et de la même manière on mettra le contenu de la case j+1 dans la case j, puis celui de tmp dans la case j+1 pour achever la permutation.

Après le tri du tableau, on le réaffiche pour présenter les villes dans l’ordre croissant de leur nombre d’habitants.

Solution exercice 5

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct ville{
       char nom[20];
       int nbr;
};
typedef struct ville Ville;
int main()
{
    Ville t[100];
    Ville tmp;
    int i,j,n;
    printf("Donnez le nombre de villes:\t");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        printf("Donnez le nom de la ville N %d:\t",i+1);
        scanf("%s",t[i].nom);
        printf("Donnez le nombre d'habitants de cette ville:\t");
        scanf("%d",&t[i].nbr);
    }
    for(i=0;i<n;i++)
        printf("-- Le nombre d'habitants de %s est : %d\n",t[i].nom,t[i].nbr);
    for(i=0;i<n-1;i++)
        for(j=0;j<n-i-1;j++)
        {
             if(t[j].nbr>t[j+1].nbr)
             {
                 strcpy(tmp.nom,t[j].nom);
                 tmp.nbr = t[j].nbr;
 
                 strcpy(t[j].nom,t[j+1].nom);
                 t[j].nbr = t[j+1].nbr;
 
                 strcpy(t[j+1].nom,tmp.nom);
                 t[j+1].nbr = tmp.nbr;
             }
        }
    printf("Les villes dans l'ordre croissant du nombre d'habitants:\n");
    for(i=0;i<n;i++)
        printf("-- Le nombre d'habitants de %s est : %d\n",t[i].nom,t[i].nbr);
    system("pause");
    return 0;
}