C / C++ / MFC

/*  C++ program to rearrange positive and negative integers in alternate
    fashion while keeping the order of positive and negative numbers. */
#include <iostream>
#include <assert.h>
using namespace std;

void printArray(int arr[], int n);

// Utility function to right rotate all elements between [outofplace, cur]
void rightrotate(int arr[], int n, int outofplace, int cur)
{
    char tmp = arr[cur];
    for (int i = cur; i > outofplace; i--)
        arr[i] = arr[i-1];
    arr[outofplace] = tmp;
}

void rearrange(int arr[], int n)
{
    int outofplace = -1;

    for (int index = 0; index < n; index ++)
    {
        if (outofplace >= 0)
        {
            // find the item which must be moved into the out-of-place
            // entry if out-of-place entry is positive and current
            // entry is negative OR if out-of-place entry is negative
            // and current entry is negative then right rotate
            //
            // [...-3, -4, -5, 6...] -->   [...6, -3, -4, -5...]
            //      ^                          ^
            //      |                          |
            //     outofplace      -->      outofplace
            //
            if (((arr[index] >= 0) && (arr[outofplace] < 0))
                || ((arr[index] < 0) && (arr[outofplace] >= 0)))
            {
                rightrotate(arr, n, outofplace, index);
                printArray(arr, n);

                // the new out-of-place entry is now 2 steps ahead
                if (index - outofplace > 2)
                    outofplace = outofplace + 2;
                else
                    outofplace = -1;
            }
        }


        // if no entry has been flagged out-of-place
        if (outofplace == -1)
        {
            // check if current entry is out-of-place
            if (((arr[index] >= 0) && (!(index & 0x01)))      // what does (index & 0x01) means ??
                || ((arr[index] < 0) && (index & 0x01)))
            {
                outofplace = index;
            }
        }
    }
}

// A utility function to print an array 'arr[]' of size 'n'
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
      cout << arr[i] << " ";
    cout << endl;
}

// Driver program to test abive function
int main()
{
    //int arr[n] = {-5, 3, 4, 5, -6, -2, 8, 9, -1, -4};
    //int arr[] = {-5, -3, -4, -5, -6, 2 , 8, 9, 1 , 4};
    //int arr[] = {5, 3, 4, 2, 1, -2 , -8, -9, -1 , -4};
    //int arr[] = {-5, 3, -4, -7, -1, -2 , -8, -9, 1 , -4};
    int arr[] = {-5, -2, 5, 2, 4, 7, 1, 8, 0, -8};
    int n = sizeof(arr)/sizeof(arr[0]);

    cout << "Given array is \n";
    printArray(arr, n);
    cout << "\n\n";

    rearrange(arr, n);

    cout << "\n\nRearranged array is \n";
    printArray(arr, n);

    return 0;
}

Quote:

// check if current entry is out-of-place
if (((arr[index] >= 0) && (!(index & 0x01))) // what does (index & 0x01) means ??
|| ((arr[index] < 0) && (index & 0x01)))
{
outofplace = index;
}

#define N 4
int main()
	{int i, j, ncases, x[N], start[N], stop[N], n = N; ncases = 0;
	for (i = 0; i<n; i++) { start[i] = x[i] = 0; stop[i] = 3; } // set up
	for (x[(i = n) - 1]--; i > 0; x[i] = start[i]) for (i--; (++x[i]) <= stop[i]; i = n - 1) { // iterate over all cases
		ncases++;
		for (j = 0; j < n; j++) putchar('0' + x[j]); // replace by something useful to be done over every allowed combination of values of x[0:N-1]
		putchar(' '); }
	printf("\n%d cases found\n~~~~~~~~~~~~~~\n", ncases);
	printf("press a key to continue:"); i = getchar();
	return 0;
}

for( i[N-1] = start[N-1]; i[N-1] <= stop[N-1]; i[N-1]++ )
    for( i[N-2] = start[N-2]; i[N-2] <= stop[N-2]; i[N-2]++ )
        for( i[N-3] = start[N-3]; i[N-3] <= stop[N-3]; i[N-3]++ )
            for( i[N-4] = ...............................
                         etc to ..
                               for( i[1] = start[1]; i[1] <= stop[1]; i[1]++ )
                                   for( i[0] = start[0]; i[0] <= stop[0]; i[0]++ )
                                        { work to be done for every allowed combination of values of i[0:N-1] }