Maths - Intersection de HashSets

Fait partie de la section Logique & Flux du Journey C# de Coddy — leçon 63 sur 66.

L'intersection de deux ensembles contient uniquement les éléments qui apparaissent dans les deux ensembles.

Créez deux HashSets :

HashSet<int> set1 = new HashSet<int>() { 1, 2, 3, 4, 5 };
HashSet<int> set2 = new HashSet<int>() { 3, 4, 5, 6, 7 };

Pour trouver l'intersection, utilisez la méthode IntersectWith :

set1.IntersectWith(set2);

Après l'exécution de ce code, set1 contiendra :

{ 3, 4, 5 }

La méthode IntersectWith modifie l'ensemble sur lequel elle est appelée, en ne conservant que les éléments qui existent dans les deux ensembles.

Pour créer un nouvel ensemble avec l'intersection sans modifier les ensembles originaux, vous pouvez faire ceci :

HashSet<int> intersection = new HashSet<int>(set1);
intersection.IntersectWith(set2);

Défi

Moyen

Créez une méthode nommée FindCommonElements qui prend deux arguments :

Un HashSet d'entiers (set1)
Un HashSet d'entiers (set2)

La méthode doit retourner un nouveau HashSet contenant uniquement les éléments qui apparaissent dans les deux ensembles (l'intersection).

Aide-mémoire

L'intersection de deux ensembles contient uniquement les éléments qui apparaissent dans les deux ensembles.

Utilisez la méthode IntersectWith pour trouver l'intersection :

HashSet<int> set1 = new HashSet<int>() { 1, 2, 3, 4, 5 };
HashSet<int> set2 = new HashSet<int>() { 3, 4, 5, 6, 7 };
set1.IntersectWith(set2); // set1 contient maintenant { 3, 4, 5 }

La méthode IntersectWith modifie l'ensemble d'origine. Pour préserver l'ensemble d'origine, créez d'abord une copie :

HashSet<int> intersection = new HashSet<int>(set1);
intersection.IntersectWith(set2);

Essayez vous-même

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

class Program {
    public static HashSet<int> FindCommonElements(HashSet<int> set1, HashSet<int> set2) {
        // Écrivez votre code ici
        return null;
    }
    
    static void Main(string[] args) {
        // Lire la première ligne pour le premier ensemble
        string line1 = Console.ReadLine();
        HashSet<int> set1 = new HashSet<int>();
        
        // Vérifier si le premier ensemble est au format tableau JSON
        if (line1 != null && line1.StartsWith("[") && line1.EndsWith("]")) {
            try {
                // Extraire le contenu entre les crochets
                string arrayContent = line1.Substring(1, line1.Length - 2);
                
                // Essayer d'analyser le contenu du tableau JSON
                string[] values = Regex.Split(arrayContent, @",\s*");
                foreach (string value in values) {
                    // Supprimer les guillemets s'ils sont présents
                    string cleanValue = value.Trim();
                    if (cleanValue.StartsWith("\"") && cleanValue.EndsWith("\"")) {
                        cleanValue = cleanValue.Substring(1, cleanValue.Length - 2);
                    }
                    
                    // Analyser comme un entier et ajouter à l'ensemble
                    if (int.TryParse(cleanValue, out int num)) {
                        set1.Add(num);
                    }
                }
            }
            catch (Exception ex) {
                Console.WriteLine($"Error parsing first set: {ex.Message}");
                return;
            }
        }
        else {
            // Traiter l'entrée traditionnelle séparée par des espaces pour le premier ensemble
            string[] input1 = line1.Split();
            foreach (string s in input1) {
                if (int.TryParse(s, out int num)) {
                    set1.Add(num);
                }
            }
        }
        
        // Lire la deuxième ligne pour le deuxième ensemble
        string line2 = Console.ReadLine();
        HashSet<int> set2 = new HashSet<int>();
        
        // Vérifier si le deuxième ensemble est au format tableau JSON
        if (line2 != null && line2.StartsWith("[") && line2.EndsWith("]")) {
            try {
                // Extraire le contenu entre les crochets
                string arrayContent = line2.Substring(1, line2.Length - 2);
                
                // Essayer d'analyser le contenu du tableau JSON
                string[] values = Regex.Split(arrayContent, @",\s*");
                foreach (string value in values) {
                    // Supprimer les guillemets s'ils sont présents
                    string cleanValue = value.Trim();
                    if (cleanValue.StartsWith("\"") && cleanValue.EndsWith("\"")) {
                        cleanValue = cleanValue.Substring(1, cleanValue.Length - 2);
                    }
                    
                    // Analyser comme un entier et ajouter à l'ensemble
                    if (int.TryParse(cleanValue, out int num)) {
                        set2.Add(num);
                    }
                }
            }
            catch (Exception ex) {
                Console.WriteLine($"Error parsing second set: {ex.Message}");
                return;
            }
        }
        else {
            // Traiter l'entrée traditionnelle séparée par des espaces pour le deuxième ensemble
            string[] input2 = line2.Split();
            foreach (string s in input2) {
                if (int.TryParse(s, out int num)) {
                    set2.Add(num);
                }
            }
        }
        
        // Trouver les éléments communs
        HashSet<int> common = FindCommonElements(set1, set2);
        
        // Afficher le résultat (trié)
        Console.WriteLine(string.Join(" ", common.OrderBy(x => x)));
    }
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

3Améliorations des boucles

Performance des boucles Itération de structures complexes Chaque type de boucle Refactorisation des boucles Récapitulatif - Boucles optimisées

6Gestion des valeurs nulles

Les bases des références nulles Types valeur nullables Patterns de vérification de nullité Programmation défensive Récapitulatif - Null Safety

9HashMap Partie 1

Qu'est-ce qu'un HashMap ?Déclarer un HashMap Vérifier si une clé existe Accéder aux valeurs Modifier des dictionnaires Récapitulatif - HashMap

12HashSet Partie 2

Maths - Union de HashSetsMaths - Intersection de HashSetsMaths - Différence d'ensembles Maths - Différence symétrique Itération sur les ensembles