Checking if two numbers have the same sign

Question

Is there a more elegant way than the following to check if two numbers have the same sign?

 bool sameSign(int num1, int num2)
    {
        if (num1 > 0 && num2 < 0)
            return false;
        if (num1 < 0 && num2 > 0)
            return false;
        return true;
    }

It could also be written as the not case of all of this (e.g. check the true cases and return false at the end).

By design, the two integers will never contain a zero value.

Answer 1

First up, your code has bugs. What if one of the numbers is 0? 0 should be positive, but your code treats it as negative in some tests, and positive in others. When comparing against 0 you should use >=, not just >.

The actual code is quite readable, though, and the performance is probably not horrible. I would recommend a single return statement though. A single return statement is easier if you check for "the same sign", and not "opposite signs".

Take your code:

bool sameSign(int num1, int num2)
{
    if (num1 > 0 && num2 < 0)
        return false;
    if (num1 < 0 && num2 > 0)
        return false;
    return true;
}

Fix the 0-handling, and you have:

bool sameSign(int num1, int num2)
{
    return num1 >= 0 && num2 >= 0 || num1 < 0 && num2 < 0
}

Now, that's pretty good, and I would happily "pass" that in a code review, but, can you do some tricks?

The simplest (code wise) is to use XOR:

return (num1 ^ num2) >= 0

That compares the bits, and if they are the same, it sets the resulting bit to 0. If the sign bits are the same, the resulting sign-bit is 0, and thus a positive (or 0) value.

Answer 2

Why not compare the Booleans themselves?

return ((num1 < 0) == (num2 < 0));

This treats zero as "positive". For a stricter interpretation that considers zero to be neither positive nor negative, consider:

return (((num1 == 0) == (num2 == 0)) &&
        ((num1 < 0)  == (num2 < 0)));

(Edit hat tips @MichaelS, @holroy)

Answer 3

Yes, there is a more elegant way to do this by

• adding accessibility modifier to the method
• use PascalCase casing for naming the method
• naming the method HasSameSign
• using the Math.Sign() method

private static bool HasSameSign(int num1, int num2)
{
    return Math.Sign(num1) == Math.Sign(num2);
}

Answer 4

You can shift right, you will end up with -1 or zero, for negative and positive respectively. (Arithmetic shift) This will propagate the most significant bit (sign bit) yielding 0xFFFFFFFF (-1) or 0x00000000 (0).

return num1 >> 31 == num2 >> 31;

Answer 5

The thing that is missing is a comment above the function that specifies exactly what the function does for inputs that are zero: Zero values could be (a) interpreted as being positive, they could be (b) interpreted as signless (having the same sign as any number), or (c) the behaviour of the function could be undefined for zero inputs.

That needs to be written down, as a comment that is part of the function. If you had done that, then in case (b) or (c) your code would have been a fine implementation, and in case (a) it would have a severe bug.

Now anyone who blindly multiplies the numbers (severe risk of overflow, and the same problem handling zeroes), or shifting tricks (and adding assumptions about what right shift of negative numbers does, and assumptions that int = 32 bits): Don't try that at work! Do it as home as much as you like, but not where readability and code quality is asked for.

Answer 6

The code can written in one line:

return (num1 <= 0 && num2 <= 0) || (num1 >= 0 && num2 >= 0);

This preserves the original behavior of the code, which, as @200_success commented, is different than the conventional meaning of same sign.

Answer 7

A simple way using simple math. The resulting sign of a division will be positive if the two numbers have the same sign, and negative if they are distinct:

        bool sameSign(int num1, int num2)
        {
            num2 = num2==0 ? 1 : num2;
            return ((float)num1 / num2) > 0;
        }

The first line num2 = num2==0 ? 1 : num2; depends on what zero means for you:

1. zero is neither positve nor negative
2. or zero is both
3. or you think it can be eiter +0 and -0.

