逐位二进制拼接 → 翻转 → 去头零 → 消邻重

题目描述

给你一个非负整数 nn，按照下面的步骤操作，输出最终的二进制字符串。

操作步骤

1. 逐位转二进制（最少位数）

   把 nn 的每一位十进制数字分别转成二进制，并且 去掉前导 0 。

   特殊地，数字 0 转成字符串 "0"。

   示例：

   • 数字 5 → "101"

   • 数字 0 → "0"

   • 数字 9 → "1001"

2. 拼接二进制串

   按原数字从左到右的顺序，把上一步的结果拼接成一个长二进制串 SS。

   示例：数字 1 3 4 → "1" + "11" + "100" = "111100"

3. 整体反转

   将 SS 反转，得到 S′S′。

   示例："111100" → "001111"

4. 删除前导零

   删除 S′S′ 最前面的所有连续 '0'，得到 S′′S′′。

   如果 S′S′ 全是零，则 S′′S′′ 为空串。

   示例："001111" → "1111"

5. 相邻去重（非连续保留一个）

   从左到右扫描 S′′S′′，如果当前字符和前一个字符相同，就删掉当前字符，否则保留。

   示例：

   • "1111" → "1"

   • "110011" → "101"

6. 输出结果

Java

import java.util.*;

class Solution {
    private String numToBinary (int digit) {
        if (digit == 0) {
            return "0";
        }
        StringBuilder binary = new StringBuilder();
        int num = digit;
        
        while (num > 0) {
            binary.insert(0, num % 2);
            num /= 2;
        }
        
        return binary.toString();
    }
    
    public String processNum (int num) {
        if (num == 0) {
            return "";
        }
        
        // 最少位二进制数表示
        String numStr = String.valueOf(num);
        StringBuilder binaryA = new StringBuilder();
        for (int i=0; i<numStr.length(); i++) {
            int digit = numStr.charAt(i) - '0';
            binaryA.append(numToBinary(digit));
        }
        
        // 翻转字符串并去除头部0
        String reversedA = binaryA.reverse().toString();
        int startindex = 0;
        while (startindex < reversedA.length() && reversedA.charAt(startindex) == '0') {
            startindex ++;
        }
        if (startindex == reversedA.length()) {
            return "";
        }
        String binaryB = reversedA.substring(startindex);
        
        // 去除相邻重复
        StringBuilder result = new StringBuilder();
        result.append(binaryB.charAt(0));
        
        for (int i=1; i<binaryB.length(); i++) {
            if (binaryB.charAt(i) != binaryB.charAt(i-1)) {
                result.append(binaryB.charAt(i));
            }
        }
        
        return result.toString();
    }
}


public class Main {
	public static void main(String[] args) {
	    Solution solu = new Solution();
	    
		int[] nums = {34,156,981};
		
		for (int num : nums) {
		    System.out.println(num + " -> " + solu.processNum(num));
		}
	}
}

Python

def process_number(n: int) -> str:
    if n == 0:
        return ""
    
    # 步骤1: 将每一位十进制数字转换为最少位数的二进制表示
    num_str = str(n)
    binary_parts = []
    
    for ch in num_str:
        digit = int(ch)
        if digit == 0:
            binary_parts.append("0")
        else:
            # 转换为二进制并去掉前缀'0b'
            binary_parts.append(bin(digit)[2:])
    
    # 步骤2: 拼接所有二进制串
    concatenated = "".join(binary_parts)
    
    # 步骤3: 反转整个字符串
    reversed_str = concatenated[::-1]
    
    # 步骤4: 去除前导零
    # lstrip('0') 会删除字符串开头的所有'0'
    without_leading_zeros = reversed_str.lstrip('0')
    
    # 如果全部是0，lstrip后会是空字符串
    if not without_leading_zeros:
        return ""
    
    # 步骤5: 去除相邻重复的数字
    result = []
    result.append(without_leading_zeros[0])
    
    for i in range(1, len(without_leading_zeros)):
        if without_leading_zeros[i] != without_leading_zeros[i - 1]:
            result.append(without_leading_zeros[i])
    
    return "".join(result)