使用二进制二进制补码表示法

Question

我需要使用Bit运算符比较两个整数。我遇到了一个问题，我必须比较两个整数而不使用比较运算符。使用位运算符会有所帮助。但是如何？

让我们说 a = 4; b = 5;

我们必须表明a不等于b。但是，我想进一步扩展它，比方说，我们将展示哪个更大。这里b更大..

Answer 1

您至少需要与0进行比较，并且从理论上讲，这是CPU为比较所做的事情。 e.g。

等于可以建模为^，因为位必须相同才能返回0

(a ^ b) == 0

如果这是C，您可以删除== 0，因为这可以隐含

!(a ^ b)

但是在Java中，如果没有至少一些比较，则无法将int转换为boolean。

为了进行比较，你通常会做一个减法，尽管它会处理溢出。

(long) a - b > 0 // same as a > b

减法与添加负数相同，负数与~x + 1相同，所以你可以这样做

(long) a + ~ (long) b + 1 > 0

删除+1您可以将其更改为

(long) a + ~ (long) b >= 0 // same as a > b

您可以将+实施为>> << & |和^的一系列逐位操作，但我不会'对你造成伤害。

Answer 2

如果没有Peter提到的比较运算符，则无法将1或0转换为bool。如果没有比较运算符，仍然可以获得max。

我使用bit（1或0）代替int以避免混淆。

bit msb(x):
    return lsb(x >> 31)
bit lsb(x):
    return x &1

// returns 1 if x < 0, 0 if x >= 0
bit isNegative(x):
    return msb(x)

这些助手isGreater(a, b)看起来像是

// BUG: bug due to overflow when a is -ve and b is +ve
// returns 1 if a > b, 0 if a <= b
bit isGreater_BUG(a, b):
    return isNegative(b - a)    // possible overflow

我们需要两个辅助函数来检测相同和不同的符号，

// toggles lsb only
bit toggle(x):
    return lsb(~x)

// returns 1 if a, b have same signs (0 is considered +ve).
bit isSameSigns(a, b):
    return toggle(isDiffSigns(a, b))
// returns 1 if a, b have different signs (0 is considered +ve).
bit isDiffSigns(a, b):
    return msb(a ^ b)

所以有了溢出问题修复，

// returns 1 if a > b, 0 if a <= b
bit isGreater(a, b):
    return 
        (isSameSigns(a, b) & isNegative(b - a)) | 
        (isDiffSigns(a, b) & isNegative(b))

请注意，isGreater也适用于输入5, 0和0, -5。

棘手正确实施isPositive(x) 0也将被视为正面。因此，isPositive(a - b)不是使用上面的isNegative(b - a)，而是isNegative(x)用于0。

现在max可以实现为，

// BUG: returns 0 when a == b instead of a (or b)
// returns a if a > b, b if b > a
int max_BUG(a, b):
    return
        isGreater(a, b) * a +   // returns 0 when a = b
        isGreater(b, a) * b     //

要修复使用帮助器isZero(x)，

// returns 1 if x is 0, else 0
bit isZero(x):
    // x | -x will have msb 1 for a non-zero integer
    // and 0 for 0
    return toggle(msb(x | -x))

所以使用a = b时的修复，

// returns 1 if a == b else 0
bit isEqual(a, b):
    return isZero(a - b) // or isZero(a ^ b)

int max(a, b):
    return
        isGreater(a, b) * a +   // a > b, so a
        isGreater(b, a) * b +   // b > a, so b
        isEqual(a, b) * a       // a = b, so a (or b)

也就是说，如果isPositive(0)返回1，那么max(5, 5)将返回10而不是5.所以正确的isPositive(x)实现将是，

// returns 1 if x < 0, 0 if x >= 0
bit isPositive(x):
    return isNotZero(x) & toggle(isNegative(x))

// returns 1 if x != 0, else 0
bit isNotZero(x):
    return msb(x | -x)

Answer 3

使用二进制二进制补码表示法

int findMax( int x, int y)
{
 int z = x - y;
 int i  = (z  >>  31)  &  0x1;
 int  max  =  x - i  *  z;
 return max;
}

参考：Here

Answer 4

a ^ b = c                    // XOR the inputs
                             //  If a equals b, c is zero. Else c is some other value

c[0] | c[1] ... | c[n] = d   // OR the bits
                             //  If c equals zero, d equals zero. Else d equals 1

注意：a,b,c是n位整数，d是位

Answer 5

Java中不使用比较器运算符的解决方案：

    int a = 10;
    int b = 12;
    boolean[] bol = new boolean[] {true};

    try {
      boolean c = bol[a ^ b];
      System.out.println("The two integers are equal!");
    } catch (java.lang.ArrayIndexOutOfBoundsException e) {
      System.out.println("The two integers are not equal!");
      int z = a - b;
      int i = (z >> 31) & 0x1;
      System.out.println("The bigger integer is " + (a - i * z));
    }

Answer 6

我假设您需要一个整数（0 或 1），因为您需要进行比较才能从 Java 中的整数获取布尔值。

这里有一个简单的解决方案，它不使用比较，而是使用减法，实际上可以使用按位运算来完成（但不推荐，因为它在软件中需要很多周期）。

// For equality,
// 1. Perform r=a^b.
//    If they are equal you get all bits 0. Otherwise some bits are 1.
// 2. Cast it to a larger datatype 0 to have an extra bit for sign.
//    You will need to clear the high bits because of signed casting.
//    You can split it into two parts if you can't cast.
// 3. Perform -r.
//    If all bits are 0, you will get 0.
//    If some bits are not 0, then you get a negative number.
// 4. Shift right to extract MSB.
//    This will give -1 (because of sign extension) for not equal and 0 for equal.
//    You can easily convert it to 0 and 1 by adding 1 (I didn't include it in below function).
int equality(int a, int b) {
    long r = ((long)(a^b)) ^0xffffffffl;
    return (int)(((long)-r) >> 63);
}

// For greater_than,
// 1. Cast a and b to larger datatype to get more bits.
//    You can split it into two parts if you can't cast.
// 2. Perform b-a.
//    If a>b, then negative number (MSB is 1)
//    If a<=b, then positive number or zero (MSB is 0)
// 3. Shift right to extract MSB.
//    This will give -1 (because of sign extension) for greater than and 0 for not.
//    You can easily convert it to 0 and 1 by negating it (I didn't include it in below function).
int greater_than(int a, int b) {
    long r = (long)b-(long)a;
    return (int)(r >> 63);
}

小于与大于相似，但交换 a 和 b。

琐事：这些比较函数实际上是在安全（密码学）中使用的，因为CPU比较不是恒定时间的；也就是不能抵御定时攻击。

使用位运算符比较两个整数

6 个答案:

使用二进制二进制补码表示法