Java 计数最大连续数1'；二进制数中的s

如何在Java中计算二进制数的最大连续1？ 例如，用户输入一个类似13的整数，这将是二进制1101。 二进制数1101有两个连续的1，因此输出应该是2。 另一个例子是数字5是二进制0101，因此输出应该是1。如果我输入439号，我的程序就不能正常工作

Scanner scanner = new Scanner(System.in);
        int numb = scanner.nextInt();
        int tempCount = 0;
        int count = 0; 

        // numb = 439 -> output 3
        // numb = 13  -> output 2
        // numb = 1   -> output 1 
        while (numb >= 1) {

            if (numb % 2 != 0) {

                tempCount++;
                numb /= 2;
                count = tempCount;
                if (numb % 2 != 0) {
                    tempCount++;
                    count = tempCount;
                    numb /= 2;
                }

            }
            else {
                numb /= 2;
                tempCount = 0;
            }
        }
        System.out.println(count);

---

我想出来了，这是解决办法。 我忘记了嵌套的if语句

Scanner scanner = new Scanner(System.in);
int numb = scanner.nextInt();
int tempCount = 0; //save temporarily the longest sequence of one's in this variable 
int count = 0; // before the sequence of one's gets interrupted, I save the value from tempCount in count

// numb = 439 -> output 3
// numb = 13  -> output 2
// numb = 1   -> output 1 
while (numb >= 1) {

    if (numb % 2 != 0) {

        tempCount++;
        numb /= 2;
        if(count < tempCount){
            count = tempCount;
        }

    }
    else {
        numb /= 2;
        tempCount = 0;
    }
}
System.out.println(count);

Scanner Scanner=新的扫描仪（System.in）；
int numb=scanner.nextInt（）；
int tempCount=0//暂时保存此变量中的最长序列
整数计数=0；//在一个人的序列被中断之前，我将tempCount中的值保存在count中
//numb=439->输出3
//numb=13->输出2
//numb=1->输出1
while（numb>=1）{
如果（编号%2！=0）{
tempCount++；
麻木/=2；
如果（计数<临时计数）{
计数=临时计数；
}
}
否则{
麻木/=2；
tempCount=0；
}
}
系统输出打印项次（计数）；

我们可以在最不重要的位置识别两个连续的二进制位，如下所示：

(value & 0b11) == 0b11

我们可以将值中的位向右移动，如下所示：

value >>>= 1;

使用tripple

>>

而不是double

>

非常重要，因为我们不关心符号位

然后我们所要做的就是跟踪连续

1

s的最大数量：

int countMax1Streak(int value) { // value could also be a long if required
    int max = 0;
    int count = 1;
    while (value != 0) {
        if ((value & 0b11) == 0b11) {
            count++;
        } else {
            count = 1;
        }
        value >>>= 1;
        if (count > max) {
            max = count;
        }
    }
    return max;
}

测试用例：

assertEquals(0, countMax1Streak(0b0));
assertEquals(1, countMax1Streak(0b1));
assertEquals(1, countMax1Streak(0b10));
assertEquals(2, countMax1Streak(0b11));
assertEquals(3, countMax1Streak(0b1110011));
assertEquals(3, countMax1Streak(0b1100111));
assertEquals(3, countMax1Streak(0b1110111));
assertEquals(7, countMax1Streak(0b1111111));
assertEquals(32, countMax1Streak(-1));

您还可以使用来计算最大0条纹，如下所示：

public int countMax0Streak(int value) {
    return countMax1Streak(~value);
}

---

我相信您希望

count

是最长的1s序列的长度，而

tempCount

是您当前计数序列中的1s数。因此，仅当

tempCount

大于

count

时，才应将

tempCount

指定给

count

。对于439，我相信您正确地计算了3个1。然后是0，您正确地将

tempCount

重置为零。下次计算1时，正确地将

tempCount

增加到1，然后将此值也分配到

count

，则三的计数将丢失。

这是一个有趣的问题。这是一个通用的解决方案，它还考虑了Java中所有可能的

long

值（如果您检查

n

的值，您的解决方案可能不适用于负数）：

---

请注意，可以根据number和bit的值进行一些优化，但对于初学者来说，这应该是一个不错的解决方案。

您必须实现自己的十进制->二进制方法吗？如果不是，你可以使用Integer.toBinaryString（）不，我只需要取一个整数，然后输出二进制版本中有多少个连续的整数。

1110111

的结果应该是什么？3或6？对于二进制数1110111，在这种情况下，结果应3重新打开，与其他问题不同。您的测试用例显示，要计算相反类型的位，您所需要做的只是不计算输入，因此参数

b

是多余的。这与我的答案非常接近，但请注意，我不需要知道输入中的位数。

public class LongestBitStreak {

/**
 * Returns the longest <i>streak</i> of the given bit b in 
   given number n. 
 * A bit streak is defined as a consecutive sequence of the given bit. 
 * @param n the number to find streak in
 * @param b the bit whose streak is to be found
 * @return the <i>longest</i> bit streak
 */
static int get(long n, int b) {
    if (b != 0 && b != 1)
        throw new IllegalArgumentException("second arg: (" + b + ") must be 0 or 1");
    int streak = 0, maxStreak = 0;
    for (int i = 0; i < 64; i++) {
        if ((n & 1) == b) {
            streak += 1;
            maxStreak = Math.max(streak, maxStreak);
        } else {
            streak = 0;
        }
        n >>= 1;
    }
    return maxStreak;
}

@Test
public void foolProof() {
    long n = 0b11111000001111100110101010;
    long nc = ~n; // One's complement of n
    System.out.println(get(n, 1));
    System.out.println(get(nc, 0));
    assertEquals(get(n, 1), get(nc, 0));
    assertEquals(get(n, 0), get(nc, 1));
}