d11427274f28e3b6dad9dc655ce6b8b656846897 to main · algorithmique / cours

Some changes are not shown.

For a faster browsing experience, only 187 of 688 files are shown. Download one of the files below to see all changes.

README.md

+11
−7

Original line number
Diff line number
Diff line

# Remerciements et contributions

Merci aux contributeurs suivants pour leurs efforts (dans un ordre aléatoire):

Merci aux contributeurs suivants pour leurs efforts (dans un ordre alphabétique):

* P. Kunzli

* A. Boyer

* G. Legouic

* P. Albuquerque

* O. Malaspinas

* A. Escribano

* J. Bach

* A. Boyer

* M. Corboz

* M. Divià

* Y. El Hakouni

* A. Escribano

* P. Kunzli

* G. Legouic

* G. Marino Jarrin

* H. Radhwan

* I. Saroukhanian

* C. Volta

slides/.gitignore

+1
−4

Original line number
Diff line number
Diff line

*.pdf

*.json

*.err

*.markdown

*.html

index.md

.puppeteer.json

slides/Makefile

+3
−2

Original line number
Diff line number
Diff line

@@ -18,14 +18,15 @@ all: puppeteer $(PDF)

# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf

docker: docker-compose.yml

	docker-compose run slides

	docker compose run slides

docker_clean: docker-compose.yml

	docker-compose run slides clean

	docker compose run slides clean

puppeteer:

	@echo "Setting chromium to $(CHROMIUM) for puppeteer"

	@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json

	# @echo "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json

index.md: gen_index.sh

	$(shell ./gen_index.sh)

slides/cours_1.md

+10
−219

Original line number
Diff line number
Diff line

---

title: "Introduction aux algorithmes"

date: "2022-09-21"

title: "Introduction aux algorithmes I"

date: "2025-09-16"

---

# Qu'est-ce qu'un algorithme?

@@ -42,7 +42,7 @@ de résoudre typiquement une classe de problèmes ou effectuer un calcul.

. . .

* Opérateurs (arthimétiques / booléens)

* Opérateurs (arithmétiques / booléens)

* Boucles;

* Structures de contrôle;

* Fonctions;

@@ -79,7 +79,7 @@ booléen est_premier(nombre)

```C

booléen est_premier(nombre) // fonction

    soit i = 2;       // variable, type, assignation

    soit i = 2       // variable, type, assignation

    tant que i < nombre // boucle

        si nombre modulo i == 0 // expression typée

            retourne faux    // expression typée

@@ -99,7 +99,7 @@ bool est_premier(int nombre) {

        if (0 == nombre % i) { // is i divise nombre

            return false; // i n'est pas premier

        }

        i += 1; // sinon on incrémente i

        i = i + 1; // sinon on incrémente i

    }

    return true;

}

@@ -121,8 +121,8 @@ bool est_premier(int nombre) {

- Il existe une multitude d'options de compilation:

    ```bash

    $ gcc -O1 -std=c11 -Wall -Wextra -g porg.c -o prog 

    ```console

    $ gcc -O1 -std=c11 -Wall -Wextra -g prog.c -o prog 

    	-fsanitize=address 

    ```

    1. `-std=c11` utilisation de C11.

@@ -240,7 +240,7 @@ int main() {

# Quiz: compile ou compile pas?

## [Quiz: compile ou compile pas](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033948)

## [Quiz: compile ou compile pas](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501934)

# Types de base (1/4)

@@ -288,7 +288,7 @@ Type                               Signification

# Quiz: booléens

## [Quiz: booléens](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1032492)

## [Quiz: booléens](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501922)

<!-- TODO Quiz en ligne -->

<!-- ```C

@@ -332,7 +332,7 @@ if (x) { /* vrai */ }

# Quiz: conversions

## [Quiz: conversions](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033446)

## [Quiz: conversions](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501925)

<!-- TODO Quiz en ligne -->

<!-- ```C

@@ -347,212 +347,3 @@ 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");

}

```

slides/cours_2.md

+210
−10

Original line number
Diff line number
Diff line

---

title: "Introduction aux algorithmes"

date: "2022-09-28"

title: "Introduction aux algorithmes II"

date: "2025-09-23"

---

# Rappel (1/2)

# Rappel

* Quel est l'algorithme pour le calcul des nombres 1ers?

@@ -22,16 +22,216 @@ bool est_premier(int nombre) {

}

```

# Rappel (2/2)

# Expressions et opérateurs (1/6)

* Quelles structures de contrôles avons nous vues?

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=501928)

<!-- 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=501931)

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

}

