Rearrange positive and negative numbers in array

Here given code implementation process.

// C Program 
// Rearrange positive and negative numbers in array
#include <stdio.h>

//Display elements of given array
void printArray(int arr[], int size)
{
	for (int i = 0; i < size; ++i)
	{
		printf("  %d", arr[i]);
	}
	printf("\n");
}
// Swapping of array elements 
void swapNode(int arr[], int a, int b)
{
	int temp = arr[a];
	arr[a] = arr[b];
	arr[b] = temp;
}
// Arrange pairwise positive and negative elements
void rearrange(int arr[], int size)
{
	int negative = 1;
	int positive = 0;
	// Loop controlling variable
	int i = 1;
	// Set positive elements in Even position in given arrays
	while (i < size && positive < size)
	{
		if (arr[positive] > 0)
		{
			// When element already positive
			positive += 2;
		}
		else if (arr[i] >= 0)
		{
			if (i < positive)
			{
				if (i % 2 == 1)
				{
					// When if swap the positive elements at odd position element
					swapNode(arr, i, positive);
					positive += 2;
				}
			}
			else
			{
				swapNode(arr, i, positive);
				positive += 2;
			}
		}
		i++;
	}
	i = 0;
	// Set negative elements in Odd position in given arrays
	while (i < size && negative < size)
	{
		if (arr[negative] < 0)
		{
			// When element already negative number
			negative += 2;
		}
		else if (arr[i] < 0)
		{
			if (i < negative)
			{
				if (i % 2 == 0)
				{
					swapNode(arr, i, negative);
					negative += 2;
				}
			}
			else
			{
				swapNode(arr, i, negative);
				negative += 2;
			}
		}
		i++;
	}
}
int main(int argc, char
	const *argv[])
{
	// Define array of integer elements
	int arr1[] = {
		-1 , -2 , -5 , 1 , -4 , 2 , 5 , 2 , 4 , -4
	};
	int arr2[] = {
		8 , 7 , 0 , -5 , 1 , -4 , -9 , 5 , 2 , 4 , -4 , -6
	};
	int arr3[] = {
		8 , 6 , 2 , 6 , -2 , 5 , 2 , -6 , 2 , -6 , 3
	};
	int arr4[] = {
		1 , 2 , 3 , 4
	};
	int arr5[] = {
		-1 , -2 , -3 , -4 , -5 , 1 , 2 , 3 , 4
	};
	// Test 1
	int size = sizeof(arr1) / sizeof(arr1[0]);
	printf("  Before Arrange \n");
	printArray(arr1, size);
	rearrange(arr1, size);
	printf("  After Arrange \n");
	printArray(arr1, size);
	// Test 2
	size = sizeof(arr2) / sizeof(arr2[0]);
	printf("\n  Before Arrange \n");
	printArray(arr2, size);
	rearrange(arr2, size);
	printf("  After Arrange \n");
	printArray(arr2, size);
	// Test 3
	size = sizeof(arr3) / sizeof(arr3[0]);
	printf("  Before Arrange \n");
	printArray(arr3, size);
	rearrange(arr3, size);
	printf("  After Arrange \n");
	printArray(arr3, size);
	// Test 4
	size = sizeof(arr4) / sizeof(arr4[0]);
	printf("\n  Before Arrange \n");
	printArray(arr4, size);
	rearrange(arr4, size);
	printf("  After Arrange \n");
	printArray(arr4, size);
	// Test 5
	size = sizeof(arr5) / sizeof(arr5[0]);
	printf("\n  Before Arrange \n");
	printArray(arr5, size);
	rearrange(arr5, size);
	printf("  After Arrange \n");
	printArray(arr5, size);
	return 0;
}

Output

  Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
  After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

  Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
  After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
  Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
  After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

  Before Arrange
  1  2  3  4
  After Arrange
  1  2  3  4

  Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
  After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

