Vérifier si un élément existe

Fait partie de la section Logique & Flux du Journey C# de Coddy. Leçon 59 sur 66.

La méthode Contains(element) vérifie si un élément spécifique existe dans le HashSet. Elle renvoie true si l’élément est trouvé, et false dans le cas contraire.

Créez un HashSet vide :

HashSet<string> fruits = new HashSet<string>();

Ajoutez quelques éléments au HashSet :

fruits.Add("Apple");
fruits.Add("Banana");

Vérifiez si un élément existe :

bool hasApple = fruits.Contains("Apple");  // Renvoie true
bool hasOrange = fruits.Contains("Orange"); // Renvoie false

Vous pouvez utiliser le résultat dans des instructions conditionnelles :

if (fruits.Contains("Apple"))
{
    Console.WriteLine("Apple is in the set");
}

Défi

Facile

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

Un HashSet de chaînes (set)
Une chaîne (element) à vérifier

La méthode doit vérifier si l’élément existe dans l’ensemble et renvoyer un message sous forme de chaîne :

Si l’élément existe, renvoyer "The element 'X' exists in the set"
Si l’élément n’existe pas, renvoyer "The element 'X' does not exist in the set"

Où 'X' correspond à la valeur réelle de l’élément vérifié.

Essayez vous-même

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

public class Program
{
    public static string ElementExists(HashSet<string> set, string element)
    {
        // Écrivez votre code ici
        return "";
    }
    
    public static void Main()
    {
        // Lire la première ligne pour vérifier s'il s'agit du format JSON
        string firstLine = Console.ReadLine();
        string elementToCheck = Console.ReadLine();
        HashSet<string> set = new HashSet<string>();
        
        // Vérifier si l'entrée est au format de tableau JSON
        if (firstLine != null && firstLine.StartsWith("[") && firstLine.EndsWith("]"))
        {
            try
            {
                // Extraire le contenu entre les crochets
                string arrayContent = firstLine.Substring(1, firstLine.Length - 2);
                
                // Utiliser une expression régulière pour faire correspondre toutes les chaînes entre guillemets
                MatchCollection matches = Regex.Matches(arrayContent, @"""([^""]*)""");
                
                foreach (Match match in matches)
                {
                    // Ajouter le groupe capturé (sans les guillemets)
                    if (match.Groups.Count > 1)
                    {
                        set.Add(match.Groups[1].Value.Trim());
                    }
                }
                
                // Vérifier si l'élément est au format de chaîne JSON
                Match elementMatch = Regex.Match(elementToCheck, @"""([^""]*)""");
                if (elementMatch.Success && elementMatch.Groups.Count > 1)
                {
                    elementToCheck = elementMatch.Groups[1].Value;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing JSON input: {ex.Message}");
                return;
            }
        }
        else
        {
            // Traiter l'entrée traditionnelle séparée par des virgules
            string[] elements = firstLine.Split(',');
            foreach (string element in elements)
            {
                set.Add(element.Trim());
            }
        }
        
        string result = ElementExists(set, elementToCheck);
        Console.WriteLine(result);
    }
}