diff options
Diffstat (limited to 'semestre 2/informatique')
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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew file mode 100644 index 0000000..f3dc95b --- /dev/null +++ b/semestre 2/informatique/used_operators_c.png |
