TD N°2 - Framework .NET (C#)

Partie 1 : List<T> — Listes dynamiques

Exercice 1 : Déclarations correctes

Indiquez si chaque déclaration est Correcte (C) ou Incorrecte (I). Si incorrecte, expliquez :

Déclaration	C/I	Explication si incorrecte
`List<int> lst = new List<int>();`
`List<int> lst = new List<int> { 1, 2, 3 };`
`List lst = new List();`
`var lst = new List<string>();`
`List<int> lst = { 1, 2, 3 };`
`List<int> lst = new List<double>();`
`List<string> lst = new List<string>(20);`
`List<int> lst = new List<int>[] { 1, 2 };`

Exercice 2 : Méthodes de List<T>

Complétez le tableau en indiquant la méthode ou propriété de List<T> correspondante :

Action souhaitée	Méthode / Propriété
Ajouter un élément à la fin de la liste
Insérer un élément à l'indice 2
Supprimer la première occurrence de la valeur 15
Supprimer l'élément à l'indice 3
Vérifier si la valeur "Ali" existe dans la liste
Obtenir le nombre d'éléments
Trier la liste par ordre croissant
Supprimer tous les éléments négatifs
Vider entièrement la liste
Trouver l'indice de la valeur 20

Exercice 3 : Traçage — List<T>

Déterminez l'état de la liste après chaque instruction :

var lst = new List<int> { 10, 20, 30, 40, 50 };
lst.RemoveAt(1);
lst.Insert(0, 5);
lst.Add(60);
lst.Remove(30);
lst.Reverse();
Console.WriteLine(string.Join(", ", lst));

Instruction	État de la liste
Déclaration initiale
`lst.RemoveAt(1);`
`lst.Insert(0, 5);`
`lst.Add(60);`
`lst.Remove(30);`
`lst.Reverse();`

Sortie : ___________________________________________

Exercice 4 : Gestion d'une liste d'étudiants

Écrivez un programme qui :

Crée une List<string> contenant : "Ali", "Sara", "Omar", "Fatma", "Khaled"
Affiche le nombre d'étudiants
Insère "Imen" à la position 2
Supprime "Omar"
Trie la liste par ordre alphabétique
Affiche la liste triée

Exercice 5 : Filtrage de notes

Écrivez un programme qui à partir d'une List<double> contenant : 14.5, 8.0, 17.25, 9.5, 11.0, 6.75, 19.0, 12.5 :

Calcule et affiche la moyenne générale
Crée une nouvelle List<double> contenant uniquement les notes ≥ 10
Trie cette nouvelle liste en ordre décroissant
Affiche les notes admises triées

Indication : pour trier en ordre décroissant, utilisez Sort() suivi de Reverse().

Exercice 6 : Traçage avancé

Déterminez la sortie du code suivant :

var nums = new List<int> { 3, 7, 2, 9, 4, 1 };
nums.Sort();
nums.RemoveAt(nums.Count - 1);
nums.Insert(1, 10);
int somme = 0;
foreach (int n in nums)
    somme += n;
Console.WriteLine(string.Join(", ", nums));
Console.WriteLine($"Somme = {somme}");

Sortie :

Partie 2 : Dictionary<TKey, TValue> — Dictionnaires

Exercice 7 : Méthodes de Dictionary

Pour chaque action, indiquez la méthode ou syntaxe correcte :

Action souhaitée	Code C#
Ajouter la clé "Ali" avec la valeur 85 (exception si existe)
Ajouter ou mettre à jour la clé "Ali" avec la valeur 90
Vérifier si la clé "Sara" existe
Supprimer la paire dont la clé est "Omar"
Lire la valeur de "Ali" de manière sécurisée
Obtenir le nombre de paires

Exercice 8 : Traçage — Dictionary

Déterminez la sortie du code suivant :

var d = new Dictionary<string, int>();
d.Add("x", 10);
d.Add("y", 20);
d["z"] = 30;
d["x"] = 100;
d.Remove("y");
d["w"] = 40;

Console.WriteLine(d.Count);
Console.WriteLine(d.ContainsKey("y"));
Console.WriteLine(d.ContainsValue(100));
Console.WriteLine(d["x"] + d["z"]);

Instruction	Sortie
`Console.WriteLine(d.Count);`
`Console.WriteLine(d.ContainsKey("y"));`
`Console.WriteLine(d.ContainsValue(100));`
`Console.WriteLine(d["x"] + d["z"]);`

Exercice 9 : Répertoire téléphonique

Écrivez un programme qui gère un répertoire téléphonique en utilisant un Dictionary<string, string> :

Ajoutez 4 contacts (nom → numéro)
Affichez le numéro d'un contact existant
Modifiez le numéro d'un contact
Recherchez un contact inexistant avec TryGetValue
Affichez tous les contacts avec un parcours foreach

Exercice 10 : Compteur de caractères

Écrivez un programme qui prend une chaîne "programmation" et utilise un Dictionary<char, int> pour compter le nombre d'occurrences de chaque caractère. Affichez le résultat.

Indication : parcourez la chaîne caractère par caractère avec foreach.

Exercice 11 : Traçage avancé

Déterminez la sortie du code suivant :

var notes = new Dictionary<string, int>
{
    ["Ali"] = 14, ["Sara"] = 16, ["Omar"] = 9, ["Fatma"] = 18
};

int total = 0;
int admis = 0;
foreach (var p in notes)
{
    total += p.Value;
    if (p.Value >= 10) admis++;
}
Console.WriteLine($"Moyenne = {(double)total / notes.Count}");
Console.WriteLine($"Admis = {admis}/{notes.Count}");

Sortie :

Partie 3 : HashSet<T> — Ensembles de valeurs uniques

Exercice 12 : Vrai ou Faux

Indiquez si chaque affirmation est Vraie (V) ou Fausse (F) :

Affirmation	V/F
Un `HashSet<T>` accepte les doublons
On peut accéder à un élément de HashSet par indice `[0]`
`Add()` retourne `false` si l'élément existe déjà
La méthode `Contains()` a une complexité O(n)
`IntersectWith()` modifie l'ensemble sur lequel il est appelé
L'ordre d'insertion est garanti dans un `HashSet<T>`
`ExceptWith(B)` donne les éléments présents dans A mais pas dans B
On peut convertir un `HashSet<T>` en `List<T>`

Exercice 13 : Traçage — HashSet

Déterminez la sortie du code suivant :

var A = new HashSet<int> { 1, 2, 3, 4, 5 };
var B = new HashSet<int> { 4, 5, 6, 7, 8 };

Console.WriteLine(A.Add(3));
Console.WriteLine(A.Add(6));
Console.WriteLine(A.Count);

var C = new HashSet<int>(A);
C.IntersectWith(B);
Console.WriteLine(string.Join(", ", C));

var D = new HashSet<int>(A);
D.ExceptWith(B);
Console.WriteLine(string.Join(", ", D));

Ligne	Sortie
`A.Add(3)`
`A.Add(6)`
`A.Count`
Intersection C
Différence D

Exercice 14 : Éliminer les doublons

Écrivez un programme qui :

Part d'une List<int> : { 5, 3, 8, 3, 1, 5, 9, 1, 8, 7 }
Utilise un HashSet<int> pour éliminer les doublons
Reconvertit le résultat en une List<int> triée
Affiche la liste sans doublons triée

Exercice 15 : Analyse de deux groupes de modules

Soient deux ensembles de modules :

Semestre 1 : { "C#", "SQL", "Anglais", "Math", "Réseaux" }
Semestre 2 : { "C#", "Java", "SQL", "Gestion", "Réseaux" }

Écrivez un programme qui affiche :

Les modules communs aux deux semestres
Tous les modules étudiés sur l'année (sans doublons)
Les modules uniquement au semestre 1
Les modules uniquement au semestre 2
Le nombre total de modules distincts sur l'année

Partie 4 : Queue<T> — Files d'attente (FIFO)

Exercice 16 : Méthodes de Queue

Complétez le tableau :

Action	Méthode	Principe
Ajouter un élément à la file
Retirer et récupérer le premier élément
Consulter le premier élément sans le retirer

Question : Que signifie l'acronyme FIFO ? __________________________________

Exercice 17 : Traçage — Queue

Tracez l'état de la file après chaque instruction :

var q = new Queue<string>();
q.Enqueue("A");
q.Enqueue("B");
q.Enqueue("C");
Console.WriteLine(q.Dequeue());
q.Enqueue("D");
Console.WriteLine(q.Peek());
q.Enqueue("E");
Console.WriteLine(q.Dequeue());
Console.WriteLine(q.Count);

Instruction	État de la file (début → fin)	Sortie
`Enqueue("A")`		—
`Enqueue("B")`		—
`Enqueue("C")`		—
`Dequeue()`
`Enqueue("D")`		—
`Peek()`
`Enqueue("E")`		—
`Dequeue()`
`Count`

Exercice 18 : File d'attente d'un service client

Écrivez un programme qui simule un service client :

Créez une Queue<string> et ajoutez 4 tickets : "Ticket-101", "Ticket-102", "Ticket-103", "Ticket-104"
Traitez (retirez) les deux premiers tickets en affichant "Traité : ..."
Ajoutez deux nouveaux tickets : "Ticket-105" et "Ticket-106"
Affichez le prochain ticket à traiter (sans le retirer)
Traitez tous les tickets restants avec une boucle while

Partie 5 : Stack<T> — Piles (LIFO)

Exercice 19 : Méthodes de Stack

Complétez le tableau :

Action	Méthode	Principe
Empiler un élément au sommet
Dépiler et récupérer le sommet
Consulter le sommet sans dépiler

Question : Que signifie l'acronyme LIFO ? __________________________________

Question : Donnez deux exemples concrets d'utilisation d'une pile :

1. _____________________________________________ 2. _____________________________________________

Exercice 20 : Traçage — Stack

Tracez l'état de la pile après chaque instruction :

var s = new Stack<int>();
s.Push(100);
s.Push(200);
s.Push(300);
Console.WriteLine(s.Pop());
s.Push(400);
Console.WriteLine(s.Peek());
s.Push(500);
Console.WriteLine(s.Pop());
Console.WriteLine(s.Pop());
Console.WriteLine(s.Count);

Instruction	État de la pile (sommet à gauche)	Sortie
`Push(100)`		—
`Push(200)`		—
`Push(300)`		—
`Pop()`
`Push(400)`		—
`Peek()`
`Push(500)`		—
`Pop()`
`Pop()`
`Count`

Exercice 21 : Inverser une chaîne de caractères

Écrivez un programme qui utilise un Stack<char> pour inverser la chaîne "INFORMATIQUE" et affiche le résultat.

Exercice 22 : Vérification de parenthèses

Écrivez un programme qui vérifie si une expression contient des parenthèses correctement équilibrées en utilisant un Stack<char>.

Algorithme : pour chaque caractère, si c'est ( empiler, si c'est ) dépiler (si pile vide → non équilibré). À la fin, la pile doit être vide.

