diff --git a/circ_list.c b/circ_list.c
new file mode 100644
index 0000000000000000000000000000000000000000..95ed608c0cc07f2b660a5396866a5e45b09bcdb2
--- /dev/null
+++ b/circ_list.c
@@ -0,0 +1,370 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include "circ_list.h"
+
+void display(Element* head){
+
+ Element* now = head;
+ printf("[");
+
+ do {
+ printf("%d;",now->content);
+ now = now->next;
+ if(now == NULL){
+ break;
+ }
+ }while(now->part != Head);
+ printf("]");
+}
+
+
+//Fonction Créant des éléments par défaut
+Element* element_create(void *data, Body Part, Element* Next){
+
+ //Allocation de la mémoire
+ Element* New = calloc(1,sizeof(Element));
+ //Attribution des données
+ New->content = data;
+ New->part = Part;
+ New->next = Next;
+ //Retour de l'élément
+ return New;
+}
+
+//Fonction qui créer une liste vide contenant seulement la tête
+Element* list_create(){
+
+ Element* create = element_create(NULL,Head,NULL);
+ return create;
+}
+
+//Fonction Créant un chaine par défaut
+Chain_Circ* chain_create(){
+
+ //Déclaration de la tête ainsi de que de la queue
+ Element* tail = element_create(NULL,Tail,NULL);
+ //last et next correspondent a la queue pour la tête
+ Element* head = element_create(NULL,Head,tail);
+ //et inversement pour la queue
+ tail->next = head;
+ //Attribution de la mémoire pour la chaine
+ Chain_Circ* New = calloc(1,sizeof(Chain_Circ));
+ //Distribution de la tête, la queue et la longueur
+ New->head = head;
+ New->tail = tail;
+ //2 est la longueur de base vue qu'il n'y a que la tête et la queue
+ New->length = 2;
+
+}
+
+//Fonction vérifiant le contenu de la chaine
+bool list_empty(Element* head){
+
+ //Si head ne pointe sur rien alors la chaine est vide
+ if(head->next == NULL) {
+ //On retourne donc "vrai"
+ return true;
+ }
+ else {
+ //Sinon elle n'est pas vide on retourne "faux"
+ return false;
+ }
+}
+
+//Fonction qui déplace la tête au prochain élément
+Element* list_move(Element* head){
+
+ head->next->part= Head;
+ Element* new_head = head->next;
+ head->part = Tail;
+
+ return new_head;
+}
+
+//Fonction qui compte le nombre d'élément de la liste en partant de la tête
+unsigned int list_count(Element* head) {
+
+ //On utilise une fonction qui contient la tête
+ Element* now = head;
+ //Et une autre qui va compter les éléments
+ unsigned int count = 0;
+ //On compte tant que l'on est pas de retour à la tête ou que le prochaine élément est NULL
+ do{
+ count++;
+ //On passe à l'élément d'après ici
+ now = now->next;
+ if(now == NULL){
+ break;
+ }
+ }while(now->part != Head);
+ return count;
+}
+
+//Fonction qui insert un élément après la tête
+Element* list_insert_after(Element* head, void* data){
+
+ //On créer l'élément que l'on veut insérer
+ Element* insert = element_create(data,Trunk,NULL);
+ //Si il y avait déja un élément après la tête
+ if(head->next != NULL){
+ //Notre nouvel pointera dessus afin de garder intacte la liste
+ insert->next = head->next;
+ }
+ //Sinon on fait simplement pointer la tête sur le nouvel élément
+ head->next = insert;
+
+ //Puis on le retourne
+ return insert;
+
+}
+
+//Fonction qui insert un élément avant la tête
+Element* list_insert_before(Element* head, void* data) {
+
+ //On créé simplement un élément qui pointe sur la tête
+ Element* insert = element_create(data,Trunk,head);
+
+ return insert;
+}
+
+//Fonction de comparaison des données
+int compare (void* data1, void* data2){
+
+ //On vérifie si les valeurs sont différentes
+ if (data1!=data2 ){
+
+ return 0;
+ }
+ //Si la condition n'est pas remplie alors elle sont égales
+ else {
+
+ return 1;
+ }
+}
+
+//Fonction qui recherche un élément dans la liste
+Element* list_search(Element* head, void* data, int (*compare)(void*, void*)){
+
+ //On stock head dans une variable
+ Element* now = head;
+
+ //Boucle s'arrêtant au retour de la tête si c'est une liste circulaire ou des qu'un élément est NULL
+ do{
+ //On compare les valeurs
+ int v = (*compare)(data,now->content);
+ //Si c'est 1 on retourne l'élément car on l'a trouvé
+ if(v==1){
+ return now;
+ }
+ //Sinon on passe à celui d'après
+ now = now->next;
+
+ if(now == NULL){
+ return NULL;
+ }
+
+ }while(now->part != Head);
+
+ //Si on fini la boucle sans rien avoir trouvé on renvoi NULL
+ return NULL;
+}
+
+
+//Fonction qui supprime un élément dans la liste
+Element* list_remove(Element* head, void* data, int (*compare)(void*, void*)){
+
+ //On stock head dans une variable
+ Element* now = head;
+ //On créé une variable pour garder l'élément précédent
+ Element* last;
+
+ //Boucle s'arrêtant au retour de la tête si c'est une liste circulaire ou des qu'un élément est NULL
+ do{
+ //On compare les valeurs
+ int v = (*compare)(data,now->content);
+ //Si le retour est 1
+ if(v==1){
+ //on fait pointé l'élément juste avant celui qu'on supprime à l'élément après celui-ci
+ last->next = now->next;
+
+ //Et l'élément qu'on veut enlever de la liste ne pointe plus sur rien. De cette façon il n'est plus dans la liste
+ now->next = NULL;
+ return now;
+ }
+
+ //le précédent de vient l'actuel
+ last = now;
+ //l'actuel devient le prochain
+ now = now->next;
+
+ if(now == NULL){
+ return NULL;
+ }
+
+ }while(now->part != Head);
+
+ //Si on fini la boucle sans rien avoir trouvé on renvoi NULL
+ return NULL;
+
+}
+
+
+void list_free(Element* head, void (*data_free)(void*)){
+
+ //On stock head dans une variable
+ Element* now = head;
+
+ //Boucle s'arrêtant au retour de la tête si c'est une liste circulaire ou des qu'un élément est NULL
+ do{
+
+ (*data_free)(now);
+
+ //l'actuel devient le prochain
+ now = now->next;
+
+ if(now->next == NULL){
+ break;
+ }
+
+ }while(now->part != Head);
+
+}
+
+//TESTS//
+
+//TEST DE LA CREATION DE CHAINE
+void Test1() {
+
+ //On créer un chaine afin de vérifier si elle correspond bien à nôtre code
+ Chain_Circ* test = chain_create();
+
+ //On verifie chaque attribut pour qu'il correspondent bien au code
+ if(test->length == 2 && test->head->part == Head && test->tail->part == Tail){
+ printf("\nTest chain_create() OK");
+ }
+ //Si la condition n'est pas rempli alors notre fonction ne fait pas ce que l'on veut
+ else{
+ printf("\nTest chain_create() Error");
+ }
+
+ //On libère la mémoire
+ free(test->head);
+ free(test->tail);
+ free(test);
+
+}
+
+//TEST COMPTE DE LA LISTE
+void Test2(){
+
+ //Création d'une chaine par défaut
+ Chain_Circ* test = chain_create();
+
+ //On verifie si ça correspond a la taille donnée par défaut
+ if(list_count(test->head)== test->length){
+ printf("\nTest list_count() OK");
+ }
+ else{
+ printf("\nTest list_count() Error");
+ }
+
+ //Libération de la mémoire
+ free(test->head);
+ free(test->tail);
+ free(test);
+}
+
+//TEST INSERTION AVANT ET APRES LA TETE
+void Test4() {
+
+ //On créer une liste
+ Element* head = list_create();
+ int* data = 1;
+
+ //Utilisation de la fonction d'insertion après la tête
+ Element* insert1 = list_insert_after(head, data);
+ //Si la tête pointe bien sur l'élément retourné et que la donné est bien celle que l'on voulait le test est bon
+ if(head->next == insert1 && head->next->content == data){
+ printf("\nTest list_insert_after() OK");
+ }
+ else {
+ printf("\nTest list_insert_after() Error");
+ }
+
+ //Puis on refait la même chose avec la fonction d'insertion avant la tête
+ Element* insert2 = list_insert_before(head,data);
+ if(insert2->next == head && insert2->content == data){
+ printf("\nTest list_insert_before() OK");
+ }
+ else {
+ printf("\nTest list_insert_before() Error");
+ }
+ list_free(head,free);
+}
+
+//TEST DE LA FONCTION DE RECHERCHE
+void Test5(){
+
+ //Création d'un liste
+ Element* test = list_create();
+ //Variable de la donnée qui sera testée
+ int* data;
+ //Insertion d'élément de 5 à 1
+ for(int i = 5; i>0; i--){
+ data = i;
+ list_insert_after(test,data);
+ }
+ //Recherche d'un des éléments inséré
+ data = 3;
+ Element* test_v = list_search(test,data,compare);
+
+ //Recherche d'un élément qui n'a pas été inséré
+ data = 7;
+ Element* test_f = list_search(test,data,compare);
+
+ //Si il trouve le premier et non le deuxieme alors la fonction marche parfaitement
+ if(test_v != NULL && test_f == NULL){
+ printf("\nTest list_search() OK");
+ }
+ else{
+ printf("\nTest list_search() Error");
+ }
+ //On libére la mémoire
+ list_free(test,free);
+}
+
+//TEST DE LA FONCTION DE SUPPRESSION D'UN ELEMENT DE LA LISTE
+void Test6(){
+
+ //Création d'un liste
+ Element* test = list_create();
+ //Variable de la donnée qui sera testée
+ int* data;
+ //Insertion d'élément de 5 à 1
+ for(int i = 5; i>0; i--){
+ data = i;
+ list_insert_after(test,data);
+ }
+ data = 3;
+ list_remove(test,data,compare);
+ Element* test_s = list_search(test,data,compare);
+
+ if (test_s == NULL){
+ printf("\nTest list_remove() OK");
+ }
+ else{
+ printf("\nTest list_remove() Error");
+ }
+ //On libère la mémoire
+ list_free(test,free);
+}
+
+//Fonction de tout les Tests
+void All_Test(){
+ Test1();
+ Test2();
+ Test4();
+ Test5();
+ Test6();
+}
\ No newline at end of file
diff --git a/circ_list.h b/circ_list.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cbda306104cb43884230465bbf3fe61a8223508
--- /dev/null
+++ b/circ_list.h
@@ -0,0 +1,57 @@
+#include <stdbool.h>
+//Enum Body afin de déterminer les partis de la chaine dans nôtre structure Element suivante
+typedef enum Body {
+
+ Head,
+ Tail,
+ Trunk,
+
+}Body;
+
+//Structure Element Contenant la donnée, l'élément suivant, l'élément précédent et la parti de la chaine (queue, tête ou tronc)
+typedef struct Element{
+
+ void* content;
+ struct Element* next;
+ Body part;
+
+}Element;
+
+//Structure Représentant une chaine circulaire composé de la tête et de la queue ainsi que de la longeur de la chaine
+typedef struct Chain_Circ {
+
+ Element* head;
+ Element* tail;
+ unsigned int length;
+
+}Chain_Circ;
+
+//Fonctions defini pour le fichier "circ_list.c"
+
+Element* element_create(void *data, Body Part, Element* Next);
+
+Element* list_create();
+
+Chain_Circ* chain_create();
+
+bool list_empty(Element* head);
+
+Element* list_move(Element* head);
+
+unsigned int list_count(Element* head);
+
+Element* list_insert_after(Element* head, void* data);
+
+Element* list_insert_before(Element* head, void* data);
+
+int compare(void* data1, void* data2);
+
+Element* list_search(Element* head, void* data, int (*compare)(void*, void*));
+
+Element* list_remove(Element* head, void* data, int (*compare)(void*, void*));
+
+void list_free(Element* head, void (*data_free)(void*));
+
+void display(Element* head);
+
+
diff --git a/circ_list.o b/circ_list.o
new file mode 100644
index 0000000000000000000000000000000000000000..34952b9f1e0830060127ae3bce6201fa56bfe395
Binary files /dev/null and b/circ_list.o differ
diff --git a/joseph.c b/joseph.c
new file mode 100644
index 0000000000000000000000000000000000000000..7a4c39308b5bf5209f7fa5f833f7cd8d0c99158c
--- /dev/null
+++ b/joseph.c
@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include "circ_list.h"
+
+//Fonction qui supprime le k-eme élément
+Element* delete_k(Element* head,int k){
+
+ //Variable de déplacement dans la liste
+ Element* now = head;
+ //variable pour le compte
+ int loop = 1;
+ //Si k = 1 cela veut dire que l'on va supprimer la tête donc on la déplace
+ if(k==1){
+ head = list_move(head);
+ }
+ //Boucle jusqu'a que que notre compte soit égale à k
+ while(loop!=k){
+ //Incrémentation
+ loop++;
+ //On passe à l'élément d'après
+ now = now->next;
+ }
+ //Affichage de l'élément supprimé comme demandé
+ printf("\n%d",now->content);
+ //Suppression
+ list_remove(head,now->content,compare);
+ //On retourne la tête dans le cas où elle aurait été changé
+ return head;
+}
+
+int main (int argc, char *argv[]){
+
+ if(strcmp(argv[1], "test") == 0){
+ All_Test();
+ }
+ else{
+ //On récupère les 2 premiers arguments
+ int n = atoi(argv[1]);
+ int k = atoi(argv[2]);
+
+ //Création d'une liste
+ Element* head = list_create();
+ //On donne la valeur 1
+ head->content = 1;
+
+ int* kk;
+ //Boucle d'insertion jusqu'a avoir n élément dans la liste chainée
+ for(int i=n; i>1; i--) {
+ kk = i;
+ list_insert_after(head,kk);
+ }
+
+ int* length = n;
+ //On cherche le dernier élément de la liste
+ Element* last = list_search(head,length,compare);
+ //On le fait pointé sur la tête pour avoir réellement un liste chainée
+ last->next = head;
+
+ //Affichage de la liste
+ display(head);
+ //Boucle pour l'ordre de suprression
+ for(int i =0; i<n; i++) {
+
+ //Si "k" depasse "n" on lui soustrait "n" et on lui ajoute "i"(qui correspond au nombre d'éléments supprimés)
+ while(k > n) {
+ k = k - n + i;
+ }
+ //On supprime l'élément à la k-eme place moins i
+ head = delete_k(head, k - i);
+ //On augmente k de sa valeur de départ a chaque boucle
+ k += atoi(argv[2]);
+ }
+ }
+}
\ No newline at end of file
diff --git a/joseph.exe b/joseph.exe
new file mode 100644
index 0000000000000000000000000000000000000000..1a921245da6d6d3bb3b20ddad95a114102965370
Binary files /dev/null and b/joseph.exe differ
diff --git a/joseph.o b/joseph.o
new file mode 100644
index 0000000000000000000000000000000000000000..bdc613e042be2501a222e768b46c43b96e29b4e0
Binary files /dev/null and b/joseph.o differ
diff --git a/makefile b/makefile
new file mode 100644
index 0000000000000000000000000000000000000000..3ab6699d344f3903b0829d3b0991e6a17a1cb556
--- /dev/null
+++ b/makefile
@@ -0,0 +1,29 @@
+All: joseph matrix_compute pointer_sort
+
+joseph: circ_list.o joseph.o
+ gcc -o joseph circ_list.o joseph.o
+
+matrix_compute: matrix.o matrix_compute.o
+ gcc -o matrix_compute matrix.o matrix_compute.o
+
+pointer_sort: pointer_sort.o
+ gcc -o pointer_sort pointer_sort.o
+
+circ_list.o: circ_list.c
+ gcc -o circ_list.o -c circ_list.c
+
+joseph.o: joseph.c
+ gcc -o joseph.o -c joseph.c
+
+matrix.o: matrix.c
+ gcc -o matrix.o -c matrix.c
+
+matrix_compute.o: matrix_compute.c
+ gcc -o matrix_compute.o -c matrix_compute.c
+
+
+pointer_sort.o: pointer_sort.c
+ gcc -o pointer_sort.o -c pointer_sort.c
+
+clean:
+ del /f /q *.o
diff --git a/matrix.c b/matrix.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa60b0b92e58580b99147f9c931b4c09219db6c2
--- /dev/null
+++ b/matrix.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include "matrix.h"
+
+m_double* matrix_alloc(unsigned int row, unsigned int col){
+
+ if(row == 0 || col == 0){
+ return NULL;
+ }
+ m_double* matrix = calloc(1,sizeof(m_double));
+ double ** mat_ptr = malloc(row*col*sizeof(double));
+ matrix->content = malloc(row*col*sizeof(double*))
+ for (int i=0;i<li;i++) mat->content[i] = data+i*co;
+ return matrix;
+
+}
+
+
+
+m_double* matrix_transpose(m_double* matrix){
+
+ m_double transp = matrix_alloc(matrix->col,matrix->row);
+ for(int i=0;i<matrix->row;i++){
+ for(int j=0;j<matrix->col;j++){
+ transp[j][i] = matrix[i][j];
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/matrix.h b/matrix.h
new file mode 100644
index 0000000000000000000000000000000000000000..4905544f7123c7376aa57c91749afbe7881f374e
--- /dev/null
+++ b/matrix.h
@@ -0,0 +1,8 @@
+typedef struct m_double {
+ unsigned int row, col;
+ double** content;
+} m_double;
+
+m_double* matrix_alloc(unsigned int row, unsigned int col);
+
+m_double* matrix_transpose(m_double* m);
diff --git a/matrix.o b/matrix.o
new file mode 100644
index 0000000000000000000000000000000000000000..4180cf6ac3e7f81eeca9ac7669e9928d8e04b74a
Binary files /dev/null and b/matrix.o differ
diff --git a/matrix_compute.c b/matrix_compute.c
new file mode 100644
index 0000000000000000000000000000000000000000..dbbd85ecccc5d2448d1ec6789047642fe726d971
--- /dev/null
+++ b/matrix_compute.c
@@ -0,0 +1 @@
+int main(){}
\ No newline at end of file
diff --git a/matrix_compute.exe b/matrix_compute.exe
new file mode 100644
index 0000000000000000000000000000000000000000..2c3ce2bb599db4eeeaaf55a5829244da5d48c2d6
Binary files /dev/null and b/matrix_compute.exe differ
diff --git a/matrix_compute.o b/matrix_compute.o
new file mode 100644
index 0000000000000000000000000000000000000000..8bdd7c1e0f37ce1dc7641608c1d1ebaaf04530c3
Binary files /dev/null and b/matrix_compute.o differ
diff --git a/pointer_sort.c b/pointer_sort.c
new file mode 100644
index 0000000000000000000000000000000000000000..72fa295b39e6a2a05ac5ad685c615a663e07ac04
--- /dev/null
+++ b/pointer_sort.c
@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+//Fonction de Vérification d'une valeur dans un tableau
+int check(int* tab[],unsigned int len, int n){
+
+ //On parcours
+ for(int i=0; i<len; i++){
+ //Si la valeur est égale à une d'une tableau on retourne 1
+ if(n==tab[i]){
+ return 1;
+ }
+ }
+ //Sinon 0
+ return 0;
+}
+
+//Fonction de sort
+int* sort(int tab[],unsigned int len){
+
+ //Tableau de pointeur(len-1 car on prendra argc en argument)
+ int* ptr_tab[len-1];
+ //variable utile dans le processus
+ int sort;
+
+ //Double boucle
+ for(int j=0; j<len-1; j++) {
+ //Initialisation
+ sort = 0;
+
+ for (int i = 0; i < len-1; i++) {
+ //On vérifie d'abord si la valeur n'est pas déjà dans le tableau autrement on la passe
+ int v = check(ptr_tab,len-1,tab[i]);
+ if (v == 1) {
+ continue;
+ }
+ //Sort prend la première valeur valable du tableau
+ if(sort==0){sort = tab[i];}
+
+ //Ensuite on compare avec chaque élément pour voir lequel est le plus petit
+ if (sort >= tab[i]) {
+
+ //On pointe sur celui ci tant qu'on en trouve pas un autre encore plus petit
+ ptr_tab[j] = *(tab+i);
+ //Si on trouve un plus petit on remplace les valeurs
+ sort = tab[i];
+ }
+ }
+ //Affichage des valeurs
+ printf("\n%d",ptr_tab[j]);
+ }
+ return ptr_tab;
+}
+
+
+int main(int argc, char *argv[]){
+
+ //Tableau qui contiendra les arguments
+ int tab[argc];
+
+ //Boucle (on commence à 1 pour ne pas prendre le nom du fichier dans nos arguments)
+ for(int i=1; i<argc; i++){
+ //On transforme les char en int et on les entre dans le tableau
+ tab[i-1]=atoi(argv[i]);
+ }
+ //On sort les valeurs
+ int* ptr = sort(tab,argc);
+
+
+}
\ No newline at end of file
diff --git a/pointer_sort.exe b/pointer_sort.exe
new file mode 100644
index 0000000000000000000000000000000000000000..8d039c0d7d3fc7583840abc83733a9b2ef334fe1
Binary files /dev/null and b/pointer_sort.exe differ
diff --git a/pointer_sort.o b/pointer_sort.o
new file mode 100644
index 0000000000000000000000000000000000000000..c662c30c2fe50a7091d2b5d3f1830c3a71cce18c
Binary files /dev/null and b/pointer_sort.o differ