420-KBB-LG – Programmation orientée objet avancée

//
// code produit pour vous aider et pour amorcer une réflexion avec vous
//
using MonNamespace;
List<Orque> orques = new();
try
{
   for (string s = Console.ReadLine(); "" != s; s = Console.ReadLine())
   {
      orques.Add(new Orque(s));
      Console.WriteLine($"Orque créé : {orques[orques.Count - 1].Nom}");
   }
}
catch (NomInvalideException nie)
{
   Console.WriteLine(nie.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> orques, out int nbPerms)
{
   nbPerms = 0;
   Orque[] orq = orques.ToArray(); 
   for (int i = 0; i < orq.Length - 1; ++i)
      for (int j = i + 1; j < orq.Length; ++j)
         if (!(orq[i].Nom.CompareTo(orq[j].Nom) < 0)) // désordre
         {
            Permuter(ref orq[i], ref orq[j]);
            ++nbPerms;
         }
   orques = orq.ToList();
   return nbPerms == 0;
}

// using...
namespace MonNamespace
{
   static class Algos
   {
      static char [] voyelles = { 'a', 'e', 'i', 'o', 'u', 'y' };
      public static bool Contient(char [] tab, char c)
      {
         foreach (char ch in tab)
            if (ch == c)
               return true;
         return false;
      }
      public static bool EstVoyelle(char c) =>
         Contient(voyelles, char.ToLower(c));
      public static int CompterVoyelles(string s)
      {
         int n = 0;
         foreach (char c in s)
            if (EstVoyelle(c))
               ++n;
         return n;
      }
      public static bool EstEntreInclusif(int val, int min, int max) =>
         min <= val && val <= max;
   }
}

using static MonNamespace.Algos;
// ...
class NomInvalideException : Exception;

class Orque
{
   static bool EstNomValide(string nom) =>
      nom != null &&
      EstEntreInclusif(nom.Length, 1, 4) &&
      Algos.CompterVoyelles(nom) <= 1;

   string nom;
   public string Nom
   {
      get => nom;
      private init
      {
         nom = EstNomValide(value) ?
            value : throw new NomInvalideException();
         //if (!EstNomValide(value))
         //   throw new NomInvalideException();
         //nom = value;
      }
   }
   public Orque(string nom)
   {
      Nom = nom;
   }
}

// ...
class NomInvalideException : Exception;
abstract class Soldat
{
   public string Nom { get; private init; }
   public Soldat(string nom)
   {
      Nom = nom;
   }
   public abstract void Saluer();
}

// ...
using static MonNamespace.Algos;
class Orque : Soldat
{
   const int LG_NOM_MIN = 1,
             LG_NOM_MAX = 4;
   static bool EstNomValide(string s) =>
      EstEntreInclusif(s.Length, LG_NOM_MIN, LG_NOM_MAX) &&
      CompterVoyelles(s) <= 1;
   static string ValiderNom(string s) =>
      EstNomValide(s) ? s : throw new NomInvalideException();
      public Orque(string nom)
         : base(ValiderNom(nom))
      {
      }
      public override void Saluer()
      {
         Console.WriteLine($"MOI {Nom.ToUpper()}, MOI PUE");
      }
   }
}

Image[] images = new Image[]
{
   new Jpeg(ConsoleColor.Magenta),
   new Png(ConsoleColor.Green),
   new Bmp(ConsoleColor.Blue)
};
// non, pas le droit!
//foreach (Image img in images)
//{
//   img.Dessiner();
//   img = ModifierPeutÊtre(img); // <-- ceci serait illégal
//   img.Dessiner();
//}

for (int i = 0; i != images.Length; ++i)
{
   images[i].Dessiner();
   images[i] = ModifierPeutÊtre(images[i]);
   images[i].Dessiner();
}


////////////////////////

static Image ModifierPeutÊtre(Image img)
{
   // 0 : créer un backup
   Image backup = img.Cloner();

   // 1 : modifier img
   img.Teinte = ConsoleColor.Red;

   // 2 : demander si on veut conserver les modifs
   Console.WriteLine("Conserver les modifs? ");
   // 2a : si oui, on retourne img
   // 2b : sinon, on retourne le backup
   if (Console.ReadKey(true).Key == ConsoleKey.O)
      return img;
   return backup;
}


