using System;

using System.Collections.Generic;

using System.Linq;

​

List<Orque> orques = new List<Orque>();

try

{

   // for (string s = Console.ReadLine(); "" != s; s = Console.ReadLine())

   foreach(string s in new [] { "urg", "bob", "GRR" }) // pour que l'exemple ne demande pas d'entrer des données au clavier!

   {

      orques.Add(new Orque(s));

      Console.WriteLine($"Orque créé : {orques[orques.Count - 1].Nom}");

   }

}

catch (NomInvalideException ex)

{

   Console.WriteLine(ex.Message);

}

if (Trier(ref orques, out int nbPermutations))

{

   Console.WriteLine("Les orques ont été entrés en ordre alphabétique");

}

else

{

   Console.WriteLine($"Trier les orques a nécessité {nbPermutations} permutations");

}

Console.Write("La tribu d'orques est :");

foreach (Orque orque in orques)

   Console.Write($" {orque.Nom}");

​

//

//

//

static void Permuter(ref Orque a, ref Orque b)

{

   Orque temp = a;

   a = b;

   b = temp;

}

​

//

//

//

static bool Trier(ref List<Orque> lst, out int nbPerm)

{

   nbPerm = 0;

   Orque[] tab = lst.ToArray();

   // tri à bulles... très, très naïf

   for (int i = 0; i < tab.Length - 1; ++i)

      for (int j = i + 1; j < tab.Length; ++j)

         //

         // s'ils ne sont pas dans l'ordre, les permuter

         //

         // deux versions du même test : méthode d'instance (en commentaire)

         // et méthode de classe (pas en commentaire). L'avantage de la méthode

         // de classe est qu'elle fonctionnera aussi dans le cas où l'un des deux

         // paramètres est null

         //

         //if (tab[i].Nom.CompareTo(tab[j].Nom) > 0)

         //

         if(string.Compare(tab[i].Nom, tab[j].Nom) > 0)

         {

            Permuter(ref tab[i], ref tab[j]);

            ++nbPerm;

         }

   lst = tab.ToList();

   return nbPerm == 0;

}

​

//

//

//

static class Algos

{

   //

   // Rappel : quand une fonction se limite à « return » suivi d'une

   // expression, les deux formes suivantes sont équivalentes (c'est

   // pour vous encourager à écrire de petites fonctions qui font une

   // et une seule chose!)

   //

   public static bool EstEntreInclusif(int val, int min, int max) =>

      min <= val && val <= max;

   //public static bool EstEntreInclusif(int val, int min, int max)

   //{

   //   return min <= val && val <= max;

   //}

}

​

//

//

//

static class OutilsTexte

{

   private static char[] voyelles = { 'a', 'e', 'i', 'o', 'u', 'y' };

   public static bool EstVoyelle(char c) => voyelles.Contains(char.ToLower(c));

   public static int CompterVoyelles(string s)

   {

      int nb = 0;

      foreach (char c in s)

         if (EstVoyelle(c))

            ++nb;

      return nb;

   }

}

​

//

//

//

class NomInvalideException : Exception

{

   public NomInvalideException(string nom) : base($"Nom invalide : {nom}")

   {

   }

}

​

//

//

//

class Orque

{

   private static bool EstNomValide(string s)

   {

      const int LG_MIN = 1,

                LG_MAX = 4;

      const int MAX_VOYELLES = 1;

      return s != null && Algos.EstEntreInclusif(s.Length, LG_MIN, LG_MAX) &&

                          OutilsTexte.CompterVoyelles(s) <= MAX_VOYELLES;

   }

   private string nom;

   public string Nom

   {

      get => nom;

      // private init

      // {

      //    if (!EstNomValide(value))

      //       throw new NomInvalideException(value);

      //    nom = value;

      // }

      private init

      {

         nom = !EstNomValide(value) ? throw new NomInvalideException(value) : value;

      }

   }

   public Orque(string nom)

   {

      Nom = nom;

   }

}