Comment ajouter des éléments d'un tableau dans un autre tableau d'une taille indéfinie en fonction d'une condition?

Il n’existe aucun moyen magique d’obtenir ces informations en un seul coup . Vous pouvez cependant essayer l'une des méthodes ci-dessous:

• Faites une boucle sur le premier tableau pour déterminer le nombre de nombres impairs (ou pairs), puis, vous connaissez le nombre d'éléments pour lesquels la mémoire doit être allouée, et vous pouvez utiliser soit un VLA (comme le premier tableau lui-même) ou utilisez un pointeur et des fonctions d'allocation pour allouer de la mémoire.

  -> Cependant, dans ce processus, vous devez effectuer deux fois le contrôle impair / pair - une fois pour compter l'occurrence de nombres pairs / impairs et la fois suivante, pour les décider et les copier dans les nouveaux emplacements.

• Allouez deux blocs de mémoire similaires à la taille du premier tableau et commencez à remplir respectivement les éléments impairs et pairs dans la nouvelle mémoire. Une fois tous les éléments stockés, prenez les décomptes, realloc () les mémoires allouées à la taille exacte.

  -> Dans ce cas, la pré-allocation est à faire, mais le contrôle impair / pair ne doit être effectué qu'une seule fois.

Vous pouvez copier dans les tableaux impairs / pairs et conserver des compteurs séparés pour le suivre. c'est-à-dire:

  //loop goes through array, separates even and odds into 2 new arrays----------
  //use dynamic allocation??

  int evencount =0;
  int oddcount =0;
  int *evenarray = malloc(sizeof(evenarray)); //not sure if this is setup correctly
  int *oddarray = malloc(sizeof(oddarray)); //not sure if this is setup correctly
  for(i=0;i<n;i++)
  {
    if(array[i] % 2 == 0) //if value in array CAN be divided by 2
    {
      printf("Printing to even array.\n");
      evenarray[evencount] = array[i];
      evencount++;
    }
    else //if this is not true, append to odd array
    {
      printf("Printing to odd array.\n");
      oddarray[oddcount] = array[i];
      oddcount++;
    }
  }

  printf("evenarray = ");
  for(i=0;i<evencount;i++){
    printf("%d, ", evenarray[i]);
  }
  printf("\n");
  printf("oddarray = ");
  for(i=0;i<oddcount;i++){
    printf("%d, ", oddarray[i]);
  }
  printf("\n");

Je vois quelques problèmes ici. Vous ne devez pas définir de tableaux avec une valeur non constante, telle que la variable n que vous avez demandé à l'utilisateur de saisir.

Habituellement, lorsque vous définissez un tableau avec une valeur constante, il y aura exactement autant d'espaces créés pour votre tableau. Regardons ceci par exemple:

How many numbers? 5
What are the numbers?
1
2
3
4
5

Original array: 1 2 3 4 5
Odd array: 1 3 5
Even array: 2 4

Nous venons de créer un tableau d'entiers avec une constante définie comme MAX avec 100 espaces non définis, mais en utilisant une boucle for, nous avons réussi à remplir le lacunes dans les n premiers index. Si n vaut 20 par exemple, les 80 autres espaces seront laissés sous forme de valeurs aléatoires extraites de la mémoire (corbeille très probablement, -84134 ...). C'est aussi de la mémoire statique , utilisée par la pile.

C'est bien mais vous pouvez cependant allouer dynamiquement suffisamment d'espace (espace comme en termes simples, emplacements mémoire) avec le fonction appelée malloc () pour vous assurer que vous avez juste assez pour n nombres.

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

int main() {
    int n;

    printf("How many numbers? ");
    scanf("%d", &n);

    int i, odd = 0, even = 0, counter_odd = 0, counter_even = 0;
    int *array = (int*)malloc(n * sizeof(int));

    printf("What are the numbers?\n");
    for(i = 0; i < n; i++) scanf("%d", &array[i]);

    // Counting how many odd and even numbers there are
    for(i = 0; i < n; i++) {
        if(array[i] % 2) odd++;
        else even++; 
    }
    int *even_array = (int*)malloc(sizeof(int) * even);
    int *odd_array = (int*)malloc(sizeof(int) * odd);

    // Placing the numbers in separate arrays
    for(i = 0; i < n; i++) {
        if(array[i] % 2) odd_array[counter_odd++] = array[i];
        else even_array[counter_even++] = array[i]; 
    }

    // Printing them out
    printf("\nOriginal array: ");
    for(i = 0; i < n; i++) printf("%d ", array[i]);

    printf("\nOdd array: ");
    for(i = 0; i < odd; i++) printf("%d ", odd_array[i]);

    printf("\nEven array: ");
    for(i = 0; i < even; i++) printf("%d ", even_array[i]);

    return 0;
}

Nous avons maintenant utilisé la fonction malloc () pour créer juste assez d'espace. Malloc est utilisé pour allouer de la mémoire dynamique sur le tas, et non sur la pile.

La définition de la fonction elle-même est la suivante:

int *array = (int*)malloc(n * sizeof(int));

malloc () renvoie un pointeur vide vers un nouveau bloc de mémoire que vous lui avez dit de créer. Il n'a qu'un seul paramètre et c'est la taille du nouveau bloc en octets, qui est calculée en prenant le nombre "d'espaces" que vous voulez et en les multipliant à l'aide de l'opérateur sizeof .

Le pointeur vers le nouveau bloc de mémoire doit cependant être converti dans le type approprié, et dans ce cas, il s'agit d'un pointeur entier.

void *malloc(size_t size)

Donc, le moyen le plus simple de le mettre est: faites un pointeur -> demandez à malloc d'allouer dynamiquement la mémoire pour vous -> lancez-le dans le type approprié, et voilà, vous avez votre tableau avec juste assez d'espaces.

Maintenant, allons-y à la tâche elle-même: je commencerais par compter le nombre de nombres pairs et impairs, en les stockant dans des variables entières séparées et en allouant dynamiquement suffisamment d'espace pour cette quantité de nombres pairs et impairs.

Solution finale :

  int n;
  printf("How many numbers? ");
  scanf("%d", &n);

  // User inputs values into array the size of array[n]
  int i;
  int *array = (int*)malloc(n * sizeof(int));
  printf("What are the numbers?\n");
  for(i=0; i<n; i++) scanf("%d", &array[i]);

Et le cas de test:

#define MAX 100
<...>
int array[MAX];
int n;
scanf("%d", &n);
for(int i = 0; i < n; i++) scanf("%d", &array[i]);
<...>