Testez avec : "((a+b)*(c-d))" et "(a+(b*c))" et "(a+b))"

Partie 6 : Choix de structure et exercices de synthèse

Exercice 23 : Choix de la collection

Pour chaque situation, indiquez la collection la plus adaptée (List<T>, Dictionary<K,V>, HashSet<T>, Queue<T>, Stack<T>) et justifiez brièvement :

N°	Situation	Collection	Justification
1	Stocker les prix des produits accessibles par nom
2	Gérer l'historique des pages visitées pour un bouton "Retour"
3	Gérer les adresses e-mail d'une newsletter (pas de doublons)
4	Gérer une file de patients dans une salle d'attente
5	Stocker une liste de courses modifiable et ordonnée
6	Associer les matricules des étudiants à leurs noms
7	Implémenter la fonctionnalité Annuler (Undo) d'un éditeur de texte
8	Stocker les numéros de CIN des votants (chacun ne vote qu'une fois)

Exercice 24 : Tableau comparatif

Complétez le tableau comparatif :

Critère	List<T>	Dictionary<K,V>	HashSet<T>	Queue<T>	Stack<T>
Accès par indice
Doublons autorisés
Ordre garanti
Complexité recherche
Complexité ajout

Exercice 25 : Gestion d'un magasin

Écrivez un programme complet qui gère un magasin :

Utilisez un Dictionary<string, double> pour le catalogue (produit → prix) avec 5 produits
Utilisez une Queue<string> pour les commandes en attente (ajoutez 4 commandes)
Utilisez un HashSet<string> pour les clients VIP (ajoutez 3 clients)
Traitez la première commande : affichez le produit commandé et son prix
Vérifiez si le client "Ali" est VIP
Affichez le nombre de commandes restantes

Exercice 26 : Traçage mixte

Déterminez la sortie du code suivant :

var pile = new Stack<int>();
var file = new Queue<int>();

int[] tab = { 3, 7, 1, 9, 4 };
foreach (int n in tab)
{
    pile.Push(n);
    file.Enqueue(n);
}

Console.Write("Pile : ");
while (pile.Count > 0)
    Console.Write(pile.Pop() + " ");

Console.WriteLine();
Console.Write("File : ");
while (file.Count > 0)
    Console.Write(file.Dequeue() + " ");

Sortie :

Explication : _____________________________________________________________

Exercice 27 : Statistiques d'une classe

Écrivez un programme qui utilise un Dictionary<string, List<int>> pour gérer les notes de 3 étudiants :

"Ali" : 14, 12, 16
"Sara" : 18, 15, 17
"Omar" : 8, 11, 9

Le programme doit :

Calculer et afficher la moyenne de chaque étudiant
Déterminer et afficher le nom de l'étudiant ayant la meilleure moyenne
Afficher le nombre d'étudiants admis (moyenne ≥ 10)

Indication : pour parcourir un Dictionary<string, List<int>>, chaque paire.Value est une List<int>.

Exercice 28 : Traçage de synthèse

Déterminez la sortie du code suivant :

var lst = new List<int> { 5, 3, 8, 3, 1, 5, 9 };
var uniques = new HashSet<int>(lst);
var triee = new List<int>(uniques);
triee.Sort();

var resultat = new Dictionary<string, int>();
resultat["Count"] = triee.Count;
resultat["First"] = triee[0];
resultat["Last"] = triee[triee.Count - 1];

foreach (var p in resultat)
    Console.WriteLine($"{p.Key} = {p.Value}");

Sortie :

Travaux Dirigés N°2

Framework .NET (C#) — Chapitre 2 : Les collections et structures de données génériques