In this case, num2 = num2==0 ? 1 : num2; zero is always positive (case 3, +0). You can change it to -0 by switching 1 to -1.

If you think case 2 is the real deal, the first line would be num2 = num2==0 ? num1 : num2;, this way the result of the division will be always 1.

Finally, for case 1, num2 = num2 == 0 ? (num1 == Int32.MinValue ? 1 : num1 * -1) : num2;, you might say it must always return false, since "something (some sign) equals nothing (no sign)" is always false. You can achieve that by switching the num1 sign having the division be the original num1 / num1 with switched sign, which is always < 0.

Note in C# the division by two integers return an integer (rounded). By casting to float forces the result to be float. Without it, the result would be an int, and if the num2 is larger enough it would round to 0, both if it was approaching from the negative or positive side.

Answer 8

 bool sameSign(int num1, int num2)
    {
        if (num1 > 0 && num2 < 0)
            return false;
        if (num1 < 0 && num2 > 0)
            return false;
        return true;
    }

First line (prototype) should be (if you want to check doubles):

bool sameSign(long double num1, long double num2)

(note that both must be floating-point numbers)

3rd and 5th lines are completely wrong (3rd line takes 0 as num1 as negative, 5th takes 0 as num2 as negative).
So they should respectively be:

if (num1 >= 0 && num2 < 0)

and

if (num1 < 0 && num2 >= 0)

to have right results. But I recommend 1 return only:

return num1>=0&&num2>=0||num1<0&&num2<0

so that the function would just be:

bool sameSign(long double num1, long double num2)
{
    return num1>=0&&num2>=0||num1<0&&num2<0;
}

or a one-liner:

bool sameSign(long double num1,long double num2){return num1>=0&&num2>=0||num1<0&&num2<0;}

or a two-liner:

bool sameSign(long double num1,long double num2){return num1>=0&&num2>=0||num1<0
&&num2<0;}

Answer 9

I want to introduce one more alternative way for checking that two numbers has same sign.

The method of choice of course is to The method code is here, and a fat explanation follows.

(Only for Int32; other Int types, you should change the number 31 to the bit size of the integer type minus 1 , added on warning of Dmitry Rubanovich)

return System.Convert.ToBoolean(~(num0>>31 ^ num1>>31) & 1);

Using the following two facts, we can build a complete bitwise check (without any comparison) for the signs to be equal.

computers use a method called the two's complement for storing negative numbers.in that form the most significant bit in binary form is 1 if a number is negative and it is 0 if the number is positive.
we can access an 32bit integer's most significant bit with following snippet:

num0>>31 

that shifts it 31 bits to right, ignoring every bit except the leftmost one(sign indicator bit :-) )

the XOR( ^ ) operator return 1 if two bits are not equal and returns 0 if both bits are equal. if we use the "~" ( "binary one's complement operator" that basically flips bits) on the XOR results (called XNOR) and extract the least significant bit of it( using a logical "and" with integer 1 will do the trick) we get 1 if the bits are equal and 0 if the bits are not equal in C# we have to explicitly convert int to boolean so, combining two facts above we get:

return System.Convert.ToBoolean(~(num0>>31 ^ num1>>31) & 1);

The bitwise code returns true if at least one of the numbers is zero.

Answer 10

Multiply the two number together. If the sign of the result is positive, then the sign was the same. If the sign of the result is negative, then the signs were different.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace SignsSameProject
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            bool x;

            x =  SignsAreTheSame(5, 2);
            if (x == true)
                MessageBox.Show("True");
            else
                MessageBox.Show("False");
        }

        private bool SignsAreTheSame(int x, int y)
        {
            long z;

            z = x * y;
            if (z < 0)
                return false;
            else
                return true;

        }
    }
}

Answer 11

How about:

return (num1 < 0) == (num2 < 0);

This checks if 2 numbers have the same sign, in one line

The logic in in this one liner is clearer and is probably faster than if statements