/*
    Java Program
    Rearrange positive and negative numbers in array
*/
public class Arrangement
{
	//Display elements of given array
	public void printArray(int[] arr, int size)
	{
		for (int i = 0; i < size; ++i)
		{
			System.out.print("  " + arr[i] );
		}
		System.out.print("\n");
	}
	// Swapping of array elements 
	public void swapNode(int[] arr, int a, int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	// Arrange pairwise positive and negative elements
	public void rearrange(int[] arr, int size)
	{
		int negative = 1;
		int positive = 0;
		// Loop controlling variable
		int i = 1;
		// Set positive elements in Even position in given arrays
		while (i < size && positive < size)
		{
			if (arr[positive] > 0)
			{
				// When element already negative positive
				positive += 2;
			}
			else if (arr[i] >= 0)
			{
				if (i < positive)
				{
					if (i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						swapNode(arr, i, positive);
						positive += 2;
					}
				}
				else
				{
					swapNode(arr, i, positive);
					positive += 2;
				}
			}
			i++;
		}
		i = 0;
		// Set negative elements in Odd position in given arrays
		while (i < size && negative < size)
		{
			if (arr[negative] < 0)
			{
				// When element already number
				negative += 2;
			}
			else if (arr[i] < 0)
			{
				if (i < negative)
				{
					if (i % 2 == 0)
					{
						swapNode(arr, i, negative);
						negative += 2;
					}
				}
				else
				{
					swapNode(arr, i, negative);
					negative += 2;
				}
			}
			i++;
		}
	}
	public static void main(String args[])
	{
		Arrangement task = new Arrangement();
		// Define array of integer elements
		int[] arr1 = {
			-1 , -2 , -5 , 1 , -4 , 2 , 5 , 2 , 4 , -4
		};
		int[] arr2 = {
			8 , 7 , 0 , -5 , 1 , -4 , -9 , 5 , 2 , 4 , -4 , -6
		};
		int[] arr3 = {
			8 , 6 , 2 , 6 , -2 , 5 , 2 , -6 , 2 , -6 , 3
		};
		int[] arr4 = {
			1 , 2 , 3 , 4
		};
		int[] arr5 = {
			-1 , -2 , -3 , -4 , -5 , 1 , 2 , 3 , 4
		};
		// Test 1
		int size = arr1.length;
		System.out.print(" Before Arrange \n");
		task.printArray(arr1, size);
		task.rearrange(arr1, size);
		System.out.print(" After Arrange \n");
		task.printArray(arr1, size);
		// Test 2
		size = arr2.length;
		System.out.print("\n Before Arrange \n");
		task.printArray(arr2, size);
		task.rearrange(arr2, size);
		System.out.print(" After Arrange \n");
		task.printArray(arr2, size);
		// Test 3
		size = arr3.length;
		System.out.print(" Before Arrange \n");
		task.printArray(arr3, size);
		task.rearrange(arr3, size);
		System.out.print(" After Arrange \n");
		task.printArray(arr3, size);
		// Test 4
		size = arr4.length;
		System.out.print("\n Before Arrange \n");
		task.printArray(arr4, size);
		task.rearrange(arr4, size);
		System.out.print(" After Arrange \n");
		task.printArray(arr4, size);
		// Test 5
		size = arr5.length;
		System.out.print("\n Before Arrange \n");
		task.printArray(arr5, size);
		task.rearrange(arr5, size);
		System.out.print(" After Arrange \n");
		task.printArray(arr5, size);
	}
}

Output

 Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange
  1  2  3  4
 After Arrange
  1  2  3  4

 Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

// Include header file
#include <iostream>

using namespace std;
/*
    C++ Program
    Rearrange positive and negative numbers in array
*/
class Arrangement
{
	public:
		//Display elements of given array
		void printArray(int arr[], int size)
		{
			for (int i = 0; i < size; ++i)
			{
				cout << "  " << arr[i];
			}
			cout << "\n";
		}
	// Swapping of array elements
	void swapNode(int arr[], int a, int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	// Arrange pairwise positive and negative elements
	void rearrange(int arr[], int size)
	{
		int negative = 1;
		int positive = 0;
		// Loop controlling variable
		int i = 1;
		// Set positive elements in Even position in given arrays
		while (i < size && positive < size)
		{
			if (arr[positive] > 0)
			{
				// When element already positive
				positive += 2;
			}
			else if (arr[i] >= 0)
			{
				if (i < positive)
				{
					if (i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						this->swapNode(arr, i, positive);
						positive += 2;
					}
				}
				else
				{
					this->swapNode(arr, i, positive);
					positive += 2;
				}
			}
			i++;
		}
		i = 0;
		// Set negative elements in Odd position in given arrays
		while (i < size && negative < size)
		{
			if (arr[negative] < 0)
			{
				// When element already negative number
				negative += 2;
			}
			else if (arr[i] < 0)
			{
				if (i < negative)
				{
					if (i % 2 == 0)
					{
						this->swapNode(arr, i, negative);
						negative += 2;
					}
				}
				else
				{
					this->swapNode(arr, i, negative);
					negative += 2;
				}
			}
			i++;
		}
	}
};
int main()
{
	Arrangement task = Arrangement();
	// Define array of integer elements
	int arr1[] = {
		-1 , -2 , -5 , 1 , -4 , 2 , 5 , 2 , 4 , -4
	};
	int arr2[] = {
		8 , 7 , 0 , -5 , 1 , -4 , -9 , 5 , 2 , 4 , -4 , -6
	};
	int arr3[] = {
		8 , 6 , 2 , 6 , -2 , 5 , 2 , -6 , 2 , -6 , 3
	};
	int arr4[] = {
		1 , 2 , 3 , 4
	};
	int arr5[] = {
		-1 , -2 , -3 , -4 , -5 , 1 , 2 , 3 , 4
	};
	// Test 1
	int size = sizeof(arr1) / sizeof(arr1[0]);
	cout << " Before Arrange \n";
	task.printArray(arr1, size);
	task.rearrange(arr1, size);
	cout << " After Arrange \n";
	task.printArray(arr1, size);
	// Test 2
	size = sizeof(arr2) / sizeof(arr2[0]);
	cout << "\n Before Arrange \n";
	task.printArray(arr2, size);
	task.rearrange(arr2, size);
	cout << " After Arrange \n";
	task.printArray(arr2, size);
	// Test 3
	size = sizeof(arr3) / sizeof(arr3[0]);
	cout << " Before Arrange \n";
	task.printArray(arr3, size);
	task.rearrange(arr3, size);
	cout << " After Arrange \n";
	task.printArray(arr3, size);
	// Test 4
	size = sizeof(arr4) / sizeof(arr4[0]);
	cout << "\n Before Arrange \n";
	task.printArray(arr4, size);
	task.rearrange(arr4, size);
	cout << " After Arrange \n";
	task.printArray(arr4, size);
	// Test 5
	size = sizeof(arr5) / sizeof(arr5[0]);
	cout << "\n Before Arrange \n";
	task.printArray(arr5, size);
	task.rearrange(arr5, size);
	cout << " After Arrange \n";
	task.printArray(arr5, size);
	return 0;
}

Output

 Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange
  1  2  3  4
 After Arrange
  1  2  3  4

 Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

// Include namespace system
using System;
/*
    C# Program
    Rearrange positive and negative numbers in array
*/
public class Arrangement
{
	//Display elements of given array
	public void printArray(int[] arr, int size)
	{
		for (int i = 0; i < size; ++i)
		{
			Console.Write("  " + arr[i]);
		}
		Console.Write("\n");
	}
	// Swapping of array elements
	public void swapNode(int[] arr, int a, int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	// Arrange pairwise positive and negative elements
	public void rearrange(int[] arr, int size)
	{
		int negative = 1;
		int positive = 0;
		// Loop controlling variable
		int i = 1;
		// Set positive elements in Even position in given arrays
		while (i < size && positive < size)
		{
			if (arr[positive] > 0)
			{
				// When element already positive
				positive += 2;
			}
			else if (arr[i] >= 0)
			{
				if (i < positive)
				{
					if (i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						swapNode(arr, i, positive);
						positive += 2;
					}
				}
				else
				{
					swapNode(arr, i, positive);
					positive += 2;
				}
			}
			i++;
		}
		i = 0;
		// Set negative elements in Odd position in given arrays
		while (i < size && negative < size)
		{
			if (arr[negative] < 0)
			{
				// When element already negative number
				negative += 2;
			}
			else if (arr[i] < 0)
			{
				if (i < negative)
				{
					if (i % 2 == 0)
					{
						swapNode(arr, i, negative);
						negative += 2;
					}
				}
				else
				{
					swapNode(arr, i, negative);
					negative += 2;
				}
			}
			i++;
		}
	}
	public static void Main(String[] args)
	{
		Arrangement task = new Arrangement();
		// Define array of integer elements
		int[] arr1 = {
			-1 , -2 , -5 , 1 , -4 , 2 , 5 , 2 , 4 , -4
		};
		int[] arr2 = {
			8 , 7 , 0 , -5 , 1 , -4 , -9 , 5 , 2 , 4 , -4 , -6
		};
		int[] arr3 = {
			8 , 6 , 2 , 6 , -2 , 5 , 2 , -6 , 2 , -6 , 3
		};
		int[] arr4 = {
			1 , 2 , 3 , 4
		};
		int[] arr5 = {
			-1 , -2 , -3 , -4 , -5 , 1 , 2 , 3 , 4
		};
		// Test 1
		int size = arr1.Length;
		Console.Write(" Before Arrange \n");
		task.printArray(arr1, size);
		task.rearrange(arr1, size);
		Console.Write(" After Arrange \n");
		task.printArray(arr1, size);
		// Test 2
		size = arr2.Length;
		Console.Write("\n Before Arrange \n");
		task.printArray(arr2, size);
		task.rearrange(arr2, size);
		Console.Write(" After Arrange \n");
		task.printArray(arr2, size);
		// Test 3
		size = arr3.Length;
		Console.Write(" Before Arrange \n");
		task.printArray(arr3, size);
		task.rearrange(arr3, size);
		Console.Write(" After Arrange \n");
		task.printArray(arr3, size);
		// Test 4
		size = arr4.Length;
		Console.Write("\n Before Arrange \n");
		task.printArray(arr4, size);
		task.rearrange(arr4, size);
		Console.Write(" After Arrange \n");
		task.printArray(arr4, size);
		// Test 5
		size = arr5.Length;
		Console.Write("\n Before Arrange \n");
		task.printArray(arr5, size);
		task.rearrange(arr5, size);
		Console.Write(" After Arrange \n");
		task.printArray(arr5, size);
	}
}

Output

 Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange
  1  2  3  4
 After Arrange
  1  2  3  4

 Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

<?php
/*
    Php Program
    Rearrange positive and negative numbers in array
*/
class Arrangement
{
	//Display elements of given array
	public	function printArray( & $arr, $size)
	{
		for ($i = 0; $i < $size; ++$i)
		{
			echo "  ". $arr[$i];
		}
		echo "\n";
	}
	// Swapping of array elements
	public	function swapNode( & $arr, $a, $b)
	{
		$temp = $arr[$a];
		$arr[$a] = $arr[$b];
		$arr[$b] = $temp;
	}
	// Arrange pairwise positive and negative elements
	public	function rearrange( & $arr, $size)
	{
		$negative = 1;
		$positive = 0;
		// Loop controlling variable
		$i = 1;
		// Set positive elements in Even position in given arrays
		while ($i < $size && $positive < $size)
		{
			if ($arr[$positive] > 0)
			{
				// When element already positive
				$positive += 2;
			}
			else if ($arr[$i] >= 0)
			{
				if ($i < $positive)
				{
					if ($i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						$this->swapNode($arr, $i, $positive);
						$positive += 2;
					}
				}
				else
				{
					$this->swapNode($arr, $i, $positive);
					$positive += 2;
				}
			}
			$i++;
		}
		$i = 0;
		// Set negative elements in Odd position in given arrays
		while ($i < $size && $negative < $size)
		{
			if ($arr[$negative] < 0)
			{
				// When element already negative number
				$negative += 2;
			}
			else if ($arr[$i] < 0)
			{
				if ($i < $negative)
				{
					if ($i % 2 == 0)
					{
						$this->swapNode($arr, $i, $negative);
						$negative += 2;
					}
				}
				else
				{
					$this->swapNode($arr, $i, $negative);
					$negative += 2;
				}
			}
			$i++;
		}
	}
}

function main()
{
	$task = new Arrangement();
	// Define array of integer elements
	$arr1 = array(-1, -2, -5, 1, -4, 2, 5, 2, 4, -4);
	$arr2 = array(8, 7, 0, -5, 1, -4, -9, 5, 2, 4, -4, -6);
	$arr3 = array(8, 6, 2, 6, -2, 5, 2, -6, 2, -6, 3);
	$arr4 = array(1, 2, 3, 4);
	$arr5 = array(-1, -2, -3, -4, -5, 1, 2, 3, 4);
	// Test 1
	$size = count($arr1);
	echo " Before Arrange \n";
	$task->printArray($arr1, $size);
	$task->rearrange($arr1, $size);
	echo " After Arrange \n";
	$task->printArray($arr1, $size);
	// Test 2
	$size = count($arr2);
	echo "\n Before Arrange \n";
	$task->printArray($arr2, $size);
	$task->rearrange($arr2, $size);
	echo " After Arrange \n";
	$task->printArray($arr2, $size);
	// Test 3
	$size = count($arr3);
	echo " Before Arrange \n";
	$task->printArray($arr3, $size);
	$task->rearrange($arr3, $size);
	echo " After Arrange \n";
	$task->printArray($arr3, $size);
	// Test 4
	$size = count($arr4);
	echo "\n Before Arrange \n";
	$task->printArray($arr4, $size);
	$task->rearrange($arr4, $size);
	echo " After Arrange \n";
	$task->printArray($arr4, $size);
	// Test 5
	$size = count($arr5);
	echo "\n Before Arrange \n";
	$task->printArray($arr5, $size);
	$task->rearrange($arr5, $size);
	echo " After Arrange \n";
	$task->printArray($arr5, $size);
}
main();

Output

 Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange
  1  2  3  4
 After Arrange
  1  2  3  4

 Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

/*
    Node Js Program
    Rearrange positive and negative numbers in array
*/
class Arrangement
{
	//Display elements of given array
	printArray(arr, size)
	{
		for (var i = 0; i < size; ++i)
		{
			process.stdout.write("  " + arr[i]);
		}
		process.stdout.write("\n");
	}
	// Swapping of array elements
	swapNode(arr, a, b)
	{
		var temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	// Arrange pairwise positive and negative elements
	rearrange(arr, size)
	{
		var negative = 1;
		var positive = 0;
		// Loop controlling variable
		var i = 1;
		// Set positive elements in Even position in given arrays
		while (i < size && positive < size)
		{
			if (arr[positive] > 0)
			{
				// When element already positive
				positive += 2;
			}
			else if (arr[i] >= 0)
			{
				if (i < positive)
				{
					if (i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						this.swapNode(arr, i, positive);
						positive += 2;
					}
				}
				else
				{
					this.swapNode(arr, i, positive);
					positive += 2;
				}
			}
			i++;
		}
		i = 0;
		// Set negative elements in Odd position in given arrays
		while (i < size && negative < size)
		{
			if (arr[negative] < 0)
			{
				// When element already negative number
				negative += 2;
			}
			else if (arr[i] < 0)
			{
				if (i < negative)
				{
					if (i % 2 == 0)
					{
						this.swapNode(arr, i, negative);
						negative += 2;
					}
				}
				else
				{
					this.swapNode(arr, i, negative);
					negative += 2;
				}
			}
			i++;
		}
	}
}

function main()
{
	var task = new Arrangement();
	// Define array of integer elements
	var arr1 = [-1, -2, -5, 1, -4, 2, 5, 2, 4, -4];
	var arr2 = [8, 7, 0, -5, 1, -4, -9, 5, 2, 4, -4, -6];
	var arr3 = [8, 6, 2, 6, -2, 5, 2, -6, 2, -6, 3];
	var arr4 = [1, 2, 3, 4];
	var arr5 = [-1, -2, -3, -4, -5, 1, 2, 3, 4];
	// Test 1
	var size = arr1.length;
	process.stdout.write(" Before Arrange \n");
	task.printArray(arr1, size);
	task.rearrange(arr1, size);
	process.stdout.write(" After Arrange \n");
	task.printArray(arr1, size);
	// Test 2
	size = arr2.length;
	process.stdout.write("\n Before Arrange \n");
	task.printArray(arr2, size);
	task.rearrange(arr2, size);
	process.stdout.write(" After Arrange \n");
	task.printArray(arr2, size);
	// Test 3
	size = arr3.length;
	process.stdout.write(" Before Arrange \n");
	task.printArray(arr3, size);
	task.rearrange(arr3, size);
	process.stdout.write(" After Arrange \n");
	task.printArray(arr3, size);
	// Test 4
	size = arr4.length;
	process.stdout.write("\n Before Arrange \n");
	task.printArray(arr4, size);
	task.rearrange(arr4, size);
	process.stdout.write(" After Arrange \n");
	task.printArray(arr4, size);
	// Test 5
	size = arr5.length;
	process.stdout.write("\n Before Arrange \n");
	task.printArray(arr5, size);
	task.rearrange(arr5, size);
	process.stdout.write(" After Arrange \n");
	task.printArray(arr5, size);
}
main();

Output

 Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange
  1  2  3  4
 After Arrange
  1  2  3  4

 Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

#  Python 3 Program
#  Rearrange positive and negative numbers in array

class Arrangement :
	# Display elements of given array
	def printArray(self, arr, size) :
		i = 0
		while (i < size) :
			print("  ", arr[i], end = "")
			i += 1
		
