Java中的二进制Gap程序

我的问题陈述：

正整数N内的二进制间隔是在N的二进制表示中两端被1包围的任何连续零的最大序列。例如，数字9具有二进制表示1001，并且包含长度为2的二进制间隔。数字529具有二进制表示100001001，并包含两个二进制间隙：一个为长度4，一个为长度3。数字20具有二进制表示10100，并包含一个长度为1的二进制间隙。数字15具有二进制表示1111，并且没有二进制间隙。数字32具有二进制表示形式，并且没有二进制间隙

我的代码：

public class Abc {

    static void decToBinary(int n) {

        int[] binaryNum = new int[1000];

        // counter for binary array 
        int i = 0;
        while (n > 0) {
            // storing remainder in binary array 
            binaryNum[i] = n % 2;
            n = n / 2;
            i++;
        }
        int ctr = 0, k = 0;
        ArrayList<Integer> al = new ArrayList<Integer>();

        // printing binary array in reverse order 
        for (int j = i - 1; j >= 0; j--) {
            System.out.print(binaryNum[j]);
            if (binaryNum[j] == 0) {
                k = j;
                do {
                    ctr++;
                    k++;
                } while (binaryNum[k] == 0);
                al.add(ctr);
                ctr = 0;
            }
        }

        for (int ii = 0; ii < al.size(); ii++) {
            System.out.println(al.get(ii));
        }
    }

    // driver program 
    public static void main(String[] args) {
        int n = 1041;
        decToBinary(n);
    }
}

