420-R51-MA / Programmation 1

420-R51-MA \_ Programmation 1 | Gestionreseau Wiki | FANDOM powered by Wikia

Prof :

## Introduction au cours

#### Exemple 1

Un litre équivaut à 0.264179 gallons et un kilomètre est égal à 0.62137 mile. Écrire un programme qui lit les litres de carburant consommés, la longueur du trajet en kilomètres, calcule et affiche le nombre de gallons par miles que le véhicule a consommé.

En pseudo-code :

```
// Déclaration des variables et des constantes
//   1 L = 0,26 gallon
//   1 Km = 0,62 mile
var NombreLitresConsommés : décimal;
var LongueurTrajet : décimal;
const ConversionLitreGallon = 0,26;
const ConversionKilometreMile = 0,62;

// Saisi des données
Écrire ("Saisir le nombre de litres consommés");
NombreLitresConsommés = Lire ();
Écrire ("Saisir la longueur du trajet");
LongueurTrajet = Lire ();

// Faire les calcules
var ResultatGallon : réel;
ResultatGallon = nombreLitre * ConversionLitreGallon;
var ResultatMile : réel;
ResultatMile = LongueurTrajet * ConversionKilometreMile;
var ResultatConsommation : réel;
ResultatConsommation = ResultatGallon / ResultatMile;

// Afficher le résultat
Écrire ("Le trajet en miles = " + ResultatMile);
Écrire ("Carburant consommée en gallons = " + ResultatGallon);
Écrire ("Consommation du carburant (gallons par mile) = " + ResultatConsommation);

```

En C# :

```
   // Exercice 1.1
   // Consommation du carburant par mile
   using System;
   namespace Exercice
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Déclaration des variables et des constantes
               float nombreLitres = 0;
               float longueurTrajet = 0;
               float resultatMile = 0;
               float resultatGallon = 0;
               float resultatConsommation = 0;
               float resultatParcour = 0;
               const float conversionLitreGallon = 0.26f;
               const float conversionKilometreMile = 0.62f;
               //
               // Saisie des données
               Console.WriteLine();
               Console.WriteLine("-------------------------------------------------");
               Console.WriteLine("Exercice 1.1 : Consommation du carburant par mile");
               Console.WriteLine("-------------------------------------------------");
               Console.Write("Saisir la longueur du trajet (km) : ");
               // longueurTrajet = (float)Convert.ToDouble(Console.ReadLine());
               longueurTrajet = float.Parse(Console.ReadLine(), System.Globalization.CultureInfo.InvariantCulture);
               Console.Write("Saisir la consommation du carburant (l) : ");
               nombreLitres = (float)Convert.ToDouble(Console.ReadLine());
               //
               // Calculations
               resultatMile = longueurTrajet * conversionKilometreMile;
               resultatGallon = nombreLitres * conversionLitreGallon;
               resultatConsommation = resultatGallon / resultatMile;
               resultatParcour = resultatMile / resultatGallon;
               //
               // Affichage du résultat
               Console.WriteLine("Longueur du trajet (miles) = " + resultatMile);
               Console.WriteLine("Carburant consommé (gallons) = " + resultatGallon);
               Console.WriteLine("Consommation en gallon par mile = " + Math.Round(resultatConsommation,5));
               Console.WriteLine("Parcour en mile par gallon = " + Math.Round(resultatParcour,2));
               Console.WriteLine();
           }
       }
   }

```

#### Exemple 2

La force d’attraction gravitationnelle de deux corps de masses m1 et m2 séparés par une distance d est donnée par F = Gm1m2/d2 Où G est la constante universelle de gravitation G = 6.673 \* 10−8cm3 /gsec2. Écrire un algorithme qui lit la masse de deux corps et la distance qui les sépare et calcule la force gravitationnelle entre elles.

En pseudo-code :

```
// Déclaration des variables et constantes
var m1 : décimal;
    m2 : décimal;
    d  : décimal;

const G_CGS = 6,67*10^-8;  // C'est pour CGS (cm, g, seconde )
const G_SI  = 6,67*10^-11; // C'est pour SI (m, kg, seconde)

var F : réel; // Résultat

// Saisie des données
Écrire ("Saisir masse 1 (kg)");
m1 = Lire ();
Écrire ("Saisir masse 2 (kg)");
m2 = Lire ();
Écrire ("Saisir la distance entre les deux corps (m)");
d = Lire ();

// Calculations
F = (G_SI * m1 * m2) / (d*d)
...

```

#### Exemple 3

Saisir les coefficients a et b et afficher la solution de l'équation ax + b = 0.

En pseudo-code :

```
// Déclaration des variables
//...

// Saisie de données
Écrire ("Saisir le coefficient a");
a = Lire ();
Écrire ("Saisir le coefficient b");
b = Lire ();

// Calculation
// ...

// Affichage du résultat
// ...

```

En C#

```
   // Exemple 1.3
   //   ...
   using System;
   namespace helloworld
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Exercice 3
               // Résolution d'une equation ax+b=0
               // ----------------------------------
               // Déclaration des variables et des constantes
               float a = 0;
               float b = 0;
               float x = 0;
               //
               // Saisie des données
               Console.WriteLine();
               Console.WriteLine("-----------------------------------------------");
               Console.WriteLine("Exercice 1.2 : Résolution d'une equation ax+b=0");
               Console.WriteLine("-----------------------------------------------");
               Console.Write("Saisir le coéfficient a : ");
               a = float.Parse(Console.ReadLine());
               Console.Write("Saisir le coéfficient b : ");
               b = float.Parse(Console.ReadLine());
               //
               // Calculations
               x = -b/a;
               //
               // Affichage du résultat
               Console.WriteLine("La solution : x = " + x);
               Console.WriteLine();
           }
       }
   }

```

## Déclaration des variables en C#

### Exercices

#### Exercice 1

Saisir l'année de naissance d'une personne puis afficher son âge.
On considère que l'année en cours est 2018.
La phrase finale doit être: "Votre âge est 45 ans"

En pseudo-code :

```
var dateNaissance : entier;
    age : entier;

Écrir("Saisir la date de naissaince :");
dateNaissaice = Lire();
age = dateEnCours - DateNaissance;
Écrir("Votre age = " + age);

```

En C# :

```
   // Exercice 2.1
   //   Saisir l'année de naissance d'une personne puis afficher son âge.
   //   On considère que l'année en cours est 2018.
   //   La phrase finale doit être: "Votre âge est 45 ans".

   using System;
   using System.Globalization;

   namespace UserAge
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Préparer l'écran
               Console.WriteLine("----------------------------------------------");
               Console.WriteLine("Exercice 2.1 : Calculation d'age d'utilisateur");
               Console.WriteLine("----------------------------------------------");

               // Définir les variables
               DateTime dateNaissance;
               DateTime dateEnCours = DateTime.Today;  // La date en cours
               string   dateString;                    // Pour lire l'entré d'utilisateur
               int      age;                           // L'age en années
               const string cultureString = "fr-CA";   // Comment «parser» la date
               CultureInfo cultureCurrent = new CultureInfo(cultureString);

               // Saisir l'entrée
               Console.Write("Saisir la date de naissance (AAAA-MM-JJ) : ");
               dateString = Console.ReadLine();

               // Faire la calcul et la conversion
               dateNaissance = DateTime.Parse(dateString, cultureCurrent, DateTimeStyles.NoCurrentDateDefault);
               age = ((int) (dateEnCours - dateNaissance).TotalDays) / 365;

               // Afficher le résultat
               Console.WriteLine("Votre age est " + age + " ans.");
           }
       }
   }

```

#### Exercice 2

Écrire un programme permettant à l'utilisateur d'entrer un nombre d'étudiants inscrits et un nombre d'étudiants présents et affichant le pourcentage d'étudiants présents. La sortie du programme doit correspondre à l'exécution ci-dessous. On suppose que l'utilisateur entre des valeurs strictement positives. On affichera le pourcentage avec un chiffre après la virgule.

* nombre d'étudiants inscrits ? 400
* nombre d'étudiants inscrits = 400
* nombre d'étudiants présents ? 250
* nombre d'étudiants présents = 250
* pourcentage de présences = 62.5 %

```
   // Exercice 2.1
   //  Écrire un programme permettant à l'utilisateur d'entrer un nombre d'étudiants inscrits et un nombre
   //  d'étudiants présents et affichant le pourcentage d'étudiants présents. La sortie du programme doit
   //  correspondre à l'exécution ci-dessous. On suppose que l'utilisateur entre des valeurs strictement
   //  positives. On affichera le pourcentage avec un chiffre après la virgule.
   //    nombre d'étudiants inscrits ? 400
   //    nombre d'étudiants inscrits = 400
   //    nombre d'étudiants présents ? 250
   //    nombre d'étudiants présents = 250
   //    pourcentage de présences = 62.5 %

   using System;

   namespace UserAge
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Préparer l'écran
               Console.WriteLine("--------------------------------------");
               Console.WriteLine("Exercice 2.2 : Pourcentage de présence");
               Console.WriteLine("--------------------------------------");
               //
               // Définir les variables
               int    nombreInscrit = 0;
               int    nombrePresent = 0;
               string inputInscrit = "";
               string inputPresent = "";
               float  pourcentPresent;
               //
               // Saisir l'entrée
               Console.Write("Nombre d'étudiants inscrits ? ");
               inputInscrit = Console.ReadLine();
               Console.Write("Nombre d'étudiants présents ? ");
               inputPresent = Console.ReadLine();
               //
               // Faire la calcul et la conversion
               nombreInscrit = int.Parse(inputInscrit);
               nombrePresent = int.Parse(inputPresent);
               pourcentPresent = ((float) nombrePresent / (float) nombreInscrit) * 100;
               //
               // Afficher le résultat
               Console.WriteLine("Pourcentage de présence = " + pourcentPresent.ToString("0.0") + " %");
           }
       }
   }

```

