From 684194909504d61662b20a7df8ecaa44df773e2a Mon Sep 17 00:00:00 2001
From: Lucas <lucas.morel@epita.fr>
Date: Mon, 2 Feb 2026 03:36:21 +0100
Subject: [PATCH] archi124

---
 .../Fundamentals/most_frequent.c              |  76 ++++++++++++++++
 Digby_Real_Estate/Fundamentals/my_factor.c    |  43 ++++++++++
 Digby_Real_Estate/Fundamentals/my_strapp.c    |  60 +++++++++++++
 Digby_Real_Estate/Fundamentals/my_weirddup.c  |  55 +++++++-----
 Digby_Real_Estate/Fundamentals/replace.c      |  73 ++++++++++++++++
 Digby_Real_Estate/Fundamentals/test           | Bin 16032 -> 0 bytes
 Digby_Real_Estate/Fundamentals/trap_sweeper.c |  81 ++++++++++++++++++
 7 files changed, 365 insertions(+), 23 deletions(-)
 delete mode 100755 Digby_Real_Estate/Fundamentals/test

diff --git a/Digby_Real_Estate/Fundamentals/most_frequent.c b/Digby_Real_Estate/Fundamentals/most_frequent.c
index e69de29..85d010c 100644
--- a/Digby_Real_Estate/Fundamentals/most_frequent.c
+++ b/Digby_Real_Estate/Fundamentals/most_frequent.c
@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+//###############################
+// ATTENTION CE CODE EST  MOCHE #
+//###############################
+
+char most_frequent(const char *str){
+    
+    //max
+    //temp max
+    //
+    //lettre
+    //temp lettre
+    //index
+    //index_clc
+
+
+    char *cha = malloc(2 * sizeof(char));
+    //{ lettre, temp}
+    if (cha == NULL) return 0;
+
+    *cha = 0; // lettre 
+    *(cha + 1) = 0; //lettre pendant le clc
+
+    int *values = malloc (4 * sizeof(int));
+    if(values == NULL) return 0 ;
+    //{ max, temp max, index, index_clc}
+   
+    *values = 0;       // Maximum
+    *(values + 1) = 0; // Max temporaire
+    *(values + 2) = 0; // Index de la chaine 
+    *(values + 3) = 0; // Index de calcul
+    
+    //deplacement (index de la chaine)
+    while (*(str + *(values + 2)) != '\0'){
+        
+        *(cha + 1) = *(str + *(values + 2)); //Traitement de la lettre à l'index x 
+        *(values + 1) = 0; // RESET du max de clc
+        *(values + 3) = 0; // RESET de l'index de clc
+        
+        //calcul pas du tt opti mais bon
+        while (*(str + *(values + 3)) != '\0'){
+
+            //si la lettre en traitment est la mm que celle rencontree
+            if (*(cha + 1) == *(str + *(values + 3))) {
+                (*(values + 1)) ++;
+            }
+            
+            (*(values + 3)) ++;
+        }
+
+        if (*values < *(values + 1)) {
+            *values = *(values + 1); // temp -> max
+            *cha = *(cha + 1);
+        }
+
+        (*(values + 2)) ++;
+    }
+    free(values);
+    return *cha;
+}
+/*
+int main () {
+
+    char test = most_frequent("WRYYYY!1!");       // 'Y'
+    printf("%c\n", test);
+
+    test = most_frequent("ORA ORA ORA!");    // 'O'
+    printf("%c\n",test);
+    test = most_frequent("hello warudo!");   // 'l'
+    printf("%c\n", test);
+    most_frequent("oRA ora oRa?");    // 'o'
+
+
+}*/
diff --git a/Digby_Real_Estate/Fundamentals/my_factor.c b/Digby_Real_Estate/Fundamentals/my_factor.c
index e69de29..813afd2 100644
--- a/Digby_Real_Estate/Fundamentals/my_factor.c
+++ b/Digby_Real_Estate/Fundamentals/my_factor.c
@@ -0,0 +1,43 @@
+#include <stdlib.h>
+#include <stdio.h>
+//utiliser la recu ?
+//possible mais avec fct aux
+//malloc dans my_factor puis appelle aux (poineur, n)
+int *my_factor(int n){
+
+    if (n <= 0) return NULL;
+    if (n == 1) return 1;
+
+    int cnt = 0;
+    int tmp = n;
+    int div = 2;
+
+    while(tmp > 1){
+        if (tmp % div == 0){
+        cnt ++;
+        tmp = tmp /div
+        }
+        else div ++;
+    }
+
+    int *rslt = malloc((cnt + 1)* sizeof(int));
+    if(rslt == NULL) return NULL;
+    
+    int index = 0;
+    int *kebab = rslt;
+    tmp = n;
+    div = 2;
+    
+    while (temps > 1) {
+        if (tmp % div == 0){
+            *(kebab + index) = div;
+            index ++;
+            tmp = tmp /  div;
+        }
+        else div ++;
+    }
+
+    *kebab = 0;
+    return rslt;
+    
+}
diff --git a/Digby_Real_Estate/Fundamentals/my_strapp.c b/Digby_Real_Estate/Fundamentals/my_strapp.c
index e69de29..f18cabe 100644
--- a/Digby_Real_Estate/Fundamentals/my_strapp.c
+++ b/Digby_Real_Estate/Fundamentals/my_strapp.c
@@ -0,0 +1,60 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+char *strdup(const char *s); 
+
+
+void my_strapp(char *src, char **dest){  
+
+    if (src == NULL || dest == NULL) return;
+
+    //taille src
+    int index = 0;
+    while (*(src + index)) index ++;
+    
+    //taille desti
+    int index_dest = 0;
+    while (*(*dest + index_dest)) index_dest ++;
+
+    //realloc des dest avec la taille de src
+    *dest = realloc(*dest, index + index_dest + 1);
+    //int *dest = realloc(*dest, index);
+    
+    if (dest == NULL) return;
+
+    index = 0;
+    /*while(*(new + index_dest)){ 
+        
+        printf("%c", *(new + index_dest));
+
+        index_dest ++;
+    }
+    printf("\n");
+    //index_dest --;
+    while(*(src + index)){
+
+        *(new + (index_dest+ index)) = *(src + index);
+        index ++;
+    }*/
+ 
+    while(*(src + index)){
+        *(*dest + index_dest + index) = *(src + index);
+        index ++;
+    }
+
+    *(dest + index_dest + index + 1) = '\0';
+
+
+}
+/*
+int main(){
+    
+    char *src = strdup("World!");
+    char *dest = strdup("Hello, ");
+    char **dest_ptr = &dest;
+    
+    my_strapp(src, dest_ptr); // Hello, World!
+    printf("%s", *dest_ptr);
+    free(src);
+    free(dest);
+}*/
diff --git a/Digby_Real_Estate/Fundamentals/my_weirddup.c b/Digby_Real_Estate/Fundamentals/my_weirddup.c
index 7f6f815..04ca12a 100644
--- a/Digby_Real_Estate/Fundamentals/my_weirddup.c
+++ b/Digby_Real_Estate/Fundamentals/my_weirddup.c
@@ -6,45 +6,54 @@ char *my_weirddup(char *src){
     if(src == NULL) return NULL;
 
     int index = 0;
-    while(*(src)){
+    while(*(src + index)){
         index ++;
-        src ++;
     }
     
-    char *str =  malloc(index + 1);
+    char *str =  malloc(index);
     if(str == NULL) return NULL; 
     
-    //src = 0;
+    //printf("test");
     
     char lettre = ' ';
     index = 0;
-    
-    while (*src){
-        lettre = *src;
 
-        //maj
+    while (*(src + index) != '\0'){
+
+        lettre = *(src + index);
+
+        //MAJ
         if (lettre > 64 && lettre < 91){
             if (lettre == 'Z') lettre = 'A';
-            else lettre += 1;
+            else lettre ++;
         }
-
+    
         //min
-        else if (lettre > 97 && lettre < 124 ){
-            
-            if (lettre == 'z')lettre = 'a';
-            else lettre += 1;    
+        if (lettre > 96 && lettre < 124) {
+            if (lettre == 'z') lettre = 'a';
+            else lettre ++;
         }
 
-        *str = lettre;
-        src ++;
-        str ++;
+        *(str + index) = lettre;
+        index ++;
     }
-
+    
+    *(str + index + 1) = '\0';
     return str;
-}
-
-int main(){
-
-    printf("%s",my_weirddup("abb"));
+
+}
+//TODO MARCHE MAIS À COMPLETER
+
+int main(int args ,char **arg){
+
+    int index = 1;
+    char *rslt = "";
+    
+    while(index < args){
+        rslt = my_weirddup(*(arg + index));
+        printf("%s\n",rslt);
+        free(rslt);
+        index ++;
+        }
 
 }
diff --git a/Digby_Real_Estate/Fundamentals/replace.c b/Digby_Real_Estate/Fundamentals/replace.c
index e69de29..2dd5dff 100644
--- a/Digby_Real_Estate/Fundamentals/replace.c
+++ b/Digby_Real_Estate/Fundamentals/replace.c
@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+char *replace(char *str, char *sub){
+
+    //clc taille sub
+    //nbr * x taille sub
+
+    int len_fin = 0;
+
+    //clc taille str
+    int index = 0;
+    int nb_etoile = 0;
+    while( *(str + index)){
+        if ( *(str + index) == '*') nb_etoile ++;
+
+        index ++;
+
+    }
+    len_fin = index;
+    
+    //clc taille sub
+    index = 0;
+    while (*(sub + index)) index ++;
+
+    //longueur finale
+    len_fin += nb_etoile * index;
+    
+
+    char *rslt = malloc(len_fin);
+    if (rslt == NULL) return  NULL;
+        
+    index = 0;
+    int index_str = 0;
+    int index_sub = 0;
+    //parcours total
+    while(*(str + index_str)){
+        
+        index_sub = 0;
+        //si le char est une etoile
+        if (*(str + index_str) == '*'){
+            //copie de sub dans rslt
+            while(*(sub + index_sub)){
+                *(rslt + index) = *(sub + index_sub);
+                index_sub ++;
+                index ++;
+            }
+            
+        }
+        else{
+            *(rslt + index) = *(str + index_str);
+            index ++;
+        }
+        index_str ++;
+
+    }
+
+    return rslt;
+
+}
+
+/*
+int main(){
+    
+    
+    char *test =replace("Hello *", "World!");     // Hello World!
+    printf("%s\n", test);
+    free(test);
+    //printf("ici");
+    test = replace("*H*e*l*l*o*", "BIM");    // BIMHBIMeBIMlBIMlBIMoBIM
+    printf("%s\n", test);
+    free(test);
+}*/
diff --git a/Digby_Real_Estate/Fundamentals/test b/Digby_Real_Estate/Fundamentals/test
deleted file mode 100755
index 7a008584637f8070feecec70ac7120b0f685d046..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16032
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
J@EQ16@h?lijoJVJ

diff --git a/Digby_Real_Estate/Fundamentals/trap_sweeper.c b/Digby_Real_Estate/Fundamentals/trap_sweeper.c
index e69de29..016d76c 100644
--- a/Digby_Real_Estate/Fundamentals/trap_sweeper.c
+++ b/Digby_Real_Estate/Fundamentals/trap_sweeper.c
@@ -0,0 +1,81 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int **trap_sweeper(char **mat, int rows, int cols){
+    //Vraiment la merde les matrices
+    int **mat_clc = malloc(rows * sizeof(int));
+    if (mat_clc == NULL) { return NULL;}
+
+    // index, x, temp
+    // le y = rows actuel
+    int *values = calloc(5,sizeof(int));
+    if (values == NULL) { free(mat_clc); return NULL;}
+    //0 -> x
+    //1 -> y
+    //2 -> xt
+    //3 -> yt 
+    //4 -> count
+    
+    *(values + 1) = 0;
+
+    while (*(values + 1 ) < rows){
+
+        *(mat_clc + *(values + 1)) = calloc(cols, sizeof(int));
+        *values = 0;
+
+        while(*values < cols){
+            
+            if ( *( *(mat + *(values + 1)) + *values) == '#'){
+            
+                *( *(mat_clc + *(values + 1)) + *values) = -1;
+
+            }
+            else {
+
+                *(values + 4) = 0;
+                *(values + 3) = *(values + 1) - 1;
+
+                while (*(values + 3) <= *(values + 1) + 1){
+                    
+                    *(values + 2) = *values - 1;
+                    while (*(values + 2) <= *values + 1){
+                        
+                        if(*(values + 3) >= 0 && *(values + 3) < rows && *(values + 2) >= 0 && *(values + 2) < cols) {
+                    
+                            if(*( *(mat + *(values + 3)) + *(values + 2)) == '#') (*(values + 4)) ++;
+                        }
+                        (*(values + 2)) ++;
+                    }
+                    (*(values + 3)) ++;
+                }
+                *(*(mat_clc + *(values + 1)) + *values) = *(values + 4);
+            }
+            (*values) ++;
+        }
+        (*(values + 1)) ++;
+    }
+    
+    return mat_clc;
+
+}
+/*
+int main()
+{
+    char *mat1[] = {
+        "OOO#O",    // 1  1  2 -1  2
+        "#OO#O",    //-1  3  4 -1  2
+        "O##OO",    // 2 -1 -1  3  2
+        "OOOO#"     // 1  2  2  2 -1
+    };
+    int **res = trap_sweeper(mat1, 4, 5);
+    for (int i = 0; i < 4; ++i)
+    {
+        for (int j = 0; j < 5; ++j)
+            printf("%d ", res[i][j]);
+        printf("\n");
+    }
+
+    for (int i = 0; i < 4; ++i)
+        free(res[i]);
+    free(res);
+}*/