Ajout des cours du 10 au 27 mars

23 files changed, 704 insertions, 62 deletions

diff --git a/semestre 2/informatique/1- De Python à C.md b/semestre 2/informatique/1- De Python à C.md
index c088a7b..1d36031 100644
--- a/semestre 2/informatique/1- De Python à C.md
+++ b/semestre 2/informatique/1- De Python à C.md
@@ -4,7 +4,7 @@ tags:
   - informatique
 semestre: 2
 ---
-```c
+```c title=hello_world.c
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -24,13 +24,13 @@ On écrit des programmes comme éditeur de texte
 -> permet d'écrire le programme
 
 Au début, on écrit les bibliothèques :
-```c
+```c title=hello_world.c
 #include <stdio.h>
 #include <stdlib.h>
 ```
 
 Les commentaires s'écrivent comme ça :
-```c
+```c title=commentaire.c
 /* bonjour, 
 je suis un commentaire sur
 plusieurs lignes */
@@ -41,7 +41,7 @@ plusieurs lignes */
 (le deuxième type de commentaire provient du C++, mais souvent ça passe)
 
 Après, on doit toujours écrire une fonction `main` :
-```c
+```c title=main_function.c
 int main(){
 	/* ... */
 	return 0;
@@ -75,7 +75,7 @@ Toutes les lignes d'instructions se finissent par un `;`
 On a toujours besoin d'une *unique* fonction `main` par programme.
 
 On peut définir plusieurs fonctions dans un programme, e.g.
-```c
+```c title=hello_world_function.c
 void hello(){
 	printf("Hello World\n");
 }
@@ -104,7 +104,7 @@ int main(){
 > `0` est vraie, le reste est faux.
 ## Arguments dans une fonction
 On les place dans les parenthèses et il fonctionne comme en Java
-```c
+```c title=hello_world_year.c
 void hello(int annee){
 	printf("Hello World %d!\n", annee)
 }
@@ -121,14 +121,14 @@ La fonction `printf` ici est utilisée pour formaté un string que l'on va ensui
 |> `"%c"` insert un `char`
 |> les valeurs que l'on insert sans mise après le format
 i.e.
-```c
+```c title=format_hello_world.c
 printf("Hello World%d-%d\n", 2024, 2025);
 // est équivalent à
 printf("Hello World 2024-2025\n");
 ```
 ## Variables
 On est obligé de déclarer les variables avec leur type, i.e.
-```c
+```c title=variables.c
 int p;
 p = 5;
 
@@ -147,14 +147,14 @@ float a=1, b=2.5, c=-2.5;
 
 ## De Python à C
 ### Syntaxe simple
-```python
+```python title=perimeter.py
 def perimetre(largeur: int, longeur: int) -> int:
 	"""Precond: longueur >= largeur >= 0
 	Retourne le périmètre du rectangle défini par sa longeur et sa largeur"""
 	return 2*(largeur + longueur)
 ```
 devient en C
-```c
+```c title=perimeter.c
 /* hypothèse: longueur >= largeur >= 0
 retourne le périmetre du rectangle défini par sa longueur et sa largeur*/
 int perimetre(int largeur, int longueur){
@@ -163,7 +163,7 @@ int perimetre(int largeur, int longueur){
 ```
 ### Structures de contrôle
 Un `if/else` s'écrit :