#### Exercice 3

Écrire un programme permettant de calculer et d'afficher le salaire net d'un employé ainsi que le détail des déductions. Pour cela, il vous faudra lire les informations suivantes :
    • le nombre d'heures travaillées ;
    • le taux horaire.

Pour cela, il vous faudra lire les informations suivantes :

* le nombre d'heures travaillées ;
* le taux horaire.

Il vous faudra tenir compte que l'employé devra payer :

* 15 % d'impôt fédéral ;
* 20 % d'impôt provincial ;
* 2,5 % d'assurance emploi ;
* 2 % de régime des rentes.

En pseudo-code :

```
const impotFederal : float = 0,15;
      impotProvincial : float = 0,20;
      assuranceEmploi : float = 0,025;
      regimeRentes : float = 0,02;
var   nombreHeureTravail : float;
         tauxHoraire : float;
         salaireNet : float;
         salaireBrut: float;

Écrire("Saisir le nombre d'heure par semaine");
nombreHeureTravail = Lire();
Écrire("Saisir le taux horaire");
tauxHoraire = Lire();

salaireBrut = nombreHeureTravail * tauxHoraire;
salaireNet = salaireBrut * (1 - impotFederal - impotProvincial - assuranceEmploi - regimeRentes);

Écrire("Salaire brut = " + salaireBrut);
Écrire("Salaire net = " + salaireNet);

```

En C# :

```
   // Exercice 2.3
   //   Écrire un programme permettant de calculer et d'afficher le salaire net
   //   d'un employé ainsi que le détail des déductions. Pour cela, il vous faudra
   //   lire les informations suivantes :
   //    • le nombre d'heures travaillées ;
   //    • le taux horaire.
   //   Il vous faudra tenir compte que l'employé devra payer :
   //    • 15 % d'impôt fédéral ;
   //    • 20 % d'impôt provincial ;
   //    • 2,5 % d'assurance emploi ;
   //    • 2 % de régime des rentes.
   using System;
   using System.Globalization;
   namespace Exercice
   {
       class Program
       {
           static void Main(string[] args)
           {
               //
               // Préparer l'écran
               Console.WriteLine();
               Console.WriteLine("------------------------------------------");
               Console.WriteLine("Exercice 2.3 : Salaire brut et net");
               Console.WriteLine("------------------------------------------");
               //
               // Définir les constantes et variables
               const float impotFederal = 0.15f;
               const float impotProvincial = 0.20f;
               const float assuranceEmploi = 0.025f;
               const float regimeRentes = 0.02f;
               float nombreHeures;
               float tauxHoraire;
               float salaireBrut;
               float salaireNet;
               //
               // Saisir l'entrée
               Console.Write("Taux horaire en $ par heure ? ");
               tauxHoraire = (float) Math.Round(float.Parse(Console.ReadLine()),2);
               Console.Write("Nombre d'heure travaillées ? ");
               nombreHeures = float.Parse(Console.ReadLine());
               //
               // Faire la calcul et la conversion
               salaireBrut = nombreHeures * tauxHoraire;
               salaireNet = (float) Math.Round(salaireBrut * (1 - impotFederal - impotProvincial - assuranceEmploi - regimeRentes));
               //
               // Afficher le résultat
               Console.WriteLine("Le salaire brut : " + salaireBrut.ToString("0.00") + " CAD");
               Console.WriteLine("Le salaire net  : " + salaireNet.ToString("0.00") + " CAD");
               Console.WriteLine();
           }
       }
   }

```

#### Exercice 4

Georges est un représentant sur la route. Comme il voyage beaucoup et qu'il change régulièrement de voiture, il aimerait avoir un programme qui lui permettrait de calculer le coût de déplacement pour un voyage. Il aimerait que le programme lui permette d'entrer le prix d'un litre d'essence, la distance à parcourir et la consommation du véhicule en litres/100 km, puis le programme doit calculer le coût du voyage.

```
   // Exercice 2.4
   //   Georges est un représentant sur la route. Comme il voyage beaucoup et qu'il change
   //   régulièrement de voiture, il aimerait avoir un programme qui lui permettrait de
   //   calculer le coût de déplacement pour un voyage. Il aimerait que le programme lui
   //   permette d'entrer le prix d'un litre d'essence, la distance à parcourir et la
   //   consommation du véhicule en litres/100 km, puis le programme doit calculer le coût
   //   du voyage.
   using System;
   using System.Globalization;
   namespace Exercice
   {
       class Program
       {
           static void Main(string[] args)
           {
               //
               // Préparer l'écran
               Console.WriteLine();
               Console.WriteLine("------------------------------------------");
               Console.WriteLine("Exercice 2.4 : Coût de déplacement");
               Console.WriteLine("------------------------------------------");
               //
               // Définir les variables
               float  prixLitre         = 0;    // CAD par litre
               float  distance          = 0;    // Km
               float  consommation      = 0;    // Litres par 100 km
               float  coutVoyage        = 0;
               //
               // Saisir l'entrée
               Console.Write("Prix d'un litre d'essence en $ ? ");
               prixLitre = float.Parse(Console.ReadLine());
               Console.Write("Distance du voyage en km ? ");
               distance = float.Parse(Console.ReadLine());
               Console.Write("Consommation de la voiture en litres par 100 km ? ");
               consommation = float.Parse(Console.ReadLine());
               //
               // Faire la calcul et la conversion
               //   Formule :
               //   Coût = Prix * Consommation * (Distance / 100 km)
               //   Exemple :
               //   distance 10 km, consommation 10 l par 100 km --> (10/100)*10 = 1 l brulé
               //   prix de litre 1,42 $ --> 1,42 $ * 1 l = coût 1,42 $
               coutVoyage = prixLitre * consommation * (distance / 100);
               //
               // Afficher le résultat
               Console.WriteLine("Le coût du voyage : " + coutVoyage.ToString("0.00") + " CAD");
               Console.WriteLine();
           }
       }
   }

```

#### Exercice 5

Les employés d’une société viennent enfin d'obtenir une augmentation de 3% suite aux négociations serrées de leur syndicat. La convention collective ayant échu il y a 9 mois, cette augmentation sera donc rétroactive à cette période. Créez-leur un programme qui permettra à un employé d'entrer son ancien salaire annuel pour obtenir :

* Le nouveau salaire annuel
* Le nouveau salaire mensuel
* Le montant rétroactif auquel il aura droit sur sa première paie

```
   // Exercice 2.5
   //    Les employés d’une société viennent enfin d'obtenir une augmentation
   //    de 3% suite aux négociations serrées de leur syndicat. La convention
   //    collective ayant échu il y a 9 mois, cette augmentation sera donc
   //    rétroactive à cette période. Créez-leur un programme qui permettra à
   //    un employé d'entrer son ancien salaire annuel pour obtenir:
   //    • Le nouveau salaire annuel
   //    • Le nouveau salaire mensuel
   //    • Le montant rétroactif auquel il aura droit sur sa première paie
   using System;
   using System.Globalization;
   namespace Exercice
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Préparer l'écran
               Console.WriteLine();
               Console.WriteLine("---------------------------------");
               Console.WriteLine("Exercice 2.5 : Augmentation de 3%");
               Console.WriteLine("---------------------------------");
               //
               // Définir les variables
               float salaireAnnuelAvant;           // Salaire avant l'augmentation
               float salaireAnnuel;
               float salaireMensuel;
               float montantRetroactif;            // Le montant qui sera ajouté à la première paie
               const int dureeRetroactif = 9;      // Nombre de mois pour le calcul rétroactif
               const float augmentation    = 3f;   // Taux d'augmentation en pourcents !!!
               //
               // Saisir l'entrée
               Console.Write("Votre salaire avant l'augmentation ? ");
               salaireAnnuelAvant = float.Parse(Console.ReadLine());
               //
               // Faire la calcul et la conversion
               //   Formules :
               //   salaireAnnuel = salaireAnnuelAvant + 3% (c'est à dire x 1,03)
               //   salaireMensuel = salaireAnnuel / 12
               //   montantRetroactif = (3% de salaireAnnuelAvant) x (9/12)
               salaireAnnuel = (float) Math.Round(salaireAnnuelAvant * (1 + ((float) augmentation / 100)), 2);
               salaireMensuel = (float) Math.Round(salaireAnnuel / 12, 2);
               montantRetroactif = (salaireAnnuelAvant * (augmentation / 100)) * ((float) dureeRetroactif/12);
               // Afficher le résultat
               Console.WriteLine("Taux d'augmentation : " + augmentation + " %");
               Console.WriteLine("Period du paiement rétroactif : " + dureeRetroactif + " mois");
               Console.WriteLine("Votre nouvelle salaire...");
               Console.WriteLine("   annuel  : " + salaireAnnuel.ToString("# ##0.00") + " CAD");
               Console.WriteLine("   mensuel : " + salaireMensuel.ToString("# ##0.00") + " CAD");
               Console.WriteLine("Montant rétroactif sur la première paie : " + montantRetroactif.ToString("# ##0.00") + " CAD");
               Console.WriteLine();
           }
       }
   }

```

