Given two signed integers, write a function that returns true if the signs of given integers are different, otherwise false. For example, the function should return true -1 and +100, and should return false for -100 and -200. The function should not use any of the arithmetic operators. Let the given integers be x and y. The sign bit is 1 in negative numbers, and 0 in positive numbers. The XOR of x and y will have the sign bit as 1 if they have opposite sign. In other words, XOR of x and y will be negative number if x and y have opposite signs. The following code use this logic.
The first method is more efficient. The first method uses a bitwise XOR and a comparison operator. The second method uses two comparison operators and a bitwise XOR operation is more efficient compared to a comparison operation. We can also use following method. It doesn’t use any comparison operator. The method is suggested by Hongliang and improved by gaurav.
CPP
booloppositeSigns(intx, inty)
{
return((x ^ y) >> 31);
}
C
//C program to detect whether two integers
//have different sign or not
#include <stdio.h>
#include<stdbool.h>
booloppositeSigns(intx, inty)
{
return((x ^ y) >> 31);
}
//this code is contributed by shruti456rawal
Java
importjava.io.*;
classGFG {
staticbooleanoppositeSigns(intx, inty)
{
return((x ^ y) >> 31);
}
}
// This code is contributed by shivanisinghss2110
Python3
defoppositeSigns(x, y):
return((x ^ y) >> 31)
# this code is contributed by shivanisinghss2110
C#
usingSystem;
classGFG {
staticbooloppositeSigns(intx, inty)
{
return((x ^ y) >> 31);
}
}
// This code is contributed by shivanisinghss2110
Javascript
<script>
functionoppositeSigns(x, y)
{
return((x ^ y) >> 31);
}
// This code is contributed by shivanisinghss2110
</script>
Time Complexity: O(1)
The function is written only for compilers where size of an integer is 32 bit. The expression basically checks sign of (x^y) using bitwise operator ‘>>’. As mentioned above, the sign bit for negative numbers is always 1. The sign bit is the leftmost bit in binary representation. So we need to checks whether the 32th bit (or leftmost bit) of x^y is 1 or not. We do it by right shifting the value of x^y by 31, so that the sign bit becomes the least significant bit. If sign bit is 1, then the value of (x^y)>>31 will be 1, otherwise 0.
C++
// C++ Program to detect if two integers have opposite
// signs.
#include <iostream>
usingnamespacestd;
booloppositeSigns(intx, inty)
{
longlongproduct = 1ll * x * y;
return(product < 0);
}
intmain()
{
intx = 100, y = -100;
if(oppositeSigns(x, y) == true)
cout << "Signs are opposite";
else
cout << "Signs are not opposite";
return0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
C
// C Program to detect
// if two integers have opposite signs.
#include <stdbool.h>
#include <stdio.h>
booloppositeSigns(intx, inty)
{
longlongproduct = 1ll * x * y;
return(product < 0);
}
intmain()
{
intx = 100, y = -100;
if(oppositeSigns(x, y) == true)
printf("Signs are opposite");
else
printf("Signs are not opposite");
return0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
Java
// Java program for the above approach
importjava.util.*;
classGFG {
staticbooleanoppositeSigns(intx, inty)
{
longproduct = 1*x*y;
return(product<0);
}
// Driver Code
publicstaticvoidmain(String[] args)
{
intx = 100, y = -100;
if(oppositeSigns(x, y) == true)
System.out.print( "Signs are opposite");
else
System.out.print("Signs are not opposite");
}
}
// This code is contributed by sanjoy_62.
Python3
# Python Program to detect
# if two integers have opposite signs.
defoppositeSigns(x,y):
product =x*y
return(product<0)
# driver code
x =100
y =-100
if(oppositeSigns(x, y) ==True):
print("Signs are opposite")
else:
print("Signs are not opposite")
# this code is contributed by shinjanpatra
C#
// C# program for the above approach
usingSystem;
classGFG{
staticbooloppositeSigns(intx, inty)
{
longproduct = 1*x*y;
return(product<0);
}
// Driver Code
publicstaticvoidMain(String[] args)
{
intx = 100, y = -100;
if(oppositeSigns(x, y) == true)
Console.WriteLine( "Signs are opposite");
else
Console.WriteLine("Signs are not opposite");
}
}
// This code is contributed by avijitmondal1998.
Javascript
// JavaScript Program to detect
// if two integers have opposite signs.
functionoppositeSigns(x,y)
{
const product = Number(x)*Number(y);
return(product<0);
}
// driver code
let x = 100, y = -100;
if(oppositeSigns(x, y) == true)
{
console.log("Signs are opposite");
}
elseconsole.log("Signs are not opposite");
// this code is contributed by shinjanpatra
Output
Signs are opposite
Approach : The basic approach is to calculate the product the two integers, and as we know, two integers having opposite signs will always produce a negative integer, we need to just find out whether the product is negative or not.
Time Complexity: O(1)
Space Complexity: O(1)
Please write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve the same problem.
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy