нечетное или четное число с помощью указателя в C

Question

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

Я придумал это:

int main()
{
    int array[10];
    int *arrayPtr = &array;

    int arrayEven[10];
    int *pEven = &arrayEven;

    int arrayOdd[10];
    int * pOdd = &arrayOdd;

    int i, j;

    for(i=0; i<10; i++)
        {

        array[i] =rand()%100 ;




        if(array[i] %2 ==0)
        {
            printf("%d\n", array[i]);
            printf("Even number");
        }
        else
        {
            printf("%d\n", array[i]);
            printf("Odd number");

        }

    }

Answer 1

Эти объявления указателей

int *arrayPtr = &array;
int *pEven = &arrayEven;
int * pOdd = &arrayOdd;

неверны. Инициализаторы имеют тип int( * )[10] в соответствии с объявлениями массивов, например, для переменной array

int array[10];

, тогда как объявленные указатели имеют несовместимый тип int *.

Вам нужны объявления вроде этого

int *arrayPtr = array;

Нет большого смысла определять массивы того же размера, что и исходный массив, потому что, например, исходный массив не может иметь нечетных или четных чисел. Вы должны иметь дело с массивами в зависимости от количества нечетных и четных чисел в исходном массиве. Если ваш компилятор поддерживает массивы переменной длины, вы можете использовать их. Или вы должны динамически распределять массивы.

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

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

void copy_if( const int a1[], size_t n, int *a2, int *a3, int predicate( int ) )
{
    for ( const int *p = a1; p != a1 + n; ++p )
    {
        if ( predicate( *p ) )
        {
            *a2++ = *p;
        }
        else
        {
            *a3++ = *p;
        }
    }
}

size_t count_if( const int a[], size_t n, int predicate( int ) )
{
    size_t  cnt = 0;

    for ( const int *p = a; p != a + n; ++p )
    {
        if ( predicate( *p ) ) ++cnt;
    }

    return cnt;
}

int is_even( int x )
{
    return x % 2 == 0;
}

int main(void) 
{
    enum { N = 10 };
    int a1[N];

    srand( ( unsigned int )time( NULL ) );

    for ( int *p = a1; p != a1 + N; ++p )
    {
        *p = rand() % N;
    }

    for ( const int *p = a1; p != a1 + N; ++p )
    {
        printf( "%d ", *p );
    }

    putchar( '\n' );

    size_t cnt = count_if( a1, N, is_even );

    if ( cnt != 0 && cnt != N )
    {
        int a2[cnt];
        int a3[N-cnt];

        copy_if( a1, N, a2, a3, is_even );

        for ( const int *p = a2; p != a2 + cnt; ++p )
        {
            printf( "%d ", *p );
        }

        putchar( '\n' );

        for ( const int *p = a3; p != a3 + N - cnt; ++p )
        {
            printf( "%d ", *p );
        }

        putchar( '\n' );
    }

    return 0;
}

Вывод программы может выглядеть как

6 3 3 8 3 0 5 5 3 2 
6 8 0 2 
3 3 3 5 5 3 

Если использовать ваш простой подход, то программа может выглядеть следующим образом

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

int main(void) 
{
    enum { N = 10 };
    int array[N];
    int *arrayPtr = array;

    srand( ( unsigned int )time( NULL ) );

    for ( int *p = arrayPtr; p != arrayPtr + N; ++p )
    {
        *p = rand() % N;
    }

    for ( const int *p = arrayPtr; p != arrayPtr + N; ++p )
    {
        printf( "%d ", *p );
    }

    putchar( '\n' );

    int arrayEven[10];
    int *pEven = arrayEven;

    int arrayOdd[10];   
    int *pOdd = arrayOdd;

    int *pEvenEnd = pEven;
    int *pOddEnd  = pOdd;

    for ( const int *p = array; p != arrayPtr + N; ++p )
    {
        if ( *p % 2 == 0 )
        {
            *pEvenEnd++ = *p;
        }
        else
        {
            *pOddEnd++ = *p;
        }
    }

    for ( const int *p = pEven; p != pEvenEnd; ++p )
    {
        printf( "%d ", *p );
    }

    putchar( '\n' );

    for ( const int *p = pOdd; p != pOddEnd; ++p )
    {
        printf( "%d ", *p );
    }

    putchar( '\n' );

    return 0;
}

Ее вывод может выглядеть, например, как

1 0 0 3 4 5 2 1 9 5 
0 0 4 2 
1 3 5 1 9 5 

Answer 2

Вы можете использовать двоичное сравнение, поскольку все нечетные конечные значения sh на 1 в двоичном режиме:

If( a & 1)
//Odd
Else
//Even

Answer 3

Чтобы это работало, вам нужны две дополнительные переменные coutner

int oddCount, evenCount;

. Они должны быть инициализированы равными 0 (т.е. сколько нечетных / четных чисел вы уже добавили). Затем во время итерации первого массива вы увеличиваете соответствующий coutner, если встречаете четное / нечетное число. Также вы можете просто использовать эти переменные, чтобы узнать, куда вам нужно поместить следующее четное / нечетное число в их соответствующем массиве.