#### Exercice 6

À un barbecue, on désire nourrir les étudiants et les étudiantes d'informatique avec des hots-dogs. Écrivez un programme qui demande le nombre d'étudiants en informatique et le nombre de hots-dogs prévu par étudiant. Le programme doit calculer le nombre de saucisses qu'il faudra acheter, le nombre de paquets complets que cela représente (il y a douze saucisses par paquet) et le nombre de saucisses supplémentaires qu'il faudra acheter à l'unité.

```
   // Exercice 2.6
   //   À un barbecue, on désire nourrir les étudiants et les étudiantes d'informatique
   //   avec des hots-dogs. Écrivez un programme qui demande le nombre d'étudiants en
   //   informatique et le nombre de hots-dogs prévu par étudiant. Le programme doit
   //   calculer le nombre de saucisses qu'il faudra acheter, le nombre de paquets
   //   complets que cela représente (il y a douze saucisses par paquet) et le nombre
   //   de saucisses supplémentaires qu'il faudra acheter à l'unité.

   using System;
   using System.Globalization;

   namespace Exercice
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Préparer l'écran
               Console.WriteLine("------------------------------------------");
               Console.WriteLine("Exercice 2.6 : Barbecue pour les étudiants");
               Console.WriteLine("------------------------------------------");

               // Définir les variables
               int    nombreEtudiants          = 0;
               string inputEtudiants           = "";
               int    nombreHotdogsParEtudiant = 0;    // Saucisses mangées par un étudiant
               string inputHotdogsParEtudiant  = "";
               int    nombreSaucissesParPaquet = 12;
               int    nombrePaquets            = 0;    // Paquets de saucisses à acheter
               int    nombreSaucissesUnite     = 0;    // Saucisses à acheter par unité
               int    nombreSaucissesTotal     = 0;    // Nombre total des saucisses

               // Saisir l'entrée
               Console.Write("Nombre d'étudiants au barbecue ? ");
               inputEtudiants = Console.ReadLine();
               Console.Write("Nombre de hotdogs par étudiant ? ");
               inputHotdogsParEtudiant = Console.ReadLine();

               // Faire la calcul et la conversion
               nombreEtudiants = int.Parse(inputEtudiants);
               nombreHotdogsParEtudiant = int.Parse(inputHotdogsParEtudiant);
               nombreSaucissesTotal = nombreEtudiants * nombreHotdogsParEtudiant;
               nombrePaquets = nombreSaucissesTotal / nombreSaucissesParPaquet;
               nombreSaucissesUnite = nombreSaucissesTotal % nombreSaucissesParPaquet;

               // Afficher le résultat
               Console.WriteLine("Pour le barbecue il faut :");
               Console.WriteLine("  " + nombreSaucissesTotal + " saucisses en total;");
               Console.WriteLine("  " + nombrePaquets + " paquet (" + nombreSaucissesParPaquet + " par paquet);");
               Console.WriteLine("  " + nombreSaucissesUnite + " à acheter par unité. Bon appetit !");
           }
       }
   }

```

#### Exercice 7

Un jeu vidéo simule un tank qui tire des projectiles. La distance maximale que peut atteindre le projectile est donnée par la formule2\*v^2\*cos(theta)\*sin(theta)/g. Le temps que prendra le projectile à atteindre le sol est donné par la formule 2\*v\*sin(theta)/g.

Écrivez un programme qui demande la vitesse initiale du projectile v (en m/s) et l'angle de tir theta (en degrées ou en radians) et qui calcule la distance maximale de tir et le temps où le projectile touchera le sol.

La valeur de g est de 9,8. N'oubliez pas que les fonctions trigonométriques de la bibliothèque math utilisent des angles en radians.

```
   // Exercice 2.7
   //    Un jeu vidéo simule un tank qui tire des projectiles.
   //    La distance maximale que peut atteindre le projectile
   //    est donnée par la formule 2*v^2*cos(theta)*sin(theta)/g.
   //    Le temps que prendra le projectile à atteindre le sol
   //    est donné par la formule 2*v*sin(theta)/g.
   //
   //    Écrivez un programme qui demande la vitesse initiale du
   //    projectile v (en m/s) et l'angle de tir theta (en degrées
   //    ou en radians) et qui calcule la distance maximale de tir
   //    et le temps où le projectile touchera le sol.
   //
   //    La valeur de g est de 9,8. N'oubliez pas que les fonctions
   //    trigonométriques de la bibliothèque math utilisent des
   //    angles en radians.
   using System;
   using System.Globalization;
   namespace Exercice
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Préparer l'écran
               Console.WriteLine();
               Console.WriteLine("--------------------------------------------");
               Console.WriteLine("Exercice 2.7 : Distance de tir de projectile");
               Console.WriteLine("--------------------------------------------");
               //
               // Définir les variables
               const float g = 9.8f;
               const float pi = (float) Math.PI;
               float thetaDegrees;         // Angle de tir (degrées)
               float thetaRadian;          // Angle de tir (radians)
               float vitesse;              // Vitesse initiale du projectile
               float distance;             // Distance maximale de tir
               float temps;                // Temps du vol du projectile
               //
               // Saisir l'entrée
               Console.Write("Angle du tir (degrées 0..90) ? ");
               thetaDegrees = float.Parse(Console.ReadLine());
               if (thetaDegrees > 90 || thetaDegrees <0)
               {
                   Console.WriteLine("Angle incorrect !");
                   Console.WriteLine();
                   Environment.Exit(1);
               }
               Console.Write("Vitesse initiale du projectile (m/s) ? ");
               vitesse = float.Parse(Console.ReadLine());
               //
               // Faire les calculs et les conversions
               //   Formules
               //   thetaRadian = thetaDegrees * (pi/180)
               //   d = 2*v^2*cos(theta)*sin(theta)/g = v*t*cos(theta)
               //   t = 2*v*sin(theta)/g
               thetaRadian = thetaDegrees * (pi/180);
               temps = (2 * (float) Math.Pow(vitesse,2) * (float) Math.Sin(thetaRadian)) / g;
               distance = vitesse * temps * (float) Math.Cos(thetaRadian);
               //
               // Afficher le résultat
               Console.WriteLine("Distance de tir : " + distance.ToString("0.0") + " m");
               Console.WriteLine("Temps du vol    : " + temps.ToString("0.0") + " sec");
               Console.WriteLine();
           }
       }
   }

```

## Opérateurs

Le sujet dans le Référence sur C# par Microsoft

## Sélection (switch, case)

Modèle générale

```
switch (variable)
{
  case valeur_1 : ... ; break ;
  case valeur_2 : ... ; break ;
  default       : ... ; break ;
}

```

### Bloc d'exercices 3

#### Exercice 1

Écrire un programme C# demandant à l'utilisateur de saisir deux valeurs numériques a et b, un opérateur op (vérifier qu'il s'agit de l'une des valeurs suivantes : +;\*; /; -) de type alphanumérique, et qui affiche le résultat de l'opération a op b.

En C# :

```
static void Main ()
{
  float a,b;
  char op;
  //
  // Saisir l'entrée
  //
  Console.Write("Saisir la valeur a : ");
  a = float.Parse(Console.ReadLine());
  Console.Write("Saisir la baleur b : ");
  b = float.parse(Console.ReadLine());
  Console.Write("Saisir l'operateur : ");
  op = char.
}

```

#### Exercice 2

Une compagnie d'assurance effectue des remboursements sur lesquels est ponctionnée une franchise correspondant à 10% du montant à rembourser. Cependant, cette franchise ne doit pas excéder 4000 $. Demander à l'utilisateur de saisir le montant des dommages, afficher ensuite le montant qui sera remboursé ainsi que la franchise.

En C#

```
   // Exercice 3.2
   //    Une compagnie d'assurance effectue des remboursements sur lesquels est
   //    ponctionnée une franchise correspondant à 10% du montant à rembourser.
   //    Cependant, cette franchise ne doit pas excéder 4000 $. Demander à
   //    l'utilisateur de saisir le montant des dommages, afficher ensuite le
   //    montant qui sera remboursé ainsi que la franchise.
   using System;
   using System.Globalization;
   namespace Exercice
   {
       class Program
       {
           static void Main(string[] args)
           {
               //
               // Préparer l'écran
               //
               Console.WriteLine();
               Console.WriteLine("--------------------------------------------");
               Console.WriteLine("Exercice 3.2 : Franchise d'assurance");
               Console.WriteLine("--------------------------------------------");
               //
               // Définir les variables
               //
               float dommages;
               float franchise;
               float remboursement;                    // remboursement = dommages - franchise
               const float maxFranchise = 4000f;       //
               const float pourcentFranchise = 10f;    // Franchise = 10%, mais pas plus que 4000.00
               //
               // Saisir l'entrées
               //
               Console.Write("Montant des dommages ? ");
               dommages = float.Parse(Console.ReadLine());
               //
               // Faire les calculs et les conversions
               //
               // franchise = ((franchise = dommages * pourcentFranchise/100) > maxFranchise) ? maxFranchise : franchise;
               remboursement = dommages - (franchise = ((franchise = dommages * pourcentFranchise/100) > maxFranchise) ? maxFranchise : franchise);
               //
               // Afficher le résultat
               //
               Console.WriteLine("  Franchise =     " + franchise.ToString("0.00") + " CAD");
               Console.WriteLine("  Remboursement = " + remboursement.ToString("0.00") + " CAD");
               Console.WriteLine();
           }
       }
   }

```

