字节SRE面试算法题

两个大数相加。
1、是整数；
2、两个数无限大，long都装不下；
3、不能用BigInteger；
4、不能用任何包装类提供的运算方法；
5、两个数都是以字符串的方式提供。
例：
str1 = “123”,str2 = “456123”
输出：“456246”
解法一：通过对每个字符转换相加得到结果，单字符转换不会超过大整型，需要处理进位问题。

def s(str1: str, str2: str) -> str:  
    # 如果任一字符串为空，则返回另一个字符串  
    if str1 == '':  
        return str2  
    elif str2 == '':  
        return str1  
      
    # 获取两个字符串的长度  
    lenth1 = len(str1)  
    lenth2 = len(str2)  
      
    # 初始化一个空列表来存储结果字符  
    lst1 = []  
      
    # 初始化进位  
    increase = 0  
      
    # 确定哪个字符串更短，哪个更长，以及它们的长度  
    if lenth1 < lenth2:  
        less = str1  # 较短的字符串  
        more = str2  # 较长的字符串  
        more_lenth = lenth2  # 较长字符串的长度  
        lenth = lenth1  # 用于遍历较短字符串的长度  
    else:  
        less = str2  
        more = str1  
        more_lenth = lenth1  
        lenth = lenth2  
      
    # 将较长字符串的每个字符添加到结果列表中  
    for i in more:  
        lst1.append(i)  
      
    for i in less[lenth-1::-1]:  
        # 获取结果列表的最后一个字符（实际上是较长字符串的当前对应字符）  
        # 和较短字符串的当前字符，将它们转换为整数并相加，再加上进位  
        num = int(lst1[more_lenth-1]) + int(i) + increase  
          
        # 计算当前位的值（取模10）  
        num %= 10  
          
        # 更新结果列表的最后一个字符  
        lst1[more_lenth-1] = str(num)  # 这里需要转换为字符串，因为lst1是字符列表  
          
        # 更新进位  
        increase = num // 10  
          
        # 减少较长字符串的对应索引，以便在下一次迭代中处理下一个字符  
        more_lenth -= 1  
  
    result = ''.join(lst1)  # 将字符列表转换为字符串  
      
    # 如果在最长字符串处理完毕后还有进位，需要将其添加到结果字符串的开头  
    # 但由于我们的列表是从较长字符串开始的，并且我们是在逆序处理较短字符串，  
    # 所以如果最后有进位，它已经在lst1的第一个位置了（因为我们是从后往前填充的）  
    # 因此，我们不需要额外的步骤来处理这个进位，它已经被正确地包含在了result中  
      
    # 返回最终的结果字符串  
    return result  
  
# 测试代码  
str1 = "123"  
str2 = "123456"  
x = s(str1, str2)  
print(x)  # 输出应该是 "123579"
print(type(x))  # 输出应该是 <class 'str'>

解法二：通过字符asscll码加减，需要处理进位问题

def add(str1, str2):  
    # 任何一个字符串为None或空字符串，都不需要相加了  
    if str1 is None or str1 == "":  
        return str2  
    if str2 is None or str2 == "":  
        return str1  
      
    max_length = max(len(str1), len(str2))  
    # 定义一个存贮结果的字符串，长度要比最大长度字符串还长一位，用于存储可能出现的进位  
    result = []  
      
    # 翻转两个字符串  
    str1 = str1[::-1]  
    str2 = str2[::-1]  
      
    # 反转后的结果分别为：  
    # 954321  
    # 321  
    min_length = min(len(str1), len(str2))  
    # 进位  
    carry = 0  
    # 当前位上的数值  
    current_num = 0  
    # 循环变量  
    i = 0  
      
    for i in range(min_length):  
        # 分别获取两个字符对应的字面数值，然后相加，再加上进位  
        current_num = int(str1[i]) + int(str2[i]) + carry  
        # 获取进位  
        carry = current_num // 10  
        # 处理当前位的最终值  
        current_num = current_num % 10  
        # 保存当前位的值到最终的列表中  
        result.append(str(current_num))  
      
    if len(str1) < len(str2):  
        # 选择较长的字符串继续处理  
        str1 = str2  
      
    for i in range(min_length, len(str1)):  
        # 分别获取字符对应的字面数值，然后相加，再加上进位  
        current_num = int(str1[i]) + carry  
        # 获取进位  
        carry = current_num // 10  
        # 处理当前位的最终值  
        current_num = current_num % 10  
        # 保存当前位的值到最终的列表中  
        result.append(str(current_num))  
      
    # 处理最后一个的进位(当循环结束后，是不是还可能会有一个进位)  
    if carry > 0:  
        result.append(str(carry))  
      
    # 最后翻转恢复字符串，再返回  
    return ''.join(result[::-1])  
  
# 测试代码  
str1 = "123459"  
str2 = "123"  
print(add(str1, str2))  # 输出: 123582