addToArrayForm-数组形式的整数加法

题意

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

给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。

示例 1：

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

示例 2：

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

示例 3：

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

示例 4：

输入：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

提示：

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

解题思路

1.首先我们无法确定两个数的长度大小，但是根据题意来说k是个整数，且k的最大值不会超过10000，所以如果k的长度大于等于A数组，则意味着两个数相加不会大于INTEGET.MAX_VALUE
2.如果数组长度大于k则可能会大于最大整数
详细解题会在代码中一一呈现（注意看操作，以及细节处理）

代码演示：

class Solution {
    public  List<Integer> addToArrayForm(int[] A, int K) {
        int alen = A.length-1;
        List<Integer> res=new ArrayList<>();
        int flag=0;//标志位，如果两个对应位置相加超过个位数，则为1，代表进1.
        //这一重循环主要是比较k的长度和alen的长度大小，从低位到高位运算，将结果保存到res中
        while (K!=0&&alen!=-1)
        {
            if(K%10+A[alen]+flag<10)
            {
                res.add(K%10+A[alen]+flag);
                flag=0;
            }
            else {
                res.add((K%10+A[alen]+flag)%10);
                flag=1;
            }
            K=K/10;
            alen--;
        }
        //数组元素长度小于等于k的长度
        if (alen==-1)
        {
            //求出剩余整数k与flag的值
            //（k的细节处理-------------------------------------------------）
            K=K+flag;
            //新的k是0的情况，意思是所有数都耗光了
            if(K==0)
            {
                Collections.reverse(res);
                return res;
            }
            //k不是0，新k有剩余
            while (K!=0)
            {
                res.add(K%10);
                K=K/10;
            }
        }
        //数组元素还存在的情况，此时k应该为0，flag不知道有没有
        else {
            while (alen!=-1)
            {
                if(A[alen]+flag<10)
                {
                    res.add(A[alen]+flag);
                    alen--;
                    flag=0;
                    //（当flag可以舍弃时，直接break，跳到下面，注意细节
                   // -------------------------------------）
                    break;
                }else {
                    res.add((A[alen]+flag)%10);
                    flag=1;
                    alen--;
                }
            }
            while (alen!=-1)
            {
                res.add(A[alen]);
                alen--;
            }

            if(flag==1)
                res.add(flag);
        }
        Collections.reverse(res);
        return res;
    }
}

结果演示

info
解答成功:
执行耗时:4 ms,击败了86.63% 的Java用户
内存消耗:40.1 MB,击败了34.70% 的Java用户