6a92d6726c5e711f19dc31d9355d64389ebd6d80 to main · algorithmique / cours

Some changes are not shown.

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

.gitignore

+5 −0

Original line number	Diff line number	Diff line
		*.o
		.xopp
		slides/package-lock.json
		slides/package.json
		slides/.vscode/settings.json
		.vscode/settings.json
		slides/node_modules/.package-lock.json

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/cours_2.md

+302 −159

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

		# Rappel

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

		. . .

		```C
		bool est_premier(int nombre) {
		int i = 2; // bonne pratique!
		while (i < nombre) { // penser à bien indenter!
		if (0 == nombre % i) { // ça rend le code LISIBLE!
		return false;
		}
		i += 1;
		}
		return true;
		}
		```

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

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

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

		# Expressions et opérateurs (4/6)

		## Opérateurs arithmétiques

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

		# Expressions et opérateurs (5/6)

		## Opérateurs d'assignation

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

		# Expressions et opérateurs (6/6)

		## Opérateurs d'assignation (suite)

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


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

		## Syntaxe

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

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

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

		## Pièges

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

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

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


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

		## La boucle `while`{.C}

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

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

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

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

		## La boucle `for`{.C}

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

		## La boucle `for`{.C}

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

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


		# 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

		. . .

		```python
		entier factorielle(entier n)
		i = 1
		fact = 1
		tant que i <= n
		fact *= i
		i += 1
		retourne fact
		```

		# 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++;
		}
		printf("La factorielle de %d est %d\n", nb, fact);
		}
		```

		. . .

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


		# Exercice: la factorielle en mieux

		## Individuellement

		1. Écrivez l'algorithme de calcul de deux façon différentes.
		2. Que se passe-t-il si $n>=15$?
		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!

		# Exercice: test si un nombre est premier

		## Avec tout ce que vous avez appris la dernière fois:
		## Avec tout ce que vous avez appris jusqu'ici:

		* Écrivez le code testant si un nombre est premier.
		* Quels sont les ajouts possibles par rapport au code de la semaine passée?
		@@ -159,12 +457,6 @@ Par groupe de 3 (5-10min):
		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`.

		<!-- Si un nombre, $p$, est multiple de $a$ et de $b$ alors il peut s'écrire -->
		<!-- $$ -->
		<!-- p = a \cdot i = b \cdot j, -->
		<!-- $$ -->
		<!-- ou encore $p / a = i$ et $p / b = j$. -->

		. . .

		## Pseudo-code
		@@ -172,7 +464,7 @@ Si un nombre, `p`, est multiple de `a` et de `b` alors il peut s'écrire `p = a
		```C
		int ppcm(int a, int b) {
		for (i in [1, b]) {
		if a * i is divisible by b {
		if a * i est divisible par b {
		return a * i
		}
		}
		@@ -191,7 +483,6 @@ int ppcm(int a, int b) {
		```C
		#include <stdio.h>
		#include <stdlib.h>

		int main() {
		int n = 15, m = 12;
		int i = 1;
		@@ -209,7 +500,6 @@ int main() {
		```C
		#include <stdio.h>
		#include <stdlib.h>

		int main() {
		int res = n*m;
		for (int i = 2; i <= m; i++) {
		@@ -222,153 +512,6 @@ int main() {
		}
		```

		# Le calcul du PGCD (1/5)

		## Définition

		Le plus grand commun diviseur (PGCD) de deux nombres entiers non nuls est le
		plus grand entier qui les divise en même temps.

		## Exemples:

		```C
		PGCD(3, 4) = 1,
		PGCD(4, 6) = 2,
		PGCD(5, 15) = 5.
		```

		. . .

		## Mathématiquement

		Décomposition en nombres premiers:

		$$
		36 = 2^2\cdot 3^2,\quad 90=2\cdot 5\cdot 3^2,
		$$
		On garde tous les premiers à la puissance la plus basse
		$$
		PGCD(36, 90)=2^{\min{1,2}}\cdot 3^{\min{2,2}}\cdot 5^{\min{0,1}}=18.
		$$

		# Le calcul du PGCD (2/5)

		## Algorithme

		Par groupe de 3 (5-10min):

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

		. . .

		## Exemple d'algorithme

		```C
		PGCD(36, 90):
		90 % 36 != 0 // otherwise 36 would be PGCD
		90 % 35 != 0 // otherwise 35 would be PGCD
		90 % 34 != 0 // otherwise 34 would be PGCD
		...
		90 % 19 != 0 // otherwise 19 would be PGCD
		90 % 18 == 0 // The end!
		```

		* 18 modulos, 18 assignations, et 18 comparaisons.

		# Le calcul du PGCD (3/5)

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

		. . .

		## Optimisation

		* Combien d'additions / comparaisons au pire?
		* Un moyen de le rendre plus efficace?

		. . .

		## Tentative de correction

		```C
		void main() {
		int n = 90, m = 78;
		int gcd = 1;
		for (int div = n; div >= 2; div--) { // div = m, sqrt(n)
		if (n % div == 0 && m % div == 0) {
		gcd = div;
		break;
		}
		}
		printf("Le pgcd de %d et %d est %d\n", n, m, gcd);
		}
		```

		# Le calcul du PGCD (4/5)

		## Réusinage: l'algorithme d'Euclide

		`Dividende = Diviseur * Quotient + Reste`

		```C
		PGCD(35, 60):
		35 = 60 * 0 + 35 // 60 -> 35, 35 -> 60
		60 = 35 * 1 + 25 // 35 -> 60, 25 -> 35
		35 = 25 * 1 + 10 // 25 -> 35, 20 -> 25
		25 = 10 * 2 + 5 // 10 -> 25, 5 -> 10
		10 = 5 * 2 + 0 // PGCD = 5!
		```

		. . .

		## Algorithme

		Par groupe de 3 (5-10min):

		* analysez l'exemple ci-dessus;
		* transcrivez le en pseudo-code.

		# Le calcul du PGCD (5/5)

		## Pseudo-code

		```C
		int pgcd(int a, int b) {
		tmp_n = n
		tmp_m = m
		while (tmp_m does not divide tmp_n) {
		tmp = tmp_n
		tmp_n = tmp_m
		tmp_m = tmp modulo tmp_m
		}
		return tmp_m
		}
		```

		# Le code du PGCD de 2 nombres

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

		. . .

		## Un corrigé possible

		```C
		#include <stdio.h>
		void main() {
		int n = 90;
		int m = 78;
		printf("n = %d et m = %d\n", n, m);
		int tmp_n = n;
		int tmp_m = m;
		while (tmp_n%tmp_m > 0) {
		int tmp = tmp_n;
		tmp_n = tmp_m;
		tmp_m = tmp % tmp_m;
		}
		printf("Le pgcd de %d et %d est %d\n", n, m, tmp_m);
		}
		```

slides/cours_21.md

deleted100644 → 0

+0 −236

Original line number	Diff line number	Diff line
		---
		title: "Arbres quaternaires, compression et Barnes-Hut"
		date: "2022-04-06"
		patat:
		eval:
		tai:
		command: fish
		fragment: false
		replace: true
		ccc:
		command: fish
		fragment: false
		replace: true
		images:
		backend: auto
		---

		# Le cours précédent

		## Questions


		* Structure de données d'un arbre quaternaire?

		. . .

		```C
		typedef struct _node {
		int info;
		struct _node *child[4];
		} node;
		```

		. . .

		* Dessin d'un noeud d'arbre quaternaire (avec correspondance `node`)?

		. . .

		```{.mermaid format=pdf width=400 loc=figs/}
		graph TD;
		id0((" "))-->\|"child[0]"\| id1(("info"));
		id0-->\|"child[1]"\| id2(("info"));
		id0-->\|"child[2]"\| id3(("info"));
		id0-->\|"child[3]"\| id4(("info"));
		```

		# Le cours précédent

		## Questions

		* Comment faire la symétrie d'axe horizontal?

		. . .

		```C
		arbre symétrie(arbre)
		si !est_feuille(arbre)
		échanger(arbre.enfant[0], arbre.enfant[1])
		échanger(arbre.enfant[2], arbre.enfant[3])
		pour i de 0 à 3
		symétrie(arbre.enfant[i])
		retourne arbre
		```

		# Compression sans perte (1/N)

		## Idée générale

		* Regrouper les pixels par valeur

		```
		SG=0 \| SD=1 SG=0 \| SD=1
		21 \| 12 \| 4 \| 4 21 \| 12 \| 4
		9 \| 7 \| 4 \| 4 9 \| 7 \|
		----------------- => -----------------
		1 \| 1 \| 0 \| 31 1 \| 0 \| 31
		1 \| 1 \| 3 \| 27 \| 3 \| 27
		IG=2 \| ID=3 IG=2 \| ID=3
		```

		* Comment faire?

		# Compression sans perte (2/N)

		## Que devient l'arbre suivant?

		![](figs/quad_img_simple.svg)

		. . .

		## Arbre compressé

		![](figs/quad_img_simple_comp.svg)

		# Compression sans perte (3/N)

		* Si un noeud a tous ses enfants égaux:
		* Donner la valeur au noeud,
		* Supprimer les enfants.
		* Remonter jusqu'à la racine.

		## Écrire le pseudo-code (5min, matrix)

		```C
		rien compression_sans_perte(arbre)
		si !est_feuille(arbre)
		pour i de 0 à 3
		compression_sans_perte(arbre.enfant[i])
		si derniere_branche(arbre)
		valeur, toutes_égales = valeur_enfants(arbre)
		si toutes_egales
		arbre.info = valeur
		detruire_enfants(arbre)
		```

		# Compression sans perte (4/N)

		\footnotesize

		## Écrire le code C (5min, matrix)

		. . .

		```C
		void lossless_compression(node *qt) {
		if (!is_leaf(qt)) {
		for (int i = 0; i < CHILDREN; i++) {
		lossless_compression(qt->child[i]);
		}
		if (is_last_branch(qt)) {
		int val = -1;
		if (last_value(qt, &val)) {
		qt->info = val;
		for (int i = 0; i < 4; ++i) {
		free(qt->child[i]);
		qt->child[i] = NULL;
		}
		}
		}
		}
		}
		```

		# Compression sans perte (5/N)

		\footnotesize

		```C
		bool is_last_branch(node *qt) {
		for (int i = 0; i < 4; ++i) {
		if (!is_leaf(qt)) {
		return false;
		}
		}
		return true;
		}
		bool last_value(node qt, int val) {
		int info = qt->child[0];
		for (int i = 1; i < 4; ++i) {
		if (info != qt->child[i]) {
		return false;
		}
		}
		*val = info;
		return true;
		}
		```


		# Compression avec perte (1/N)

		## Idée générale

		* Regrouper les pixels par valeur sous certaines conditions

		```
		SG=0 \| SD=1 SG=0 \| SD=1
		21 \| 12 \| 4 \| 3 21 \| 12 \| 4
		9 \| 7 \| 4 \| 4 9 \| 7 \|
		----------------- => ------------------
		1 \| 1 \| 0 \| 31 1 \| 0 \| 31
		2 \| 1 \| 3 \| 27 \| 3 \| 27
		IG=2 \| ID=3 IG=2 \| ID=3
		```

		* On enlève si l'écart à la moyenne est "petit"?

		# Compression avec perte (2/N)

		## Que devient l'arbre suivant si l'écart est petit?

		![](figs/quad_img_simple_variation.svg)

		. . .

		## Arbre compressé

		![](figs/quad_img_simple_comp_loss.svg)

		# Compression avec perte (3/N)

		## Comment mesurer l'écart à la moyenne?

		. . .

		* Avec l'écart-type

		\begin{equation*}
		\mu = \frac{1}{4}\sum_{i=0}^{3} p[i],\quad \sigma = \sqrt{\frac{1}{N}\sum_{i=0}^3 (\mu-p[i])
		^2}
		\end{equation*}

		## Que devient l'algorithme?

		. . .

		* Si $\sigma<\theta$, $\theta$ est la tolérance:
		* Remplacer la valeur du pixel par la moyenne des enfants.
		* Remonter les valeurs dans l'arbre.

		## Quelle influence de la valeur de $\theta$ sur la compression?

		. . .

		* Plus $\theta$ est grand, plus l'image sera compressée.

		# Compression avec perte (4/N)

		## Que devient l'arbre avec $\theta=0.5$?

		![L'arbre original.](figs/quad_img_simple_variation.svg)

		. . .

		![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)

slides/cours_3.md

+267 −220

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2021-10-06"
		patat:
		eval:
		tai:
		command: fish
		fragment: false
		replace: true
		ccc:
		command: fish
		fragment: false
		replace: true
		images:
		backend: auto
		title: "Introduction aux algorithmes III"
		date: "2025-09-30"
		---

		# Quelques algorithmes simples
		# Rappel (1/2)

		## Quelques algorithmes supplémentaires
		## Quels algos avons-nous vu la semaine passée?

		* Remplissage d'un tableau et recherche de la valeur minimal
		* Anagrammes
		* Palindromes
		* Crible d'ératosthène
		. . .

		# Collections: tableaux statiques
		* L'algorithme de la factorielle.
		* L'algorithme du PPCM.

		* Objets de même type: leur nombre est connu à la compilation;
		* Stockés contigüement en mémoire (très efficace);
		# Rappel (2/2)

		```C
		#define SIZE 10
		int entiers[] = {2, 1, 4, 5, 7}; // taille 5, initialisé
		int tab[3]; // taille 3, non initialisé
		float many_floats[SIZE]; // taille 10, non initialisé
		```
		* Les indices sont numérotés de `0` à `taille-1`;
		## Algorithme du PPCM?

		```C
		int premier = entier[0]; // premier = 2
		int dernier = entier[4]; // dernier = 7
		```
		* Les tableaux sont non-initialisés par défaut;
		* Les bornes ne sont jamais vérifiées.
		. . .

		```C
		int indetermine_1 = tab[1]; // undefined behavior
		int indetermine_2 = entiers[5]; // UB
		int main() {
		int m = 15, n = 12;
		int mult_m = m, mult_n = n;
		while (mult_m != mult_n) {
		if (mult_m > mult_n) {
		mult_n += n;
		} else {
		mult_m += m;
		}
		}
		printf("Le ppcm de %d et %d est %d\n", n, m, mult_m);
		}
		```

		# Remarques

		* Depuis `C99` possibilité d'avoir des tableaux dont la taille est *inconnue à
		la compilation*;
		# Le calcul du PPCM (1/2)

		```C
		int size;
		scanf("%d", &size);
		char string[size];
		```
		## Réusinage: Comment décrire une fonction qui ferait ce calcul (arguments, sorties)?

		. . .

		* 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).

		# Initialisation

		* Les variables ne sont jamais initialisées en `C` par défaut.
		* Question: Que contient le tableau suivant?
		En `C` on pourrait la décrire comme

		```C
		double tab[4];
		int ppcm(int a, int b); // La signature de cette fonction
		```

		. . .

		* Réponse: On en sait absolument rien!
		* Comment initialiser un tableau?
		## Algorithme

		. . .
		Par groupe de 3 (5-10min):

		```C
		#define SIZE 10
		double tab[SIZE];
		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]
		}
		```
		* réfléchissez à un algorithme alternatif donnant le PPCM de deux nombres;
		* écrivez l'algorithme en pseudo-code.

		# Recherche du minimum dans un tableau (1/2)
		. . .

		## Problématique
		* 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`.

		Trouver la valeur minimale contenue dans un tableau et l'indice de l'élément le plus petit.

		## Écrire un pseudo-code résolvant ce problème (groupe de 3), 2min
		# Le calcul du PPCM (2/2)

		. . .

		## Pseudo-code

		```C
		index = 0
		min = tab[0]
		for i in [1; SIZE] {
		if min > tab[i] {
		min = tab[i]
		index = i
		int ppcm(int a, int b) {
		for (i in [1, b]) {
		if a * i est divisible par b {
		return a * i
		}
		}
		}
		```

		# Recherche du minimum dans un tableau (2/2)
		# Le code du PPCM de 2 nombres (1/2)

		## Implémenter ce bout de code en C (groupe de 3), 4min
		## Implémentez le pseudo-code et postez le code sur matrix (5min).

		. . .

		## Un corrigé possible


		```C
		int index = 0;
		float min = tab[0];
		for (int i = 1; i < SIZE; ++i) {
		if min > tab[i] {
		min = tab[i];
		index = i;
		#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);
		}
		```

		# Tri par sélection (1/2)

		## Problématique

		Trier un tableau par ordre croissant.
		# Le code du PPCM de 2 nombres (2/2)

		## Idée d'algorithme
		## Corrigé alternatif

		```C
		ind = 0
		boucle (ind < SIZE-1) {
		Trouver le minimum du tableau, tab_min[ind:SIZE].
		Échanger tab_min avec tab[ind]
		ind += 1
		#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);
		}
		```

		# Tri par sélection (2/2)

		## Implémentation par groupe de 3

		* Initialiser aléatoirement un tableau de `double` de taille 10;
		* Afficher le tableau;
		* Trier par sélection le tableau;
		* Afficher le résultat trié;
		* Vérifier algorithmiquement que le résultat est bien trié.

		# Un type de tableau particulier

		## Les chaînes de caractères
		# Le calcul du PGCD (1/5)

		```C
		string = tableau + char + magie noire
		```
		## Définition

		# Le type `char`{.C}
		Le plus grand commun diviseur (PGCD) de deux nombres entiers non nuls est le
		plus grand entier qui les divise en même temps.

		- Le type `char`{.C} est utilisé pour représenter un caractère.
		- C'est un entier 8 bits signé.
		- En particulier:
		- Écrire
		## Exemples:

		```C
		char c = 'A';
		PGCD(3, 4) = 1,
		PGCD(4, 6) = 2,
		PGCD(5, 15) = 5.
		```
		- Est équivalent à:

		```C
		char c = 65;
		```
		- Les fonctions d'affichage interprètent le nombre comme sa valeur ASCII.
		. . .

		# Chaînes de caractères (strings)
		## Mathématiquement

		- Chaîne de caractère `==` tableau de caractères terminé par la valeur `'\0'`{.C} ou `0`{.C}.
		Décomposition en nombres premiers:

		## Exemple
		$$
		36 = 2^2\cdot 3^2,\quad 90=2\cdot 5\cdot 3^2,
		$$
		On garde tous les premiers à la puissance la plus basse
		$$
		PGCD(36, 90)=2^{\min{1,2}}\cdot 3^{\min{2,2}}\cdot 5^{\min{0,1}}=18.
		$$

		# Le calcul du PGCD (2/5)

		## Algorithme

		Par groupe de 3 (5-10min):

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

		. . .

		## Exemple d'algorithme

		```C
		char *str = "HELLO !";
		char str[] = "HELLO !";
		PGCD(36, 90):
		90 % 36 != 0 // otherwise 36 would be PGCD
		90 % 35 != 0 // otherwise 35 would be PGCD
		90 % 34 != 0 // otherwise 34 would be PGCD
		...
		90 % 19 != 0 // otherwise 19 would be PGCD
		90 % 18 == 0 // The end!
		```

		Est représenté par
		* 18 modulos, 18 assignations, et 18 comparaisons.

		\| `char` \| `H` \| `E` \| `L` \| `L` \| `O` \| \| `!` \| `\0`\|
		\|---------\|------\|------\|------\|------\|------\|------\|------\|-----\|
		\| `ASCII` \| `72` \| `69` \| `76` \| `76` \| `79` \| `32` \| `33` \| `0` \|
		# Le calcul du PGCD (3/5)

		. . .
		\footnotesize

		## A quoi sert le `\0`?
		## Transcrivez cet exemple en algorithme et codez-le (5-10min)!

		. . .

		Permet de connaître la fin de la chaîne de caractères (pas le cas des autres
		sortes de tableaux).
		## Optimisation

		# Syntaxe
		* Combien d'additions / comparaisons au pire?
		* Un moyen de le rendre plus efficace?

		. . .

		## Tentative de correction

		```C
		char name[5];
		name[0] = 'P'; // = 70;
		name[1] = 'a'; // = 97;
		name[2] = 'u'; // = 117;
		name[3] = 'l'; // = 108;
		name[4] = '\0'; // = 0;
		char name[] = {'P', 'a', 'u', 'l', '\0'};
		char name[5] = "Paul";
		char name[] = "Paul";
		char name[100] = "Paul is not 100 characters long.";
		void main() {
		int n = 90, m = 78;
		int gcd = 1;
		for (int div = n; div >= 2; div--) { // div = m, sqrt(n)
		if (n % div == 0 && m % div == 0) {
		gcd = div;
		break;
		}
		}
		printf("Le pgcd de %d et %d est %d\n", n, m, gcd);
		}
		```

		# Fonctions
		# Le calcul du PGCD (4/5)

		## Réusinage: l'algorithme d'Euclide

		- Il existe une grande quantités de fonction pour la manipulation de chaînes de caractères dans `string.h`.
		- Fonctions principales:
		`Dividende = Diviseur * Quotient + Reste`

		```C
		// longueur de la chaîne (sans le \0)
		size_t strlen(char *str);
		// copie jusqu'à un \0
		char strcpy(char dest, const char *src);
		// copie len char
		char strncpy(char dest, const char *src, size_t len);
		// compare len chars
		int strncmp(char str1, char str2, size_t len);
		// compare jusqu'à un \0
		int strcmp(char str1, char str2);
		PGCD(35, 60):
		35 = 60 * 0 + 35 // 60 -> 35, 35 -> 60
		60 = 35 * 1 + 25 // 35 -> 60, 25 -> 35
		35 = 25 * 1 + 10 // 25 -> 35, 20 -> 25
		25 = 10 * 2 + 5 // 10 -> 25, 5 -> 10
		10 = 5 * 2 + 0 // PGCD = 5!
		```

		- Pour avoir la liste complète: `man string`.

		. . .

		## Quels problèmes peuvent se produire avec `strlen`, `strcpy`, `strcmp`?
		## Algorithme

		# Les anagrammes
		Par groupe de 3 (5-10min):

		## Définition

		Deux mots sont des anagrammes l'un de l'autre quand ils contiennent les mêmes
		lettres mais dans un ordre différent.
		* analysez l'exemple ci-dessus;
		* transcrivez le en pseudo-code.

		## Exemple
		# Le calcul du PGCD (5/5)

		\| `t` \| `u` \| `t` \| `u` \| `t` \| `\0` \| ` ` \| ` ` \|
		\|------\|------\|------\|------\|------\|------\|------\|-----\|
		\| `t` \| `u` \| `t` \| `t` \| `u` \| `\0` \| ` ` \| ` ` \|
		## Pseudo-code

		```C
		entier pgcd(m, n)
		tmp_n = n
		tmp_m = m
		tant que (tmp_m ne divise pas tmp_n)
		tmp = tmp_n
		tmp_n = tmp_m
		tmp_m = tmp modulo tmp_m
		retourne tmp_m

		## Problème: Trouvez un algorithme pour déterminer si deux mots sont des anagrammes.
		```

		# Les anagrammes
		# Le code du PGCD de 2 nombres

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

		1. Trier les deux mots.
		2. Vérifier s'ils contiennent les mêmes lettres.
		. . .

		## Implémentation en live (offerte par HepiaVPN)
		## Un corrigé possible

		```C
		int main() { // pseudo C
		tri(mot1);
		tri(mot2);
		if egalite(mot1, mot2) {
		// anagrammes
		} else {
		// pas anagrammes
		#include <stdio.h>
		void main() {
		int n = 90;
		int m = 78;
		printf("n = %d et m = %d\n", n, m);
		int tmp_n = n;
		int tmp_m = m;
		while (tmp_n%tmp_m > 0) {
		int tmp = tmp_n;
		tmp_n = tmp_m;
		tmp_m = tmp % tmp_m;
		}
		printf("Le pgcd de %d et %d est %d\n", n, m, tmp_m);
		}
		```

		<!-- TODO: Live implémentation hors des cours? -->

		# Les palindromes
		# Quelques algorithmes simples

		Mot qui se lit pareil de droite à gauche que de gauche à droite:
		* Stockage d'une liste de nombre et recherche de la valeur minimale
		* Anagrammes
		* Palindromes
		* Crible d’Ératosthène

		. . .

		* rotor, kayak, ressasser, ...
		* Ces algorithme nécessitent d'utiliser des tableaux.

		# Collections: tableaux statiques

		\footnotesize

		## Problème: proposer un algorithme pour détecter un palindrome
		* 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
		int entiers[] = {2, 1, 4, 5, 7}; // taille 5, initialisé
		int tab[3]; // taille 3, non initialisé
		float many_floats[SIZE]; // taille 10, non initialisé
		```
		* Les indices sont numérotés de `0` à `taille-1`;

		```C
		int premier = entier[0]; // premier = 2
		int dernier = entier[4]; // dernier = 7
		```
		* Les tableaux sont non-initialisés par défaut;
		* Les bornes ne sont jamais vérifiées.

		```C
		int indetermine_1 = tab[1]; // undefined behavior
		int indetermine_2 = entiers[5]; // UB
		```

		# Remarques

		* Depuis `C99` la taille peut être inconnue à la compilation (VLA);

		```C
		int size;
		scanf("%d", &size);
		char string[size];
		```

		. . .

		## Solution 1
		* 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).

		# Initialisation

		* Les variables ne sont jamais initialisées en `C` par défaut.
		* Question: Que contient le tableau suivant?

		```C
		while (first_index < last_index {
		if (mot[first_index] != mot [last_index]) {
		return false;
		}
		first_index += 1;
		last_index -= 1;
		}
		return true;
		double tab[4];
		```

		. . .

		## Solution 2
		* Réponse: On en sait absolument rien!
		* Comment initialiser un tableau?

		. . .

		```C
		mot_tmp = revert(mot);
		return mot == mot_tmp;
		#define SIZE 10
		double tab[SIZE];
		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}
		```

		# Crible d'Ératosthène
		# Recherche du minimum dans un tableau (1/2)

		## Problématique

		Algorithme de génération de nombres premiers.
		Trouver la valeur minimale contenue dans un tableau et l'indice de l'élément le plus petit.

		## Exercice
		## Écrire un pseudo-code résolvant ce problème (groupe de 3), 2min

		* À l'aide d'un tableau de booléens,
		* Générer les nombres premiers plus petits qu'un nombre $N$
		. . .

		## Pseudo-code
		```C
		index = 0
		min = tab[0]
		pour i de 1 à SIZE - 1
		si min > tab[i]
		min = tab[i]
		index = i
		```

		* Par groupe de trois, réfléchir à un algorithme.
		# Recherche du minimum dans un tableau (2/2)

		## Programme en C
		## Implémenter ce bout de code en C (groupe de 3), 4min

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

		```C
		int index = 0;
		float min = tab[0];
		for (int i = 1; i < SIZE; ++i) {
		if (min > tab[i]) {
		min = tab[i];
		index = i;
		}
		}
		```

slides/cours_4.md

+147 −571

Original line number	Diff line number	Diff line
		---
		title: "Introduction aux algorithmes"
		date: "2021-10-13"
		patat:
		eval:
		tai:
		command: fish
		fragment: false
		replace: true
		ccc:
		command: fish
		fragment: false
		replace: true
		images:
		backend: auto
		title: "Introduction aux algorithmes IV"
		date: "2025-10-07"
		---

		# Crible d'Ératosthène: solution
		# Le tri par sélection

		\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:
		\Huge Le tri par sélection

		* Réusiner le code se trouvant sur
		[Cyberlearn](https://cyberlearn.hes-so.ch/mod/resource/view.php?id=1627712).
		# Tri par sélection (1/3)

		# Tableau à deux dimensions (1/4)
		## Problématique

		## Mais qu'est-ce donc?

		. . .
		Trier un tableau par ordre croissant.

		* 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
		## Idée d'algorithme

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

		# Tableau à deux dimensions (3/4)
		# Tri par sélection (2/3)

		## Exercice: déclarer et initialiser aléatoirement un tableau `50x100`
		## Quel est l'algorithme du tri par sélection?

		. . .

		```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
		}
		}
		```
		1. Soit un tableau d'entiers, `tab[0:SIZE-1]` et `i = 0`.
		2. Trouver l'indice, `j`, de `tab[i:SIZE-1]` où la valeur est minimale.
		3. Échanger `tab[i]` et `tab[j]`.
		4. `i += 1` et revenir à 2, tant que `i < SIZE-1`.

		## Exercice: afficher le tableau
		# Tri par sélection (3/3)

		. . .
		## Implémentation par groupe de 3

		```C
		for (int i = 0; i < NX; ++i) {
		for (int j = 0; j < NY; ++j) {
		printf("%d ", tab[i][j]);
		}
		printf("\n");
		}
		```
		* Initialiser aléatoirement un tableau de `double` de taille 10;
		* Afficher le tableau;
		* Trier par sélection le tableau;
		* Afficher le résultat trié;
		* Vérifier algorithmiquement que le résultat est bien trié.

		# Les chaînes de caractères

		# Tableau à deux dimensions (4/4)
		\Huge Les chaînes de caractères

		## Attention
		# Un type de tableau particulier

		* Les éléments ne sont jamais initialisés.
		* Les bornes ne sont jamais vérifiées.
		## Les chaînes de caractères

		```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?
		string = tableau + char + magie noire
		```

		# 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`.
		# Le type `char`{.C}

		## 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.
		- Le type `char`{.C} est utilisé pour représenter un caractère.
		- C'est un entier 8 bits signé.
		- En particulier:
		- Écrire

		```C
		enum days {
		monday, tuesday, wednesday,
		thursday, friday, saturday, sunday
		};
		char c = 'A';
		```
		* On peut aussi donner des valeurs "custom"
		- Est équivalent à:

		```C
		enum days {
		monday = 2, tuesday = 8, wednesday = -2,
		thursday = 1, friday = 3, saturday = 12, sunday = 9
		};
		char c = 65;
		```
		* S'utilise comme un type standard et un entier
		- Les fonctions d'affichage interprètent le nombre comme sa valeur ASCII.

		```C
		enum days d = monday;
		(d + 2) == tuesday + tuesday; // true
		```
		# Chaînes de caractères (strings)

		# Types énumérés (2/2)
		- Chaîne de caractère `==` tableau de caractères terminé par la valeur `'\0'`{.C} ou `0`{.C}.

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

		```C
		enum days d = monday;
		switch (d) {
		case monday:
		// trucs
		break;
		case tuesday:
		printf("0 ou 1\n");
		break;
		}
		char *str = "HELLO !";
		char str[] = "HELLO !";
		```
		* 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`.
		Est représenté par

		## 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
		$$
		\| `char` \| `H` \| `E` \| `L` \| `L` \| `O` \| \| `!` \| `\0`\|
		\|---------\|------\|------\|------\|------\|------\|------\|------\|-----\|
		\| `ASCII` \| `72` \| `69` \| `76` \| `76` \| `79` \| `32` \| `33` \| `0` \|

		. . .

		$$
		= 247.
		$$

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

		## Convertir 11 en binaire?
		## A quoi sert le `\0`?

		. . .

		* 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)
		Permet de connaître la fin de la chaîne de caractères (pas le cas des autres
		sortes de tableaux).

		## 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
		# Syntaxe

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

		char name[5];
		name[0] = 'P'; // = 70;
		name[1] = 'a'; // = 97;
		name[2] = 'u'; // = 117;
		name[3] = 'l'; // = 108;
		name[4] = '\0'; // = 0;
		char name[] = {'P', 'a', 'u', 'l', '\0'};
		char name[5] = "Paul";
		char name[] = "Paul";
		char name[100] = "Paul is not 100 characters long.";
		```
		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
		$$
		# Fonctions

		* 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`?
		\footnotesize

		* L'addition est la même que dans le système décimal
		- Il existe une grande quantités de fonction pour la manipulation de chaînes de caractères dans `string.h`.
		- Fonctions principales:

		```C
		// longueur de la chaîne (sans le \0)
		size_t strlen(char *str);
		// copie jusqu'à un \0
		char strcpy(char dest, const char *src);
		// copie len char
		char strncpy(char dest, const char *src, size_t len);
		// compare len chars
		int strncmp(char str1, char str2, size_t len);
		// compare jusqu'à un \0
		int strcmp(char str1, char str2);
		```
		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?
		- Pour avoir la liste complète: `man 3 string`.

		. . .

		* Décalage de un bit vers la gauche!

		```
		0110
		* 0010
		---------
		0000
		+ 01100
		---------
		01100
		```
		## Quel problème peut se produire avec `strlen`, `strcpy`, `strcmp`?

		. . .

		## Que fait la multiplication par $2^N$?
		- Si `\0` est absent... on a un comportement indéfini.

		. . .
		# Les anagrammes

		* Décalade de $N$ bits vers la gauche!
		\Huge Les anagrammes

		# Entiers signés (1/2)
		# Les anagrammes

		Pas de nombres négatifs encore...
		## Définition

		## Comment faire?
		Deux mots sont des anagrammes l'un de l'autre quand ils contiennent les mêmes
		lettres mais dans un ordre différent.

		. . .
		## Exemple

		## Solution naïve:
		\| `t` \| `u` \| `t` \| `u` \| `t` \| `\0` \| ` ` \| ` ` \|
		\|------\|------\|------\|------\|------\|------\|------\|-----\|
		\| `t` \| `u` \| `t` \| `t` \| `u` \| `\0` \| ` ` \| ` ` \|

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

		```
		00000010: +2
		10000010: -2
		```
		## Problème: Trouvez un algorithme pour déterminer si deux mots sont des anagrammes.

		## Problèmes?
		# Les anagrammes

		. . .

		* 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).

		. . .
		## Il suffit de:

		* Comment écrit-on `-4` en 8 bits?
		1. Trier les deux mots.
		2. Vérifier s'ils contiennent les mêmes lettres.

		. . .
		## Implémentation ensemble

		```C
		int main() { // pseudo C
		tri(mot1);
		tri(mot2);
		if egalite(mot1, mot2) {
		// anagrammes
		} else {
		// pas anagrammes
		}
		}
		```
		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)`?
		# Les palindromes

		```
		00000010 2
		+ 11111100 + -4
		---------- -----
		11111110 -2
		```
		* En effet
		\Huge Les palindromes

		```
		11111110 => 00000001 + 00000001 = 00000010 = 2.
		```
		# Les palindromes

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

		## Quels sont les entiers représentables en 8 bits?
		Mot qui se lit pareil de droite à gauche que de gauche à droite:

		. . .

		```
		01111111 => 127
		10000000 => -128 // par définition
		```
		* rotor, kayak, ressasser, ...

		## Quels sont les entiers représentables sur $N$ bits?
		## Problème: proposer un algorithme pour détecter un palindrome

		. . .

		$$
		-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
		## Solution 1

		```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;
		while (first_index < last_index) {
		if (mot[first_index] != mot [last_index]) {
		return false;
		}

		struct fraction frac; // déclaration de 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
		first_index += 1;
		last_index -= 1;
		}
		return true;
		```

		# 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}
		## Solution 2

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

		![La représentation mémoire de
		`fraction_t`.](figs/pointer_struct.svg){width=50%}
		# Le crible d'Ératosthène

		# Types composés: `struct`{.C} (5/6)
		\Huge Le crible d'Ératosthène

		## Initialisation
		# Crible d'Ératosthène

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

		```C
		void fraction_init(fraction_t *frac,
		int32_t re, int32_t im)
		{
		// 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
		}
		```
		## Exercice

		# Types composés: `struct`{.C} (6/6)
		* À l'aide d'un tableau de booléens,
		* Générer les nombres premiers plus petits qu'un nombre $N$

		## Initialisation version copie
		## Pseudo-code

		* On peut allouer une fraction, l'initialiser et le retourner.
		* La valeur retournée peut être copiée dans une nouvelle structure.
		* Par groupe de trois, réfléchir à un algorithme.

		```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);
		}
		```
		## Programme en C

		<!-- # TODO jusqu'aux vacances -->
		* Implémenter l'algorithme et le poster sur le salon `Element`.

		<!-- * Refactorisation -->
		<!-- * Tris et complexité -->
		<!-- * Récursivité -->

slides/cours_5.md

+129 −714

File changed.

Preview size limit exceeded, changes collapsed.

slides/cours_6.md

+364 −325

Original line number	Diff line number	Diff line
		---
		title: "Récursivité et complexité"
		date: "2021-11-03"
		patat:
		eval:
		tai:
		command: fish
		fragment: false
		replace: true
		ccc:
		command: fish
		fragment: false
		replace: true
		images:
		backend: auto
		title: "Types énumérés, tri par fusion, récursivité"
		date: "2025-10-28"
		---

		# La récursivité (1/2)
		# Les types énumérés

		* Code récursif
		\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
		int factorial(int n) {
		if (n > 1) { // Condition de récursivité
		return n * factorial(n - 1);
		} else { // Condition d'arrêt
		return 1;
		}
		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
		@@ -43,6 +184,161 @@ patat:
		}
		```

		# 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
		@@ -139,9 +435,9 @@ int fib(int n) {

		```C
		int fib_imp(int n) {
		int fib0 = 1;
		int fib0 = 0;
		int fib1 = 1;
		int fib = n == 0 ? 0 : fib1;
		int fib = n == 0 ? fib0 : fib1;
		for (int i = 2; i < n; ++i) {
		fib = fib0 + fib1;
		fib0 = fib1;
		@@ -151,34 +447,45 @@ int fib_imp(int n) {
		}
		```

		# Exponentiation rapide

		\Huge L'exponentiation rapide ou indienne

		# Exponentiation rapide ou indienne (1/4)

		## But: Calculer $x^n$

		* Algorithme naîf et impératif
		* Quel est l'algorithmie le plus simple que vous pouvez imaginer?

		. . .

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

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

		. . .

		* Complexité? Combien de multiplication en fonction de `n`?
		* `n` assignations et `n` multiplications.

		# Exponentiation rapide ou indienne (2/4)

		* Algorithme naïf et récursif
		* Proposez un algorithme naïf et récursif

		. . .

		```C
		int pow(x, n) {
		double pow(double x, int n) {
		if (n != 0) {
		return x * pow(x, n-1);
		} else {
		@@ -211,8 +518,8 @@ $$

		## Le vrai algorithme

		* Si n est pair: calculer $\left(x^{n/2}\right)^2$,
		* Si n est impair: calculer $x \cdot \left(x^{(n-1)/2}\right)^2$.
		* 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

		@@ -220,8 +527,8 @@ $$

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


		# 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
		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
		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/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/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

File added.

Preview size limit exceeded, changes collapsed.

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/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

File changed.

Preview size limit exceeded, changes collapsed.

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: "Algorithmes 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"