Ajout du début du deuxième semestre

27 files changed, 879 insertions, 0 deletions

diff --git a/semestre 2/informatique/.gitignore b/semestre 2/informatique/.gitignore
new file mode 100644
index 0000000..7a8f1ae
--- /dev/null
+++ b/semestre 2/informatique/.gitignore
@@ -0,0 +1,2 @@
+0-\ Introduction.md
+*.pdf
diff --git a/semestre 2/informatique/1- De Python à C.md b/semestre 2/informatique/1- De Python à C.md
new file mode 100644
index 0000000..c088a7b
--- /dev/null
+++ b/semestre 2/informatique/1- De Python à C.md
@@ -0,0 +1,208 @@
+---
+tags:
+  - sorbonne
+  - informatique
+semestre: 2
+---
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+/* premier programme */
+
+int main(){
+	printf("Hello World\n");
+	return 0;
+}
+```
+
+On écrit des programmes comme éditeur de texte
+|> Visual Studio Code
+|> gedit
+|> vi/vim
+|> emacs
+-> permet d'écrire le programme
+
+Au début, on écrit les bibliothèques :
+```c
+#include <stdio.h>
+#include <stdlib.h>
+```
+
+Les commentaires s'écrivent comme ça :
+```c
+/* bonjour, 
+je suis un commentaire sur
+plusieurs lignes */
+
+// bonjour, je suis sur une seule ligne
+```
+
+(le deuxième type de commentaire provient du C++, mais souvent ça passe)
+
+Après, on doit toujours écrire une fonction `main` :
+```c
+int main(){
+	/* ... */
+	return 0;
+}
+```
+
+Après avoir écrit notre programme, on doit faire en sorte qu'il soit exécutable
+|> est la compilation
+|> on utilise `gcc` (GNU C Compiler) pour compiler le texte
+
+Pour compiler, on fait :
+```bash
+$ gcc -Wall -o hello_world hello_world.c
+$ ./hello_world
+Hello World
+$
+```
+
+Le `-Wall` veut dire "Warning all", i.e. affiche tous les warnings
+## Fonctions
+Quand on définit une fonction, on a besoin de spécifier :
+- le type de retour (`void` si rien n'est retourné)
+- le nom de la fonction
+- les arguments avec leur type
+- le corps de la fonction (entre accolades)
+
+Les blocks en C sont définis par des accolages (`{ ... }`)
+
+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
+void hello(){
+	printf("Hello World\n");
+}
+
+int main(){
+	hello();
+	return 0;
+}
+```
+
+> [!warning] Définition d'une fonction
+> On a besoin de définir une fonction avant de l'utiliser !
+## Types que l'on utilise
+
+| Type  | Signification    | Taille (o) | Plage de valeurs                | Exemple |
+| ----- | ---------------- | ---------- | ------------------------------- | ------- |
+| char  | Caractère        | 1          | -128 à 127                      | 'a'     |
+| int   | Entier           | 4          | -2 147 483 648 à  2 147 483 647 | 25      |
+| float | Simple précision | 4          | $\pm$ ...                       | 3.14    |
+> [!warning] `'a'` et `"a"`
+> Ce sont des types différents !
+> `'a'` est un caractère tandis que `"a"` est une chaîne de caractère !
+
+> [!warning] Booléen en C
+> Il n'existe pas de booléen en C : on utilise donc les `int` pour décrire l'état.
+> `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
+void hello(int annee){
+	printf("Hello World %d!\n", annee)
+}
+
+int main(){
+	hello(2025);
+	return 0;
+}
+```
+
+La fonction `printf` ici est utilisée pour formaté un string que l'on va ensuite afficher
+|> `"%d"` insert un `int`
+|> `"%f"` insert un `float`
+|> `"%c"` insert un `char`
+|> les valeurs que l'on insert sans mise après le format
+i.e.
+```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
+int p;
+p = 5;
+
+float a=1, b=2.5, c=-2.5;
+```
+
+> [!warning] Porté des variables
+> Les variables sont locales au bloc ! On ne peut pas y accéder autre part !
+> (comme en python)
+
+![[used_operators_c.png]]
+
+> [!warning] Division en C
+> Si on a une division d'un entier par un entier, on obtient un... entier !
+> Pour avoir un `float`, on doit faire quelque chose comme `int / (float) int`
+
+## De Python à C
+### Syntaxe simple
+```python
+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
+/* 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){
+	return 2*(largeur + longueur);
+}
+```
+### Structures de contrôle
+Un `if/else` s'écrit :
+```c
+if (cond) {
+	//
+} else {
+	//
+}
+```
+où `cond` est un booléen
+
+Un `while` s'écrit :
+```c
+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
+do {
+	//
+} while (cond);
+```
+où `cond` est encore un booléen
+⚠ il y a un `;` après le while
+
+La boucle `for` est comme celle en java
+```c
+int n = 5;
+int i;
+for (i = 0; i <= n; i++) {
+	printf("%d", i);
+}
+```
+est équivalente à
+```c
+int i;
+i = 0;
+while (i <= n) {
+	printf("%d", i);
+	i++;
+}
+```
diff --git a/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md b/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
new file mode 100644
index 0000000..fa8979c
--- /dev/null
+++ b/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
@@ -0,0 +1,68 @@
+---
+tags:
+  - sorbonne
+  - informatique
+semestre: 2
+---
+## Architecture de von Neumann
+Ordinateur est composé d'un processeur, d'une mémoire et de périphériques
+![[computer_architecture_simplified.png]]
+![[computer_architecture_detailled.png]]
+
+Registres = mémoire interne au CPU
+
+Unité de base = octet (8 bits)
+
+**Organisation de la mémoire :**
+![[ram_organisation_schema.png]]
+
+Les tensions électriques pour la valeur binaire 1 = 5 V ou 3.3 V ou 1.65 V
+|> compliqué de descendre plus bas que 1 V à cause de la tension de seuil du silicium
+Les tensions électriques pour la valeur binaire 0 = 0 V
+
+On peut ensuite calculer des choses :
+|> $1010 \land 0011 = 0010$ (bool)
+|> $1010 + 0010 = 1100$ (binaire)
+
+Souvent, on représente la mémoire avec un tableau de 4 colonnes avançant de 4 en 4
+
+Pour représenter les floatants, on les décompose en 3 parties :
+- signe
+- mantisse
+- exposant
+
+Après on peut les approximer à l'aide des sommes d'inverses de 2 ($\frac{1}{2}+\frac{1}{4}+\cdots$)
+Exemple sur $-50.5$ :
+- $2^5+2^4+2^1+2^{-1}$
+- $(2^0+2^{-1}+2^{-4}+2^{-6})\times 2^{5}$
+- la somme est la mantisse et la multiplication est l'exposant
+
+Chaque octet a une adresse unique !
+## Portée des variables
+Globale = disponible partout dans le fichier
+Paramètre = disponible dans toute la fonction
+Locale = disponible dans le bloc
+
+Le shadowing existe en C
+## Pointeurs
+On peut mettre une valeur et une adresse en mémoire
+|> valeur est une valeur classique
+|> une adresse est une zone de la mémoire contenant une valeur
+
+Une variable qui contient une adresse est un pointeur
+```c
+int *n;
+```
+
+ici, `n` contient l'adresse vers un entier
+
+On récupère l'adresse avec l'opérateur `&`
+```c
+int x = 0;
+int *p;
+p = &x;
+printf("%t %d", p, *p);
+```
+
+On peut afficher l'adresse avec `printf("%t", n)`
+On peut afficher le contenu du pointeur avec `*n`
\ No newline at end of file
diff --git a/semestre 2/informatique/3- Tableaux & pointeurs.md b/semestre 2/informatique/3- Tableaux & pointeurs.md
new file mode 100644
index 0000000..1f70ab7
--- /dev/null
+++ b/semestre 2/informatique/3- Tableaux & pointeurs.md
@@ -0,0 +1,129 @@
+---
+tags:
+  - sorbonne
+  - informatique
+semestre: 2
+---
+La taille du pointeurs dépend de l'architecture
+|> sur une machine 64 bits, il est sur 8 octets ($8\times 8 = 64$)
+|> donc, `int *` prend plus de place que `int` !
+## Tableaux
+Un tableau est une suite de valeurs en mémoire
+|> les valeurs  sont toutes du même type
+
+Il y a deux types de tableaux en C :
+- tableaux statiques sont de tailles fixes localisés dans la pile (stack) (`float[12]`)
+- tableaux dynamiques sont de tailles... dynamiques localisés dans le tas (heap)
+
+On déclare un tableau statique (array) comme ça :
+```c
+type var[size];
+```
+e.g.
+```c
+int tab[12];
+```
+déclare un tableau contenant 12 entiers
+
+> [!warning] Les indices négatifs n'existent pas !
+
+On assigne une valeur avec 
+```c
+var[indice] = val;
+```
+e.g.
+```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
+float tab[5] = {0, 1.1, 10.9, 5, 5.6};
+```
+
+> [!warning] On ne peut pas assigner plus tard un tableau avec des accolades !
+
+Représentation d'un tableau dans la pile
+![[array_stack_c.png]]
+ici, `i` est un indice dans une boucle (`for` ici)
+Ici c'est `pile (1)` car on écrit c'est la pile à l'étape 1 (écrit en commentaire sur le code donné sur moodle)
+
+Or, les arrays sont des pointeurs !
+On a donc que :
+```c
+int main(){
+	int tab[3] = {0, 1, 2};
+	int *a = tab+2;
+	printf("%d", *a);
+	return 0;
+}
+```
+affiche `2` !
+Ici, `tab+2` est équivalent à prendre l'adresse de la 3e valeur du tableau
+Quand on passe un tableau en paramètre, on obtient en réalité un pointeur
+|> tout ce qu'on réalisera avec ce paramètre affectera donc le tableau d'origine !
+
+> [!important] Longueur d'un array
+> Il n'existe aucun moyen d'avoir la longueur d'un array en C : on doit passer sa taille en paramètre en plus du tableau (sans spécifier sa taille)
+
+> [!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
+#define N 5
+int main(){
+	printf("%d\n", N);
+	return 0;
+}
+```
+À chaque fois que le programme rencontrera `N`, il remplacera par `5`
+
+> [!danger] On ne met jamais de `;` lors de la définition d'une macro !
+
+Le préprocesseur est la partie du compilateur qui lie les instructions commençant par `#`
+## Compréhension plus avancée de la pile
+Chaque zone dans la pile appartient à une fonction
+|> chaque zone possède ses propres noms : elle n'a pas accès aux autres noms de variables
+
+Pour qu'une fonction puisse accéder aux variables des autres fonctions, on doit utiliser les pointeurs !
+## Fonction `scanf`
+Elle permet de récupérer l'entrée donnée par l'utilisateur au clavier
+|> elle prend 2 paramètres : le⋅s type⋅s et un pointeur
+|> le type est par exemple `"%d"`pour un entier ou `"%c"` pour un caractère
+|> le pointeur est la variable devant recevoir la variable
+|> (elle ajoute automatiquement le `"\n"` après la saisi de l'utilisateur)
+
+```c
+int main(){
+	char c;
+	int i;
+	
+	printf("Saisir un caractère\n");
+	scanf("%c", &c);
+	printf("Vous avez saisi %c\n", c);
+	
+	printf("Saisir un entier\n");
+	scanf("%d", &i);
+	printf("Vous avez saisi %d\n", i);
+	return 0;
+}
+```
+## 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
+int ns[42];
+int *a = ns;
+```
+On a :
+`&ns[0]` $\equiv$ `a`
+`&ns[1]` $\equiv$ `a+1`
+`&ns[2]` $\equiv$ `a+2`
+`&ns[3]` $\equiv$ `a+3`
+...
+et
+`ns[0]` $\equiv$ `*a`
+`ns[1]` $\equiv$ `*(a+1)`
+`ns[2]` $\equiv$ `*(a+2)`
+`ns[3]` $\equiv$ `*(a+2)`
+...
diff --git a/semestre 2/informatique/array_stack_c.png b/semestre 2/informatique/array_stack_c.png
new file mode 100644
index 0000000..913a1bb
--- /dev/null
+++ b/semestre 2/informatique/array_stack_c.png
diff --git a/semestre 2/informatique/computer_architecture_detailled.png b/semestre 2/informatique/computer_architecture_detailled.png
new file mode 100644
index 0000000..1765914
--- /dev/null
+++ b/semestre 2/informatique/computer_architecture_detailled.png
diff --git a/semestre 2/informatique/computer_architecture_simplified.png b/semestre 2/informatique/computer_architecture_simplified.png
new file mode 100644
index 0000000..f4c95bf
--- /dev/null
+++ b/semestre 2/informatique/computer_architecture_simplified.png
diff --git a/semestre 2/informatique/ram_organisation_schema.png b/semestre 2/informatique/ram_organisation_schema.png
new file mode 100644
index 0000000..8f6015e
--- /dev/null
+++ b/semestre 2/informatique/ram_organisation_schema.png
diff --git a/semestre 2/informatique/td/1- Fonctions, affichage, define et assert.md b/semestre 2/informatique/td/1- Fonctions, affichage, define et assert.md
new file mode 100644
index 0000000..3cc87f8
--- /dev/null
+++ b/semestre 2/informatique/td/1- Fonctions, affichage, define et assert.md
@@ -0,0 +1,26 @@
+---
+tags:
+  - sorbonne
+  - informatique
+  - td
+semestre: 2
+---
+Pour afficher des valeurs en C, on utilise `printf`:
+
+| Format | Type                             |
+| ------ | -------------------------------- |
+| `%d`   | `int`                            |
+| `%f`   | `float`                          |
+| `%.xf` | `float` et affiche `x` virgule⋅s |
+| `%c`   | `char`                           |
+| `%s`   | une chaîne de caractères         |
+
+> [!warning] Booléen en C
+> On n'oublie pas que les booléens n'existent pas en C !
+> Ils sont remplacés par des entiers où 0 est false et tous les autres valeurs est vrai.
+> Donc, `1 == 1` vaut `1` et `1 == 0` vaut `0` !
+
+On peut créer des constantes en C grâce à `#define` :
+```c
+#define ZERO 0
+```
diff --git a/semestre 2/informatique/td/1- exemples/constant.c b/semestre 2/informatique/td/1- exemples/constant.c
new file mode 100644
index 0000000..37864ae
--- /dev/null
+++ b/semestre 2/informatique/td/1- exemples/constant.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+#define TNORMAL 11.4
+#define TMOINS 4.5
+#define TMOINS26S 4.9
+#define TMOINS26WE 7.9
+#define TMATIN 7.1
+
+float prixPlace(int age, int jour, float h){
+	if (age < 14) return TMOINS;
+	if (age < 26 && jour < 6) return TMOINS26S;
+	if (h < 11 && h > 8) return TMATIN;
+	if (age < 26) return TMOINS26WE;
+	return TNORMAL;
+}
+
+int main(){
+	printf("%.2f€ prix pour %d ans le %de jour de la semaine à %.1fh\n", prixPlace(13, 5, 13), 13, 5, 13.0);
+	printf("%.2f€ prix pour %d ans le %de jour de la semaine à %.1fh\n", prixPlace(14, 5, 13), 14, 5, 13.0);
+	printf("%.2f€ prix pour %d ans le %de jour de la semaine à %.1fh\n", prixPlace(14, 6, 13), 14, 6, 13.0);
+	printf("%.2f€ prix pour %d ans le %de jour de la semaine à %.1fh\n", prixPlace(14, 6, 10), 14, 6, 10.0);
+	printf("%.2f€ prix pour %d ans le %de jour de la semaine à %.1fh\n", prixPlace(28, 6, 10), 28, 6, 10.0);
+	printf("%.2f€ prix pour %d ans le %de jour de la semaine à %.1fh\n", prixPlace(28, 6, 15), 28, 6, 15.0);
+	return 0;
+}
+
diff --git a/semestre 2/informatique/td/1- exemples/plus_grand.c b/semestre 2/informatique/td/1- exemples/plus_grand.c
new file mode 100644
index 0000000..97c47a6
--- /dev/null
+++ b/semestre 2/informatique/td/1- exemples/plus_grand.c
@@ -0,0 +1,28 @@
+#include <assert.h>
+
+int plusGrand(int a, int b, int c){
+	int max = a;
+	if (max < b){
+		max = b;
+	}
+	if (max < c) {
+		max = c;
+	}
+	return max;
+}
+
+int plusGrandParmisCinq(int a, int b, int c, int d, int e){
+	return plusGrand(plusGrand(a, b, c), d, e);
+}
+
+int main(){
+	assert(plusGrand(1, 2, 3) == 3);
+	assert(plusGrand(4, 2, 3) == 4);
+	assert(plusGrand(4, 5, 3) == 5);
+	assert(plusGrandParmisCinq(1, 2, 3, 4, 5) == 5);
+	assert(plusGrandParmisCinq(6, 2, 3, 4, 5) == 6);
+	assert(plusGrandParmisCinq(6, 7, 3, 4, 5) == 7);
+	assert(plusGrandParmisCinq(6, 7, 8, 4, 5) == 8);
+	assert(plusGrandParmisCinq(6, 7, 8, 9, 5) == 9);
+	return 0;
+}
diff --git a/semestre 2/informatique/td/1- exemples/printf.c b/semestre 2/informatique/td/1- exemples/printf.c
new file mode 100644
index 0000000..f40921f
--- /dev/null
+++ b/semestre 2/informatique/td/1- exemples/printf.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+float mult(int op1, float op2){
+	return op1 * op2;
+}
+
+int main(){
+	int op1 = 3;
+	float op2 = 2.7;
+
+	printf("%d * %f = %f\n", op1, op2, mult(op1, op2));
+
+	return 0;
+}
diff --git a/semestre 2/informatique/td/1- exemples/signe_somme.c b/semestre 2/informatique/td/1- exemples/signe_somme.c
new file mode 100644
index 0000000..4506089
--- /dev/null
+++ b/semestre 2/informatique/td/1- exemples/signe_somme.c
@@ -0,0 +1,17 @@
+#include <assert.h>
+
+int signeSomme(int a, int b){
+	if (a > -b){
+		return 1;
+	} else if (a == -b){
+		return 0;
+	}
+	return -1;
+}
+
+int main(){
+	assert(signeSomme(2, -1) == 1);
+	assert(signeSomme(-1, 1) == 0);
+	assert(signeSomme(-2, 1) == -1);
+	return 0;
+}
diff --git a/semestre 2/informatique/td/2- Boucles, pile et comparaison de réels.md b/semestre 2/informatique/td/2- Boucles, pile et comparaison de réels.md
new file mode 100644
index 0000000..0c62406
--- /dev/null
+++ b/semestre 2/informatique/td/2- Boucles, pile et comparaison de réels.md
@@ -0,0 +1,14 @@
+---
+tags:
+  - sorbonne
+  - informatique
+  - td
+semestre: 2
+---
+Quand on fait la pile d'un programme, on procède par étape :
+1. on commence le bloc de la première fonction (`main`)
+2. dans le bloc, on enregistre et on affiche les valeurs des variables (e.g. `i`)
+3. quand on rencontre une nouvelle fonction, on crée un nouveau bloc et on retourne à l'étape 2
+4. quand on a fini l'exécution de la fonction, on libère la mémoire dans la pile
+5. on continue l'exécution du bloc
+
diff --git a/semestre 2/informatique/td/2- exemples/boucle.c b/semestre 2/informatique/td/2- exemples/boucle.c
new file mode 100644
index 0000000..b582080
--- /dev/null
+++ b/semestre 2/informatique/td/2- exemples/boucle.c
@@ -0,0 +1,25 @@
+#include <assert.h>
+
+int somme_carres_while(int m, int n){
+	int s = 0, i = m;
+	while (i <= n){
+		s += i*i;
+		i++;
+	}
+	return s;
+}
+
+int somme_carres_for(int m, int n){
+	int s = 0;
+	for (int i = m; i <= n; i++){
+		s += i*i;
+	}
+	return s;
+}
+
+int main(){
+	assert(somme_carres_while(0, 5) == somme_carres_for(0, 5));
+	assert(somme_carres_while(3, 5) == somme_carres_for(3, 5));
+	assert(somme_carres_while(15, 25) == somme_carres_for(15, 25));
+	return 0;
+}
diff --git a/semestre 2/informatique/td/2- exemples/boucle_complet.c b/semestre 2/informatique/td/2- exemples/boucle_complet.c
new file mode 100644
index 0000000..9cae542
--- /dev/null
+++ b/semestre 2/informatique/td/2- exemples/boucle_complet.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#define MAX 20
+
+int premier(int n){
+	if (n < 2) return 0;
+	for (int i = 2; i < n;i++){
+		if (n%i == 0) return 0; // est une boucle avec sortie anticipée
+	}
+	return 1;
+}
+
+void afficheNombresPremiers(int max){
+	for (int i = 2; i <= max; i++){
+		if (premier(i)) printf("%d\n", i);
+	}
+}
+
+int main(){
+	printf("Liste des nombres premiers <= %d\n", MAX);
+	afficheNombresPremiers(MAX);
+	return 0;
+}
diff --git a/semestre 2/informatique/td/2- exemples/boucles_complexes.c b/semestre 2/informatique/td/2- exemples/boucles_complexes.c
new file mode 100644
index 0000000..6c388a4
--- /dev/null
+++ b/semestre 2/informatique/td/2- exemples/boucles_complexes.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <assert.h>
+
+void afficheBilletsPieces(int m){
+	int r = m;
+	int billets = r/5;
+	r = r%5;
+	int pieces2 = r/2;
+	r = r%2;
+	int pieces1 = r;
+	printf("%d€ = %d * 5€ + %d * 2€ + %d * 1€", m, billets, pieces2, pieces1);
+}
+
+void afficheBilletsPiecesMultiple(int m){
+	for (int billets = m/5; billets >= 0; billets--){
+		int av = m - billets*5;
+		for (int p2 = av/2; p2 >= 0; p2--){
+			int av2 = av - p2*2;
+			assert(billets*5+p2*2+av2 == m);
+			printf("%d€ = %d*5€ + %d*2€ + %d*1€\n", m, billets, p2, av2);
+		}
+	}
+}
+
+int main(){
+	afficheBilletsPiecesMultiple(23);
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine1/03_jeuTest.c b/semestre 2/informatique/tme/semaine1/03_jeuTest.c
new file mode 100644
index 0000000..1099c11
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine1/03_jeuTest.c
@@ -0,0 +1,18 @@
+#include <assert.h>
+
+int alternative(int n1, int n2, int n3){
+	int res;
+	if (n1 > 8) res = 3;
+	else if (n3 == 20) res = 2;
+	else if (n2 >= 10 && n3 >= 10) res = 1;
+	else res = 0;
+	return res;
+}
+
+int main(){
+	assert(alternative(-4, 3, 20) == 2); // teste de la branche n3 == 20
+	assert(alternative(9,-2,20) == 3); // teste de la branche n1 > 8
+	assert(alternative(-5, 15, 1098765) == 1); // teste de la branche n2 >= 10 && n3 >= 10
+	assert(alternative(4, 8, 23) == 0); // teste des autres cas
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine1/05_discriminant.c b/semestre 2/informatique/tme/semaine1/05_discriminant.c
new file mode 100644
index 0000000..575f776
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine1/05_discriminant.c
@@ -0,0 +1,28 @@
+#include <math.h>
+#include <stdio.h>
+
+int discriminant(int a, int b, int c){
+	return b*b-4*a*c;
+}
+
+void afficheRacines(int a, int b, int c){
+	int disc = discriminant(a,b,c);
+	if (disc > 0) {
+		float sq = sqrt(disc);
+		printf("Racine 1 : %f\nRacine 2 : %f\n", (-b-sq)/(2*a), (-b+sq)/(2*a));
+	} else if (disc == 0) {
+		printf("Racine double : %f\n", (-b)/(float) (2*a));
+	} else {
+		printf("Pas de racine réelle\n");
+	}
+}
+
+int main(){
+	afficheRacines(1, 1, 1);
+	afficheRacines(1, 1, -1);
+	afficheRacines(-1, 1, -1);
+	afficheRacines(-1, 1, 1);
+	afficheRacines(1, 2, 1);
+	afficheRacines(2, 4, 2);
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine1/06_signe_produit.c b/semestre 2/informatique/tme/semaine1/06_signe_produit.c
new file mode 100644
index 0000000..764f184
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine1/06_signe_produit.c
@@ -0,0 +1,20 @@
+#include <assert.h>
+
+int signeProduit(int a, int b){
+	if (a == 0 || b == 0) return 0;
+	else if (
+		(a < 0 && b > 0) || (a > 0 && b < 0)
+	) return -1;
+	return 1;
+}
+
+int main(){
+	assert(signeProduit(0, 0) == 0);
+	assert(signeProduit(1, 0) == 0);
+	assert(signeProduit(0, -1) == 0);
+	assert(signeProduit(1, 1) == 1);
+	assert(signeProduit(-1, -1) == 1);
+	assert(signeProduit(1, -1) == -1);
+	assert(signeProduit(-1, 1) == -1);
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine1/07_tour_londres.c b/semestre 2/informatique/tme/semaine1/07_tour_londres.c
new file mode 100644
index 0000000..92f0cff
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine1/07_tour_londres.c
@@ -0,0 +1,37 @@
+#include <assert.h>
+#define ADU 22.7
+#define KID 10.75
+#define FAMILLY 57.8
+#define COMPARE_FLOAT_PRECISION 0.00001
+
+float prixEntree(int adus, int kids){
+	float no_familly = adus * ADU + kids * KID;
+	float with_familly = FAMILLY;
+	int r_adus = adus - 2;
+	int r_kids = kids - 3;
+	if (r_adus > 0){
+		with_familly += r_adus * ADU;
+	}
+	if (r_kids > 0){
+		with_familly += r_kids * KID;
+	}
+	if (no_familly < with_familly) return no_familly;
+	return with_familly;
+}
+
+int compareFloat(float f1, float f2, float eps){
+	/* Prend trois floats (f1, f2 et eps) et renvoie |f1-f2|<eps ; est une comparaison de deux
+	 * floats à epsilon près */
+	float diff = f1 - f2;
+	if (diff < 0) diff = - diff;
+	return diff < eps;
+}
+
+int main(){
+	assert(compareFloat(prixEntree(2, 3), FAMILLY, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(2, 2), FAMILLY, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(2, 1), 2*ADU + KID, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(1, 3), ADU + 3*KID, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(0, 1), KID, COMPARE_FLOAT_PRECISION));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine2/09_lib_graphique.c b/semestre 2/informatique/tme/semaine2/09_lib_graphique.c
new file mode 100644
index 0000000..d90845e
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine2/09_lib_graphique.c
@@ -0,0 +1,15 @@
+#include <cini.h>
+
+void diagonale(int x){
+	for (int i = 0; i <= x; i++) {
+		CINI_draw_pixel(i, i, "orange");
+	}
+}
+
+int main(){
+	CINI_open_window(400, 300, "hello world");
+	diagonale(200);
+	CINI_loop();
+
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine2/10_carre.c b/semestre 2/informatique/tme/semaine2/10_carre.c
new file mode 100644
index 0000000..45029bb
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine2/10_carre.c
@@ -0,0 +1,28 @@
+#include <cini.h>
+
+void carre(int c, int x, int y){
+	for (int i = 0; i<c;i++){
+		CINI_draw_pixel(x+i, y, "blue");
+		CINI_draw_pixel(x+i, y+c, "green");
+		CINI_draw_pixel(x, y+i, "red");
+		CINI_draw_pixel(x+c, y+i, "black");
+	}
+}
+
+void carres_remontant(int c, int x, int y){
+	int nx = x, ny = y;
+	while (nx >= 0 && ny >= 0){
+		carre(c, nx, ny);
+		nx -= 20;
+		ny -= 20;
+	}
+}
+
+int main() {
+	CINI_open_window(400, 400, "Carre");
+	CINI_fill_window("white");
+	carres_remontant(100, 50, 100);
+	CINI_loop();
+
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine2/11_propagation_epidemie.c b/semestre 2/informatique/tme/semaine2/11_propagation_epidemie.c
new file mode 100644
index 0000000..26b763e
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine2/11_propagation_epidemie.c
@@ -0,0 +1,41 @@
+#include <assert.h>
+#include <stdio.h>
+
+int jours(int infected, int pop, float percentage){
+	int n = 1, c = 0;
+	while (n / (float) pop < percentage/100){
+		n += infected * n;
+		c++;
+	}
+	return c;
+}
+
+float pourcentage(int infected, int pop, int day){
+	int n = 1, c = 0;
+	while (c < day && n <= pop){
+		n += infected*n;
+		c++;
+	}
+	if (n >= pop) return 100;
+	return 100*n/ (float) pop;
+}
+
+int eps_pres(float a, float b, float eps){
+	float v = a - b;
+	if (v < 0) v = -v;
+	return v < eps;
+}
+
+int main(){
+	assert(jours(5, 10000, 100) == 6);
+	assert(jours(5, 10000, 50) == 5);
+	assert(jours(5, 10000, 25) == 5);
+	assert(jours(5, 10000, 10) == 4);
+	
+	assert(eps_pres(pourcentage(5, 10000, 2), 0.36, 0.001));
+	assert(eps_pres(pourcentage(5, 10000, 3), 2.16, 0.001));
+	assert(eps_pres(pourcentage(5, 10000, 4), 12.96, 0.001));
+	assert(eps_pres(pourcentage(5, 10000, 5), 77.76, 0.001));
+	assert(eps_pres(pourcentage(5, 10000, 6), 100.00, 0.001));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine2/12_droite_points.c b/semestre 2/informatique/tme/semaine2/12_droite_points.c
new file mode 100644
index 0000000..a202e24
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine2/12_droite_points.c
@@ -0,0 +1,34 @@
+#include <cini.h>
+#define WIDTH 400
+#define HEIGHT 400
+
+int position(int a, int b, int x, int y){
+	// t(z) = az+b
+	// y(x) = alpha x + beta
+	int straight_line_y = a*x+b;
+	if (straight_line_y > y) return 1;
+	if (straight_line_y < y) return -1;
+	return 0;
+}
+
+void affiche(int a, int b, int width, int height){
+	for (int x = 0; x < width; x++){
+		for (int y = 0; y < height; y++){
+			int pos = position(a, b, x, y);
+			char* color;
+			if (pos == 1) color = "red";
+			else if (pos == -1) color = "blue";
+			else color = "black";	
+			CINI_draw_pixel(x, y, color);
+		}
+	}
+}
+
+int main(){
+	CINI_open_window(WIDTH, HEIGHT, "Hello");
+	CINI_fill_window("white");
+	affiche(1, 0, WIDTH, HEIGHT);
+	CINI_loop();
+	return 0;
+}
+
diff --git a/semestre 2/informatique/tme/semaine2/14_tour_londres.c b/semestre 2/informatique/tme/semaine2/14_tour_londres.c
new file mode 100644
index 0000000..1c86e65
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine2/14_tour_londres.c
@@ -0,0 +1,51 @@
+#include <assert.h>
+#define ADU 22.7
+#define KID 10.75
+#define FAMILLY 57.8
+#define MAX_ADU_FAMILLY 2
+#define MAX_KID_FAMILLY 3
+#define COMPARE_FLOAT_PRECISION 0.00001
+
+float prixEntree(int adus, int kids){
+	int max_familly = 0;
+	int r_adus = adus;
+	int r_kids = kids;
+	do {
+		r_adus -= MAX_ADU_FAMILLY;
+		r_kids -= MAX_KID_FAMILLY;
+		max_familly++;	
+	} while (r_adus > 0 || r_kids > 0);
+	float min = -1;
+	for (int f = 0; f <= max_familly; f++){
+		int r_adus = adus - MAX_ADU_FAMILLY*f;
+		int r_kids = kids - MAX_KID_FAMILLY*f;
+		float t = f*FAMILLY;
+	    if (r_adus > 0) t += r_adus * ADU;
+	    if (r_kids > 0) t += r_kids * KID;
+		if (min == -1 || t < min) {
+			min = t;
+		}
+	}
+	return min;
+}
+
+int compareFloat(float f1, float f2, float eps){
+	/* Prend trois floats (f1, f2 et eps) et renvoie |f1-f2|<eps ; est une comparaison de deux
+	 * floats à epsilon près */
+	float diff = f1 - f2;
+	if (diff < 0) diff = - diff;
+	return diff < eps;
+}
+
+int main(){
+	assert(compareFloat(prixEntree(2, 3), FAMILLY, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(2, 2), FAMILLY, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(2, 1), 2*ADU + KID, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(6, 3), 4*ADU + FAMILLY, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(1, 3), 1*ADU + 3*KID, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(5, 7), 2*FAMILLY + ADU + KID, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(6, 8), 3*FAMILLY, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(10, 0), 227, COMPARE_FLOAT_PRECISION));
+	assert(compareFloat(prixEntree(0, 4), 43, COMPARE_FLOAT_PRECISION));
+	return 0;
+}
diff --git a/semestre 2/informatique/used_operators_c.png b/semestre 2/informatique/used_operators_c.png
new file mode 100644
index 0000000..f3dc95b
--- /dev/null
+++ b/semestre 2/informatique/used_operators_c.png