From 8e02f0662753f0e625cc3155af822c3a05651447 Mon Sep 17 00:00:00 2001
From: Orestis <orestis.malaspinas@pm.me>
Date: Thu, 23 Sep 2021 23:04:25 +0200
Subject: [PATCH] added course 1 and working on 2
---
slides/.gitignore | 2 +
slides/Makefile | 38 +++
slides/cours_1.md | 693 ++++++++++++++++++++++++++++++++++++++
slides/cours_2.md | 49 +++
slides/figs/matrix.png | Bin 0 -> 5335 bytes
slides/intro.md | 69 ++++
slides/metadata.yaml | 9 +
slides/my_highlight.theme | 204 +++++++++++
8 files changed, 1064 insertions(+)
create mode 100644 slides/.gitignore
create mode 100644 slides/Makefile
create mode 100644 slides/cours_1.md
create mode 100644 slides/figs/matrix.png
create mode 100644 slides/intro.md
create mode 100644 slides/metadata.yaml
create mode 100644 slides/my_highlight.theme
diff --git a/slides/.gitignore b/slides/.gitignore
new file mode 100644
index 0000000..021299b
--- /dev/null
+++ b/slides/.gitignore
@@ -0,0 +1,2 @@
+*.pdf
+*.err
diff --git a/slides/Makefile b/slides/Makefile
new file mode 100644
index 0000000..1403418
--- /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 0000000..81ca94e
--- /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 c43498f..0be09fe 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
GIT binary patch
literal 5335
zcmeAS@N?(olHy`uVBq!ia0y~yU}OMc4mJh`hM1xiX$%Y^^E_P~Ln`9l&b^&<dl#RJ
z|G)o>s~@GAuTAPa!sEU~ckMp5JqZjtO<N|{{rUChyZyg~3|x1D8u=LtPVabZ!u2PN
zfnfrNMnN(w!-3xB{?{4|3?~>xc5Gx~cyR3C@lp{6h9?YMcOn=W3LZarY{kXEP{hER
zw}ydXN8yJ;Syl!H%LXR%Fb0M@7C(0MF)=jAI5bLYGce@I)Wo<mGC1%pIM6G~z+ld2
zw{9^5g93ZNgJWC_4btrL*8>?CCNPs~?Ew*nnwpwDQ;)d+5BECFU)qy(Unt=3{#Y6N
zzH9RZqp$9t7H0fyw$HaE@2h_^F<7s%IJ&Yg@GYamvNa3`!rU1c7|gg<sGsX;3i|HC
z9?-7Jz`($;AWr|X?&J@TxdM3RU!J!*Iiz|W!_fz&XVOY^X3niU%fv7#OYC`3SFr5j
zTg(kf9~c@`M8X-?F~l$~nKU!I<|p5S9QL{Fis}BwQQlj#3;uX4-Tpan@v4Q7?_ZQU
z7o)wkYwh2cKh|GKasO;_vf$f1xzFm89ev}D+cRtkJ?nWl<;+}(cXmfi_o+YrvEohk
zPtgZC>@OLnl$^L}bs=2w)e}C38^<IVIPw|ze2P>{|0vZ=UBbq2{^lbGzmt{>3=C6h
zG;d#GoU+tvPnTU914F57>ggvZSI&$3lqP+0!k5E0!(YX%&UztoJakLf(U+m}j8{`K
zI44!v%-*;>d~ce}+tU|abnm2GTvcrOPd0PuvxjS~8>SwzZVc*NBX%(P-x9T~NlXl;
zhra&aQyeRG|Lk=h{oia8e9E>i2(4C^U|6tjR#ldD?3Gh9m>cGHFgBzIPMURrF-Mev
zp;Y1YG`@$EPOf7M-#VQ&)8>Wc^68uHK<Sl{Z(k!T!z+(MhqZC_JD9FKUKsU>ZNuUl
zUJMqjOWE#j^cP*bd7H6Y@4_tmWdDBCkh@oF85tM?PDz>yhBy1@W?bE;a*JO%oj0_+
zG#=#rA~#<bh7UU03>A};ikU)JEvoNHTeI-p%2a-aV^>R(*1cNyZW7-E-vvw9%yQSO
zDakU(9@x%Q!!yIPtt3$UGb4lR+S+KV26M~YbQY~jC#&DKUe7}ouKsNEZE@Y5={6CQ
zq*mRss_S|DBAaa;gQCVtPJV`Yt?Ue6{R9~}xK@;ezm<<>WVqe1qUr);#&tHuzq6N>
zFqAMzvtBtA>i;&(Y*n%4+TtSKtsLnxI<Mw|(i%fAU*6YHUsfXq4v{ZBLF@f=zAk)q
zBF;AOCBv(H`Eyr=7#JGzS!GVFQ0HS<G5t<Y^U{5@^-oXV%e11;;@in5q5dAvS^VB!
z-)X)4Pw}HAPMSAUEq;d{S9z?s{;#Iqf5Q{}S0_zcvAiHVmtn!O^1XNcj>X(nWe5=E
zzPX(1lx5)yhF6Y0V$XYKT(|wbp7(h@TafDM8|OXPtQtN>Fg6tO@~<z5VVt*g=EQ;$
zhObNJ3HCpcDn0*#;Yt35m5;36RvJmZU^u31rYv{TG^9WOFWZ7H)5CT@3wx{17EEe1
zeHA;0>xtygYf+DL40QiX6l^_E{hGPq<Mq$w%r~{4JxumzNN`MHU|@)tP`2BfseyGO
z0|P^X<1NO9aPhx)Z$&wTvEN+%<lgz(3yeA)Jgvd{b5>_;RXFSA9mm9=>aU;mB~SlL
zmP8uEgAD(4@%B|mt#A4N6nP-q>iJfZ!AAR~gY(ZVYNETX&oDFi^%*fRFsLuTap4O?
zg2%pp2@DJjzalrCV`7-I#ulqg5*I^S&Hr1Kf^m^^{7%TqUo8#V==IKY>+*K7SNqb|
zysg>q())U%EyIn#W0gzGj;(MEnH)a%f8u<vA5Y?ftC<+iOENMr9B^w4*~r*%=BoP2
z$M+h+k)5%{OH*OnF8*~4e(QfF_c(jqV<?L{bnO1};6qQ2JpM3G>XtC5Bw2d-+|KjX
z$y1t&CWX(PZ{F~^!Grxl%3_0Kpcp&nU7;>l!tk}6d7;UyWvA~m1gWQMKb+KBw`AF?
z_N@C|i=uMQ?KRsOZ(14pe~#a=$j73MOS8Bc%0y-dDx7Qznq1yipQWV6$j<QU6*DL&
zO;g$6#r-dN2@@Z~6;U<@h6Ph}85XEq&R1T3IB5N}uXnfTGBPk|JQZTlILX5BEv0DR
ziv>Yb+z%8Bi!jVt{eG!+!?coD+<#9^4;S_NIz@7G$omt0@~@<l<#OGvEf@WI!EjD;
z@vEY3?}FDcFgWn;PFt_m870$ycSUxFT*<qY?DttpcG-PhGWX)%ZF}sa%NaH-{>QUP
zo!iA%h~dMUeZs}*JyPYS+g|+v=j~^2TztwqwVupLDmymi$iL$+a_)lN_T*+K2g5f}
zi|BGtC_6mvZ8mQRs;cO>IQO{y)-6l^2<`Z}m(?HMtMLnxf2%FYANqZ2wsq>lU(eSp
z?3;Os@eIclW?|En>3gi08_qD_o!IwkukFnyW(G$8tOX1Xu`yN+>1)$Op7)r(iu{o3
z$-ZIn3}KC}rwjeW(&J+ow{fjt?-pL3lD<-GOBO#U))`G7hJM(3FD2x_+L&nFE%%qN
z{n)COE}O~&a$G`C;XN^ilkIDlbQnMLvUSr8d4E$)-Z=FCq@5GyoPMb`Y2WvxvTNs;
zmoOMJE#0>6<uo5(g|B+Ed>9x$tXU?tKg?!MjL)&~ncNI-Ry<`1@Ks<4&_9%7llJ1>
zn{drrOLQ3+7^GQ4CaB(iAQ^7Nu%TB1Waom9953c<D`9BL()t?u`^oQS<LOmS%ls0)
z_sxpBuh}$pqwmkZ7w&$H)tI?LQ<eb?9YnPJCtH@(x^}7kEqG>S?iIgz^)7Y)+^hSa
zgwMLVRsP#biB+?#t8Jx>mogW$L}{K{7;&sV$nx<;&6xtL-Z3P^)P{ckDEj{#0|Sfc
zWQF2qLff)tuR6)Wkh5|>`>I*}>p2*7c;_x!%DiET9`7TrfJrMeUDy>eI2h&~UBoOP
z^y0u2z6AFfQx|<;3-Hfk2)O?0L{aKG{r3!4#3HwrA2L=}IC*HM;q+C>pT6@>`WUda
zXr1IMsa4xNs~I+|`0b%~vS;U&CCm)xyHp*Q9eccC_1`;J)?Z2Sd%b4fi&c9c-)8Y#
zR4>ECaAonDELZk`>)$REwRN0hzI)1g=B$pj24`k?`!ZWGST*FcG91{s{yD>fKK0Pm
zk~^dC*WR0C&Tx;xjBAONCP+aL`-G%flM7x|JAKM^u<e|q-LQD=s?Orxpjv;&lNT48
zx?R<pX|EYSt(-yAox#D)({v@{ft}ZP`-JqTGcs7;TA@Bgc*zr~lfps_R~D}XJ0)z}
z66Oi2w`CWonaVQAI+%Z+q<-a8i?`4mz6Jk0%#`bQdFt4RsVBdF<1Kkuv_boT8>3Z2
z)z1}Cs{9jv>D`{D&)p#TXq9@mu)|lAfbU;8-tW#_`fJ6n=NXf<R(!GXJEvLAz|a)s
zXTad_w{K0{`$_Sa1TQ75S~<D+6dPm1f@#8_1ll4}ZB$z17s=1Sk!5+1fq}un!;s;F
zJLA`T({=o|isrI{Q<TBO^)Hzksur%j*5!V{N@z~R)%5>=E<c;kt@F2<;Z^49c`MGn
zT=VW^r1RT?sO%NRmWuwOZx8ohiLqhQTDmXanw4RFl)~drXXiTV%CM(+9*|qR{?|gL
zyu6TCt1as+HmrM}5yZ~GFlB<w?NzPJ3`V<_r!g{Ed#zIM3uZ|VHkqohw^HW*_h&x;
z?z!ZjueJ~WTflYv=JlJ&GWO@r#jayWcel0JA7xR(;P{a_n32J%VW9~VL-fy}Djrr>
z2_6Q9h6#G-m#u7h&SfCNR{bHD@j*>Y@@gFix7>-rtUn^I@4S7sLO;-Srr`1=VV?hk
zJ{J7(erflVmw~~i{WNEl*26hZ3csyhxA@ofS@Eq~AJ5+ve>Lvv`Hk!h)~hVn&eHmK
zswMdQt1_KeRwtPl8BD)|%BR#W<~5g&{Fh*42;Ep%&A`Cm70JTzs((`!yQTB(#R|-z
zJSt{?>YfzC%J7>{oEKNs>x2eeJmJZ<wRGOY`Hzo3)J*+j_OfTstc`9#$M^o#d(RLT
zctnzQ(x=~s{0thGu3EgD8xzoNR#|a%>W@t<4Axzij^VBB45ddWee@7Z*J@*M*wJpC
z`>1EZ^~*bRSH7Fd=MWrs^?IX!5pSuUFRxWY?A|#GRv%jK$Iq}pbG_J<$=oMRuk182
zWnf?kFkY51-zR1{M{q;wwXoX#e?%9|FqSrUuSlP}*D#A=Zm`AH>(_4i37)xd_hR{Z
z@$~g8w?=;qmQS6$bHO>&r-A`@r%b+bPRg%wMZSQx@VSrYHMK&2Pf<G;7o5$^VESs&
zUg4O+PUm8E&#<8QtE-;Qx0=3q=VE=?hQ%fIJhBJ+-29rD8tOLv-B|F2m7%m&)EnGd
zzrd*RbaVdhPX+<y{GgBvSiLNnpMk0AoJHpxcOyB*<ISf<6Jicu;R&{Cc=CJ>U+h&w
zzM6Y4!yST8ex7msqSn@Z%tEH(QPrW(i?$TignVITu+CCtUaHn9v?qK+=@zfIw>A4x
zY_9B-St}zi3T|wEdV2Dj=c|RR|0Umuv`1|zVQ9=KWUUap=y}gU<54g}LsgFK+H>cG
zL1luXhJ~l?76n-cuYLDFGcYh1ObK9U;7ibG>|<N+vu3fa>VBu!Tgq1c&i>>zt>=D^
ze^3ao?Al2?Uq9&#nh<Qokm_8YGg-;%_4{5%hEmnJKNuUT%me#fZVNGRcri8XieOl<
zF7)&yK83}}DPjx((*+r>Y-M6t*uJCZ$??q$4Z998ELbPXz`(FHCs2OF9QIuyr#TtC
z6yHiMeN;Gudp`G{SMMIVFq;O>dAq80@h$r&fyY<WSt|y}UzN*V@oQDx_CEp7z4l$O
zj*|Vk=-kq*cTboYZUibwu1NW`jA_j;c7}OV%N^Ff;$vv(DL>*Ry8JWS0<~rZ*Xvgz
zqpyZvoyPYdk}>pi-UHU=r}E6JT1t-uO%B=moNIz-R%rP;2B)R+Gng12GEU-Ka8GGH
zOX+K^$t^tj438Nm{a<k8)Db2Ih6R&8y}Ek(<jYfbT4upk49i1T=hR(EJC?cNo#9NL
zRrQ<K8LearT;HFiQ}u0S#M(9d3<5t&7EISTbw1ehsmNyIW13D38_setEC}(q5N4}5
zHzj;KH^VFbF5^cRyW+LN7#!A4nqbQyvH!BQs|ULS`-im-U5ogH85kG}K0P}>BjnvB
z#vYf%1RVwj2IiN_^|`+?bQuhUS{pYqFfi~e;b)K#d@p-k&2#Oc<zJoboll4Co_#0V
zNbcn2o1M8q;;HL2<(ajlt5R>L9J2I$WV2)G7Z!%c^ZoWLX`4Sg>euT7D_Q0m@-xg>
zSXA4aV)KIG)vo*3jAj;;Fg(tj(!<Um(SQ7Dx`&z!gM|O|6dQ&E6*hYI&PERz4pi(?
zdCbUg>~W#R;Zw)8kFR~Qxg+X@U(o98Ehe5vv%cp0t^2br(WrjTpU`7IKSdO#hIAz>
zZ#&7b>L@3}Jmu$4_!(A&GBDh@$jNYJ((+VSc7t^fdn6ec7;b1hn6s_AlZzp3%KINu
zpe)qj&w53>`S#zQ={aSfQ3M7Ch7&<gpXZ!Ad~K)ouUWCR3yQxjS@&?ugI6z2ANL-<
z==C-EnC6=!&R=aM`AgqEl|2yj+}^J2tJgbDhAY8B3|F>#MKU#*?_!c+jn$na*-$JL
z^0k@oKwzac8v{ebLLIMdCm0emM6Q9_;cJfkH0EI7Ir+W1V3TriIWq%8!z^RzY6b%p
zc?OSdwc77btUSK&N#=rgnKo1ZpL<aAX>yC_rRi5<{MM;|PCVZ~{Vl_!lMA@scdQee
zo%LSjVUKCwH&%vuQv*L29Q(?^(6WvpYvamq3<m-qY(2)nu<*tUhGUb<*-~CGyeed3
zV0aMSD0$Q}nU{fqVHek$ef+DQJmp;=eQDjnS2N1ZcN}my>wJ&F$uX#vo#F8zW(GON
z-EZ@{3)cT&o8Xfr>a})K$n&DQ@Ol}}`t*SB)myebZr`=7SYpNXMNg!%=KK&*_@Xz_
zONYH?<yQG1i`T0?m%kHdSiyDuEh8uf7#Oy3PPCaDZg)zqOm#lrynpu0s?pD_ZvUBf
z*>d3(!&SE74Zr5@x_WZOF7?yQ3@v`qqD(6ns5>ru$H~CJVESJBTMVO9KoED-R(1x4
z1wj{9@iK5QI@GQxdUq?!`qh>>=VsX6pPT3DcdvQ>i!U?WS=X$}{d5qNQM=3=WLdAI
z_>1Khtvmccs{WJDRhQV^p>wi=tS5N>WM^o}P-Rxt`JFq<ig%Lh>^a`Lhn_rt{^}Nk
z!|qcSKiBm<<T@alu-M^MOUZ)uDtYf&{2cdhRcC)x{kf1;;8wAz=cMnB>JPG%w*3hf
zKB}3P&XdpJ7xqtf@v+jJt#31|7(gYYKkFQ&5<V8I26--vL(4f<%q#Od5c+@8+RdBq
zPuXT{C7HfH%Vv)06~mJ=PG|3bWzHDtE>q3$V1=2To9-c%6IZq#-~0AF1H&(=xk-!+
zeiOG^uZ(J8SfIT!_rs=qhHdVL92gWjL`_&3?ByQy=$kA(#K<6K%OuBYaFb8X|6Ir+
z+h>fRXlFE)oYd*TJ|SeY-E^tXAY)(0{ha3cV)gEbdyFfj=Ox-d-uye<_tleqS0c`8
zoLl{Sc@`goSS;hD&KWv$p6t7l;`8fa%*HE!SA8@76a1Y8-0EjoFfHJ&9K)5ZQCTNN
z6MFv`b3J+05UlLZ?!fNAz96hO)1JBD)iqFdW5~KX;~T>Pk-TpP>likR{*TIcYb;>B
zajeXXeS_NE2vOF61<M&2UT7XUANb%97efO#yZH5CB=kqV<DGoPr}ON+puq5S^>bP0
Hl+XkKZP6_@
literal 0
HcmV?d00001
diff --git a/slides/intro.md b/slides/intro.md
new file mode 100644
index 0000000..5b75c15
--- /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 0000000..74c008c
--- /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 0000000..1d80b47
--- /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
+ }
+ }
+}
--
GitLab