7d11d4c7bc1b54ebd42ad42db3105e1399c1a9e9 to main · algorithmique / cours

Some changes are not shown.

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

README.md

+3 −0

Original line number	Diff line number	Diff line
		@@ -7,8 +7,11 @@ Merci aux contributeurs suivants pour leurs efforts (dans un ordre alphabétique
		* 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

+3 −3

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2023-09-19"
		title: "Introduction aux algorithmes I"
		date: "2025-09-16"
		---

		# Qu'est-ce qu'un algorithme?
		@@ -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

slides/cours_2.md

+3 −3

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2023-09-26"
		title: "Introduction aux algorithmes II"
		date: "2025-09-23"
		---

		# Rappel
		@@ -206,7 +206,7 @@ while (sum < 10) {
		}
		do {
		sum += 10;
		} while (sum < 100)
		} while (sum < 100);
		```

		# Structures de contrôle: `for`{.C}

slides/cours_3.md

+97 −27

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2023-10-03"
		title: "Introduction aux algorithmes III"
		date: "2025-09-30"
		---

		# Rappel (1/2)
		@@ -33,6 +33,92 @@ int main() {
		}
		```

		# Le calcul du PPCM (1/2)

		## Réusinage: Comment décrire une fonction qui ferait ce calcul (arguments, sorties)?

		. . .

		En `C` on pourrait la décrire comme

		```C
		int ppcm(int a, int b); // La signature de cette fonction
		```

		. . .

		## Algorithme

		Par groupe de 3 (5-10min):

		* réfléchissez à un algorithme alternatif donnant le PPCM de deux nombres;
		* écrivez l'algorithme en pseudo-code.

		. . .

		* Si un nombre, `p`, est multiple de `a` et de `b` alors il peut s'écrire `p = a * i = b * j` ou encore `p / a = i` et `p / b = j`.


		# Le calcul du PPCM (2/2)


		## Pseudo-code

		```C
		int ppcm(int a, int b) {
		for (i in [1, b]) {
		if a * i est divisible par b {
		return a * i
		}
		}
		}
		```

		# Le code du PPCM de 2 nombres (1/2)

		## Implémentez le pseudo-code et postez le code sur matrix (5min).

		. . .

		## Un corrigé possible


		```C
		#include <stdio.h>
		#include <stdlib.h>
		int main() {
		int n = 15, m = 12;
		int i = 1;
		while (n * i % m != 0) {
		i++;
		}
		printf("Le ppcm de %d et %d est %d\n", n, m, n*i);
		}
		```

		# Le code du PPCM de 2 nombres (2/2)

		## Corrigé alternatif

		```C
		#include <stdio.h>
		#include <stdlib.h>
		int main() {
		int res = n*m;
		for (int i = 2; i <= m; i++) {
		if (n * i % m == 0) {
		res = n * i;
		break;
		}
		}
		printf("Le ppcm de %d et %d est %d\n", n, m, res);
		}
		```





		# Le calcul du PGCD (1/5)

		## Définition
		@@ -89,7 +175,9 @@ PGCD(36, 90):

		# Le calcul du PGCD (3/5)

		## Transcrivez cet exemple en algorithme (groupe de 3) et codez-le (5-10min)!
		\footnotesize

		## Transcrivez cet exemple en algorithme et codez-le (5-10min)!

		. . .

		@@ -183,7 +271,7 @@ void main() {

		# Quelques algorithmes simples

		* Remplissage d'un tableau et recherche de la valeur minimal
		* Stockage d'une liste de nombre et recherche de la valeur minimale
		* Anagrammes
		* Palindromes
		* Crible d’Ératosthène
		@@ -196,8 +284,8 @@ void main() {

		\footnotesize

		* Objets de même type: leur nombre est connu à la compilation;
		* Stockés de façon contiguë en mémoire (très efficace);
		* Objets de même type: leur nombre est connu à la compilation
		* Stockés de façon contiguë en mémoire (très efficace)

		```C
		#define SIZE 10
		@@ -232,8 +320,7 @@ void main() {
		. . .

		* Considéré comme une mauvaise pratique: que se passe-t-il si `size == 1e9`?
		* On préfère utiliser l'allocation dynamique de mémoire pour ce genre de
		cas-là (spoiler du futur du cours).
		* On préfère utiliser l'allocation dynamique de mémoire pour ce genre de cas-là (spoiler du futur du cours).

		# Initialisation

		@@ -258,6 +345,7 @@ for (int i = 0; i < SIZE; ++i) {
		tab[i] = rand() / (double)RAND_MAX * 10.0 - 5.0;
		// tab[i] contient un double dans [-5;5]
		}
		int other_tab[4] = {0}; // pareil que {0, 0, 0, 0}
		```

		# Recherche du minimum dans un tableau (1/2)
		@@ -289,28 +377,10 @@ pour i de 1 à SIZE - 1
		int index = 0;
		float min = tab[0];
		for (int i = 1; i < SIZE; ++i) {
		if min > tab[i] {
		if (min > tab[i]) {
		min = tab[i];
		index = i;
		}
		}
		```

		# Tri par sélection (1/2)

		## Problématique

		Trier un tableau par ordre croissant.

		## Idée d'algorithme

		```C
		ind = 0
		tant que (ind < SIZE-1)
		Trouver le minimum du tableau, tab_min = min([ind:SIZE]).
		Échanger tab_min avec tab[ind]
		ind += 1
		```

slides/cours_4.md

+42 −657

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2023-10-10"
		title: "Introduction aux algorithmes IV"
		date: "2025-10-07"
		---

		# Rappel
		# Le tri par sélection

		\Huge Le tri par sélection

		# Tri par sélection (1/3)

		## Problématique

		Trier un tableau par ordre croissant.

		## Idée d'algorithme

		```C
		ind = 0
		tant que (ind < SIZE-1)
		Trouver le minimum du tableau, tab_min = min([ind:SIZE-1]).
		Échanger tab_min avec tab[ind]
		ind += 1
		```

		# Tri par sélection (2/3)

		## Quel est l'algorithme du tri par sélection?

		@@ -14,7 +34,7 @@ date: "2023-10-10"
		3. Échanger `tab[i]` et `tab[j]`.
		4. `i += 1` et revenir à 2, tant que `i < SIZE-1`.

		# Tri par sélection
		# Tri par sélection (3/3)

		## Implémentation par groupe de 3

		@@ -24,6 +44,10 @@ date: "2023-10-10"
		* Afficher le résultat trié;
		* Vérifier algorithmiquement que le résultat est bien trié.

		# Les chaînes de caractères

		\Huge Les chaînes de caractères

		# Un type de tableau particulier

		## Les chaînes de caractères
		@@ -122,6 +146,10 @@ char name[100] = "Paul is not 100 characters long.";

		# Les anagrammes

		\Huge Les anagrammes

		# Les anagrammes

		## Définition

		Deux mots sont des anagrammes l'un de l'autre quand ils contiennent les mêmes
		@@ -159,6 +187,12 @@ int main() { // pseudo C

		# Les palindromes

		\Huge Les palindromes

		# Les palindromes

		\footnotesize

		Mot qui se lit pareil de droite à gauche que de gauche à droite:

		. . .
		@@ -191,6 +225,10 @@ mot_tmp = revert(mot);
		return mot == mot_tmp;
		```

		# Le crible d'Ératosthène

		\Huge Le crible d'Ératosthène

		# Crible d'Ératosthène

		Algorithme de génération de nombres premiers.
		@@ -208,656 +246,3 @@ Algorithme de génération de nombres premiers.

		* Implémenter l'algorithme et le poster sur le salon `Element`.

		# Crible d'Ératosthène: solution

		\footnotesize

		```C
		#include <stdio.h>
		#include <stdbool.h>
		#define SIZE 51
		int main() {
		bool tab[SIZE];
		for (int i=0;i<SIZE;i++) {
		tab[i] = true;
		}
		for (int i = 2; i < SIZE; i++) {
		if (tab[i]) {
		printf("%d ", i);
		int j = i;
		while (j < SIZE) {
		j += i;
		tab[j] = false;
		}
		}
		}
		printf("\n");
		}
		```


		# Réusinage de code (refactoring)

		## Le réusinage est?

		. . .

		* le processus de restructuration d'un programme:
		* en modifiant son design,
		* en modifiant sa structure,
		* en modifiant ses algorithmes
		* mais en conservant ses fonctionalités.

		. . .

		## Avantages?

		. . .

		* Amélioration de la lisibilité,
		* Amélioration de la maintenabilité,
		* Réduction de la complexité.

		. . .

		## "Make it work, make it nice, make it fast", Kent Beck.

		. . .

		## Exercice:

		* Réusiner le code se trouvant sur
		[Cyberlearn](https://cyberlearn.hes-so.ch/pluginfile.php/703384/mod_resource/content/1/comprendre.c).

		# Tableau à deux dimensions (1/4)

		## Mais qu'est-ce donc?

		. . .

		* Un tableau où chaque cellule est un tableau.

		## Quels cas d'utilisation?

		. . .

		* Tableau à double entrée;
		* Image;
		* Écran (pixels);
		* Matrice (mathématique);

		# Tableau à deux dimensions (2/4)

		## Exemple: tableau à 3 lignes et 4 colonnes d'entiers

		+-----------+-----+-----+-----+-----+
		\| `indices` \| `0` \| `1` \| `2` \| `3` \|
		+-----------+-----+-----+-----+-----+
		\| `0` \| `7` \| `4` \| `7` \| `3` \|
		+-----------+-----+-----+-----+-----+
		\| `1` \| `2` \| `2` \| `9` \| `2` \|
		+-----------+-----+-----+-----+-----+
		\| `2` \| `4` \| `8` \| `8` \| `9` \|
		+-----------+-----+-----+-----+-----+

		## Syntaxe

		```C
		int tab[3][4]; // déclaration d'un tableau 4x3
		tab[2][1]; // accès à la case 2, 1
		tab[2][1] = 14; // assignation de 14 à la position 2, 1
		```

		# Tableau à deux dimensions (3/4)

		\footnotesize

		## Exercice:

		Déclarer et initialiser aléatoirement un tableau `50x100` avec des valeurs `0` à `255`

		. . .

		```C
		#define NX 50
		#define NY 100
		int tab[NX][NY];
		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NY; ++j) {
		tab[i][j] = rand() % 256; // 256 niveaux de gris
		}
		}
		```

		## Exercice: afficher le tableau

		. . .

		```C
		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NY; ++j) {
		printf("%d ", tab[i][j]);
		}
		printf("\n");
		}
		```

		# Tableau à deux dimensions (4/4)

		## Attention

		* Les éléments ne sont jamais initialisés.
		* Les bornes ne sont jamais vérifiées.

		```C
		int tab[3][2] = { {1, 2}, {3, 4}, {5, 6} };
		printf("%d\n", tab[2][1]); // affiche?
		printf("%d\n", tab[10][9]); // affiche?
		printf("%d\n", tab[3][1]); // affiche?
		```

		# La couverture de la reine

		* Aux échecs la reine peut se déplacer horizontalement et verticalement
		* Pour un échiquier `5x6`, elle couvre les cases comme ci-dessous

		+-----+-----+-----+-----+-----+-----+-----+
		\| ` ` \| `0` \| `1` \| `2` \| `3` \| `4` \| `5` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `0` \| `` \| ` ` \| `` \| ` ` \| `*` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `1` \| ` ` \| `` \| `` \| `*` \| ` ` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `2` \| `` \| `` \| `R` \| `` \| `` \| `*` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `3` \| ` ` \| `` \| `` \| `*` \| ` ` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `4` \| `` \| ` ` \| `` \| ` ` \| `*` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+

		## Exercice

		* En utilisant les conditions, les tableaux à deux dimensions, et des
		`char` uniquement.
		* Implémenter un programme qui demande à l'utilisateur d'entrer les
		coordonnées de la reine et affiche un tableau comme ci-dessus pour un
		échiquier `8x8`.

		## Poster le résultat sur `Element`

		# Types énumérés (1/2)

		* Un type énuméré: ensemble de variantes (valeurs constantes).
		* En `C` les variantes sont des entiers numérotés à partir de 0.

		```C
		enum days {
		monday, tuesday, wednesday,
		thursday, friday, saturday, sunday
		};
		```
		* On peut aussi donner des valeurs "custom"

		```C
		enum days {
		monday = 2, tuesday = 8, wednesday = -2,
		thursday = 1, friday = 3, saturday = 12, sunday = 9
		};
		```
		* S'utilise comme un type standard et un entier

		```C
		enum days d = monday;
		(d + 2) == tuesday + tuesday; // true
		```

		# Types énumérés (2/2)

		* Très utile dans les `switch ... case`{.C}

		```C
		enum days d = monday;
		switch (d) {
		case monday:
		// trucs
		break;
		case tuesday:
		printf("0 ou 1\n");
		break;
		}
		```
		* Le compilateur vous prévient qu'il en manque!

		# Utilisation des types énumérés

		## Réusiner votre couverture de la reine avec des `enum`

		# Représentation des nombres (1/2)

		* Le nombre `247`.

		## Nombres décimaux: Les nombres en base 10

		+--------+--------+--------+
		\| $10^2$ \| $10^1$ \| $10^0$ \|
		+--------+--------+--------+
		\| `2` \| `4` \| `7` \|
		+--------+--------+--------+

		$$
		247 = 2\cdot 10^2 + 4\cdot 10^1 + 7\cdot 10^0.
		$$

		# Représentation des nombres (2/2)

		* Le nombre `11110111`.

		## Nombres binaires: Les nombres en base 2

		+-------+-------+-------+-------+-------+-------+-------+-------+
		\| $2^7$ \| $2^6$ \| $2^5$ \| $2^4$ \| $2^3$ \| $2^2$ \| $2^1$ \| $2^0$ \|
		+-------+-------+-------+-------+-------+-------+-------+-------+
		\| `1` \| `1` \| `1` \| `1` \| `0` \| `1` \| `1` \| `1` \|
		+-------+-------+-------+-------+-------+-------+-------+-------+

		$$
		1\cdot 2^7 + 1\cdot 2^6 +1\cdot 2^5 +1\cdot 2^4 +0\cdot 2^3 +1\cdot 2^2
		+1\cdot 2^1 +1\cdot 2^0
		$$

		. . .

		$$
		= 247.
		$$

		# Conversion de décimal à binaire (1/2)

		## Convertir 11 en binaire?

		. . .

		* On décompose en puissances de 2 en partant de la plus grande possible

		```
		11 / 8 = 1, 11 % 8 = 3
		3 / 4 = 0, 3 % 4 = 3
		3 / 2 = 1, 3 % 2 = 1
		1 / 1 = 1, 1 % 1 = 0
		```
		* On a donc

		$$
		1011 \Rightarrow 1\cdot 2^3 + 0\cdot 2^2 + 1\cdot 2^1 + 1\cdot
		2^0=11.
		$$

		# Conversion de décimal à binaire (2/2)

		## Convertir un nombre arbitraire en binaire: 247?

		* Par groupe établir un algorithme.

		. . .

		## Algorithme

		1. Initialisation

		```C
		num = 247
		while (2^N < num) {
		N += 1
		}
		```

		. . .

		2. Boucle

		```C
		while (N >= 0) {
		bit = num / 2^N
		num = num % 2^N
		N -= 1
		}
		```

		# Les additions en binaire

		Que donne l'addition `1101` avec `0110`?

		* L'addition est la même que dans le système décimal

		```
		1101 8+4+0+1 = 13
		+ 0110 + 0+4+2+0 = 6
		------- -----------------
		10011 16+0+0+2+1 = 19
		```
		* Les entiers sur un ordinateur ont une précision fixée (ici 4 bits).
		* Que se passe-t-il donc ici?

		. . .

		## Dépassement de capacité: le nombre est "tronqué"

		* `10011 (19) -> 0011 (3)`.
		* On fait "le tour"."

		# Entier non-signés minimal/maximal

		* Quel est l'entier non-signé maximal représentable avec 4 bit?

		. . .

		$$
		(1111)_2 = 8+4+2+1 = 15
		$$

		* Quel est l'entier non-signé minimal représentable avec 4 bit?

		. . .

		$$
		(0000)_2 = 0+0+0+0 = 0
		$$

		* Quel est l'entier non-signé min/max représentable avec N bit?

		. . .

		$$
		0\mbox{ et }2^N-1.
		$$

		* Donc `uint32_t?` maximal est?

		. . .

		$$
		4294967295
		$$


		# Les multiplications en binaire (1/2)

		Que donne la multiplication de `1101` avec `0110`?

		* L'addition est la même que dans le système décimal

		```
		1101 13
		* 0110 * 6
		--------- --------------
		0000 78
		11010
		110100
		+ 0000000
		--------- --------------
		1001110 64+0+0+8+4+2+0
		```

		# Les multiplications en binaire (2/2)

		## Que fait la multiplication par 2?

		. . .

		* Décalage de un bit vers la gauche!

		```
		0110
		* 0010
		---------
		0000
		+ 01100
		---------
		01100
		```

		. . .

		## Que fait la multiplication par $2^N$?

		. . .

		* Décalade de $N$ bits vers la gauche!

		# Entiers signés (1/2)

		Pas de nombres négatifs encore...

		## Comment faire?

		. . .

		## Solution naïve:

		* On ajoute un bit de signe (le bit de poids fort):

		```
		00000010: +2
		10000010: -2
		```

		## Problèmes?

		. . .

		* Il y a deux zéros (pas trop grave): `10000000` et `00000000`
		* Les additions différentes que pour les non-signés (très grave)

		```
		00000010 2
		+ 10000100 + -4
		---------- ----
		10000110 = -6 != -2
		```

		# Entiers signés (2/2)

		## Beaucoup mieux

		* Complément à un:
		* on inverse tous les bits: `1001 => 0110`.

		## Encore un peu mieux

		* Complément à deux:
		* on inverse tous les bits,
		* on ajoute 1 (on ignore les dépassements).

		. . .

		* Comment écrit-on `-4` en 8 bits?

		. . .

		```
		4 = 00000100
		________
		-4 => 00000100

		11111011
		+ 00000001
		----------
		11111100
		```

		# Le complément à 2 (1/2)

		## Questions:

		* Comment on écrit `+0` et `-0`?
		* Comment calcule-t-on `2 + (-4)`?
		* Quel est le complément à 2 de `1000 0000`?

		. . .

		## Réponses

		* Comment on écrit `+0` et `-0`?

		```
		+0 = 00000000
		-0 = 11111111 + 00000001 = 100000000 => 00000000
		```
		* Comment calcule-t-on `2 + (-4)`?

		```
		00000010 2
		+ 11111100 + -4
		---------- -----
		11111110 -2
		```
		* En effet

		```
		11111110 => 00000001 + 00000001 = 00000010 = 2.
		```

		# Le complément à 2 (1/2)

		## Quels sont les entiers représentables en 8 bits?

		. . .

		```
		01111111 => 127
		10000000 => -128 // par définition
		```

		## Quels sont les entiers représentables sur $N$ bits?

		. . .

		$$
		-2^{N-1} ... 2^{N-1}-1.
		$$

		## Remarque: dépassement de capacité en `C`

		* Comportement indéfini!


		<!-- # TODO --

		<!-- ## Entiers, entiers non-signés -->

		<!-- ## Complément à 1, 2 -->

		<!-- ## Nombres à virgule flottante, simple/double précision -->

		# Types composés: `struct`{.C} (1/6)

		## Fractions

		* Numérateur: `int num`;
		* Dénominateur: `int denom`.

		## Addition

		```C
		int num1 = 1, denom1 = 2;
		int num2 = 1, denom2 = 3;
		int num3 = num1 * denom2 + num2 * denom1;
		int denom3 = denom1 * denom2;
		```

		## Pas super pratique....

		# Types composés: `struct`{.C} (2/6)

		## On peut faire mieux

		* Plusieurs variables qu'on aimerait regrouper dans un seul type: `struct`{.C}.

		```C
		struct fraction { // déclaration du type
		int32_t num, denom;
		}

		struct fraction frac; // déclaration de la variable frac
		```

		# Types composés: `struct`{.C} (3/6)

		## Simplifications

		- `typedef`{.C} permet de définir un nouveau type.

		```C
		typedef unsinged int uint;
		typedef struct fraction fraction_t;
		typedef struct fraction {
		int32_t num, denom;
		} fraction_t;
		```
		- L'initialisation peut aussi se faire avec

		```C
		fraction_t frac = {1, -2}; // num = 1, denom = -2
		fraction_t frac = {.denom = 1, .num = -2};
		fraction_t frac = {.denom = 1}; // argl! .num non initialisé
		fraction_t frac2 = frac; // copie
		```

		# Types composés: `struct`{.C} (4/6)

		## Pointeurs

		- Comme pour tout type, on peut avoir des pointeurs vers un `struct`{.C}.
		- Les champs sont accessible avec le sélecteur `->`{.C}

		```C
		fraction_t *frac; // on crée un pointeur
		frac->num = 1; // seg fault...
		frac->denom = -1; // mémoire pas allouée.
		```

		![La représentation mémoire de
		`fraction_t`.](figs/pointer_struct.svg){width=50%}

		# Types composés: `struct`{.C} (5/6)

		## Initialisation

		- Avec le passage par référence on peut modifier un struct en place.
		- Les champs sont accessible avec le sélecteur `->`{.C}

		```C
		void fraction_init(fraction_t *frac,
		int32_t re, int32_t im)
		{
		// hypothèse: frac a déjà été allouée
		frac->num = frac;
		frac->denom = denom;
		}
		int main() {
		fraction_t frac; // on alloue une fraction
		fraction_init(&frac, 2, -1); // on l'initialise
		}
		```

		# Types composés: `struct`{.C} (6/6)

		## Initialisation version copie

		* On peut allouer une fraction, l'initialiser et le retourner.
		* La valeur retournée peut être copiée dans une nouvelle structure.

		```C
		fraction_t fraction_create(int32_t re, int32_t im) {
		fraction_t frac;
		frac.num = re;
		frac.denom = im;
		return frac;
		}
		int main() {
		// on crée une fraction et on l'initialise
		// en copiant la fraction créé par fraction_create
		// deux allocation et une copie
		fraction_t frac = fraction_create(2, -1);
		}
		```

slides/cours_5.md

0 → 100644

+201 −0

Original line number	Diff line number	Diff line
		---
		title: "Tableaux à deux dimensions"
		date: "2025-10-14"
		---

		# Rappel / devoirs: Crible d'Ératosthène

		* But:
		- Générer tous les nombres premiers plus petits qu'un entier $N$,
		- en n'utilisant qu'un tableau de booléens,
		- et que des multiplications.
		* Exercice: Écrire l'algorithme en C.

		# Crible d'Ératosthène: solution

		\footnotesize

		```C
		#include <stdio.h>
		#include <stdbool.h>
		#define SIZE 51
		int main() {
		bool tab[SIZE];
		for (int i=0;i<SIZE;i++) {
		tab[i] = true;
		}
		for (int i = 2; i < SIZE; i++) {
		if (tab[i]) {
		printf("%d ", i);
		int j = i;
		while (j < SIZE) {
		j += i;
		tab[j] = false;
		}
		}
		}
		printf("\n");
		return EXIT_SUCCESS;
		}
		```

		# Réusinage de code (refactoring)

		## Le réusinage est?

		. . .

		* Le processus de restructuration d'un programme:
		* en modifiant son design,
		* en modifiant sa structure,
		* en modifiant ses algorithmes,
		* mais en conservant ses fonctionnalités.

		. . .

		## Avantages?

		. . .

		* Amélioration de la lisibilité;
		* Amélioration de la maintenabilité;
		* Réduction de la complexité.

		. . .

		## "Make it work, make it nice, make it fast", Kent Beck.

		. . .

		## Exercice:

		* Réusiner le code se trouvant sur
		[Cyberlearn](https://cyberlearn.hes-so.ch/pluginfile.php/703384/mod_resource/content/1/comprendre.c).

		# Les tableaux à deux dimensions

		\Huge Les tableaux à deux dimensions


		# Tableau à deux dimensions (1/4)

		## Mais qu'est-ce donc?

		. . .

		* Un tableau où chaque cellule est un tableau.

		## Quels cas d'utilisation?

		. . .

		* Tableau à double entrée;
		* Image;
		* Écran (pixels);
		* Matrice (mathématique);

		# Tableau à deux dimensions (2/4)

		## Exemple: tableau à 3 lignes et 4 colonnes d'entiers

		+-----------+-----+-----+-----+-----+
		\| `indices` \| `0` \| `1` \| `2` \| `3` \|
		+-----------+-----+-----+-----+-----+
		\| `0` \| `7` \| `4` \| `7` \| `3` \|
		+-----------+-----+-----+-----+-----+
		\| `1` \| `2` \| `2` \| `9` \| `2` \|
		+-----------+-----+-----+-----+-----+
		\| `2` \| `4` \| `8` \| `8` \| `9` \|
		+-----------+-----+-----+-----+-----+

		## Syntaxe

		```C
		int tab[3][4]; // déclaration d'un tableau 3 par 4
		tab[2][1]; // accès case: ligne 2, colonne 1
		tab[2][1] = 14; // assignation de 14 à la position 2, 1
		```

		# Tableau à deux dimensions (3/4)

		\footnotesize

		## Exercice:

		Déclarer et initialiser aléatoirement un tableau `50x100` avec des valeurs `0` à `255`

		. . .

		```C
		#define NX 50
		#define NY 100
		int tab[NX][NY];
		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NY; ++j) {
		tab[i][j] = rand() % 256; // 256 niveaux de gris
		}
		}
		```

		## Exercice: afficher le tableau

		. . .

		```C
		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NY; ++j) {
		printf("%d ", tab[i][j]);
		}
		printf("\n");
		}
		```

		# Tableau à deux dimensions (4/4)

		## Attention

		* Les éléments ne sont jamais initialisés.
		* Les bornes ne sont jamais vérifiées.

		```C
		int tab[3][2] = { {1, 2}, {3, 4}, {5, 6} };
		printf("%d\n", tab[2][1]); // affiche?
		printf("%d\n", tab[10][9]); // affiche?
		printf("%d\n", tab[3][1]); // affiche?
		```

		# La couverture de la reine

		\Huge La couverture de la reine

		# La couverture de la reine

		\footnotesize

		* Aux échecs, la reine peut se déplacer horizontalement et verticalement.
		* Pour un échiquier `5x6`, elle couvre les cases comme ci-dessous.

		+-----+-----+-----+-----+-----+-----+-----+
		\| ` ` \| `0` \| `1` \| `2` \| `3` \| `4` \| `5` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `0` \| `` \| ` ` \| `` \| ` ` \| `*` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `1` \| ` ` \| `` \| `` \| `*` \| ` ` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `2` \| `` \| `` \| `R` \| `` \| `` \| `*` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `3` \| ` ` \| `` \| `` \| `*` \| ` ` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+
		\| `4` \| `` \| ` ` \| `` \| ` ` \| `*` \| ` ` \|
		+-----+-----+-----+-----+-----+-----+-----+

		## Exercice

		* En utilisant les structures de contrôle, les tableaux à deux dimensions, et des
		`char` uniquement.
		* Implémenter un programme qui, à partir des
		coordonnées de la reine, affiche un tableau comme ci-dessus pour un
		échiquier `8x8`.

		## Poster le résultat sur `element`

slides/cours_6.md

0 → 100644

+449 −0

Original line number	Diff line number	Diff line
		---
		title: "Types énumérés, tri par fusion, récursivité"
		date: "2025-10-28"
		---

		# Les types énumérés

		\Huge Les types énumérés

		# Types énumérés (1/2)

		* Un type énuméré: ensemble de variantes (valeurs constantes).
		* En `C`, les variantes sont des entiers numérotés à partir de 0.

		```C
		enum days {
		monday, tuesday, wednesday,
		thursday, friday, saturday, sunday
		};
		```
		* On peut aussi donner des valeurs "custom"

		```C
		enum days {
		monday = 2, tuesday = 8, wednesday = -2,
		thursday = 1, friday = 3, saturday = 12, sunday = 9
		};
		```
		* S'utilise comme un type standard et un entier

		```C
		enum days d = monday;
		(d + 2) == monday + monday; // true
		```

		# Types énumérés (2/2)

		* Très utiles dans les `switch ... case`{.C}

		```C
		enum days d = monday;
		switch (d) {
		case monday:
		// trucs
		break;
		case tuesday:
		printf("0 ou 1\n");
		break;
		}
		```
		* Le compilateur vous prévient qu'il en manque!

		# Utilisation des types énumérés

		## Réusiner votre couverture de la reine avec des `enum`

		A faire à la maison comme exercice!

		# Le tri par fusion (merge sort)

		\Huge Le tri par fusion (merge sort)

		# Tri par fusion (merge sort)

		* Tri par comparaison.
		* Idée: deux listes triées sont fusionnées pour donner une liste triée plus longue.
		* Itérativement, on trie d'abord les paires de nombres, puis les groupes de 4 nombres, ensuite de 8, et ainsi de suite jusqu'à obtenir un tableau trié.
		<!-- * On simplifie ici: le tableau a une longueur de puissance de 2. -->

		<!-- Pour son implémentation, le tri par fusion nécessite d'utiliser une zone temporaire de stockage des données de taille égale à celle de la liste de nombres à trier. On considère le cas du tri d'une liste de nombres entiers stockés dans un tableau. -->

		# Principe de l'algorithme

		* Soit `taille` la taille du tableau à trier.
		* Pour `i = 0` à `entier(log2(taille))-1`:
		* Fusion des paires de sous-tableaux successifs de taille `2**i` (ou moins pour l'extrémité)

		. . .

		* Remarques:
		* Pour l'étape `i`, les sous-tableaux de taille `2**i` sont triés.
		* La dernière paire de sous-tableaux peut être incomplète (vide ou avec moins que `2**i` éléments).

		# Exemple de tri par fusion

		* Soit la liste de nombres entiers stockés dans un tableau de taille 9:

		\| 0 \| 1 \| 2 \| 3 \| 4 \| 5 \| 6 \| 7 \| 8 \|
		\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|
		\| 5 \| -5 \| 1 \| 6 \| 4 \| -6 \| 2 \| -9 \| 2 \|

		. . .

		* Fusion des éléments successifs (ce qui revient à les mettre dans l'ordre):

		\| étape \| 0 \| 1 \| 2 \| 3 \| 4 \| 5 \| 6 \| 7 \| 8 \|
		\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|:---:\|
		\| 0 \| \textcolor{red}{5} \| \textcolor{green}{-5} \| \textcolor{red}{1} \| \textcolor{green}{6} \| \textcolor{red}{4} \| \textcolor{green}{-6} \| \textcolor{red}{2} \| \textcolor{green}{-9} \| \textcolor{red}{2} \|
		\| 1 \| \textcolor{red}{-5} \| \textcolor{red}{5} \| \textcolor{green}{1} \| \textcolor{green}{6} \| \textcolor{red}{-6} \| \textcolor{red}{4} \| \textcolor{green}{-9} \| \textcolor{green}{2} \| \textcolor{red}{2} \|
		\| 2 \| \textcolor{red}{-5} \| \textcolor{red}{1} \| \textcolor{red}{5} \| \textcolor{red}{6} \| \textcolor{green}{-9} \| \textcolor{green}{-6} \| \textcolor{green}{2} \| \textcolor{green}{4} \| \textcolor{red}{2} \|
		\| 3 \| \textcolor{red}{-9} \| \textcolor{red}{-6} \| \textcolor{red}{-5} \| \textcolor{red}{1} \| \textcolor{red}{2} \| \textcolor{red}{4} \| \textcolor{red}{5} \| \textcolor{red}{6} \| \textcolor{green}{2} \|
		\| 4 \| -9 \| -6 \| -5 \| 1 \| 2 \| 2 \| 4 \| 5 \| 6 \|


		# Pseudo-code (autrement)

		```python
		rien tri_fusion(entier taille, entier tab[taille])
		entier tab_tmp[taille];
		entier nb_etapes = log_2(taille) + 1;
		pour etape de 0 a nb_etapes - 1:
		entier gauche = 0;
		entier t_tranche = 2**etape;
		tant que (gauche < taille):
		fusion(
		tab[gauche..gauche+t_tranche-1],
		tab[gauche+t_tranche..gauche+2*t_tranche-1],
		tab_tmp[gauche..gauche+2*t_tranche-1]);
		#bornes incluses
		gauche += 2*t_tranche;
		echanger(tab, tab_tmp);
		```


		# Algorithme de fusion possible

		## Une idée?

		. . .

		* Parcourir les deux tableaux jusqu'à atteindre la fin d'un des deux
		* Comparer l'élément courant des 2 tableaux
		* Écrire le plus petit élément dans le tableau résultat
		* Avancer de 1 dans les tableaux du plus petit élément et résultat
		* Copier les éléments du tableau restant dans le tableau résultat

		# La fonction de fusion (pseudo-code autrement)

		\footnotesize

		## Une idée?

		. . .

		```python
		# hyp: tab_g et tab_d sont triés
		rien fusion(entier tab_g[], entier tab_d[], entier res[]):
		entier g = taille(tab_g)
		entier d = taille(tab_d)
		entier i_g = 0, i_d = 0
		pour i = 0 à g + d:
		si i_g < g et i_d < d:
		si tab_g[i_g] < tab_d[i_d]:
		res[i] = tab_g[i_g]
		i_g = i_g + 1
		sinon:
		res[i] = tab_d[i_d]
		i_d = i_d + 1
		sinon si i_g < g:
		res[i] = tab_g[i_g]
		i_g = i_g + 1
		sinon si i_d < d:
		res[i] = tab_d[i_d]
		i_d = i_d + 1

		```


		# La récursivité

		\Huge La récursivité

		# La factorielle: Code impératif

		* Code impératif

		```C
		int factorial(int n) {
		int f = 1;
		for (int i = 1; i < n; ++i) {
		f *= i;
		}
		return f;
		}
		```

		# Exemple de récursivité (1/2)

		## La factorielle

		```C
		int factorial(int n) {
		if (n > 1) {
		return n * factorial(n - 1);
		} else {
		return 1;
		}
		}
		```

		. . .

		## Que se passe-t-il quand on fait `factorial(4)`?

		. . .

		## On empile les appels

		+----------------+----------------+----------------+----------------+
		\| \| \| \| `factorial(1)` \|
		+----------------+----------------+----------------+----------------+
		\| \| \| `factorial(2)` \| `factorial(2)` \|
		+----------------+----------------+----------------+----------------+
		\| \| `factorial(3)` \| `factorial(3)` \| `factorial(3)` \|
		+----------------+----------------+----------------+----------------+
		\| `factorial(4)` \| `factorial(4)` \| `factorial(4)` \| `factorial(4)` \|
		+----------------+----------------+----------------+----------------+

		# Exemple de récursivité (2/2)

		## La factorielle

		```C
		int factorial(int n) {
		if (n > 1) {
		return n * factorial(n - 1);
		} else {
		return 1;
		}
		}
		```

		. . .

		## Que se passe-t-il quand on fait `factorial(4)`?

		. . .

		## On dépile les calculs

		+----------------+----------------+----------------+----------------+
		\| `1` \| \| \| \|
		+----------------+----------------+----------------+----------------+
		\| `factorial(2)` \| `2 * 1 = 2` \| \| \|
		+----------------+----------------+----------------+----------------+
		\| `factorial(3)` \| `factorial(3)` \| `3 * 2 = 6` \| \|
		+----------------+----------------+----------------+----------------+
		\| `factorial(4)` \| `factorial(4)` \| `factorial(4)` \| `4 * 6 = 24` \|
		+----------------+----------------+----------------+----------------+

		# La récursivité (1/4)

		## Formellement

		* Une condition de récursivité - qui réduit les cas successifs vers...
		* Une condition d'arrêt - qui retourne un résultat

		## Pour la factorielle, qui est qui?

		```C
		int factorial(int n) {
		if (n > 1) {
		return n * factorial(n - 1);
		} else {
		return 1;
		}
		}
		```

		# La récursivité (2/4)

		## Formellement

		* Une condition de récursivité - qui réduit les cas successifs vers...
		* Une condition d'arrêt - qui retourne un résultat

		## Pour la factorielle, qui est qui?

		```C
		int factorial(int n) {
		if (n > 1) { // Condition de récursivité
		return n * factorial(n - 1);
		} else { // Condition d'arrêt
		return 1;
		}
		}
		```

		# La récursivité (3/4)

		## Exercice: trouver l'$\varepsilon$-machine pour un `double`

		. . .

		Rappelez-vous vous l'avez fait en style impératif plus tôt.

		. . .

		```C
		double epsilon_machine(double eps) {
		if (1.0 + eps != 1.0) {
		return epsilon_machine(eps / 2.0);
		} else {
		return eps;
		}
		}
		```

		# La récursivité (4/4)

		\footnotesize

		## Exercice: que fait ce code récursif?

		```C
		void recurse(int n) {
		printf("%d ", n % 2);
		if (n / 2 != 0) {
		recurse(n / 2);
		} else {
		printf("\n");
		}
		}
		recurse(13);
		```

		. . .

		```C
		recurse(13): n = 13, n % 2 = 1, n / 2 = 6,
		recurse(6): n = 6, n % 2 = 0, n / 2 = 3,
		recurse(3): n = 3, n % 2 = 1, n / 2 = 1,
		recurse(1): n = 1, n % 2 = 1, n / 2 = 0.

		// affiche: 1 0 1 1
		```

		. . .

		Affiche la représentation binaire d'un nombre!

		# Exercice: réusinage et récursivité (1/4)

		## Réusiner le code du PGCD avec une fonction récursive

		## Étudier l'exécution

		```C
		42 = 27 * 1 + 15
		27 = 15 * 1 + 12
		15 = 12 * 1 + 3
		12 = 3 * 4 + 0
		```

		# Exercice: réusinage et récursivité (2/4)

		## Réusiner le code du PGCD avec une fonction récursive

		## Étudier l'exécution

		```C
		42 = 27 * 1 + 15 \| PGCD(42, 27)
		27 = 15 * 1 + 12 \| PGCD(27, 15)
		15 = 12 * 1 + 3 \| PGCD(15, 12)
		12 = 3 * 4 + 0 \| PGCD(12, 3)
		```

		# Exercice: réusinage et récursivité (3/4)

		## Réusiner le code du PGCD avec une fonction récursive

		## Étudier l'exécution

		```C
		42 = 27 * 1 + 15 \| PGCD(42, 27)
		27 = 15 * 1 + 12 \| PGCD(27, 15)
		15 = 12 * 1 + 3 \| PGCD(15, 12)
		12 = 3 * 4 + 0 \| PGCD(12, 3)
		```

		## Effectuer l'empilage - dépilage

		. . .

		```C
		PGCD(12, 3) \| 3
		PGCD(15, 12) \| 3
		PGCD(27, 15) \| 3
		PGCD(42, 27) \| 3
		```

		# Exercice: réusinage et récursivité (4/4)

		## Écrire le code

		. . .

		```C
		int pgcd(int n, int m) {
		if (n % m > 0) {
		return pgcd(m, n % m);
		} else {
		return m;
		}
		}
		```

		# La suite de Fibonacci (1/2)

		## Règle

		$$
		\mathrm{Fib}(n) = \mathrm{Fib}(n-1) + \mathrm{Fib}(n-2),\quad
		\mathrm{Fib}(0)=0,\quad \mathrm{Fib}(1)=1.
		$$

		## Exercice: écrire la fonction $\mathrm{Fib}$ en récursif et impératif

		. . .

		## En récursif (6 lignes)

		```C
		int fib(int n) {
		if (n > 1) {
		return fib(n - 1) + fib(n - 2);
		}
		return n;
		}
		```

		# La suite de Fibonacci (2/2)

		## Et en impératif (11 lignes)

		```C
		int fib_imp(int n) {
		int fib0 = 0;
		int fib1 = 1;
		int fib = n == 0 ? fib0 : fib1;
		for (int i = 2; i < n; ++i) {
		fib = fib0 + fib1;
		fib0 = fib1;
		fib1 = fib;
		}
		return fib;
		}
		```

slides/cours_7.md

0 → 100644

+860 −0

Original line number	Diff line number	Diff line
		---
		title: "Récursivité, représentation des nombres, tris, et complexité"
		date: "2025-11-11"
		header-includes: \|
		\usepackage{xcolor}
		---

		# Rappel

		## La récursivité

		* Une condition de récursivité - qui réduit les cas successifs vers...
		* Une condition d'arrêt - qui retourne un résultat

		## Un exemple

		```C
		int factorial(int n) {
		if (n > 1) {
		return n * factorial(n - 1);
		} else {
		return 1;
		}
		}
		```

		# Exponentiation rapide

		\Huge L'exponentiation rapide ou indienne

		# Exponentiation rapide ou indienne (1/3)

		## But: Calculer $x^n$

		* Quel est l'algorithmie le plus simple que vous pouvez imaginer?

		. . .

		```C
		double pow(double x, int n) {
		if (0 == n) {
		return 1;
		}
		double p = x;
		for (int i = 1; i < n; ++i) {
		p = p * x; // p *= x
		}
		return p;
		}
		```

		* Combien de multiplication et d'assignations en fonction de `n`?

		. . .

		* `n` assignations et `n` multiplications.

		# Exponentiation rapide ou indienne (2/3)

		* Proposez un algorithme naïf et récursif

		. . .

		```C
		double pow(double x, int n) {
		if (n != 0) {
		return x * pow(x, n-1);
		} else {
		return 1;
		}
		}
		```

		# Exponentiation rapide ou indienne (3/3)

		## Le vrai algorithme

		* Si n est pair: calculer $\left(x^{n/2}\cdot x^{n/2}\right)$;
		* Si n est impair: calculer $x \cdot \left(x^{(n-1)/2}\right)^2=x\cdot x^{n-1}$.

		## Exercice: écrire l'algorithme récursif correspondant

		. . .

		```C
		double pow(double x, int n) {
		if (0 == n) {
		return 1;
		} else if (n % 2 == 0) {
		return pow(x, n / 2) * pow(x, n/2);
		} else {
		return x * pow(x, (n-1));
		}
		}
		```

		# Représentation des nombres

		\Huge La représentation des nombres

		# Représentation des nombres (1/2)

		* Le nombre `247`.

		## Nombres décimaux: Les nombres en base 10

		+--------+--------+--------+
		\| $10^2$ \| $10^1$ \| $10^0$ \|
		+--------+--------+--------+
		\| `2` \| `4` \| `7` \|
		+--------+--------+--------+

		$$
		247 = 2\cdot 10^2 + 4\cdot 10^1 + 7\cdot 10^0.
		$$

		# Représentation des nombres (2/2)

		* Le nombre `11110111`.

		## Nombres binaires: Les nombres en base 2

		+-------+-------+-------+-------+-------+-------+-------+-------+
		\| $2^7$ \| $2^6$ \| $2^5$ \| $2^4$ \| $2^3$ \| $2^2$ \| $2^1$ \| $2^0$ \|
		+-------+-------+-------+-------+-------+-------+-------+-------+
		\| `1` \| `1` \| `1` \| `1` \| `0` \| `1` \| `1` \| `1` \|
		+-------+-------+-------+-------+-------+-------+-------+-------+

		$$
		1\cdot 2^7 + 1\cdot 2^6 +1\cdot 2^5 +1\cdot 2^4 +0\cdot 2^3 +1\cdot 2^2
		+1\cdot 2^1 +1\cdot 2^0
		$$

		. . .

		$$
		= 247.
		$$

		# Conversion de décimal à binaire (1/2)

		## Convertir 11 en binaire?

		. . .

		* On décompose en puissances de 2 en partant de la plus grande possible

		```
		11 / 8 = 1, 11 % 8 = 3
		3 / 4 = 0, 3 % 4 = 3
		3 / 2 = 1, 3 % 2 = 1
		1 / 1 = 1, 1 % 1 = 0
		```
		* On a donc

		$$
		1011 \Rightarrow 1\cdot 2^3 + 0\cdot 2^2 + 1\cdot 2^1 + 1\cdot
		2^0=11.
		$$

		# Conversion de décimal à binaire (2/2)

		## Convertir un nombre arbitraire en binaire: 247?

		* Par groupe établir un algorithme.

		. . .

		## Algorithme

		1. Initialisation

		```C
		num = 247
		N = 0

		tant que (2^(N+1) < num) {
		N += 1
		}
		```

		. . .

		2. Boucle

		```C
		tant que (N >= 0) {
		bit = num / 2^N
		num = num % 2^N
		N -= 1
		}
		```

		# Les additions en binaire

		Que donne l'addition `1101` avec `0110`?

		* L'addition est la même que dans le système décimal

		```
		1101 8+4+0+1 = 13
		+ 0110 + 0+4+2+0 = 6
		------- -----------------
		10011 16+0+0+2+1 = 19
		```
		* Les entiers sur un ordinateur ont une précision fixée (ici 4 bits).
		* Que se passe-t-il donc ici?

		. . .

		## Dépassement de capacité: le nombre est "tronqué"

		* `10011 (19) -> 0011 (3)`.
		* On fait "le tour"."

		# Entier non-signés minimal/maximal

		* Quel est l'entier non-signé maximal représentable avec 4 bit?

		. . .

		$$
		(1111)_2 = 8+4+2+1 = 15
		$$

		* Quel est l'entier non-signé minimal représentable avec 4 bit?

		. . .

		$$
		(0000)_2 = 0+0+0+0 = 0
		$$

		* Quel est l'entier non-signé min/max représentable avec N bit?

		. . .

		$$
		0\mbox{ et }2^N-1.
		$$

		* Donc `uint32_t?` maximal est?

		. . .

		$$
		2^{32}-1=4'294'967'295
		$$


		# Les multiplications en binaire (1/2)

		Que donne la multiplication de `1101` avec `0110`?

		* La multiplication est la même que dans le système décimal

		```
		1101 13
		* 0110 * 6
		--------- --------------
		0000 78
		11010
		110100
		+ 0000000
		--------- --------------
		1001110 64+0+0+8+4+2+0
		```

		# Les multiplications en binaire (2/2)

		## Que fait la multiplication par 2?

		. . .

		* Décalage de un bit vers la gauche!

		```
		0110
		* 0010
		---------
		0000
		+ 01100
		---------
		01100
		```

		. . .

		## Que fait la multiplication par $2^N$?

		. . .

		* Décalage de $N$ bits vers la gauche!

		# Entiers signés (1/2)

		Pas de nombres négatifs encore...

		## Comment faire?

		. . .

		## Solution naïve:

		* On ajoute un bit de signe (le bit de poids fort):

		```
		00000010: +2
		10000010: -2
		```

		## Problèmes?

		. . .

		* Il y a deux zéros (pas trop grave): `10000000` et `00000000`
		* Les additions différentes que pour les non-signés (très grave)

		```
		00000010 2
		+ 10000100 + -4
		---------- ----
		10000110 = -6 != -2
		```

		# Entiers signés (2/2)

		## Beaucoup mieux

		* Complément à un:
		* on inverse tous les bits: `1001 => 0110`.

		## Encore un peu mieux

		* Complément à deux:
		* on inverse tous les bits,
		* on ajoute 1 (on ignore les dépassements).

		. . .

		* Comment écrit-on `-4` en 8 bits?

		. . .

		```
		4 = 00000100
		________
		-4 => 00000100

		11111011
		+ 00000001
		----------
		11111100
		```

		# Le complément à 2 (1/2)

		\footnotesize

		## Questions:

		* Comment on écrit `+0` et `-0`?
		* Comment calcule-t-on `2 + (-4)`?
		* Quel est le complément à 2 de `1000 0000`?

		. . .

		## Réponses

		* Comment on écrit `+0` et `-0`?

		```
		+0 = 00000000
		-0 = 11111111 + 00000001 = 100000000 => 00000000
		```
		* Comment calcule-t-on `2 + (-4)`?

		```
		00000010 2
		+ 11111100 + -4
		---------- -----
		11111110 -2
		```
		* En effet

		```
		11111110 => 00000001 + 00000001 = 00000010 = 2.
		```

		# Le complément à 2 (2/2)

		## Quels sont les entiers représentables en 8 bits?

		. . .

		```
		01111111 => 127
		10000000 => -128 // par définition
		```

		## Quels sont les entiers représentables sur $N$ bits?

		. . .

		$$
		-2^{N-1} ... 2^{N-1}-1.
		$$

		## Remarque: dépassement de capacité en `C`

		* Comportement indéfini!


		# Le tri rapide ou quicksort

		\Huge Tri rapide ou quicksort

		# Tri rapide ou quicksort (1/8)

		## Idée: algorithme `diviser pour régner` (`divide-and-conquer`)

		* Diviser: découper un problème en sous problèmes;
		* Régner: résoudre les sous-problèmes (souvent récursivement);
		* Combiner: à partir des sous problèmes résolu, calculer la solution.

		## Le pivot

		* Trouver le pivot, un élément qui divise le tableau en 2, tels que:
		1. Éléments à gauche sont plus petits que le pivot.
		2. Élements à droite sont plus grands que le pivot.

		# Tri rapide ou quicksort (2/8)

		## Algorithme `quicksort(tableau)`

		1. Choisir le pivot et l'amener à sa place:
		* Les éléments à gauche sont plus petits que le pivot.
		* Les éléments à droite sont plus grand que le pivot.
		2. `quicksort(tableau_gauche)` en omettant le pivot.
		3. `quicksort(tableau_droite)` en omettant le pivot.
		4. S'il y a moins de deux éléments dans le tableau, le tableau est trié.

		. . .

		Compris?

		. . .

		Non c'est normal, faisons un exemple.

		# Tri rapide ou quicksort (3/8)

		\footnotesize

		Deux variables sont primordiales:

		```C
		entier ind_min, ind_max; // les indices min/max des tableaux à trier
		```

		![Un exemple de quicksort.](figs/quicksort.svg)

		# Tri rapide ou quicksort (4/8)

		\footnotesize

		Deux variables sont primordiales:

		```C
		entier ind_min, ind_max; // les indices min/max des tableaux à trier
		```

		## Pseudocode: quicksort

		```python
		rien quicksort(entier tableau[], entier ind_min, entier ind_max)
		si (longueur(tab) > 1)
		ind_pivot = partition(tableau, ind_min, ind_max)
		si (longueur(tableau[ind_min:ind_pivot-1]) != 0)
		quicksort(tableau, ind_min, pivot_ind - 1)
		si (longueur(tableau[ind_pivot+1:ind_max]) != 0)
		quicksort(tableau, ind_pivot + 1, ind_max)
		```

		# Tri rapide ou quicksort (5/8)

		\footnotesize

		## Pseudocode: partition

		```C
		entier partition(entier tableau[], entier ind_min, entier ind_max)
		pivot = tableau[ind_max] // choix arbitraire
		i = ind_min
		j = ind_max-1
		tant que i < j:
		en remontant i trouver le premier élément > pivot
		en descendant j trouver le premier élément < pivot
		échanger(tableau[i], tableau[j])
		// les plus grands à droite
		// mettre les plus petits à gauche

		// on met le pivot "au milieu"
		échanger(tableau[i], tableau[ind_max])
		retourne i // on retourne l'indice pivot
		```

		# Tri rapide ou quicksort (6/8)

		## Exercice: implémenter les fonctions `quicksort` et `partition`

		. . .

		```C
		void quicksort(int size, int array[size], int first,
		int last)
		{
		if (first < last) {
		int midpoint = partition(size, array, first, last);
		if (first < midpoint - 1) {
		quicksort(size, array, first, midpoint - 1);
		}
		if (midpoint + 1 < last) {
		quicksort(size, array, midpoint + 1, last);
		}
		}
		}
		```


		# Tri rapide ou quicksort (7/8)

		\footnotesize

		## Exercice: implémenter les fonctions `quicksort` et `partition`

		```C
		int partition(int size, int array[size], int first, int last) {
		int pivot = array[last];
		int i = first - 1, j = last;
		do {
		do {
		i += 1;
		} while (array[i] < pivot && i < j);
		do {
		j -= 1;
		} while (array[j] > pivot && i < j);
		if (j > i) {
		swap(&array[i], &array[j]);
		}
		} while (j > i);
		swap(&array[i], &array[last]);
		return i;
		}
		```

		<!-- # Tri rapide ou quicksort (8/8)

		## Quelle est la complexité du tri rapide?

		. . .

		* Pire des cas plus: $\mathcal{O}(N^2)$
		* Quand le pivot sépare toujours le tableau de façon déséquilibrée ($N-1$
		éléments d'un côté $1$ de l'autre).
		* $N$ boucles et $N$ comparaisons $\Rightarrow N^2$.
		* Meilleur des cas (toujours le meilleur pivot): $\mathcal{O}(N\cdot \log_2(N))$.
		* Chaque fois le tableau est séparé en $2$ parties égales.
		* On a $\log_2(N)$ partitions, et $N$ boucles $\Rightarrow N\cdot
		\log_2(N)$.
		* En moyenne: $\mathcal{O}(N\cdot \log_2(N))$. -->

		# L'algorithme à la main

		## Exercice sur papier

		* Trier par tri rapide le tableau `[5, -2, 1, 3, 10, 15, 7, 4]`

		```C













		```

		# L'efficacité d'un algorithmique

		\Huge L'efficacité d'un algorithmique

		# Efficacité d'un algorithmique

		Comment mesurer l'efficacité d'un algorithme?

		. . .

		* Mesurer le temps CPU,
		* Mesurer le temps d'accès à la mémoire,
		* Mesurer la place prise mémoire,

		. . .

		Dépendant du matériel, du compilateur, des options de compilation, etc!

		## Mesure du temps CPU

		```C
		#include <time.h>
		struct timespec tstart={0,0}, tend={0,0};
		clock_gettime(CLOCK_MONOTONIC, &tstart);
		// some computation
		clock_gettime(CLOCK_MONOTONIC, &tend);
		printf("computation about %.5f seconds\n",
		((double)tend.tv_sec + 1e-9*tend.tv_nsec) -
		((double)tstart.tv_sec + 1e-9*tstart.tv_nsec));
		```

		# Programme simple: mesure du temps CPU

		## Preuve sur un [petit exemple](../source_codes/complexity/sum.c)

		```bash
		source_codes/complexity$ make bench
		RUN ONCE -O0
		the computation took about 0.00836 seconds
		RUN ONCE -O3
		the computation took about 0.00203 seconds
		RUN THOUSAND TIMES -O0
		the computation took about 0.00363 seconds
		RUN THOUSAND TIMES -O3
		the computation took about 0.00046 seconds
		```

		Et sur votre machine les résultats seront différents.

		. . .

		## Conclusion

		* Nécessité d'avoir une mesure indépendante du/de la
		matériel/compilateur/façon de mesurer/météo.

		# Analyse de complexité algorithmique (1/4)

		* On analyse le temps pris par un algorithme en fonction de la **taille de
		l'entrée**.

		## Exemple: recherche d'un élément dans une liste triée de taille N

		```C
		int sorted_list[N];
		bool in_list = is_present(N, sorted_list, elem);
		```

		* Plus `N` est grand, plus l'algorithme prend de temps sauf si...

		. . .

		* l'élément est le premier de la liste (ou à une position toujours la même).
		* ce genre de cas pathologique ne rentre pas en ligne de compte.

		# Analyse de complexité algorithmique (2/4)

		## Recherche linéaire

		```C
		bool is_present(int n, int tab[], int elem) {
		for (int i = 0; i < n; ++i) {
		if (tab[i] == elem) {
		return true;
		} else if (elem < tab[i]) {
		return false;
		}
		}
		return false;
		}
		```

		* Dans le meilleurs des cas il faut `1` comparaison.
		* Dans le pire des cas (élément absent p.ex.) il faut `n` comparaisons.

		. . .

		La complexité algorithmique est proportionnelle à `N`: on double la taille
		du tableau $\Rightarrow$ on double le temps pris par l'algorithme.

		# Analyse de complexité algorithmique (3/4)

		## Recherche dichotomique

		```C
		bool is_present_binary_search(int n, int tab[], int elem) {
		int left = 0;
		int right = n - 1;
		while (left <= right) {
		int mid = (right + left) / 2;
		if (tab[mid] < elem) {
		left = mid + 1;
		} else if (tab[mid] > elem) {
		right = mid - 1;
		} else {
		return true;
		}
		}
		return false;
		}
		```

		# Analyse de complexité algorithmique (4/4)

		## Recherche dichotomique

		![Source: [Wikipédia](https://upload.wikimedia.org/wikipedia/commons/a/aa/Binary_search_complexity.svg)](figs/Binary_search_complexity.svg){width=80%}

		. . .

		* Dans le meilleurs de cas il faut `1` comparaison.
		* Dans le pire des cas il faut $\log_2(N)+1$ comparaisons

		. . .

		## Linéaire vs dichotomique

		* $N$ vs $\log_2(N)$ comparaisons logiques.
		* Pour $N=1000000$: `1000000` vs `21` comparaisons.

		# Notation pour la complexité

		## Constante de proportionnalité

		* Pour la recherche linéaire ou dichotomique, on a des algorithmes qui sont $\sim N$ ou $\sim \log_2(N)$
		* Qu'est-ce que cela veut dire?

		. . .

		* Temps de calcul est $t=C\cdot N$ (où $C$ est le temps pris pour une comparaisons sur une machine/compilateur donné)
		* La complexité ne dépend pas de $C$.

		## Le $\mathcal{O}$ de Leibnitz

		* Pour noter la complexité d'un algorithme on utilise le symbole $\mathcal{O}$ (ou "grand Ô de").
		* Les complexités les plus couramment rencontrées sont

		. . .

		$$
		\mathcal{O}(1),\quad \mathcal{O}(\log(N)),\quad \mathcal{O}(N),\quad
		\mathcal{O}(\log(N)\cdot N), \quad \mathcal{O}(N^2), \quad
		\mathcal{O}(N^3).
		$$

		# Ordres de grandeur

		\begin{table}[!h]
		\begin{center}
		\caption{Valeurs approximatives de quelques fonctions usuelles de complexité.}
		\medskip
		\begin{tabular}{\|c\|c\|c\|c\|c\|}
		\hline
		$\log_2(N)$ & $\sqrt{N}$ & $N$ & $N\log_2(N)$ & $N^2$ \\
		\hline\hline
		$3$ & $3$ & $10$ & $30$ & $10^2$ \\
		\hline
		$6$ & $10$ & $10^2$ & $6\cdot 10^2$ & $10^4$ \\
		\hline
		$9$ & $31$ & $10^3$ & $9\cdot 10^3$ & $10^6$ \\
		\hline
		$13$ & $10^2$ & $10^4$ & $1.3\cdot 10^5$ & $10^8$ \\
		\hline
		$16$ & $3.1\cdot 10^2$ & $10^5$ & $1.6\cdot 10^6$ & $10^{10}$ \\
		\hline
		$19$ & $10^3$ & $10^6$ & $1.9\cdot 10^7$ & $10^{12}$ \\
		\hline
		\end{tabular}
		\end{center}
		\end{table}


		# Quelques exercices (1/3)

		## Complexité de l'algorithme de test de primalité naïf?

		```C
		for (i = 2; i < sqrt(N); ++i) {
		if (N % i == 0) {
		return false;
		}
		}
		return true;
		```

		. . .

		## Réponse

		$$
		\mathcal{O}(\sqrt{N}).
		$$

		# Quelques exercices (2/3)

		## Complexité de trouver le minimum d'un tableau?

		```C
		int min = MAX;
		for (i = 0; i < N; ++i) {
		if (tab[i] < min) {
		min = tab[i];
		}
		}
		return min;
		```

		. . .

		## Réponse

		$$
		\mathcal{O}(N).
		$$

		# Quelques exercices (3/3)

		## Complexité du tri par sélection?

		```C
		int ind = 0;
		while (ind < SIZE-1) {
		min = find_min(tab[ind:SIZE]);
		swap(min, tab[ind]);
		ind += 1;
		}
		```

		. . .

		## Réponse

		### `min = find_min`

		$$
		(N-1)+(N-2)+...+2+1=\sum_{i=1}^{N-1}i=N\cdot(N-1)/2=\mathcal{O}(N^2).
		$$

		## Finalement

		$$
		\mathcal{O}(N^2\mbox{ comparaisons}) + \mathcal{O}(N\mbox{swaps})=\mathcal{O}(N^2).
		$$

slides/exemples/pgcd.c

0 → 100644

+43 −0

Original line number	Diff line number	Diff line
		/*
		* entier pgcd(a, b):
		* v_min = min(a, b)
		* tant que a % v_min != 0 ou b % v_min != 0:
		* v_min -= 1
		* retourne v_min
		*/

		#include <stdio.h>

		int pgcd_1(int a, int b) {
		int v_min = a > b ? b : a;
		while (a % v_min != 0 \|\| b % v_min != 0) {
		v_min -= 1;
		}
		return v_min;
		}

		/*
		* entier pcgd(a, b):
		* tant que b != 0:
		* tmp = b
		* b = a % b
		* a = tmp
		*
		* return a
		*/

		int pgcd_2(int a, int b) {
		while (b != 0) {
		int tmp = b;
		b = a % b;
		a = tmp;
		}
		return a;
		}

		int main() {
		int a = 36;
		int b = 90;
		printf("pgcd_1(%d, %d) = %d\n", a, b, pgcd_1(a, b));
		printf("pgcd_2(%d, %d) = %d\n", a, b, pgcd_2(a, b));
		}

slides/exemples/queens.c

0 → 100644

+33 −0

Original line number	Diff line number	Diff line
		#include <stdlib.h>
		#include <stdio.h>

		#define NX 8

		int main() {
		int co = 1;
		int li = 2;

		char board[NX][NX];
		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NX; ++j) {
		board[i][j] = ' ';
		}
		}

		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NX; ++j) {
		if (i == co \|\| j == li \|\| i - j == co - li \|\| i + j == li + co) {
		board[i][j] = '*';
		}
		}
		}
		board[co][li] = 'R';
		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NX; ++j) {
		printf("%c ", board[i][j]);
		}
		printf("\n");
		}

		return EXIT_SUCCESS;
		}

slides/exemples/recursive.c

0 → 100644

+78 −0

Original line number	Diff line number	Diff line
		// factorial(n):
		// return 1 * 2 * 3 * .... * n
		// return n * factorial(n-1)
		// return n * (n-1) * factorial(n-2)
		// return n * (n-1) * (n-2) * factorial(n-3)
		// ....
		// return n * (n-1) * (n-2) * (n-3) * (n-4) * (n-5) * (n-6) * ... * (n-1000) * ...
		#include <stdio.h>
		#include <stdlib.h>

		int factorial(int n) {
		int prod = 1;
		for (int i = 1; i <= n; ++i) {
		prod *= i;
		}
		return prod;
		}

		// factorial_rec(5);
		// return 5 * factorial_rec(4);
		// return 5 * (4 * factorial_rec(3));
		// return 5 * (4 * (3 * factorial_rec(2)));
		// return 5 * (4 * (3 * (2 * factorial_rec(1))));
		// return 5 * (4 * (3 * (2 * 1)));
		int factorial_rec(int n) {
		if (n <= 1) {
		return 1;
		} else {
		return n * factorial_rec(n-1);
		}
		}

		double epsilon() {
		double eps = 1.0;
		while (1.0 != 1.0 + eps) {
		eps /= 2.0;
		}
		return eps;
		}

		double epsilon_rec(double eps) {
		if (1.0 != 1.0 + eps) {
		return epsilon_rec(eps / 2.0);
		}
		return eps;
		}

		int pgcd(int a, int b) {
		int rest = a % b;
		if (rest == 0) {
		return b;
		} else {
		return pgcd(b, rest);
		}
		}

		int fib(int n) {
		if (n == 0) {
		return 0;
		} else if (n == 1) {
		return 1;
		} else {
		return fib(n-2) + fib(n-1);
		}
		}

		int main() {
		int val = factorial(10);
		printf("val = %d\n", val);
		int val_rec = factorial_rec(10);
		printf("val_rec = %d\n", val_rec);
		printf("espilon = %g\n", epsilon());
		printf("espilon_rec = %g\n", epsilon_rec(1.0));
		printf("pgcd(27, 42) = %d\n", pgcd(27, 42));
		printf("fib(8) = %d\n", fib(8));

		return EXIT_SUCCESS;
		}

slides/exemples/refactoring.c

0 → 100644

+64 −0

Original line number	Diff line number	Diff line
		#include <stdio.h>
		#include <stdlib.h>
		#include <time.h>

		#define SIZE 10

		void initialization_tab(int size, double tab[size]) {
		for (int i = 0; i < size; ++i) {
		tab[i] = rand() / (double)RAND_MAX;
		}
		}

		void swap(double left, double right) {
		double tmp = *left; // déréférencement de left
		left = right;
		*right = tmp;
		}

		int index_min(int size, double tab[size], int i) {
		double min = tab[i];
		int ind_min = i;
		for (int j = i + 1; j < size; ++j) {
		if (min > tab[j]) {
		ind_min = j;
		min = tab[j];
		}
		}
		return ind_min;
		}

		void selection_sort(int size, double tab[size]) {
		for (int i = 0; i < size - 1; ++i) {
		// 1. Trouver l'indice auquel se trouve le minimum du tableau
		int ind_min = index_min(size, tab, i);
		// 2. Échanger la valeur minimale avec l'élément courant du tableau
		swap(&tab[i], &tab[ind_min]);
		}
		}

		void print_tab(int size, double tab[size]) {
		for (int i = 0; i < size; ++i) {
		printf("%f ", tab[i]);
		}
		printf("\n");
		}

		int is_sorted(int size, double tab[size]) {
		for (int i = 0; i < size - 1; ++i) {
		if (tab[i] > tab[i + 1]) {
		return EXIT_FAILURE;
		}
		}
		return EXIT_SUCCESS;
		}

		int main() {
		srand(0);
		// Déclaration: tableau
		double tab[SIZE];
		initialization_tab(SIZE, tab);
		selection_sort(SIZE, tab);
		print_tab(SIZE, tab);
		return is_sorted(SIZE, tab);
		}

slides/exemples/tab2d.c

0 → 100644

+32 −0

Original line number	Diff line number	Diff line
		#include <stdio.h>
		#include <stdlib.h>
		#include <time.h>

		void init(int nx, int ny, int tab[nx][ny]) {
		for (int i = 0; i < nx; ++i) {
		for (int j = 0; j < ny; ++j) {
		tab[i][j] = rand() % 256;
		}
		}
		}

		void print(int nx, int ny, int tab[nx][ny]) {
		for (int i = 0; i < nx; ++i) {
		for (int j = 0; j < ny; ++j) {
		printf("%d\t", tab[i][j]);
		}
		printf("\n");
		}
		}

		int main() {
		srand(time(NULL));
		int nx = 10;
		int ny = 20;

		int tab[nx][ny];
		init(nx, ny, tab);
		print(nx, ny, tab);

		return EXIT_SUCCESS;
		}

slides/intro.md

+13 −14

Original line number	Diff line number	Diff line
		---
		title: "Introduction générale"
		date: "2023-09-19"
		date: "2025-09-16"
		---

		# La hotline
		@@ -11,13 +11,11 @@ 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%}
		* Communauté lemmy: <https://lemmy.hepiapp.ch/c/algo>

		# Cyberlearn

		@@ -25,29 +23,30 @@ 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=7276>
		- Clé d'inscription: algo_2023_24
		- Clé d'inscription: algo_2025_26

		- Programmation Sequentielle en C
		- Programmation séquentielle en C
		- <https://cyberlearn.hes-so.ch/course/view.php?id=7282>
		- Clé d'inscription: prog_seq_2023_24
		- Clé d'inscription: prog_seq_2025_26


		# Organisation du module

		* Cinq cours, 20% chacun.
		## 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).
		* 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 (4 tests machine).
		3. Programmation système
		3. Programmation système (semestre de printemps)

slides/metadata.yaml

+2 −2

Original line number	Diff line number	Diff line
		---
		subtitle: "Algorithmique et structures de données, 2023-2024"
		subtitle: "Algorithmes et structures de données, 2025-2026"
		author: "P. Albuquerque (B410) et O. Malaspinas (A401), ISC, HEPIA"
		institute: En partie inspirés des supports de cours de P. Albuquerque
		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/cours_20.md

+1 −1

Original line number	Diff line number	Diff line
		@@ -429,7 +429,7 @@ rien compression_avec_pertes(arbre, theta)
		```C
		arbre = matrice_à_arbre(matrice)
		moyenne(arbre)
		compression_sans_pertes(arbre)
		compression_avec_pertes(arbre)
		```

		# La dynamique des corps célestes

slides_2022/cours_22.md

+1 −1

Original line number	Diff line number	Diff line
		@@ -157,7 +157,7 @@ booléen est_feuille(page)

		entier position(page, valeur)
		i = 0
		tant que i < page.nb && val >= page.tab[i+1].clef
		tant que i < page.nb && valeur >= page.tab[i+1].clef
		i += 1
		retourne i

slides_2023/.gitignore

0 → 100644

+6 −0

Original line number	Diff line number	Diff line
		*.pdf
		*.err
		*.markdown
		*.html
		index.md
		.puppeteer.json

slides_2023/Makefile

0 → 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

slides_2023/cours_1.md

0 → 100644

+349 −0

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2023-09-19"
		---

		# 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 (arithmé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
		booléen 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
		booléen 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 = 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:

		```console
		$ gcc -O1 -std=c11 -Wall -Wextra -g prog.c -o prog
		-fsanitize=address
		```
		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=501934)

		# 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=501922)

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

		<!-- 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
		``` -->

slides_2023/cours_10.md

0 → 100644

+338 −0

Original line number	Diff line number	Diff line
		---
		title: "Piles"
		date: "2023-12-05"
		---

		# Rappel

		## Qu'est-ce qu'une pile?

		. . .

		* Structure de données LIFO.

		## Quelles fonctionnalités?

		. . .

		1. Empiler (push): ajouter un élément sur la pile.
		2. Dépiler (pop): retirer l'élément du sommet de la pile et le retrouner.
		3. Liste vide? (is_empty?).
		4. Jeter un oeil (peek): retourner l'élément du sommet de la pile (sans le dépiler).
		5. Nombre d'éléments (length).

		# Structure de données (1/2)

		## Struct `stack`

		. . .

		```C
		#define MAX_CAPACITY 500
		typedef struct _stack {
		int data[MAX_CAPACITY]; // les données
		int top; // indice du sommet
		} stack;
		```

		# Structure de données (2/2)

		## Fonctions `stack`

		. . .

		```C
		void stack_init(stack *s) {
		s->top = -1;
		}
		bool stack_is_empty(stack s) {
		return s.top == -1;
		}
		void stack_push(stack *s, int val) {
		s->top += 1;
		s->data[s->top] = val;
		}
		int stack_pop(stack *s) {
		s->top -= 1;
		return s->data[s->top+1];
		}
		```

		# La pile dynamique

		## Comment modifier le code précédent pour avoir une taille dynamique?

		. . .

		```C
		// alloue une zone mémoire de size octets
		void *malloc(size_t size);
		// change la taille allouée à size octets (contiguïté garantie)
		void realloc(void ptr, size_t size);
		```

		. . .

		Attention: `malloc` sert à allouer un espace mémoire (pas de notion de tableau).

		## Et maintenant?

		. . .

		```C
		void stack_create(stack *s); // crée une pile avec une taille par défaut
		// vérifie si la pile est pleine et réalloue si besoin
		void stack_push(stack *s, int val);
		// vérifie si la pile est vide/trop grande
		// et réalloue si besoin
		void stack_pop(stack s, int ret);
		```

		. . .

		## Faisons l'implémentation ensemble

		# Le tri à deux piles (1/3)

		## Cas pratique

		![Un exemple de tri à deux piles](figs/tri_piles.svg){width=70%}

		# Le tri à deux piles (2/3)

		## Exercice: formaliser l'algorithme

		. . .

		## Algorithme de tri nécessitant 2 piles (G, D)

		Soit `tab` le tableau à trier:

		```C
		pour i de 0 à N-1
		tant que (tab[i] > que le sommet de G)
		dépiler G dans D
		tant que (tab[i] < que le sommet de D)
		dépiler de D dans G
		empiler tab[i] sur G
		dépiler tout D dans G
		tab est trié dans G
		```

		# Le tri à deux piles (3/3)

		## Exercice: trier le tableau `[2, 10, 5, 20, 15]`

		```C
















		```

		# La calculatrice (1/8)

		## Vocabulaire

		```C
		2 + 3 = 2 3 +,
		```

		`2` et `3` sont les opérandes, `+` l'opérateur.

		. . .

		## La notation infixe

		```C
		2 * (3 + 2) - 4 = 6.
		```

		## La notation postfixe

		```C
		2 3 2 + * 4 - = 6.
		```

		## Exercice: écrire `2 * 3 * 4 + 2` en notation `postfixe`

		. . .

		```C
		2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
		```

		# La calculatrice (2/8)

		## De infixe à post-fixe

		* Une pile est utilisée pour stocker opérateurs et parenthèses.
		* Les opérateurs on des priorités différentes.

		```C
		^ : priorité 3
		* / : priorité 2
		+ - : priorité 1
		( ) : priorité 0 // pas un opérateur mais bon
		```


		# La calculatrice (3/8)

		## De infixe à post-fixe: algorithme

		* On lit l'expression infixe de gauche à droite.

		* On examine le prochain caractère de l'expression infixe.
		* Si opérande, le placer dans l'expression du résultat.
		* Si parenthèse le mettre dans la pile (priorité 0).
		* Si opérateur, comparer sa priorité avec celui du sommet de la pile:
		* Si sa priorité est plus élevée, empiler.
		* Sinon dépiler l'opérateur de la pile dans l'expression du résultat et
		recommencer jusqu'à apparition d'un opérateur de priorité plus faible
		au sommet de la pile (ou pile vide).
		* Si parenthèse fermée, dépiler les opérateurs du sommet de la pile et les
		placer dans l'expression du résultat, jusqu'à ce qu'une parenthèse
		ouverte apparaisse au sommet, dépiler également la parenthèse.
		* Si il n'y a pas de caractère dans l'expression dépiler tous les
		opérateurs dans le résultat.

		# La calculatrice (4/8)

		## De infixe à post-fixe: exemple

		```C
		Infixe Postfixe Pile Priorité
		((A*B)/D-F)/(G+H) Vide Vide Néant
		(A*B)/D-F)/(G+H) Vide ( 0
		A*B)/D-F)/(G+H) Vide (( 0
		*B)/D-F)/(G+H) A (( 0
		B)/D-F)/(G+H) A ((* 2
		)/D-F)/(G+H) AB ((* 2
		/D-F)/(G+H) AB* ( 0
		D-F)/(G+H) AB* (/ 2
		-F)/(G+H) AB*D (/ 2
		F)/(G+H) AB*D/ (- 1
		)/(G+H) AB*D/F (- 1
		/(G+H) AB*D/F- Vide Néant
		```

		# La calculatrice (5/8)

		## De infixe à post-fixe: exemple

		```C
		Infixe Postfixe Pile Priorité
		((A*B)/D-F)/(G+H) Vide Vide Néant
		--------------------------------------------------------
		/(G+H) AB*D/F- Vide Néant
		(G+H) AB*D/F- / 2
		G+H) AB*D/F- /( 0
		+H) AB*D/F-G /( 0
		H) AB*D/F-G /(+ 1
		) AB*D/F-GH /(+ 1
		Vide AB*D/F-GH+ / 2
		Vide AB*D/F-GH+/ Vide Néant
		```

		# La calculatrice (6/8)

		\footnotesize

		## Exercice: écrire le code et le poster sur matrix

		* Quelle est la signature de la fonction?

		. . .

		* Une sorte de corrigé:

		```C
		char infix_to_postfix(char infix) { // init and alloc stack and postfix
		for (size_t i = 0; i < strlen(infix); ++i) {
		if (is_operand(infix[i])) {
		// we just add operands in the new postfix string
		} else if (infix[i] == '(') {
		// we push opening parenthesis into the stack
		} else if (infix[i] == ')') {
		// we pop everything into the postfix
		} else if (is_operator(infix[i])) {
		// this is an operator. We add it to the postfix based
		// on the priority of what is already in the stack and push it
		}
		}
		// pop all the operators from the s at the end of postfix
		// and end the postfix with `\0`
		return postfix;
		}
		```


		# La calculatrice (7/8)

		## Évaluation d'expression postfixe: algorithme

		* Chaque opérateur porte sur les deux opérandes qui le précèdent.
		* Le résultat d'une opération est un nouvel opérande qui est remis au
		sommet de la pile.

		## Exemple

		```C
		2 3 4 + * 5 - = ?
		```

		* On parcours de gauche à droite:

		```C
		Caractère lu Pile opérandes
		2 2
		3 2, 3
		4 2, 3, 4
		+ 2, (3 + 4)
		* 2 * 7
		5 14, 5
		- 14 - 5 = 9
		```

		# La calculatrice (8/8)

		## Évaluation d'expression postfixe: algorithme

		1. La valeur d'un opérande est toujours empilée.
		2. L'opérateur s'applique toujours au 2 opérandes au sommet.
		3. Le résultat est remis au sommet.

		## Exercice: écrire l'algorithme en C (et poster sur matrix)

		. . .

		```C
		bool evaluate(char postfix, double val) { // init stack
		for (size_t i = 0; i < strlen(postfix); ++i) {
		if (is_operand(postfix[i])) {
		stack_push(&s, postfix[i]);
		} else if (is_operator(postfix[i])) {
		double rhs = stack_pop(&s);
		double lhs = stack_pop(&s);
		stack_push(&s, op(postfix[i], lhs, rhs));
		}
		}
		return stack_pop(&s);
		}
		```

slides_2023/cours_11.md

0 → 100644

+765 −0

Original line number	Diff line number	Diff line
		---
		title: "Calculatrices, liste chaînée, et files d'attente"
		date: "2023-12-12"
		---

		# La calculatrice (Rappel)

		## Écrire `2 * 3 * 4 + 2` en notation `postfixe`

		. . .

		```C
		2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
		```

		## Quelle structure de données utiliser pour la calculatrice?

		. . .

		La pile!

		# La calculatrice (Rappel 2)

		\footnotesize

		## Quel est l'algorithme pour `infix_to_postfix`?

		. . .

		```C
		char infix_to_postfix(char infix) { // init and alloc stack and postfix
		for (size_t i = 0; i < strlen(infix); ++i) {
		if (is_operand(infix[i])) {
		// we just add operands in the new postfix string
		} else if (infix[i] == '(') {
		// we push opening parenthesis into the stack
		} else if (infix[i] == ')') {
		// we pop everything into the postfix
		} else if (is_operator(infix[i])) {
		// this is an operator. We add it to the postfix based
		// on the priority of what is already in the stack and push it
		}
		}
		// pop all the operators from the s at the end of postfix
		// and end the postfix with `\0`
		return postfix;
		}
		```


		# La calculatrice (nouveautés)

		## Évaluation d'expression postfixe: algorithme

		* Chaque opérateur porte sur les deux opérandes qui le précèdent.
		* Le résultat d'une opération est un nouvel opérande qui est remis au
		sommet de la pile.

		## Exemple

		```C
		2 3 4 + * 5 - = ?
		```

		* On parcours de gauche à droite:

		```C
		Caractère lu Pile opérandes
		2 2
		3 2, 3
		4 2, 3, 4
		+ 2, (3 + 4)
		* 2 * 7
		5 14, 5
		- 14 - 5 = 9
		```

		# La calculatrice (nouveautés 2)

		## Évaluation d'expression postfixe: algorithme

		1. La valeur d'un opérande est toujours empilée.
		2. L'opérateur s'applique toujours au 2 opérandes au sommet.
		3. Le résultat est remis au sommet.

		## Exercice: écrire l'algorithme en C (et poster sur matrix)

		. . .

		```C
		double evaluate(char *postfix) { // init stack
		for (size_t i = 0; i < strlen(postfix); ++i) {
		if (is_operand(postfix[i])) {
		stack_push(&s, postfix[i]);
		} else if (is_operator(postfix[i])) {
		double rhs = stack_pop(&s);
		double lhs = stack_pop(&s);
		stack_push(&s, op(postfix[i], lhs, rhs));
		}
		}
		return stack_pop(&s);
		}
		```



		# La liste chaînée et pile (1/6)

		## Structure de données

		* Chaque élément de la liste contient:
		1. une valeur,
		2. un pointeur vers le prochain élément.
		* La pile est un pointeur vers le premier élément.

		![Un exemple de liste chaînée.](figs/Singly-linked-list.svg){width=80%}

		# La liste chaînée et pile (2/6)

		## Une pile-liste-chaînée

		```C
		typedef struct _element {
		int data;
		struct _element *next;
		} element;
		typedef element* stack;
		```

		## Fonctionnalités?

		. . .

		```C
		void stack_create(stack s); // s = NULL;
		void stack_destroy(stack *s);
		void stack_push(stack *s, int val);
		void stack_pop(stack s, int val);
		void stack_peek(stack s, int *val);
		bool stack_is_empty(stack s); // reutrn NULL == stack;
		```

		# La liste chaînée et pile (3/6)

		## Empiler? (faire un dessin)

		. . .

		```C







		```

		## Empiler? (le code ensemble)

		. . .

		```C
		void stack_push(stack *s, int val) {
		element elem = malloc(sizeof(elem));
		elem->data = val;
		elem->next = *s;
		*s = elem;
		}
		```

		# La liste chaînée et pile (4/6)

		## Jeter un oeil? (faire un dessin)

		. . .

		```C







		```

		## Jeter un oeil? (le code ensemble)

		. . .

		```C
		void stack_peek(stack s, int *val) {
		*val = s->data;
		}
		```

		# La liste chaînée et pile (5/6)

		## Dépiler? (faire un dessin)

		. . .

		```C







		```

		## Dépiler? (le code ensemble)

		. . .

		```C
		void stack_pop(stack s, int val) {
		stack_peek(*s, val);
		element tmp = s;
		s = (s)->next;
		free(tmp);
		}
		```

		# La liste chaînée et pile (6/6)

		## Détruire? (faire un dessin)

		. . .

		```C







		```

		## Détruire? (le code ensemble)

		. . .

		```C
		void stack_destroy(stack *s) {
		while (!stack_is_empty(*s)) {
		int val;
		stack_pop(s, &val);
		}
		}
		```


		# La file d'attente (1/N)

		* Structure de données abstraite permettant le stockage d'éléments.
		* FIFO: First In First Out, ou première entrée première sortie.
		* Analogue de la vie "réelle"":
		* File à un guichet,
		* Serveur d'impressions,
		* Mémoire tampon, ...

		## Fonctionnalités

		. . .

		* Enfiler: ajouter un élément à la fin de la file.
		* Défiler: extraire un élément au devant de la file.
		* Tester si la file est vide.

		. . .

		* Lire l'élément de la fin de la file.
		* Lire l'élément du devant de la file.
		* Créer une liste vide.
		* Détruire une liste vide.

		# La file d'attente (2/N)

		\footnotesize

		## Implémentation possible

		* La structure file, contient un pointeur vers la tête et un vers le début de la file.
		* Entre les deux, les éléments sont stockés dans une liste chaînée.

		![Illustration d'une file d'attente.](figs/fig_queue_representation.png){width=80%}

		## Structure de données en C?

		. . .

		```C
		typedef struct _element { // Elément de liste
		int data;
		struct _element* next;
		} element;
		typedef struct _queue { // File d'attente:
		element* head; // tête de file d'attente
		element* tail; // queue de file d'attente
		} queue;
		```

		# Fonctionnalités d'une file d'attente

		## Creation et consultations

		. . .

		```C
		void queue_init(queue *fa); // head = tail = NULL
		bool queue_is_empty(queue fa); // fa.head == fa.tail == NULL
		int queue_tail(queue fa); // return fa.tail->data
		int queue_head(queue fa); // return fa.head->data
		```

		## Manipulations et destruction

		. . .

		```C
		void queue_enqueue(queue *fa, int val);
		// adds an element before the tail
		int queue_dequeue(queue *fa);
		// removes the head and returns stored value
		void queue_destroy(queue *fa);
		// dequeues everything into oblivion
		```

		# Enfilage

		## Deux cas différents:

		1. La file est vide (faire un dessin):

		. . .

		![Insertion dans une file d'attente vide.](./figs/fig_empty_queue_insert.png){width=40%}

		2. La file n'est pas vide (faire un dessin):

		. . .

		![Insertion dans une file d'attente non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}

		# Enfilage

		## Live (implémentation)

		. . .

		```C
		void queue_enqueue(queue *fa, int val) {
		element* elmt = malloc(sizeof(*elmt));
		elmt->data = val;
		elmt->next = NULL;
		if (queue_is_empty(*fa)) {
		fa->head = elmt;
		fa->tail = elmt;
		} else {
		fa->tail->next = elmt;
		fa->tail = elmt;
		}
		}
		```

		# Défilage

		## Trois cas différents

		1. La file a plus d'un élément (faire un dessin):

		. . .

		![Extraction d'une file d'attente](./figs/fig_queue_extract.png){width=80%}

		2. La file un seul élément (faire un dessin):

		. . .

		![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}


		3. La file est vide (problème)

		# Défilage

		## Live (implémentation)

		. . .

		```C
		int queue_dequeue(queue *fa) {
		element* elmt = fa->head;
		int val = elmt->data;
		fa->head = fa->head->next;
		free(elmt);
		if (NULL == fa->head) {
		fa->tail = NULL;
		}
		return val;
		}
		```

		. . .

		## Problème avec cette implémentation?

		# Destruction

		## Comment on faire la désallocation?

		. . .

		On défile jusqu'à ce que la file soit vide!

		# Complexité

		## Quelle sont les complexité de:

		* Enfiler?

		. . .

		* Défiler?

		. . .

		* Détruire?

		. . .

		* Est vide?


		# Implémentation alternative

		## Comment implémenter la file autrement?

		. . .

		* Données stockées dans un tableau;
		* Tableau de taille connue à la compilation ou pas (réallouable);
		* `tail` seraient les indices du tableau;
		* `capacity` seraient la capacité maximale;
		* On enfile "au bout" du tableau, au défile au début (indice `0`).

		. . .

		## Structure de données

		```C
		typedef struct _queue {
		int *data;
		int tail, capacity;
		} queue;
		```

		# File basée sur un tableau

		* Initialisation?

		. . .

		```C




		```

		* Est vide?

		. . .

		```C




		```


		* Enfiler?

		. . .

		```C




		```

		* Défiler?

		. . .

		```C




		```

		# Complexité

		## Quelle sont les complexités de:

		* Initialisation?

		. . .

		```C




		```

		* Est vide?

		. . .

		```C

		```


		* Enfiler?

		. . .

		```C




		```

		* Défiler?

		. . .

		```C




		```

		# Une file plus efficace

		## Comment faire une file plus efficace?

		* Où est-ce que ça coince?

		. . .

		* Défiler est particulièrement lent $\mathcal{O}(N)$.

		## Solution?

		. . .

		* Utiliser un indice séparé pour `head`.

		```C
		typedef struct _queue {
		int *data;
		int head, tail, capacity;
		} queue;
		```

		# Une file plus efficace (implémentation)

		## Enfilage

		\footnotesize

		```C
		void queue_enqueue(queue *fa, int val) {
		if ((fa->head == 0 && fa->tail == fa->capacity-1) \|\|
		(fa->tail == (fa->head-1) % (fa->capacity-1))) {
		return; // queue is full
		}
		if (fa->head == -1) { // queue was empty
		fa->head = fa->tail = 0;
		fa->data[fa->tail] = val;
		} else if (fa->tail == fa->capacity-1 && fa->head != 0) {
		// the tail reached the end of the array
		fa->tail = 0;
		fa->data[fa->tail] = val;
		} else {
		// nothing particular
		fa->tail += 1;
		fa->data[fa->tail] = val;
		}
		}
		```

		# Une file plus efficace (implémentation)

		## Défilage

		```C
		void queue_dequeue(queue fa, int val) {
		if (queue_is_empty(*fa)) {
		return; // queue is empty
		}
		*val = fa->data[fa->head];
		if (fa->head == fa->tail) { // that was the last element
		fa->head = fa->tail = -1;
		} else if (fa->head == fa->capacity-1) {
		fa->head = 0;
		} else {
		fa->head += 1;
		}
		}
		```


		# Les listes triées

		Une liste chaînée triée est:

		* une liste chaînée
		* dont les éléments sont insérés dans l'ordre.

		![Exemple de liste triée.](./figs/sorted_list_example.svg)

		. . .

		* L'insertion est faite telle que l'ordre est maintenu.

		## Quelle structure de données?

		```C





		```

		# Les listes triées

		## Quel but?

		* Permet de retrouver rapidement un élément.
		* Utile pour la recherche de plus court chemin dans des graphes.
		* Ordonnancement de processus par degré de priorité.

		## Comment?

		* Les implémentations les plus efficaces se basent sur les tableaux.
		* Possibles aussi avec des listes chaînées.

		# Les listes triées

		\footnotesize

		## Quelle structure de données dans notre cas?


		Une liste chaînée bien sûr (oui c'est pour vous entraîner)!

		```C
		typedef struct _element { // chaque élément
		int data;
		struct _element *next;
		} element;
		typedef element* sorted_list; // la liste
		```

		## Fonctionnalités

		```C
		// insertion de val
		sorted_list sorted_list_push(sorted_list list, int val);
		// la liste est-elle vide?
		bool is_empty(sorted_list list); // list == NULL
		// extraction de val (il disparaît)
		sorted_list sorted_list_extract(sorted_list list, int val);
		// rechercher un élément et le retourner
		element* sorted_list_search(sorted_list list, int val);
		```

		# L'insertion

		## Trois cas

		1. La liste est vide.

		. . .

		![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}

		. . .

		```C
		sorted_list sorted_list_push(sorted_list list, int val) {
		if (sorted_list_is_empty(list)) {
		list = malloc(sizeof(*list));
		list->data = val;
		list->next = NULL;
		return list;
		}
		}
		```

		# L'insertion

		2. L'insertion se fait en première position.

		. . .

		![Insertion en tête de liste, `list->data >=
		val`.](figs/sorted_list_insert_first.svg){width=80%}

		. . .

		```C
		sorted_list sorted_list_push(sorted_list list, int val) {
		if (list->data >= val) {
		element tmp = malloc(sizeof(tmp));
		tmp->data = val;
		tmp->next = list;
		list = tmp;
		return list;
		}
		}
		```

		# L'insertion

		3. L'insertion se fait sur une autre position que la première.

		. . .

		![Insertion sur une autre position, list->data <
		val.](figs/sorted_list_insert_any.svg){width=70%}

		. . .

		\footnotesize

		```C
		sorted_list sorted_list_push(sorted_list list, int val) {
		element tmp = malloc(sizeof(tmp));
		tmp->data = val;
		element *crt = list;
		while (NULL != crt->next && val > crt->next->data) {
		crt = crt->next;
		}
		tmp->next = crt->next;
		crt->next = tmp;
		return list;
		}
		```

slides_2023/cours_12.md

0 → 100644

+776 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_13.md

0 → 100644

+940 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_14.md

0 → 100644

+574 −0

Original line number	Diff line number	Diff line
		---
		title: "Tables de hachage"
		date: "2024-02-20"
		---

		# Les tables de hachage

		\Huge Les tables de hachage

		# Tableau vs Table

		## Tableau

		* Chaque élément (ou valeur) est lié à un indice (la case du tableau).

		```C
		annuaire tab[2] = {
		"+41 22 123 45 67", "+41 22 234 56 78", ...
		};
		tab[1] == "+41 22 123 45 67";
		```

		## Table

		* Chaque élément (ou valeur) est lié à une clé.

		```C
		annuaire tab = {
		// Clé , Valeur
		"Paul", "+41 22 123 45 67",
		"Orestis", "+41 22 234 56 78",
		};
		tab["Paul"] == "+41 22 123 45 67";
		tab["Orestis"] == "+41 22 234 56 78";
		```

		# Table

		## Définition

		Structure de données abstraite où chaque valeur (ou élément) est associée à une clé (ou
		argument).

		On parle de paires clé-valeur (key-value pairs).

		## Donnez des exemples de telles paires

		. . .

		* Annuaire (nom-téléphone),
		* Catalogue (objet-prix),
		* Table de valeur fonctions (nombre-nombre),
		* Index (nombre-page)
		* ...

		# Table

		## Opérations principales sur les tables

		* Insertion d'élément (`insert(clé, valeur)`{.C}), insère la paire `clé-valeur`
		* Consultation (`get(clé)`{.C}), retourne la `valeur` correspondant à `clé`
		* Suppression (`remove(clé)`{.C}), supprime la paire `clé-valeur`

		## Structure de données / implémentation

		Efficacité dépend de différents paramètres:

		* taille (nombre de clé-valeurs maximal),
		* fréquence d'utilisation (insertion, consultation, suppression),
		* données triées/non-triées,
		* ...

		# Consultation séquentielle (`sequential_get`)

		## Séquentielle

		* table représentée par un (petit) tableau ou liste chaînée,
		* types: `key_t` et `value_t` quelconques, et `key_value_t`

		```C
		typedef struct {
		key_t key;
		value_t value;
		} key_value_t;
		```
		* on recherche l'existence de la clé séquentiellement dans le tableau, on
		retourne la valeur.

		# Consultation séquentielle (`sequential_get`)

		## Implémentation? Une idée?

		. . .

		```C
		bool sequential_get(int n, key_value_t table[n], key_t key,
		value_t *value)
		{
		int pos = n - 1;
		while (pos >= 0) {
		if (key == table[pos].key) {
		*value = table[pos].value;
		return true;
		}
		pos--;
		}
		return false;
		}
		```

		. . .

		## Inconvénient?

		# Consultation séquentielle (`sequential_get`)

		## Exercice: implémenter la même fonction avec une liste chaînée

		Poster le résultat sur matrix.

		# Consultation dichotomique (`binary_get`)

		## Dichotomique

		* table représentée par un (petit) tableau trié par les clés,
		* types: `key_t` et `value_t` quelconques, et `key_value_t`
		* on recherche l'existence de la clé par dichotomie dans le tableau, on
		retourne la valeur,
		* les clés possèdent la notion d'ordre (`<, >, =` sont définis).

		# Consultation dichotomique (`binary_get`)

		\footnotesize

		## Implémentation? Une idée?

		. . .

		```C
		bool binary_get1(int n, key_value_t table[n], key_t key, value_t *value) {
		int top = n - 1, bottom = 0;
		while (top > bottom) {
		int middle = (top + bottom) / 2;
		if (key > table[middle].key) {
		bottom = middle+1;
		} else {
		top = middle;
		}
		}
		if (key == table[top].key) {
		*value = table[top].value;
		return true;
		} else {
		return false;
		}
		}
		```

		# Consultation dichotomique (`binary_get`)

		\footnotesize

		## Autre implémentation

		```C
		bool binary_get2(int n, key_value_t table[n], key_t key, value_t *value) {
		int top = n - 1, bottom = 0;
		while (true) {
		int middle = (top + bottom) / 2;
		if (key > table[middle].key) {
		bottom = middle + 1;
		} else if (key < table[middle].key) {
		top = middle;
		} else {
		*value = table[middle].value;
		return true;
		}
		if (top < bottom) {
		break;
		}
		}
		return false;
		}
		```

		## Quelle est la différence avec le code précédent?

		# Transformation de clé (hashing)

		## Problématique: Numéro AVS (13 chiffres)

		* Format: 106.3123.8492.13

		```
		Numéro AVS \| Nom
		0000000000000 \| -------
		... \| ...
		1063123849213 \| Paul
		... \| ...
		3066713878328 \| Orestis
		... \| ...
		9999999999999 \| -------
		```

		## Quelle est la clé? Quelle est la valeur?

		. . .

		* Clé: Numéro AVS, Valeur: Nom.

		## Nombre de clés? Nombre de citoyens? Rapport?

		. . .

		* $10^{13}$ clés, $10^7$ citoyens, $10^{-5}$ ($10^{-3}\%$ de la table est
		occupée) $\Rightarrow$ inefficace.
		* Pire: $10^{13}$ entrées ne rentre pas dans la mémoire d'un
		ordinateur.

		# Transformation de clé (hashing)

		## Problématique 2: Identificateurs d'un programme

		* Format: 8 caractères (simplification)

		```
		Identificateur \| Adresse
		aaaaaaaa \| -------
		... \| ...
		resultat \| 3aeff
		compteur \| 4fedc
		... \| ...
		zzzzzzzz \| -------
		```

		## Quelle est la clé? Quelle est la valeur?

		. . .

		* Clé: Identificateur, Valeur: Adresse.

		## Nombre de clés? Nombre d'identificateur d'un programme? Rapport?

		. . .

		* $26^{8}\sim 2\cdot 10^{11}$ clés, $2000$ identificateurs, $10^{-8}$ ($10^{-6}\%$ de la table est
		occupée) $\Rightarrow$ un peu inefficace.

		# Fonctions de transformation de clé (hash functions)

		* La table est représentée avec un tableau.
		* La taille du tableau est beaucoup plus petit que le nombre de clés.
		* On produit un indice du tableau à partir d'une clé:
		$$
		h(key) = n,\quad n\in\mathbb{N}.
		$$
		En français: on transforme `key` en nombre entier qui sera l'indice dans le
		tableau correspondant à `key`.

		## La fonction de hash

		* La taille du domaine des clés est beaucoup plus grand que le domaine des
		indices.
		* Plusieurs indices peuvent correspondre à la même clé:
		* Il faut traiter les collisions.
		* L'ensemble des indices doit être plus petit ou égal à la taille de la table.

		## Une bonne fonction de hash

		* Distribue uniformément les clés sur l'ensemble des indices.

		# Fonctions de transformation de clés: exemples

		## Méthode par troncature

		\begin{align*}
		&h: [0,9999]\rightarrow [0,9]\\
		&h(key)=\mbox{troisième chiffre du nombre.}
		\end{align*}

		```
		Key \| Index
		0003 \| 0
		1123 \| 2 \
		1234 \| 3 \|-> collision.
		1224 \| 2 /
		1264 \| 6
		```

		## Quelle est la taille de la table?

		. . .

		C'est bien dix oui.

		# Fonctions de transformation de clés: exemples

		## Méthode par découpage

		Taille de l'index: 3 chiffres.

		```
		key = 321 991 24 -> 321
		991
		+ 24
		----
		1336 -> index = 336
		```

		## Devinez l'algorithme?

		. . .

		On part de la gauche:

		1. On découpe la clé en tranche de longueur égale à celle de l'index.
		2. On somme les nombres obtenus.
		3. On tronque à la longueur de l'index.

		# Fonctions de transformation de clés: exemples

		## Méthode multiplicative

		Taille de l'index: 2 chiffres.

		```
		key = 5486 -> key^2 = 30096196 -> index = 96
		```

		On prend le carré de la clé et on garde les chiffres du milieu du résultat.

		# Fonctions de transformation de clés: exemples

		## Méthode par division modulo

		Taille de l'index: `N` chiffres.

		```
		h(key) = key % N.
		```

		## Quelle doit être la taille de la table?

		. . .

		Oui comme vous le pensiez au moins `N`.

		# Traitement des collisions

		## La collision

		```
		key1 != key2, h(key1) == h(key2)
		```

		## Traitement (une idée?)

		. . .

		* La première clé occupe la place prévue dans le tableau.
		* La deuxième (troisième, etc.) est placée ailleurs de façon déterministe.

		Dans ce qui suit la taille de la table est `table_size`.

		# La méthode séquentielle

		\footnotesize

		## Comment ça marche?

		* Quand l'index est déjà occupé on regarde sur la position suivante, jusqu'à en
		trouver une libre.

		```C
		index = h(key);
		while (table[index].state == OCCUPIED && table[index].key != key) {
		index = (index + 1) % table_size; // attention à pas dépasser
		}
		table[index].key = key;
		table[index].state = OCCUPIED;
		```

		## Problème?

		. . .

		* Regroupement d'éléments (clustering).

		# Méthode linéaire

		\footnotesize

		## Comment ça marche?

		* Comme la méthode séquentielle mais on "saute" de `k`.

		```C
		index = h(key);
		while (table[index].state == OCCUPIED && table[index].key != key) {
		index = (index + k) % table_size; // attention à pas dépasser
		}
		table[index].key = key;
		table[index].state = OCCUPIED;
		```

		## Quelle valeur de `k` éviter?

		. . .

		* Une valeur où `table_size` est multiple de `k`.

		Cette méthode répartit mieux les regroupements au travers de la table.

		# Méthode du double hashing

		\footnotesize

		## Comment ça marche?

		* Comme la méthode linéaire, mais `k = h2(key)` (variable).

		```C
		index = h(key);
		while (table[index].state == OCCUPIED && table[index].key != key) {
		index = (index + h2(k)) % table_size; // attention à pas dépasser
		}
		table[index].key = key;
		table[index].state = OCCUPIED;
		```

		## Quelle propriété doit avoir `h2`?

		## Exemple

		```C
		h2(key) = (table_size - 2) - key % (table_size -2)
		```

		# Méthode pseudo-aléatoire

		\footnotesize

		## Comment ça marche?

		* Comme la méthode linéaire mais on génère `k` pseudo-aléatoirement.

		```C
		index = h(key);
		while (table[index].state == OCCUPIED && table[index].key != key) {
		index = (index + random_number) % table_size;
		}
		table[index].key = key;
		table[index].state = OCCUPIED;
		```

		## Comment s'assurer qu'on va bien retrouver la bonne clé?

		. . .

		* Le germe (seed) de la séquence pseudo-aléatoire doit être le même.
		* Le germe à choisir est l'index retourné par `h(key)`.

		```C
		srand(h(key));
		while {
		random_number = rand();
		}
		```

		# Méthode quadratique

		* La fonction des indices de collision est de degré 2.
		* Soit $J_0=h(key)$, les indices de collision se construisent comme:

		```C
		J_i = J_0 + i^2 % table_size, i > 0,
		J_0 = 100, J_1 = 101, J_2 = 104, J_3 = 109, ...
		```

		## Problème possible?

		. . .

		* Calculer le carré peut-être "lent".
		* En fait on peut ruser un peu.

		# Méthode quadratique

		\footnotesize

		```C
		J_i = J_0 + i^2 % table_size, i > 0,
		J_0 = 100
		\
		d_0 = 1
		/ \
		J_1 = 101 Delta = 2
		\ /
		d_1 = 3
		/ \
		J_2 = 104 Delta = 2
		\ /
		d_2 = 5
		/ \
		J_3 = 109 Delta = 2
		\ /
		d_3 = 7
		/
		J_4 = 116
		--------------------------------------
		J_{i+1} = J_i + d_i,
		d_{i+1} = d_i + Delta, d_0 = 1, i > 0.
		```

		# Méthode de chaînage

		## Comment ça marche?

		* Chaque index de la table contient un pointeur vers une liste chaînée
		contenant les paires clés-valeurs.

		## Un petit dessin

		```











		```

		# Méthode de chaînage

		## Exemple

		On hash avec la fonction `h(key) = key % 11` (`key` est le numéro de la lettre
		de l'alphabet)

		```
		U \| N \| E \| X \| E \| M \| P \| L \| E \| D \| E \| T \| A \| B \| L \| E
		10 \| 3 \| 5 \| 2 \| 5 \| 2 \| 5 \| 1 \| 5 \| 4 \| 5 \| 9 \| 1 \| 2 \| 1 \| 5
		```

		## Comment on représente ça? (à vous)

		. . .

		![La méthode de chaînage](figs/fig_hash.png){width=80%}

		# Méthode de chaînage

		Avantages:

		* Si les clés sont grandes l'économie de place est importante (les places vides
		sont `NULL`).
		* La gestion des collisions est conceptuellement simple.
		* Pas de problème de regroupement (clustering).

		# Exercice 1

		* Construire une table à partir de la liste de clés suivante:
		```
		R, E, C, O, U, P, A, N, T
		```

		* On suppose que la table est initialement vide, de taille $n = 13$.
		* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.

slides_2023/cours_15.md

0 → 100644

+1140 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_16.md

0 → 100644

+933 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_17.md

0 → 100644

+408 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_18.md

0 → 100644

+1191 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_19.md

0 → 100644

+1235 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_2.md

0 → 100644

+517 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_20.md

0 → 100644

+891 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_21.md

0 → 100644

+493 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_22.md

0 → 100644

+940 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_23.md

0 → 100644

+475 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_24.md

0 → 100644

+1319 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_25.md

0 → 100644

+957 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_26.md

0 → 100644

+1087 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_27.md

0 → 100644

+782 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_3.md

0 → 100644

+316 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_4.md

0 → 100644

+271 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_5.md

0 → 100644

+487 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_6.md

0 → 100644

+599 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_7.md

0 → 100644

+573 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_8.md

0 → 100644

+561 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/cours_9.md

0 → 100644

+418 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/docker-compose.yml

0 → 100644

+10 −0

Original line number	Diff line number	Diff line
		version: "3.3"
		services:
		slides:
		image: omalaspinas/pandoc:latest
		user: 1000:1000
		container_name: slides
		volumes:
		- ./:/data
		entrypoint: ["make"]
		working_dir: /data

slides_2023/exemples/hashmap/Makefile

0 → 100644

+15 −0

Original line number	Diff line number	Diff line
		CC:=clang
		CFLAGS:=-Wall -Wextra -pedantic -g -fsanitize=address,undefined
		LDFLAGS:=-fsanitize=address,undefined

		main: main.o hm.o
		$(CC) main.o hm.o -o main $(LDFLAGS)

		main.o: main.c hm.h
		$(CC) -c main.c -o main.o $(CFLAGS)

		hm.o: hm.c hm.h
		$(CC) -c hm.c -o hm.o $(CFLAGS)

		clean:
		rm -f *.o main
		No newline at end of file

slides_2023/exemples/hashmap/hm.c

0 → 100644

+59 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2023/exemples/hashmap/hm.h

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		#ifndef HM_H
		#define HM_H

		#include <stdlib.h>

		#define MAX_SIZE 80

		typedef enum _state_t { EMPTY, OCCUPIED, DELETED } state_t;

		typedef struct _entry_t {
		char key[MAX_SIZE];
		char value[MAX_SIZE];
		state_t state;
		} entry_t;

		typedef struct _hm_t {
		entry_t *table;
		size_t table_capacity;
		size_t table_length;
		} hm_t;

		void hm_init(hm_t *hm, size_t table_capacity);
		void hm_destroy(hm_t *hm);

		void hm_insert(hm_t hm, char key, char *value);
		void hm_remove(hm_t hm, char key);

		#endif