		print(end = "\n")
	
	#  Swapping of array elements
	def swapNode(self, arr, a, b) :
		temp = arr[a]
		arr[a] = arr[b]
		arr[b] = temp
	
	#  Arrange pairwise positive and negative elements
	def rearrange(self, arr, size) :
		negative = 1
		positive = 0
		#  Loop controlling variable
		i = 1
		#  Set positive elements in Even position in given arrays
		while (i < size and positive < size) :
			if (arr[positive] > 0) :
				#  When element already positive
				positive += 2
			
			elif(arr[i] >= 0) :
				if (i < positive) :
					if (i % 2 == 1) :
						#  When if swap the positive elements at odd position element
						self.swapNode(arr, i, positive)
						positive += 2
					
				else :
					self.swapNode(arr, i, positive)
					positive += 2
				
			
			i += 1
		
		i = 0
		#  Set negative elements in Odd position in given arrays
		while (i < size and negative < size) :
			if (arr[negative] < 0) :
				#  When element already negative number
				negative += 2
			
			elif(arr[i] < 0) :
				if (i < negative) :
					if (i % 2 == 0) :
						self.swapNode(arr, i, negative)
						negative += 2
					
				else :
					self.swapNode(arr, i, negative)
					negative += 2
				
			
			i += 1
		
	

def main() :
	task = Arrangement()
	#  Define array of integer elements
	arr1 = [-1, -2, -5, 1, -4, 2, 5, 2, 4, -4]
	arr2 = [8, 7, 0, -5, 1, -4, -9, 5, 2, 4, -4, -6]
	arr3 = [8, 6, 2, 6, -2, 5, 2, -6, 2, -6, 3]
	arr4 = [1, 2, 3, 4]
	arr5 = [-1, -2, -3, -4, -5, 1, 2, 3, 4]
	#  Test 1
	size = len(arr1)
	print(" Before Arrange ")
	task.printArray(arr1, size)
	task.rearrange(arr1, size)
	print(" After Arrange ")
	task.printArray(arr1, size)
	#  Test 2
	size = len(arr2)
	print("\n Before Arrange ")
	task.printArray(arr2, size)
	task.rearrange(arr2, size)
	print(" After Arrange ")
	task.printArray(arr2, size)
	#  Test 3
	size = len(arr3)
	print(" Before Arrange ")
	task.printArray(arr3, size)
	task.rearrange(arr3, size)
	print(" After Arrange ")
	task.printArray(arr3, size)
	#  Test 4
	size = len(arr4)
	print("\n Before Arrange ")
	task.printArray(arr4, size)
	task.rearrange(arr4, size)
	print(" After Arrange ")
	task.printArray(arr4, size)
	#  Test 5
	size = len(arr5)
	print("\n Before Arrange ")
	task.printArray(arr5, size)
	task.rearrange(arr5, size)
	print(" After Arrange ")
	task.printArray(arr5, size)

if __name__ == "__main__": main()

Output

