力扣刷题记录#数组#简单#989数组形式的整数加法

题目描述

对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。
给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。

注意：

1. 1 <= A.length <= 10000
2. 0 <= A[i] <= 9
3. 0 <= K <= 10000
4. 如果 A.length > 1，那么 A[0] != 0

示例

输入：A = [1,2,0,0], K = 34
输出：[1,2,3,4]
解释：1200 + 34 = 1234

输入：A = [2,7,4], K = 181
输出：[4,5,5]
解释：274 + 181 = 455

输入：A = [2,1,5], K = 806
输出：[1,0,2,1]
解释：215 + 806 = 1021

输入：A = [9,9,9,9,9,9,9,9,9,9], K = 1
输出：[1,0,0,0,0,0,0,0,0,0,0]
解释：9999999999 + 1 = 10000000000

解答

进位有点类似于 加一 那道题。
首先把整数K转化为列表形式；然后比较两个数组的长度，短数组在高位补零，这样避免在相加时出现超出索引范围的问题；最后从最低位开始逐位相加。

从最低位开始逐位相加，分两种情况：

1. 该位相加和小于10，不需要进位；
2. 该位相加和大于10，需要进位，又有两种情况：
   （1）该位不是最高位，则进位的数直接加到前一位上即可；
   （2）该位是最高位，需要另外插入新的最高位（如[9,9] + 1的情况，原数组的两位变成[0,0]，在索引0处插入进位1，得到[1,0,0]）

class Solution(object):
    def addToArrayForm(self, A, K):
        """
        :type A: List[int]
        :type K: int
        :rtype: List[int]
        """
        
        if K==0:
            return A
        
        # 把整数K转化为列表形式
        k_list = list()
        while K!=0:
            k_list.insert(0,K%10)
            K = int(K/10)
            
        len_A = len(A)
        len_K = len(k_list)
        
        # 低位对齐，位数少的用0补齐
        if len_A>len_K:
            k_list = [0]*(len_A-len_K) + k_list
            length = len_A
        elif len_A<len_K:
            A = [0]*(len_K-len_A) + A
            length = len_K
        else:
            length = len_A
               
        # 从低位开始，按位相加
        n = length - 1
        while n>=0:
            # 相加后不进位
            if (A[n]+k_list[n])<10:
                A[n] = A[n]+k_list[n]
            # 相加后需要进位
            else:
                # 这一位不是最高位，则向前一位进1
                if n != 0:
                    A[n] = (A[n]+k_list[n])%10
                    A[n-1] += 1
                # 这一位是最高位，需要插入新的最高位
                else:
                    A[n] = (A[n]+k_list[n])%10
                    A.insert(0,1)
            
            n -= 1
                    
        return A