420-SF1-RE – Introduction à la programmation

Je corrige les programmes en appliquant des codes de correction. Vous trouverez ici la liste des codes les plus fréquents.

Ma stratégie de correction en tant que telle (pour le code, à tout le moins) est résumée ici.

Cliquez sur cette cible pour un résumé des principales règles de programmatique en vigueur dans ce cours.

Cliquez sur cette cible pour les normes appliquées dans ce cours, en ce qui a trait au pseudocode

22 août

Au menu :

• Présentation du cours et du plan de cours
• Premiers pas avec les séquences et le pseudocode (et même une touche de code C#, pour le plaisir)
• Présentation du laboratoire 00 : remettre un document

À faire au plus tôt :

• Laboratoire 00 : remettre un document

25 août

Au menu :

• Structures de contrôle (première partie) : la séquence
  • Voir ../../../Sujets/Bases/sequence.html pour un rappel
• Suites de nos premiers contacts avec le pseudocode
• Introduction plus formelle du type float, pour représenter des nombres à virgule flottante
• Première mention formelle du type int, pour représenter des nombres entiers
• Retour sur les règles de nomenclature applicables dans le cours :
  • comment exprimer un nom de variable
  • comment exprimer un nom de constante
  • pourquoi limiter les noms en majuscules aux constantes
  • comment séparer des mots dans un nom de variable?
  • comment séparer des mots dans un nom de constante?
• Quelques éléments de vocabulaire :
  • Mention de noms et de préfixes utilisés pour nommer des quantités, particulièrement en informatique : bit, byte, octet, de même que les préfixes kilo (considéré par certains comme valant 1000, et par la plupart des informaticien(ne)s comme valant 1024), méga, giga et téra
• Introduction à la conception logicielle (module 01 des notes de cours)
• Quelques éléments de culture, incluant :
  • Une très brève mention d'Alan Turing, un personnage important pour nous, et diverses considérations historiques
  • J'ai glissé un mot sur Kurt Gödel et sur David Hilbert, entre autres
• Quelques exercices
• Présentation du laboratoire 01 : conversion de volumes

À faire pour S02 :

• Se familiariser avec l'introduction à la conception logicielle (module 01 des notes de cours)
• Pour vous aider, commencer à lire le module 02 des notes de cours
• Laboratoire 01 : conversion de volumes (analyse, pseudocode, jeux d'essai)

29 août

Au menu :

• Détail technique : le mot-clé using de C# (avec exemples dans Visual Studio et dans dotnetfiddle pour illustrer une subtilité)
• Retour sur le laboratoire 00
• Algorithmes et codification (module 02 des notes de cours)
• Toute petite introduction au débogueur
  • Pas à pas détaillé
  • Points d'arrêt
  • Examen du changement d'état de certaines variables

Exercices en classe :

• Exercice sur la conversion de °F à °C (pseudocode, C#, solutionnaire)
• Exercice sur la permutation de valeurs, avec plusieurs solutions distinctes, et brève discussion des mérites de chacune (pseudocode, trace, jeux d'essai, solutionnaire)

À remettre :

• Laboratoire 01 : conversion de volumes (analyse, pseudocode, jeux d'essai)

string nom;
int âge;
Console.Write("Nom? ");
nom = Console.ReadLine();
Console.Write("Âge? ");
âge = int.Parse(Console.ReadLine());
Console.Write("Bonjour, ");
Console.Write(nom);
Console.Write(" qui a ");
Console.Write(âge);
Console.WriteLine(" ans");

string nom;
int âge;
Console.Write("Nom? ");
nom = Console.ReadLine();
Console.Write("Âge? ");
âge = int.Parse(Console.ReadLine());
Console.WriteLine("Bonjour, {0} qui a {1} ans", nom, âge);

string nom;
int âge;
Console.Write("Nom? ");
nom = Console.ReadLine();
Console.Write("Âge? ");
âge = int.Parse(Console.ReadLine());
Console.WriteLine($"Bonjour, {nom} qui a {âge} ans");

1 sept.

Au menu :

• Discussions sur le laboratoire 01
  • explication de mes pratiques de correction
  • explication de mes codes de correction
• Préciser ce qui constitue ou non un intrant (ou : que signifie la primitive Lire du pseudocode?)
• Retour sur les règles de nomenclature applicables dans le cours :
  • comment exprimer un nom de variable
  • comment exprimer un nom de constante
  • pourquoi limiter les noms en majuscules aux constantes
  • comment séparer des mots dans un nom de variable?
  • comment séparer des mots dans un nom de constante?
• Retour sur le fait que deux noms différents dénotent deux objets distincts
• Nombres à virgule flottante : utiliser le '.' ou la ','?
• Types string, int, float et double
• Suites de la section Algorithmes et codification (module 02 des notes de cours)
• Sondage SPEC
• Présentation du laboratoire 02 : pizza! (analyse, pseudocode, code C#, jeux d'essai)

À faire pour S04 :

• Laboratoire 02 : pizza! (analyse, pseudocode, code C#, jeux d'essai)

5 sept.

Au menu :

• Bref regard sur le transtypage, ou comment forcer le compilateur transformer une valeur d'un type vers un autre type – nous n'avons pas exploré formellement la chose, cela dit; nous l'avons mentionné et utilisé, sans plus, mais nous y reviendrons
• Expressions arithmétiques, séquences et fonctions (module 03 des notes de cours)
• Survol des fonctions mathématiques de C#
  • aujourd'hui, nous limiterons notre démarche à l'utilisation de fonctions; évidemment, dans quelques séances, nous rédigerons nos propres fonctions
• Services des types de C#
  • méthode Parse
  • méthode ToString
  • certaines constantes telles que MinValue, MaxValue et (pour les nombres à virgule flottante) Epsilon
• Survol de la structure interne des nombres entiers
• Exercices

8 sept.

Au menu :

• Quelle police choisir pour le code et pour le pseudocode?
• Que faire quand les lignes sont trop longues?
• Une manière plus simple d'écrire quelque chose comme "------------------------------"
• Débordements et leur effet (en utilisant un bloc checked... ne faites pas ça à la maison!)

Lire fahr
cels ← ConvertirFahrÀCels(fahr)
Écrire cels

ConvertirFahrÀCels(degFahr)
   SEUIL_GEL_EAU ← 32
   degCels ← (degFahr - SEUIL_GEL_EAU) * 5 / 9
   Retourner degCels

// quelques using (omis par souci d'économie)
namespace VOTRE_NAMESPACE
{
   internal class Sf1
   {
   }
}

// quelques using (omis par souci d'économie)
namespace VOTRE_NAMESPACE
{
   static class Sf1
   {
   }
}

// quelques using (omis par souci d'économie)
namespace VOTRE_NAMESPACE
{
   static class Sf1
   {
      public static float ConvertirFahrÀCels(float degFahr)
      {
         const int SEUIL_GEL_EAU = 32;
         float degCels;
         degCels = (degFahr - SEUIL_GEL_EAU) * 5 / 9;
         return degCels;
      }

      public static int CalculerSomme(int nb0, int nb1)
      {
         int somme;
         somme = nb0 + nb1;
         return somme;
      }
   }
}

using static VOTRE_NAMESPACE.Sf1;

Console.WriteLine($"La somme de 2 et 3 est... {CalculerSomme(2,3)}");

float fahr,
      cels;
Console.Write("Température en degrés Fahrenheit? ");
fahr = float.Parse(Console.ReadLine());
cels = ConvertirFahrÀCels(fahr);
Console.WriteLine($"Équivalent en degrés Celsius : {cels}");
Console.WriteLine("En passant, 32 fahr vaut... ");
cels = ConvertirFahrÀCels(32);
Console.WriteLine($"{cels} cels");

• Présentation du laboratoire 03 : APOO volet plongeon (analyse, pseudocode, code C#, jeux d'essai)

À remettre :

• Laboratoire 02 : pizza! (analyse, pseudocode, code C#, jeux d'essai)

À faire :

• Travail sur le laboratoire 03 : APOO volet plongeon (analyse, pseudocode, code C#, jeux d'essai)

12 sept.

Au menu :

• Retour sur le laboratoire 02
  • positionnement des déclarations de variables en C# et prudence en pseudocode
  • afficher une ligne vide?
  • rappel sur la lisibilité
• Introduction à l'approche que l'on nomme le développement graduel (approche Top-Down), module 04 des notes de cours
• Fonctions en pseudocode
  • paramètres passés par valeur
  • variables locales
  • retour
• Fonctions en C#
  • paramètres passés par valeur
  • variables locales
  • retour
• Diagramme hiérarchique

À faire :

• Travail sur le laboratoire 03 : APOO volet plongeon (analyse, pseudocode, code C#, jeux d'essai)

15 sept.

Au menu :

• Premier contact sommaire avec les alternatives, chapitre 05 des notes de cours
• Structures alternatives (bases)
• Présentation du laboratoire 04 : introduction aux fonctions
• Nous allons piger un peu dans la matière de la prochaine séance pour prendre un peu d'avance, mais cette matière ne sera pas applicable au laboratoire 04

À remettre :

• Laboratoire 03 : APOO volet plongeon (analyse, pseudocode, code C#, jeux d'essai)

À faire :

• Laboratoire 04 : introduction aux fonctions

19 sept.

Au menu :

• Premier contact avec les alternatives complexes, chapitre 06 des notes de cours
• Structures alternatives plus complexes :
  • forme imbriquée
  • balancement des formes imbriquées
  • forme empilée
  • évaluation superficielle de la complexité des programmes contenant une alternative

À faire :

• Laboratoire 04 : introduction aux fonctions

22 sept.

Au menu :

• Fonctions prédicats
• Exercices
• Présentation du laboratoire 05 : APOO volet cartésien

À remettre :

• Remettre la partie imprimée du laboratoire 04 : fonctions assorties (analyse, pseudocode, code C#)

À faire :

• Travail sur le laboratoire 05 : APOO volet cartésien (code C#)

26 sept.

Au menu :

• Quelques messages d'erreurs typiques de programmes qui se compliquent, et comment les déchiffrer
  • « Tous les chemins ne retournent pas une valeur »
  • « Utilisation d'une variable non-assignée »
• Introduction à la logique et aux répétitives, modules 06 et 07 des notes de cours
• Petits bonbons syntaxiques :
  • autoincrémentation (++cpt et cpt++) et autodécrémentation (--cpt et cpt--)
  • variantes modifiantes de certains opérateurs (p. ex. : x += y; au lieu de x = x + y;)

À faire :

• Travail sur le laboratoire 05 : APOO volet cartésien (code C#)

13 oct.

Au menu :

• Chic examen intra plein d'amour!

17 oct.

Au menu :

• Retour sur l'intra
• Fonctions void
• Variantes de la répétitive classique
  • Boucle for
  • Boucle do ... while
• Petits bonbons syntaxiques :
  • autoincrémentation (++cpt et cpt++) et autodécrémentation (--cpt et cpt--)
  • variantes modifiantes de certains opérateurs (p. ex. : x += y; au lieu de x = x + y;)

• Présentation du laboratoire 06 : introduction aux répétitives

À faire :

• Travail sur le laboratoire 06 : introduction aux répétitives (pseudocode, code C#)

20 oct.

Au menu :

• Qu'advient-il avec les variables déclarées dans une boucle for?
• Introduction à la modularisation, chapitre 08 des notes de cours :
  • des rectangles?
  • un sapin!
• Attention : le cours se corsera à la prochaine séance...

À faire :

• Travail sur le laboratoire 06 : introduction aux répétitives (pseudocode, code C#)

24 oct.

Au menu :

• Présentation du laboratoire 07 : roche, papier, ciseaux (code C#)
  • Exceptionnellement, le laboratoire 07 ne sera remis qu'en version électronique et se limitera au code C# puisque la remise tombe pendant une journée pédagogique. Pas de remise imprimée,
• Travail sur le laboratoire 07 : roche, papier, ciseaux (code C#)

27 oct.

Au menu :

• Introduction aux tableaux unidimensionnels :
  • création
  • distinguer position d'un élément et valeur d'un élément
  • taille
  • parcours
  • tri
  • « ajouter un élément à un tableau »
• exercices formatifs
• Travail sur le laboratoire 07 : roche, papier, ciseaux (code C#)
• Présentation du laboratoire 08 : répétitives et tableaux (code C#, pseudocode de LireValeur)

#nullable disable
int valeurA = LireValeur("Donnez la première valeur : ");
int valeurB = LireValeur("Donnez la deuxième valeur : ");
AfficherLigneTirets();

int[] diviseursA = TrouverDiviseurs(valeurA);
int[] diviseursB = TrouverDiviseurs(valeurB);
int[] communs = TrouverDiviseursCommuns(diviseursA, diviseursB);

Afficher($"Diviseurs de {valeurA}", diviseursA);
AfficherLigneTirets();

Afficher($"Diviseurs de {valeurB}", diviseursB);
AfficherLigneTirets();

Afficher($"Diviseurs communs de {valeurA} et {valeurB}", communs);
AfficherLigneTirets();

7 nov.

Au menu :

• Retour sur le laboratoire 06
• Introduction aux tableaux unidimensionnels (suite)
  • comparer deux tableaux
• Fonctions, intrants et extrants ($0,1,\cdots$)
  • paramètres ref
  • paramètres out
• Représentation des objets en mémoire (aperçu)
• Bonbon : quelle est la différence entre ++i et i++?

À remettre :

• Laboratoire 08 : répétitives et tableaux (code C#, pseudocode de LireValeur)

10 nov.

Au menu :

• On récupère du bouleversement de S19
• Présentation du laboratoire 09 

À faire :

• Travail sur le laboratoire 09

14 nov.

Au menu :

• Introduction à Console.ReadKey
• Introduction aux sélectives (switch)
• Introduction aux tableaux 2D :
  • Équivalent 1D
  • Déclaration
  • Dimensions
  • Affichage à la console
  • Accès à une case par ses indices
• Où en sommes-nous? On s'amuse...!

À faire :

• Travail sur le laboratoire 09

using System;

const char HÉROS = 'H';
const char GAZON = 'g';
const char MONSTRE = 'M';
const int HAUTEUR = 20,
          LARGEUR = 60;

// créer une carte de HAUTEUR x LARGEUR
// la remplir de GAZON
char [,] carte = CréerCarte(HAUTEUR, LARGEUR, GAZON);
// placer le HÉROS quelque part (mettons, coin haut + gauche)
int hérosX = 0,
    hérosY = 0;
carte[hérosY, hérosX] = HÉROS;
// placer le MONSTRE quelque part (mettons, 10,15)
carte[10, 15] = MONSTRE;
Afficher(carte);

bool poursuivre = true;
while(poursuivre)
{
   ConsoleKeyInfo clé = Console.ReadKey(true);
   int nouvX,
       nouvY;
   switch(clé.Key)
   {
      case ConsoleKey.RightArrow:
      case ConsoleKey.UpArrow:
      case ConsoleKey.LeftArrow:
      case ConsoleKey.DownArrow:
         CalculerDéplacement(hérosX, hérosY, out nouvX, out nouvY, clé.Key);
         if(EstPositionValide(nouvX, nouvY, carte))
         {
            Permuter(ref carte[hérosY, hérosX],
                     ref carte[nouvY, nouvX]);
            hérosX = nouvX;
            hérosY = nouvY;
         }
         break;
      case ConsoleKey.Escape:
         poursuivre = false;
         break;
      default:
         Console.Beep();
         break;
   }
   Afficher(carte);
}

static void Afficher(char [,] carte)
{
   Console.Clear();
   for(int ligne = 0; ligne !=carte.GetLength(0); ++ligne)
   {
      for(int colonne = 0; colonne != carte.GetLength(1); ++colonne)
      {
         AfficherSymbole(carte[ligne, colonne]);
      }
      Console.WriteLine();
   }
}

static void AfficherSymbole(char c)
{
   const ConsoleColor SYMBOLE_GAZON = ConsoleColor.Green;
   const ConsoleColor SYMBOLE_HÉROS = ConsoleColor.Blue;
   const ConsoleColor SYMBOLE_MONSTRE = ConsoleColor.Red;
   ConsoleColor avant = Console.ForegroundColor;
   switch(c)
   {
      case GAZON:
         Console.ForegroundColor = SYMBOLE_GAZON;
         break;
      case HÉROS:
         Console.ForegroundColor = SYMBOLE_HÉROS;
         break;
      case MONSTRE:
         Console.ForegroundColor = SYMBOLE_MONSTRE;
         break;
      default:
         Console.ForegroundColor = ConsoleColor.White;
         break;
   }
   Console.Write(c);
   Console.ForegroundColor = avant;
}

static char[,] CréerCarte(int hauteur, int largeur,
                          char symboleRempl)
{
   char[,] carte = new char[hauteur, largeur];
   for(int ligne = 0; ligne != carte.GetLength(0); ++ligne)
   {
      for(int colonne = 0; colonne != carte.GetLength(1); ++colonne)
      {
         carte[ligne, colonne] = symboleRempl;
      }
   }
   return carte;
}

static void Permuter(ref char a, ref char b)
{
   char temp = a;
   a = b;
   b = temp;
}

static void CalculerDéplacement(int x, int y, out int nouvX, out int nouvY, ConsoleKey touche)
{
   nouvX = x;
   nouvY = y;
   switch(touche)
   {
      case ConsoleKey.RightArrow:
         ++nouvX;
         break;
      case ConsoleKey.UpArrow:
         --nouvY;
         break;
      case ConsoleKey.LeftArrow:
         --nouvX;
         break;
      case ConsoleKey.DownArrow:
         ++nouvY;
         break;
   }
}

static bool EstPositionValide(int x, int y, char [,] carte)
{
   return 0 <= x && 0 <= y &&
          x < carte.GetLength(1) && y < carte.GetLength(0);
}

const int HAUTEUR = 20,
          LARGEUR = 75;
const char HÉROS = 'H',
           MONSTRE = 'X',
           GAZON = ',';

const int CHOIX_DROITE = 0,
          CHOIX_HAUT = 1,
          CHOIX_GAUCHE = 2,
          CHOIX_BAS = 3,
          CHOIX_QUITTER = 4;

char[,] grille = CréerGrille(HAUTEUR, LARGEUR, GAZON);
Afficher(grille);
Console.ReadLine();
// positionner les protagonistes
Random dé = new();
int ligneHéros,
    colHéros;
PositionnerÉlément(grille, HÉROS, dé, out ligneHéros, out colHéros);
Afficher(grille);
Console.ReadLine();
int ligneMonstre,
    colMonstre;
PositionnerÉlément(grille, MONSTRE, dé, out ligneMonstre, out colMonstre);
Afficher(grille);

bool fini = Déplacer(grille, ref ligneHéros, ref colHéros);
Afficher(grille);
while (!fini)
{
   fini = Déplacer(grille, ref ligneHéros, ref colHéros);
   Afficher(grille);
}

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

static char[,] CréerGrille(int hauteur, int largeur, char valInit)
{
   char[,] tab = new char[hauteur, largeur];
   for (int ligne = 0; ligne != tab.GetLength(0); ++ligne)
   {
      for(int col = 0; col != tab.GetLength(1); ++col)
      {
         tab[ligne, col] = valInit;
      }
   }
   return tab;
}

static ConsoleColor ChoisirCouleur(char symbole)
{
   ConsoleColor c;
   switch(symbole)
   {
      case HÉROS:
         c = ConsoleColor.Red;
         break;
      case MONSTRE:
         c = ConsoleColor.Magenta;
         break;
      case GAZON:
         c = ConsoleColor.Green;
         break;
      default:
         c = ConsoleColor.White;
         break;
   }
   return c;
}
static void AfficherSymbole(char symbole)
{
   ConsoleColor avant = Console.ForegroundColor;
   ConsoleColor après = ChoisirCouleur(symbole);
   Console.ForegroundColor = après;
   Console.Write(symbole);
   Console.ForegroundColor = avant;
}

static void Afficher(char[,] grille)
{
   Console.Clear();
   for (int ligne = 0; ligne != grille.GetLength(0); ++ligne)
   {
      for (int col = 0; col != grille.GetLength(1); ++col)
      {
         AfficherSymbole(grille[ligne, col]);
      }
      Console.WriteLine();
   }
}

static void PositionnerÉlément(
   char[,] grille, char symbole, Random gen,
   out int ligne, out int col
)
{
   ligne = gen.Next(0, grille.GetLength(0));
   col = gen.Next(0, grille.GetLength(1));
   grille[ligne, col] = symbole;
}

static bool EstToucheValide(char c)
{
   return c == 'W' || c == 'A' || c == 'S' || c == 'D' || c == 'Q';
}

// c est présumé valide à ce point
static int DéterminerChoix(char c)
{
   int choix = CHOIX_QUITTER; // par défaut
   switch (c)
   {
      case 'W':
         choix = CHOIX_HAUT;
         break;
      case 'A':
         choix = CHOIX_GAUCHE;
         break;
      case 'S':
         choix = CHOIX_BAS;
         break;
      case 'D':
         choix = CHOIX_DROITE;
         break;
   }
   return choix;
}

static char LireTouche()
{
   char c = char.ToUpper(Console.ReadKey(true).KeyChar);
   while(!EstToucheValide(c))
   {
      c = char.ToUpper(Console.ReadKey(true).KeyChar);
   }
   return c;
}

static bool EstDansGrille(char[,] grille, int ligne, int col)
{
   return 0 <= ligne && ligne < grille.GetLength(0) &&
          0 <= col && col < grille.GetLength(1);
}

static void Permuter(ref char a, ref char b)
{
   char temp = a;
   a = b;
   b = temp;
}

static bool Déplacer(char[,] grille, ref int ligne, ref int col)
{
   bool fini = false;
   char touche = LireTouche();
   int choix = DéterminerChoix(touche);
   int ligneAprès = ligne;
   int colAprès = col;
   switch(choix)
   {
      case CHOIX_DROITE:
         ++colAprès; // valider...
         break;
      case CHOIX_HAUT:
         --ligneAprès;
         break;
      case CHOIX_GAUCHE:
         --colAprès;
         break;
      case CHOIX_BAS:
         ++ligneAprès;
         break;
      case CHOIX_QUITTER:
         fini = true;
         break;
   }
   if (EstDansGrille(grille, ligneAprès, colAprès))
   {
      Permuter(ref grille[ligne, col], ref grille[ligneAprès, colAprès]);
      ligne = ligneAprès;
      col = colAprès;
   }
   else
   {
      Console.Beep();
   }
   return fini;
}

const int HAUTEUR = 20,
          LARGEUR = 70;

const char HÉROS = 'H',
           MONSTRE = 'M',
           GAZON = ',';

const int CHOIX_DROITE = 0,
          CHOIX_HAUT = 1,
          CHOIX_GAUCHE = 2,
          CHOIX_BAS = 3,
          CHOIX_QUITTER = 4;


char[,] grille = CréerGrille(HAUTEUR, LARGEUR, GAZON);
Afficher(grille);
Console.ReadLine();
Random dé = new();
int ligneHéros,
    colHéros;
Positionner(grille, HÉROS, dé, out ligneHéros, out colHéros);
Afficher(grille);
Console.ReadLine();
int ligneMonstre,
    colMonstre;
Positionner(grille, MONSTRE, dé, out ligneMonstre, out colMonstre);
Afficher(grille);

bool fini = Déplacer(grille, ref ligneHéros, ref colHéros);
Afficher(grille);
while (!fini)
{
   fini = Déplacer(grille, ref ligneHéros, ref colHéros);
   Afficher(grille);
}


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

static bool EstToucheValide(ConsoleKey c)
{
   return c == ConsoleKey.W ||
          c == ConsoleKey.A ||
          c == ConsoleKey.S ||
          c == ConsoleKey.D ||
          c == ConsoleKey.Escape;
}
static ConsoleKey LireTouche()
{
   ConsoleKey c = Console.ReadKey(true).Key;
   while(!EstToucheValide(c))
   {
      c = Console.ReadKey(true).Key;
   }
   return c;
}

static int DéterminerChoix(ConsoleKey c)
{
   int choix = CHOIX_QUITTER;
   switch(c)
   {
      case ConsoleKey.W:
         choix = CHOIX_HAUT;
         break;
      case ConsoleKey.A:
         choix = CHOIX_GAUCHE;
         break;
      case ConsoleKey.S:
         choix = CHOIX_BAS;
         break;
      case ConsoleKey.D:
         choix = CHOIX_DROITE;
         break;
   }
   return choix;
}

static void Permuter(ref char a, ref char b)
{
   char temp = a;
   a = b;
   b = temp;
}

static bool EstPositionValide(char[,] tab, int ligne, int col)
{
   return 0 <= ligne && ligne < tab.GetLength(0) &&
          0 <= col && col < tab.GetLength(1);
}
static bool Déplacer(char [,] grille, ref int ligne, ref int col)
{
   bool fini = false;
   ConsoleKey touche = LireTouche(); // subtilité ici...
   int choix = DéterminerChoix(touche);
   int ligneAprès = ligne;
   int colAprès = col;
   switch(choix)
   {
      case CHOIX_DROITE:
         ++colAprès;
         break;
      case CHOIX_HAUT:
         --ligneAprès;
         break;
      case CHOIX_GAUCHE:
         --colAprès;
         break;
      case CHOIX_BAS:
         ++ligneAprès;
         break;
      case CHOIX_QUITTER:
         fini = true;
         break;
   }
   if(EstPositionValide(grille, ligneAprès, colAprès))
   {
      Permuter(ref grille[ligne, col], ref grille[ligneAprès, colAprès]);
      ligne = ligneAprès;
      col = colAprès;
   }
   else
   {
      Console.Beep();
   }
   return fini;
}

static void Positionner(
   char[,] tab, char symbole, Random r,
   out int ligne, out int col
   )
{
   ligne = r.Next(0, tab.GetLength(0));
   col = r.Next(0, tab.GetLength(1));
   tab[ligne, col] = symbole;
}

static char[,] CréerGrille(int hauteur, int largeur, char valInit)
{
   char[,] tab = new char[hauteur, largeur];
   for(int ligne = 0; ligne != hauteur; ++ligne)
   {
      for(int col = 0; col != largeur; ++col)
      {
         tab[ligne, col] = valInit;
      }
   }
   return tab;
}

static ConsoleColor DéterminerCouleur(char symbole)
{
   ConsoleColor c;
   switch(symbole)
   {
      case HÉROS:
         c = ConsoleColor.Red;
         break;
      case MONSTRE:
         c = ConsoleColor.Magenta;
         break;
      case GAZON:
         c = ConsoleColor.Green;
         break;
      default:
         c = ConsoleColor.White;
         break;
   }
   return c;
}

static void AfficherSymbole(char symbole)
{
   ConsoleColor avant = Console.ForegroundColor;
   ConsoleColor après = DéterminerCouleur(symbole);
   Console.ForegroundColor = après;
   Console.Write(symbole);
   Console.ForegroundColor = avant;
}

static void Afficher(char[,] tab)
{
   Console.Clear();
   for (int ligne = 0; ligne != tab.GetLength(0); ++ligne)
   {
      for (int col = 0; col != tab.GetLength(1); ++col)
      {
         AfficherSymbole(tab[ligne, col]);
      }
      Console.WriteLine();
   }
}

17 nov.

Au menu :

• Présentation du labo 10
• Travail sur le labo 10

21 nov.

24 nov.

Au menu :

• Présentation succincte des énumérations
• Présentation des bases (très naïves) de la POO
• Exercices formatifs sur les bases (très naïves) de la POO
• Remise du laboratoire 10 : les pyramides (code C#)

28 nov.

Au menu :

• Présentation de la PFI
• Travail sur la PFI

1 déc.

Au menu :

• Travail sur la PFI

5 déc.

Au menu :

• Travail sur la PFI

8 déc.

Au menu :

• Travail sur la PFI

Comment accéder à du code .NET à partir d'un client C++ natif.

À venir

À venir

À venir