31443fdb44902fc08f6a07c8fdc38cb052170c44 to main · algorithmique / cours

Some changes are not shown.

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

README.md

0 → 100644

+17 −0

Original line number	Diff line number	Diff line
		# Remerciements et contributions

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

		* P. Albuquerque
		* J. Bach
		* A. Boyer
		* M. Corboz
		* M. Divià
		* Y. El Hakouni
		* A. Escribano
		* P. Kunzli
		* G. Legouic
		* G. Marino Jarrin
		* H. Radhwan
		* I. Saroukhanian
		* C. Volta

css/tufte-css/tufte.css

0 → 100644

+470 −0

Original line number	Diff line number	Diff line
		@charset "UTF-8";

		/* Import ET Book styles
		adapted from https://github.com/edwardtufte/et-book/blob/gh-pages/et-book.css */

		@font-face {
		font-family: "et-book";
		src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot");
		src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.woff") format("woff"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.ttf") format("truetype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.svg#etbookromanosf") format("svg");
		font-weight: normal;
		font-style: normal;
		font-display: swap;
		}

		@font-face {
		font-family: "et-book";
		src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot");
		src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.woff") format("woff"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.ttf") format("truetype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.svg#etbookromanosf") format("svg");
		font-weight: normal;
		font-style: italic;
		font-display: swap;
		}

		@font-face {
		font-family: "et-book";
		src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot");
		src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.woff") format("woff"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.ttf") format("truetype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.svg#etbookromanosf") format("svg");
		font-weight: bold;
		font-style: normal;
		font-display: swap;
		}

		@font-face {
		font-family: "et-book-roman-old-style";
		src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot");
		src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.woff") format("woff"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.ttf") format("truetype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.svg#etbookromanosf") format("svg");
		font-weight: normal;
		font-style: normal;
		font-display: swap;
		}

		/* Tufte CSS styles */
		html {
		font-size: 15px;
		}

		body {
		width: 87.5%;
		margin-left: auto;
		margin-right: auto;
		padding-left: 12.5%;
		font-family: et-book, Palatino, "Palatino Linotype", "Palatino LT STD", "Book Antiqua", Georgia, serif;
		background-color: #fffff8;
		color: #111;
		max-width: 1400px;
		counter-reset: sidenote-counter;
		}

		h1 {
		font-weight: 400;
		margin-top: 4rem;
		margin-bottom: 1.5rem;
		font-size: 3.2rem;
		line-height: 1;
		}

		h2 {
		font-style: italic;
		font-weight: 400;
		margin-top: 2.1rem;
		margin-bottom: 1.4rem;
		font-size: 2.2rem;
		line-height: 1;
		}

		h3 {
		font-style: italic;
		font-weight: 400;
		font-size: 1.7rem;
		margin-top: 2rem;
		margin-bottom: 1.4rem;
		line-height: 1;
		}

		hr {
		display: block;
		height: 1px;
		width: 55%;
		border: 0;
		border-top: 1px solid #ccc;
		margin: 1em 0;
		padding: 0;
		}

		p.subtitle {
		font-style: italic;
		margin-top: 1rem;
		margin-bottom: 1rem;
		font-size: 1.8rem;
		display: block;
		line-height: 1;
		}

		.numeral {
		font-family: et-book-roman-old-style;
		}

		.danger {
		color: red;
		}

		article {
		padding: 5rem 0rem;
		}

		section {
		padding-top: 1rem;
		padding-bottom: 1rem;
		}

		p,
		dl,
		ol,
		ul {
		font-size: 1.4rem;
		line-height: 2rem;
		}

		p {
		margin-top: 1.4rem;
		margin-bottom: 1.4rem;
		padding-right: 0;
		vertical-align: baseline;
		}

		/* Chapter Epigraphs */
		div.epigraph {
		margin: 5em 0;
		}

		div.epigraph > blockquote {
		margin-top: 3em;
		margin-bottom: 3em;
		}

		div.epigraph > blockquote,
		div.epigraph > blockquote > p {
		font-style: italic;
		}

		div.epigraph > blockquote > footer {
		font-style: normal;
		}

		div.epigraph > blockquote > footer > cite {
		font-style: italic;
		}
		/* end chapter epigraphs styles */

		blockquote {
		font-size: 1.4rem;
		}

		blockquote p {
		width: 55%;
		margin-right: 40px;
		}

		blockquote footer {
		width: 55%;
		font-size: 1.1rem;
		text-align: right;
		}

		section > p,
		section > footer,
		section > table {
		width: 55%;
		}

		/* 50 + 5 == 55, to be the same width as paragraph */
		section > dl,
		section > ol,
		section > ul {
		width: 50%;
		-webkit-padding-start: 5%;
		}

		dt:not(:first-child),
		li:not(:first-child) {
		margin-top: 0.25rem;
		}

		figure {
		padding: 0;
		border: 0;
		font-size: 100%;
		font: inherit;
		vertical-align: baseline;
		max-width: 55%;
		-webkit-margin-start: 0;
		-webkit-margin-end: 0;
		margin: 0 0 3em 0;
		}

		figcaption {
		float: right;
		clear: right;
		margin-top: 0;
		margin-bottom: 0;
		font-size: 1.1rem;
		line-height: 1.6;
		vertical-align: baseline;
		position: relative;
		max-width: 40%;
		}

		figure.fullwidth figcaption {
		margin-right: 24%;
		}

		/* Links: replicate underline that clears descenders */
		a:link,
		a:visited {
		color: inherit;
		}

		.no-tufte-underline:link {
		background: unset;
		text-shadow: unset;
		}

		a:link, .tufte-underline, .hover-tufte-underline:hover {
		text-decoration: none;
		background: -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(currentColor, currentColor);
		background: linear-gradient(#fffff8, #fffff8), linear-gradient(#fffff8, #fffff8), linear-gradient(currentColor, currentColor);
		-webkit-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
		-moz-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
		background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
		background-repeat: no-repeat, no-repeat, repeat-x;
		text-shadow: 0.03em 0 #fffff8, -0.03em 0 #fffff8, 0 0.03em #fffff8, 0 -0.03em #fffff8, 0.06em 0 #fffff8, -0.06em 0 #fffff8, 0.09em 0 #fffff8, -0.09em 0 #fffff8, 0.12em 0 #fffff8, -0.12em 0 #fffff8, 0.15em 0 #fffff8, -0.15em 0 #fffff8;
		background-position: 0% 93%, 100% 93%, 0% 93%;
		}

		@media screen and (-webkit-min-device-pixel-ratio: 0) {
		a:link, .tufte-underline, .hover-tufte-underline:hover {
		background-position-y: 87%, 87%, 87%;
		}
		}

		a:link::selection,
		a:link::-moz-selection {
		text-shadow: 0.03em 0 #b4d5fe, -0.03em 0 #b4d5fe, 0 0.03em #b4d5fe, 0 -0.03em #b4d5fe, 0.06em 0 #b4d5fe, -0.06em 0 #b4d5fe, 0.09em 0 #b4d5fe, -0.09em 0 #b4d5fe, 0.12em 0 #b4d5fe, -0.12em 0 #b4d5fe, 0.15em 0 #b4d5fe, -0.15em 0 #b4d5fe;
		background: #b4d5fe;
		}

		/* Sidenotes, margin notes, figures, captions */
		img {
		max-width: 100%;
		}

		.sidenote,
		.marginnote {
		float: right;
		clear: right;
		margin-right: -60%;
		width: 50%;
		margin-top: 0.3rem;
		margin-bottom: 0;
		font-size: 1.1rem;
		line-height: 1.3;
		vertical-align: baseline;
		position: relative;
		}

		.sidenote-number {
		counter-increment: sidenote-counter;
		}

		.sidenote-number:after,
		.sidenote:before {
		font-family: et-book-roman-old-style;
		position: relative;
		vertical-align: baseline;
		}

		.sidenote-number:after {
		content: counter(sidenote-counter);
		font-size: 1rem;
		top: -0.5rem;
		left: 0.1rem;
		}

		.sidenote:before {
		content: counter(sidenote-counter) " ";
		font-size: 1rem;
		top: -0.5rem;
		}

		blockquote .sidenote,
		blockquote .marginnote {
		margin-right: -82%;
		min-width: 59%;
		text-align: left;
		}

		div.fullwidth,
		table.fullwidth {
		width: 100%;
		}

		div.table-wrapper {
		overflow-x: auto;
		font-family: "Trebuchet MS", "Gill Sans", "Gill Sans MT", sans-serif;
		}

		.sans {
		font-family: "Gill Sans", "Gill Sans MT", Calibri, sans-serif;
		letter-spacing: .03em;
		}

		code, pre > code {
		font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
		font-size: 1.0rem;
		line-height: 1.42;
		-webkit-text-size-adjust: 100%; /* Prevent adjustments of font size after orientation changes in iOS. See https://github.com/edwardtufte/tufte-css/issues/81#issuecomment-261953409 */
		}

		.sans > code {
		font-size: 1.2rem;
		}

		h1 > code,
		h2 > code,
		h3 > code {
		font-size: 0.80em;
		}

		.marginnote > code,
		.sidenote > code {
		font-size: 1rem;
		}

		pre > code {
		font-size: 0.9rem;
		width: 52.5%;
		margin-left: 2.5%;
		overflow-x: auto;
		display: block;
		}

		pre.fullwidth > code {
		width: 90%;
		}

		.fullwidth {
		max-width: 90%;
		clear:both;
		}

		span.newthought {
		font-variant: small-caps;
		font-size: 1.2em;
		}

		input.margin-toggle {
		display: none;
		}

		label.sidenote-number {
		display: inline;
		}

		label.margin-toggle:not(.sidenote-number) {
		display: none;
		}

		.iframe-wrapper {
		position: relative;
		padding-bottom: 56.25%; /* 16:9 */
		padding-top: 25px;
		height: 0;
		}

		.iframe-wrapper iframe {
		position: absolute;
		top: 0;
		left: 0;
		width: 100%;
		height: 100%;
		}

		@media (max-width: 760px) {
		body {
		width: 84%;
		padding-left: 8%;
		padding-right: 8%;
		}

		hr,
		section > p,
		section > footer,
		section > table {
		width: 100%;
		}

		pre > code {
		width: 97%;
		}

		section > dl,
		section > ol,
		section > ul {
		width: 90%;
		}

		figure {
		max-width: 90%;
		}

		figcaption,
		figure.fullwidth figcaption {
		margin-right: 0%;
		max-width: none;
		}

		blockquote {
		margin-left: 1.5em;
		margin-right: 0em;
		}

		blockquote p,
		blockquote footer {
		width: 100%;
		}

		label.margin-toggle:not(.sidenote-number) {
		display: inline;
		}

		.sidenote,
		.marginnote {
		display: none;
		}

		.margin-toggle:checked + .sidenote,
		.margin-toggle:checked + .marginnote {
		display: block;
		float: left;
		left: 1rem;
		clear: both;
		width: 95%;
		margin: 1rem 2.5%;
		vertical-align: baseline;
		position: relative;
		}

		label {
		cursor: pointer;
		}

		div.table-wrapper,
		table {
		width: 85%;
		}

		img {
		width: 100%;
		}
		}

slides/.gitignore

+1 −4

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

slides/Makefile

+14 −22

Original line number	Diff line number	Diff line
		@@ -8,46 +8,37 @@ PDFOPTIONS += -V themeoptions:numbering=none -V themeoptions:progressbar=foot
		PDFOPTIONS += -V fontsize=smaller
		PDFOPTIONS += -V urlcolor=blue

		REVEALOPTIONS = -t revealjs
		REVEALOPTIONS += -F mermaid-filter
		REVEALOPTIONS += --self-contained
		REVEALOPTIONS += -V revealjs-url=reveal.js
		REVEALOPTIONS += -V theme=white
		REVEALOPTIONS += -V width=1920
		REVEALOPTIONS += -V margin=0
		REVEALOPTIONS += --slide-level=1

		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) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf
		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 make puppeteer -k \|\| true
		docker-compose run slides make all -k \|\| true
		docker compose run slides

		docker_clean: docker-compose.yml
		docker-compose run slides make clean -k \|\| true
		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)

		index:
		rm -f index.md
		./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 $@ $^

		%.html: %.md metadata.yaml
		pandoc -s $(OPTIONS) $(REVEALOPTIONS) -o $@ $^

		%.markdown: %.md metadata.yaml yq
		sed '1 { /^---/ { :a N; /\n---/! ba; d} }' $< > no_header
		grep -v -F -x -f no_header $< > header.yaml
		@@ -60,11 +51,12 @@ 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
		deploy: all index.html
		mkdir -p algo_cours
		cp *.pdf algo_cours
		cp index.html algo_cours

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

		.PHONY: clean index puppeteer yq
		.PHONY: clean index.md puppeteer yq

