Thread: Even / Odd Issues

Originally Posted by Salem

I call this indented code.

Code:

#include <stdio.h>
#include <stdlib.h>
#define N 9                     /* MAIN */

void revArray(int arr[])
{
  int temp[N];
  int i;

  for (i = 0; i < N; ++i) {
    temp[i] = arr[N - 1 - i];
  }

  for (i = 0; i < N; ++i) {
    arr[i] = temp[i];
  }
}

int *revElement(int arr[])
{
  static int idx = N;
  idx = --idx;
  return arr + idx;
}

void evenOdd(int odd[])
{
  int i;
  int evenTemp[N / 2];
  int oddTemp[(N - 1) / 2];
  char tempOdd;

  for (i = 0; i < N - 1; i++) {
    if (odd[i] % 2 == 0)        /* if even integer */
      evenTemp[i] = odd[i];     /*store even numbers temporary */
    else
      oddTemp[i] = odd[i];      /*store odd numbers temporary */
  }

  for (i = 0; i < (N / 2); ++i) {
    odd[i] = evenTemp[i];       /*swap even numbers first in the array */
    odd[i - N] = oddTemp[i];    /*swap odd numbers last in the array */
  }
}

int main(int argc, char **argv)
{
  int a[N];
  int idx;
  int *p = a;

  while (p < a + N)
    *p++ = a + N - p;

  printf("Original: ");
  p = a;
  while (p < a + N)
    printf("%2d ", *p++);       /* Part A: Reverse the array */

  revArray(a);
  printf("\nReversed: ");
  p = a;
  while (p < a + N)
    printf("%2d ", *p++);
  printf("\n");                 /* Part B: Return elements in reverse order */

  printf("Original: ");
  for (idx = 0; idx < N; idx++) {
    printf("%2d ", *revElement(a));
  }

  printf("\n");                 /* Part C: Put even numbers first, odd numbers last in the array. Order of
                                   the elements is not important as long as all evens are before first odd */

  printf("Even:     ");
  evenOdd(a);
  p = a;
  while (p < a + N)
    printf("%2d ", *p++);

  printf("\n");
  system("pause");
}

Original: 9 8 7 6 5 4 3 2 1
Reversed: 1 2 3 4 5 6 7 8 9
Original: 9 8 7 6 5 4 3 2 1
Even: 2 4 6 8 5 3 7 9 1
What is the order of the odd numbers at the end of the array? It seems entirely random to me.

Code:

  //!! you're assuming an equal balance of even and odd numbers.
  //!! what if the input array was all even numbers?
  int evenTemp[N / 2];
  int oddTemp[(N - 1) / 2];

  for (i = 0; i < N - 1; i++) {
    if (odd[i] % 2 == 0)        /* if even integer */
      //!! you need separate subscripts for each array.
      //!! at the moment, you make two copies of the input array (which overflow both local arrays)
      evenTemp[i] = odd[i];     /*store even numbers temporary */
    else
      oddTemp[i] = odd[i];      /*store odd numbers temporary */
  }

The order of the numbers at the end do not matter, as long as all the even come first.

Originally Posted by Salem

Original: 9 8 7 6 5 4 3 2 1
Reversed: 1 2 3 4 5 6 7 8 9
Original: 9 8 7 6 5 4 3 2 1
Even: 2 4 6 8 5 3 7 9 1
What is the order of the odd numbers at the end of the array? It seems entirely random to me.

The order doesnt matter, as long as the even numbers come first, followed by the odd