Examen module informatique iii i133 mip s3 2021 2022 traite

Examen module informatique iii i133 mip s3 2021 2022 traite

Télécharger PDF

Programmation C : Exercices sur les Nombres Rationnels et les Listes Chaînées

Module Informatique III I133

Cette section présente des exercices de programmation en C portant sur la manipulation de nombres rationnels et l'utilisation de listes simplement chaînées.

Exercice 1 : Gestion des Nombres Rationnels avec une Liste Chaînée (8 pts)

L'objectif de cet exercice est de créer un programme en langage C pour traiter les nombres rationnels. Il vous est demandé de réaliser les fonctions suivantes :

1. Écrire une fonction qui crée une liste simplement chaînée de nombres rationnels.
2. Écrire une fonction qui retourne la somme de tous les nombres rationnels de la liste.
3. Écrire une fonction qui retourne la multiplication de tous les nombres rationnels de la liste.
4. Développer le programme principal qui présente un menu permettant de choisir les opérations à effectuer.

Programmation C : Gestion d'Étudiants avec Listes Doublement Chaînées

Cette partie propose des exercices de programmation en C axés sur la gestion des données d'étudiants en utilisant des listes doublement chaînées.

Exercice 2 : Gestion des Étudiants et Listes Doublement Chaînées (12 pts)

L'objectif est de créer un programme C utilisant les déclarations de structures suivantes :

typedef struct {
    int code; // Un numéro identifiant l'étudiant
    char Nom[15]; // Nom de l'étudiant
    char prenom[30]; // Prénom de l'étudiant
    char sexe; // 'm' pour masculin ou 'f' pour féminin
    float MoyETD; // Moyenne de l'étudiant
    } ETD;

typedef struct element {
    ETD E;
    struct element *suiv; // Pointeur vers l'élément suivant
    struct element *prec; // Pointeur vers l'élément précédent
    } LDC;

Les fonctions à rédiger sont les suivantes :

1. ETD Lire_ETD() : Fonction pour lire les informations d'un étudiant.
2. LDC Creer() : Fonction pour créer une nouvelle liste doublement chaînée vide.
3. LDC* inserer_debut(LDC *L, ETD ne) : Fonction pour insérer un nouvel étudiant au début de la liste.
4. LDC* inserer_fin(LDC *L, ETD ne) : Fonction pour insérer un nouvel étudiant à la fin de la liste.
5. void Afficher(LDC *L) : Fonction pour afficher le contenu de la liste.
6. LDC* Tri_liste(LDC *L) : Cette fonction retourne une liste classée par ordre croissant de la moyenne des étudiants.
7. void Diviser(LDC *L, LDC *L1, LDC *L2) : Fonction pour créer deux listes à partir de la liste initiale L. La liste L1 contiendra les étudiants avec une moyenne supérieure ou égale à 10, et la liste L2 ceux avec une moyenne inférieure à 10.
8. Écrire le programme principal en présentant un menu de choix pour les opérations.

Bonne chance !

Fonctions C de Traitement de Chaînes et Récursion : Exercices Avancés

Cette section aborde des questions sur la manipulation de chaînes de caractères en C et l'implémentation de fonctions récursives, notamment la fonction d'Ackermann.

Exercice 1 : Manipulation de Chaînes et Fonction d'Ackermann (5 pts)

1. Citer 5 fonctions de manipulation des chaînes de caractères de la bibliothèque string.h.

   Exemples possibles : strlen (calculer la longueur), strcpy (copier une chaîne), strcat (concaténer des chaînes), strcmp (comparer des chaînes), strstr (rechercher une sous-chaîne).

2. Que fait la fonction strncpy(s2, s3, 5) ?

   Cette fonction copie au maximum 5 caractères de la chaîne source s3 vers la chaîne de destination s2. Il est important de noter que si s3 contient moins de 5 caractères, strncpy complétera s2 avec des caractères nuls jusqu'à 5 caractères. Si s3 est plus longue, s2 ne sera pas nécessairement terminée par un caractère nul si la taille de s2 est exactement 5, ce qui peut entraîner des problèmes si s2 est ensuite traitée comme une chaîne standard.

3. La fonction d'Ackermann A(m, n) est définie pour m, n ≥ 0 par les conditions suivantes :
   • A(0, n) = n + 1
   • A(m, 0) = A(m - 1, 1) pour m > 0
   • A(m, n) = A(m - 1, A(m, n - 1)) pour m, n > 0

   Écrire une fonction récursive qui calcule la fonction d'Ackermann. Dérouler le calcul de A(1, 2).

   Déroulement du calcul de A(1, 2) :

   • A(1, 2) = A(1 - 1, A(1, 2 - 1)) (selon la 3ème règle)
   • A(1, 2) = A(0, A(1, 1))
   • Calculons A(1, 1) :
     • A(1, 1) = A(1 - 1, A(1, 1 - 1)) (selon la 3ème règle)
     • A(1, 1) = A(0, A(1, 0))
     • Calculons A(1, 0) :
       • A(1, 0) = A(1 - 1, 1) (selon la 2ème règle)
       • A(1, 0) = A(0, 1)
       • A(0, 1) = 1 + 1 = 2 (selon la 1ère règle)
     • Donc, A(1, 1) = A(0, 2)
     • A(0, 2) = 2 + 1 = 3 (selon la 1ère règle)
   • Donc, A(1, 2) = A(0, 3)
   • A(0, 3) = 3 + 1 = 4 (selon la 1ère règle)

   Ainsi, A(1, 2) = 4.

