check positive or negative without using conditional statements in java

Question

An interview question I was asked last week:

I need a function to print out whether a number is positive or negative without using conditional statements like if else while for switch a? b:c etc. How can i do that.

I told the interviewer that it's impossible cuz the question is 'conditional' in nature. He told me it's possible but didn't tell me how. I did quite a bit of search but no good answers.

Answer 1

One possible solution:

String[] responses = {"Positive", "Negative"};
System.out.println(responses[(i >> 31) & 1]);

This also counts zero as a positive number.

Because integers in Java are required to be stored in two's complement (or behave as if they are) the highest bit of any negative number is 1, and the highest bit of any other number is 0. (i >> 31) copies the highest bit to every other bit (so negative numbers become 11111111 11111111 11111111 11111111 and positive/zero numbers become 00000000 00000000 00000000 00000000). & 1 sets all but the lowest bit to 0. The combination (i >> 31) & 1 effectively reads only the highest bit of i.

Answer 2

Just to elaborate on immibis' answer a bit:

int index(int i) {
    return 1 + (i>>31) - (-i>>31);
}

String[] text = {"negative", "zero", "positive"};

private String text(int i) {
    return text[index(i)];
}

The signed shift i>>31 converts every negative number into -1 and every other into 0. Computing -i>>31 allows to tell positive numbers from non-positive ones. Now look at the computed index:

positive: 1 +    0 - (-1) = 2
zero:     1 +    0 -    0 = 1
negative: 1 + (-1) -    0 = 0

Answer 3

Here is a variation, accounting for the fact that zero is neither positive or negative:

    int x = (int)Math.sqrt(Math.pow(n, 2));
    try {
        x = n / x;
    }
    catch (ArithmeticException e) {
        x = 0;
    }

    String[] result = {"negative", "zero", "positive"};
    System.out.println(result[x + 1]);

Answer 4

Super simple solution abusing the fact that arrays cannot have a negative size:

void printPositive(int i) {
    try { new int[i]; System.out.println("positive"); } 
    catch( NegativeArraySizeException e) { System.out.println("negative"); }
}

Okay, this answer may allocate a huge array if i is positive and the VM might use conditionals under its hood when evaluating new int[i], but at least it would show the interviewer some kind of creativity. In addition, it might show the interviewer that you can think out of the box (because he might anticipate that you will do some bit magic as most of the other answers use) and do something completely different.

Answer 5

Old answer. The reason I am making this new answer is because I was using Boolean's compareTo method, which uses a ternary operator to convert boolean expressions to binary.

Here is my new answer, which is much more unreadable.

public static String positiveOrNegative(int n) {

    ArrayList<String> responses = new ArrayList<String>();
    // first element should be "Zero", so if n is 0, the response is "Zero"
    responses.add("Zero");

    // this populates the ArrayList with elements "Positive" for n elements
    // so that if n is positive, n will be an index in the ArrayList
    // and the return will be "Positive"
    // but still if n is negative, it will never be an index in the ArrayList
    for (int i = 0; i < n; i++) {
        responses.add("Positive");
    }

    String response = "";
    try {
        // try to get a response from the ArrayList
        response = responses.get(n);
    } catch (Exception e) {
         // index is out of bounds, so it must have been negative
        response = "Negative";
    }

    return response;
}

public static void main(String[] args) {
    System.out.println(positiveOrNegative(4)); // Positive
    System.out.println(positiveOrNegative(1)); // Positive
    System.out.println(positiveOrNegative(0)); // Zero
    System.out.println(positiveOrNegative(-1)); // Negative
    System.out.println(positiveOrNegative(-4)); // Negative
}

Answer 6

Another possible solution:

boolean isPositive(int n) {
  return n > ((n + 1) % n);
}

It does not work for 0 though.

---- EDIT -----

New algorithm:

String isPositive(int n) {
  String[] results = {"-", "", "+"};
  return results[1+(1+((n+1)%n)*((n-1)%n))/n];
}

It still does not work for 0.

Answer 7

Folks, it's not really hard, don't need to shift bits or do weird calls, just use the signum method in the Math class! ;p

http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#signum%28float%29

Answer 8

This is a very simple question than it sounds. This is possible without using conditional; just write this code

System.out.println(n>0);