Les diverses sections de cette page (en fonction desquelles vous trouverez
quelques liens dans l'encadré à droite) vous mèneront elles-aussi
sur des pistes qui vous permettront d'explorer un peu plus par vous-mêmes,
de valider vos acquis et d'enrichir votre apprentissage.
Date |
Séance |
Détails |
24
août
|
S00 |
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)
|
27 août |
S01 |
Au menu :
- Introduction à la conception logicielle (chapitre
01 des notes de cours)
- Structures de contrôle (première partie) : la séquence
- 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?
- Présentation du laboratoire 00 :
remettre un document
- Présentation du laboratoire 01 :
conversion de volumes
Exercices en classe :
À faire pour S02 :
- Laboratoire 00 : remettre un document
À faire pour S03 :
- Laboratoire 01 : conversion de volumes (analyse,
pseudocode,
jeux d'essai)
|
31 août |
S02 |
Au menu :
- Introduction à la conception logicielle (chapitre
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 é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
- Retour sur le laboratoire 00
- Algorithmes et codification (chapitre 02
des notes de cours)
- Quelques exercices
À faire pour S03 :
- Laboratoire 01 : conversion de volumes (analyse,
pseudocode,
jeux d'essai)
Nous avons fait un petit exemple d'utilisation du type string
et d'affichage, avec formatage « de base », avec formatage
positionnel comme avec formatage par
interpolation. Les trois sont des manières distinctes d'avoir le même
effet.
Pour l'affichage « de base », le code suit :
using System;
namespace z
{
class Program
{
static void Main(string[] args)
{
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");
}
}
}
Pour l'affichage avec formatage positionnel, le code suit :
using System;
namespace z
{
class Program
{
static void Main(string[] args)
{
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);
}
}
}
Pour l'affichage avec formatage par interpolation, le code suit :
using System;
namespace z
{
class Program
{
static void Main(string[] args)
{
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");
}
}
}
|
3 sept.
|
S03 |
Au menu :
- Remise du laboratoire 01 :
conversion de volumes (analyse,
pseudocode,
jeux d'essai)
- Discussions sur le laboratoire 01
- 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 (chapitre
02 des notes de cours)
- Présentation du laboratoire 02 :
gazonnage de parc (analyse,
pseudocode,
code
C#, jeux d'essai)
À remettre :
- Laboratoire 01 : conversion de volumes (analyse,
pseudocode,
jeux d'essai)
À faire pour S05 :
- Laboratoire 02 : gazonnage de parc
(analyse,
pseudocode,
code
C#, jeux d'essai)
|
7 sept. |
S04 |
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 (chapitre
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
-
Débordements
et leur effet (en utilisant un bloc checked...
ne faites pas ça à la maison!)
À faire pour S05 :
- Laboratoire 02 : gazonnage de parc
(analyse,
pseudocode,
code
C#, jeux d'essai)
|
10 sept.
|
S05 |
Au menu :
- Introduction à l'approche que l'on nomme le développement graduel
(approche Top-Down), chapitre 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
- Présentation du laboratoire 03 : APOO
volet plongeon (analyse,
pseudocode,
code
C#,
jeux d'essai)
À remettre :
- Laboratoire 02 : gazonnage de parc
(analyse,
pseudocode,
code
C#, jeux d'essai)
À faire :
- Travail sur le laboratoire 03 : APOO
volet plongeon (analyse,
pseudocode,
code
C#,
jeux d'essai)
|
14 sept. |
S06 |
Au menu :
- Retour sur le laboratoire 02 :
gazonnage de parc (analyse,
pseudocode,
code
C#, jeux d'essai)
- Pourquoi mettre son nom dans le document est une bonne idée
(indice : ça évite d'avoir zéro)
- Pourquoi respecter le format demandé pour les noms de fichiers évite
de perdre des points (surtout après trois remises!)
- Quand le livrable se limite à un document Word ou à un PDF, pas
besoin de le zipper avec moi
- Les caractères gras ne sont pas une décoration
- Les polices de caractères ne sont pas un artifice
- Les nombres à virgule s'écrivent... avec une virgule, en pseudocode
comme dans l'analyse
- Attention aux erreurs lexicales, en particulier aux constantes et
aux variables qui changent de nom et brisent votre code!
- Quelle
police utiliser pour le code (incluant le
pseudocode)?
- Rappel sur la disposition des lignes longues (visibilité)
- En
C#,
une variable dont le nom est en majuscules demeure une variable
- Même dans l'analyse, éviter la confusion est important (p. ex. :
« un cm est un centimètre » ressemble tellement à un accident
qu'on « cherche le bogue »... Idem pour celles et ceux qui
parlent de « l'aire de la surface » ou de « l'aire en m^3 » (truc : relisez-vous... lentement... avant d'envoyer le
document!)
- Comment utiliser le paysage et le portrait
- Évitez les « De / DeLa / Du / Un / Le / La... » dans les noms de variables
- Configurez votre éditeur de texte pour qu'il utilise la bonne langue
pour vos études (« canadien français »)
- Une bonne habitude à prendre : une variable, une vocation
- Vous êtes plusieurs à vous nommer Pierre Prud'homme ou à avoir un
labo 02 dans un namespace nommé Laboratoire_01_exemple_A2021_ ce qui me
dit que plusieurs d'entre vous gagneraient à se relire avec un peu plus
d'attention avant de livrer un labo 🙂
- Exercices avec les fonctions :
- Écrire une fonction prenant en paramètre les coordonnées de deux points et
sur le plan cartésien, et retournant la distance entre ces deux points,
de même qu'un petit programme testant cette fonction (solutionnaire)
- Écrire une fonction calculant la pente d'une droite non-verticale étant donné
l'ordonnée à l'origine et un point par lequel passe cette droite,
de même qu'un petit programme testant cette fonction (solutionnaire)
- Écrire une fonction prenant en paramètre un poids exprimé en
kilogrammes et retournant la valeur équivalente, mais exprimée en
livres, de même qu'un petit programme testant cette fonction
(solutionnaire)
À faire :
- Travail sur le laboratoire 03 : APOO
volet plongeon (analyse,
pseudocode,
code
C#,
jeux d'essai)
|
17 sept.
|
S07 |
Au menu :
- Présentation du laboratoire 04 : APOO
volet
glisse (analyse,
pseudocode,
code
C#,
jeux d'essai)
- Arrondir un nombre à virgule flottante avec
C#
- Premier contact sommaire avec les alternatives, chapitre
05 des notes de cours
- Structures alternatives (bases)
À remettre :
- Travail sur le laboratoire 03 : APOO
volet plongeon (analyse,
pseudocode,
code
C#,
jeux d'essai)
À faire :
- Travail sur le laboratoire 04 : APOO
volet
glisse (analyse,
pseudocode,
code
C#,
jeux d'essai)
|
21 sept. |
S08 |
Au menu :
- Structures alternatives plus complexes :
À faire :
- Travail sur le laboratoire 04 : APOO
volet
glisse (analyse,
pseudocode,
code
C#,
jeux d'essai)
|
24 sept.
|
S09 |
Séance suspendue dû à un vote de contestation de l'association
étudiante, pour vous permettre de manifester à propos de la lutte sur le
climat; on décale la remise du labo 04 à la séance
S10 pour vous
accommoder
|
28 sept. |
S10 |
Au menu :
- Fonctions prédicats
- Exercices
- Présentation du laboratoire 05 : APOO
volet
cartésien
Exceptionnellement, vous aurez moins de temps qu'à l'habitude pour
faire le labo 05, mais sachez qu'il s'agit
d'un laboratoire pratique pour lequel vous n'aurez à remettre que le code
source (en respectant certaines règles)
À remettre :
- Travail sur le laboratoire 04 : APOO
volet
glisse (analyse,
pseudocode,
code
C#,
jeux d'essai)
À faire :
- Travail sur le laboratoire 05 : APOO
volet
cartésien (code
C#)
|
1 oct.
|
S11 |
Au menu :
- J'ai l'impression que plusieurs trouvent difficile le laboratoire 05 : APOO
volet cartésien
- Pour cette raison, je vais vous laisser un peu de temps pour
travailler dessus aujourd'hui en classe, et accepter les remises jusqu'à
23 h 59 samedi soir (pour me permettre de corriger par la suite)
- Si vous l'avez déjà remis, vous pouvez (si vous le souhaitez)
utiliser ce temps extra pour envoyer une version « mise à jour » et je
l'accepterai
- ...évidemment, si vous l'avez déjà remis et êtes satisfait(e), tout
est merveilleux!
- Présentation du « laboratoire 5,5 »
- Travail sur le « laboratoire 5,5 »
À remettre (voir ci-dessus pour la date et l'heure) :
- Laboratoire 05 :
APOO volet cartésien (code
C#)
À faire :
- Travail sur le « laboratoire 5,5 »
|
5 oct. |
S12 |
Au menu :
- Retour sur le laboratoire 04
- Indenter le pseudocode autant que le code
- Commenter (sommairement) les fonctions
- Localité des constantes
- Note sur les constantes globales
- Une copie d'une constante, ce n'est pas nécessairement une constante
- À propos des noms utiles, et de ceux qui le sont moins...
- Intrants et extrants, du programme ou d'une fonction...
- Ce que le mot « degré » peut être compliqué à écrire, qui l'eut cru?
(et ne me parlez pas du mot « radian »!)
- Retour sur le laboratoire 05
- ... ou comment écrire du code sans trop se faire de mal 🙂
- Introduction à la logique et aux répétitives, chapitres
06 et 07 des
notes de cours
- Pour aujourd'hui, un peu de logique
|
8 oct.
|
S13 |
Au menu :
- Retour sur le laboratoire 05,5
Introduction à la logique et aux répétitives, chapitres
06 et 07 des
notes de cours (suite)
- 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 (pseudocode,
code
C#)
À faire :
- Travail sur le laboratoire 06 :
introduction aux répétitives (pseudocode,
code
C#)
|
12 oct.
|
s/o |
Pas de cours aujourd'hui (journée de mise à niveau)
|
15 oct. |
s/o |
Pas de cours aujourd'hui (journée de mise à niveau)
|
19 oct.
|
S14 |
Au menu :
- Retour sur l'examen préparatoire à l'intra
- Posez toutes les questions qui vous turlupinent encore, c'est le
temps!
- Retour sur le laboratoire 06
Note : je vais éviter de donner de la nouvelle matière aujourd'hui,
dans le but de réduire les risques de confusion lors de l'examen intra
donné à la séance S15,
mais c'est un excellent moment pour clarifier votre compréhension de ce
que nous avosn vu jusqu'ici, et pour renforcer cette compréhension le cas
échéant. Profitez-en!
|
22 oct. |
S15 |
Au menu :
- Examen intra :
- Deux périodes, un peu plus pour les ami(e)s qui ont une entente au
SAIDE
- Papier, crayon, pas d'ordinateur, de calculatrice, de cellulaire ou
autre appareil
- De l'amour, bien sûr
- Vous pouvez quitter une fois l'examen terminé
|
26 oct. |
S16 |
Je serai absent cette semaine car je donne des conférences à
CppCon. Vous pourrez suivre mes
aventures sur :
../../../Sujets/Orthogonal/cppcon2021.html
|
29 oct.
|
S17 |
Je serai absent cette semaine car je donne des conférences à
CppCon. Vous pourrez suivre mes
aventures sur :
../../../Sujets/Orthogonal/cppcon2021.html
Toutefois, je serai remplacé :
Cette séance portera sur un retour sur l'examen intra, et comportera
des exercices sur des aspects moins bien réussis
|
2 nov. |
S18 |
Au menu :
- Variantes de la répétitive :
- forme for
- forme do ... while
- Introduction à la modularisation, chapitre 08
des notes de cours :
- des rectangles?
- un sapin!
|
5 nov.
|
S19 |
Au menu :
- Présentation du laboratoire 07 :
The Clock Game (analyse – sans jeux d'essai – de même que
pseudocode,
code
C#)
À faire :
- Travail sur le laboratoire 07 :
The Clock Game (analyse – sans jeux d'essai – de même que
pseudocode,
code
C#)
|
9 nov. |
S20 |
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 »
À faire :
- Travail sur le laboratoire 07 :
The Clock Game (analyse – sans jeux d'essai – de même que
pseudocode,
code
C#)
|
12 nov.
|
S21 |
Au menu :
- Retour sur le passage de paramètre par valeur, et sur le sens d'un
tel passage avec un « type référence »
- Présentation du laboratoire 08 : répétitives et tableaux
(code
C#)
- Pour vous aider, le code du programme principal imposé pour le
laboratoire 08 est :
static void Main(string[] args)
{
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();
}
À faire :
- Travail sur le laboratoire 08 : répétitives et tableaux
(code
C#)
À remettre :
- Laboratoire 07 :
The Clock Game (analyse – sans jeux d'essai – de même que
pseudocode,
code
C#)
|
16 nov. |
S22 |
Au menu :
- Introduction aux tableaux unidimensionnels (suite)
- Fonctions, intrants et extrants ()
- 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++?
À faire :
- Travail sur le laboratoire 08 : répétitives et tableaux
(code
C#)
|
19 nov.
|
S23 |
Au menu :
- Introduction à Console.ReadKey
- Introducttion aux tableaux 2D :
- Équivalent 1D
- Déclaration
- Dimensions
- Affichage à la console
- Accès à une case par ses indices
- Présentation du laboratoire 09
À remettre :
- Laboratoire 08 : répétitives et tableaux
(code
C#)
À faire :
- Travail sur le laboratoire 09 :
matrices
J'ai fait avec vous un petit exemple amusant avec un héros et un monstre sur une surface
rectangulaire. Le code allait comme suit (note : c'est la version d'un des deux groupes,
mais les deux sont semblables) :
using System;
namespace z
{
class Program
{
const int NB_LIGNES = 6,
NB_COLONNES = 10;
const char MONSTRE = 'M',
GAZON = 'G',
HÉROS = 'H';
static char Lire (char[,] carte, int ligne, int colonne)
{
return carte[ligne, colonne];
}
static char[,] CréerMatrice(int hauteur, int largeur, char c)
{
char[,] carte = new char[hauteur, largeur];
// populer la carte
for (int ligne = 0; ligne != carte.GetLength(0); ++ligne)
{
for (int colonne = 0; colonne != carte.GetLength(1); ++colonne)
{
carte[ligne, colonne] = c;
}
}
return carte;
}
static void Afficher(char [,] mat)
{
for (int ligne = 0; ligne != mat.GetLength(0); ++ligne)
{
for (int colonne = 0; colonne != mat.GetLength(1); ++colonne)
{
Console.Write($"{mat[ligne, colonne]}\t");
}
Console.WriteLine();
}
}
static void Permuter(ref char a, ref char b)
{
char temp = a;
a = b;
b = temp;
}
static bool EstDans(char [,] mat, int x, int y)
{
return x >= 0 && x < mat.GetLength(1) &&
y >= 0 && y < mat.GetLength(0);
}
static void Main(string[] args)
{
char[,] carte = CréerMatrice(NB_LIGNES, NB_COLONNES, GAZON);
carte[3, 5] = MONSTRE;
int x = 0,
y = 0;
carte[y, x] = HÉROS;
Afficher(carte);
ConsoleKeyInfo clé = Console.ReadKey();
while(clé.Key != ConsoleKey.Escape)
{
int dx = 0,
dy = 0;
if (clé.Key == ConsoleKey.RightArrow)
{
dx = 1;
}
else if (clé.Key == ConsoleKey.UpArrow)
{
dy = -1;
}
else if (clé.Key == ConsoleKey.LeftArrow)
{
dx = -1;
}
else if (clé.Key == ConsoleKey.DownArrow)
{
dy = 1;
}
if(EstDans(carte, x + dx, y + dy))
{
Permuter(ref carte[y, x], ref carte[y + dy, x + dx]);
x = x + dx;
y = y + dy;
Console.Clear();
Afficher(carte);
}
else
{
Console.Beep();
}
clé = Console.ReadKey();
}
}
}
}
|
23 nov. |
S24 |
Au menu :
- Retour sur le labo 07
- Retour sur le labo 08
- Présentation des types énumérés
À faire :
- Travail sur le laboratoire 09 :
matrices
|
26 nov.
|
S25 |
Au menu :
- Présentation des bases (très naïves) de la
POO
- Exercices formatifs sur les bases (très naïves) de la
POO
- Présentation de la PFI
- Un exécutable de démonstration est disponible sur
AnimalerieÉsotérique -
démo.zip
- Si vous avez un Mac, il se peut que les accents dans les noms de
fichiers posent problème. Voici une archive de départ sans accents :
AnimalerieEsoterique-Mac.zip
|
30 nov.
|
SS26 |
Au menu :
|
3 déc. |
SS27 |
Au menu :
|
7 déc. |
s/o
|
Journée d'examen de français, formation générale (cours suspendus)
|
10 déc.
|
S28 |
Au menu :
|
14 déc.
|
S29 |
À remettre :
- La
PFI de la session
A2021
|
Vous trouverez ici quelques documents, la plupart petits, qui peuvent vous
donner un petit coup de pouce occasionnel.
Énoncé : écrivez le pseudocode de l'algorithme qui lit une valeur en
degrés Fahrenheit, calcule la valeur équivalente exprimée en degrés Celsius,
puis affiche cette dernière.
Énoncé : écrivez le pseudocode de l'algorithme qui lit deux entiers nb0
et nb1, permute leurs valeurs, puis affiche les valeurs permutées
Énoncé : écrire une fonction prenant en paramètre les coordonnées de deux points et
sur le plan cartésien, et retournant la distance entre ces deux points,
de même qu'un petit programme testant cette fonction .
using System;
namespace z
{
class Program
{
static double CalculerDistance(float x0, float y0, float x1, float y1)
{
double distance;
distance = Math.Sqrt(Math.Pow(x0 - x1, 2) +
Math.Pow(y0 - y1, 2));
return distance;
}
static void Main(string[] args)
{
Console.WriteLine("distance entre (0,0) et (0,1) : {0}",
CalculerDistance(0, 0, 0, 1)); // 1
Console.WriteLine("distance entre (1,0) et (3,0) : {0}",
CalculerDistance(1, 0, 3, 0)); // 2
Console.WriteLine("distance entre (0,0) et (1,1) : {0}",
CalculerDistance(0,0,1,1)); // 1,41...
}
}
}
Énoncé : écrire une fonction calculant la pente d'une droite non-verticale étant donné
l'ordonnée à l'origine et un point
par lequel passe cette droite, de même qu'un petit programme testant cette
fonction.
Énoncé : écrire une fonction prenant en paramètre un poids exprimé en
kilogrammes et retournant la valeur équivalente, mais exprimée en livres, de
même qu'un petit programme testant cette fonction.