Even / Odd Issues

The even/odd function does not work...here is what I have so far. Everything works except for the evenodd function. I am supposed to get the even numbers to list first, then the odd numbers. It should look like this:

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

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)/2; i++)
{
if(odd[i]%2 == 0)
/* if even integer*/
evenTemp[i] = odd[i];
/*store even numbers temporary */
elseoddTemp[i]= odd[i];
/*store odd numbers temporary */
}
for(i=0; i<(N-1)/2; i++)
{
odd[i]=evenTemp[i];
/*swap even numbers first in the array*/
odd[N-1-i]=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");
}

---

SourceForge.net: Indentation - cpwiki
Your code has no indentation, so as a result it's too hard to follow the flow easily (for us, AND for you).

is this better?

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");
}

---

Quote:

---

that does not help

---

To the contrary. It helps everyone else undestand your code so they are more likely to help debug it. I am not going to lie I looked at this post over an hour ago and saw there was no indentation as Salem has suggested and I immediately hit the Back key.

Proper indentation will help you alot.

Quote:

---

Originally Posted by akemi.kanegae

that does not help

---

If you're expecting knowledgeable people to help you, for free - could you at least meet them half way, put in some effort, and make it presentable? Demanding help is not a good way to get assistance from those who are willing to volunteer their time for you.

Edit: Lesshardtofind beat me to it. And I had the same reaction they describe in their third sentence.

I did not mean it that way, I meant that it did not help me when I indented it. Not that your information was not helpful. I do not know proper indentation. I re-read what I posted and changed it. It sounded really rude. I apologize. I did not know that proper indentation was needed. Did I do it correctly now? I am unsure. Again, I am sorry for sounding rude. I did not mean it that way at all.

Sorry Salem, I did not mean to sound rude. I indented my program, is that way better? Or did I not do it correctly? Please let me know if I need to change it again.

I really do appreciate all of your help. I did not mean it sound rude :( Im sorry everyone.

It's okay, if it's a misunderstanding. I don't think anyone is snubbing you - it does take some time to study a program, after all.

Ok. I appreciate your reply. Did I indent the program correctly after I edited it?

Code:

---

void evenOdd(int odd[])     
{           
  int i;           
  int evenTemp[N/2];  // size 9/2        or 4
  int oddTemp[(N-1)/2];  // size 8/2    also 4       
  char tempOdd;           
  for(i=0; i < N-1 ; i++)             
  {                     
    if(odd[i]%2 == 0) /* if even integer*/                     
      evenTemp[i] = odd[i]; // <---- What happens here when the loop has run 8 times but you store a variable into the 7th
                                    //          address in array with a size of 4                   
    else                     
      oddTemp[i]= odd[i]; /*store odd numbers temporary */  <--- same problem
  }       
  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 */               
  }             
}

---

Second time in an hour that Lesshardtofind beat me to the punch :)

And your indentation could be better - but notice how fast you got an answer when the code was somewhat more readable.

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 */
  }

---

Thank you for helping. How can I solve the problem? Do I need to mess with the eventemp[N/2] and oddTemp[(N-1)/2] so they are not the same? and also my if / else loop?

Quote:

---

Originally Posted by Matticus

Second time in an hour that Lesshardtofind beat me to the punch :)

And your indentation could be better - but notice how fast you got an answer when the code was somewhat more readable.

---

Thank you :) I see that. I will work on my indentation!!

Quote:

---

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.

Code:

---

Original: 9 8 7 6 5 4 3 2 1
Even: 2 4 6 8 5 3 7 9 1

---

One way you could do it by hand.

look for leftmost odd value swap with rightmost even value

Code:

---

9 8 7 6 5 4 3 2 1
2 8 7 6 5 4 3 9 1
2 8 4 6 5 7 3 9 1

---

Tim S.

You could add two integers being an evencount and an oddcount to increment when you save into the respective arrays.

Code:

---

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

---

You still need to look at why your two arrays add up to 8 in size but your final array needs 9 numbers

Quote:

---

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