Exercices

Consignes

Activer la null safety
Ne pas utiliser les fonctions de tri de .Net

Série 1

Ecrire un programme qui affiche un nombre aléatoire en utilisant la classe Random. Voir un exemple ici
Ecrire une fonction qui génère 2 entiers pseudo-aléatoires entre 0 et 50 et les affiche dans l'ordre croissant
Ecrire une fonction qui génère 3 entiers pseudo-aléatoires entre 0 et 50 et les affiche dans l'ordre croissant
Ecrire une fonction qui génère des entiers pseudo-aléatoires entre 10 et 20 et s'arrête lorsque le premier nombre généré apparaît une seconde fois
Ecrire un programme qui génère un nombre de départ entre 0 et 9, et qui ensuite écrit la table de multiplication de ce nombre, présentée comme suit (cas du nombre 5).
Ecrire un programme qui génère un tableau 2D épars de 4 lignes. Pour chaque ligne, le nombre de colonnes est un nombre pseudo-aléatoire. Remplir cette matrice par des nombres pseudo-aléatoires de valeur max 999
- Afficher cette matrice comme sur Excel. Conseil: utiliser la méthode PadRight
Ecrire un programme qui génère deux tableaux de tailles pseudo-aléatoires et de contenus pseudo-aléatoires. Calculer le schtroumpf des deux tableaux et afficher le détail. Les nombres aléatoires sont compris entre 0 et 10.
- Pour calculer le schtroumpf, il faut multiplier chaque élément du tableau 1 par chaque élément du tableau 2, et additionner le tout.
- Par exemple si l'on a : [4, 8, 7, 12] et [3, 6], le programme va afficher: Le Schtroumpf sera : 3 x 4 + 3 x 8 + 3 x 7 + 3 x 12 + 6 x 4 + 6 x 8 + 6 x 7 + 6 x 12 = 279
Ecrivez un programme permettant de générer aléatoirement 10 notes comprises entre 0 et 20. Le programme, renvoie la liste et le nombre de notes supérieures à la moyenne de la classe.
Ecrire une fonction IsPalindrome(string) qui permet de dire si une chaîne de caractères est un palindrome, et ce Sans utiliser de fonction reverse,
- IsPalindrome("toto") -> false (car toto != otot)
- IsPalindrome("totot") -> true
Ecrire une fonction IsPalindrome(int) qui permet de dire si un entier est un palindrome, et ce, sans transformer l'entier en String
- IsPalindrome(1234) -> false
- IsPalindrome(12321) -> true
- IsPalindrome(1221) -> true
- IsPalindrome(1) -> true
Modélisation des pièce d'un ordinateur avec les classes.
- Chaque pièce électronique d'un ordinateur est de type ComputerPiece et est définie par un prix et une consommation en watts.
- Définir la classe ComputerPiece de telle façon à ce que l'on ne peut pas l'instancier.
- Nous souhaitons modéliser une classe CPU qui est une sorte de ComputerPiece avec une vitesse d'horloge et un nombre de coeurs.
- Modéliser les classes MotherBoard, RAM, GPU, SoundCard, BluetoothCard en leur attribuant des propriétés spécifiques.
- La classe Computer contient des pièces requises (non nulles): 1 MotherBoard, 1 CPU et 1 GPU. Elle contient aussi des pièces optionnelles (qui peuvent être nulles): 1 SoundCard et 1 BluetoothCard.
- Instancier un ordinateur qui n'a que les pièces requises
- Instancier un ordinateur qui a les pièces optionnelles
- Afficher les informations de chaque ordinateur en suivant ce modèle
  - "Ordinateur: CPU (ClockSpeed: 100, ...), GPU(ClockSpeed: 20, ...)"
- La classe SliComputer est un Computer qui contient un tableau qui peut contenir jusqu'à 9 GPU supplémentaires qui doivent être du même type que le GPU principal. Elle définit aussi une méthode bool IsSliCompliant() qui retourne true unqiement si tout les GPU sont exactement les mêmes.
- Instancier un SliComputer avec 2 GPU supplémentaires identiques au GPU principal.
- Instancier un SliComputer avec 3 GPU supplémentaires différents du GPU principal.
- Afficher le résultat de IsSliCompliant() à chaque fois.

Corrections série 1

Les corrections sont disponibles ci-dessous ainsi qu'en suivant ce lien

Exos de 1 à 5

exos de 1 à 5

void RunExercice1()
{
  Console.WriteLine("Exercise 1");
  var r = new Random();
  Console.WriteLine(r.Next());
}

void RunExercice2()
{
  Console.WriteLine("Exercise 2");
  var r = new Random(50);
  int x = r.Next();
  int y = r.Next();
  if (x < y)
  {
    Console.WriteLine($"{x}, {y}");
  }
  else
  {
    Console.WriteLine($"{y}, {x}");
  }
}

