Java 查找1'的连续数；s

我试图找出二进制中连续1的数目

示例：将十进制数转换为二进制数并查找连续的1

static int count = 0;
static int max = 0;
static int index = 1;

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    scan.close();
    String b = Integer.toBinaryString(n);
    char[] arr = b.toCharArray();
    System.out.println(arr);

    for (int i = 0; i < b.length(); i++) {
        if (arr[i] == index) {
            count++;
        } else {
            count = 0;
        }

        if (count > max) {
            max = count;
        }
    }

    System.out.println(max);
}

static int count=0；
静态int max=0；
静态int指数=1；
公共静态void main（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
int n=scan.nextInt（）；
scan.close（）；
字符串b=整数。toBinaryString（n）；
char[]arr=b.toCharArray（）；
系统输出打印项次（arr）；
对于（int i=0；i最大值）{
最大值=计数；
}
}
系统输出打印项次（最大值）；
}

---

我总是得到0分。在我的代码中，条件似乎不起作用。您能就我的错误提出建议吗？

正如我正确理解的那样，您希望在

int

值的二进制表示中计算

1

组的最大长度。例如，对于

7917=0b1111011101101

，结果将是

4

（我们有以下

1

组：1、2、3、4）

您可以使用位操作（并避免转换为字符串）。您有一个计数器（用于计算当前组中

1

的金额）和

max

以及所有此类金额的最大值。您只需检查

1

的最低位，然后向右旋转该值，直到它变为

0

，如

GetMaxConcertiveSetBit1

或者只需以一种非常简单的方式进行操作—将其转换为二进制字符串并计算其中

1

字符的数量，如

getMaxConcertiveSetBit2

。还有一个计数器+最大值。不要忘记，Java中的

char

是JVM级别上的

int

。因此，将

char

与

int

值

1

进行比较并不存在编译问题，但这是错误的。要检查字符是否为

1

，必须使用字符-

'1'

public static void main(String[] args) {
    try (Scanner scan = new Scanner(System.in)) {
        int val = scan.nextInt();
        System.out.println(Integer.toBinaryString(val));
        System.out.println(getMaxConsecutiveSetBit1(val));
        System.out.println(getMaxConsecutiveSetBit2(val));
    }
}

public static int getMaxConsecutiveSetBit1(int val) {
    int max = 0;
    int cur = 0;

    while (val != 0) {
        if ((val & 0x1) != 0)
            cur++;
        else {
            max = Math.max(max, cur);
            cur = 0;
        }

        val >>>= 1;
    }

    return Math.max(max, cur);
}

public static int getMaxConsecutiveSetBit2(int val) {
    int max = 0;
    int cur = 0;

    for (char ch : Integer.toBinaryString(val).toCharArray()) {
        if (ch == '1')
            cur++;
        else {
            max = Math.max(max, cur);
            cur = 0;
        }
    }

    return Math.max(max, cur);
}

---

将

索引

变量的类型从

int

更改为

char

：

静态字符索引=1

让我们在这行中进行比较：

if (arr[i] == index)

做好本职工作。比较
int 1
（在您的代码中，这是存储在
index
变量中的值）和
char'1'
（在您的示例中，它当前是
arr[]
的选中元素）检查给定
char
的ASCII代码是否等于
int
值1。此比较永远不会为真，因为字符“1”具有ASCII代码49，并且这是正在与值1进行比较的值（49永远不等于1）

您可能希望查看web中的ASCII代码表，以查看其中的所有字符都已分配了相应的数值。您需要注意，在将
char
与
int
与
==
运算符进行比较时，会考虑这些值

当您将所提到的
索引类型更改为
字符
时，比较工作正常，您的代码似乎是固定的。
您的量化不太清楚，但与您的算法不同，您试图找到重复次数最多的1。问题是，当您执行比较
if（arr[i]==index）
时，比较是使用字符和整数进行的，因为arr的类型是字符数组。不是吗？要克服此问题，您可以将
字符数组
转换为整数，或将整数
索引
值转换为
字符
。我这样做是为了克服它

if (arr[i] == index + '0')

这不是一个真正优雅的解决方案。我假设你是一名学生，想让你证明什么是错的。如果我想做这样的事，我用