#### Rencontre avec la responsable

Mme Martine Gervais (bureau 444)

Remplace Mme Charland.

### Bloc d'exercices 4

#### Exercice 4.5

```
 // Exercice 4.5
 //    Écrire un programme permettant de lire trois nombres et d’afficher le plus
 //    grand des trois. Nous prenons pour acquis que les nombres seront différents
 //    (vous n'avez pas à le valider).
 using System;
 using System.Globalization;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("---------------------------------------------------");
             Console.WriteLine("Exercice 4.5 : Min et max de 3 nombres");
             Console.WriteLine("---------------------------------------------------");
             //
             // Définir les variables
             //
             int max, min, tmp;
             string entree;
             //
             // Saisir l'entrées
             //
             Console.Write("Donnez trois nombres entiers (exemple : 1 2 3) ? ");
             entree = Console.ReadLine();
             //
             // Faire les calculs et les conversions
             //
             string[] tokens = entree.Split();                     // Separer les numéros
             int[] numeros = Array.ConvertAll(tokens, int.Parse);
             if (numeros.Length != 3)
             {
               Console.WriteLine("Erreur ! Seulement 3 numéros peuvent être acceptés.");
               Environment.Exit(1);
             }
             max = numeros[2] > (tmp = numeros[0] > numeros[1] ? numeros[0] : numeros[1]) ? numeros[2] : tmp;
             //
             // Afficher le résultat
             //
             Console.WriteLine("Le maximum = " + max);
             Console.WriteLine();
         }
     }
 }

```

#### Exercice 4.6

```
 // Exercice 4.6
 //    Écrire un programme permettant de lire le rayon d'un cercle, ainsi que le choix
 //    de l'utilisateur, et qui affiche :
 //    • Soit la circonférence du cercle ;
 //    • Soit la surface du cercle.
 //    Le choix de l'utilisateur est un chiffre (1 ou 2) qui a la signification suivante :
 //    • 1 pour la circonférence ;
 //    • 2 pour la surface.
 //    • Tout autre choix doit générer un message d'erreur.
 using System;
 using System.Globalization;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("---------------------------------------------------");
             Console.WriteLine("Exercice 4.6 : Circonférence ou surface d'un cercle");
             Console.WriteLine("---------------------------------------------------");
             //
             // Définir les variables
             //
             float  rayon;           // À obtenir d'utilisateur
             int    fonction;        // Choix d'une fonction à calculer
             float  resultat;        // Le paramètre calculé
             bool   erreur = false;  // Erreur d'entrée
             string[] menu = new string[] {"Circonférence (L = 2*Pi*r)", "Surface (S = Pi*r^2)"};
             //
             // Saisir l'entrées
             //
             Console.Write("Entrez le rayon du cercle ? ");
             rayon = float.Parse(Console.ReadLine());
             //
             // Menu
             //
             for (int i = 1; i <= menu.Length; i++)
             {
               Console.WriteLine("  [" + i + "] " + menu[i-1]);
             }
             Console.Write("Selectionnez le paramètre à calculer ? ");
             fonction = int.Parse(Console.ReadLine());
             //
             // Faire les calculs et les conversions
             //
             switch (fonction)
             {
               // Circonférence
               case 1 :
                 resultat = (float) (2 * Math.PI * rayon);
                 break;
               case 2 :
                 resultat = (float) (Math.PI * Math.Pow(rayon, 2));
                 break;
               default :
                 resultat = 0;
                 erreur = true;
                 break;
             }
             //
             // Afficher le résultat
             //
             if (erreur)
             {
               Console.WriteLine("Choix de fonction incorrect !");
             }
             else
             {
               Console.WriteLine("Le resultat = " + resultat.ToString("0.0"));
             }
             Console.WriteLine();
         }
     }
 }

```

#### Exercice 4.9

```
 // Exercice 4.9 : Trois modes de rémunération
 //  On donne à un vendeur les trois choix suivant :
 //    • un salaire fixe de 300 $ par semaine ;
 //    • un salaire fixe de 140 $ par semaine plus 10% de commission sur les ventes ;
 //    • 15% de commission sur les ventes.
 //  Écrire un programme permettant de lire :
 //    • Le montant des ventes du vendeur ;
 //  et d'afficher :
 //    • Le salaire qui lui reviendrait selon les choix a, b, c ;
 //    • Le meilleur choix.
 //  Votre programme devra donc calculer et afficher les trois salaires possibles,
 //  puis indiquer à l’usager quel est le meilleur choix (a, b ou c).
 using System;
 namespace Exercice
 {
   class Program
   {
     static void Main(string[] args)
     {
       // ----------------
       // Préparer l'écran
       // ----------------
       Console.WriteLine();
       Console.WriteLine("---------------------------------------------------");
       Console.WriteLine("Exercice 4.9 : Trois modes de rémunération");
       Console.WriteLine("---------------------------------------------------");
       // ---------------------
       // Définir les variables
       // ---------------------
       float[][] remuneration = new float[][] {          // Un array contenant les modes de rémunération
         new float[] {300, 0},                           // Chaque mode de rémunération est défini par 2 nombres :
         new float[] {140, 10},                          //  1) la base ($ par semaine) et 2) la commission (% de ventes)
         new float[] {0,   15}                           // Pour ajouter un mode de rémunération, ajoutez une ligne,
       };                                                //  ex : new float[] {base, pourcentage},
       float[] salaire = new float[remuneration.Length]; // Le montant du salaire pour chaque mode de rémunération
       float  ventes;
       // ------------------
       // Saisir les données
       // ------------------
       Console.Write("Saisissez le montant des ventes par semaine ($) ? ");
       ventes = float.Parse(Console.ReadLine());
       Console.WriteLine();
       // -----------------
       // Faire les calculs
       // -----------------
       // Calculer le salaire pour chaque mode de remuneration
       for (int i=1; i<=remuneration.Length; i++) {
         salaire[i-1] = remuneration[i-1][0] + (ventes * remuneration[i-1][1] / 100);
         Console.WriteLine("Mode de rémunération #" + i + " : $" + remuneration[i-1][0] + " par semaine et " + remuneration[i-1][1] + " % sur ventes = $" + salaire[i-1]);
       }
       // Trouver le mode le plus rentable
       int choix = 1;      // Choisir le 1e de le debut, et vérifier le reste
       for (int i=2; i<=remuneration.Length; i++) {
         if (salaire[choix-1] < salaire[i-1]) choix = i;
       }
       // --------------------
       // Afficher le résultat
       // --------------------
       Console.WriteLine();
       Console.WriteLine("Meilleur choix : mode de rémunération #" + choix);
       Console.ReadKey();
     }
   }
 }

```

#### Exercice 4.12

```
 // Exercice 4.12
 //    Écrire un programme  qui pour un pour un point P du plan détermine si ce point
 //    se trouve ou non à l'intérieur de la couronne de centre l'origine et définie
 //    par la donnée de son rayon extérieur r1 et son rayon intérieur r2.
 using System;
 using System.Globalization;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("------------------------------------------------");
             Console.WriteLine("Exercice 4.12 : Un point dans un cercle");
             Console.WriteLine("------------------------------------------------");
             //
             // Définir les variables
             //
             float rayon, x, y;
             float dcp;          // Distance du centre (0,0) au point, à calculer.
             bool  dedans;       // Est-ce que le point est dans le cercle ?
             bool  bingo;        // Est-ce que le point se trouve SUR le cercle ?
             //
             // Saisir l'entrées
             //
             Console.Write("Entrez le rayon du cercle ? ");
             rayon = float.Parse(Console.ReadLine());
             Console.Write("Entrez x du point ? ");
             x = float.Parse(Console.ReadLine());
             Console.Write("Entrez y du point ? ");
             y = float.Parse(Console.ReadLine());
             //
             // Faire les calculs et les conversions
             //
             dcp = (float) Math.Sqrt(Math.Pow(x, 2) + Math.Pow(y, 2));
             dedans = (rayon > dcp);
             bingo = (rayon == dcp);
             //
             // Afficher le résultat
             //
             if (dedans)
             {
               Console.WriteLine("[+] Le point (" + x.ToString("0.0") + "; " + y.ToString("0.0") + ") se trouve à l'interieur du cercle (r = " + rayon.ToString("0.0") + ").");
             }
             else if (bingo)
             {
               Console.WriteLine("[!] Le point (" + x.ToString("0.0") + "; " + y.ToString("0.0") + ") se trouve sur le cercle (r = " + rayon.ToString("0.0") + "), bingo !");
             }
             else
             {
               Console.WriteLine("[-] Le point (" + x.ToString("0.0") + "; " + y.ToString("0.0") + ") se trouve à l'exterieur du cercle (r = " + rayon.ToString("0.0") + ").");
             }
             Console.WriteLine();
         }
     }
 }

```

### Bloc d'exercices 5

#### Exercice 5.1