-```c
+```c title=conditions.c
 if (cond) {
 	//
 } else {
@@ -173,7 +173,7 @@ if (cond) {
 où `cond` est un booléen
 
 Un `while` s'écrit :
-```c
+```c title=repeat.c
 while (cond) {
 	//
 }
@@ -181,7 +181,7 @@ while (cond) {
 où `cond` est toujours un booléen
 
 Une nouvelle boucle : la `do while` qui est une boucle `while` où la condition est testée à la fin de la boucle (i.e. elle tourne toujours au moins 1 fois)
-```c
+```c title=repeat.c
 do {
 	//
 } while (cond);
@@ -190,7 +190,7 @@ où `cond` est encore un booléen
 ⚠ il y a un `;` après le while
 
 La boucle `for` est comme celle en java
-```c
+```c title=repeat.c
 int n = 5;
 int i;
 for (i = 0; i <= n; i++) {
@@ -198,7 +198,7 @@ for (i = 0; i <= n; i++) {
 }
 ```
 est équivalente à
-```c
+```c title=repeat.c
 int i;
 i = 0;
 while (i <= n) {
diff --git a/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md b/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
index fa8979c..c92371c 100644
--- a/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
+++ b/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
@@ -50,14 +50,14 @@ On peut mettre une valeur et une adresse en mémoire
 |> une adresse est une zone de la mémoire contenant une valeur
 
 Une variable qui contient une adresse est un pointeur
-```c
+```c title=pointer.c
 int *n;
 ```
 
 ici, `n` contient l'adresse vers un entier
 
 On récupère l'adresse avec l'opérateur `&`
-```c
+```c title=pointer.c
 int x = 0;
 int *p;
 p = &x;
diff --git a/semestre 2/informatique/3- Tableaux & pointeurs.md b/semestre 2/informatique/3- Tableaux & pointeurs.md
index 1f70ab7..3b5de4e 100644
--- a/semestre 2/informatique/3- Tableaux & pointeurs.md
+++ b/semestre 2/informatique/3- Tableaux & pointeurs.md
@@ -16,11 +16,11 @@ Il y a deux types de tableaux en C :
 - tableaux dynamiques sont de tailles... dynamiques localisés dans le tas (heap)
 
 On déclare un tableau statique (array) comme ça :
-```c
+```c title=array.c
 type var[size];
 ```
 e.g.
-```c
+```c title=array.c
 int tab[12];
 ```
 déclare un tableau contenant 12 entiers
@@ -28,17 +28,17 @@ déclare un tableau contenant 12 entiers
 > [!warning] Les indices négatifs n'existent pas !
 
 On assigne une valeur avec 
-```c
+```c title=array.c
 var[indice] = val;
 ```
 e.g.
-```c
+```c title=array.c
 tab[0] = 1;
 ```
 assigne `1` dans `tab` à l'indice `0`
 
 On peut déclarer et initialiser un tableau avec les accolades, e.g.
-```c
+```c title=array.c
 float tab[5] = {0, 1.1, 10.9, 5, 5.6};
 ```
 
@@ -51,7 +51,7 @@ Ici c'est `pile (1)` car on écrit c'est la pile à l'étape 1 (écrit en commen
 
 Or, les arrays sont des pointeurs !
 On a donc que :
-```c
+```c title=array_pointer.c
 int main(){
 	int tab[3] = {0, 1, 2};
 	int *a = tab+2;
@@ -70,7 +70,7 @@ Quand on passe un tableau en paramètre, on obtient en réalité un pointeur
 > [!danger] Il n'y a pas d'erreur du style "Index Out Of Bound" en C, donc on doit faire attention à comment on manipule les tableaux
 ## Macro
 On peut définir des raccourcies appelé macro, avec `#define` :
-```c
+```c title=macro.c
 #define N 5
 int main(){
 	printf("%d\n", N);
@@ -94,7 +94,7 @@ Elle permet de récupérer l'entrée donnée par l'utilisateur au clavier
 |> le pointeur est la variable devant recevoir la variable
 |> (elle ajoute automatiquement le `"\n"` après la saisi de l'utilisateur)
 
-```c
+```c title=scan_input.c
 int main(){
 	char c;
 	int i;
@@ -111,7 +111,7 @@ int main(){
 ```
 ## Arithmétique des pointeurs
 Soit `ns` un array d'int de taille 42. Soit `a` un pointeur référencé sur `ns`. En C, on a donc :
-```c
+```c title=pointer.c
 int ns[42];
 int *a = ns;
 ```
diff --git a/semestre 2/informatique/4- Mémoire & algorithmique.md b/semestre 2/informatique/4- Mémoire & algorithmique.md
index 8528d8b..3f61727 100644
--- a/semestre 2/informatique/4- Mémoire & algorithmique.md
+++ b/semestre 2/informatique/4- Mémoire & algorithmique.md
@@ -21,27 +21,27 @@ Pour retourné un pointeur (et donc aussi un array), on utilise le tas (heap en
 
 **Comment mettre un tableau dans le heap ?**
 On récupère la taille du tableau :
-```c
+```c title=alloc_array.c
 sizeof(float)*len;
 ```
 où `len` est la taille du tableau
 
 Après, on récupère l'adresse dans le heap pour le mettre :
-```c
+```c title=alloc_array.c
 float* ptr = (float*) malloc(size);
 ```
 où `malloc` est dans `stdlib.h` et `size` est la taille de la variable.
 `ptr` est un pointeur vers cette nouvelle valeur.
 
 Après l'allocation, on doit vérifié que le pointeur n'est pas null :
-```c
+```c title=alloc_array.c
 ptr == NULL
 ```
 si sa valeur est null, alors la mémoire n'a pas été allouée.
 
 Par contre, attention, la mémoire allouée par `malloc` n'est jamais supprimée avant la fin du programme !
 -> on utilise `free` pour libérer la mémoire !
-```c
+```c title=alloc_array.c
 free(ptr);
 ```
 où `ptr` est un pointeur dans le heap *qui n'a pas déjà été libéré*, `free` est dans `stdlib.h`
@@ -49,14 +49,14 @@ où `ptr` est un pointeur dans le heap *qui n'a pas déjà été libéré*, `fre
 > [!tip] On doit avoir autant de `malloc` que de `free`
 
 On peut aussi initialiser toutes les valeurs à 0 avec `calloc`:
-```c
+```c title=alloc_init_array.c
 float* ptr = (float*)calloc(n, sizeof(float));
 ```
 où `n` est un entier non null et `calloc` la fonction de `stdlib.h`.
 (On vérifie toujours que `ptr != NULL`.)
 
 On peut modifier la taille allouée avec `realloc`:
-```c
+```c title=realloc_array.c
 float* ptr = (float*)realloc(ptr, 10*sizeof(float));
 ```
 où `ptr` est un pointeur et `realloc` la fonction dans `stdlib.h`
@@ -69,7 +69,7 @@ Quels sont les arguments de cette fonction ? -> `xs`, `x` et la taille de `xs`
 Quels sont les sorties ? -> `i` (un int >= -1, où -1 signifie pas trouver)
 Quelle méthode employer ? -> dichotomie car le tableau est trié
 Comment tester la fonction ? -> avec des valeurs particulières ou en démontrant formellement la fonction
-```c
+```c title=algo.c
 int found(int* arr, int n, int x){
 	int i = n >> 1;
 	while (arr[i] != x){
diff --git a/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md b/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md
index 4d259b5..9c26c55 100644
--- a/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md
+++ b/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md
@@ -6,7 +6,7 @@ semestre: 2
 ---
 ## Tableaux à plusieurs dimensions
 Pour déclarer un tableau à deux dimensions, on fait :
-```c
+```c title=double_dimension_array.c
 T tab[n1][n2];
 ```
 où `n1` et `n2` sont deux entiers naturels non nul et `T` est un type valide.
diff --git a/semestre 2/informatique/6- Récursion.md b/semestre 2/informatique/6- Récursion.md
index 7ce5af6..a4a3f40 100644
--- a/semestre 2/informatique/6- Récursion.md
+++ b/semestre 2/informatique/6- Récursion.md
@@ -5,7 +5,7 @@ tags:
 semestre: 2
 ---
 Une fonction récursive est une fonction qui s'appelle elle-même, e.g.
-```c
+```c title=recursive.c
 int somme(int n){
 	if (n == 0) return 0;
 	return somme(n-1) + n;
@@ -27,7 +27,7 @@ La pile ressemble à la même chose que le tableau
 Si l'appel est trop vénère, alors il remplit la mémoire et provoque une erreur
 
 Autre exemple :
-```c
+```c title=recursive.c
 int factoriel(int n){
 	if (n <= 1) return 1;
 	return factoriel(n-1) * n;
@@ -37,7 +37,7 @@ int factoriel(int n){
 La suite de Fibonacci,
 $$ F_n=\left\{\begin{matrix}1&\text{si $n=0$ ou $n=1$}\\F_{n-1}+F_{n-2}&\text{sinon}\end{matrix}\right. $$
 sert à faire une dichotomie plus rapide en pratique (mais pas en théorie)
-```c
+```c title=recursive.c
 int fibonacci(int n){
 	if (n <= 1) return 1
 	return fibonacci(n-1)+fibonacci(n-2)
diff --git a/semestre 2/informatique/7- Structure (ou enregistrement).md b/semestre 2/informatique/7- Structure (ou enregistrement).md
index d06d805..9741146 100644
--- a/semestre 2/informatique/7- Structure (ou enregistrement).md
+++ b/semestre 2/informatique/7- Structure (ou enregistrement).md
@@ -5,11 +5,11 @@ tags:
 semestre: 2
 ---
 Pour organiser les données, on utilise `struct`
-```c
+```c title=structure.c
 struct s_int_pair {
 	int fst;
 	int snd;
-}; // vraiment utile le ; ?
+}; // le ; est *obligatoire*
 ```
 Est toujours au début du fichier `.c` ou dans le `.h` si elle est utilisée par plusieurs fichiers
 |> possède deux champs nommés `fst` et `snd`
@@ -19,11 +19,11 @@ Les fichiers headers (`.h`) spécifient les interfaces utilisables par l'extéri
 |> ne contient pas tout ce qui est privé
 
 Pour qu'une variable utilise un struct, on écrit
-```c
+```c title=structure.c
 struct s_int_pair point;
 ```
 sauf que c'est long à écrire, donc on renomme tout ça avec un `typedef` :
-```c
+```c title=structure.c
 typedef struct s_int_pair int_pair;
 int main(){
 	int_pair point; 
@@ -31,7 +31,7 @@ int main(){
 }
 ```
 on peut aussi tout définir d'un coup
-```c
+```c title=structure_better.c
 typedef struct s_int_pair{
 	int fst;
 	int snd;
@@ -44,14 +44,14 @@ typedef struct s_int_pair{
 > |> est une convention
 
 Pour initialiser un struct, on utilise les parenthèses
-```c
+```c title=structure_init.c
 int_pair p = {1,2}; // initialisation séquentielle
 int_pair p2 = {.snd=3, .fst=4}; // initialisation sélective
 ```
 la première est traditionnelle et est commune
 
 Pour modifier les valeurs dans un struct, on accède aux champs avec l'opérateur `.` :
-```c
+```c title=structure_init.c
 p.fst = -1;
 p.snd = -2;
 
@@ -69,16 +69,16 @@ Structures et fonctions
 Il n'existe pas d'arithmétique des structures
 
 On peut chaîner les structures, i.e.
-```c
+```c title=chained_structure.c
 struct _cell {
 	int v;
-	struct cell* next;
+	struct _cell* next;
 }
 ```
 (ce qui donne une liste chaînée)
 
 L'opérateur `->` est un raccourcie permettant le déférencement rapide
-```c
+```c title=arrow_operator.c
 Foo *foo;
 
 foo->bar = 10;
@@ -89,3 +89,5 @@ foo->baz();
 // est équivalent à
 (*foo).baz();
 ```
+
+On a fini toutes les questions de syntaxe en C
\ No newline at end of file
diff --git a/semestre 2/informatique/8- Listes.md b/semestre 2/informatique/8- Listes.md
new file mode 100644
index 0000000..4dabbab
--- /dev/null
+++ b/semestre 2/informatique/8- Listes.md
@@ -0,0 +1,88 @@
+---
+tags:
+  - sorbonne
+  - informatique
+semestre: 2
+---
+Pour ajouter une élément dans un tableau, on a besoin de :
+- rajouter une case
+- déterminer l'emplacement de l'élément à insérer
+- décaler d'une position tous les éléments situés après l'insertion
+
+Struct d'une cellule d'une liste :
+```c title=chained_list.c
+typedef struct _cellule {
+	int data;
+	_cellule* before;
+} Cellule;
+```
+
+Une liste vide est :
+```c title=chained_list.c
+Cellule* liste = NULL;
+```
+
+Pour créer une ajouter une cellule à une liste, on fait :
+```c title=chained_list.c
+Cellule* add_to_list(Cellule* cell, int val){
+	Cellule* el = malloc(sizeof(Cellule)); // on alloue la prochaine valeur
+	el->data = val;
+	el->before = cell;
+	return el;
+}
+```
+
+Pour afficher une liste :
+```c title=chained_list.c
+void print_list(Cellule* cell){
+	if (cell->before == NULL) printf("%d", cell->data);
+	else {
+		printf("%d ", cell->data);
+		list_to_string(cell->before);
+	}
+}
+```
+
+Pour sommer la liste :
+```c title=chained_list.c
+int sum_list(Cellule* cell){
+	return cell->before == NULL ?
+		cell->data :
+		cell->data + sum_list(cell->before);
+}
+```
+
+Pour libérer une liste :
+```c title=chained_list.c
+// on préfère souvent utiliser un while pour éviter de consommer bcp de ram
+void free_list(Cellule *cell){
+	if (!cell) return; // on vérifie que cell n'est pas null (i.e. elle a déjà été initialisée)
+	if (cell->before != NULL) free_list(cell->before);
+	cell->before = NULL;
+	free(cell);
+}
+```
+
+> [!NOTE] Les cas de tests des listes
+> On teste élément en premier, en dernier, au milieu et si la liste est vide
+
+Pour supprimer un élément :
+```c title=chained_list.c
+// on pourrait aussi faire une version avec simple pointeur où on renverrait le first
+void delete_el_list(Cellule **p_cell, int v){
+	if (!*p_cell) return;
+	Cellule *prec = NULL;
+	Cellule *next = *p_cell;
+	Cellule *first = *p_cell;
+	while (next && liste->data != v) {
+		prec = next;
+		next = next->before;
+	}
+	if (next == NULL) return;
+	if (prec != NULL) prec->before = next->before;
+	else first = first->suivant;
+	free(next);
+	*p_cell = first; // est-ce vraiment utile ?
+}
+```
+-> voir les diapos pour un truc plus clean
\ No newline at end of file
diff --git a/semestre 2/informatique/9- Utilisation des listes.md b/semestre 2/informatique/9- Utilisation des listes.md
new file mode 100644
index 0000000..8e8e093
--- /dev/null
+++ b/semestre 2/informatique/9- Utilisation des listes.md
@@ -0,0 +1,144 @@
+---
+tags:
+  - sorbonne
+  - informatique
+semestre: 2
+---
+On va implémenter un table de hashage et des files
+## Files
+On utilise par défaut des piles « Last In First Out » (LIFO) dans les listes
+|> on ajoute en tête, on retire la tête
+
+Mais comment faire une file ?
+|> est un « First In First out »
+
+On a les structs suivantes :
+```c title=queue_list.c
+typedef struct _cell{
+	int donnee;
+	struct _cell *suivant;
+} cell;
+
+typedef struct _fifo{
+	cell *first;
+	cell *last;
+} fifo;
+```
+
+On utilise maintenant le type `*fifo` pour représenter une liste
+```c title=queue_list.c
+fifo *list = NULL; // est une nouvelle liste de type FIFO
+```
+
+Bibliothèque minimale pour les listes FIFO contient :
+- `new_fifo` -> crée une nouvelle liste FIFO
+- `is_empty` -> vérifie si la liste est vide
+- `add` -> ajoute un élément à la fin
+- `pop` -> retire le premier élément
+- `print_fifo` -> affiche la liste
+
+```c title=queue_list.c
+fifo *new_fifo(){
+	fifo *f = malloc(sizeof(fifo));
+	f->last = NULL;
+	f->first = NULL;
+	return f;
+}
+
+
+int is_empty(fifo f){
+	assert((f.last && f.first) || (!f.last && !f.first)); // permet de faire une vérification et de faire en sorte que le programme s'arrête proprement
+	return !f.first && !f.last
+}
+
+void add(fifo *f, int val){
+	if (*f == NULL) return;
+	cell *c = malloc(sizeof(cell));
+	c->suivant = NULL;
+	c->donnee = val;
+	if (is_empty(f)) f->first = c;
+	else f->last->suivant = c;
+	f->last = c;
+}
+
+int pop(fifo *f){
+	if (!f || is_empty(f)) return 0;
+	cell c = f->first;
+	int d = c->donnee;
+	f->first = c->suivant;
+	free(c);
+	if (!f->first) free(f);
+	return d;
+}
+
+void print_fifo(fifo *f){
+	if (!f) {
+		printf("\n");
+		return;
+	}
+	cell *first = fifo->first;
+	printf("{");
+	while (first){
+		printf("%d, ", f->donnee);
+		first = first->suivant;
+	}
+	printf("}\n");
+}
+```
+## Table de hashage
+Comme on ne peut pas représenter toutes les possibilités, on a besoin de trouver une structure de donnée et sa fonction pour les séparer
+|> est le principe des maps
+
+Soit $h$ une fonction de hashage de taille $t$
+|> les valeurs qu'elles donnent sont dans $[0, t-1]$
+
+Une fonction de hashage peut être la somme de la taille des caractères ASCII modulo la taille
+|> $h$ de `"LU1IN002"` vaut donc `76+85+49+73+78+48+48+50 = 507` et si sa taille vaut 500, alors $h$ vaut `7`
+|> cette fonction n'est pas très efficace car elle provoque beaucoup de collisions ($h$ de `"LU2IN001"` vaut aussi `7`)
+
+Pour gérer les collisions, on a deux grandes possibilités :
+- on prend la case d'après (hashage linéaire)
+- on utilise une liste pour représenter les collisions dans la case
+	|> cette liste devra contenir la clé et la valeur pour bien tout vérifier
+
+Exemple de fonction de hashage
+```c title=hash.c
+int h(char *key, int t){
+	int sum = 0;
+	while (*key != '\0') {
+		sum += *key;
+		key = key+1;
+	}
+	return sum % t;
+}
+```
+
+Pour construire le stockage, on fait :
+```c title=hash.c
+typedef struct _DataHash{
+	char *key;
+	int val;
+} DataHash;
+
+int main(){
+	DataHash t_hash[] = cell[TAILLE];
+	int ki = h("LUIN002", TAILLE);
+	t_hash[ki].key = "LUIN002";
+	t_hash[ki].val = 753;
+}
+```
+
+Fonctions usuelles :
+```c title=hash.c
+int add_hash(DataHash t_hash[], int size, char *key, int val){
+	int ki = h(key, size);
+	int i = ki+1;
+	while (t_hash[ki] != NULL && i != ki) i = (i+1)%size;
+	if (!t_hash[ki]) return 0;
+	t_hash[ki] = DataHash{key, val};
+	return 1;
+}
+```
+
+On peut aussi gérer les collisions à l'aide d'une liste
+|> on a des pointeurs vers des listes au lieu d'avoir directement la valeur dans `DataHash`
\ No newline at end of file
diff --git a/semestre 2/informatique/td/8- liste.md b/semestre 2/informatique/td/8- liste.md
new file mode 100644
index 0000000..cd568a9
--- /dev/null
+++ b/semestre 2/informatique/td/8- liste.md
@@ -0,0 +1,68 @@
+---
+tags:
+  - sorbonne
+  - informatique
+  - td
+semestre: 2
+---
+```c title=chained_list.c
+typedef struct cellule_t{
+	int donnee;
+	struct cellule_t *suivant;
+} Cellule;
+```
+
+Pour créer une nouvelle `Cellule`, on fait
+```c title=chained_list.c
+Cellule *create_cellule(int d){
+	Cellule *cell = malloc(sizeof(Cellule));
+	cell->donnee = d;
+	cell->suivant = NULL;
+	return cell;
+}
+```
+
+```c title=chained_list.c
+Cellule *last_element_list(Cellule *list){
+	if (!list) return NULL;
+	while (list->suivant) list = list->suivant;
+	return list;
+}
+```
+
+Pour modifier une cellule à la position `pos`
+```c title=chained_list.c
+void modify_element_list(Cellule *list, int pos, int val){
+	for (int i = 0; list && p <= pos; i++){
+		if (p == pos) list->donnee = val;
+		list = list->suivant;
+	}
+}
+```
+
+Pour vérifier si deux listes sont identiques
+```c title=chained_list.c
+int equal_list(Cellule *l1, Cellule *l2){
+	if ((!l1 && l2) || (l1 && !l2)) return 0;
+	while (l1 && l2){
+		if (l1->donnee != l2->donnee) return 0;
+		l1 = l1->suivant;
+		l2 = l2->suivant;
+	}
+	return !l1 && !l2;
+}
+```
+
+Pour vérifier si une liste est incluse dans l'autre
+```c title=chained_list.c
+// if l2 is included in l1
+int include_list(Cellule *l1, Cellule *l2){
+	if (!l1 && l2) return 0;
+	while (l1 && l2){
+		if (l1->donnee == l2->donnee) l2 = l2->suivant;
+		else if (l1->donnee > l2->donnee) return 0;
+		l1 = l1->suivant;
+	}
+	return !l2;
+}
+```
\ No newline at end of file
diff --git a/semestre 2/informatique/tme/semaine5/28_participation_frais.c b/semestre 2/informatique/tme/semaine5/28_participation_frais.c
index e5aff0d..96da9b7 100644
--- a/semestre 2/informatique/tme/semaine5/28_participation_frais.c
+++ b/semestre 2/informatique/tme/semaine5/28_participation_frais.c
@@ -13,9 +13,10 @@ void init_tab(float tab[NB_AMIS][NB_JOURS]){
 void random_tab(float tab[NB_AMIS][NB_JOURS], int j) {
 	int a = rand()%NB_AMIS;
 	int v = rand()%21+30;
-	tab[a][j] = v;
+	float to_pay = (float) v/(-NB_AMIS);
+	tab[a][j] = v + to_pay;
 	for (int i = 0; i < NB_AMIS; i++) {
-		if (i != a) tab[i][j] = (float) v/(-NB_AMIS+1);
+		if (i != a) tab[i][j] = to_pay;
 	}
 }
 
diff --git a/semestre 2/informatique/tme/semaine5/30_compression.c b/semestre 2/informatique/tme/semaine5/30_compression.c
index 161cd00..154dbc9 100644
--- a/semestre 2/informatique/tme/semaine5/30_compression.c
+++ b/semestre 2/informatique/tme/semaine5/30_compression.c
@@ -14,15 +14,19 @@ int init_tab(int tab[MAX+1]) {
 }
 
 void compress_tab(int tab_brut[], int tab_compress[]){
-	int j = 0;
 	int last = -1;
 	int cnt = 0;
+	int w = 0;
 	for (int i = 0; tab_brut[i] != -1; i++) {
 		if (last == -1 || tab_brut[i] != last) {
 			if (last != -1) {
-				int id = j++;
-				tab_compress[id*2] = cnt;
-				tab_compress[id*2+1] = last;
+				if (cnt == 1) {
+					tab_compress[w] = last;
+				} else {
+					tab_compress[w] = cnt;
+					tab_compress[++w] = last;
+				}
+				w++;
 			}
 			last = tab_brut[i];
 			cnt = 0;
@@ -30,11 +34,35 @@ void compress_tab(int tab_brut[], int tab_compress[]){
 		cnt++;
 	}
 	if (last != -1) {
-		int id = j++;
-		tab_compress[id*2] = cnt;
-		tab_compress[id*2+1] = last;
+		if (cnt == 1) {
+			tab_compress[w] = last;
+		} else {
+			tab_compress[w] = cnt;
+			tab_compress[++w] = last;
+		}
+		w++;
+	}
+	tab_compress[w] = -1;
+}
+
+void decompress(int tab_brut[], int tab_compress[]) {
+	int i = 0;
+	int w = 0;
+	while (tab_compress[i] != -1) {
+		int v = tab_compress[i];
+		if (v < 2) {
+			tab_brut[w++] = v;
+		} else {
+			int ins_v = tab_compress[++i];
+			for (int j = 0; j < v; j++) {
+				tab_brut[w++] = ins_v;
+			}
+		}
+		for (int j = 0; j < w; j++) printf("%d, ", tab_brut[j]);
+		printf("\n");
+		i++;
 	}
-	tab_compress[j*2] = -1;
+	tab_brut[w] = -1;
 }
 
 int compare(int tab_brut[], int tab_compress[]){
@@ -51,7 +79,31 @@ int compare(int tab_brut[], int tab_compress[]){
 
 int main(){
 	srand(time(NULL));
-	int tab[MAX+1] = {};
+	int tab1[]={0,0,1,1,1,1,0,1,1,1,0,0,1,0,0,0,0,-1};
+	//int tab1[] = {0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,-1};
+	for (int i = 0; tab1[i] != -1; i++) printf("%d, ", tab1[i]);
+	printf("\n");
+	int tab2[20];
+	compress_tab(tab1,tab2);
+	int tab3[20];
+	decompress(tab3, tab2);
+	int i;
+	for (i = 0; tab1[i] != -1 && tab3[i] != -1; i++) {
+		printf("%d - %d\n", tab1[i], tab3[i]);
+	}
+	printf("%d\n", i);
+	i = 0;
+	while (tab2[i] != -1) {
+		int v = tab2[i];
+		if (v < 2) {
+			printf("%d ", v);
+		} else {
+			printf("%d:%d ", v, tab2[++i]);
+		}
+		i++;
+	}
+	printf("\n");
+	/*int tab[MAX+1] = {};
 	int tab_compress[MAX+1] = {};
 	init_tab(tab);
 	compress_tab(tab, tab_compress);
@@ -59,6 +111,6 @@ int main(){
 	printf("\n");
 	for (int i = 0; tab_compress[i] != -1; i += 2) printf("%d:%d, ", tab_compress[i], tab_compress[i+1]);
 	printf("\n");
-	printf("%s", compare(tab, tab_compress) ? "True" : "False");
+	printf("%s", compare(tab, tab_compress) ? "True" : "False");*/
 	return 0;
 }
diff --git a/semestre 2/informatique/tme/semaine5/31_image_mystere.c b/semestre 2/informatique/tme/semaine5/31_image_mystere.c
index 51ca321..29264e1 100644
--- a/semestre 2/informatique/tme/semaine5/31_image_mystere.c
+++ b/semestre 2/informatique/tme/semaine5/31_image_mystere.c
@@ -12,9 +12,15 @@ void calcule_borne_sup(int *tab, int taille){
 
 int tire_non_equi(int *tab, int taille){
 	int tire = rand()%100;
-	int i;
-	for (i = taille -1; tab[i] > tire; i--);
-	printf("%d - %d <= %d\n", i, tab[i], tire);
+	int i = taille -1;
+	/*while (i >= 0) {
+		if (tire > tab[i]) break;
+		i--;
+	}
+	i++;*/
+	for (i = taille -1; tab[i] >= tire; i--);
+	i++;
+	printf("%d >= %d\n", tab[i], tire);
 	return i;
 }
 
diff --git a/semestre 2/informatique/tme/semaine6/iter.c b/semestre 2/informatique/tme/semaine6/iter.c
new file mode 100644
index 0000000..fd55e23
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/iter.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+int recherche_iter(int* arr, int n, int v) {
+    int i;
+    for (i = 0; arr[i] != v && i < n; i++);
+    if (i == n) return -1;
+    return i;
+}
+
+int main() {
+	int arr[] = {1, 2, 3};
+	printf("%d\n", recherche_iter(arr, 3, 4));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine6/rec.c b/semestre 2/informatique/tme/semaine6/rec.c
new file mode 100644
index 0000000..0a5bb34
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/rec.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+int recherche_rec(int* arr, int n, int v){
+	if (n == 0) return -1;
+	if (arr[n-1] == v) return n-1;
+	return recherche_rec(arr, n-1, v);
+}
+
+int main() {
+	int arr[] = {1, 2, 3, 5, 5};
+	printf("%d\n",recherche_rec(arr, 5, 6));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine6/rec_2.c b/semestre 2/informatique/tme/semaine6/rec_2.c
new file mode 100644
index 0000000..9bfd376
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/rec_2.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+int recherche_rec_aux (int* tab, int n,int i, int v) {
+    if (i == n) return -1;
+    if (tab[i] == v) return i;
+    return recherche_rec_aux(tab, n, i+1, v);
+}
+
+int recherche_rec (int tab[], int taille, int elem) {
+    return recherche_rec_aux (tab, taille, 0, elem);
+}
+
+int main() {
+	int arr[] = {1, 2, 3};
+	printf("%d\n", recherche_rec(arr, 3, 0));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine6/rec_str.c b/semestre 2/informatique/tme/semaine6/rec_str.c
new file mode 100644
index 0000000..a920af3
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/rec_str.c
@@ -0,0 +1,19 @@
+#include <stdio.h>
+int est_deb(char* s1, char* s2) {
+	if (*s1 == '\0' || *s2 =='\0') return 1;
+	if (*s1 != *s2) return 0;
+	return est_deb(s1+1, s2+1);
+}
+
+int est_incluse(char *sub, char* s) {
+	if (*s == '\0') return 0;
+	return est_deb(sub, s) ? 1 : est_incluse(sub, s+1);
+}
+
+int main() {
+	printf("%d\n", est_deb("alpha", "alphabet"));
+	printf("%d\n", est_deb("alpaga", "alphabet"));
+	printf("%d\n", est_incluse("alp", "alphabet"));
+	printf("%d\n", est_incluse("apl", "alphabet"));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine7/35_systeme_solaire.c b/semestre 2/informatique/tme/semaine7/35_systeme_solaire.c
new file mode 100644
index 0000000..aa9c42b
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine7/35_systeme_solaire.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#define NB_PLANETES 8
+
+typedef struct{
+	char name[10];
+	float density;
+	float distance;
+	int satellites;
+} planete;
+
+void affichePlanete(planete *p){
+	printf(
+		"%s:\n- densité : %.02f\n- distance : %.2f\n- nombre de satellites : %d\n\n", 
+		p->name,
+		p->density,
+		p->distance,
+		p->satellites
+	);
+}
+
+void afficheToutesPlanetes(planete ps[]) {
+	for (int i = 0; i < NB_PLANETES; i++) affichePlanete((ps+i));
+}
+
+void modifieDensite(planete *p, float v){
+	p->density = v;
+}
+
+int main(){
+    planete systemeSolaire[NB_PLANETES] ={{"Mercure", 5.42, 58, 0},{"Venus", 5.25, 108.2, 0},{"Terre", 5.52,149.6,1},{"Mars",3.94,227.9,2},{"Jupiter",1.314,778.3,16},{"Saturne",0.69,1427,17},{"Uranus",1.19,2869,15},{"Neptune",1.6,4496,2}};           
+	afficheToutesPlanetes(systemeSolaire);
+    return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine7/hello.c b/semestre 2/informatique/tme/semaine7/hello.c
new file mode 100644
index 0000000..4e2d9dc
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine7/hello.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#define NB_PLANETES 8
+
+/* ici la definition du type planete */
+typedef struct{
+	char nom[10];
+	float densite;
+	float distance;
+	int nbsat;
+} planete;
+
+void affichePlanete(planete p){
+   printf("%s : densite = %.2f, distance soleil = %.1f, nb satellites = %d", 
+   p.nom, p.densite, p.distance, p.nbsat);
+}
+
+void afficheToutesPlanetes(planete ps[], int n){
+    for (int i = 0; i < n; i++) affichePlanete(*(ps+i));
+}
+
+void modifieDensite (planete *p, float v) {
+    p->densite = v;
+}
+
+int main(){
+   planete systemeSolaire[NB_PLANETES] ={{"Mercure", 5.42, 58, 0}, {"Venus", 5.25, 108.2, 0}, 
+         {"Terre", 5.52, 149.6,1}, {"Mars", 3.94, 227.9, 2}, {"Jupiter", 1.314, 778.3, 16},
+         {"Saturne", 0.69, 1427, 17}, {"Uranus", 1.19, 2869, 15}, {"Neptune", 1.6, 4496, 2}};
+   int i;
+   float d;
+   
+   afficheToutesPlanetes(systemeSolaire, NB_PLANETES);
+   printf("\n");
+   scanf("%d", &i);
+   scanf("%f", &d);
+   /* on affecte la densite d a la planete d'indice i du tableau systemeSolaire */
+   modifieDensite(systemeSolaire+i, d);
+   affichePlanete(systemeSolaire[i]);
+   printf("\n");
+   return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine8/build_run.sh b/semestre 2/informatique/tme/semaine8/build_run.sh
new file mode 100644
index 0000000..4a32768
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/build_run.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+gcc -Wall -o app liste_entiers.c liste_entiers.h test_liste.c
+./app
+rm app
diff --git a/semestre 2/informatique/tme/semaine8/liste_entiers.c b/semestre 2/informatique/tme/semaine8/liste_entiers.c
new file mode 100644
index 0000000..c53040c
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/liste_entiers.c
@@ -0,0 +1,102 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "liste_entiers.h"
+
+cellule_t * creerListe(int n) {
+/* cree une liste de n entiers saisi par l'utilisateur
+  renvoie l'adresse du premier element de la liste */
+  int i;
+  int val;
+  cellule_t *tete=NULL;
+  cellule_t *ptr;
+  
+  printf("Saisie des %d elements de la liste\n",n);
+  for (i=0; i < n; i++) {
+    printf("Element %d :",i+1);
+    scanf("%d",&val);
+    ptr=malloc(sizeof(cellule_t));
+    ptr->donnee = val;
+    ptr->suivant = tete;
+    tete = ptr;
+  }
+  return tete;
+}
+
+cellule_t *list(int n, cellule_t *q){
+	cellule_t *h = malloc(sizeof(cellule_t));
+	h->suivant = q;
+	h->donnee = n;
+	return h;
+}
+
+void AfficherListeInt(cellule_t *liste){
+	while (liste){
+		printf("%d ", liste->donnee);
+		liste = liste->suivant;	
+	}
+}
+
+int nb_occurences(int val, cellule_t *liste){
+	int c = 0;
+	while (liste){
+		if (liste->donnee == val) c++;
+		liste = liste->suivant;
+	}
+	return c;
+}
+
+int tous_plus_grand(int val, cellule_t *liste){
+	while (liste){
+		if (liste->donnee < val) return 0;
+		liste = liste->suivant;
+	}
+	return 1;
+}
+
+cellule_t *Maximum(cellule_t *liste){
+	cellule_t *max= NULL;
+	while (liste){
+		if (!max || (liste->donnee > max->donnee)) max = liste;
+		liste = liste->suivant;
+	}
+	return max;
+}
+
+int Renvoyer_val_element_pos(int pos, cellule_t* liste){
+	int size;
+	cellule_t *tmp = liste;
+	for (size = 0; tmp; size++) tmp = tmp->suivant;
+	for (int i = 0; i < pos; i++) liste = liste->suivant;
+	// pos = 0 ~ 2
+	// pos = 1 ~ 1
+	// pos = 2 ~ 0
+	// size-pos = 3-0 -> 3
+	// size-pos = 3-1 -> 2
+	// size-pos = 3-2 -> 1
+	if (!liste) {
+		printf("error\n");
+		return -1;
+	}
+	return liste->donnee;
+}
+
+cellule_t *Concatener_it(cellule_t *liste1, cellule_t *liste2){
+	if (!liste1) return liste2;
+	cellule_t *head = liste1;
+	while (liste1->suivant) liste1 = liste1->suivant;
+	liste1->suivant = liste2;
+	return head;
+}
+
+int nb_maximum(cellule_t *liste){
+	cellule_t *max= NULL;
+	int c = 1;
+	while (liste){
+		if (!max || (liste->donnee > max->donnee)) {
+			max = liste;
+			c = 1;
+		} else if (liste->donnee == max->donnee) c++;
+		liste = liste->suivant;
+	}
+	return c;
+}
diff --git a/semestre 2/informatique/tme/semaine8/liste_entiers.h b/semestre 2/informatique/tme/semaine8/liste_entiers.h
new file mode 100644
index 0000000..78ccefb
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/liste_entiers.h
@@ -0,0 +1,24 @@
+typedef struct _cellule_t cellule_t;
+
+struct _cellule_t {
+  int donnee;
+  cellule_t *suivant;
+};
+
+cellule_t * creerListe(int n);
+
+void AfficherListeInt(cellule_t *liste);
+
+int nb_occurences(int val, cellule_t *liste);
+
+int tous_plus_grand(int val, cellule_t *liste);
+
+cellule_t *Maximum(cellule_t *liste);
+
+int Renvoyer_val_element_pos(int pos, cellule_t* liste);
+
+cellule_t *Concatener_it(cellule_t *liste1, cellule_t *liste2);
+
+int nb_maximum(cellule_t *liste);
+
+cellule_t *list(int n, cellule_t *q);
diff --git a/semestre 2/informatique/tme/semaine8/test_liste.c b/semestre 2/informatique/tme/semaine8/test_liste.c
new file mode 100644
index 0000000..acd23ae
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/test_liste.c
@@ -0,0 +1,17 @@
+#include "liste_entiers.h"
+#include <stdio.h>
+
+int main() {
+  cellule_t *ma_liste=list(1, list(3, list(0, NULL)));
+  int size = 0;
+  cellule_t *t = ma_liste;
+  for (size = 0; t; size++) {
+	  printf("val %d\n", t->donnee);
+	  t = t->suivant;
+  }
+  printf("size %d\n", size);
+  printf("before\n");
+  for (int i = 0; i < size; i++) printf("pos %d = %d\n", i, Renvoyer_val_element_pos(i, ma_liste));
+  printf("after\n");
+  return 0;
+}