Как объединить два массива в единый массив в чередующемся порядке в C?

Question

Я думаю, что я близок к тому, чтобы завершить эту программу, но я не совсем уверен, как продолжить.

В принципе, у меня есть три массива. Массив 3 пуст, а Массив 1 и Массив 2 имеют значения по усмотрению пользователей. Я хочу объединить Array 1 и Array 2 в Array 3 таким образом, чтобы они чередовались между четными и нечетными позициями в Array 3.

Так, например:

Массив 1 = [ 1,2,3,4,5 ]

Массив 2 = [ 10,20,30,40,50 ]

и массив 3 = [0,0,0,0,0,0,0,0,0,0]

Я хочу, чтобы конечный результат выглядел так:

Массив 3 = [ 1 , 10 , 2 , 20 , 3 , 30 , 4 , 40 , 5 , 50 ]

Вот что Я имею в виду, когда я говорю, что я хочу, чтобы Array 1 заполнял нечетных значений , а Array 2 заполнял четных значений .

Это то, что у меня есть соответствующий фрагмент кода пока выглядит так:

void EvenOdd(int n, int *ap1, int *ap2, int *ap3) {
  // "n" is set to 5.
  ap1 = arr1;
  ap2 = arr2;
  ap3 = arr3;
  int i;
  int j;
  int k;
  for (i = 0; i < n * 2; i++) {
    for (j = 0; j < n; j++) {
      if ((i + 1) % 2 != 0)
        ap3[i] = ap1[j];
    }
    for (k = 0; k < n; k++) {
      if ((i + 1) % 2 == 0)
        ap3[i] = ap2[k];
    }
  }
}

arr1, arr2 и arr3 - все глобальные массивы.

Каждый раз, когда я запускаю программу, ей присваиваются только последние значения Массива 1 и Массива 2 позициям в Массив 3, например:

Массив 1 = [ 1,2,3,4,5 ]

Массив 2 = [ 6,7,8,9,10 ]

И массив 3 = [ 5 , * тысяча шестьдесят-девять * 10 , * тысяча семьдесят-один * 5 , * тысяча семьдесят три * 10 * тысяча семьдесят четыре *, 5 , 10 , 5 , 10 , 5 , 10 ]

Это все подсказывает мне, что два для циклов внутри первого продолжайте работать для «i», пока они не достигнут конца своего массива каждый раз, поэтому последние значения последовательно назначаются, но я не уверен, как это исправить, чтобы получить ожидаемый результат.

Answer 1

Проблема:

Вот что я имею в виду, когда говорю, что хочу, чтобы массив 1 заполнял нечетные значения, а массив 2 заполнял четные значения

На самом деле, в случае индексов массив1 заполняет четные индексы, а массив2 заполняет нечетные индексы. К счастью, ваш код работает в этом отношении, потому что вы проверяете четность i + 1, а не i.

Каждый раз, когда я запускаю программу, она назначает только последние значения массива 1 и Массив 2 на позиции в массиве 3, например, так:

il oop отвечает за заполнение целевого массива. Но у вас есть два других вложенных цикла, которые перезаписывают ap[i] снова и снова со значениями в четных и нечетных индексах ap1 и ap2. Последнее значение, которое остается в ap[i], - это когда jl oop и kl oop заканчиваются. Вот почему вы видите повторяющиеся значения, заполненные внутри ap3 с конца ap1 и ap2.

Решение:

Вам просто нужно одно il oop, который заполняет массив назначения после проверки четности i.

for (int i = 0; i < 2 * n; ++i)
    ap3[i] = i % 2 ? ap2[i / 2] : ap1[i / 2];

Answer 2

Я бы go за что-то подобное

void EvenOdd(int n, int*ap1, int*ap2, int*ap3){
// "n" is set to 5.
    ap1=arr1;
    ap2=arr2;
    ap3=arr3;
    int i;
    for(int i = 0; i < 2 * n; i++)
    {
        if(i%2)
            {
                *ap3= *ap2;
                ap1++;
            }
        else
            {
                *ap3= *ap1;
                ap2++;
            }
        ap3++;
    }
}

Answer 3

Другой способ будет

#include <stdio.h>

void EvenOdd(int n, int *ap1, int *ap2, int *ap3) {
  for (int i = 0; i < 2 * n; i++)
    if(i % 2 == 0)
      ap3[i] = ap1[i / 2];
    else
      ap3[i] = ap2[i / 2];
}

int main() {
  int arr1[5] = {1, 2, 3, 4, 5};
  int arr2[5] = {10, 20, 30, 40, 50};

  int arr[10];

  EvenOdd(5, arr1, arr2, arr);

  for (int i = 0; i < 10; i++)
    printf("%d ", arr[i]);

  return 0;
}

Вывод

1 10 2 20 3 30 4 40 5 50 

Answer 4

Вы можете сделать что-то вроде этого:

int ap1[5] = {1, 2, 3, 4, 5};
int ap2[5] = {10, 20, 30, 40, 50};
int ap3[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

int j = 0;
int k = 0;
for (int i = 0; i < 10; i++) {
    if (i % 2 != 0) { // if i is odd
        ap3[i] = ap2[j++]; // set ap3 to jth value in ap2; j becomes j+1
    } else { // if i is even
        ap3[i] = ap1[k++]; // likewise, but ap1 and k becomes k+1
    }
}

for (int i = 0; i < 10; i++) {
    printf("%d ", ap3[i]);
}

Вывод: 1 10 2 20 3 30 4 40 5 50.

Ваша проблема заключается в том, что вложенные циклы являются ненужными и изменяют значения записи, когда вы не хотите их к.