Stuck on code about arrays and moving digits in it - c

Question

There are two arrays:
s: 7 3 6 2 8
c: 0 12 5 23 14
new array: 8 3 7 6 2
Basically, you look at array c and if it has an even number, you print the one from the array s. For example, 14 is even so you print 8. You need to print them in that order, from right to left.
So I read the first two arrays, but I don't know how to put the rest of the code. If you put:
array s: 1 2 3
array c: 4 4 4
you will get: 3 2 1, which we need, but if I put 1 odd number, I will get some error number. I don't know how to put the rest of array s, after I put the even numbers.
for(d=0; d<ns; d++)
{
scanf("%d", &s[d]); //here we have the first array
}
for(d=0; d<nc; d++)
{
scanf("%d", &c[d]); //second array
}
for(d=0; d<ns; d++)
{
if(c[d]%2==0) //I check here if the nb. from second array are even
{
r[d]=s[d]; //I try to put the numbers from the first array
}
}
for(d=ns-1; d>-1; d--)
{
printf("%d ", r[d]); //I print the new array
}
}

Answer 1

Your problem description is not very clear, but you want to do this:
You have two arrays s and c of the same size N.
First, walk through the array backwards. If the value in c is even, add the corresponding value from s to the result array.
Finally, add the remaining elements of s to the array. The result array will now have N elements, too.
The first thing to notice is that if you look at c[4] and decide to add element s[4] to the result array, the index for that array is 0, because you add elements from the front. In general, if you want to append to an array, you do:
int array[5]; // space for 5 ints
int n = 0; // current length; start with empty array
array[n++] = 5; // array == [5]; n == 1
array[n++] = 8; // array == [5, 8]; n == 2
array[n++] = 15; // array == [5, 8, 15]; n == 3
Your backwards loop works, but it is a bit clumsy, in my opinion. In C (and other languages), ranges are described by the inclusive lower bound and an exclusive upper bound. In the range [0, N), the value N is just out of bound.
Forwad loops initialize to the lower bound, break on the upper bound and increment after each cycle. Because of this asymetry, backwards loops are simpler when you start with the upper bound, break on the lower bound, but decrement at the start of the loop:
for (i = N; i-- > 0; ) ...
The empty update section looks strange, but in this loop, the index never leaves the valid range and therefore also works with unsigned integers.
Create your arrays:
int s[N] = {7, 3, 6, 2, 8}; // value array
int c[N] = {0, 12, 5, 23, 14}; // control array
int r[N]; // result array
int k = 0; // length of r
Now walk the arrays backwards and pick the items you want:
for (i = N; i-- > 0; ) {
if (c[i] % 2 == 0) {
r[k++] = s[i];
}
}
Walk the array forwards and pick the items you didn't pick in the first pass:
for (i = 0; i < N; i++) {
if (c[i] % 2) {
r[k++] = s[i];
}
}
Voilà.