```
 // Exercice 5.1
 //    Créer un menu avec des sous-menus:
 //    Menu
 //    1) Cercle
 //      1.1) Surface
 //      1.2) Circonference
 //    2) Rectangle
 //      2.1) Surface
 //      2.2) Perimetre
 //    3) Triangle
 //      3.1) Surface
 //      3.2) Perimetre
 //    4) Sortie du programme
 using System;
 using System.Globalization;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("---------------------------------------------------");
             Console.WriteLine("Exercice 5.1 : Menu avec sous-menus pour figures");
             Console.WriteLine("---------------------------------------------------");
             //
             // Définir les variables
             //
             int      figure = 0;    // Pour le moment ça sert à rien, en fait
             int      fonction = 0;  // Pour le moment ça sert à rien, en fait
             float    rayon = 0;
             float[]  cotes = new float[] {0f, 0f, 0f};
             float    resultat = 0;
             string   resultat_name = "";
             string[] menu_principal = new string[] {
               "Sortie du programme",
               "Cercle",
               "Triangle",
               "Rectangle"};
             string[] menu_cercle = new string[] {
               "Retour au menu principal",
               "Circonférence (C = 2*Pi*r)",
               "Surface (S = Pi*r^2)"};
             string[] menu_triangle = new string[] {
               "Retour au menu principal",
               "Perimetre (pas encore programmé)",
               "Surface (pas encore programmé)"};
             string[] menu_rectangle = new string[] {
               "Retour au menu principal",
               "Perimetre (P = (a+b)*2)",
               "Surface (S = a*b)"};
             //
             // Saisir les données (menu)
             //
             int menu_principal_id = 0;        // Choix dans le menu principal
             do {  // Boucle du menu principal
               Console.WriteLine("\nMenu principal");
               for (int i = 1; i <= menu_principal.Length; i++)
               {
                 Console.WriteLine("  [" + (i-1) + "] " + menu_principal[i-1]);
               }
               do {  // Saisir l'entrée dans le menu principal
                 Console.Write("Selectionnez une figure ? ");
                 menu_principal_id = int.Parse(Console.ReadLine());
               } while (menu_principal_id < 0 || menu_principal_id > (menu_principal.Length - 1) );
               // Menu secondaire
               int menu_secondaire_id = 0;     // Choix dans les menus secondaires
               string[] menu_secondaire;
               string menu_secondaire_name = "";
               if (menu_principal_id != 0) { // Si le choix dans le menu principal n'est pas "Sortie"
                 string entree;
                 string[] tokens;
                 switch (menu_principal_id) {
                   case 1 :    // Circle
                     figure = 1;
                     menu_secondaire = menu_cercle;
                     menu_secondaire_name = "Circle";
                     Console.Write("\nEntrez le rayon du cercle ? ");
                     rayon = float.Parse(Console.ReadLine());
                     break;
                   case 2 :    // Triangle
                     figure = 2;
                     menu_secondaire = menu_triangle;
                     menu_secondaire_name = "Triangle";
                     Console.Write("\nEntrez les trois côtés du triangle (separés par espaces)? ");
                     entree = Console.ReadLine();
                     tokens = entree.Split();
                     cotes = Array.ConvertAll(tokens, float.Parse);
                     break;
                   case 3 :    // Rectangle
                     figure = 3;
                     menu_secondaire = menu_rectangle;
                     menu_secondaire_name = "Rectangle";
                     Console.Write("\nEntrez les deux côtés du rectangle (separés par espaces)? ");
                     entree = Console.ReadLine();
                     tokens = entree.Split();
                     cotes = Array.ConvertAll(tokens, float.Parse);
                     break;
                   default :   // Retour ou entrée invalide
                     menu_secondaire = menu_cercle;
                     break;
                 } // switch (menu_principal_id)...
                 do {  // Boucle du menu secondaire
                   // Montrer le menu secondaire
                   Console.WriteLine("\nMenu " + menu_secondaire_name);
                   for (int i = 1; i <= menu_secondaire.Length; i++)
                   {
                     Console.WriteLine("  [" + (i-1) + "] " + menu_secondaire[i-1]);
                   }
                   do {  // Saisir l'entrée dans le menu secondaire
                     Console.Write("Selectionnez une fonction ? ");
                     menu_secondaire_id = int.Parse(Console.ReadLine());
                   } while (menu_secondaire_id < 0 || menu_secondaire_id > (menu_secondaire.Length - 1) );
                   switch (menu_secondaire_id) {
                     case 1 :  // Circonference ou perimetre
                       fonction = 1; // Circonference
                       switch (figure) {
                         case 1 :  // Cercle
                           resultat_name = "Circonference du cercle (r " +rayon.ToString("0.0") + ")";
                           resultat = (float) (2 * Math.PI * rayon);
                           break;
                         case 2 : // Triangle
                           break;
                         case 3 : // Rectangle
                           resultat_name = "Perimètre du rectangle (a " + cotes[0].ToString("0.0") + "; b " + cotes[1].ToString("0.0") + ")";
                           resultat = (float) (2 * (cotes[0] + cotes[1]));
                           break;
                       } // switch (figure)...
                       break;
                     case 2 :  // Surface
                       fonction = 2; // Surface
                       switch (figure) {
                         case 1 : // Cercle
                           resultat_name = "Surface du cercle (r " + rayon + ")";
                           resultat = (float) (Math.PI * Math.Pow(rayon, 2));
                           break;
                         case 2 : // Triangle
                           break;
                         case 3 : // Rectangle
                           resultat_name = "Surface du rectangle (a " + cotes[0].ToString("0.0") + "; b " + cotes[1].ToString("0.0") + ")";
                           resultat = (float) (cotes[0] * cotes[1]);
                           break;
                       } // switch (figure)...
                       break;
                     default :
                       fonction = 0;
                       break;
                   } // switch (menu_secondaire_id)...
                   if (menu_secondaire_id != 0) {
                     // Finalement, le resultat !
                     Console.WriteLine("\n" + resultat_name + " = " + resultat.ToString("0.0"));
                     Console.ReadKey();
                   }
                 } while (menu_secondaire_id !=0);
               } // if (menu_principal_id != 0)...
             } while (menu_principal_id != 0);
             //
             // Faire les calculs et les conversions
             //
             //
             // Afficher le résultat
             //
             Console.WriteLine();
         }
     }
 }

```

## Expressions itératives

### Exercices

#### Exercice 6.0

```
 // Exercice 6.0
 //    L’expérimentation avec les boucles for, while et do ... while
 using System;
 using System.Globalization;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("--------------------------------------------------------------------------");
             Console.WriteLine("Exercice 6.0 : L'expérimentation avec les boucles for, while et do...while");
             Console.WriteLine("--------------------------------------------------------------------------");
             //
             // Définir les variables
             //
             //
             // Saisir les données (menu)
             //
             //
             // Faire les calculs et les conversions
             //
             // Boucle for
             Console.WriteLine("1. Boucle for (int i=1; i<5; i++)");
             int i = 0;
             for (i = 1; i < 5; i++) {
               Console.WriteLine("   Bonjour (i = " + i + ")");
             }
             Console.WriteLine("   N.B. La valeur de i après la boucle = " + i);
             // Boucle while
             Console.WriteLine("2. Boucle while (j<5)");
             int j = 1;
             while (j < 5) {
               Console.WriteLine("   Bonjour (j = " + j +")");
               j++;
             }
             Console.WriteLine("   N.B. La valeur de j après la boucle = " + j);
             // Boucle do...while
             Console.WriteLine("3. Boucle do...while (k<5)");
             int k = 1;
             do {
               Console.WriteLine("   Bonjour (k = " + k +")");
               k++;
             } while (k < 5);
             Console.WriteLine("   N.B. La valeur de k après la boucle = " + k);
             //
             // Afficher le résultat
             //
             Console.WriteLine();
             Console.ReadKey();
         }
     }
 }

```

#### Exercice 6.2 (3.2 dans les notes du cours)

```
 // Exercice 6.2 : Afficher les nombre pairs entre 2 et 50
 //    L’expérimentation avec les boucles for, while et do ... while
 using System;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("-----------------------------------------------------");
             Console.WriteLine("Exercice 6.2 : Afficher les nombre pairs entre a et b");
             Console.WriteLine("-----------------------------------------------------");
             //
             // Définir les variables
             //
             int debut = 2;
             int debutPair;
             int fin = 50;
             int[] numeros = {0, 0};
             //
             // Saisir les données (menu)
             //
             Console.Write("Saisissez deux nombres entiers a < b, séparés par un espace (ex.: 2 50) ? ");
             string entree = Console.ReadLine();                   // Lire les nombres
             string[] tokens = entree.Split();                     // Séparer les nombres
             numeros = Array.ConvertAll(tokens, int.Parse);
             debut = (numeros[0] < numeros[1] ? numeros[0] : numeros[1]);
             fin = (numeros[0] < numeros[1] ? numeros[1] : numeros[0]);
             if (debut % 2 == 0) {
               debutPair = debut;
             } else {
               debutPair = debut + 1;
             }
             //
             // Faire les calculs et les conversions
             //
             Console.Write("Nombres pairs entre " + debut + " et " + fin + " : ");
             for (int i = debutPair; i <= fin; i+=2) {
               Console.Write(i + " ");
             }
             Console.WriteLine();
             //
             // Afficher le résultat
             //
             Console.WriteLine();
         }
     }
 }

```

#### Exercice 6.5 (3.5 dans les notes du cours)

