diff --git a/lessons/lesson_1/contenu_cours_1.md b/lessons/lesson_1/contenu_cours_1.md
new file mode 100644
index 0000000000000000000000000000000000000000..24b2d2658718520002b1c33614c579c2950f2959
--- /dev/null
+++ b/lessons/lesson_1/contenu_cours_1.md
@@ -0,0 +1,206 @@
+# Algorithmes et structures de données 2019-20
+
+Contenu du cours 1 du 18.09.2019
+
+*****
+
+
+## Présentation personnelle
+
+[Paul Albuquerque](mailto:paul.albuquerque@hesge.ch), resp. de filière
+bureau B410
+022 546 2554
+paul.albuquerque@hesge.ch
+
+## Organisation du module (2 cours, 50 % chacun)
+
+- Algorithmes et structures de données
+ - 1er semestre
+ - Bases de la programmation en C jusqu'à Noël
+ - Algorithmique jusque fin janvier
+ - 2ème semestre
+ - Algorithmique
+
+> Au moins 2 évaluations par semestre
+
+- Programmation séquentielle 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 ?
+
+Informellement, c'est une recette ou une marche à suivre.
+
+Plus formellement:
+
+| Définition |
+|:-----------------------------------------------------------------|
+| Un **algorithme** est une suite finie et non ambiguë d'opérations|
+| ou d'instructions permettant de résoudre un problème. |
+
+
+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
+
+Le père de l'algorithmique : **Muhammad Ibn Mūsā al-Khuwārizmī**
+
+Résolution d'un problème
+
+- Décomposition en sous-problèmes
+- Résolution des sous-problèmes
+- Assemblage des résultats
+
+## Notions de base d'algorithmique séquentielle
+
+- Définition d'une variable (nom, type, valeur, adresse)
+- Séquences d'instructions
+- Boucles et tests (`for`, `while`, `do...while`, `if...else`)
+
+## Algorithme de vérification qu'un nombre est 1<sup>er</sup>
+
+- Comment demander le nombre
+- Forme de l'algorithme (boucle et tests)
+- Condition d'arrêt de la boucle
+
+## Qu'est qu'un programme C ?
+
+- 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 :
+```C
+ {
+ int x = 5;
+ printf("x=%d\n",x);
+
+ }
+```
+
+## 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 :
+
+ |binaire | entier≥0| binaire | entier<0|
+ |:-------|:---------------------|:--------|:--------|
+ |000 | 0 | 111 | -1 |
+ |001 | 1 | 110 | -2 |
+ |010 | 2 | 101 | -3 |
+ |011 | 3 | 100 | -4 |
+
+- Nombres négatifs =\> complément à 1 par simple inversion des bits
+
+ **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
+- Constantes de la librairie `<limits.h>`: `INT_MAX, INT_MIN`
+
+## 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.
+
+> Sur 32 bits : 1 bit de signe, 8 bits pour l'exposant et 23 bits pour la mantisse.
+
+- 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,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).
+
+> > L'exposant est stocké sur 8 positions =\> 256 valeurs =\> -128..127.
+
+> > Donc 5 = 00000101
+
+> > La mantisse de 23 bits stockée est 00111010000000000000000
+(le 1<sup>er</sup> 1 est omis car obligatoire)
+
+> > 19,625 stocké en binaire : 0 00000101 00111010000000000000000
+
+- Questions : quelles sont les valeurs les plus petite, grande, petite positive (\>0)?
+
+## Les booléens `bool`
+
+- Librairie: `<stdbool.h>`
+ Valeurs possibles: `true, false`
+ Conversion possible en entier
+
+> Exemples:
+```C
+ bool x = true; // booléen vrai
+ bool x = false; // booléen faux
+ bool x = 17; // 17 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
+```
+
+- 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 : `&=, |=, ^=`
+
+
+## Structures de boucle
+
+- Syntaxe
+```C
+ for (initialisation>;condition;increment) {
+ instructions;
+ }
+
+ while (condition) {
+ instructions;
+ }
+
+ do {
+ instructions;
+ } while (condition);
+```
+- Instructions : `break, continue`
+
+## Les caractères (type prédéfini) `char`
+
+- On considère les caractères sont des valeurs encodées sur 1 octet (code ASCII étendu).
+Il y a donc 256 valeurs possibles. La conversion entre entier et caractère est effective.
+Par exemple, le caractère *'A'* correspond à 65 et *'a'* à 96.
+```C
+ char ch = 'a'; // Caractère 'a'
+ printf("La variable ch est %c\n",ch); // affiche 'a'
+ char x = 96;
+ printf("La variable x est %c\n",x); // affiche aussi 'a'
+ int v = 'a';
+ printf("La variable v est %d\n",v); // affiche 96
+```
+## Structures de test
+
+- Syntaxe
+```C
+ if (condition) {
+ instructions;
+ } else if (condition) {
+ instructions;
+ } else {
+ instructions;
+ }
+```
+## Exemple de boucles (`for, while, do ... while`)
+
+- La factorielle
diff --git a/lessons/lesson_1/nb1er.c b/lessons/lesson_1/nb1er.c
new file mode 100644
index 0000000000000000000000000000000000000000..32e4824fe67527d910ff8b3125fedbe0f6821f76
--- /dev/null
+++ b/lessons/lesson_1/nb1er.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdbool.h>
+// Programme testant si un nombre est 1er
+void main() {
+ int nb = 1;
+ printf("Entrez un nombre: ");
+ scanf("%d",&nb);
+ bool premier = true;
+ for (int div=2;div<=sqrt(nb);div++) {
+ if (nb%div == 0) {
+ premier = false;
+ break;
+ }
+ }
+ /* variante pour la boucle
+ int i = 2;
+ while (i <= sqrt(nombre) && premier) {
+ if (nombre%i == 0) {
+ premier = false;
+ }
+ i++;
+ }
+ */
+
+ if (premier) {
+ printf("Le nombre %d est premier\n",nb);
+ } else {
+ printf("Le nombre %d n'est pas premier\n",nb);
+ }
+}
+