公共类Abc{
静态无效十二月日（整数n）{
int[]binaryNum=新int[1000]；
//二进制数组计数器
int i=0；
而（n>0）{
//在二进制数组中存储余数
二进制数[i]=n%2；
n=n/2；
i++；
}
int ctr=0，k=0；
ArrayList al=新的ArrayList（）；
//按相反顺序打印二进制数组
对于（int j=i-1；j>=0；j--）{
System.out.print（二进制数[j]）；
if（二进制数[j]==0）{
k=j；
做{
ctr++；
k++；
}而（二进制数[k]==0）；
加总费用；
ctr=0；
}
}
对于（int ii=0；ii

我试图显示存储在ArrayList中的二进制gap的输出。但是对于给定的1041输入，输出是完全不同的。我不知道它为什么存储1,2,3,4；根据我的逻辑，在输入1041的情况下，它应该只存储间隙值5和3，即使5和3也存储在ArrayList中，但存储在其他索引中

---

我认为do-while循环中存在问题，特别是在

al.add（ctr）

中，但我还没有弄清楚

如果这是家庭作业，你的问题是：

（int j=i-1；j>=0；j--）的

{
if（二进制数[j]==0）{
k=j；
做{
ctr++；
k++；
}而（二进制数[k]==0）；
加总费用；
ctr=0；
}
}

请注意：

• 您可以在执行过程中更新

  k

  ，但不更新

  j

  ，因此无论正确的值是什么，都可以得到1（

  [1,2,3,4,5,1,2,3]

  而不是

  [5,3]

  ）
• 您根本不需要

  k

（int j=i-1；j>=0；j--）的

{
if（二进制数[j]==0）{
int ctr=0；
while（binaryNum[j]==0）{
ctr++；
j--；
}
加总费用；
}
}

这是

---

如果您不是为了家庭作业而这样做，并且您需要实际使用的性能，请使用中的Java内置逐位方法，该方法在具有这些方法的CPU上使用非常非常快的CPU指令：

导入java.util.array；
公共课Abc{
静态最终int[]间隙（int n）{
最终整数[]未修剪结果=新整数[15]；
int i=0；
//删除尾随的零和最后一位以到达第一个间隙。
n>>>=整数。跟踪零的数目（n）+1；
而（n！=0）{
final int gapSize=整数。跟踪零的数量（n）；
未修剪结果[i++]=昏睡；
n>>>=虚张声势+1；
}
最终整数[]结果=新整数[i]；
数组复制（未修剪的结果，0，结果，0，i）；
返回结果；
}
//驱动程序
公共静态void main（最终字符串[]args）{
最终整数n=1041；
System.out.println（Integer.toBinaryString（n））；
System.out.println（Arrays.toString（gaps（n））；
}
}

---

这是，尽管它以相反的顺序给出结果（这可以通过以相反的顺序填充

untrimmedResult

并适当调整

System.arraycopy

的参数来轻松修复）。

var k也应该减小，因为j减小，同样在迭代完成后，您应该分配j=k。当（k>=0&&binaryNum[k]=0）时，必须检查k是否大于或等于零

，否则将获得ArrayIndexOutOfBoundsException。此外，如果（k<0）{j=k；break；}

  for (int j = i - 1; j >= 0; j--) {
        System.out.print(binaryNum[j]);
        if (binaryNum[j] == 0) {
            k = j;
            do {
                ctr++;
                k--;
            } while (k >= 0 && binaryNum[k] == 0);
            if(k < 0) {
                j = k;
                break;
            }
            al.add(ctr);
            ctr = 0;
            j = k;
        }
    }

（int j=i-1；j>=0；j--）的

{
System.out.print（二进制数[j]）；
if（二进制数[j]==0）{
k=j；
做{
ctr++；
k--；
}而（k>=0&&binaryNum[k]==0）；
if（k<0）{
j=k；
打破
}
加总费用；
ctr=0；
j=k；
}
}

这个答案我得了满分100分。希望这对你有帮助

public int solution(int N) {
        String binary = Integer.toBinaryString(N);
        int count = 0;
        int tmpCount = 0;
        for (int i = 0; i < binary.length(); i++) {
            if (binary.charAt(i) == '0') {
                if (i > 0 && binary.charAt(i - 1) == '1') {
                    tmpCount++;
                } else {
                    if (tmpCount > 0) tmpCount++;
                }
            } else if (binary.charAt(i) == '1') {
                if (tmpCount > 0 && tmpCount > count) {
                    count = tmpCount;
                }
                tmpCount = 0;
            }
        }
        return count;
    }

public int解决方案（int N）{
字符串二进制=整数。toBinaryString（N）；
整数计数=0；
int-tmpCount=0；
对于（int i=0；i0&&binary.charAt（i-1）='1'）{
tmpCount++；
}否则{
如果（tmpCount>0）tmpCount++；
}
}else if（binary.charAt（i）='1'）{
如果（tmpCount>0&&tmpCount>count）{
计数=TMP计数；
}
tmpCount=0；
}
}
返回计数；
}

//100%处理所有测试用例

public static void main(String ar[]) {
        Integer val = 10092;
        String vals = val.toBinaryString(val);
        int gapVal = findBinaryGap(vals);
        System.out.println(vals);
        System.out.println("gapVal=" + gapVal);

    }

public static Integer findBinaryGap(String binVal) {
        Integer retVal = 0;
        String splitVal[] = binVal.split("1");
        int endVal = splitVal.length;
        if (binVal.endsWith("0")) {
            endVal = endVal - 1;
        }
        for (int incr = 0; incr < endVal; incr++) {
            if (retVal < splitVal[incr].length()) {
                retVal = splitVal[incr].length();
            }
        }
        return retVal;
    }