 Before Arrange
   -1   -2   -5   1   -4   2   5   2   4   -4
 After Arrange
   1   -2   2   -1   5   -5   2   -4   4   -4

 Before Arrange
   8   7   0   -5   1   -4   -9   5   2   4   -4   -6
 After Arrange
   8   -5   0   -4   1   -9   5   -4   2   -6   4   7
 Before Arrange
   8   6   2   6   -2   5   2   -6   2   -6   3
 After Arrange
   8   -2   2   -6   6   -6   2   6   2   5   3

 Before Arrange
   1   2   3   4
 After Arrange
   1   2   3   4

 Before Arrange
   -1   -2   -3   -4   -5   1   2   3   4
 After Arrange
   1   -2   2   -4   3   -1   4   -5   -3

#  Ruby Program
#  Rearrange positive and negative numbers in array

class Arrangement 
	# Display elements of given array
	def printArray(arr, size) 
		i = 0
		while (i < size) 
			print("  ", arr[i])
			i += 1
		end

		print("\n")
	end

	#  Swapping of array elements
	def swapNode(arr, a, b) 
		temp = arr[a]
		arr[a] = arr[b]
		arr[b] = temp
	end

	#  Arrange pairwise positive and negative elements
	def rearrange(arr, size) 
		negative = 1
		positive = 0
		#  Loop controlling variable
		i = 1
		#  Set positive elements in Even position in given arrays
		while (i < size && positive < size) 
			if (arr[positive] > 0) 
				#  When element already positive
				positive += 2
			elsif(arr[i] >= 0) 
				if (i < positive) 
					if (i % 2 == 1) 
						#  When if swap the positive elements at odd position element
						self.swapNode(arr, i, positive)
						positive += 2
					end

				else 
					self.swapNode(arr, i, positive)
					positive += 2
				end

			end

			i += 1
		end

		i = 0
		#  Set negative elements in Odd position in given arrays
		while (i < size && negative < size) 
			if (arr[negative] < 0) 
				#  When element already negative number
				negative += 2
			elsif(arr[i] < 0) 
				if (i < negative) 
					if (i % 2 == 0) 
						self.swapNode(arr, i, negative)
						negative += 2
					end

				else 
					self.swapNode(arr, i, negative)
					negative += 2
				end

			end

			i += 1
		end

	end

end

def main() 
	task = Arrangement.new()
	#  Define array of integer elements
	arr1 = [-1, -2, -5, 1, -4, 2, 5, 2, 4, -4]
	arr2 = [8, 7, 0, -5, 1, -4, -9, 5, 2, 4, -4, -6]
	arr3 = [8, 6, 2, 6, -2, 5, 2, -6, 2, -6, 3]
	arr4 = [1, 2, 3, 4]
	arr5 = [-1, -2, -3, -4, -5, 1, 2, 3, 4]
	#  Test 1
	size = arr1.length
	print(" Before Arrange \n")
	task.printArray(arr1, size)
	task.rearrange(arr1, size)
	print(" After Arrange \n")
	task.printArray(arr1, size)
	#  Test 2
	size = arr2.length
	print("\n Before Arrange \n")
	task.printArray(arr2, size)
	task.rearrange(arr2, size)
	print(" After Arrange \n")
	task.printArray(arr2, size)
	#  Test 3
	size = arr3.length
	print(" Before Arrange \n")
	task.printArray(arr3, size)
	task.rearrange(arr3, size)
	print(" After Arrange \n")
	task.printArray(arr3, size)
	#  Test 4
	size = arr4.length
	print("\n Before Arrange \n")
	task.printArray(arr4, size)
	task.rearrange(arr4, size)
	print(" After Arrange \n")
	task.printArray(arr4, size)
	#  Test 5
	size = arr5.length
	print("\n Before Arrange \n")
	task.printArray(arr5, size)
	task.rearrange(arr5, size)
	print(" After Arrange \n")
	task.printArray(arr5, size)
end

main()

Output