Gestion de Magasin en C : Structures, Catalogue et Facturation

Cet ensemble d'exercices porte sur la conception d'un programme en C pour la gestion d'un magasin d'électroménager, incluant la gestion des produits, des commandes et la génération de factures.

Exercice 2 : Système de Gestion de Magasin (15 pts)

On souhaite écrire un programme qui permet de gérer un magasin vendant des produits électroménagers. Ce programme permet, entre autres, de saisir les produits, de créer des commandes et d'établir des factures. Un produit est défini par :

• référence : la référence unique du produit (par exemple, 12985) ;
• désignation : le nom ou la description du produit (par exemple, Micro-onde) ;
• prix unitaire : le prix unitaire du produit (par exemple, 9850 DH).

1. Définir la structure Produit en C.
2. Un catalogue contient le nombre de produits et l'ensemble des produits existants dans le magasin. Proposer une structure pour le type Catalogue.
3. Écrire les deux fonctions : void saisir_Produit(Produit *p) pour saisir les informations d'un seul produit, et void saisir_Catalogue(Catalogue *c) pour remplir le catalogue avec plusieurs produits.
4. Écrire une fonction int chercher_reference(int r, Catalogue c) qui prend en entrée une référence de produit et un catalogue, et qui retourne l'indice du produit correspondant dans le catalogue. Si le produit n'existe pas dans le catalogue, la fonction renvoie -1.
5. Une commande contient plusieurs lignes de commande. Chaque ligne de commande contient une référence d'un produit ainsi que sa quantité. Une commande ne doit pas contenir plus de 20 lignes. Définir les structures LigneCommande et Commande.
6. Écrire une fonction saisir_Commande(Commande *c, Catalogue cat) qui prend en entrée une commande et un catalogue, et qui demande à l'utilisateur de saisir les références des produits ainsi que leurs quantités.

   Remarques :

   • La fonction ne doit accepter que les références des produits existants dans le catalogue.
   • La fonction ne doit accepter que des quantités strictement supérieures à 0.
7. Écrire une fonction void afficher_Facture(Commande c, Catalogue cat) qui prend en entrée une commande et un catalogue, et affiche la facture à l'écran. Pour chaque référence de produit commandé, la fonction affiche sa référence, sa désignation, son prix unitaire, sa quantité dans la commande et le prix total de la ligne. À la fin de la facture, la fonction affiche le montant total à payer. L'affichage de cette fonction doit ressembler à celui montré ci-dessous :

Facture
    -------------------------------------------------------------------
    Référence   Désignation   Prix Unitaire   Quantité   Prix Ligne
    -------------------------------------------------------------------
    45665       Téléviseur    66500 DH        3          199500 DH
    12985       Micro-onde    9850 DH         2          19700 DH
    87653       Réfrigérateur 86000 DH        1          86000 DH
    86509       Cafetière     6500 DH         4          26000 DH
    -------------------------------------------------------------------
    Montant Total = 331200 DH

8. Écrire une fonction main qui permet de saisir un catalogue, de créer une commande, puis d'afficher sa facture.

Foire Aux Questions (FAQ) sur la Programmation C

Qu'est-ce qu'une liste chaînée en C et pourquoi l'utiliser ?

Une liste chaînée est une structure de données linéaire où les éléments ne sont pas stockés à des emplacements mémoire contigus. Chaque élément (ou "nœud") est constitué de données et d'un pointeur vers le prochain nœud de la séquence (et potentiellement un pointeur vers le nœud précédent pour les listes doublement chaînées). Elle est utilisée pour une allocation dynamique de mémoire, permettant une insertion et suppression efficaces d'éléments sans avoir à redimensionner un tableau, contrairement aux tableaux qui ont une taille fixe ou nécessitent une réallocation coûteuse.

Quelle est l'utilité des structures (struct) en C ?

Les structures en C permettent de regrouper plusieurs variables de types différents sous un même nom. Cela est particulièrement utile pour créer des types de données complexes qui représentent des entités du monde réel, comme un "étudiant" avec son code, son nom, son prénom, son sexe et sa moyenne, ou un "produit" avec sa référence, sa désignation et son prix unitaire. Elles facilitent l'organisation et la manipulation des données associées, améliorant la lisibilité et la modularité du code.

Quand faut-il utiliser la récursion dans un programme C ?

La récursion est une technique de programmation où une fonction s'appelle elle-même pour résoudre un problème. Elle est souvent utilisée pour résoudre des problèmes qui peuvent être décomposés en sous-problèmes similaires plus petits. Elle est particulièrement adaptée aux problèmes naturellement définis de manière récursive, comme le calcul de la fonction d'Ackermann, le parcours d'arbres ou de graphes, ou le calcul de factorielles. Cependant, une utilisation excessive ou incorrecte de la récursion peut entraîner une consommation excessive de mémoire (due à l'empilement des appels de fonction) ou des performances moindres par rapport à une approche itérative si le problème peut être résolu simplement sans récursion.