ArrangePositiveAndNegative.cpp

#include <iostream>
#include <vector>

std::vector<int> ArrangePositiveAndNegative(const std::vector<int>& arr) {
std::vector<int> positiveNumbers, negativeNumbers;

for (int num : arr) {
    if (num > 0) {
        positiveNumbers.push_back(num);
    } else if (num < 0) {
        negativeNumbers.push_back(num);
    }
}

std::vector<int> arrangedArray;
int posIndex = 0, negIndex = 0;
bool positiveStep = true;

while (posIndex < positiveNumbers.size() || negIndex < negativeNumbers.size()) {
    if (positiveStep && posIndex < positiveNumbers.size()) {
        arrangedArray.push_back(positiveNumbers[posIndex++]);
    } else if (!positiveStep && negIndex < negativeNumbers.size()) {
        arrangedArray.push_back(negativeNumbers[negIndex++]);
    }
    positiveStep = !positiveStep;
}

return arrangedArray;

}

int main() {
std::cout << "Enter the size of the array: ";
int arraySize;
std::cin >> arraySize;
std::vector<int> array(arraySize);

for (int i = 0; i < arraySize; i++) {
    std::cout << "Enter element at index " << i << ": ";
    std::cin >> array[i];
}

std::cout << "Original Array: ";
for (int num : array) {
    std::cout << num << " ";
}
std::cout << std::endl;

std::vector<int> resultArray = ArrangePositiveAndNegative(array);

std::cout << "Arranged Array: ";
for (int num : resultArray) {
    std::cout << num << " ";
}
std::cout << std::endl;

return 0;

}

/* Possible Testcases

Testcase-1:

Input:
Size of the array: 5
Elements: 4 7 1 9 2

Output:
Original Array: 4 7 1 9 2
Arranged Array: 4 7 1 9 2

Testcase-2:

Input:
Size of the array: 6
Elements: -3 -7 -2 -5 -8 -1

Output:
Original Array: -3 -7 -2 -5 -8 -1
Arranged Array: -3 -7 -2 -5 -8 -1

Testcase-3:

Input:
Size of the array: 8
Elements: 4 -7 1 0 -3 6 -5 2

Output:
Original Array: 4 -7 1 0 -3 6 -5 2
Arranged Array: 4 -7 1 -3 6 -5 0 2
*/

/*Complexity:
Time Complexity: O(n) in worst case.
Space Complexity: This approach takes O(n) auxilary space , as we created 2 arrays positives and negatives.
*/