```
// Exercice 6.5 : Somme des nombres impairs entre a et b
//    L’expérimentation avec les boucles for, while et do ... while
using System;
namespace Exercice
{
   class Program
   {
       static void Main(string[] args)
       {
           //
           // Préparer l'écran
           //
           Console.WriteLine();
           Console.WriteLine("-----------------------------------------------------");
           Console.WriteLine("Exercice 6.5 : Somme des nombres impairs entre a et b");
           Console.WriteLine("-----------------------------------------------------");
           //
           // Définir les variables
           //
           int debut;
           int debutBoucle;
           int fin;
           int somme = 0;
           int[] numeros = {0, 0};
           //
           // Saisir les données (menu)
           //
           Console.Write("Saisissez deux nombres entiers a et b, séparés par un espace (ex.: 1 99) ? ");
           string entree = Console.ReadLine();                   // Lire les nombres
           string[] tokens = entree.Split();                     // Séparer les nombres
           numeros = Array.ConvertAll(tokens, int.Parse);
           debut = (numeros[0] < numeros[1] ? numeros[0] : numeros[1]);
           fin = (numeros[0] < numeros[1] ? numeros[1] : numeros[0]);
           if (debut % 2 == 1) {
             debutBoucle = debut;
           } else {
             debutBoucle = debut + 1;
           }
           //
           // Faire les calculs et les conversions
           //
           Console.Write("En trains de cumuler les nombres impairs entre " + debut + " et " + fin + " : ");
           for (int i = debutBoucle; i <= fin; i+=2) {
             Console.Write(i + ((i < fin) ? ", " : "."));
             somme = somme + i;
           }
           Console.WriteLine();
           //
           // Afficher le résultat
           //
           Console.WriteLine("La somme des nombres impairs entre " + debut + " et " + fin + " = " + somme);
           Console.WriteLine();
       }
   }
}

```

#### Exercice 6.6 (3.6 dans les notes du cours)

```
 // Exercice 6.6 : Somme des nombres impairs entre 77 et 7
 //    L’expérimentation avec les boucles for, while et do ... while
 using System;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("-----------------------------------------------------");
             Console.WriteLine("Exercice 6.6 : Somme des nombres impairs entre a et b");
             Console.WriteLine("-----------------------------------------------------");
             //
             // Définir les variables
             //
             int debut, fin;                                 // debut et fin du diapason
             int debutBoucle, finBoucle;                     // debut et fin de la boucle
             int signe;                                      // signe (+1 ou -1) des pas d’incrémentation
             int somme = 0;
             int[] numeros = {0, 0};
             //
             // Saisir les données (menu)
             //
             do {
               Console.Write("Saisissez deux nombres entiers a et b, séparés par un espace (ex.: 1 99 ou 77 7) ? ");
               string entree = Console.ReadLine();                   // Lire les nombres
               string[] tokens = entree.Split();                     // Séparer les nombres
               numeros = Array.ConvertAll(tokens, int.Parse);
             } while (numeros[0] == numeros[1]);                     // Éviter que les deux nombres soient les mêmes
             debut = numeros[0];
             fin = numeros[1];
             if (debut % 2 == 1) {
               debutBoucle = debut;
             } else {
               debutBoucle = debut + 1;
             }
             if (fin % 2 == 1) {
               finBoucle = fin;
             } else {
               finBoucle = fin - 1;
             }
             signe = (debut < fin) ? 1 : -1;
             //
             // Faire les calculs et les conversions
             //
             Console.Write("En trains de cumuler les nombres impairs entre " + debut + " et " + fin + " : ");
             for (int i = debutBoucle; (signe > 0 ? i <= finBoucle : i >= finBoucle); i=i+signe*2) {
               Console.Write(i + ((i != finBoucle) ? ", " : "."));
               somme = somme + i;
             }
             Console.WriteLine();
             //
             // Afficher le résultat
             //
             Console.WriteLine("La somme des nombres impairs entre " + debut + " et " + fin + " = " + somme);
             Console.WriteLine();
         }
     }
 }

```

#### Exercice 6.8 (3.8 dans les notes du cours)

```
 // Exercice 6.8 : Calcul des notes moyennes de plusieurs étudiants
 //    Vous devez calculer la moyenne des examens de 18 étudiants. Chaque étudiant
 //    a passé trois examens dont la note doit se situer entre 0 et 100 inclusivement.
 //    Si l'usager entre une note invalide, le programme doit recommencer la lecture de
 //    la note tant et aussi longtemps que la note n'est pas valide. Vous désirez obtenir
 //    pour chacun des étudiants sa moyenne aux examens, ainsi qu’un commentaire qui
 //    variera selon la moyenne obtenue (voir tableau ci-dessous). Vous devez aussi calculer
 //    et afficher la moyenne du groupe. Créez un programme permettant de résoudre ce
 //    problème.
 //    0 <= Moyenne < 60     Échec
 //    60 <= Moyenne < 70    Bien
 //    70 <= Moyenne < 85    Très bien
 //    85 <= Moyenne <= 100  Formidable
 using System;
 namespace Exercice
 {
     class Program
     {
         static void Main(string[] args)
         {
             //
             // Préparer l'écran
             //
             Console.WriteLine();
             Console.WriteLine("---------------------------------------------------------------");
             Console.WriteLine("Exercice 6.8 : Calcul des notes moyennes de plusieurs étudiants");
             Console.WriteLine("---------------------------------------------------------------");
             //
             // Définir les variables
             //
             int nombreEtudiants;
             int nombreExamens;
             int[][]  notes;
             float     moyenneEtudiant;
             float     moyenneGroupe;
             float     sommeEtudiant;
             float     sommeGroupe;
             const int noteMin = 0;
             const int noteMax = 100;
             //
             // Saisir les données (menu)
             //
             do {
               Console.Write("Saisissez le nombre d'étudiants ? ");
               nombreEtudiants = int.Parse(Console.ReadLine());
             } while (nombreEtudiants < 1);
             do {
               Console.Write("Saisissez le nombre d'examens ? ");
               nombreExamens = int.Parse(Console.ReadLine());
             } while (nombreExamens < 1);
             Console.WriteLine();
             notes = new int[nombreEtudiants][];                   // Créer un « array » pour les notes des étudiants...
             for (int etudiant = 1; etudiant <= nombreEtudiants; etudiant++) {
               bool donneesCorrect = true;
               do {
                 if (!donneesCorrect) {                                // Si les notes était incorrectes...
                   Console.WriteLine("^ Erreur ! Réessayez.");
                   donneesCorrect = true;
                 }
                 Console.Write("Étudiant " + etudiant + " : saisissez les " + nombreExamens + " notes (0..100), séparées pas espaces (ex.: 80 81...) ? ");
                 string entree = Console.ReadLine();                   // Lire une ligne de texte (string) avec les nombres
                 string[] tokens = entree.Split();                     // Séparer les nombres
                 notes[etudiant-1] = Array.ConvertAll(tokens, int.Parse);     // ...et remplir l'array avec les... notes entrées
                 for (int note = 1; note <= nombreExamens; note++) {                // Vérifier si les notes entrées sont entre 0 et 100
                   donneesCorrect = (notes[etudiant-1][note-1] >= noteMin && notes[etudiant-1][note-1] <= noteMax);
                 } // for (int j)
               } while (!donneesCorrect);
             } // for (int i)
             //
             // Faire les calculs et les conversions
             //
             Console.WriteLine();
             sommeGroupe = 0;
             for (int etudiant = 1; etudiant <= nombreEtudiants; etudiant++) {             // Pour chaque etudiant...
               sommeEtudiant = 0;
               for (int note = 1; note <= nombreExamens; note++) {
                 sommeEtudiant+=notes[etudiant-1][note-1];
               } // for (note)
               moyenneEtudiant = sommeEtudiant / nombreExamens;
               sommeGroupe+=moyenneEtudiant;
               Console.WriteLine("Note moyenne de l'étudiant " + etudiant + " = " + moyenneEtudiant.ToString("0.0"));
             } // for (etudiant)
             moyenneGroupe = sommeGroupe / nombreEtudiants;
             //
             // Afficher le résultat
             //
             Console.WriteLine("Note moyenne du groupe = " + moyenneGroupe.ToString("0.0"));
             Console.WriteLine();
         }
     }
 }

```

## Révision avant l'examen 1

### Exercices 7

#### Exercice 7.1

```
// Exercice 7, question 1
//    Taras Ivasyk (2018-07-10)
//    Conteur des symboles dans un texte
//    Saisir une ligne terminant avec * et conter A
using System;
using System.Globalization;
namespace Exercice
{
   class Program
   {
       static void Main(string[] args)
       {
           //
           // Préparer l'écran
           //
           Console.WriteLine();
           Console.WriteLine("------------------------------------------------------------");
           Console.WriteLine("Exercice 7.1 : Saisir une ligne terminant avec * et conter A");
           Console.WriteLine("------------------------------------------------------------");
           //
           // Définir les variables et les constantes
           //
           string ligneTexte = "";
           char finChar = '*';
           char chercheChar = 'A';
           int  conteur = 0;
           //
           // Saisir les données
           //
           Console.Write("Saisissez une ligne terminant pas * : ");
           ConsoleKeyInfo key;
           do {
             key = Console.ReadKey(true);
             ligneTexte = ligneTexte + key.KeyChar.ToString();
             Console.Write(key.KeyChar);
           } while (key.KeyChar != finChar);
           Console.WriteLine();
           //
           // Faire les calculs et les conversions
           //
           for (int i = 1; i <= ligneTexte.Length; i++) {
             if (ligneTexte[i-1] == chercheChar) conteur++;
           }
           //
           // Afficher le résultat
           //
           Console.WriteLine();
           Console.WriteLine("On trouve «" + chercheChar.ToString() + "» " + conteur + " fois dans votre texte.");
           Console.WriteLine();
       }
   }
}

```

