updated lesson 1 to version 16.09.2020

lessons/lesson_1/contenu_cours_1.md

-#  Algorithmes et structures de données 2019-20
+#  Algorithmes et structures de données 2020-21
 
-Contenu du cours 1 du 18.09.2019
+Contenu du cours 1 du 16.09.2020
 
 *****
 
@@ -12,7 +12,7 @@ bureau B410
 022 546 2554  
 paul.albuquerque@hesge.ch
 
-##  Organisation du module (2 cours, 50 % chacun)
+##  Organisation du module (2 cours, 50 % chacun)
 
 - Algorithmes et structures de données
     - 1er semestre
@@ -24,10 +24,10 @@ paul.albuquerque@hesge.ch
 > Au moins 2 évaluations par semestre
 
 - Programmation séquentielle en langage C
-    - 1er & 2ème semestre :travaux pratiques en langage C
+    - 1er & 2ème semestre :travaux pratiques en langage C
         - Chaque semestre des travaux pratiques sont répartis dans deux gros projets d'env. 7 semaines
 
-##  Qu'est-ce qu'un algorithme ?
+##  Qu'est-ce qu'un algorithme ?
 
 Informellement, c'est une recette ou une marche à suivre.
 
@@ -42,9 +42,9 @@ Plus formellement:
 Le mot *algorithme* vient du nom latinisé du mathématicien perse
 [Al-Khawarizmi](http://fr.wikipedia.org/wiki/Al-Khawarizmi)
 
-Les algorithmes des grecs : Euclide, Erastosthène
+Les algorithmes des grecs : Euclide, Erastosthène
 
-Le père de l'algorithmique : **Muhammad Ibn Mūsā al-Khuwārizmī**
+Le père de l'algorithmique : **Muhammad Ibn Mūsā al-Khuwārizmī**
 
 Résolution d'un problème
 
@@ -64,17 +64,17 @@ Résolution d'un problème
 -   Forme de l'algorithme (boucle et tests)
 -   Condition d'arrêt de la boucle
 
-##  Qu'est qu'un programme C ?
+##  Qu'est qu'un programme C ?
 
--   Importations de librairies (paquetages) :
+-   Importations de librairies (paquetages) :
 ```C
      #include <stdlio.h>
      #include <stdlib.h>
 ```
 
--   Entête du programme : `int main()`
--   Déclaration de variables : `int x = 5;`
--   Bloc d'instructions :
+-   Entête du programme : `int main()`
+-   Déclaration de variables : `int x = 5;`
+-   Bloc d'instructions :
 ```C
      {
          int x = 5;
@@ -83,12 +83,12 @@ Résolution d'un problème
      }
 ```
 
-##  Les types de base : les entiers (`int, unsigned int`)
+##  Les types de base : les entiers (`int, unsigned int`)
 
 -   Numérotation binaire en particulier sur 32 bits
 -   Nombres négatifs =\> complément à 2
 
-    numération sur 3 bits : 
+    numération sur 3 bits : 
 
     |binaire | entier&GreaterEqual;0| binaire | entier<0|
     |:-------|:---------------------|:--------|:--------|
@@ -99,27 +99,27 @@ Résolution d'un problème
 
 -   Nombres négatifs =\> complément à 1 par simple inversion des bits
 
-    **problème **: 0 possède alors deux représentations !
+    **problème **: 0 possède alors deux représentations !
 
 -   Opérations particulières
-    -   Division entière : 5 / 2 = 2 , 10 / 3 = 3 , 18 / 5 = 3
-    -   Reste de la division entière (modulo) : 5 % 2 = 1 , 10 % 3 = 1 , 18 % 5 = 3
+    -   Division entière : 5 / 2 = 2 , 10 / 3 = 3 , 18 / 5 = 3
+    -   Reste de la division entière (modulo) : 5 % 2 = 1 , 10 % 3 = 1 , 18 % 5 = 3
 -   Constantes de la librairie `<limits.h>`: `INT_MAX, INT_MIN`
 
-## Les types de base : les réels (`float, double`)
+## Les types de base : les réels (`float, double`)
 
 - `Float`: écriture, opérations, exemples complets d'exponentiation  
-  `pow(A,B)` où `A, B` sont des `double` =\> le résultat est un `double` !  
-  **Attention !** Le calcul effectué par *pow* utilise un logarithmes et une exponentielle.
+  `pow(A,B)` où `A, B` sont des `double` =\> le résultat est un `double` !  
+  **Attention !** Le calcul effectué par *pow* utilise un logarithmes et une exponentielle.
 
 > Sur 32 bits : 1 bit de signe, 8 bits pour l'exposant et 23 bits pour la mantisse.
 
-- Exemple : coder 19,625 en binaire
+- Exemple : coder 19,625 en binaire
 
-> > 19  : 10011 = 2<sup>4</sup> + 2<sup>1</sup> + 2<sup>0</sup>;
-0,625 : 0,101 = 2<sup>-1</sup> + 2<sup>-3</sup>
+> > 19  : 10011 = 2<sup>4</sup> + 2<sup>1</sup> + 2<sup>0</sup>;
+0,625 : 0,101 = 2<sup>-1</sup> + 2<sup>-3</sup>
 
-> > 19,625  : 10011,101 = 0,10011101 \* 2<sup>5</sup>
+> > 19,625  : 10011,101 = 0,10011101 \* 2<sup>5</sup>
 
 > > Le signe du nombre est stocké sur dans le 1<sup>er</sup> bit (0 positif / 1 négatif).
 
@@ -128,11 +128,11 @@ Résolution d'un problème
 > > Donc 5 = 00000101
 
 > > La mantisse de 23 bits stockée est 00111010000000000000000  
-(le 1<sup>er</sup> 1 est omis car obligatoire)
+   (le 1<sup>er</sup> 1 est omis car obligatoire)
 
-> > 19,625 stocké en binaire : 0 00000101 00111010000000000000000
+> > 19,625 stocké en binaire : 0 00000101 00111010000000000000000
 
-- Questions : quelles sont les valeurs les plus petite, grande, petite positive (\>0)?
+- Questions : quelles sont les valeurs les plus petite, grande, petite positive (\>0)?
 
 ##  Les booléens `bool`
 
@@ -145,6 +145,7 @@ Résolution d'un problème
         bool x = true;  // booléen vrai
         bool x = false; // booléen faux
         bool x = 17;    // 17 converti en booléen vrai
+        bool x = -5;    // -5 converti en booléen vrai
         bool x = 0;     // 0 converti en booléen faux
         int y = false;  // booléen faux converti en 0
         int y = true;   // booléen vrai converti en 1
@@ -153,16 +154,16 @@ Résolution d'un problème
 - Vérification =\> table de vérité
     - not (A and B) = (not A) or (not B) : `!(A && B) == (!A)|| (!B)`
     - not (A or B) = (not A) and (not B) : `! --|| B) == (!A) && (!B)`
-- Opérateurs logiques : `*==, !=, &&, ||, !, <, >, <=, >=`
-- Comparaisons bit à bit : `&` (et), `|` (ou), `^` (xor), `!` (not)
-- Comparaisons bit à bit avec assignation : `&=, |=, ^=`
+- Opérateurs logiques : `*==, !=, &&, ||, !, <, >, <=, >=`
+- Comparaisons bit à bit : `&` (et), `|` (ou), `^` (xor), `!` (not)
+- Comparaisons bit à bit avec assignation : `&=, |=, ^=`
 
 
 ##  Structures de boucle
 
 - Syntaxe
 ```C
-      for (initialisation>;condition;increment) {
+      for (initialisation;condition;increment) {
           instructions;
       }
 
@@ -174,7 +175,7 @@ Résolution d'un problème
           instructions;
       } while (condition);
 ```
-- Instructions : `break, continue`
+- Instructions : `break, continue`
 
 ##  Les caractères (type prédéfini) `char`