¿La forma más simple de verificar si dos enteros tienen el mismo signo?

Question

¿Cuál es la forma más sencilla de comprobar si dos enteros tienen el mismo signo? ¿Hay algún truco a pequeña escala para hacer esto?

Answer 1

Aquí está una versión que funciona en C/C++ que no se basa en tamaños enteros o tienen el problema de desbordamiento (es decir, x * y> = 0 no funciona)

bool SameSign(int x, int y) 
{ 
    return (x >= 0)^(y < 0); 
} 

Por supuesto, puede geek y la plantilla:

template <typename valueType> 
bool SameSign(typename valueType x, typename valueType y) 
{ 
    return (x >= 0)^(y < 0); 
} 

Nota: Puesto que estamos utilizando exclusivo o, queremos que el LHS y el RHS a ser diferentes cuando los signos son iguales, por lo tanto los diferentes cheque contra cero.

Answer 2

si (x * y)> 0 ...

suponiendo que no sea cero y tal.

Answer 3

Justo al lado de la parte superior de mi cabeza ...

int mask = 1 << 31; 
(a & mask)^(b & mask) < 0; 

Answer 4

si (a * b < 0) signo es diferente, signo demás es igual (o A o B es cero)

Answer 5

suponiendo 32 ints bits:

bool same = ((x^y) >> 31) != 1; 

poco más concisa:

bool same = !((x^y) >> 31); 

Answer 6

Recordando a mis días universitarios, en la mayoría de las representaciones de máquinas, ¿no es el bit más a la izquierda de un entero un 1 cuando el número es negativo, y 0 cuando es positivo?

Supongo que esto es más bien dependiente de la máquina, sin embargo.

Answer 7

(entero1 * entero2)> 0

Porque cuando dos enteros comparten un signo, el resultado de la multiplicación siempre será positivo.

También puede hacerlo> = 0 si desea tratar 0 como si fuera el mismo signo pase lo que pase.

Answer 8

int same_sign =! ((X >> 31)^(y >> 31));

si (same_sign) ... otra cosa ...

Answer 9

Como nota técnica, soluciones de bits twiddly van a ser mucho más eficiente que la multiplicación, incluso en arquitecturas modernas. Es sólo alrededor de 3 ciclos que usted está ahorrando, pero ya sabes lo que dicen de un "centavo ahorrado" ...

Answer 10

(a^b) >= 0 

evaluará a 1 si el signo es el mismo, 0 en caso contrario.

Answer 11

Sería cauteloso con cualquier trucos de bit a bit para determinar el signo de los enteros, ya que entonces tiene que hacer suposiciones sobre cómo esos números se representan internamente.

Casi el 100% del tiempo, los enteros se almacenarán como two's compliment, pero no es una buena práctica hacer suposiciones sobre las partes internas de un sistema a menos que esté utilizando un tipo de datos que garantice un formato de almacenamiento particular.

En dos complementos, puede verificar el último bit (el extremo izquierdo) en el número entero para determinar si es negativo, por lo que puede comparar solo estos dos bits. Sin embargo, esto significaría que 0 tendría el mismo signo que un número positivo, lo que está en desacuerdo con la función de signo implementada en la mayoría de los idiomas.

Personalmente, solo usaría la función de signo del idioma elegido. Es poco probable que haya problemas de rendimiento con un cálculo como este.

Answer 12

Para cualquier tamaño de int con la aritmética de complemento a dos:

#define SIGNBIT (~((unsigned int)-1 >> 1)) 
if ((x & SIGNBIT) == (y & SIGNBIT)) 
    // signs are the same 

Answer 13

asumiendo 32 bits

if (((x^y) & 0x80000000) == 0)

... la respuesta si (x * y> 0) es malo debido al desbordamiento

Answer 14

No estoy muy seguro de que consideraría "truco bitwise" y "más simple" también. Veo muchas respuestas que están asumiendo números enteros de 32 bits (aunque sería sería una tontería pedir sin firmar); No estoy seguro de que se apliquen a los valores de coma flotante.

Parece que el control "más simple" sería comparar cómo ambos valores se comparan con 0; esto es bastante genérico suponiendo que los tipos se pueden comparar:

bool compare(T left, T right) 
{ 
    return (left < 0) == (right < 0); 
} 

Si los signos son opuestos, se obtiene falso. Si los signos son los mismos, te haces verdadero.

Answer 15

¿Qué hay de malo en

return ((x<0) == (y<0)); 

?

Answer 16

dos en dos Suponiendo que complementan la aritmética (http://en.wikipedia.org/wiki/Two_complement):

inline bool same_sign(int x, int y) { 
    return (x^y) >= 0; 
} 

Esto puede tomar tan poco como dos instrucciones y menos de 1 ns en un procesador moderno con la optimización.

dos en dos

no asumir complementan la aritmética:

inline bool same_sign(int x, int y) { 
    return (x<0) == (y<0); 
} 

Esto puede requerir uno o dos instrucciones adicionales y tomar un poco más de tiempo.

Usar la multiplicación es una mala idea porque es vulnerable al desbordamiento.

Answer 17

sucursales C versión:

int sameSign(int a, int b) { 
    return ~(a^b) & (1<<(sizeof(int)*8-1)); 
} 

C++ plantilla para tipos de enteros:

template <typename T> T sameSign(T a, T b) { 
    return ~(a^b) & (1<<(sizeof(T)*8-1)); 
} 

Answer 18

mejor manera usando std::signbit como sigue:

std::signbit(firstNumber) == std::signbit(secondNumber); 

También soporta otros tipos básicos (double , float, char etc.)