## Fonctions

### Exercices 4.x

#### Exercice 4.4

```
   // Exercice 8.4 (fonctions 4.4)
   // Taras Ivasyk (2018-08-10)
   using System;
   namespace Exercice
   {
       class Program
       {
           //
           // Définitions des variables globales
           //
           static string exerciseNo =      "8.4";
           static string exerciseTitle =   "Fonctions Factorielle(), Somme_N() et Somme_N_P()";
           static string exerciseAuthor =  "Taras Ivasyk";
           static string exerciseDate =    "2018-08-10" ;
           //
           // La fonction Main()
           //
           static void Main(string[] args) {
               // Info sur l'exercice
               PrepScreen(exerciseNo, exerciseTitle, exerciseAuthor, exerciseDate);
               // Calculs et résultats
               Console.WriteLine("Juste un teste (1..10) :");
               for (int i = 1; i <= 10; i++) {
                   Console.WriteLine(" la somme 1..{0} est {2}, la somme 1..{0}^2 est {3}, et la factorielle de {0} est {1}", i, Factorielle(i), Somme_N(i), Somme_N_P(i, 2));
               }
               Console.WriteLine();
           }
           //
           // Définitions des fonctions
           //
           // Préparer l'écran avec l'info sur l'exercice
           public static void PrepScreen(string number, string title, string author, string date) {
               //
               // On construit le texte avec les info sur l'exercice
               string[] exerciseInfo = new string[] {
                   "Exercice " + number + " : " + title,
                   author + " (" + date + ")"};
               //
               // On imprime les informations sur l'exercice
               Console.WriteLine(new string('-', exerciseInfo[0].Length));
               for (int i = 1; i <= exerciseInfo.Length; i++) {
                   Console.WriteLine(exerciseInfo[i-1]);
               }
               Console.WriteLine(new string('-', exerciseInfo[0].Length));
               Console.WriteLine();
           }
           // Calculer la factirielle d'un nombre entier et positif
           public static double Factorielle(int nombre) {
               double factorial = 1;
               if (nombre >= 0) {
                   for (int i = 1; i <= nombre; i++) {
                       factorial *= i;
                   }
               } else if (nombre < 0) {
                   factorial = -1;
               }
               return factorial;
           }
           // Calculer la somme de 1..nombre
           public static double Somme_N(int nombre) {
               double somme = 0;
               for (int i = 1; i <= nombre; i++) {
                   somme += i;
               }
               return somme;
           }
           // Calculer la somme de 1..nombre^puissance
           public static double Somme_N_P(int nombre, int puissance){
               double somme = 0;
               for (int i = 1; i <= nombre; i++) {
                   somme += Math.Pow(i, puissance);
               }
               return somme;
           }
       }
   }

```

#### Exercice 4.5

```
   using System;
   namespace Exercice
   {
       class Program
       {
           //
           // Définitions des variables globales
           //
           static string exerciseNo =      "8.5 (4.5)";
           static string exerciseTitle =   "Fonctions unites(), dizaines(), extrait(), nbChiffres() et sommeChiffres()";
           static string exerciseAuthor =  "Taras Ivasyk";
           static string exerciseDate =    "2018-08-10" ;
           //
           // La fonction Main()
           //
           static void Main(string[] args) {
               //
               // Info sur l'exercice
               PrepScreen(exerciseNo, exerciseTitle, exerciseAuthor, exerciseDate);
               //
               // Calculs et résultats
               int nombre = 12345;
               Console.WriteLine("Le nombre {0} est composé de {1} chiffres, la somme de chiffres est {2}.", nombre, nbChiffres(nombre), sommeChiffres(nombre));
               //
               // Extrait du p-ième chiffre en utilisant conversion en texte
               Console.WriteLine("Dans {0} il y a {1} milles, {2} centaines, {3} dizaines et {4} unités.",
                   nombre, extrait(nombre, 4), extrait(nombre, 3), extrait(nombre, 2), extrait(nombre, 1) );
               // Extrait du p-ième chiffre en utilisant division et modulo
               Console.WriteLine("Et si on utilisait division et modulo... {0} milles, {1} centaines, {2} dizaines et {3} unités", extraitModulo(nombre, 4), extraitModulo(nombre, 3), extraitModulo(nombre, 2), extraitModulo(nombre, 1) );
               //
               // Quelque testes
               Console.WriteLine("Teste : extrait({0}, 0) = {1}", nombre, extrait(nombre, 0));
               Console.WriteLine("Teste : extraitModulo({0}, 0) = {1}", nombre, extraitModulo(nombre, 0));
               Console.WriteLine();
           }
           //
           // Définitions des fonctions
           //
           // Préparer l'écran avec l'info sur l'exercice
           public static void PrepScreen(string number, string title, string author, string date) {
               //
               // On construit le texte avec les info sur l'exercice
               string[] exerciseInfo = new string[] {
                   "Exercice " + number + " : " + title,
                   author + " (" + date + ")"};
               //
               // On imprime les informations sur l'exercice
               Console.WriteLine(new string('-', exerciseInfo[0].Length));
               for (int i = 1; i <= exerciseInfo.Length; i++) {
                   Console.WriteLine(exerciseInfo[i-1]);
               }
               Console.WriteLine(new string('-', exerciseInfo[0].Length));
               Console.WriteLine();
           }
           // unites() ― retourne le chiffre des unités du nombre
           static int unites(int number) {
               return extrait(number, 1);
           }
           // dizaines () ― retourne le chiffre des dizaines du nombre
           static int dizaines(int number) {
               return extrait(number, 2);
           }
           // extrait() ― retourne le p-ième chiffre de représentation décimale de n (en partant des unités)
           static int extrait( int number, int position) {
               string numberText = number.ToString();
               if (position > numberText.Length || position < 1) {
                   // Si le nombre est trop court... retourne 0
                   return 0;
               } else {
                   // Il y a assez de chiffres, il faut chercher le p-ième
                   return Int32.Parse(numberText[numberText.Length-position].ToString());
               }
           }
           static int extraitModulo(int number, int position) {
               // Cette version utilise les opérations de division et de modulo
               // pour trouver le p-ième chiffre d'un nombre, plutôt que
               // convertir le nombre en ligne de texte

               return position > 0 ? (number / (int) Math.Pow(10, position-1)) % 10 : 0;
           }
           // nbChiffres() ― retourne le nombre de chiffres que comporte la représentation décimale du nombre
           static int nbChiffres(int number) {
               return number.ToString().Length;
           }
           // sommeChiffres() ― retourne la somme des chiffres du nombre
           static int sommeChiffres(int number) {
               int somme = 0;
               for (int i = 1; i <= nbChiffres(number); i++) {
                   somme += extrait(number, i);
               }
               return somme;
           }
       }
   }

```

## Tableaux (arrays) ====== Exercices ==

