Quelques raccourcis :

420-201-RE – Introduction à la programmation

Ceci est un petit site de support pour le cours 420-201-RE – Introduction à la programmation.

Vous trouverez aussi des liens sur divers langages (dont C#, notre outil de prédilection dans ce cours) un peu partout dans http://h-deb.clg.qc.ca/. Portez une attention particulière à ../../../Sujets/Divers--cdiese/index.html.

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.

Cliquez sur cette cible pour le plan de cours, sous forme électronique

Pratiques de correction

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

Détail des séances en classe

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 :

À 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
    • Détails à venir
    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 »
    • exercices formatifs

À 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)
    • comparer deux tableaux
  • 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 :

  • Travail sur la PFI

3 déc.

SS27

Au menu :

  • Travail sur la PFI

7 déc.

s/o

Journée d'examen de français, formation générale (cours suspendus)

10 déc.

S28

Au menu :

  • Chic examen final

14 déc.

S29

À remettre :

  • La PFI de la session A2021

Petits coups de pouces

Vous trouverez ici quelques documents, la plupart petits, qui peuvent vous donner un petit coup de pouce occasionnel.

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

Vous trouverez aussi des exemples de code C# dans la section Divers – C# du site, mais notez que je n'ai pas nécessairement harmonisé ces exemples (écrits pour des cours plus avancés, sous forme de survols) aux standards de programmation appliqués dans le présent cours. À lire avec prudence et discrimination, donc.

Solutionnaires

Quelques solutionnaires suivent. Référez-vous aux règles programmatiques pour plus de détails sur les normes de programmation appliquées dans ce cours.

Travail

À venir

À venir

À venir

Conversion °F à °C

É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.

Intrant(s) :

Extrant(s) :

tempCelsius (température exprimée en °C)

Autres informations pertinentes :

Pseudocode :

SEUIL_GEL_EAU ← 32
Lire tempFahrenheit
tempCelsius ← (tempFahrenheit - SEUIL_GEL_EAU) * 5 / 9
Écrire tempCelsius

Code C# :

using System;
namespace ConversionFahrCels
{
   class Program
   {
      static void Main()
      {
         const int SEUIL_GEL_EAU = 32;
         float tempFahrenheit,
               tempCelsius;
         tempFahrenheit = float.Parse(Console.ReadLine());
         tempCelsius = (tempFahrenheit - SEUIL_GEL_EAU) * 5 / 9;
         Console.WriteLine(tempCelsius);
      }
   }
}

Permutation de deux valeurs

Énoncé : écrivez le pseudocode de l'algorithme qui lit deux entiers nb0 et nb1, permute leurs valeurs, puis affiche les valeurs permutées

Pseudocode (une variable temporaire) :

Lire nb0
Lire nb1
temp ← nb0
nb0 ← nb1
nb1 ← temp
Écrire nb0
Écrire nb1

Pseudocode (sans variable temporaire; attention, solution limitée aux variables numériques) :

Lire nb0
Lire nb1
nb0 ← nb0 + nb1
nb1 ← nb0 - nb1
nb0 ← nb0 - nb1
Écrire nb0
Écrire nb1

Calculer la distance entre deux points

É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 .

Code C# :

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...
      }
   }
}

Calculer la pente d'une courbe non-verticale

É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.

Code C# :

using System;

namespace z
{
   class Program
   {
      static double CalculerPente(float b, float x, float y)
      {
         double pente;
         pente = (y - b) / x;
         return pente;
      }
      static void Main(string[] args)
      {
         Console.WriteLine(CalculerPente(2, 2, 0)); // -1
      }
   }
}

Convertir un poids de Kg en Lbs

É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.

Code C# :

using System;

namespace z
{
   class Program
   {
      static float ConvertirKgLbs(float poidsKg)
      {
         const float FACTEUR_CONVERSION = 2.2f;
         float poidsLbs;
         poidsLbs = poidsKg * FACTEUR_CONVERSION;
         return poidsLbs;
      }
      static void Main(string[] args)
      {
         float poidsKg;
         Console.Write("Votre poids en Kg? ");
         poidsKg = float.Parse(Console.ReadLine());
         Console.WriteLine($"Cela équivaut à {ConvertirKgLbs(poidsKg)} lbs");
      }
   }
}

Valid XHTML 1.0 Transitional

CSS Valide !