Find the smallest binary number without continous 1

So here is the thing.
I have to write code to show a binary number X's next smallest "code-X number" which is bigger than binary number X.
code-X number is a binary number which have no continuously 1. For example: 1100 is not a code X number because it has 11, and 1001001001 is a code-X number
Here is my code

String a = "11001110101010";
    String b = "";
    int d = 0;
    for(int i = a.length()-1; i>0;i--){
        if(a.charAt(i) == '1' && a.charAt(i-1)=='1'){
        while(a.charAt(i)=='1'){
            b = b + '0';
            if(i!=0){i--;}
            d++;
        }
        }
        b = b + a.charAt(i);
    }
    StringBuffer c = new StringBuffer(b);
    System.out.println(c.reverse());

I plan on copy the binary string to string b, replace every '1' which next i is '1' into '0' and insert an '1'
like:
1100 ---> 10000
but i have no idea how to do it
May you help me some how? Thanks

Try this. This handles arbitrary length bit strings. The algorithm is as follows.

• Needed to conditionally modify last two bits to force a change if the number is not a codeEx number. This ensures it will be higher. Thanks to John Mitchell for this observation.
• Starting from the left, find the first group of 1's. e.g 0110
• If not at the beginning replace it with 100 to get 1000
• Otherwise, insert 1 at the beginning.
• In all cases, replace everything to the right of the grouping with 0's.

String x = "10000101000000000001000001000000001111000000000000110000000000011011";

System.out.println(x.length());
String result = codeX(x);

System.out.println(x);
System.out.println(result);


public static String codeX(String bitStr) {
	StringBuilder sb = new StringBuilder(bitStr);
	int i = 0;

   
    int len = sb.length();
	// Make adjust to ensure new number is larger than
	// original.  If the word ends in 00 or 10, then adding one will
	// increase the value in all cases.  If it ends in 01
	// then replacing with 10 will do the same.  Once done
	// the algorithm takes over to find the next CodeX number.
	if (s.equals("01")) {
		sb.replace(len - 2, len, "10");
	} else {
		sb.replace(len- 1, len, "1");
	}
	while ((i = sb.indexOf("11")) >= 0) {
		sb.replace(i, len, "0".repeat(len - i));
		if (i != 0) {
			sb.replace(i - 1, i + 2, "100");
		} else {
			sb.insert(i, "1");
		}
	}
	String str = sb.toString();
	i = str.indexOf("1");
	return i >= 0 ? str.substring(i) : str;
}

Prints

10000101000000000001000001000000001111000000000000110000000000011011
10000101000000000001000001000000010000000000000000000000000000000000



</details>



# 答案2
**得分**: 2

Using raw binary you can use the following.

```java
public static void main(String[] args) {
    long l = 0b1000010100000000010000010000000011110000000000110000000000011011L;
    System.out.println(
            Long.toBinaryString(nextX(l)));
}

public static long nextX(long l) {
    long l2 = l >>> 1;
    long next = Long.highestOneBit(l & l2);
    long cutoff = next << 1;
    long mask = ~(cutoff - 1);
    return (l & mask) | cutoff;
}

prints

1000010100000000010000010000000010000000000000000000000000000000

EDIT: Based on @WJS correct way to find the smallest value just larger.

public static void main(String[] args) {
    long l = 0b1000010100000000010000010000000011110000000000110000000000011011L;
    System.out.println(
            Long.toBinaryString(nextX(l)));
}

public static long nextX(long l) {
    long l2 = l >>> 1;
    long next = Long.highestOneBit(l & l2);
    long cutoff = next << 1;
    long mask = ~(cutoff - 1);
    return (l & mask) | cutoff;
}

1000010100000000010000010000000010000000000000000000000000000000

答案3

得分: 0

这是WJS的99%正确答案的一个小扩展。

只有一件事缺失，如果原始的X字符串中没有连续的1，数字不会递增。主方法的这个修改处理了这个问题。

编辑；添加了一个else{}。从字符串的末尾开始，直到找到一个0之前，所有数字都应该被反转。然后我们将其更改为1，并在将结果字符串传递给WJS的codeX函数之前中断。
（codeX版本不包括sb.replace(len-2,len，"11");）

public static void main(String[] args) {
    String x = "10100";
    StringBuilder sb = new StringBuilder(x);

    if (!x.contains("11")) {
        for (int i = sb.length()-1; i >= 0; i--) {
            if (sb.charAt(i) == '0') {
                sb.setCharAt(i, '1');
                break;
            } else {
                sb.setCharAt(i, '0');
            }
        }
    }

    String result = codeX(sb.toString());

    System.out.println(x);
    System.out.println(result);
}

public static void main(String[] args) {
    String x = "10100";
    StringBuilder sb = new StringBuilder(x);

    if (!x.contains("11")) {
        for (int i = sb.length()-1; i >= 0; i--) {
            if (sb.charAt(i) == '0') {
                sb.setCharAt(i, '1');
                break;
            } else {
                sb.setCharAt(i, '0');
            }
        }
    }

    String result = codeX(sb.toString());

    System.out.println(x);
    System.out.println(result);
}