slides/cours_1.md

+19 −363

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

		# Qu'est-ce qu'un algorithme?
		@@ -42,7 +42,7 @@ de résoudre typiquement une classe de problèmes ou effectuer un calcul.

		. . .

		* Opérateurs (arthimétiques / booléens)
		* Opérateurs (arithmétiques / booléens)
		* Boucles;
		* Structures de contrôle;
		* Fonctions;
		@@ -57,14 +57,12 @@ Nombre premier: nombre possédant deux diviseurs entiers distincts.
		## Algorithme naïf (problème)

		```C
		est_premier(nombre) {
		si {
		pour tout i, t.q. 1 < i < nombre {
		booléen est_premier(nombre)
		si
		pour tout i, t.q. 1 < i < nombre
		i ne divise pas nombre
		}
		} alors vrai
		alors vrai
		sinon faux
		}
		```

		. . .
		@@ -80,14 +78,12 @@ est_premier(nombre) {
		## Algorithme naïf (une solution)

		```C
		est_premier(nombre) { // fonction
		soit i := 2; // variable, type, assignation
		tant que i < nombre { // boucle
		si nombre modulo i = 0 { // expression typée
		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
		}
		i = i + 1
		retourne vrai // expression typée
		```

		@@ -103,7 +99,7 @@ bool est_premier(int nombre) {
		if (0 == nombre % i) { // is i divise nombre
		return false; // i n'est pas premier
		}
		i += 1; // sinon on incrémente i
		i = i + 1; // sinon on incrémente i
		}
		return true;
		}
		@@ -125,9 +121,9 @@ bool est_premier(int nombre) {

		- Il existe une multitude d'options de compilation:

		```bash
		$ gcc -O1 -std=c11 -Wall -Wextra -g porg.c -o prog -fsanitize=address
		-fsanitize=leak -fsanitize=undefined
		```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.
		@@ -244,7 +240,7 @@ int main() {

		# Quiz: compile ou compile pas?

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

		# Types de base (1/4)

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

		# Quiz: booléens

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

		<!-- TODO Quiz en ligne -->
		<!-- ```C
		@@ -336,7 +332,7 @@ if (x) { /* vrai */ }

		# Quiz: conversions

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

		<!-- TODO Quiz en ligne -->
		<!-- ```C
		@@ -351,343 +347,3 @@ bool d = 2.78; // 1
		bool e = 1.0; // 1
		``` -->

		# Expressions et opérateurs (1/6)

		Une expression est tout bout de code qui est évalué.

		## Expressions simples

		- Pas d'opérateurs impliqués.
		- Les littéraux, les variables, et les constantes.

		```C
		const int L = -1; // 'L' est une constante, -1 un littéral
		int x = 0; // '0' est un litéral
		int y = x; // 'x' est une variable
		int z = L; // 'L' est une constante
		```

		## Expressions complexes

		- Obtenues en combinant des opérandes avec des opérateurs

		```C
		int x; // pas une expression (une instruction)
		x = 4 + 5; // 4 + 5 est une expression
		// dont le résultat est affecté à 'x'
		```

		# Expressions et opérateurs (2/6)

		## Opérateurs relationnels

		Opérateurs testant la relation entre deux expressions:

		- `(a opérateur b)` retourne `1`{.C} si l'expression s'évalue à `true`{.C}, `0`{.C} si l'expression s'évalue à `false`{.C}.

		\| Opérateur \| Syntaxe \| Résultat \|
		\|-----------\|--------------\|----------------------\|
		\| `<`{.C} \| `a < b`{.C} \| 1 si a < b; 0 sinon \|
		\| `>`{.C} \| `a > b`{.C} \| 1 si a > b; 0 sinon \|
		\| `<=`{.C} \| `a <= b`{.C} \| 1 si a <= b; 0 sinon \|
		\| `>=`{.C} \| `a >= b`{.C} \| 1 si a >= b; 0 sinon \|
		\| `==`{.C} \| `a == b`{.C} \| 1 si a == b; 0 sinon \|
		\| `!=`{.C} \| `a != b`{.C} \| 1 si a != b; 0 sinon \|

		# Expressions et opérateurs (3/6)

		## Opérateurs logiques

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|----------------------\|
		\| `&&`{.C} \| `a && b`{.C} \| ET logique \|
		\| `\|\|`{.C} \| `a \|\| b`{.C} \| OU logique \|
		\| `!`{.C} \| `!a`{.C} \| NON logique \|

		# Quiz: opérateurs logiques

		## [Quiz: opérateurs logiques](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033629)

		<!-- TODO: Quiz -->
		<!-- ```C
		1 && 0 == 0
		7 && 3 == 1
		4 \|\| 3 == 1
		!34 == 0
		!0 == 1

		Soit n un unsigned char initialisé à 127:
		!n == 0
		``` -->

		# Expressions et opérateurs (4/6)

		## Opérateurs arithmétiques

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|----------------------\|
		\| `+`{.C} \| `a + b`{.C} \| Addition \|
		\| `-`{.C} \| `a - b`{.C} \| Soustraction \|
		\| ``{.C} \| `a b`{.C} \| Multiplication \|
		\| `/`{.C} \| `a / b`{.C} \| Division \|
		\| `%`{.C} \| `a % b`{.C} \| Modulo \|

		# Expressions et opérateurs (5/6)

		## Opérateurs d'assignation

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|---------------------------------------------\|
		\| `=`{.C} \| `a = b`{.C} \| Affecte la valeur `b` à la variable `a` \|
		\| \| \| et retourne la valeur de `b` \|
		\| `+=`{.C} \| `a += b`{.C} \| Additionne la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `-=`{.C} \| `a -= b`{.C} \| Soustrait la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `=`{.C} \| `a = b`{.C} \| Multiplie la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `/=`{.C} \| `a /= b`{.C} \| Divise la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `%=`{.C} \| `a %= b`{.C} \| Calcule le modulo la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|

		# Expressions et opérateurs (6/6)

		## Opérateurs d'assignation (suite)

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|---------------------------------------------\|
		\| `++`{.C} \| `++a`{.C} \| Incrémente la valeur de `a` de 1 et \|
		\| \| \| retourne le résultat (`a += 1`). \|
		\| `--`{.C} \| `--a`{.C} \| Décrémente la valeur de `a` de 1 et \|
		\| \| \| retourne le résultat (`a -= 1`). \|
		\| `++`{.C} \| `a++`{.C} \| Retourne `a`{.C} et incrémente `a` de 1. \|
		\| `--`{.C} \| `a--`{.C} \| Retourne `a`{.C} et décrémente `a` de 1. \|


		# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)

		## Syntaxe

		```C
		if (expression) {
		instructions;
		} else if (expression) { // optionnel
		// il peut y en avoir plusieurs
		instructions;
		} else {
		instructions; // optionnel
		}
		```

		```C
		if (x) { // si x s'évalue à `vrai`
		printf("x s'évalue à vrai.\n");
		} else if (y == 8) { // si y vaut 8
		printf("y vaut 8.\n");
		} else {
		printf("Ni l'un ni l'autre.\n");
		}
		```

		# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/2)

		## Pièges

		```C
		int x, y;
		x = y = 3;
		if (x = 2)
		printf("x = 2 est vrai.\n");
		else if (y < 8)
		printf("y < 8.\n");
		else if (y == 3)
		printf("y vaut 3 mais cela ne sera jamais affiché.\n");
		else
		printf("Ni l'un ni l'autre.\n");
		x = -1; // toujours évalué
		```

		# Quiz: `if ... else`{.C}

		## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)


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

		## La boucle `while`{.C}

		```C
		while (condition) {
		instructions;
		}
		do {
		instructions;
		} while (condition);
		```

		## La boucle `while`{.C}, un exemple

		```C
		int sum = 0; // syntaxe C99
		while (sum < 10) {
		sum += 1;
		}
		do {
		sum += 10;
		} while (sum < 100)
		```

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

		## La boucle `for`{.C}

		```C
		for (expression1; expression2; expression3) {
		instructions;
		}
		```

		## La boucle `for`{.C}

		```C
		int sum = 0; // syntaxe C99
		for (int i = 0; i < 10; i++) {
		sum += i;
		}

		for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
		printf("C'est plus ésotérique.\n");
		}
		```

		# Exercice: la factorielle

		Écrire un programme qui calcule la factorielle d'un nombre
		$$
		N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
		$$

		## Par groupe de 3: écrire un pseudo-code

		. . .

		```C
		int factorielle(int n) {
		i = 1;
		fact = 1;
		pour i <= n {
		fact *= i;
		i += 1;
		}
		}
		```

		# Exercice: la factorielle

		\footnotesize

		Écrire un programme qui calcule la factorielle d'un nombre
		$$
		N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
		$$

		## Par groupe de 3: écrire un code en C

		Quand vous avez fini postez le code sur le salon matrix.

		. . .

		```C
		#include <stdio.h>
		int main() {
		int nb = 10;
		int fact = 1;
		int iter = 2;
		while (iter <= nb) {
		fact *= iter;
		iter++;
		}
		}
		```

		. . .

		## Comment améliorer ce code? (notez ça sur une feuille)


		# Entrées/sorties: `printf()`{.C} (1/2)

		## Généralités

		- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:

		```C
		int printf(const char *format, ...);
		```
		- Nombre d'arguments variables.
		- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.
		- Les arguments suivants sont les expressions à afficher.

		# Entrées/sorties: `printf()`{.C} (2/2)

		## Exemple

		```C
		#include <stdio.h>
		#include <stdlib.h>

		int main() {
		printf("Hello world.\n");
		int val = 1;
		printf("Hello world %d time.\n", val);
		printf("%f squared is equal to %f.\n", 2.5, 2.5*2.5);
		return EXIT_SUCCESS;
		}
		```

		# Entrées/sorties: `scanf()`{.C} (1/2)

		## Généralités

		- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:

		```C
		int scanf(const char *format, ...);
		```

		- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).
		- Les arguments suivants sont les variables où sont stockées les valeurs lues.

		# Entrées/sorties: `scanf()`{.C} (2/2)

		## Exemple

		```C
		#include <stdio.h>
		#include <stdlib.h>

		int main() {
		printf("Enter 3 numbers: \n");
		int i, j, k;
		scanf("%d %d %d", &i, &j, &k);
		printf("You entered: %d %d %d\n", i, j, k);

		return EXIT_SUCCESS;
		}
		```

		# Exercice: la factorielle en mieux

		## Individuellement

		1. Ajoutez des fonctionnalités à votre code.
		2. Écrivez l'algorithme de calcul de deux façon différentes.
		3. Pour celles et ceux qui ont fini pendant que les autres essaient: faites-le
		en récursif (sans aide).

		. . .

		## Postez vos solutions sur matrix!

slides/docker-compose.yml

+2 −6

Original line number	Diff line number	Diff line
		version: "3.3"
		services:
		slides:
		#To use dockerfile : build: .
		image: omalaspinas/pandoc:latest
		environment:
		USER: 1000
		GROUP: 1000
		user: 1000:1000
		container_name: slides
		volumes:
		- ./:/data
		# entrypoint: ["make", "all"]
		entrypoint: ["make"]
		working_dir: /data
		# user: "$(id -u):$(id -g)"

slides/figs/matrix_qr.png

0 → 100644

+1.93 KiB

1.93 KiB

slides/gen_index.sh

+1 −1

Original line number	Diff line number	Diff line
		@@ -38,7 +38,7 @@ for i in *.md; do
		fail "Error title field not found"
		fi
		i="${i%.*}"
		class="[${date} ${comp}](${PREFIX}${i}.pdf)"
		class="[${date}: ${comp}](${PREFIX}${i}.pdf)"
		classes+=("$class")
		done
		IFS=$'\n'

slides/intro.md

+21 −38

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

		# La hotline
		@@ -11,59 +11,42 @@ Paul Albuquerque paul.albuquerque@hesge.ch B410
		Orestis Malaspinas orestis.malaspinas@hesge.ch A401
		-------------------- ------------------------------ --------------------

		Utilisez le libre service (l'horaire sera fixé prochainement).
		- 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).

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

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

		# Cyberlearn

		Tout le contenu de ce qu'on raconte se trouve sur cyberlearn:

		- Algorithmes et structures de données
		- <https://cyberlearn.hes-so.ch/course/view.php?id=13941>
		- Clé d'inscription: algo_2020_21
		- <https://cyberlearn.hes-so.ch/course/view.php?id=7276>
		- Clé d'inscription: algo_2025_26

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

		- Programmation Sequentielle en C
		- <https://cyberlearn.hes-so.ch/course/view.php?id=12399>
		- Clé d'inscription: PS_2018

		# Organisation du module

		* Deux cours, 50% chacun.
		1. Algorithmes et structures de données:
		## 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.
		2. Programmation séquentielle en C
		* Deux évaluations écrites par semestre (1er sem.: novembre et janvier).
		2. Programmation séquentielle en C (2 semestres)
		* Familiarisation avec l'environnement Linux.
		* Travaux pratiques en C.
		* Apprentissage du gestionnaire de versions: git.
		* Plusieurs "petits" exercices illustrant les concepts d'algorithmique
		(1-2 séances).
		* Évaluations:
		* Un projet de programmation.
		* Une évaluation machine.

		# Sondage: expérience de programmation

		## [Sondage: expérience de linux](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1291283)

		## [Sondage: expérience de programmation](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1035242)

		Installez un lecteur de QR code s'il-vous-plaît.

		# Questions?

		- N'hésitez pas à poser des questions, nous sommes là pour ça! [^1]
		- Ne restez pas coincés pendant des jours sur un problème.
		- Utilisez le libre-service!
		- N'hésitez pas à faire des retours: négatifs ou positifs.

		[^1]: Chaque étudiant·e·s a un quota de 5 questions par semestre.
		* Plusieurs exercices illustrant les concepts d'algorithmique.
		* Évaluations (4 tests machine).
		3. Programmation système (semestre de printemps)

slides/metadata.yaml

+3 −3

Original line number	Diff line number	Diff line
		---
		subtitle: "Algorithmique et structures de données, 2021-2022"
		author: "Paul Albuquerque (B410), Pierre Künzli et Orestis Malaspinas (A401), ISC, HEPIA"
		institute: En partie inspirés des supports de cours de P. Albuquerque
		subtitle: "Algorithmique et structures de données, 2025-2026"
		author: "P. Albuquerque (B410) et O. Malaspinas (A401), ISC, HEPIA"
		institute: En partie inspiré des supports de cours de P. Albuquerque
		lang: fr-CH
		revealjs-url: /reveal.js
		mathjaxurl: "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"

slides_2021/.gitignore

0 → 100644

+6 −0

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

slides_2021/Makefile

0 → 100644

+71 −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

		REVEALOPTIONS = -t revealjs
		REVEALOPTIONS += -F mermaid-filter
		REVEALOPTIONS += --self-contained
		REVEALOPTIONS += -V revealjs-url=reveal.js
		REVEALOPTIONS += -V theme=white
		REVEALOPTIONS += -V width=1920
		REVEALOPTIONS += -V margin=0
		REVEALOPTIONS += --slide-level=1

		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 make puppeteer -k \|\| true
		docker-compose run slides make all -k \|\| true

		docker_clean: docker-compose.yml
		docker-compose run slides make clean -k \|\| true

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

		index:
		rm -f index.md
		./gen_index.sh

		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 $@ $^

		%.html: %.md metadata.yaml
		pandoc -s $(OPTIONS) $(REVEALOPTIONS) -o $@ $^

		%.markdown: %.md metadata.yaml yq
		sed '1 { /^---/ { :a N; /\n---/! ba; d} }' $< > no_header
		grep -v -F -x -f no_header $< > header.yaml
		echo "---" > tmp.yaml
		./yq_linux_amd64 merge metadata.yaml header.yaml >> tmp.yaml
		cat tmp.yaml no_header > $@
		rm no_header header.yaml tmp.yaml

		yq: # On peut même télécharger un petit programme avec notre makefile
		wget -nc https://github.com/mikefarah/yq/releases/download/3.4.1/yq_linux_amd64
		chmod "u+x" yq_linux_amd64

		deploy: all
		mkdir -p algo_cours
		cp *.pdf algo_cours

		clean:
		rm -f .html .pdf .markdown yq_linux_amd64 index.md .puppeteer.json

		.PHONY: clean index puppeteer yq

slides_2021/cours_1.md

0 → 100644

+693 −0

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2021-09-22"
		---

		# Qu'est-ce qu'un algorithme?

		## Définition informelle (recette)

		* des entrées (les ingrédients, le matériel utilisé) ;
		* des instructions élémentaires simples (frire, flamber, etc.), dont les
		exécutions dans un ordre précis amènent au résultat voulu ;
		* un résultat : le plat préparé.

		. . .

		## Histoire et étymologie

		- Existent depuis 4500 ans au moins (algorithme de division, crible
		d'Eratosthène).
		- Le mot algorithme est dérivé du nom du mathématicien perse
		Muḥammad ibn Musā al-Khwārizmī, qui a été "latinisé" comme
		Algoritmi.

		. . .

		## Définition formelle

		En partant d'un état initial et d'entrées (peut-être vides), une séquence finie
		d'instruction bien définies (ordonnées) implémentables sur un ordinateur, afin
		de résoudre typiquement une classe de problèmes ou effectuer un calcul.

		# Notions de base d'algorithmique

		## Variable

		. . .

		* Paire: identifiant - valeur (assignation);

		## Séquence d'instructions / expressions

		. . .

		* Opérateurs (arthimétiques / booléens)
		* Boucles;
		* Structures de contrôle;
		* Fonctions;


		# Algorithme de vérification qu'un nombre est premier (1/3)

		Nombre premier: nombre possédant deux diviseurs entiers distincts.

		. . .

		## Algorithme naïf (problème)

		```C
		est_premier(nombre) {
		si {
		pour tout i, t.q. 1 < i < nombre {
		i ne divise pas nombre
		}
		} alors vrai
		sinon faux
		}
		```

		. . .

		## Pas vraiment un algorithme: pas une séquence ordonnée et bien définie

		. . .

		## Problème: Comment écrire ça sous une forme algorithmique?

		# Algorithme de vérification qu'un nombre est premier (2/3)

		## Algorithme naïf (une solution)

		```C
		est_premier(nombre) { // fonction
		soit i := 2; // variable, type, assignation
		tant que i < nombre { // boucle
		si nombre modulo i = 0 { // expression typée
		retourne faux // expression typée
		}
		i := i + 1
		}
		retourne vrai // expression typée
		```

		# Algorithme de vérification qu'un nombre est premier (3/3)

		## Algorithme naïf (une solution en C)

		```C
		bool est_premier(int nombre) {
		int i; // i est un entier
		i = 2; // assignation i à 2
		while (i < nombre) { // boucle avec condition
		if (0 == nombre % i) { // is i divise nombre
		return false; // i n'est pas premier
		}
		i += 1; // sinon on incrémente i
		}
		return true;
		}
		```

		. . .

		## Exercice: Comment faire plus rapide?

		# Génération d'un exécutable

		- Pour pouvoir être exécuté un code C doit être d'abord compilé (avec `gcc` ou `clang`).
		- Pour un code `prog.c` la compilation "minimale" est

		```bash
		$ gcc prog.c
		$ ./a.out # exécutable par défaut
		```

		- Il existe une multitude d'options de compilation:

		```bash
		$ gcc -O1 -std=c11 -Wall -Wextra -g porg.c -o prog -fsanitize=address
		-fsanitize=leak -fsanitize=undefined
		```
		1. `-std=c11` utilisation de C11.
		2. `-Wall et -Wextra` activation des warnings.
		3. `-fsanitize=…` contrôles d’erreurs à l’exécution (coût en performance).
		4. `-g` symboles de débogages sont gardés.
		5. `-o` défini le fichier exécutable à produire en sortie.
		6. `-O1`, `-O2`, `-O3`: activation de divers degrés d'optimisation



		# La simplicité de C?

		## 32 mots-clé et c'est tout

		---------------- -------------- ---------------- ---------------
		`auto`{.C} `double`{.C} `int`{.C} `struct`{.C}
		`break`{.C} `else`{.C} `long`{.C} `switch`{.C}
		`case`{.C} `enum`{.C} `register`{.C} `typedef`{.C}
		`char`{.C} `extern`{.C} `return`{.C} `union`{.C}
		`const`{.C} `float`{.C} `short`{.C} `unsigned`{.C}
		`continue`{.C} `for`{.C} `signed`{.C} `void`{.C}
		`default`{.C} `goto`{.C} `sizeof`{.C} `volatile`{.C}
		`do`{.C} `if`{.C} `static`{.C} `while`{.C}
		---------------- -------------- ---------------- ---------------

		# Déclaration et typage

		En C lorsqu'on veut utiliser une variable (ou une constante), on doit déclarer son type

		```C
		const double two = 2.0; // déclaration et init.
		int x; // déclaration (instruction)
		char c; // déclaration (instruction)
		x = 1; // affectation (expression)
		c = 'a'; // affectation (expression)
		int y = x; // déclaration et initialisation en même temps
		int a, b, c; // déclarations multiples
		a = b = c = 1; // init. multiples
		```

		# Les variables (1/2)

		## Variables et portée

		- Une variable est un identifiant, qui peut être liée à une valeur (un expression).
		- Une variable a une portée qui définit où elle est visible (où elle peut être accédée).
		- La portée est globale ou locale.
		- Une variable est globale est accessible à tout endroit d'un programme et doit être déclarée en dehors de toute fonction.
		- Une variable est locale lorsqu'elle est déclarée dans un bloc, `{...}`{.C}.
		- Une variable est dans la portée après avoir été déclarée.

		# Les variables (2/2)

		## Exemple

		```C
		float max; // variable globale accessible partout
		int foo() {
		// max est visible ici
		float a = max; // valide
		// par contre les varibles du main() ne sont pas visibles
		}
		int main() {
		// max est visible ici
		int x = 1; // x est locale à main
		{
		// x est visible ici, y pas encore
		// on peut par exemple pas faire x = y;
		int y = 2;
		} // y est détruite à la sortie du bloc
		} // x est à la sortie de main

		```

		<!-- TODO: quiz, compile, compile pas -->
		<!-- ```C
		int main() {
		global = 1;
		} // COMPILE PAS
		```

		```C
		int main() {
		int global = 1;
		{
		printf("global = %d", global);
		}
		} // COMPILE
		```

		```C
		int local;

		int main() {
		local = 1;
		{
		printf("local = %d", local);
		}
		} // COMPILE
		```

		```C
		#include <stdio.h>
		int local = 0;

		int main() {
		int local = -1;
		{
		int local = 1;
		printf("local = %d\n", local);
		}
		} // COMPILE
		``` -->

		# Quiz: compile ou compile pas?

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

		# Types de base (1/4)

		## Numériques

		Type Signification (gcc pour x86-64)
		---------------------------------- ---------------------------------------------
		`char`{.C}, `unsigned char`{.C} Entier signé/non-signé 8-bit
		`short`{.C}, `unsigned short`{.C} Entier signé/non-signé 16-bit
		`int`{.C}, `unsigned int`{.C} Entier signé/non-signé 32-bit
		`long`{.C}, `unsigned long`{.C} Entier signé/non-signé 64-bit
		`float`{.C} Nombre à virgule flottante, simple précision
		`double`{.C} Nombre à virgule flottante, double précision
		---------------------------------- ---------------------------------------------

		La signification de `short`{.C}, `int`{.C}, ... dépend du compilateur et de l'architecture.

		# Types de base (2/4)

		Voir `<stdint.h>` pour des représentations portables

		Type Signification
		---------------------------------- ---------------------------------------------
		`int8_t`{.C}, `uint8_t`{.C} Entier signé/non-signé 8-bit
		`int16_t`{.C}, `uint16_t`{.C} Entier signé/non-signé 16-bit
		`int32_t`{.C}, `uint32_t`{.C} Entier signé/non-signé 32-bit
		`int64_t`{.C}, `uint64_t`{.C} Entier signé/non-signé 64-bit
		---------------------------------- ---------------------------------------------

		. . .

		## Prenez l'habitude d'utiliser ces types-là!

		# Types de base (3/4)

		## Booléens

		- Le ANSI C n'offre pas de booléens.
		- L'entier `0`{.C} signifie faux, tout le reste vrai.
		- Depuis C99, la librairie `stdbool` met à disposition un type `bool`{.C}.
		- En réalité c'est un entier:
		- $1 \Rightarrow$ `true`{.C}
		- $0 \Rightarrow$ `false`{.C}
		- On peut les manipuler comme des entier (les sommer, les multiplier, ...).

		# Quiz: booléens

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

		<!-- TODO Quiz en ligne -->
		<!-- ```C
		if (42) { /* vrai */ }

		int x = 100;
		if (x == 4) { /* faux */ }
		if (x) { /* vrai */ }

		int x = 100;
		while (x−−) { /* répète tant que x est différent de 0 */ }

		if (0) { /* faux */ }
		if (i = 4) { /* vrai */ }
		if (i = 0) { /* faux */ }

		#include <stdbool.h>

		bool x = true;
		if (x) { /* vrai */ }
		``` -->

		# Types de base (4/4)

		## Conversions

		- Les conversions se font de manière:
		- Explicite:
		```C
		int a = (int)2.8;
		double b = (double)a;
		int c = (int)(2.8+0.5);
		```
		- Implicite:
		```C
		int a = 2.8; // warning, si activés, avec clang
		double b = a + 0.5;
		char c = b; // pas de warning...
		int d = 'c';
		```

		# Quiz: conversions

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

		<!-- TODO Quiz en ligne -->
		<!-- ```C
		int a = (int)2.8; // 2

		double b = 2.85;
		int c = b + 0.5; // 3

		int d = a + 0.5; // 2

		bool d = 2.78; // 1
		bool e = 1.0; // 1
		``` -->

		# Expressions et opérateurs (1/6)

		Une expression est tout bout de code qui est évalué.

		## Expressions simples

		- Pas d'opérateurs impliqués.
		- Les littéraux, les variables, et les constantes.

		```C
		const int L = -1; // 'L' est une constante, -1 un littéral
		int x = 0; // '0' est un litéral
		int y = x; // 'x' est une variable
		int z = L; // 'L' est une constante
		```

		## Expressions complexes

		- Obtenues en combinant des opérandes avec des opérateurs

		```C
		int x; // pas une expression (une instruction)
		x = 4 + 5; // 4 + 5 est une expression
		// dont le résultat est affecté à 'x'
		```

		# Expressions et opérateurs (2/6)

		## Opérateurs relationnels

		Opérateurs testant la relation entre deux expressions:

		- `(a opérateur b)` retourne `1`{.C} si l'expression s'évalue à `true`{.C}, `0`{.C} si l'expression s'évalue à `false`{.C}.

		\| Opérateur \| Syntaxe \| Résultat \|
		\|-----------\|--------------\|----------------------\|
		\| `<`{.C} \| `a < b`{.C} \| 1 si a < b; 0 sinon \|
		\| `>`{.C} \| `a > b`{.C} \| 1 si a > b; 0 sinon \|
		\| `<=`{.C} \| `a <= b`{.C} \| 1 si a <= b; 0 sinon \|
		\| `>=`{.C} \| `a >= b`{.C} \| 1 si a >= b; 0 sinon \|
		\| `==`{.C} \| `a == b`{.C} \| 1 si a == b; 0 sinon \|
		\| `!=`{.C} \| `a != b`{.C} \| 1 si a != b; 0 sinon \|

		# Expressions et opérateurs (3/6)

		## Opérateurs logiques

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|----------------------\|
		\| `&&`{.C} \| `a && b`{.C} \| ET logique \|
		\| `\|\|`{.C} \| `a \|\| b`{.C} \| OU logique \|
		\| `!`{.C} \| `!a`{.C} \| NON logique \|

		# Quiz: opérateurs logiques

		## [Quiz: opérateurs logiques](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033629)

		<!-- TODO: Quiz -->
		<!-- ```C
		1 && 0 == 0
		7 && 3 == 1
		4 \|\| 3 == 1
		!34 == 0
		!0 == 1

		Soit n un unsigned char initialisé à 127:
		!n == 0
		``` -->

		# Expressions et opérateurs (4/6)

		## Opérateurs arithmétiques

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|----------------------\|
		\| `+`{.C} \| `a + b`{.C} \| Addition \|
		\| `-`{.C} \| `a - b`{.C} \| Soustraction \|
		\| ``{.C} \| `a b`{.C} \| Multiplication \|
		\| `/`{.C} \| `a / b`{.C} \| Division \|
		\| `%`{.C} \| `a % b`{.C} \| Modulo \|

		# Expressions et opérateurs (5/6)

		## Opérateurs d'assignation

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|---------------------------------------------\|
		\| `=`{.C} \| `a = b`{.C} \| Affecte la valeur `b` à la variable `a` \|
		\| \| \| et retourne la valeur de `b` \|
		\| `+=`{.C} \| `a += b`{.C} \| Additionne la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `-=`{.C} \| `a -= b`{.C} \| Soustrait la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `=`{.C} \| `a = b`{.C} \| Multiplie la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `/=`{.C} \| `a /= b`{.C} \| Divise la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|
		\| `%=`{.C} \| `a %= b`{.C} \| Calcule le modulo la valeur de `b` à `a` et \|
		\| \| \| assigne le résultat à `a`. \|

		# Expressions et opérateurs (6/6)

		## Opérateurs d'assignation (suite)

		\| Opérateur \| Syntaxe \| Signification \|
		\|-----------\|--------------\|---------------------------------------------\|
		\| `++`{.C} \| `++a`{.C} \| Incrémente la valeur de `a` de 1 et \|
		\| \| \| retourne le résultat (`a += 1`). \|
		\| `--`{.C} \| `--a`{.C} \| Décrémente la valeur de `a` de 1 et \|
		\| \| \| retourne le résultat (`a -= 1`). \|
		\| `++`{.C} \| `a++`{.C} \| Retourne `a`{.C} et incrémente `a` de 1. \|
		\| `--`{.C} \| `a--`{.C} \| Retourne `a`{.C} et décrémente `a` de 1. \|


		# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)

		## Syntaxe

		```C
		if (expression) {
		instructions;
		} else if (expression) { // optionnel
		// il peut y en avoir plusieurs
		instructions;
		} else {
		instructions; // optionnel
		}
		```

		```C
		if (x) { // si x s'évalue à `vrai`
		printf("x s'évalue à vrai.\n");
		} else if (y == 8) { // si y vaut 8
		printf("y vaut 8.\n");
		} else {
		printf("Ni l'un ni l'autre.\n");
		}
		```

		# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/2)

		## Pièges

		```C
		int x, y;
		x = y = 3;
		if (x = 2)
		printf("x = 2 est vrai.\n");
		else if (y < 8)
		printf("y < 8.\n");
		else if (y == 3)
		printf("y vaut 3 mais cela ne sera jamais affiché.\n");
		else
		printf("Ni l'un ni l'autre.\n");
		x = -1; // toujours évalué
		```

		# Quiz: `if ... else`{.C}

		## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)


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

		## La boucle `while`{.C}

		```C
		while (condition) {
		instructions;
		}
		do {
		instructions;
		} while (condition);
		```

		## La boucle `while`{.C}, un exemple

		```C
		int sum = 0; // syntaxe C99
		while (sum < 10) {
		sum += 1;
		}
		do {
		sum += 10;
		} while (sum < 100)
		```

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

		## La boucle `for`{.C}

		```C
		for (expression1; expression2; expression3) {
		instructions;
		}
		```

		## La boucle `for`{.C}

		```C
		int sum = 0; // syntaxe C99
		for (int i = 0; i < 10; i++) {
		sum += i;
		}

		for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
		printf("C'est plus ésotérique.\n");
		}
		```

		# Exercice: la factorielle

		Écrire un programme qui calcule la factorielle d'un nombre
		$$
		N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
		$$

		## Par groupe de 3: écrire un pseudo-code

		. . .

		```C
		int factorielle(int n) {
		i = 1;
		fact = 1;
		pour i <= n {
		fact *= i;
		i += 1;
		}
		}
		```

		# Exercice: la factorielle

		\footnotesize

		Écrire un programme qui calcule la factorielle d'un nombre
		$$
		N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
		$$

		## Par groupe de 3: écrire un code en C

		Quand vous avez fini postez le code sur le salon matrix.

		. . .

		```C
		#include <stdio.h>
		int main() {
		int nb = 10;
		int fact = 1;
		int iter = 2;
		while (iter <= nb) {
		fact *= iter;
		iter++;
		}
		}
		```

		. . .

		## Comment améliorer ce code? (notez ça sur une feuille)


		# Entrées/sorties: `printf()`{.C} (1/2)

		## Généralités

		- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:

		```C
		int printf(const char *format, ...);
		```
		- Nombre d'arguments variables.
		- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.
		- Les arguments suivants sont les expressions à afficher.

		# Entrées/sorties: `printf()`{.C} (2/2)

		## Exemple

		```C
		#include <stdio.h>
		#include <stdlib.h>

		int main() {
		printf("Hello world.\n");
		int val = 1;
		printf("Hello world %d time.\n", val);
		printf("%f squared is equal to %f.\n", 2.5, 2.5*2.5);
		return EXIT_SUCCESS;
		}
		```

		# Entrées/sorties: `scanf()`{.C} (1/2)

		## Généralités

		- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:

		```C
		int scanf(const char *format, ...);
		```

		- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).
		- Les arguments suivants sont les variables où sont stockées les valeurs lues.

		# Entrées/sorties: `scanf()`{.C} (2/2)

		## Exemple

		```C
		#include <stdio.h>
		#include <stdlib.h>

		int main() {
		printf("Enter 3 numbers: \n");
		int i, j, k;
		scanf("%d %d %d", &i, &j, &k);
		printf("You entered: %d %d %d\n", i, j, k);

		return EXIT_SUCCESS;
		}
		```

		# Exercice: la factorielle en mieux

		## Individuellement

		1. Ajoutez des fonctionnalités à votre code.
		2. Écrivez l'algorithme de calcul de deux façon différentes.
		3. Pour celles et ceux qui ont fini pendant que les autres essaient: faites-le
		en récursif (sans aide).

		. . .

		## Postez vos solutions sur matrix!

slides/cours_10.md→slides_2021/cours_10.md

+0 −0

File moved.

slides/cours_11.md→slides_2021/cours_11.md

+0 −0

File moved.

slides/cours_12.md→slides_2021/cours_12.md

+0 −0

File moved.

slides/cours_13.md→slides_2021/cours_13.md

+0 −0

File moved.

slides/cours_14.md→slides_2021/cours_14.md

+0 −0

File moved.

slides/cours_15.md→slides_2021/cours_15.md

+0 −0

File moved.

slides/cours_16.md→slides_2021/cours_16.md

+0 −0

File moved.

slides/cours_17.md→slides_2021/cours_17.md

+0 −0

File moved.

slides/cours_18.md→slides_2021/cours_18.md

+0 −0

File moved.

slides/cours_19.md→slides_2021/cours_19.md

+0 −0

File moved.

slides/cours_2.md→slides_2021/cours_2.md

+0 −0

File moved.

slides/cours_20.md→slides_2021/cours_20.md

+0 −0

File moved.

slides/cours_21.md→slides_2021/cours_21.md

+0 −0

File moved.

slides/cours_22.md→slides_2021/cours_22.md

+0 −0

File moved.

slides/cours_23.md→slides_2021/cours_23.md

+0 −0

File moved.

slides/cours_24.md→slides_2021/cours_24.md

+0 −0

File moved.

slides/cours_25.md→slides_2021/cours_25.md

+0 −0

File moved.

slides/cours_26.md→slides_2021/cours_26.md

+237 −9

Original line number	Diff line number	Diff line
		@@ -17,22 +17,27 @@ patat:

		# Questions

		* Qu'est-ce qu'un graphe? Un graphe orienté? Un graphe pondéré?
		* A quoi sert l'algorithme de Dijkstra?

		. . .

		* Ensemble de sommets et arêtes, avec une direction, possédant une pondération.
		* Comment représenter un graphe informatiquement?
		* A trouver le plus court chemin entre un sommet, $s$, d'un graphe pondéré et tous les autres sommets.
		* Quelle est la limitation de l'algorithme de Dijkstra?

		. . .

		* Liste ou matrice d'adjacence.
		* Quels sont les deux parcours que nous avons vus?
		* Les poids doivent être positifs.
		* Résumer les étapes de l'algorithme de Dijkstra.

		. . .

		* Parcours en largeur et profondeur.
		* Donner l'idée générale des deux parcours.
		* `distance[source] = 0`, `ditance[reste]=inf`;
		* enfiler tous les sommets, `distance <=> priorité`;
		* tant qu'il y a des sommets dans la file:
		* u = défiler;
		* pour tous les sommets `v` dans le voisinage de `u`;
		* mettre à jour `distance[v]` (priorité et précédence) si `distance[v] > distance[u] + w(u,v)`.


		# Plus cours chemin pour toute paire de sommets

		@@ -438,7 +443,7 @@ $$

		. . .

		* Moralité: si le chemin est plus court en passant par $k$, alors il faut qu'il soit le prédécesseur!
		* Moralité: si le chemin est plus court en passant par $k$, alors il faut utiliser son prédécesseur!

		# Algorithme de Floyd--Warshall

		@@ -545,4 +550,227 @@ $$

		## Appliquer l'algorithme de Floyd--Warshall au graphe suivant

		![The exorcist.](figs/floyd_exercice.png)
		![The exorcist.](figs/floyd_exercice.png){width=50%}

		* Bien indiquer l'état de $D$ et $P$ à chaque étape!
		* Ne pas oublier de faire la matrice d'adjacence évidemment...

		# La suite

		* Sans transition.... la suite!

		# Trouver un réseau électrique pour

		![Ces maisons n'ont pas d'électricité.](figs/arbre_couvrant_vide.png)

		# Solution: pas optimale

		![Le réseau simple, mais nul.](figs/arbre_couvrant_mal.png)

		* La longueur totale des câbles est super longue!

		# Solution: optimale

		![Le meilleur réseau.](figs/arbre_couvrant_bien.png)

		# Formalisation: Les arbres couvrants

		## Application: minimisation des coûrs

		* Équipement d'un lotissement avec des lignes électriques/téléphoniques, des canalisations, ...

		. . .

		* Pour réduire les coûts, on cherche à minimiser la longueur totale des câbles/tuyaux.

		. . .

		* Les lignes/tuyaux forment un arbre couvrant.

		. . .

		* La meilleure option est un arbre couvrant minimal.


		# Formalisation: Les arbres couvrants

		* Qu'est-ce qu'un arbre couvrant? Des idées? De quel objet on part? Où va-t-on?

		. . .

		* Un arbre couvrant d'un graphe non-orienté et connexe est:
		* un arbre inclu dans le graphe qui connecte tous les sommets du graphe.

		. . .

		![Exemple d'arbres couvrants d'un graphe connexe.](figs/arbre_couvrant_exemples.png)

		# Arbres couvrants

		* Quels algorithmes que nous avons déjà vus permettent de construire des arbres couvrants?

		. . .

		* Les parcours en largeur et en profondeur!

		. . .

		![Graphe, et parcours comme arbres couvrants.](figs/arbres_couvrants_parcours.png)

		# Arbres couvrants minimaux

		* Un arbre couvrant minimal est un sous-graphe d'un graphe non-orienté pondéré $G(V,E)$, tel quel:
		* C'est un arbre (graphe acyclique);
		* Il couvre tous les sommets de $G$ et contient $\|V\|-1$ arêtes;
		* Le coût total associé aux arêtes de l'arbre est minimum parmi tous les arbres couvrants possibles.

		. . .

		* Est-il unique?

		. . .

		* Pas forcément.

		# Arbres couvrants minimaux

		* Comment générer un arbre couvrant minimal?

		![Un graphe, connexe, non-orienté, pondéré, et son arbre couvrant minimal.](figs/arbre_couvrant_minimal_exemple.png)

		# Algorithme de Prim

		::: columns

		:::: column

		## Un exemple

		![Le graphe de départ.](figs/prim_0.png)

		::::

		:::: column

		## On part de `e` (au hasard)

		![Le sommet `e` est couvert.](figs/prim_1.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_1.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `e->d`

		![Le sommet `d` est couvert.](figs/prim_2.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_2.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `d->a`

		![Le sommet `a` est couvert.](figs/prim_3.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_3.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `d->c`

		![Le sommet `c` est couvert.](figs/prim_4.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_4.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `e->b`

		![Le sommet `b` est couvert.](figs/prim_5.png)

		::::

		:::

		* Game over!

slides_2021/cours_27.md

0 → 100644

+681 −0

Original line number	Diff line number	Diff line
		---
		title: "Graphes - Arbres couvrants"
		date: "2022-05-03"
		patat:
		eval:
		tai:
		command: fish
		fragment: false
		replace: true
		ccc:
		command: fish
		fragment: false
		replace: true
		images:
		backend: auto
		---

		# Questions

		* A quoi sert l'algorithme de Floyd--Warshall?

		. . .

		* A trouver le plus court chemin entre n'importe quelle paire de sommets d'un graphe pondéré.
		* Quelle est la limitation de l'algorithme de Dijkstra n'est pas présente pour l'algorithme de Floyd--Warshall?

		. . .

		* Les poids peuvent être négatifs.
		* Qu'est-ce qu'un arbre couvrant minimal?

		. . .

		* Un arbre couvrant minimal d'un graphe non-orienté et connexe est:
		* un arbre inclu dans le graphe qui connecte tous les sommets du graphe et dont le poids total des arêtes est minimal.

		# Arbres couvrants minimaux

		* Comment générer un arbre couvrant minimal?

		![Un graphe, connexe, non-orienté, pondéré, et son arbre couvrant minimal.](figs/arbre_couvrant_minimal_exemple.png)

		# Algorithme de Prim

		::: columns

		:::: column

		## Un exemple

		![Le graphe de départ.](figs/prim_0.png)

		::::

		:::: column

		## On part de `e` (au hasard)

		![Le sommet `e` est couvert.](figs/prim_1.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_1.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `e->d`

		![Le sommet `d` est couvert.](figs/prim_2.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_2.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `d->a`

		![Le sommet `a` est couvert.](figs/prim_3.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_3.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `d->c`

		![Le sommet `c` est couvert.](figs/prim_4.png)

		::::

		:::

		# Algorithme de Prim

		::: columns

		:::: column

		## On choisit comment?

		![Quelle arête choisir?](figs/prim_4.png)

		. . .

		* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.

		::::

		:::: column

		. . .

		## L'arête `e->b`

		![Le sommet `b` est couvert.](figs/prim_5.png)

		::::

		:::

		* Game over!

		# Algorithme de Prim

		## Structures de données

		* Dans quoi allons nous stocker les sommets?

		. . .

		* File de priorité min.
		* Autre chose?

		. . .

		* Tableau des distances (comme pour Dijkstra).
		* Autre chose?

		. . .

		* Tableau des parents (presque comme pour Dijkstra).
		* Autre chose?

		. . .

		* Non.

		# Algorithme de Prim

		## Initialisation: Pseudo-code (2min)

		. . .

		```C
		file_priorité, distance, parent initialisation(graphe)
		r = aléatoire(graphe)
		distance[r] = 0
		parent[r] = indéfini
		fp = file_p_vide()
		pour v dans sommets(graphe)
		si v != r
		distance[v] = infini
		parent[v] = indéfini
		fp = enfiler(fp, v, distance[v])
		retourne fp, distance, parent
		```

		# Algorithme de Prim

		## Algorithme: Pseudo-code (5min)

		. . .

		```C
		sommets, parent prim(file_priorité, distance, parent)
		sommets = vide
		tant que !est_vide(file_priorité)
		u, fp = défiler(file_priorité)
		sommets = insérer(sommets, u)
		pour v dans voisinage de u et pas dans sommets
		// ou dans file_priorité
		si w(u, v) < distance[v]
		parent[w] = u
		distance[w] = w(u, v)
		fp = changer_priorité(fp, w, w(u, v))
		retourne sommets, parent
		```

		# Exemple d'algorithme de Prim

		::: columns

		:::: {.column width="40%"}

		## Un exemple

		![Étape 1.](figs/prim_1.png)

		::::

		:::: column

		```
		FP \| e \| d \| b \| c \| a \|
		----------------------------------
		D \| 0 \| inf \| inf \| inf \| inf \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| - \| - \| - \| - \|
		```

		## Devient?

		. . .

		```
		FP \| d \| b \| c \| a \|
		----------------------------
		D \| 4 \| 5 \| 5 \| inf \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| e \| - \|
		```

		::::

		:::

		# Exemple d'algorithme de Prim

		::: columns

		:::: {.column width="40%"}

		## Un exemple

		![Étape 2.](figs/prim_2.png)

		::::

		:::: column

		```
		FP \| d \| b \| c \| a \|
		----------------------------
		D \| 4 \| 5 \| 5 \| inf \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| e \| - \|
		```

		## Devient?

		. . .

		```
		FP \| a \| c \| b \|
		----------------------
		D \| 2 \| 4 \| 5 \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| d \| d \|
		```

		::::

		:::

		# Exemple d'algorithme de Prim

		::: columns

		:::: {.column width="40%"}

		## Un exemple

		![Étape 3.](figs/prim_3.png)

		::::

		:::: column

		```
		FP \| a \| c \| b \|
		----------------------
		D \| 2 \| 4 \| 5 \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| d \| d \|
		```

		## Devient?

		. . .

		```
		FP \| c \| b \|
		----------------
		D \| 4 \| 5 \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| d \| d \|
		```

		::::

		:::

		# Exemple d'algorithme de Prim

		::: columns

		:::: {.column width="40%"}

		## Un exemple

		![Étape 4.](figs/prim_4.png)

		::::

		:::: column

		```
		FP \| c \| b \|
		----------------
		D \| 4 \| 5 \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| d \| d \|
		```

		## Devient?

		. . .

		```
		FP \| b \|
		----------
		D \| 5 \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| d \| d \|
		```

		::::

		:::

		# Exemple d'algorithme de Prim

		::: columns

		:::: {.column width="40%"}

		## Un exemple

		![Étape 5.](figs/prim_4.png)

		::::

		:::: column

		```
		FP \| b \|
		----------
		D \| 5 \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| d \| d \|
		```

		## Devient?

		. . .

		```
		FP \|
		----
		D \|

		\| e \| d \| b \| c \| a \|
		----------------------------------
		P \| - \| e \| e \| d \| d \|
		```

		::::

		:::

		# Exercice: algorithme de Prim

		## Appliquer l'algorithme de Prim à (15min):

		![En démarrant du sommet $V_1$.](figs/prim_exercice.png)

		# Exercice: algorithme de Prim

		## Solution

		![](figs/prim_solution.png)

		# Complexité de l'algorithme de Prim

		\footnotesize

		```C
		file_priorité, distance, parent initialisation(graphe)
		// choix r et initialisation
		pour v dans sommets(graphe)
		O(\|V\|) // initialisation distance et parent
		fp = enfiler(fp, v, distance[v])
		retourne fp, distance, parent
		sommets, parent prim(file_priorité, distance, parent)
		sommets = vide
		tant que !est_vide(file_priorité)
		O(\|V\|) u, fp = défiler(file_priorité)
		sommets = insérer(sommets, u)
		pour v dans voisinage de u et pas dans sommets
		O(\|E\|) si w(u, v) < distance[v]
		// màj dista + parent
		O(\|V\|) fp = changer_priorité(fp, w, w(u, v))
		retourne sommets, parent
		```

		* $O(\|V\|)+O(\|E\|)+O(\|V\|^2)=O(\|E\|+\|V\|^2)$
		* Remarque: $O(\|E\|)$ n'est pas mutliplié par $O(\|V\|)$, car les arêtes parcourues qu'une fois en tout.

		# Algorithme de Kruskal

		* On ajoute les arêtes de poids minimal:
		* si cela ne crée pas de cycle;
		* on s'arrête quand on a couvert tout le graphe.

		. . .

		* Comment on fait ça?

		. . .

		* Faisons un exemple pour voir.

		# Algorithme de Kruskal: exemple

		::: columns

		:::: column

		## Un exemple

		![Le graphe de départ.](figs/kruskal_0.png)

		::::

		:::: column

		## On part de `(a, d)` (poids le plus faible)

		![Les sommets `a, d` sont couverts.](figs/kruskal_1.png)

		::::

		:::

		# Algorithme de Kruskal: exemple

		::: columns

		:::: column

		## On continue avec `(c, d)`

		![On aurait pu choisir `(d, e)` aussi.](figs/kruskal_1.png)

		::::

		:::: column

		## Résultat

		![Les sommets `a, d, c` sont couverts.](figs/kruskal_2.png)

		::::

		:::

		# Algorithme de Kruskal: exemple

		::: columns

		:::: column

		## On continue avec `(d, e)`

		![Le poids de `(d, e)` est le plus bas.](figs/kruskal_2.png)

		::::

		:::: column

		## Résultat

		![Les sommets `a, d, c, e` sont couverts.](figs/kruskal_3.png)

		::::

		:::

		# Algorithme de Kruskal: exemple

		::: columns

		:::: column

		## On continue avec `(b, e)`

		![Le poids de `(b, e)` est le plus bas.](figs/kruskal_3.png)

		::::

		:::: column

		## Résultat

		![Les sommets `a, d, c, e, b` sont couverts.](figs/kruskal_4.png)

		::::

		:::

		# Algorithme de Kruskal: exemple

		::: columns

		:::: column

		## Mais pourquoi pas `(c, e)`?

		![Le poids de `(b, e)` ou `(a,c)` est le même.](figs/kruskal_3.png)

		::::

		:::: column

		## Résultat: un cycle

		![Les sommets `a, d, c, e` sont couverts.](figs/kruskal_cycle.png)

		::::

		:::

		* Comment faire pour empêcher l'ajout de `(c, e)` ou `(a, c)`?

		. . .

		* Si les deux sommets sont déjà couverts nous sommes sauvés (presque)!

		# Algorithme de Kruskal

		## L'initialisation

		* Créer un ensemble de sommets pour chaque de sommet du graphe ($V_1$, $V_2$, ...):
		* $V_1=\{v_1\}$, $V_2=\{v_2\}$, ...
		* S'il y a $n$ sommets, il y a $n$ $V_i$.
		* Initialiser l'ensemble $A$ des arêtes "sûres" constituant l'arbre couvrant minimal, $A=\emptyset$.
		* Initialiser l'ensemble des sommets couverts $F=\emptyset$
		* Trier les arêtes par poids croissant dans l'ensemble $E$.

		## Mise à jour

		* Tant qu'il reste plus d'un $V_i$:
		* Pour $(u,v)\in A$ à poids minimal:
		* Retirer $(u,v)$ de $A$,
		* Si $u\in V_i$ et $v\in V_j$ avec $V_i\cap V_j=\emptyset$:
		* Ajouter $(u,v)$ à $A$;
		* Fusionner $U$ et $V$ dans $F$.

		# Algorithme de Kruskal: exemple

		::: columns

		:::: column

		![Couvrir cet arbre bon sang!](figs/kruskal_enonce.png)

		::::

		:::: column

		::::

		:::

		# Algorithme de Kruskal: solution

		![La solution!](figs/kruskal_solution.png)

		# Algorithme de Kruskal: exercice

		::: columns

		:::: column

		![Couvrir cet arbre bon sang!](figs/kruskal_exercice.png)

		::::

		:::: column

		::::

		:::

		# Algorithme de Kruskal: solution

		![La solution!](figs/kruskal_solution_exercice.png)

slides/cours_3.md→slides_2021/cours_3.md

+0 −0

File moved.

slides/cours_4.md→slides_2021/cours_4.md

+0 −0

File moved.

slides/cours_5.md→slides_2021/cours_5.md

+0 −0

File moved.

slides/cours_6.md→slides_2021/cours_6.md

+0 −0

File moved.

slides/cours_7.md→slides_2021/cours_7.md

+0 −0

File moved.

slides/cours_8.md→slides_2021/cours_8.md

+0 −0

File moved.

slides/cours_9.md→slides_2021/cours_9.md

+0 −0

File moved.

slides_2021/docker-compose.yml

0 → 100644

+14 −0

Original line number	Diff line number	Diff line
		version: "3.3"
		services:
		slides:
		#To use dockerfile : build: .
		image: omalaspinas/pandoc:latest
		environment:
		USER: 1000
		GROUP: 1000
		container_name: slides
		volumes:
		- ./:/data
		# entrypoint: ["make", "all"]
		working_dir: /data
		# user: "$(id -u):$(id -g)"