CONTROLE_DEV51_kara-mosr/EX1.c

/*Je me suis pas super bien organise le fichierest long pour rien le main est trop long
Je me suis lancer dans l'utilisation d'allocation et de pointeur ce qui etat peut etre pas necessaire
j'ai essayer de commenter et de bien expliquer dans reponses.txt pour que ca reste comprehensible
Et puis dans le main j'ai mis pas mal de printf qui devrait aider la comprehension a l'execution

Pour compiler :
gcc -pg -o ex1 EX1.c
./ex1
gprof ./ex1

Riad Kara-Mostefa
*/


#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>


int racineCarree(int n) {
    if (n < 0) return -1;
    if (n == 0 || n == 1) return n;

    int i = 1;
    while (i <= n / i) {
        if ((n % i == 0) && (i == n / i)) {
            return i;
        }
        i++;
    }
    return -1;
}

void racineCarreeTab(const int *in, int *out, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        out[i] = racineCarree(in[i]);
    }
}

static void affichageTab(const char *label, const int *t, size_t n) {
    printf("%s[", label);
    for (size_t i = 0; i < n; ++i) {
        if (i) printf(",");
        printf("%d", t[i]);
    }
    printf("]\n");
}


static void affichageTabLL(const char *label, const long long *t, size_t n) {
    printf("%s[", label);
    for (size_t i = 0; i < n; ++i) {
        if (i) printf(",");
        printf("%lld", t[i]);
    }
    printf("]\n");
}


void TriSpecial(const int *in, size_t n, long long *out) {
    if (!in || !out || n == 0) return;
/*some original et some des racines*/
    long long SommeOrigine = 0;
    long long SommeSqrt = 0;
    size_t nbNonEntieres = 0;
/* tab avec les racines carees*/
    int *roots = (int*)malloc(n * sizeof(int));
    if (!roots) {
        for (size_t i = 0; i < n; ++i) {
            int r = racineCarree(in[i]);
            SommeOrigine += (long long)in[i];
            SommeSqrt += (long long)r;
            if (r == -1) ++nbNonEntieres;
        }
        roots = NULL;
    } else {
        for (size_t i = 0; i < n; ++i) {
            int r = racineCarree(in[i]);
            roots[i] = r;
            SommeOrigine += (long long)in[i];
            SommeSqrt += (long long)r;
            if (r == -1) ++nbNonEntieres;
        }
    }

    const int pair = ((nbNonEntieres % 2) == 0);

    if (pair) {
        for (size_t i = 0; i < n; ++i) {
            if ((i % 2) == 0) out[i] = (long long)in[i];
            else              out[i] = SommeOrigine * (long long)in[i];
        }
    } else {
        for (size_t i = 0; i < n; ++i) {
            if ((i % 2) == 0) {
                int r = roots ? roots[i] : racineCarree(in[i]);
                out[i] = (long long)r;
            } else {
                out[i] = SommeSqrt * (long long)in[i];
            }
        }
    }

    free(roots);
}

int main(void) {
    printf("EX1 : tests simples\n");
    printf("racineCarree(9)  = %d\n",  racineCarree(9));
    printf("racineCarree(10) = %d\n", racineCarree(10));

    int t1[] = {9,25,4};
    int r1[3];
    racineCarreeTab(t1, r1, 3);
    affichageTab("racineCarreeTab([9,25,4]) = ", r1, 3);

    int t2[] = {10,36,2};
    int r2[3];
    racineCarreeTab(t2, r2, 3);
    affichageTab("racineCarreeTab([10,36,2]) = ", r2, 3);

    /* le gros tableau de test comme demande dans l'exo2 */
    printf("\nEX2 : gros tableau (racineCarreeTab) \n");
    const size_t N = 10000;
    int *big = (int*)malloc(sizeof(int) * N);
    int *res = (int*)malloc(sizeof(int) * N);
    /*je verifie l'allocation memeoire*/
    if (!big || !res) {
        fprintf(stderr, "Allocation echouee pour EX2\n");
        free(big); free(res);
        return 1;
    }

    /* J'ai essaye de genere des carre parfait et des non-carres on va dire pour tester */
    for (size_t i = 0; i < N; ++i) {
        int base = 1000000 + (int)(i * 1237);
        if (i % 997 == 0) {
            int s = 2000 + (int)(i % 500);
            base = s * s;
        }
        big[i] = base;
    }

    racineCarreeTab(big, res, N);
    printf("res (debut 10) = [");
    for (size_t i = 0; i < 10 && i < N; ++i) {
        if (i) printf(",");
        printf("%d", res[i]);
    }
    if (N > 10) printf(", ...]");
    printf("\n");

    printf("\n EX3 : tests TriSpecial\n");
    {
        int a1[] = {3,5,25,16};
        long long out1[4];
        TriSpecial(a1, 4, out1);
        affichageTabLL("TriSpecial([3,5,25,16]) = ", out1, 4);
    }
    {
        int a2[] = {36,9,100,2,3,7};
        long long out2[6];
        TriSpecial(a2, 6, out2);
        affichageTabLL("TriSpecial([36,9,100,2,3,7]) = ", out2, 6);
    }

    /* On utilise un gros tableau comme demandéé dans l'exo4 */
    printf("\nEX4 : gros tableau (TriSpecial)\n");
    /*la sortie pour le long tableau de gros elements*/
    long long *sortieLL = (long long*)malloc(sizeof(long long) * N);
    if (!sortieLL) {
        fprintf(stderr, "Allocation echouee pour EX4 (sortieLL)\n");
        free(big); free(res);
        return 1;
    }

    TriSpecial(big, N, sortieLL);
    /*Je me suis dit que 10 elements suffisait pour voir si on a le resultat attendu donc j'en affiche que 10*/
    printf("TriSpecial(big) (debut 10) = [");
    for (size_t i = 0; i < 10 && i < N; ++i) {
        if (i) printf(",");
        printf("%lld", sortieLL[i]);
    }
    if (N > 10) printf(", ...]");
    printf("\n");

    /* Nettoyage */
    free(sortieLL);
    free(big);
    free(res);

    return 0;
}