diff --git a/slides/.gitignore b/slides/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..021299b0ce1f07daf9acb338abcb9083ef3a99fd
--- /dev/null
+++ b/slides/.gitignore
@@ -0,0 +1,2 @@
+*.pdf
+*.err
diff --git a/slides/Makefile b/slides/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..1403418496850cfbaf6c61fbbe3ec3c5ef0455d5
--- /dev/null
+++ b/slides/Makefile
@@ -0,0 +1,38 @@
+PDFOPTIONS = -t beamer
+PDFOPTIONS += -F mermaid-filter
+PDFOPTIONS += --highlight-style my_highlight.theme
+PDFOPTIONS += --pdf-engine xelatex
+PDFOPTIONS += -V theme:metropolis
+PDFOPTIONS += -V themeoptions:numbering=none -V themeoptions:progressbar=foot
+PDFOPTIONS += -V fontsize=smaller
+PDFOPTIONS += -V urlcolor=blue
+
+MD=$(wildcard *.md) # Tous les fichiers .md
+PDF=$(MD:%.md=%.pdf) # Pour les fichier pdf on transforme .md -> .pdf
+MARKDOWN=$(MD:%.md=%.markdown) # Pour les fichier markdown on transforme .md -> .markdown
+
+all: $(PDF) # La cible par défaut (all) exécute les cibles %.pdf
+
+markdown: $(MARKDOWN) # La markdown les cibles %.markdown
+
+%.pdf: %.md metadata.yaml # %.pdf (chaque fichier %.md génère un fichier avec le même nom mais l'extension .pdf et la dépendance metadata.yaml)
+ pandoc -s $(OPTIONS) $(PDFOPTIONS) -o $@ $^
+
+%.markdown: %.md metadata.yaml yq
+ sed '1 { /^---/ { :a N; /\n---/! ba; d} }' $< > no_header
+ grep -v -F -x -f no_header $< > header.yaml
+ echo "---" > tmp.yaml
+ ./yq_linux_amd64 merge metadata.yaml header.yaml >> tmp.yaml
+ cat tmp.yaml no_header > $@
+ rm no_header header.yaml tmp.yaml
+
+yq: # On peut même télécharger un petit programme avec notre makefile
+ wget -nc https://github.com/mikefarah/yq/releases/download/3.4.1/yq_linux_amd64
+ chmod "u+x" yq_linux_amd64
+
+deploy: all
+ mkdir -p algo_cours
+ cp *.pdf algo_cours
+
+clean:
+ rm -f *.pdf *.markdown yq_linux_amd64*
diff --git a/slides/cours_1.md b/slides/cours_1.md
new file mode 100644
index 0000000000000000000000000000000000000000..81ca94ea27321ab288157ce81240423cae7730a5
--- /dev/null
+++ b/slides/cours_1.md
@@ -0,0 +1,693 @@
+---
+title: "Introduction aux algorithmes"
+date: "2021-09-22"
+---
+
+# Qu'est-ce qu'un algorithme?
+
+## Définition informelle (recette)
+
+* des entrées (les ingrédients, le matériel utilisé) ;
+* des instructions élémentaires simples (frire, flamber, etc.), dont les
+ exécutions dans un ordre précis amènent au résultat voulu ;
+* un résultat : le plat préparé.
+
+. . .
+
+## Histoire et étymologie
+
+- Existent depuis 4500 ans au moins (algorithme de division, crible
+ d'Eratosthène).
+- Le mot algorithme est dérivé du nom du mathématicien perse
+ *Muḥammad ibn Musā al-Khwārizmī*, qui a été "latinisé" comme
+ *Algoritmi*.
+
+. . .
+
+## Définition formelle
+
+En partant d'un état initial et d'entrées (peut-être vides), une séquence finie
+d'instruction bien définies (ordonnées) implémentables sur un ordinateur, afin
+de résoudre typiquement une classe de problèmes ou effectuer un calcul.
+
+# Notions de base d'algorithmique
+
+## Variable
+
+. . .
+
+* Paire: identifiant - valeur (assignation);
+
+## Séquence d'instructions / expressions
+
+. . .
+
+* Opérateurs (arthimétiques / booléens)
+* Boucles;
+* Structures de contrôle;
+* Fonctions;
+
+
+# Algorithme de vérification qu'un nombre est premier (1/3)
+
+Nombre premier: nombre possédant deux diviseurs entiers distincts.
+
+. . .
+
+## Algorithme naïf (problème)
+
+```C
+est_premier(nombre) {
+ si {
+ pour tout i, t.q. 1 < i < nombre {
+ i ne divise pas nombre
+ }
+ } alors vrai
+ sinon faux
+}
+```
+
+. . .
+
+## Pas vraiment un algorithme: pas une séquence ordonnée et bien définie
+
+. . .
+
+## Problème: Comment écrire ça sous une forme algorithmique?
+
+# Algorithme de vérification qu'un nombre est premier (2/3)
+
+## Algorithme naïf (une solution)
+
+```C
+est_premier(nombre) { // fonction
+ soit i := 2; // variable, type, assignation
+ tant que i < nombre { // boucle
+ si nombre modulo i = 0 { // expression typée
+ retourne faux // expression typée
+ }
+ i := i + 1
+ }
+ retourne vrai // expression typée
+```
+
+# Algorithme de vérification qu'un nombre est premier (3/3)
+
+## Algorithme naïf (une solution en C)
+
+```C
+bool est_premier(int nombre) {
+ int i; // i est un entier
+ i = 2; // assignation i à 2
+ while (i < nombre) { // boucle avec condition
+ if (0 == nombre % i) { // is i divise nombre
+ return false; // i n'est pas premier
+ }
+ i += 1; // sinon on incrémente i
+ }
+ return true;
+}
+```
+
+. . .
+
+## Exercice: Comment faire plus rapide?
+
+# Génération d'un exécutable
+
+- Pour pouvoir être exécuté un code C doit être d'abord compilé (avec `gcc` ou `clang`).
+- Pour un code `prog.c` la compilation "minimale" est
+
+ ```bash
+ $ gcc prog.c
+ $ ./a.out # exécutable par défaut
+ ```
+
+- Il existe une multitude d'options de compilation:
+
+ ```bash
+ $ gcc -O1 -std=c11 -Wall -Wextra -g porg.c -o prog -fsanitize=address
+ -fsanitize=leak -fsanitize=undefined
+ ```
+ 1. `-std=c11` utilisation de C11.
+ 2. `-Wall et -Wextra` activation des warnings.
+ 3. `-fsanitize=…` contrôles d’erreurs à l’exécution (coût en performance).
+ 4. `-g` symboles de débogages sont gardés.
+ 5. `-o` défini le fichier exécutable à produire en sortie.
+ 6. `-O1`, `-O2`, `-O3`: activation de divers degrés d'optimisation
+
+
+
+# La simplicité de C?
+
+## 32 mots-clé et c'est tout
+
+---------------- -------------- ---------------- ---------------
+`auto`{.C} `double`{.C} `int`{.C} `struct`{.C}
+`break`{.C} `else`{.C} `long`{.C} `switch`{.C}
+`case`{.C} `enum`{.C} `register`{.C} `typedef`{.C}
+`char`{.C} `extern`{.C} `return`{.C} `union`{.C}
+`const`{.C} `float`{.C} `short`{.C} `unsigned`{.C}
+`continue`{.C} `for`{.C} `signed`{.C} `void`{.C}
+`default`{.C} `goto`{.C} `sizeof`{.C} `volatile`{.C}
+`do`{.C} `if`{.C} `static`{.C} `while`{.C}
+---------------- -------------- ---------------- ---------------
+
+# Déclaration et typage
+
+En C lorsqu'on veut utiliser une variable (ou une constante), on doit déclarer son type
+
+```C
+const double two = 2.0; // déclaration et init.
+int x; // déclaration (instruction)
+char c; // déclaration (instruction)
+x = 1; // affectation (expression)
+c = 'a'; // affectation (expression)
+int y = x; // déclaration et initialisation en même temps
+int a, b, c; // déclarations multiples
+a = b = c = 1; // init. multiples
+```
+
+# Les variables (1/2)
+
+## Variables et portée
+
+- Une variable est un identifiant, qui peut être liée à une valeur (un expression).
+- Une variable a une **portée** qui définit où elle est *visible* (où elle peut être accédée).
+- La portée est **globale** ou **locale**.
+- Une variable est **globale** est accessible à tout endroit d'un programme et doit être déclarée en dehors de toute fonction.
+- Une variable est **locale** lorsqu'elle est déclarée dans un **bloc**, `{...}`{.C}.
+- Une variable est dans la portée **après** avoir été déclarée.
+
+# Les variables (2/2)
+
+## Exemple
+
+```C
+float max; // variable globale accessible partout
+int foo() {
+ // max est visible ici
+ float a = max; // valide
+ // par contre les varibles du main() ne sont pas visibles
+}
+int main() {
+ // max est visible ici
+ int x = 1; // x est locale à main
+ {
+ // x est visible ici, y pas encore
+ // on peut par exemple pas faire x = y;
+ int y = 2;
+ } // y est détruite à la sortie du bloc
+} // x est à la sortie de main
+
+```
+
+<!-- TODO: quiz, compile, compile pas -->
+<!-- ```C
+int main() {
+ global = 1;
+} // COMPILE PAS
+```
+
+```C
+int main() {
+ int global = 1;
+ {
+ printf("global = %d", global);
+ }
+} // COMPILE
+```
+
+```C
+int local;
+
+int main() {
+ local = 1;
+ {
+ printf("local = %d", local);
+ }
+} // COMPILE
+```
+
+```C
+#include <stdio.h>
+int local = 0;
+
+int main() {
+ int local = -1;
+ {
+ int local = 1;
+ printf("local = %d\n", local);
+ }
+} // COMPILE
+``` -->
+
+# Quiz: compile ou compile pas?
+
+## [Quiz: compile ou compile pas](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033948)
+
+# Types de base (1/4)
+
+## Numériques
+
+Type Signification (**gcc pour x86-64**)
+---------------------------------- ---------------------------------------------
+`char`{.C}, `unsigned char`{.C} Entier signé/non-signé 8-bit
+`short`{.C}, `unsigned short`{.C} Entier signé/non-signé 16-bit
+`int`{.C}, `unsigned int`{.C} Entier signé/non-signé 32-bit
+`long`{.C}, `unsigned long`{.C} Entier signé/non-signé 64-bit
+`float`{.C} Nombre à virgule flottante, simple précision
+`double`{.C} Nombre à virgule flottante, double précision
+---------------------------------- ---------------------------------------------
+
+**La signification de `short`{.C}, `int`{.C}, ... dépend du compilateur et de l'architecture.**
+
+# Types de base (2/4)
+
+Voir `<stdint.h>` pour des représentations **portables**
+
+Type Signification
+---------------------------------- ---------------------------------------------
+`int8_t`{.C}, `uint8_t`{.C} Entier signé/non-signé 8-bit
+`int16_t`{.C}, `uint16_t`{.C} Entier signé/non-signé 16-bit
+`int32_t`{.C}, `uint32_t`{.C} Entier signé/non-signé 32-bit
+`int64_t`{.C}, `uint64_t`{.C} Entier signé/non-signé 64-bit
+---------------------------------- ---------------------------------------------
+
+. . .
+
+## Prenez l'habitude d'utiliser ces types-là!
+
+# Types de base (3/4)
+
+## Booléens
+
+- Le ANSI C n'offre pas de booléens.
+- L'entier `0`{.C} signifie *faux*, tout le reste *vrai*.
+- Depuis C99, la librairie `stdbool` met à disposition un type `bool`{.C}.
+- En réalité c'est un entier:
+ - $1 \Rightarrow$ `true`{.C}
+ - $0 \Rightarrow$ `false`{.C}
+- On peut les manipuler comme des entier (les sommer, les multiplier, ...).
+
+# Quiz: booléens
+
+## [Quiz: booléens](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1032492)
+
+<!-- TODO Quiz en ligne -->
+<!-- ```C
+if (42) { /* vrai */ }
+
+int x = 100;
+if (x == 4) { /* faux */ }
+if (x) { /* vrai */ }
+
+int x = 100;
+while (x−−) { /* répète tant que x est différent de 0 */ }
+
+if (0) { /* faux */ }
+if (i = 4) { /* vrai */ }
+if (i = 0) { /* faux */ }
+
+#include <stdbool.h>
+
+bool x = true;
+if (x) { /* vrai */ }
+``` -->
+
+# Types de base (4/4)
+
+## Conversions
+
+- Les conversions se font de manière:
+ - Explicite:
+ ```C
+ int a = (int)2.8;
+ double b = (double)a;
+ int c = (int)(2.8+0.5);
+ ```
+ - Implicite:
+ ```C
+ int a = 2.8; // warning, si activés, avec clang
+ double b = a + 0.5;
+ char c = b; // pas de warning...
+ int d = 'c';
+ ```
+
+# Quiz: conversions
+
+## [Quiz: conversions](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033446)
+
+<!-- TODO Quiz en ligne -->
+<!-- ```C
+int a = (int)2.8; // 2
+
+double b = 2.85;
+int c = b + 0.5; // 3
+
+int d = a + 0.5; // 2
+
+bool d = 2.78; // 1
+bool e = 1.0; // 1
+``` -->
+
+# Expressions et opérateurs (1/6)
+
+Une expression est tout bout de code qui est **évalué**.
+
+## Expressions simples
+
+- Pas d'opérateurs impliqués.
+- Les littéraux, les variables, et les constantes.
+
+```C
+const int L = -1; // 'L' est une constante, -1 un littéral
+int x = 0; // '0' est un litéral
+int y = x; // 'x' est une variable
+int z = L; // 'L' est une constante
+```
+
+## Expressions complexes
+
+- Obtenues en combinant des *opérandes* avec des *opérateurs*
+
+```C
+int x; // pas une expression (une instruction)
+x = 4 + 5; // 4 + 5 est une expression
+ // dont le résultat est affecté à 'x'
+```
+
+# Expressions et opérateurs (2/6)
+
+## Opérateurs relationnels
+
+Opérateurs testant la relation entre deux *expressions*:
+
+ - `(a opérateur b)` retourne `1`{.C} si l'expression s'évalue à `true`{.C}, `0`{.C} si l'expression s'évalue à `false`{.C}.
+
+| Opérateur | Syntaxe | Résultat |
+|-----------|--------------|----------------------|
+| `<`{.C} | `a < b`{.C} | 1 si a < b; 0 sinon |
+| `>`{.C} | `a > b`{.C} | 1 si a > b; 0 sinon |
+| `<=`{.C} | `a <= b`{.C} | 1 si a <= b; 0 sinon |
+| `>=`{.C} | `a >= b`{.C} | 1 si a >= b; 0 sinon |
+| `==`{.C} | `a == b`{.C} | 1 si a == b; 0 sinon |
+| `!=`{.C} | `a != b`{.C} | 1 si a != b; 0 sinon |
+
+# Expressions et opérateurs (3/6)
+
+## Opérateurs logiques
+
+| Opérateur | Syntaxe | Signification |
+|-----------|--------------|----------------------|
+| `&&`{.C} | `a && b`{.C} | ET logique |
+| `||`{.C} | `a || b`{.C} | OU logique |
+| `!`{.C} | `!a`{.C} | NON logique |
+
+# Quiz: opérateurs logiques
+
+## [Quiz: opérateurs logiques](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033629)
+
+<!-- TODO: Quiz -->
+<!-- ```C
+1 && 0 == 0
+7 && 3 == 1
+4 || 3 == 1
+!34 == 0
+!0 == 1
+
+Soit n un unsigned char initialisé à 127:
+!n == 0
+``` -->
+
+# Expressions et opérateurs (4/6)
+
+## Opérateurs arithmétiques
+
+| Opérateur | Syntaxe | Signification |
+|-----------|--------------|----------------------|
+| `+`{.C} | `a + b`{.C} | Addition |
+| `-`{.C} | `a - b`{.C} | Soustraction |
+| `*`{.C} | `a * b`{.C} | Multiplication |
+| `/`{.C} | `a / b`{.C} | Division |
+| `%`{.C} | `a % b`{.C} | Modulo |
+
+# Expressions et opérateurs (5/6)
+
+## Opérateurs d'assignation
+
+| Opérateur | Syntaxe | Signification |
+|-----------|--------------|---------------------------------------------|
+| `=`{.C} | `a = b`{.C} | Affecte la valeur `b` à la variable `a` |
+| | | et retourne la valeur de `b` |
+| `+=`{.C} | `a += b`{.C} | Additionne la valeur de `b` à `a` et |
+| | | assigne le résultat à `a`. |
+| `-=`{.C} | `a -= b`{.C} | Soustrait la valeur de `b` à `a` et |
+| | | assigne le résultat à `a`. |
+| `*=`{.C} | `a *= b`{.C} | Multiplie la valeur de `b` à `a` et |
+| | | assigne le résultat à `a`. |
+| `/=`{.C} | `a /= b`{.C} | Divise la valeur de `b` à `a` et |
+| | | assigne le résultat à `a`. |
+| `%=`{.C} | `a %= b`{.C} | Calcule le modulo la valeur de `b` à `a` et |
+| | | assigne le résultat à `a`. |
+
+# Expressions et opérateurs (6/6)
+
+## Opérateurs d'assignation (suite)
+
+| Opérateur | Syntaxe | Signification |
+|-----------|--------------|---------------------------------------------|
+| `++`{.C} | `++a`{.C} | Incrémente la valeur de `a` de 1 et |
+| | | retourne le résultat (`a += 1`). |
+| `--`{.C} | `--a`{.C} | Décrémente la valeur de `a` de 1 et |
+| | | retourne le résultat (`a -= 1`). |
+| `++`{.C} | `a++`{.C} | Retourne `a`{.C} et incrémente `a` de 1. |
+| `--`{.C} | `a--`{.C} | Retourne `a`{.C} et décrémente `a` de 1. |
+
+
+# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)
+
+## Syntaxe
+
+```C
+if (expression) {
+ instructions;
+} else if (expression) { // optionnel
+ // il peut y en avoir plusieurs
+ instructions;
+} else {
+ instructions; // optionnel
+}
+```
+
+```C
+if (x) { // si x s'évalue à `vrai`
+ printf("x s'évalue à vrai.\n");
+} else if (y == 8) { // si y vaut 8
+ printf("y vaut 8.\n");
+} else {
+ printf("Ni l'un ni l'autre.\n");
+}
+```
+
+# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/2)
+
+## Pièges
+
+```C
+int x, y;
+x = y = 3;
+if (x = 2)
+ printf("x = 2 est vrai.\n");
+else if (y < 8)
+ printf("y < 8.\n");
+else if (y == 3)
+ printf("y vaut 3 mais cela ne sera jamais affiché.\n");
+else
+ printf("Ni l'un ni l'autre.\n");
+ x = -1; // toujours évalué
+```
+
+# Quiz: `if ... else`{.C}
+
+## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
+
+
+# Structures de contrôle: `while`{.C}
+
+## La boucle `while`{.C}
+
+```C
+while (condition) {
+ instructions;
+}
+do {
+ instructions;
+} while (condition);
+```
+
+## La boucle `while`{.C}, un exemple
+
+```C
+int sum = 0; // syntaxe C99
+while (sum < 10) {
+ sum += 1;
+}
+do {
+ sum += 10;
+} while (sum < 100)
+```
+
+# Structures de contrôle: `for`{.C}
+
+## La boucle `for`{.C}
+
+```C
+for (expression1; expression2; expression3) {
+ instructions;
+}
+```
+
+## La boucle `for`{.C}
+
+```C
+int sum = 0; // syntaxe C99
+for (int i = 0; i < 10; i++) {
+ sum += i;
+}
+
+for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
+ printf("C'est plus ésotérique.\n");
+}
+```
+
+# Exercice: la factorielle
+
+Écrire un programme qui calcule la factorielle d'un nombre
+$$
+N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
+$$
+
+## Par groupe de 3: écrire un pseudo-code
+
+. . .
+
+```C
+int factorielle(int n) {
+ i = 1;
+ fact = 1;
+ pour i <= n {
+ fact *= i;
+ i += 1;
+ }
+}
+```
+
+# Exercice: la factorielle
+
+\footnotesize
+
+Écrire un programme qui calcule la factorielle d'un nombre
+$$
+N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
+$$
+
+## Par groupe de 3: écrire un code en C
+
+Quand vous avez fini postez le code sur le salon matrix.
+
+. . .
+
+```C
+#include <stdio.h>
+int main() {
+ int nb = 10;
+ int fact = 1;
+ int iter = 2;
+ while (iter <= nb) {
+ fact *= iter;
+ iter++;
+ }
+}
+```
+
+. . .
+
+## Comment améliorer ce code? (notez ça sur une feuille)
+
+
+# Entrées/sorties: `printf()`{.C} (1/2)
+
+## Généralités
+
+- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:
+
+ ```C
+ int printf(const char *format, ...);
+ ```
+- Nombre d'arguments variables.
+- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.
+- Les arguments suivants sont les expressions à afficher.
+
+# Entrées/sorties: `printf()`{.C} (2/2)
+
+## Exemple
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+ printf("Hello world.\n");
+ int val = 1;
+ printf("Hello world %d time.\n", val);
+ printf("%f squared is equal to %f.\n", 2.5, 2.5*2.5);
+ return EXIT_SUCCESS;
+}
+```
+
+# Entrées/sorties: `scanf()`{.C} (1/2)
+
+## Généralités
+
+- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:
+
+ ```C
+ int scanf(const char *format, ...);
+ ```
+
+- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).
+- Les arguments suivants sont les variables où sont stockées les valeurs lues.
+
+# Entrées/sorties: `scanf()`{.C} (2/2)
+
+## Exemple
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+ printf("Enter 3 numbers: \n");
+ int i, j, k;
+ scanf("%d %d %d", &i, &j, &k);
+ printf("You entered: %d %d %d\n", i, j, k);
+
+ return EXIT_SUCCESS;
+}
+```
+
+# Exercice: la factorielle en mieux
+
+## Individuellement
+
+1. Ajoutez des fonctionnalités à votre code.
+2. Écrivez l'algorithme de calcul de deux façon différentes.
+3. Pour celles et ceux qui ont fini pendant que les autres essaient: faites-le
+ en récursif (sans aide).
+
+. . .
+
+## Postez vos solutions sur matrix!
+
+
diff --git a/slides/cours_2.md b/slides/cours_2.md
index c43498fbd1c9be975f08a207ab600eebf3bca457..0be09fe01d85d6d1dc97e93a63e0dd4101831d45 100644
--- a/slides/cours_2.md
+++ b/slides/cours_2.md
@@ -1,5 +1,54 @@
+---
+title: "Introduction aux algorithmes"
+date: "2021-09-29"
+---
+
+# Exercice: test si un nombre est premier
+
+## Avec tout ce que vous avez appris aujourd'hui (groupe de 2):
+
+* Écrivez pour vous même le code testant si un nombre est premier.
+* Quels sont les ajouts possibles par rapport au début du cours?
+* Rencontrez-vous des problèmes éventuels de compilation?
+* Voyez-vous une façon de générer des nombres premiers avec votre programme?
+
+. . .
+
+## Implémentez-la et postez votre code sur le salon matrix.
+
+# Corrigé: enfin pas vraiment mais juste un possible
+
+\footnotesize
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdbool.h>
+int 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;
+ }
+ }
+ if (premier) {
+ printf("Le nombre %d est premier\n",nb);
+ } else {
+ printf("Le nombre %d n'est pas premier\n",nb);
+ }
+ return 0;
+}
+```
+
# Quelques algorithmes simples
+## Voyons quelques algorithmes supplémentaires
+
- Plus petit commun multiple (PPCM) de deux nombres
- Autre algorithme de calcul du PPCM de deux nombres
- Plus grand commun diviseur (PGCD) de deux nombres
diff --git a/slides/figs/matrix.png b/slides/figs/matrix.png
new file mode 100644
index 0000000000000000000000000000000000000000..7fc07f4c8b426af6d9b873f349c832844d92cf50
Binary files /dev/null and b/slides/figs/matrix.png differ
diff --git a/slides/intro.md b/slides/intro.md
new file mode 100644
index 0000000000000000000000000000000000000000..5b75c151f4f666d34599632fc172f6b1cb6d0d7d
--- /dev/null
+++ b/slides/intro.md
@@ -0,0 +1,69 @@
+---
+title: Introduction générale
+date: 2020-09-16
+---
+
+# La hotline
+
+Nom Mél Bureau
+-------------------- ------------------------------ --------------------
+Paul Albuquerque paul.albuquerque@hesge.ch B410
+Orestis Malaspinas orestis.malaspinas@hesge.ch A401
+-------------------- ------------------------------ --------------------
+
+Utilisez le libre service (l'horaire sera fixé prochainement).
+
+Salon de discussion [Matrix](https://matrix.to/#/!tuZtXjUSPbnRfBsFXv:matrix.org?via=matrix.org), installez [element.io](https://element.io).
+
+{width=20%}
+
+# Cyberlearn
+
+Tout le contenu de ce qu'on raconte se trouve sur cyberlearn:
+
+- Algorithmes et structures de données
+ - <https://cyberlearn.hes-so.ch/course/view.php?id=13941>
+ - Clé d'inscription: algo_2020_21
+
+- Programmation Sequentielle en C
+ - <https://cyberlearn.hes-so.ch/course/view.php?id=12399>
+ - Clé d'inscription: PS_2018
+
+# Organisation du module
+
+* Deux cours, 50% chacun.
+1. Algorithmes et structures de données:
+ * 1er semestre:
+ * bases de programmation en C jusqu'à Noël.
+ * algorithmique jusqu'à fin janvier.
+ * 2e semestre:
+ * algorithmique.
+ * Deux évaluations écrites par semestre.
+2. Programmation séquentielle en C
+ * Familiarisation avec l'environnement Linux.
+ * Travaux pratiques en C.
+ * Apprentissage du gestionnaire de versions: git.
+ * Plusieurs "petits" exercices illustrant les concepts d'algorithmique
+ (1-2 séances).
+ * Évaluations:
+ * Un projet de programmation.
+ * Une évaluation machine.
+
+# Sondage: expérience de programmation
+
+## [Sondage: expérience de linux](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1291283)
+
+## [Sondage: expérience de programmation](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1035242)
+
+**Installez un lecteur de QR code s'il-vous-plaît.**
+
+# Questions?
+
+- N'hésitez pas à poser des *questions*, nous sommes là pour ça! [^1]
+- Ne restez pas coincés pendant des jours sur un problème.
+- Utilisez le *libre-service*!
+- N'hésitez pas à faire des *retours*: *négatifs* ou *positifs*.
+
+[^1]: Chaque étudiant·e·s a un quota de 5 questions par semestre.
+
+
diff --git a/slides/metadata.yaml b/slides/metadata.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..74c008c186b25f02380fb3fc03d633deba9576b4
--- /dev/null
+++ b/slides/metadata.yaml
@@ -0,0 +1,9 @@
+---
+subtitle: "Programmation séquentielle en C, 2020-2021"
+author: "Orestis Malaspinas (A401), ISC, HEPIA"
+institute: En partie inspirés des slides de F. Glück, P. Albuquerque, et ma créativité sans limite
+lang: fr-CH
+revealjs-url: /reveal.js
+mathjaxurl: "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"
+---
+
diff --git a/slides/my_highlight.theme b/slides/my_highlight.theme
new file mode 100644
index 0000000000000000000000000000000000000000..1d80b47b144ca30f252d27a32e3d3775267c7bbb
--- /dev/null
+++ b/slides/my_highlight.theme
@@ -0,0 +1,204 @@
+{
+ "text-color": null,
+ "background-color": "#f0f0f0",
+ "line-number-color": "#aaaaaa",
+ "line-number-background-color": null,
+ "text-styles": {
+ "Other": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Attribute": {
+ "text-color": "#c4a000",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "SpecialString": {
+ "text-color": "#4e9a06",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Annotation": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": true,
+ "italic": true,
+ "underline": false
+ },
+ "Function": {
+ "text-color": "#000000",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "String": {
+ "text-color": "#4e9a06",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "ControlFlow": {
+ "text-color": "#204a87",
+ "background-color": null,
+ "bold": true,
+ "italic": false,
+ "underline": false
+ },
+ "Operator": {
+ "text-color": "#ce5c00",
+ "background-color": null,
+ "bold": true,
+ "italic": false,
+ "underline": false
+ },
+ "Error": {
+ "text-color": "#a40000",
+ "background-color": null,
+ "bold": true,
+ "italic": false,
+ "underline": false
+ },
+ "BaseN": {
+ "text-color": "#0000cf",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Alert": {
+ "text-color": "#ef2929",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Variable": {
+ "text-color": "#000000",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Extension": {
+ "text-color": null,
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Preprocessor": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": false,
+ "italic": true,
+ "underline": false
+ },
+ "Information": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": true,
+ "italic": true,
+ "underline": false
+ },
+ "VerbatimString": {
+ "text-color": "#4e9a06",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Warning": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": true,
+ "italic": true,
+ "underline": false
+ },
+ "Documentation": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": true,
+ "italic": true,
+ "underline": false
+ },
+ "Import": {
+ "text-color": null,
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Char": {
+ "text-color": "#4e9a06",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "DataType": {
+ "text-color": "#204a87",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Float": {
+ "text-color": "#0000cf",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Comment": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": false,
+ "italic": true,
+ "underline": false
+ },
+ "CommentVar": {
+ "text-color": "#8f5902",
+ "background-color": null,
+ "bold": true,
+ "italic": true,
+ "underline": false
+ },
+ "Constant": {
+ "text-color": "#000000",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "SpecialChar": {
+ "text-color": "#000000",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "DecVal": {
+ "text-color": "#0000cf",
+ "background-color": null,
+ "bold": false,
+ "italic": false,
+ "underline": false
+ },
+ "Keyword": {
+ "text-color": "#204a87",
+ "background-color": null,
+ "bold": true,
+ "italic": false,
+ "underline": false
+ }
+ }
+}