diff --git a/organisation_memoire/serie1/ex1.md b/organisation_memoire/serie1/ex1.md
new file mode 100644
index 0000000000000000000000000000000000000000..06bd615534ed558ca8fe87a8428819d27f07ca50
--- /dev/null
+++ b/organisation_memoire/serie1/ex1.md
@@ -0,0 +1,14 @@
+# Exercice 1
+
+
+- Soit un noyau, qui lorsqu'il crée l'espace d'adressage de chaque processus,
+charge toujour la section de code à la même adresse, la section de données toujours
+à la même adresse, la section de tas toujours à la même adresse, etc.
+    - Est-ce qu'un système utilisant cette organisation mémoire pourrait fonctionner
+    correctement ou pas ? Justifiez votre réponse.
+
+- Soit un noyau, qui lorsqu'il crée l'espace d'adressage de chaque processus,
+charge toujours la section de code à l'adresse 0, la section de données à l'adresse
+1GB, la section de tas à 4GB et la section de pile à 50GB.
+    - Est-ce qu'un système comportant 32GB de RAM et utilisant cette organisation
+    mémoire pourrait fonctionner correctement ou pas ? Justifiez votre réponse.
diff --git a/organisation_memoire/serie1/ex2/.gitignore b/organisation_memoire/serie1/ex2/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..cccd7230993bed369513a1e3225d6c45ae40dca7
--- /dev/null
+++ b/organisation_memoire/serie1/ex2/.gitignore
@@ -0,0 +1,3 @@
+*.o
+prog
+*.xopp
diff --git a/organisation_memoire/serie1/ex2/Makefile b/organisation_memoire/serie1/ex2/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..df35d6384b9e9f177057b82986b6a1858455e9da
--- /dev/null
+++ b/organisation_memoire/serie1/ex2/Makefile
@@ -0,0 +1,24 @@
+CC := clang
+CFLAGS := -g -pedantic -Wall -Wextra -std=c11
+LDFLAGS := -fsanitize=address -fsanitize=leak -fsanitize=undefined -lm -lpthread
+TARGET := prog
+
+all: $(TARGET)
+
+$(TARGET): prog.o
+	@printf "=================== Building executable ===================\n"
+	$(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)
+
+%.o: %.c
+	@printf "=================== Building sources ===================\n"
+	$(CC) $(CFLAGS) -c $<
+
+.PHONY: clean
+
+clean:
+	@printf "=================== Cleaning up... ===================\n"
+	rm -f *.o $(TARGET)
+
+.PHONY: rebuild
+
+rebuild: clean all
diff --git a/organisation_memoire/serie1/ex2/ex2.md b/organisation_memoire/serie1/ex2/ex2.md
new file mode 100644
index 0000000000000000000000000000000000000000..ff2999d51dd5a3e8e95e7004cdec44cff38c2440
--- /dev/null
+++ b/organisation_memoire/serie1/ex2/ex2.md
@@ -0,0 +1,59 @@
+# Exercice 2
+
+- Est-ce que les adresses affichées sont des adresses physiques ou des adresses
+virtuelles ?
+
+    - Les adresses ci-dessous sont des adresses virtuelles, en réalité ces variables
+    se situeront à un autre emplacement dans l'espace d'adressage physique.
+
+
+- Est-ce que les adresses affichées sont les mêmes d'une exécution à l'autre ?
+    - 1ère exécution
+    ```sh
+    address of `global_init_1` = 0x564b2cacfa48
+    address of `global_init_2` = 0x564b2cacfa4c
+    address of `global_1` = 0x564b2d423720
+    address of `global_2` = 0x564b2d423724
+    address of `local` = 0x7ffeada53f14
+    address of `arr` = 0x604000000050
+    address of `pushing_call_onto_stack` = 0x564b2ca97420
+    ```
+    - 2ème exécution
+    ```sh
+    address of `global_init_1` = 0x564b7bdc9a48
+    address of `global_init_2` = 0x564b7bdc9a4c
+    address of `global_1` = 0x564b7c71d720
+    address of `global_2` = 0x564b7c71d724
+    address of `local` = 0x7fff7f16de74
+    address of `arr` = 0x604000000050
+    address of `pushing_call_onto_stack` = 0x564b7bd91420
+    ```
+    - 3ème exécution
+    ```sh
+    address of `global_init_1` = 0x561a34163a48
+    address of `global_init_2` = 0x561a34163a4c
+    address of `global_1` = 0x561a34ab7720
+    address of `global_2` = 0x561a34ab7724
+    address of `local` = 0x7fffda20dcf4
+    address of `arr` = 0x604000000050
+    address of `pushing_call_onto_stack` = 0x561a3412b420
+    ```
+
+    - Nous pouvons bien remarquer que les adresses bougent d'une exécution à l'autre
+    autant pour les variables locales que globales, les allocations dynamiques de
+    mémoire et les fonctions.
+
+- Réalisez un schéma illustrant l'ordre des sections ci-dessous selon leurs
+emplacements en mémoire (les adresses basses en bas de page, les adresses hautes
+en haut de page) :
+    - code
+    - pile
+    - données initialisées
+    - données non-initialisées
+    - tas
+
+    ![Schéma de la mémoire](figs/schema_memoire.png) 
+
+
+
+
diff --git a/organisation_memoire/serie1/ex2/figs/schema_memoire.png b/organisation_memoire/serie1/ex2/figs/schema_memoire.png
new file mode 100644
index 0000000000000000000000000000000000000000..267ca376f6f4111ae434f49e890c4f338b4ce188
Binary files /dev/null and b/organisation_memoire/serie1/ex2/figs/schema_memoire.png differ
diff --git a/organisation_memoire/serie1/ex2/prog.c b/organisation_memoire/serie1/ex2/prog.c
new file mode 100644
index 0000000000000000000000000000000000000000..7a325b4558c43dcd2bbaa09261e1075e9395cc3b
--- /dev/null
+++ b/organisation_memoire/serie1/ex2/prog.c
@@ -0,0 +1,32 @@
+#include <libgen.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int glob_init_1 = 15;
+int glob_init_2 = -50;
+int glob_1;
+int glob_2;
+
+void pushing_call_onto_stack(void) { return; }
+
+int main(void) {
+    int local;
+    int *arr = malloc(10 * sizeof(int));
+
+    pushing_call_onto_stack();
+
+    fprintf(stdout, "address of `global_init_1` = %p\n", (void *)&glob_init_1);
+    fprintf(stdout, "address of `global_init_2` = %p\n", (void *)&glob_init_2);
+    fprintf(stdout, "address of `global_1` = %p\n", (void *)&glob_1);
+    fprintf(stdout, "address of `global_2` = %p\n", (void *)&glob_2);
+    fprintf(stdout, "address of `local` = %p\n", (void *)&local);
+    fprintf(stdout, "address of `arr` = %p\n", (void *)arr);
+    fprintf(stdout, "address of `pushing_call_onto_stack` = %p\n",
+            (void *)&pushing_call_onto_stack);
+
+    free(arr);
+    return EXIT_SUCCESS;
+}