```

* La boucle `while`,

* La boucle `do ... while`,

* La boucle `for`,

* La condition `if ... else if ... else`,

# Exercice: la factorielle

slides/intro.md

+18
−19

Original line number
Diff line number
Diff line

---

title: "Introduction générale"

date: "2022-09-20"

date: "2025-09-16"

---

# La hotline

@@ -11,10 +11,9 @@ Paul Albuquerque       paul.albuquerque@hesge.ch         B410

Orestis Malaspinas     orestis.malaspinas@hesge.ch       A401

--------------------   ------------------------------    --------------------

* Utilisez le libre service (l'horaire sera fixé prochainement).

* On va intensivement utiliser *Element*, installez le et utilisez le!

* Espace de discussion [Matrix](https://matrix.to/#/!aKYVlcclmPGYXQFxAK:matrix.org?via=matrix.org), installez [element.io](https://element.io).

- Utilisez le libre service (l'horaire sera fixé prochainement).

- On va intensivement utiliser *Element*, installez le et utilisez le!

- Espace de discussion Matrix: <https://rb.gy/ku5es>, installez [element.io](https://element.io).

    ![](figs/matrix_qr.png){width=20%}

@@ -23,31 +22,31 @@ Orestis Malaspinas     orestis.malaspinas@hesge.ch       A401

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_2021_22

  - <https://cyberlearn.hes-so.ch/course/view.php?id=7276>

  - Clé d'inscription: algo_2025_26

- Programmation Sequentielle en C

  - <https://cyberlearn.hes-so.ch/course/view.php?id=12399>

  - Clé d'inscription: prog_seq_2021_22

- Programmation séquentielle en C

  - <https://cyberlearn.hes-so.ch/course/view.php?id=7282>

  - Clé d'inscription: prog_seq_2025_26

# Organisation du module

* Deux cours, 50% chacun.

1. Algorithmes et structures de données:

## Cinq cours, 20% chacun.

1. Algorithmes et structures de données (2 semestres):

    * 1er semestre:

        * bases de programmation en C jusqu'à Noël.

        * bases de programmation en C jusqu'à Noël,

        * algorithmique jusqu'à fin janvier.

    * 2e semestre:

    * 2ème semestre:

        * algorithmique.

    * Deux évaluations écrites par semestre (1er: novembre et janvier).

2. Programmation séquentielle en C

    * Deux évaluations écrites par semestre (1er sem.: novembre et janvier).

2. Programmation séquentielle en C (2 semestres)

    * Familiarisation avec l'environnement Linux.

    * Travaux pratiques en C.

    * Apprentissage du gestionnaire de versions: git.

    * Plusieurs exercices illustrant les concepts d'algorithmique.

    * Évaluations:

        * Deux évaluations machine (1er semestre).

        * Probablement, une évaluation machine et un projet (2e semestre).

    * Évaluations (4 tests machine).

3. Programmation système (semestre de printemps)

slides/metadata.yaml

+3
−3

Original line number
Diff line number
Diff line

---

subtitle: "Algorithmique et structures de données, 2022-2023"

author: "P. Albuquerque (B410), P. Künzli et O. Malaspinas (A401), ISC, HEPIA"

institute: En partie inspirés des supports de cours de P. Albuquerque

subtitle: "Algorithmique et structures de données, 2025-2026"

author: "P. Albuquerque (B410) et O. Malaspinas (A401), ISC, HEPIA"

institute: En partie inspiré des supports de cours de P. Albuquerque

lang: fr-CH

revealjs-url: /reveal.js

mathjaxurl: "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"

slides_2022/Makefile0 → 100644

+61
−0

Original line number
Diff line number
Diff line

PDFOPTIONS = -t beamer

# PDFOPTIONS += -F pantable

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

HTML=$(MD:%.md=%.html) # Pour les fichier html on transforme .md -> .html

MARKDOWN=$(MD:%.md=%.markdown) # Pour les fichier markdown on transforme .md -> .markdown

CHROMIUM:=$(shell which chromium || which chromium-browser)

all: puppeteer $(PDF) 

# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf

docker: docker-compose.yml

	docker-compose run slides

docker_clean: docker-compose.yml

	docker-compose run slides clean

puppeteer:

	@echo "Setting chromium to $(CHROMIUM) for puppeteer"

	@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json

index.md: gen_index.sh

	$(shell ./gen_index.sh)

index.html: index.md

	pandoc -s $(OPTIONS) --css ../css/tufte-css/tufte.css -o $@ $^

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

	mkdir -p algo_cours

	cp *.pdf algo_cours

	cp index.html algo_cours

clean:

	rm -rf *.html *.pdf *.markdown yq_linux_amd64* index.md .puppeteer.json algo_cours *.err

.PHONY:	clean index.md puppeteer yq

Compare revisions

Source

Target

Files

Some changes are not shown.

README.md

slides/.gitignore

slides/Makefile

slides/cours_1.md

slides/cours_2.md

slides/intro.md

slides/metadata.yaml

slides_2022/Makefile