 Before Arrange 
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange 
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange 
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange 
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange 
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange 
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange 
  1  2  3  4
 After Arrange 
  1  2  3  4

 Before Arrange 
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange 
  1  -2  2  -4  3  -1  4  -5  -3

/*
    Scala Program
    Rearrange positive and negative numbers in array
*/
class Arrangement
{
	//Display elements of given array
	def printArray(arr: Array[Int], size: Int): Unit = {
		var i: Int = 0;
		while (i < size)
		{
			print("  " + arr(i));
			i += 1;
		}
		print("\n");
	}
	// Swapping of array elements
	def swapNode(arr: Array[Int], a: Int, b: Int): Unit = {
		var temp: Int = arr(a);
		arr(a) = arr(b);
		arr(b) = temp;
	}
	// Arrange pairwise positive and negative elements
	def rearrange(arr: Array[Int], size: Int): Unit = {
		var negative: Int = 1;
		var positive: Int = 0;
		// Loop controlling variable
		var i: Int = 1;
		// Set positive elements in Even position in given arrays
		while (i < size && positive < size)
		{
			if (arr(positive) > 0)
			{
				// When element already positive
				positive += 2;
			}
			else if (arr(i) >= 0)
			{
				if (i < positive)
				{
					if (i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						this.swapNode(arr, i, positive);
						positive += 2;
					}
				}
				else
				{
					this.swapNode(arr, i, positive);
					positive += 2;
				}
			}
			i += 1;
		}
		i = 0;
		// Set negative elements in Odd position in given arrays
		while (i < size && negative < size)
		{
			if (arr(negative) < 0)
			{
				// When element already negative number
				negative += 2;
			}
			else if (arr(i) < 0)
			{
				if (i < negative)
				{
					if (i % 2 == 0)
					{
						this.swapNode(arr, i, negative);
						negative += 2;
					}
				}
				else
				{
					this.swapNode(arr, i, negative);
					negative += 2;
				}
			}
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Arrangement = new Arrangement();
		// Define array of integer elements
		var arr1: Array[Int] = Array(-1, -2, -5, 1, -4, 2, 5, 2, 4, -4);
		var arr2: Array[Int] = Array(8, 7, 0, -5, 1, -4, -9, 5, 2, 4, -4, -6);
		var arr3: Array[Int] = Array(8, 6, 2, 6, -2, 5, 2, -6, 2, -6, 3);
		var arr4: Array[Int] = Array(1, 2, 3, 4);
		var arr5: Array[Int] = Array(-1, -2, -3, -4, -5, 1, 2, 3, 4);
		// Test 1
		var size: Int = arr1.length;
		print(" Before Arrange \n");
		task.printArray(arr1, size);
		task.rearrange(arr1, size);
		print(" After Arrange \n");
		task.printArray(arr1, size);
		// Test 2
		size = arr2.length;
		print("\n Before Arrange \n");
		task.printArray(arr2, size);
		task.rearrange(arr2, size);
		print(" After Arrange \n");
		task.printArray(arr2, size);
		// Test 3
		size = arr3.length;
		print(" Before Arrange \n");
		task.printArray(arr3, size);
		task.rearrange(arr3, size);
		print(" After Arrange \n");
		task.printArray(arr3, size);
		// Test 4
		size = arr4.length;
		print("\n Before Arrange \n");
		task.printArray(arr4, size);
		task.rearrange(arr4, size);
		print(" After Arrange \n");
		task.printArray(arr4, size);
		// Test 5
		size = arr5.length;
		print("\n Before Arrange \n");
		task.printArray(arr5, size);
		task.rearrange(arr5, size);
		print(" After Arrange \n");
		task.printArray(arr5, size);
	}
}

Output

 Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange
  1  2  3  4
 After Arrange
  1  2  3  4

 Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

/*
    Swift 4 Program
    Rearrange positive and negative numbers in array
*/
class Arrangement
{
	//Display elements of given array
	func printArray(_ arr: [Int], _ size: Int)
	{
		var i: Int = 0;
		while (i < size)
		{
			print("  ", arr[i], terminator: "");
			i += 1;
		}
		print(terminator: "\n");
	}
	// Swapping of array elements
	func swapNode(_ arr: inout[Int], _ a: Int, _ b: Int)
	{
		let temp: Int = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	// Arrange pairwise positive and negative elements
	func rearrange(_ arr: inout[Int], _ size: Int)
	{
		var negative: Int = 1;
		var positive: Int = 0;
		// Loop controlling variable
		var i: Int = 1;
		// Set positive elements in Even position in given arrays
		while (i < size && positive < size)
		{
			if (arr[positive] > 0)
			{
				// When element already positive
				positive += 2;
			}
			else if (arr[i] >= 0)
			{
				if (i < positive)
				{
					if (i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						self.swapNode(&arr, i, positive);
						positive += 2;
					}
				}
				else
				{
					self.swapNode(&arr, i, positive);
					positive += 2;
				}
			}
			i += 1;
		}
		i = 0;
		// Set negative elements in Odd position in given arrays
		while (i < size && negative < size)
		{
			if (arr[negative] < 0)
			{
				// When element already negative number
				negative += 2;
			}
			else if (arr[i] < 0)
			{
				if (i < negative)
				{
					if (i % 2 == 0)
					{
						self.swapNode(&arr, i, negative);
						negative += 2;
					}
				}
				else
				{
					self.swapNode(&arr, i, negative);
					negative += 2;
				}
			}
			i += 1;
		}
	}
}
func main()
{
	let task: Arrangement = Arrangement();
	// Define array of integer elements
	var arr1: [Int] = [-1, -2, -5, 1, -4, 2, 5, 2, 4, -4];
	var arr2: [Int] = [8, 7, 0, -5, 1, -4, -9, 5, 2, 4, -4, -6];
	var arr3: [Int] = [8, 6, 2, 6, -2, 5, 2, -6, 2, -6, 3];
	var arr4: [Int] = [1, 2, 3, 4];
	var arr5: [Int] = [-1, -2, -3, -4, -5, 1, 2, 3, 4];
	// Test 1
	var size: Int = arr1.count;
	print(" Before Arrange ");
	task.printArray(arr1, size);
	task.rearrange(&arr1, size);
	print(" After Arrange ");
	task.printArray(arr1, size);
	// Test 2
	size = arr2.count;
	print("\n Before Arrange ");
	task.printArray(arr2, size);
	task.rearrange(&arr2, size);
	print(" After Arrange ");
	task.printArray(arr2, size);
	// Test 3
	size = arr3.count;
	print(" Before Arrange ");
	task.printArray(arr3, size);
	task.rearrange(&arr3, size);
	print(" After Arrange ");
	task.printArray(arr3, size);
	// Test 4
	size = arr4.count;
	print("\n Before Arrange ");
	task.printArray(arr4, size);
	task.rearrange(&arr4, size);
	print(" After Arrange ");
	task.printArray(arr4, size);
	// Test 5
	size = arr5.count;
	print("\n Before Arrange ");
	task.printArray(arr5, size);
	task.rearrange(&arr5, size);
	print(" After Arrange ");
	task.printArray(arr5, size);
}
main();

Output

