Question

我的问题陈述：

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

我的代码：

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);
    }
}

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

我认为在do-while循环中存在一个问题，尤其是在al.add(ctr)中，但我还没有弄清楚。

Answer 1

var k也应减小，因为j减小，因此在迭代完成后，还应分配j = k。并且您必须检查k是否大于或等于零while (k >= 0 && binaryNum[k] == 0);，否则会得到ArrayIndexOutOfBoundsException。另外，您还必须检查k是否小于零，以正确计算二进制间隙if(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;
        }
    }

Answer 2

这个答案我满分为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;
    }

Answer 3

//在所有测试用例中都能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;
    }

Answer 4

下面的解决方案给了我100％：

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);
        }
    }

Answer 5

如果这是家庭作业，那么您的问题就在这里：

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

请注意：

您在进行更新时会更新k，但不会更新j，因此无论正确的值是多少，您都会得到1（[1, 2, 3, 4, 5, 1, 2, 3]而不是[5, 3] ）。
您根本不需要k。

    for (int j = i - 1; j >= 0; j--) {
        if (binaryNum[j] == 0) {
            int ctr = 0;
            while (binaryNum[j] == 0) {
                ctr++;
                j--;
            }
            al.add(ctr);
        }
    }

这是shown to work here。

如果您不是要做家庭作业，并且需要在实际环境中使用性能，请在the Integer class中使用Java的内置按位方法，该方法在具有以下功能的CPU上使用非常非常快的CPU指令：他们：

import java.util.Arrays;

public class Abc {
    static final int[] gaps(int n) {
        final int[] untrimmedResult = new int[15];
        int i = 0;

        // Remove trailing zeroes and last one bit to get to first gap.
        n >>>= Integer.numberOfTrailingZeros(n) + 1;
        while (n != 0) {
            final int gapSize = Integer.numberOfTrailingZeros(n);
            untrimmedResult[i++] = gapSize;
            n >>>= gapSize + 1;
        }

        final int[] result = new int[i];
        System.arraycopy(untrimmedResult, 0, result, 0, i);
        return result;
    }

    // driver program 
    public static void main(final String[] args) {
        final int n = 1041;
        System.out.println(Integer.toBinaryString(n));
        System.out.println(Arrays.toString(gaps(n)));
    }
}

这是shown to work here，尽管它以相反的顺序给出结果（可以通过以相反的顺序填充untrimmedResult并适当地调整System.arraycopy的参数来轻松地固定它。）

Answer 6

尝试以下代码，

public int solution(int n) {
    String binaryString = Integer.toBinaryString(n);
    int count = 0, bigGap = 0, temptCount = 0;
    for (int i = 0; i < binaryString.length(); i++) {
        char c = binaryString.charAt(i);
        if (c == '0') {
            temptCount++;
        } else {
            count = temptCount;

            if (count > bigGap) {
                bigGap = count;
            }
            temptCount = 0;
        }

    }

    return bigGap;
}

Answer 7

尝试一下，我得到100％

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;
}

Answer 8

关于codility，我对BinaryGap“问题”的解决方案是

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;
    }

希望有帮助！：）

Answer 9

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

Answer 10

此解决方案给了我100％的分数，我使用indexOf获得了第一个索引1，然后获得了第一个第二索引1并计算它们之间的差，这给了我一个0的子字符串，保存了它的长度子串，然后像以前一样计算第二个0子串，因此，每次计算子串时，请确保选择最长的一个。

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;
    }
}

Answer 11

这是最容易理解的IMO

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;
     }
}

Answer 12

顺便说一句，这是KOTLIN中的相应解决方案，如果有人感兴趣。

<块引用>

我首先将数字转换为二进制字符串，然后将二进制字符串转换为字符数组，然后循环遍历 forEachIndexed 循环并尝试找到 1 的索引并将它们保存在 oneIndicesArrayList 并检查 newGap ，如果 newGap 是大于 maxGap ，否则我将 newGap 值分配给 maxGap maxGap 将保留旧值。这工作完美，得分是 100%。

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()
}

Answer 13

我得到了 100% 的分数

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

}

Java中的Binary Gap程序

13 个答案: