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

Note sur l'organisation des séances :

Date Séance Détails

23 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)

26 août

S01

Au menu :

  • 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?
  • 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
    Présentation du laboratoire 00 : remettre un document
  • Présentation du laboratoire 01 : conversion de volumes

Exercices en classe :

À faire pour ce soir (ou tôt demain matin) :

  • Laboratoire 00 : remettre un document

À faire pour S02 :

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

30 août

S02

Au menu :

  • Détail technique : le mot-clé using de C# (avec exemples dans Visual Studio et dans dotnetfiddle pour illustrer une subtilité)
  • 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
  • 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
  • Quelques exercices

À remettre :

  • 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 :

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 :

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 :

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");

2 sept.

S03

Au menu :

  • 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 (module 02 des notes de cours)
  • 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)

6 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 (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
  • Débordements et leur effet (en utilisant un bloc checked... ne faites pas ça à la maison!)
  • 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)

9 sept.

S05

Au menu : le prof doit s'absenter pour raisons personnelles...

  • 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
  • Travail sur le laboratoire 03 : APOO volet plongeon (analyse, pseudocode, code C#, jeux d'essai)

À faire :

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

13 sept.

S06

Je serai absent cette semaine car je donne des conférences à CppCon. Vous pourrez suivre mes aventures sur : ../../../Sujets/Orthogonal/cppcon2022.html

Toutefois, je serai remplacé :

  • Pour le groupe 06, par Maxime Barakatt... à moins qu'il ne soit déjà devenu papa; dans quel cas nous avons un « plan B »!

Cette séance portera sur :

  • Solution du labo 02
  • Quelques exercices
  • Un peu de temps pour travailler sur le labo 03

16 sept.

S07

Je serai absent cette semaine car je donne des conférences à CppCon. Vous pourrez suivre mes aventures sur : ../../../Sujets/Orthogonal/cppcon2022.html

Toutefois, je serai remplacé :

  • Pour le groupe 05, par Maxime Barakatt... à moins qu'il ne soit déjà devenu papa; dans quel cas nous avons un « plan B »!

Cette séance portera sur :

  • Solution du labo 02
  • Quelques exercices
  • Un peu de temps pour travailler sur le labo 03

20 sept.

S08

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 "------------------------------"
  • 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

J'ai appris pendant la séance du groupe 6 que Maxime avait présenté sommairement les fonctions la semaine dernière... Avoir su! Je ne sais pas si c'était le cas aussi pour le groupe 5, alors désolé si j'ai répété des trucs déjà vus (si c'est le cas, c'était à mon insu... Ça rime!)

Pour cette raison, avec le groupe 6, j'ai commencé le module 05 qui porte sur les opérateurs relationnels et les alternatives.

  • Présentation du laboratoire 04 : détails à venir

23 sept.

s/o

Journée institutionnelle (cours suspendus)

27 sept.

S09

Votre chic prof a un empêchement et doit lever les cours aujourd'hui... Désolé!

30 sept.

S10

Au menu :

  • Premier contact sommaire avec les alternatives, chapitre 05 des notes de cours
  • Structures alternatives (bases)
  • Structures alternatives plus complexes :
  • Fonctions prédicats

À faire :

  • Travail sur le laboratoire 04 : fonctions assorties (analyse, pseudocode, code C#)

4 oct.

S11

Au menu :

  • Résolution du laboratoire 04
  • 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#)

7 oct.

S12

Au menu :

  • Quelques exercices sur les alternatives
    • Vous trouverez ces exercices sur Colet
    • Les exercices se veulent formatifs, mais sont utiles pour se préparer à l'examen de mi-session qui se pointe à l'horizon
  • Travail sur le laboratoire 05 : APOO volet cartésien (code C#)

À faire :

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

11 oct.

S13

Au menu :

  • Retour sur le laboratoire 05
    • On le fait ensemble!
    • Subtilités en lien avec le axes
  • À propos de la portée des variables
    • Masquer une variable (le Shadowing) et la position de C# à ce sujet
    • Rappel de la distinction entre déclaration, initialisation et affectation
    • Rappel des distinctions (importantes!) entre code C# et pseudocode
  • 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 »
  • Exercice supplémentaire : les contraventions
    • Comprendre les alternatives imbriquées et équilibrées... dans la mesure du possible
    • Discussion d'enjeux de nommage

À remettre :

  • Laboratoire 05 : APOO volet cartésien (code C#)

14 oct.

S14

Au menu :

  • 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;)

Attention : la matière au menu aujourd'hui n'est pas à l'examen de la semaine prochaine!

18 oct.

S15

Au menu :

Pour le groupe 05 :

  • Présentation du laboratoire 06 : introduction aux répétitives (pseudocode, code C#)

Pour le groupe 06 :

  • 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é

21 oct.

S16

Au menu :

Pour le groupe 05 :

  • 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é

Pour le groupe 06 :

Présentation du laboratoire 06 : introduction aux répétitives (pseudocode, code C#)

25 oct.

S17

Au menu :

  • Retour sur l'examen intra
  • Variantes de la répétitive :
    • forme for
    • forme do ... while
  • Introduction à la modularisation, chapitre 08 des notes de cours :
    • des rectangles?
    • un sapin!
  • Présentation du laboratoire 07 : Roche, Papier, Ciseau

À remettre :

  • Laboratoire 06 : introduction aux répétitives (pseudocode, code C#)

28 oct.

S18

Au menu :

  • Retour sur le laboratoire 06 :
    • Le pseudocode est un langage; n'inventez pas de nouvelle syntaxe!
      • Afficher plus d'une valeur
      • Opérateurs et pseudocode
      • Sortir d'une boucle de force (écrire du code déstructuré / mal structuré)
      • Signatures des fonctions
    • Respecter la forme classique des boucles
      • Savoir quand initialiser les variables
      • Savoir quand incrémenter un compteur
      • L'importance de respecter les invariants
    • Organisez vos programmes correctement
      • Programme principal
      • Ensuite, les fonctions
      • Quand vous enchevêtrez les deux, votre code devient très, très confus
  • Travail sur le laboratoire 07 : Roche, Papier, Ciseau

1 nov.

S19

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
  • Présentation du laboratoire 08 : répétitives et tableaux (code C#, pseudocode de LireValeur)

Pour vous éviter d'avoir à le recopier manuellement, le code de démarrage du programme principal imposé pour le laboratoire 08 est :

#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();

À remettre :

  • Laboratoire 07 : Roche, Papier, Ciseau (code C#)

4 nov.

s/o

Journée de mise à niveau (cours suspendus)

8 nov.

S20

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++?
  • Présentation du laboratoire 09 : That's Too Much (code C#)

À remettre :

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

À faire :

  • Travail sur le laboratoire 09 : That's Too Much (code C#)

11 nov.

S21

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 : That's Too Much (code C#)

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;

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);
}

15 nov.

S22

Au menu :

  • Présentation du laboratoire 10 : les pyramides (code C#)
  • Travail sur le laboratoire 10 : les pyramides (code C#)

Exceptionnellement, je vous donnerai jusqu'à S23 pour remettre laboratoire 09. La raison est que la correction du laboratoire 07 a montré qu'on glissait un peu vers la négligence sur plusieurs aspects de notre pratique :

  • Utilisation saine des constantes
  • Utilisation du « sinon »
  • Écriture de boucles correctes, dans le respect de la forme classique
  • Écriture de fonctions avec un nom clair, qui font une et une seule tâche
  • Indentation dans le respect des règles programmatiques en vigueur dans le cours
  • Utilisation correcte des opérateurs relationnels
  • Utilisation correcte des opérateurs logiques

... alors je veux vous donner l'occasion de vous assurer de remettre un laboratoire 09 de qualité. Notez toutefois que le laboratoire 10 demande un peu plus de travail qu'à l'habitude alors ne prenez pas de retard!

Note : selon toute probabilité, nous aborderons la PFI dès S24... La fin approche!

18 nov.

S23

Au menu :

  • Retour sur le laboratoire 08
  • Présentation des types énumérés
  • Remise du laboratoire 09 : That's Too Much (code C#)
  • Travail sur le laboratoire 10 : les pyramides (code C#)

22 nov.

S24

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
  • Remise du laboratoire 10 : les pyramides (code C#)
  • Présentation de la PFI

Pour un exécutable de démonstration de la PFI, allez chercher Paysagiste-Solution.zip puis dézippez le tout dans un dossier avant d'exécuter le .exe qui s'y trouve

25 nov.

S25

Au menu :

  • Travail sur la PFI

29 nov.

s/o

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

2 déc.

S26

Au menu :

  • Travail sur la PFI

6 déc.

S27

Au menu :

  • Travail sur la PFI

9 déc.

S28

Au menu :

  • Chic examen final (groupe 5)

13 déc.

S29

Au menu :

  • Chic examen final (groupe 6)

À remettre :

  • La PFI de la session A2022

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;

const int SEUIL_GEL_EAU = 32;
float tempFahrenheit,
      tempCelsius;
tempFahrenheit = float.Parse(Console.ReadLine());
tempCelsius = (tempFahrenheit - SEUIL_GEL_EAU) * 5 / 9;
Console.WriteLine(tempCelsius);

Jeu d'essai :

tempFahrenheit

tempCelsius

32

0

41

5

23

-5

-40

-40

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;

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

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

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;

Console.WriteLine(CalculerPente(2, 2, 0)); // -1

static double CalculerPente(float b, float x, float y)
{
   double pente;
   pente = (y - b) / x;
   return pente;
}

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;

float poidsKg;
Console.Write("Votre poids en Kg? ");
poidsKg = float.Parse(Console.ReadLine());
Console.WriteLine($"Cela équivaut à {ConvertirKgLbs(poidsKg)} lbs");

static float ConvertirKgLbs(float poidsKg)
{
   const float FACTEUR_CONVERSION = 2.2f;
   float poidsLbs;
   poidsLbs = poidsKg * FACTEUR_CONVERSION;
   return poidsLbs;
}

Valid XHTML 1.0 Transitional

CSS Valide !