重要概念：补码

计算机中使用补码表示负数，简化了加减法运算：

• 正数的补码是其本身
• 负数的补码 = 原码取反 + 1
• 使用补码后，减法可以转换为加法运算

算法步骤

1. 将两个二进制字符串反转（从最低位开始处理）
2. 初始化进位为0和结果列表
3. 逐位相加并处理进位
4. 处理最高位的进位
5. 反转结果并返回

代码实现

def binary_add(a: str, b: str) -> str:
    # 反转字符串以便从最低位开始处理
    a = a[::-1]
    b = b[::-1]
    
    # 确保两个字符串长度相同，短的前面补0
    n = max(len(a), len(b))
    a = a.ljust(n, '0')
    b = b.ljust(n, '0')
    
    carry = 0  # 进位
    result = []  # 存储结果的列表
    
    # 逐位相加
    for i in range(n):
        # 当前位的两个数字
        bit_a = int(a[i])
        bit_b = int(b[i])
        
        # 计算当前位的和（包括进位）
        total = bit_a + bit_b + carry
        
        # 计算当前位的结果和进位
        current_bit = total % 2
        carry = total // 2
        
        result.append(str(current_bit))
    
    # 处理最高位的进位
    if carry:
        result.append(str(carry))
    
    # 反转结果并组合成字符串
    return ''.join(result[::-1])
            

加法示例分析

计算: 1101 + 1011

步骤分解：

1. 反转字符串：a = "1101" → "1011", b = "1011" → "1101"
2. 补齐长度：两者长度均为4
3. 逐位计算：
   • 第0位: 1 + 1 + 0 = 2 → 当前位0，进位1
   • 第1位: 0 + 1 + 1 = 2 → 当前位0，进位1
   • 第2位: 1 + 0 + 1 = 2 → 当前位0，进位1
   • 第3位: 1 + 1 + 1 = 3 → 当前位1，进位1
4. 处理最高进位：添加进位1
5. 反转结果：1000 → 0001 → 10000 (反转前为00001)

结果：1101 (13) + 1011 (11) = 11000 (24)

算法步骤

1. 确保被减数不小于减数（否则结果为负数）
2. 反转两个二进制字符串
3. 逐位相减并处理借位
4. 处理结果中的前导零
5. 返回结果（或负号+结果）

代码实现

def binary_subtract(a: str, b: str) -> str:
    # 判断a是否小于b
    if int(a, 2) < int(b, 2):
        # 交换并添加负号
        return '-' + binary_subtract(b, a)
    
    # 反转字符串以便从最低位开始处理
    a = a[::-1]
    b = b[::-1]
    
    # 确保两个字符串长度相同，短的前面补0
    n = max(len(a), len(b))
    a = a.ljust(n, '0')
    b = b.ljust(n, '0')
    
    borrow = 0  # 借位
    result = []  # 存储结果的列表
    
    # 逐位相减
    for i in range(n):
        bit_a = int(a[i])
        bit_b = int(b[i])
        
        # 考虑借位
        if borrow:
            bit_a -= 1
            borrow = 0
            
        # 如果被减数当前位小于减数当前位，需要借位
        if bit_a < bit_b:
            bit_a += 2  # 借位（相当于+2）
            borrow = 1  # 设置借位标志
            
        current_bit = bit_a - bit_b
        result.append(str(current_bit))
    
    # 反转结果并组合成字符串
    res_str = ''.join(result[::-1])
    
    # 去除前导零
    res_str = res_str.lstrip('0')
    
    # 处理结果为0的情况
    if not res_str:
        return '0'
        
    return res_str
            

减法示例分析

计算: 1101 - 1011

步骤分解：

1. 判断大小：1101(13) > 1011(11)，不需要交换
2. 反转字符串：a = "1101" → "1011", b = "1011" → "1101"
3. 逐位计算：
   • 第0位: 1-1=0
   • 第1位: 0-1 → 借位 → 10-1=1 (设置借位)
   • 第2位: 1-0 → 但之前有借位 → 0-0=0
   • 第3位: 1-1=0
4. 结果：0010 → 去除前导零 → 10

结果：1101 (13) - 1011 (11) = 10 (2)

完整代码实现

def binary_add(a: str, b: str) -> str:
    a = a[::-1]
    b = b[::-1]
    n = max(len(a), len(b))
    a = a.ljust(n, '0')
    b = b.ljust(n, '0')
    
    carry = 0
    result = []
    
    for i in range(n):
        bit_a = int(a[i])
        bit_b = int(b[i])
        total = bit_a + bit_b + carry
        current_bit = total % 2
        carry = total // 2
        result.append(str(current_bit))
    
    if carry:
        result.append(str(carry))
    
    return ''.join(result[::-1])

def binary_subtract(a: str, b: str) -> str:
    if int(a, 2) < int(b, 2):
        return '-' + binary_subtract(b, a)
    
    a = a[::-1]
    b = b[::-1]
    n = max(len(a), len(b))
    a = a.ljust(n, '0')
    b = b.ljust(n, '0')
    
    borrow = 0
    result = []
    
    for i in range(n):
        bit_a = int(a[i])
        bit_b = int(b[i])
        
        if borrow:
            bit_a -= 1
            borrow = 0
            
        if bit_a < bit_b:
            bit_a += 2
            borrow = 1
            
        current_bit = bit_a - bit_b
        result.append(str(current_bit))
    
    res_str = ''.join(result[::-1]).lstrip('0')
    return res_str if res_str else '0'

# 测试示例
if __name__ == "__main__":
    # 加法测试
    print("二进制加法测试:")
    print(f"101 + 110 = {binary_add('101', '110')}")  # 5 + 6 = 11 → 1011
    print(f"1111 + 1 = {binary_add('1111', '1')}")    # 15 + 1 = 16 → 10000
    print(f"1101 + 1011 = {binary_add('1101', '1011')}") # 13 + 11 = 24 → 11000
    
    # 减法测试
    print("\n二进制减法测试:")
    print(f"1101 - 1011 = {binary_subtract('1101', '1011')}") # 13 - 11 = 2 → 10
    print(f"1010 - 101 = {binary_subtract('1010', '101')}")   # 10 - 5 = 5 → 101
    print(f"100 - 101 = {binary_subtract('100', '101')}")      # 4 - 5 = -1 → -1
            

测试结果