private static int maxConsecutiveOnes(int x) {
        // Initialize result
        int count = 0;

        // Count the number of iterations to
        // reach x = 0.
        while (x!=0) {
            // This operation reduces length
            // of every sequence of 1s by one.
            x = (x & (x << 1));

            count++;
        }

        return count;
}

private static int maxConcertiveONES（int x）{
//初始化结果
整数计数=0；
//计算要执行的迭代次数
//达到x=0。
而（x！=0）{
//此操作缩短了长度
//每一个1乘1的序列。
x=（x&（x使用for循环结构，改变一些东西，同时添加一些其他统计数据以报告可能有用的信息。我计算数字中1的总数，连续1的数量（1的组），以及最大数量的连续1。此外，for循环是基于字符串长度而不是数组的长度进行循环的，数组的长度有点挑剔。下面是代码

int count = 0;
int max = 0;
char index = '1';
int consecutiveOnePairs = 0;
int numberOfOnes = 0;

Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
String b = Integer.toBinaryString(n);
char[] arr = b.toCharArray();
System.out.println(arr);

for (int i = 0; i < arr.length; i++) {
    if (arr[i] == index)
    {
        count++;
        numberOfOnes++;
    }

    if((i + 1 == arr.length && count > 1) || arr[i] != index)
    {
        if(count > 1)
            consecutiveOnePairs++;
        if (count > max)
            max = count;
        count = 0;
    }
}

System.out.println("Total Number of 1's in " + n + " is " + numberOfOnes);
System.out.println("Total Number of Consecutive 1's in " + n + " is " + consecutiveOnePairs);
System.out.println("Greatest Number of Consecutive 1's in " + n + " is " + max);
scan.close();

如果使用Java 8，可以尝试以下代码段：

 public int maxOneConsecutive(int x)
  {
    String intAsBinaryStr = Integer.toBinaryString(x);
    String[] split = intAsBinaryStr.split("0");
    return Arrays.stream(split)
        .filter(str -> !str.isEmpty())
        .map(String::length)
        .max(Comparator.comparingInt(a -> a)).orElse(0);
  }

字符
'1'
转换为
int
时，没有值
1
，因此
arr[i]=“索引< /代码>永远不会是真的。相反，您希望<代码>索引<代码>是值>代码>‘1’/代码>的建议。建议：在调试器下一步一步地运行代码，并检查沿途的所有临时值。谢谢@ AZUR青蛙，我已经将索引的数据类型更改为字符。现在它工作得很好。@卡蒂克考虑删除您的问题。现在，你想要整数二进制还是整数二进制？…例如，整数二进制中的-1就是全部1我想你误解了。他们写了“连续1”。0b11011的答案是2，因为最大值是两个连续的1。这一个更改是否修复了整个程序？如果没有，那么这应该是一个注释。如果有，请在您的答案中更加明确，以便我可以投票支持您，他们可以标记您的正确性。@DavidS感谢您的建议。我试图改进我的答案，希望您接受我的建议现在看看它是否满足您的要求。在这种情况下，这可能是Karthik的最佳答案。她很可能是一个正在做家庭作业的初级程序员，所以我不想跳到位操作（像其他一些答案一样）是合适的。@DavidS我认为对于Karthik来说，这可能是最有用的答案，但我们也应该注意，这个问题可能会被更有经验的用户搜索，以寻找更复杂或更高效的答案
13247
11001110111111
Total Number of 1's in 13247 is 11
Total Number of Consecutive 1's in 13247 is 3
Greatest Number of Consecutive 1's in 13247 is 6

511
111111111
Total Number of 1's in 511 is 9
Total Number of Consecutive 1's in 511 is 1
Greatest Number of Consecutive 1's in 511 is 9

887
1101110111
Total Number of 1's in 887 is 8
Total Number of Consecutive 1's in 887 is 3
Greatest Number of Consecutive 1's in 887 is 3

 public int maxOneConsecutive(int x)
  {
    String intAsBinaryStr = Integer.toBinaryString(x);
    String[] split = intAsBinaryStr.split("0");
    return Arrays.stream(split)
        .filter(str -> !str.isEmpty())
        .map(String::length)
        .max(Comparator.comparingInt(a -> a)).orElse(0);
  }