Done

alloc_mem.c

@@ -9,15 +9,21 @@
 
 
 int main(){
+    for (int i = 0; i != 100; i++) {
 
         srand(time(NULL));
 
-    int size = 0;
-    printf("Saisire la taille du tableau souhaitée ?\n");
-    scanf("%d", &size);
+        int size = nb_alea(20);
+        //printf("Saisire la taille du tableau souhaitée ?\n");
+        //scanf("%d", &size);
         printf("-----------------------------\n");
         
+        //malloc
         int *tab = malloc(size * sizeof(int));
+        int *tab_two = malloc(size * sizeof(int));
+        int *tab_three = malloc(size * sizeof(int));
+        int *tab_four = malloc(size * sizeof(int));
+        double *tab_five = malloc(size * sizeof(int));
 
         //int count = 0;
         
@@ -33,14 +39,54 @@ int main(){
         printf("-----------------------------\n");
 
         //Etapes 5 : Permu Cyclique
-    int deca = 0;
-    printf("Entre le decalage souhaité\n");
-    scanf("%d", &deca);
+        int deca = nb_alea(20);
+        //printf("Entre le decalage souhaité\n");
+        //scanf("%d", &deca);
         printf("-----------------------------\n");
 
         permu_cyclique(tab, size, deca);
         printf("-----------------------------\n");
 
+        //Etape 6 : minimum to last position  
+        min_to_last(tab, size);
+        printf("-----------------------------\n");
+
+        //Etape 7 : max to min with insertion
+        max_to_min(tab, size);
+        printf("-----------------------------\n");
+
+        //Etape 8 : count nb user input
+        int nb_counter = nb_alea(20);
+        //printf("Entrez nombre pour chercher compter plus petit.");
+        //scanf("%d", &nb_counter);
+        nb_count(tab, size, nb_counter);
+        printf("-----------------------------\n");
+
+        //Etape 9 : second malloc  -> tab + tab 2 = tab 3
+        fill_tab(tab_two, size); // remplir tab 2 comme tab1
+        //print_tab(tab_two, size); poru check 
+        sum(tab, tab_two, tab_three, size);
+        printf("-----------------------------\n");
 
+        //Etape 10 : tab four fill multi with n
+        int n = nb_alea(20);
+        //printf("Saisir le nombre multiplicateur.\n");
+        //scanf("%d", &n);
+        multi_element(tab_three, tab_four, size, n);
+        printf("-----------------------------\n");
+
+        //Etape 11 : tab to double 
+
+        tab_double(tab_four, tab_five, size);
+        printf("-----------------------------\n");
+        
+        //liberation tableau
         free(tab);
+        free(tab_two);
+        free(tab_three);
+        free(tab_four);
+        free(tab_five);
+    }
+
+    return EXIT_SUCCESS;
 }
\ No newline at end of file

lib_alloc.c

@@ -3,9 +3,17 @@
 #include <math.h>
 #include <stdint.h>
 #include <string.h>
+#include <time.h>
 
 #include "lib_alloc.h"
 
+int nb_alea(int max){
+
+    int nb = rand() % max+1;
+    
+    return nb;
+}
+
 void fill_tab(int *tab, int size){
     
     for (int i = 0; i < size; i++)
@@ -45,18 +53,117 @@ void permu_alea(int *tab, int size){
 
 void permu_cyclique(int *tab, int size, int deca){
 
-    for(int i = 0; i < deca; i++){
+    int32_t *tmp = malloc(size * sizeof(int32_t));
+
+    for (int32_t i = 0; i < size; i++)
+    {
+        tmp[(i+deca)%size] = tab[i];
+    }
+    for (int32_t i = 0; i < size; i++)
+    {
+        tab[i] = tmp[i];
+    }
+    free(tmp);
+
+    print_tab(tab, size);
+}
+
+void min_to_last(int *tab, int size){
 
-        int tmp = tab[size-1];
+    int i_min = 0;
+    int min = tab[0];
 
-        for(int j = size-1; j != 0; j++){   
+    for(int i = 0; i < size; i++){
 
-            tab[j] = tab[j-1];
+        if(tab[i]<min){
             
+            tab[i] = min;
+            i_min = i;
         }
-        tab[0] = tmp;
+    }
+
+    int i_end = size-1;
+    int val_end = tab[i_end];
 
+    tab[i_end] = min;
+    tab[i_min] = val_end;
+
+    print_tab(tab, size);
+}
+
+void max_to_min(int *tab, int size){
+
+    int tmp;
+
+    for(int i = 1; i < size; i++){
+        int j = i;
+        while(j > 0 && tab[j-1] < tab[j]){
+            tmp = tab[j];
+            tab[j] = tab[j-1];
+            tab[j-1] = tmp;
+
+            j--;
+
+        }
     }
 
     print_tab(tab, size);
 }
+
+void nb_count(int *tab, int size, int nb_counter){
+
+    int count = 0;
+    
+    //on trie d'abord
+    max_to_min(tab, size);
+
+    for(int i = 0; i< size; i++){
+
+        if(tab[i]<nb_counter){
+            count += 1;
+        }
+    }
+
+    printf("Il y a %d plus petit que %d", count, nb_counter);
+
+}
+
+void sum(int *tab, int *tab_two, int *tab_three, int size){
+
+    for(int i = 0; i<size; i++){
+
+        tab_three[i] = tab[i] + tab_two[i];
+    }
+
+    print_tab(tab_three, size);
+}
+
+void multi_element(int *tab_three, int *tab_four, int size, int n){
+
+    for(int i = 0; i<size; i++){
+
+        tab_four[i] = tab_three[i] * n ;
+
+    }
+    print_tab(tab_four, size);
+}
+
+void tab_double(int *tab_four, double *tab_five, int size){
+
+    for(int i = 0; i< size; i++){
+
+        tab_five[i] = (double)tab_four[i];
+
+    }
+     print_tab_double(tab_five, size);
+}   
+
+void print_tab_double(double *tab, int size){
+    
+    for (int i = 0; i < size; i++)
+    {
+        double tmp = tab[i];
+
+        printf("%d -- %lf\n", i, tmp);
+    }
+}
\ No newline at end of file

lib_alloc.h

@@ -7,5 +7,13 @@ void print_tab(int *tab, int size);
 void change(int *a, int *b);
 void permu_alea(int *tab, int size);
 void permu_cyclique(int *tab, int size, int deca);
+void min_to_last(int *tab, int size);
+void max_to_min(int *tab, int size);
+void nb_count(int *tab, int size, int nb_counter);
+void sum(int *tab, int *tab_two, int *tab_three, int size);
+void multi_element(int *tab_three, int *tab_four, int size, int n);
+void tab_double(int *tab_four, double *tab_five, int size);
+void print_tab_double(double *tab, int size);
+int nb_alea(int max);
 
 #endif
\ No newline at end of file