Partition negative and positive without comparison with 0 using java

You will be given an array of n integers, both negative and positive. You need to partition the array into positive and negative numbers. Add all the positive integers of the array to one array (or any data structure) and add all the negative to another array (or any data structure). If the first element of the input array is a positive number, then print all the positive numbers in the given order in the first line of output, and then all the negative numbers in the given order in the second line of output, vice - versa.

Notes:

Consider 0 as a positive number.

The positive and negative numbers in the output should follow the order of the elements in the given array. Each number in each line of the output should be separated by a space.

If the array contains only positive numbers then print the positive numbers in the first line and in the second line print “Array doesn't have negative numbers”.

If the array contains only negative numbers then print the negative numbers in the first line and in the second line print “Array doesn't have positive numbers”.

Input:

10

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

Output:

2 6 9 10 3 5

-1 -4 -7 -8

Explanation:

The first element of the array is 2 that is a positive number so print all the positive numbers of the array in the first line and then print all the negative numbers in the next line

Here what I have done which is working 50%(which is partitioning -ve and +ve integers in separate arraylist) and that remaining 50% where we have to check whether in our array if no positive numbers given then print the given message and vice versa

 import java.util.*;
public class Source {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int arr[] = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
partitionNegativeAndPositive(n, arr);
}
static  boolean oppositeSign(int x,int y) {
return ((x^y)<0);
}
static void printList(ArrayList<Integer> list) {
String result="";
for(int i=0;i<list.size();i++) {
result+=list.get(i)+" ";
}
System.out.println(result);
}
// Method to partition negative and positive numbers without comparing with 0
static void partitionNegativeAndPositive(int n, int arr[]) {
// Write your code here
ArrayList<Integer> a = new ArrayList<Integer>();
ArrayList<Integer> b = new ArrayList<Integer>();
//push first element
a.add(arr[0]);
// Now put all elements of same sign
// in a[] and opposite sign in b[]
for(int i=1;i<n;i++) {
if(oppositeSign( a.get(0), arr[i])) {
b.add(arr[i]);
}else {
a.add(arr[i]);
}
}
if(arr[0]>=0) {
if(a.size()>=0) {
printList(a);
}else {
System.out.println("Array doesn't have positive numbers");
}
if(b.size()>=0) {
printList(b);
}else {
System.out.println("Array doesn't have negative numbers");
}
}else {
if(b.size()>=0) {
printList(b);
}else {
System.out.println("Array doesn't have negative numbers");
}
if(a.size()>=0) {
printList(a);
}else {
System.out.println("Array doesn't have positive numbers");
}
}
}
}

Please help where I have done wrong in this piece of code

Your oppositeSign method is a nice idea, but it still bears a comparison with zero. You can perform the partition operation without comparisons when you consider that the leftmost bit of an int value indicates the sign and can be extracted, to be used as an index into your partitions. Further, Java is not C. You don’t need to pass the array length, as Java arrays know their length. Further, you should avoid the declaration syntax int arr[], but use int[] arr, to follow the idiomatic type name pattern.

static void partitionNegativeAndPositive(int[] arr) {
ArrayList<Integer> pos = new ArrayList<>(), neg = new ArrayList<>();
List<List<Integer>> posNeg = Arrays.asList(pos, neg);
for(int i: arr) posNeg.get(i >>> 31).add(i);
if(pos.isEmpty()) {
System.out.println("Array doesn't have positive numbers");
}
else {
printList(pos);
}
if(neg.isEmpty()) {
System.out.println("Array doesn't have negative numbers");
}
else {
printList(neg);
}
}

i >>> 31 shifts the sign bit to position zero, leading to zero for positive numbers and one for negative numbers. This can be used as index into the list created via Arrays.asList(pos, neg), to add to the correct partition.

The issue in the code is you are checking for the size of the array to be zero or more then print that array else print the message.
But the size of array will always be either zero or more.

To get the desired output ,you just have to make the below changes.

     if(arr[0]>=0) {
if(a.size()>0) { // <--  compare for size greater than 0 only
printList(a);
}else {
System.out.println("Array doesn't have positive numbers");
}
if(b.size()>0) { // <--  compare for size greater than 0 only
printList(b);
}else {
System.out.println("Array doesn't have negative numbers");
}
}else {
if(b.size()>0) { // <--  compare for size greater than 0 only
printList(b);
}else {
System.out.println("Array doesn't have negative numbers");
}
if(a.size()>0) { // <--  compare for size greater than 0 only
printList(a);
}else {
System.out.println("Array doesn't have positive numbers");
}
}

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
		int arr[] = {-2, -6, -9, -1, -4, -10, -7, -3, -5, -8};

		boolean isPositive = false;
		boolean isNegative = false;

		boolean fElement = arr[0] >= 0;

		ArrayList<Integer> pos = new ArrayList<Integer>();
		ArrayList<Integer> neg = new ArrayList<Integer>();

		for(int i : arr){
			if(i >= 0){
				pos.add(i);
				isPositive = true;
			}else{
				neg.add(i);
				isNegative = true;
			}
		}

		if(fElement){
			for(int i : pos){
				System.out.print(i + " ");
			}
			System.out.println();

			if(isNegative){
				for(int i : neg){
					System.out.print(i + " ");
				}
			}else{
				System.out.println("No negative numbers");
			}

		}else{
			for(int i : neg){
				System.out.print(i + " ");
			}
			System.out.println();

			if(isPositive){
				for(int i : pos){
					System.out.print(i + " ");
				}
			}else{
				System.out.println("No positvie numbers");
			}

		}
    }
}

import java.util.*;
public class array_partition {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int arr[] = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
partitionNegativeAndPositive(n, arr);
}
static  boolean oppositeSign(int x,int y) {
return ((x^y)<0);
}
// Method to partition negative and positive numbers without comparing with 0
static void partitionNegativeAndPositive(int n, int arr[]) {
// Write your code here
ArrayList<Integer> a=new ArrayList<Integer>();
ArrayList<Integer> b=new ArrayList<Integer>();
a.add(arr[0]);
// Now put all elements of same sign
// in a[] and opposite sign in b[]
for(int i=1;i<n;i++) {
if(oppositeSign( a.get(0), arr[i])) {
b.add(arr[i]);
}else {
a.add(arr[i]);
}
}
if(a.size()==n && a.get(0)>=0) {
print_arraylist(a);
System.out.println();
System.out.println("Array doesn't have negative numbers");
}
else if(a.size()==n && a.get(0)<0) {
print_arraylist(a);
System.out.println();
System.out.println("Array doesn't have positive numbers");
}
else {
print_arraylist(a);
System.out.println();
print_arraylist(b);
}
}
static void print_arraylist(ArrayList<Integer> list) {
for(int i:list) {
System.out.print(i+" ");
}
}
}