// il existe une interface ICloneable, qui expose une méthode Clone
// ... mais ne l'utilisez pas :) Pour des détails, voir :
// https://codeql.github.com/codeql-query-help/csharp/cs-class-implements-icloneable/
abstract class Image
{
   public ConsoleColor Teinte { get; set; }
   protected Image(ConsoleColor teinte)
   {
      Teinte = teinte;
   }
   // Idiome NVI : non-virtual interface
   public void Dessiner()
   {
      ConsoleColor pre = Console.ForegroundColor;
      Console.ForegroundColor = Teinte;
      DessinerImpl(); // varie selon les enfants
      Console.ForegroundColor = pre;
   }
   protected abstract void DessinerImpl();
   public abstract Image Cloner();
}
class Jpeg : Image
{
   public Jpeg(ConsoleColor teinte) : base(teinte)
   {
   }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Jpeg {Teinte}");
   }
   protected Jpeg(Jpeg autre) : base(autre.Teinte)
   {
   }
   // spécialisation covariante
   public override Jpeg Cloner() => new (this);
}
class Bmp : Image
{
   public Bmp(ConsoleColor teinte) : base(teinte)
   {
   }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Bmp {Teinte}");
   }
   protected Bmp(Bmp autre) : base(autre.Teinte)
   {
   }
   public override Bmp Cloner() => new (this);
}
class Png : Image
{
   public Png(ConsoleColor teinte) : base(teinte)
   {
   }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Png {Teinte}");
   }
   protected Png(Png autre) : base(autre.Teinte)
   {
   }
   public override Png Cloner() => new (this);
}

const int N = 10_000_000;
const int NB_FACES = 6;
Random dé = new();
int[] lancers = new int[12]; // 0 .. 11, et l'indice 0 contiendra 0
for (int i = 0; i != N; ++i)
{
   int a = dé.Next(1, NB_FACES + 1),
       b = dé.Next(1, NB_FACES + 1);
   // Console.WriteLine($"{a} + {b} == {a+b}");
   lancers[(a + b) - 1]++;
}
Console.WriteLine($"Après {N} lancers de deux dés à {NB_FACES} faces...");
for (int i = 1; i != lancers.Length; ++i)
   Console.WriteLine($"{i + 1} : {lancers[i]}");

string texte = "..."; // utilisez le texte de votre choix

Dictionary<string, int> fréquence = new();
foreach(string s in texte.Split(new char[] { ' ', '\t', '\r', '\n' }))
   if(s.Trim().Length > 0)
      if(fréquence.ContainsKey(s))
         fréquence[s]++;
      else
         fréquence.Add(s, 1);

foreach (var (mot, n) in fréquence)
   Console.WriteLine($"Le mot {mot} apparaît {n} fois");

// note : nous avons fait plusieurs variations de ce qui suit
using System;
using System.Diagnostics;
const int N = 100_000_000;
int[] vals = CréerTableau(N);

System.Diagnostics.Stopwatch sw = new();
sw.Start();
int combien = Compter(vals);
sw.Stop();
Console.WriteLine($"Compté {combien} impairs en {sw.ElapsedMilliseconds} ms");


static bool EstPair(int n) => n % 2 == 0;
static bool EstImpair(int n) => !EstPair(n);
static int Compter(int[] vals)
{
   int combien = 0;
   foreach (int n in vals)
   {
      try
      {
         int res = F(n);
         ++combien;
      }
      catch (ZutException)
      {
      }
   }
   return combien;
}
static int F(int n)
{
   if (EstPair(n))
      throw new ZutException();
   return n;
}

static int[] CréerTableau(int n)
{
   int[] tab = new int[n];
   for (int i = 0; i != tab.Length; ++i)
      //if(i % 100 == 0)
      tab[i] = 2 * i;
   //else
   //   tab[i] = 2 * i + 1;
   return tab;
}
class ZutException : Exception;

using System;
using System.Text;
const int N = 100_000_000;
for (int i = 1; i <= N; i *= 10)
{
   System.Diagnostics.Stopwatch sw = new();
   sw.Start();
   string s = CréerTexteMeilleur(i, 'A');
   sw.Stop();
   Console.WriteLine($"Créé une chaîne de longueur {s.Length} en...");
   Console.WriteLine($"\t{sw.ElapsedMilliseconds} ms");
}
static string CréerTexteLent(int n, char c)
{
   string s = "";
   for (int i = 0; i != n; ++i)
      s += c;
   return s;
}
static string CréerTexteRapide(int n, char c)
{
   StringBuilder sb = new();
   for (int i = 0; i != n; ++i)
      sb.Append(c);
   return sb.ToString();
}
static string CréerTexteMeilleur(int n, char c)
{
   return new(c, n);
}

using System;
using System.Diagnostics;
const int N = 100_000_000;
for(int i = 1; i <= N; i *= 10)
{
   List<int> lst = new();
   Stopwatch sw = new();
   sw.Start();
   for (int j = 0; j != i; ++j)
      lst.Add(3); // 3 est une valeur quelconque; c'est pas important laquelle ici
   sw.Stop();
   Console.WriteLine($"Ajout à la fin, {i} éléments : {sw.ElapsedMilliseconds} ms");
   sw = new();
   sw.Start();
   for (int j = 0; j != i; ++j)
      lst.Insert(0, 3); // 3 est une valeur quelconque; c'est pas important laquelle ici
   sw.Stop();
   Console.WriteLine($"Ajout au début, {i} éléments : {sw.ElapsedMilliseconds} ms");
}