publicstaticvoidmain（字符串ar[]{
整数val=10092；
字符串val=val.toBinaryString（val）；
public int solution(int N) {
    String binaryNumber = Integer.toBinaryString(N);

    String[] gaps = binaryNumber.replaceAll("0+$", "").split("1");


    int maxLength = 0;
    for (String gap: gaps) {
        if (gap.length() > 0 && gap.length() > maxLength) {
            maxLength = gap.length();
        }
    }
    return maxLength;
}

public int solution(int N) {
        //get binary representation
        String binaryRep = Integer.toBinaryString(N);
        //cut last zeros since they aren't between "1"
        if (!binaryRep.endsWith("1")) {
            final int i = binaryRep.lastIndexOf("1");
            binaryRep = binaryRep.substring(0, i);
        }

        //count the longest zero string
        String[] binaryBlocks = binaryRep.split("1");
        int result = 0;
        for (String binaryBlock : binaryBlocks) {
            int binaryBlockLength = binaryBlock.length();
            if (binaryBlockLength > result) {
                result = binaryBlockLength;
            }
        }
        return result;
    }

class Solution {
        public int solution(int N) {
            String value = Integer.toBinaryString(N);
            int counter = 0;
            List<Integer> counters = new ArrayList<>();
            for (int i = 0; i < value.length(); i++) {
                char current = value.charAt(i);
                if (current == '0') {
                    counter += 1;
                } else {
                    counters.add(counter);
                    counter = 0;
                }
            }
            return Collections.max(counters);
        }
    }

public int solution(int N){
    try {
        return Collections.max(Arrays.asList(Integer.toBinaryString(N)
                .replaceAll("0+$", "").split("1"))
                .stream().mapToInt(String::length).boxed()
                .collect(Collectors.toList()));
    }catch (NoSuchElementException e){
        return 0;
    }
}

"0+$" - replacing all trailing zeros

class Solution {
    public int solution(int N) {
        String bin = intToBinary(N);
        int firstOne = bin.indexOf('1');
        int cnt = 0;
        
        for(int i=firstOne; i<bin.length(); ++i){
            int sec = bin.indexOf('1', i);
            cnt = Math.max(sec-firstOne-1, cnt);
            firstOne = sec;
        }
        return cnt;
        
    }
    
    private static String intToBinary(int N){
        String s = "";
        while(N>0){
            s = ( (N%2) == 0 ? "0" : "1") + s;
            N = N / 2;
        }
        return s;
    }
}

class Solution {
    public int solution(int N) {
        int gapSize = 0;
        int tempCount = 0;
        String s = Integer.toBinaryString(N);

/* You can start the loop from index 1, since all binary numbers
except 0 start with 1 and 0 is covered by initializing the variables (saves 2 conditions) */
        for(int i = 1; i < s.length(); i++) {
            if(s.charAt(i) == '0') {
                tempCount++; // count the number of 0
            } else if(s.charAt(i) == '1') {  // when 1 is found
                if(tempCount > gapSize) {    // and gap is smaller than the now measured one
                    gapSize = tempCount;     // record the so far biggest gap
                }
                tempCount = 0;               // reset the counter when 1 is found
            }
        }
        return gapSize;
     }
} 

fun solution(N: Int): Int {
        // write your code in Kotlin
        val binaryStr = toBinary(N)
        val charArray = binaryStr.toCharArray()


    var maxGap = 0
    var oneIndicesArray = arrayListOf<Int>() 
    charArray.forEachIndexed { index, element ->
        
        if(element == '1') {
            if(oneIndicesArray.isNotEmpty()) {
               val newGap =  (index - oneIndicesArray[oneIndicesArray.size - 1]) - 1
                if(newGap > maxGap) maxGap = newGap
            }
            oneIndicesArray.add(index)
        }
    }
    return maxGap
}

fun toBinary(decimalNumber: Int, binaryString: String = "") : String {
    while (decimalNumber > 0) {
        val temp = "${binaryString}${decimalNumber%2}"
        return toBinary(decimalNumber/2, temp)
    }
    return binaryString.reversed()
}

fun solution(N: Int): Int {
// write your code in Kotlin
var maxNumber= 0
val binary= Integer.toBinaryString(N)
val split= binary.split("1")
val loop= if(binary.endsWith("1")) split.size else split.size-1
for (s in 0 until loop){
    maxNumber=Integer.max(maxNumber, split[s].length)
}
return maxNumber