void RunExercice3()
{
  var r = new Random();
  int x = r.Next(50);
  int y = r.Next(50);
  int z = r.Next(50);
  Console.WriteLine($"Exercise 3: tri de {x}, {y} et {z}");
  if (x < y)
  {
    if (z < x)
    {
      Console.WriteLine($"{z}, {x}, {y}");
    }
    else if (z < y)
    {
      Console.WriteLine($"{x}, {z}, {y}");
    }
    else
    {
      Console.WriteLine($"{x}, {y}, {z}");
    }
  }
  else // y <= x
  {
    if (z < y)
    {
      Console.WriteLine($"{z}, {y}, {x}");
    }
    else if (z < x)
    {
      Console.WriteLine($"{y}, {z}, {x}");
    }
    else
    {
      Console.WriteLine($"{y}, {x}, {z}");
    }
  }
}

void RunExercice4()
{
  var r = new Random();
  int x = r.Next(50);
  Console.WriteLine($"Exercise 4: le premier nombre généré est {x}");
  int nbIter = 1;
  for (; x != r.Next(50); nbIter++)
  { }
  Console.WriteLine($"Exercise 4: Nb itération avant de trouver {x} est de {nbIter}");
}

void RunExercice5()
{
  var r3 = new Random();
  var nb = r3.Next(10);
  Console.WriteLine($"Exercise 5: table de multiplication de {nb}:");
  for (int i = 0; i <= 10; i++)
  {
    Console.WriteLine($"{nb} x {i} = {nb * i}");
  }
}


void RunExercices()
{
  RunExercice1();
  RunExercice2();
  for (int i = 0; i < 20; i++)
  {
    RunExercice3();
  }

  RunExercice4();
  RunExercice5();

}

Exercice 11

class ComputerPiece
{
  // prorpiété en lecture et écriture
  public int WattUsage { get; set; }
  // prorpiété en lecture seule
  public int Price { get; }

  public ComputerPiece(int price)
  {
    Console.WriteLine("ComputerPiece constructor");
    this.Price = price;
  }
}

class PowerGenerator : ComputerPiece
{
  public PowerGenerator(int price) : base(price)
  {
  }
}

class UsbPort : ComputerPiece
{
  public UsbPort(int price) : base(price)
  {
  }
}

class CPU : ComputerPiece
{
  public CPU(int price) : base(price)
  {
  }
  public int ClockSpeed { get; set; }
  public int CoreCount { get; set; }
}

class RAM : ComputerPiece
{
  public RAM(int price) : base(price)
  {
  }
  public int Capacity { get; set; }
}

CPU cpu1 = new CPU(200);
cpu1.WattUsage = 100;
Console.WriteLine(cpu1.WattUsage);

CPU cpu2 = new(500);
cpu2.WattUsage = 100;
Console.WriteLine(cpu2.WattUsage);

CPU cpu3 = new(200)
{
  ClockSpeed = 100,
  CoreCount = 8,
  WattUsage = 10
};
Console.WriteLine(cpu3);


RAM ram1 = new(200)
{
  Capacity = 8000,
  WattUsage = 10
};
Console.WriteLine(ram1);

ComputerBox computerBox = new(10, 10, 5);
Console.WriteLine(computerBox);

Série 2

Modélisation des formes géométriques avec les Record
1. Créer un record Circle qui prend en paramètre du constructeur un Radius
  - Ajouter les propriétés calculées publiques (en lecture seule): Area, Circumference et Diameter
  - Créer deux instances ayant le même rayon et affichez les dans la console, en utilisant le ToString() proposé par les record
  - Comparer les deux cercles avec l’opérateur ‘==’. Ensuite, comparez en enlevant la nature record de Cercle. Que remarquez-vous ?
2. Créer un record abstract “Shape” avec un constructeur vide et les propriété en lecture seule abstraites: Area et Circumference
3. Faire en sorte que Circle hérite de Shape
4. Créer un record “Rectangle” qui hérite de Shape et prend en paramètre du constructeur (Width et Height)
  - Implémenter les propriétés calculées (en lecture seule): Area, Circumference (même si techniquement, ça devrait s’appeler Perimeter)
5. Créer une fonction PrintShapeInfo qui prend un Shape en paramètre et qui utilise le pattern matching pour afficher des infos différentes selon le type du Shape
6. Créer une fonction qui génère aléatoirement une liste de Shape de type Circle ou Rectangle avec des valeurs initiales aléatoires. Le nombre d’éléments à générer est passé en paramètre. Utiliser cette méthode pour générer une liste de 10 Shape
7. Utiliser LINQ (Select, Where, Aggregate, etc.) pour générer un objet qui a deux champs: SumCircleArea et MaxRectangleWidth:
  - SumCircleArea : la somme des surfaces de tous les cercles. MaxRectangleWidth : la largeur maximale des rectangles
  - Faire en sorte que l’objet généré soit anonyme
8. Utiliser LINQ pour calculer le nombre de cercles dans la liste
9. Utiliser LINQ pour calculer le nombre de rectangles dont la superficie est > 10
10. Utiliser LINQ pour calculer la circonférence moyenne des cercles (astuce: méthode average)