```
   using System;
   namespace Exercice
   {
       class Program
       {
           //
           // Définitions des variables globales
           //
           static string exerciseNo =      "9.1 (5.1)";
           static string exerciseTitle =   "Tableaux et fonctions pour les traiter";
           static string exerciseAuthor =  "Taras Ivasyk";
           static string exerciseDate =    "2018-08-14" ;
           //
           // La fonction Main()
           //
           static void Main(string[] args) {
               //
               // Info sur l'exercice
               PrepScreen(exerciseNo, exerciseTitle, exerciseAuthor, exerciseDate);
               //
               // Exercice 4 : Initialisation et affichage
               //
               Console.WriteLine("Exercice 4 : Initialisation et affichage");
               int[] T = new int[] {1,2,3,4,5,6,7,8,9,10};
               Console.WriteLine("Le tableau T : {0}", afficherTableau(T));
               Console.WriteLine();
               //
               // Exercice 5 : Initialisation avec une boucle
               //
               Console.WriteLine("Exercice 5 : Initialisation avec une boucle");
               for (int i = 0; i < T.Length; i++) {
                   T[i] = i + 1;       // Initialiser avec 1..
               }
               Console.WriteLine("Le tableau T : {0}", afficherTableau(T));
               Console.WriteLine();
               //
               // Exercice 6 : calculerSommeElements()
               //
               Console.WriteLine("Exercice 6 : Fonction calculerSommeElements()");
               Console.WriteLine("La somme des éléments du tableau T = {0}", calculerSommeElements(T));
               Console.WriteLine();
               //
               // Exercice 7 : calculerMoyenneElements()
               //
               Console.WriteLine("Exercice 7 : Fonction calculerMoyenneElements()");
               Console.WriteLine("La moyenne des éléments du tableau T = {0}", calculerMoyenneElements(T));
               Console.WriteLine();
               //
               // Exercice 8 : trouverElement()
               //
               Console.WriteLine("Exercice 8 : Fonction trouverElement()");
               Console.WriteLine("Cherchons 6 dans le tableau T : {0}", trouverElement(T, 6) ? "trouvé !" : "il n'y est pas.");
               Console.WriteLine("Cherchons 42 dans le tableau T : {0}", trouverElement(T, 42) ? "trouvé !" : "il n'y est pas.");
               Console.WriteLine();
               //
               // Exercice 9 : sontEgaux()
               //
               Console.WriteLine("Exercice 9 : Fonction sontEgaux()");
               int[] T2 = new int[] {1,2,3,4,5,6,7,8,9,10};
               int[] T3 = new int[] {10,9,8,7,6,5,4,3,2,1};
               Console.WriteLine("Le tableau T2 : {0} ({1})", afficherTableau(T2), (sontEgaux(T, T2) ? "égal à T" : "pas égal à T"));
               Console.WriteLine("Le tableau T3 : {0} ({1})", afficherTableau(T3), (sontEgaux(T, T3) ? "égal à T" : "pas égal à T"));
               Console.WriteLine();
               //
               // Exercice 10 : permuterDroite() - version qui utilise deux tableaux
               //
               Console.WriteLine("Exercice 10 : Permutation circulaire à droite qui utilise deux tableaux");
               int[] T4 = new int[T2.Length];
               permuterDroite(T2, T4);
               Console.WriteLine("Le tableau T4 après la permutation du tableau T2 : {0}", afficherTableau(T4));
               permuterDroite(T4, T2);
               Console.WriteLine("Le tableau T2 après la permutation du tableau T4 : {0}", afficherTableau(T2));
               Console.WriteLine();
               //
               // Exercice 11 : permuterDroite() - version sans deuxième tableau
               //
               Console.WriteLine("Exercice 11 : Permutation circulaire à droite sans deuxième tableau");
               for (int i = 1; i < 3; i++) {
                   permuterDroite(T2);
                   Console.WriteLine("Le tableau T2 après {0}-e permutation : {1}", i, afficherTableau(T2));
               }
               Console.WriteLine();
               //
               // Exercice 12 : Miroir
               //
               Console.WriteLine("Exercice 12 : Miroir d'un tableau");
               Console.WriteLine("Le tableau T3 avant le miroir : {0}", afficherTableau(T3));
               miroirTableau(T3);
               Console.WriteLine("Le tableau T3 après le miroir : {0}", afficherTableau(T3));
               int[] T5 = new int[] {1,2,3,4,5};
               Console.WriteLine("Le tableau T5 avant le miroir : {0}", afficherTableau(T5));
               miroirTableau(T5);
               Console.WriteLine("Le tableau T5 après le miroir : {0}", afficherTableau(T5));
               Console.WriteLine();
               //
               // Exercice 13 : Modification du tableau
               //
               Console.WriteLine("Exercice 13 : Modification d'un tableau");
               Array.Resize(ref T, 20);
               for (int i = 0; i < T.Length; i++) {
                   T[i] = (int)Math.Pow(i, 2) % 17;
               }
               Console.WriteLine("Le tableau T a la taille de 20 maintenant : {0}", afficherTableau(T));
               Console.WriteLine();
               //
               // Exercice 14 : Min/max d'un tableau
               //
               Console.WriteLine("Exercice 14 : Min/max d'un tableau");
               Console.WriteLine("L'élément min du tableau T = {0}, l'élément max = {1}", minTableau(T), maxTableau(T));
               Console.WriteLine();
               //
               // Exercice 15 : Recherche séquentielle
               //
               Console.WriteLine("Exercice 15 : Recherche séquentielle");
               Console.Write("Entrez un élément à chercher dans le tableau T : ");
               int element = int.Parse(Console.ReadLine());
               if (nombreOccurences(T, element) > 0) {
                   Console.Write("Il y a {0} occurences de {1} dans le tableau T : ", nombreOccurences(T, element), element);
                   for (int j = 1; j <= nombreOccurences(T, element); j++) {
                       Console.Write("T[{0}]{1}", indiceOccurence(T, element, j), (j < nombreOccurences(T, element) ? ", " : "."));
                   }
                   Console.WriteLine();
               } else {
                   Console.WriteLine("On ne trouve pas de {0} dans le tableau T", element);
               }
               Console.WriteLine();
               //
               // Exercice 16 : Recherche séquentielle avec stockage des indices
               //
               Console.WriteLine("Exercice 16 : Recherche séquentielle avec stockage des indices");
               Console.Write("Entrez un autre élément à chercher dans le tableau T : ");
               element = int.Parse(Console.ReadLine());
               if (nombreOccurences(T, element) > 0) {
                   int[] Q = new int[nombreOccurences(T, element)];
                   for (int j = 1; j <= nombreOccurences(T, element); j++) {
                       Q[j-1] = indiceOccurence(T, element, j);
                   }
                   Console.WriteLine("La valeur {0} se trouve aux indices suivantes : {1}", element, afficherTableau(Q));
               } else {
                   Console.WriteLine("La valeur {0} n'a pas été trouvée dans le tableau T", element);
               }
               Console.WriteLine();
               //
               // Pause avant de sortir
               //
               Console.Write("Pressez une touche pour finir...");
               Console.ReadKey();
               Console.WriteLine();
           } // Main()
           //
           // Définitions des fonctions
           //
           static string afficherTableau(int[] tableau) {
               // Construire une ligne de texte avec tous les elements du tableau en une seule ligne
               // en les séparant par virgules.
               string ligne = "";
               for (int i = 0; i < tableau.Length; i++) {
                   ligne = ligne + tableau[i] + (i < tableau.Length - 1 ? ", " : "");
               }
               return ligne;
           }
           static int calculerSommeElements(int[] tableau) {
               int somme = 0;
               if (tableau.Length > 0) {
                   for (int i = 0; i < tableau.Length; i++) {
                       somme += tableau[i];
                   }
               }
               return somme;
           }
           static float calculerMoyenneElements(int[] tableau) {
               float moyenne = 0;
               if (tableau.Length > 0) {
                   moyenne = calculerSommeElements(tableau) / tableau.Length;
               }
               return moyenne;
           }
           static bool trouverElement(int[] tableau, int element) {
               bool trouve = false;
               if (tableau.Length > 0) {
                   for (int i = 0; i < tableau.Length; i++) {
                       // trouve = (tableau[i] == element || trouve);      // Ça marche au lieux de l'if() suivant
                       if (tableau[i] == element) {
                           trouve = true;
                       }
                   }
               }
               return trouve;
           }
           static bool sontEgaux(int[] tableau1, int[] tableau2) {
               if (tableau1.Length != tableau2.Length) {
                   return false;
               } else {
                   for (int i = 0; i < tableau1.Length; i++) {
                       if (tableau1[i] != tableau2[i]) {
                           return false;
                       }
                   }
               }
               return true;
           }
           static void permuterDroite(int[] tableau) {
               // Version sans utiliser deux tableaux
               if (tableau.Length > 0) {
                   int temp = tableau[tableau.Length - 1];
                   for (int i = tableau.Length - 2; i >= 0; i--) {
                       tableau[i + 1] = tableau[i];
                   }
                   tableau[0] = temp;
               }
           }
           static void permuterDroite(int[] tableau1, int[] tableau2) {
               // Version qui utilise deux tableau
               if (tableau1.Length > 0 && tableau1.Length == tableau2.Length) {
                   for (int i = 0; i <= tableau1.Length - 2; i++) {
                       tableau2[i+1] = tableau1[i];
                   }
                   tableau2[0] = tableau1[tableau1.Length-1];
               }
           }
           static void miroirTableau(int[] tableau) {
               if (tableau.Length > 0) {
                   int temp;
                   for (int i = 0; i < tableau.Length / 2; i++) {
                       temp = tableau[i];
                       tableau[i] = tableau[tableau.Length - 1 - i];
                       tableau[tableau.Length - 1 - i] = temp;
                   }
               }
           }
           static int minTableau(int[] tableau) {
               int min = 0;
               if (tableau.Length > 0) {
                   min = tableau[0];
                   for (int i = 1; i < tableau.Length; i++) {
                       if (tableau[i] < min) {
                           min = tableau[i];
                       }
                   }
               }
               return min;
           }
           static int maxTableau(int[] tableau) {
               int max = 0;
               if (tableau.Length > 0) {
                   max = tableau[0];
                   for (int i = 1; i < tableau.Length; i++) {
                       if (tableau[i] > max) {
                           max = tableau[i];
                       }
                   }
               }
               return max;
           }
           static int nombreOccurences(int[] tableau, int element) {
               int occurences = 0;
               if (tableau.Length > 0) {
                   for (int i = 0; i < tableau.Length; i++) {
                       if (tableau[i] == element) {
                           occurences++;
                       }
                   }
               }
               return occurences;
           }
           static int indiceOccurence(int[] tableau, int element, int occurence) {
               int indice = -1;
               if (tableau.Length > 0 && occurence > 0 && occurence <= nombreOccurences(tableau, element)) {
                   int found = 0;
                   for (int i = 0; found < occurence; i++) {
                       if (tableau[i] == element) {
                           found++;
                           indice = i;
                       }
                   }
               }
               return indice;
           }
           //
           // Fonction pour préparer l'écran avec l'info sur l'exercice
           //
           static void PrepScreen(string number, string title, string author, string date) {
               //
               // On construit le texte avec les info sur l'exercice
               string[] exerciseInfo = new string[] {
                   "Exercice " + number + " : " + title,
                   author + " (" + date + ")"};
               //
               // On imprime les informations sur l'exercice
               Console.WriteLine(new string('-', exerciseInfo[0].Length));
               for (int i = 1; i <= exerciseInfo.Length; i++) {
                   Console.WriteLine(exerciseInfo[i-1]);
               }
               Console.WriteLine(new string('-', exerciseInfo[0].Length));
               Console.WriteLine();
           } // PrepScreen()
       } // class Program
   } // namespace Exercice

```