 Before Arrange
   -1   -2   -5   1   -4   2   5   2   4   -4
 After Arrange
   1   -2   2   -1   5   -5   2   -4   4   -4

 Before Arrange
   8   7   0   -5   1   -4   -9   5   2   4   -4   -6
 After Arrange
   8   -5   0   -4   1   -9   5   -4   2   -6   4   7
 Before Arrange
   8   6   2   6   -2   5   2   -6   2   -6   3
 After Arrange
   8   -2   2   -6   6   -6   2   6   2   5   3

 Before Arrange
   1   2   3   4
 After Arrange
   1   2   3   4

 Before Arrange
   -1   -2   -3   -4   -5   1   2   3   4
 After Arrange
   1   -2   2   -4   3   -1   4   -5   -3

/*
    Kotlin Program
    Rearrange positive and negative numbers in array
*/
class Arrangement
{
	//Display elements of given array
	fun printArray(arr: Array<Int>, size: Int): Unit
	{
		var i: Int = 0;
		while (i < size)
		{
			print("  " + arr[i]);
			i += 1;
		}
		print("\n");
	}
	// Swapping of array elements
	fun swapNode(arr: Array<Int>, a: Int, b: Int): Unit
	{
		var temp: Int = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	// Arrange pairwise positive and negative elements
	fun rearrange(arr: Array<Int>, size: Int): Unit
	{
		var negative: Int = 1;
		var positive: Int = 0;
		// Loop controlling variable
		var i: Int = 1;
		// Set positive elements in Even position in given arrays
		while (i<size && positive<size)
		{
			if (arr[positive] > 0)
			{
				// When element already positive
				positive += 2;
			}
			else
			if (arr[i] >= 0)
			{
				if (i<positive)
				{
					if (i % 2 == 1)
					{
						// When if swap the positive elements at odd position element
						this.swapNode(arr, i, positive);
						positive += 2;
					}
				}
				else
				{
					this.swapNode(arr, i, positive);
					positive += 2;
				}
			}
			i += 1;
		}
		i = 0;
		// Set negative elements in Odd position in given arrays
		while (i < size && negative < size)
		{
			if (arr[negative] < 0)
			{
				// When element already negative number
				negative += 2;
			}
			else
			if (arr[i] < 0)
			{
				if (i < negative)
				{
					if (i % 2 == 0)
					{
						this.swapNode(arr, i, negative);
						negative += 2;
					}
				}
				else
				{
					this.swapNode(arr, i, negative);
					negative += 2;
				}
			}
			i += 1;
		}
	}
}
fun main(args: Array<String>): Unit
{
	var task: Arrangement = Arrangement();
	// Define array of integer elements
	var arr1: Array<Int> = arrayOf(-1, -2, -5, 1, -4, 2, 5, 2, 4, -4);
	var arr2: Array<Int> = arrayOf(8, 7, 0, -5, 1, -4, -9, 5, 2, 4, -4, -6);
	var arr3: Array<Int> = arrayOf(8, 6, 2, 6, -2, 5, 2, -6, 2, -6, 3);
	var arr4: Array<Int> = arrayOf(1, 2, 3, 4);
	var arr5: Array<Int> = arrayOf(-1, -2, -3, -4, -5, 1, 2, 3, 4);
	// Test 1
	var size: Int = arr1.count();
	print(" Before Arrange \n");
	task.printArray(arr1, size);
	task.rearrange(arr1, size);
	print(" After Arrange \n");
	task.printArray(arr1, size);
	// Test 2
	size = arr2.count();
	print("\n Before Arrange \n");
	task.printArray(arr2, size);
	task.rearrange(arr2, size);
	print(" After Arrange \n");
	task.printArray(arr2, size);
	// Test 3
	size = arr3.count();
	print(" Before Arrange \n");
	task.printArray(arr3, size);
	task.rearrange(arr3, size);
	print(" After Arrange \n");
	task.printArray(arr3, size);
	// Test 4
	size = arr4.count();
	print("\n Before Arrange \n");
	task.printArray(arr4, size);
	task.rearrange(arr4, size);
	print(" After Arrange \n");
	task.printArray(arr4, size);
	// Test 5
	size = arr5.count();
	print("\n Before Arrange \n");
	task.printArray(arr5, size);
	task.rearrange(arr5, size);
	print(" After Arrange \n");
	task.printArray(arr5, size);
}

Output

 Before Arrange
  -1  -2  -5  1  -4  2  5  2  4  -4
 After Arrange
  1  -2  2  -1  5  -5  2  -4  4  -4

 Before Arrange
  8  7  0  -5  1  -4  -9  5  2  4  -4  -6
 After Arrange
  8  -5  0  -4  1  -9  5  -4  2  -6  4  7
 Before Arrange
  8  6  2  6  -2  5  2  -6  2  -6  3
 After Arrange
  8  -2  2  -6  6  -6  2  6  2  5  3

 Before Arrange
  1  2  3  4
 After Arrange
  1  2  3  4

 Before Arrange
  -1  -2  -3  -4  -5  1  2  3  4
 After Arrange
  1  -2  2  -4  3  -1  4  -5  -3

Rearrange positive and negative numbers in array

Output

Output

Output

Output

Output

Output

Output

Output

Output

Output

Output

Comment

New Comment